home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 113 / EnigmaAmiga113CD.iso / software / sviluppo / quakeworld_src / client / d_scan68k.s < prev    next >
Encoding:
Text File  |  2000-06-17  |  65.4 KB  |  2,097 lines
  1. * 
  2. * Copyright (C) 1996-1997 Id Software, Inc. 
  3. * 
  4. * This program is free software; you can redistribute it and/or 
  5. * modify it under the terms of the GNU General Public License 
  6. * as published by the Free Software Foundation; either version 2 
  7. * of the License, or (at your option) any later version. 
  8. * 
  9. * This program is distributed in the hope that it will be useful, 
  10. * but WITHOUT ANY WARRANTY; without even the implied warranty of 
  11. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.   
  12. * 
  13. * See the GNU General Public License for more details. 
  14. * 
  15. * You should have received a copy of the GNU General Public License 
  16. * along with this program; if not, write to the Free Software 
  17. * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA. 
  18. * 
  19.  
  20. **
  21. ** Quake for AMIGA
  22. ** d_scan.c assembler implementations by Frank Wille <frank@phoenix.owl.de>
  23. **
  24.  
  25.         XREF    _cacheblock
  26.         XREF    _d_sdivzorigin
  27.         XREF    _d_sdivzstepu
  28.         XREF    _d_sdivzstepv
  29.         XREF    _d_tdivzorigin
  30.         XREF    _d_tdivzstepu
  31.         XREF    _d_tdivzstepv
  32.         XREF    _d_ziorigin
  33.         XREF    _d_zistepu
  34.         XREF    _d_zistepv
  35.         XREF    _sadjust
  36.         XREF    _tadjust
  37.         XREF    _sdivz
  38.         XREF    _tdivz
  39.         XREF    _bbextents
  40.         XREF    _bbextentt
  41.         XREF    _d_viewbuffer
  42.         XREF    _screenwidth
  43.         XREF    _cachewidth
  44.         XREF    _d_zwidth
  45.         XREF    _d_pzbuffer
  46.         XREF    _sintable
  47.         XREF    _cl
  48.         XREF    _intsintable
  49.         XREF    _vid
  50.         XREF    _scr_vrect
  51.         XREF    _r_refdef
  52.         XREF    _d_subdiv16
  53.  
  54.         XDEF    _D_WarpScreen
  55.         XDEF    _Turbulent8
  56.         XDEF    _D_DrawSpans8
  57.         XDEF    _D_DrawZSpans
  58.  
  59. QDIV                    =       1
  60. NICE_DIV                =       1
  61.  
  62. PSPAN_NEXT              =       12
  63. CL_TIME                 =       434228
  64. VID_BUFFER              =       0
  65. VID_ROWBYTES            =       16
  66. SCR_VRECT_X             =       0
  67. SCR_VRECT_Y             =       4
  68. SCR_VRECT_WIDTH         =       8
  69. SCR_VRECT_HEIGHT        =       12
  70. REFDEF_VRECT_X          =       0
  71. REFDEF_VRECT_Y          =       4
  72. REFDEF_VRECT_WIDTH      =       8
  73. REFDEF_VRECT_HEIGHT     =       12
  74. CVAR_VALUE              =       16
  75.  
  76. CYCLE                   =       128             ;MUST match the #define in d_iface.h!
  77. AMP2                    =       3               ;--
  78. SPEED                   =       20              ;--
  79.  
  80.  
  81. ******************************************************************************
  82. *
  83. *       void _D_WarpScreen (void)
  84. *
  85. *       water effect algorithm
  86. *
  87. ******************************************************************************
  88.  
  89.         cnop    0,4
  90. _D_WarpScreen
  91.  
  92.         rsreset
  93. .rowptr         rs.l    1024
  94. .column         rs.l    1280
  95. .stackframe     rs.l    0
  96.  
  97.         movem.l d2-d7/a2-a6,-(sp)
  98.         fmovem.x        fp2/fp3,-(sp)
  99.         sub.l   #.stackframe,sp
  100.         move.l  sp,a2
  101.         lea     .column(sp),a1
  102.         lea     _vid,a3
  103.         lea     _r_refdef,a4
  104.         lea     _scr_vrect,a5
  105.         move.l  _screenwidth,d4
  106.         move.l  SCR_VRECT_WIDTH(a5),d6
  107.         move.l  SCR_VRECT_HEIGHT(a5),d7
  108.         move.l  REFDEF_VRECT_X(a4),d2
  109.         move.l  REFDEF_VRECT_Y(a4),d3
  110.         fmove.l REFDEF_VRECT_WIDTH(a4),fp0
  111.         fmove.l REFDEF_VRECT_HEIGHT(a4),fp1
  112.  
  113. *        w = r_refdef.vrect.width;
  114. *        h = r_refdef.vrect.height;
  115. *
  116. *        wratio = w / (float)scr_vrect.width;
  117. *        hratio = h / (float)scr_vrect.height;
  118.  
  119.         fmove.s #AMP2*2,fp2
  120.         fmove   fp2,fp3
  121.         fadd    fp0,fp2                 ;fp2 = w + AMP2*2
  122.         fadd    fp1,fp3                 ;fp3 = h + AMP2*2
  123.         fmul.l  d6,fp2                  ;* (float)scr_vrect.width
  124.         fmul.l  d7,fp3                  ;* (float)scr_vrect.height
  125.         fmul    fp0,fp0                 ;w*w
  126.         fmul    fp1,fp1                 ;h*h
  127.         fdiv    fp2,fp0                 ;fp0=wratio*w/(w+AMP2*2)
  128.         fdiv    fp3,fp1                 ;fp1=hratio*h/(h+AMP2*2)
  129.         move.l  VID_ROWBYTES(a3),d5
  130.         mulu    d4,d3                   ;d3=r_refdef.vrect.y*screenwidth
  131.         add.l   _d_viewbuffer,d3        ;d3=d_viewbuffer+d3
  132.         add.l   #AMP2*2,d6
  133.         add.l   #AMP2*2,d7
  134.  
  135. *        for (v=0 ; v<scr_vrect.height+AMP2*2 ; v++)
  136. *        {
  137. *                rowptr[v] = d_viewbuffer + (r_refdef.vrect.y * screenwidth) +
  138. *                                 (screenwidth * (int)((float)v * hratio * h / (h + AMP2 * 2)));
  139. *        }
  140.  
  141.  
  142.         moveq   #0,d0                   ;v = 0
  143.         move.l  a2,a6                   ;a6 -> rowptr[0]
  144. .loop
  145.         fmove.l d0,fp3                  ;fp3 = (float)v
  146.         fmul    fp1,fp3                 ;(float)v*hratio*h/(h+AMP2*2)
  147.         fmove.l fp3,d1                  ;d1 = (int)fp3
  148.         muls    d4,d1                   ;d1 = d1 * screenwidth
  149.         add.l   d3,d1                   ;d1 = d_viewbuffer+(r_...*scr...)+d1
  150.         addq.l  #1,d0                   ;v++
  151.         move.l  d1,(a6)+                ;rowptr[v] = d1
  152.         cmp.l   d7,d0
  153.         blt.b   .loop
  154.  
  155. *        for (u=0 ; u<scr_vrect.width+AMP2*2 ; u++)
  156. *        {
  157. *                column[u] = r_refdef.vrect.x +
  158. *                                (int)((float)u * wratio * w / (w + AMP2 * 2));
  159. *        }
  160.  
  161.         moveq   #0,d0                   ;u = 0
  162.         move.l  a1,a6                   ;a6 -> column[0]
  163. .loop2
  164.         fmove.l d0,fp2                  ;fp2 = (float)u
  165.         fmul    fp0,fp2                 ;(float)u * wratio*w/(w+AMP2*2)
  166.         fmove.l fp2,d1                  ;d1 = (int)fp2
  167.         add.l   d2,d1                   ;d1 = r_refdef.vrect.x + d1
  168.         addq.l  #1,d0                   ;u++
  169.         move.l  d1,(a6)+                ;column[u] = d1
  170.         cmp.l   d6,d0
  171.         blt.b   .loop2
  172.  
  173. ******  d5 = vid.rowbytes
  174. ******  a1 -> column
  175. ******  a2 -> rowptr
  176.  
  177. *        turb = intsintable + ((int)(cl.time*SPEED)&(CYCLE-1));
  178. *        dest = vid.buffer + scr_vrect.y * vid.rowbytes + scr_vrect.x;
  179. *        for (v=0 ; v<scr_vrect.height ; v++, dest += vid.rowbytes)
  180. *        {
  181. *                col = &column[turb[v]];
  182. *                row = &rowptr[v];
  183. *                for (u=0 ; u<scr_vrect.width ; u+=4)
  184. *                {
  185. *                        dest[u+0] = row[turb[u+0]][col[u+0]];
  186. *                        dest[u+1] = row[turb[u+1]][col[u+1]];
  187. *                        dest[u+2] = row[turb[u+2]][col[u+2]];
  188. *                        dest[u+3] = row[turb[u+3]][col[u+3]];
  189. *                }
  190. *        }
  191.         move.l  SCR_VRECT_WIDTH(a5),d6
  192.         lsr     #2,d6
  193.         subq    #1,d6
  194.         move.l  SCR_VRECT_HEIGHT(a5),d7
  195.  
  196.         fmove.d _cl+CL_TIME,fp0         ;get cl.time
  197.         fmul.s  #SPEED,fp0              ;fp0 = cl.time*SPEED
  198.         fmove.l fp0,d4                  ;(int)(cl.time*SPEED)
  199.         and.l   #CYCLE-1,d4             ;(int)(cl.time*SPEED)&(CYCLE-1)
  200.         lsl.l   #2,d4
  201.         add.l   #_intsintable,d4        ;turb = _intsintable + 4*d0
  202.  
  203.         move.l  SCR_VRECT_Y(a5),d3
  204.         mulu    d5,d3                   ;vid.rowbytes * scr_vrect.y
  205.         add.l   SCR_VRECT_X(a5),d3      ;d3 + scr_vrect.x
  206.         add.l   VID_BUFFER(a3),d3       ;dest = vid.buffer + d3
  207.  
  208.         moveq   #0,d1
  209. .loop3
  210.         move    d6,d0
  211.         move.l  d4,a6                   ;a6 -> turb[u]
  212.         move.l  0(a6,d1.l*4),d2         ;d2 = turb[v]
  213.         move.l  d3,a0                   ;a0 -> dest[u]
  214.         lea     0(a1,d2.l*4),a4         ;col = &column[turb[v]]
  215.         lea     0(a2,d1.l*4),a5         ;row = &rowptr[v]
  216. .loop4
  217.         move.l  (a6)+,d2                ;d2 = turb[u+0]
  218.         move.l  0(a5,d2.l*4),a3         ;a3 = row[turb[u+0]]
  219.         move.l  (a4)+,d2                ;d2 = col[u+0]
  220.         move.b  0(a3,d2.l),(a0)+        ;dest[u+0]=row[turb[u+0][col[u+0]]
  221.         move.l  (a6)+,d2                ;same for u=1,2,3
  222.         move.l  0(a5,d2.l*4),a3
  223.         move.l  (a4)+,d2
  224.         move.b  0(a3,d2.l),(a0)+
  225.         move.l  (a6)+,d2
  226.         move.l  0(a5,d2.l*4),a3
  227.         move.l  (a4)+,d2
  228.         move.b  0(a3,d2.l),(a0)+
  229.         move.l  (a6)+,d2
  230.         move.l  0(a5,d2.l*4),a3
  231.         move.l  (a4)+,d2
  232.         move.b  0(a3,d2.l),(a0)+
  233.         dbra    d0,.loop4
  234.         add.l   d5,d3
  235.         addq    #1,d1
  236.         cmp     d7,d1
  237.         blt.b   .loop3
  238.         add.l   #.stackframe,sp
  239.         fmovem.x        (sp)+,fp2/fp3
  240.         movem.l (sp)+,d2-d7/a2-a6
  241.         rts
  242.  
  243.  
  244. ******************************************************************************
  245. *
  246. *       void Turbulent8 (espan_t *pspan)
  247. *
  248. *       standard scan drawing function for animated textures
  249. *       Note: The function D_DrawTurbulent8Span was inlined into this
  250. *       function, because it's never used anywhere else.
  251. *
  252. ******************************************************************************
  253.  
  254.         cnop    0,4
  255. _Turbulent8
  256.  
  257. *****   stackframe
  258.  
  259.         rsreset
  260. .saved4         rs.l    1
  261. .saved5         rs.l    1
  262. .savea1         rs.l    1
  263. .szstpu         rs.s    1
  264. .szstpv         rs.s    1
  265. .szorg          rs.s    1
  266. .tzstpu         rs.s    1
  267. .tzstpv         rs.s    1
  268. .tzorg          rs.s    1
  269. .zistpu         rs.s    1
  270. .zistpv         rs.s    1
  271. .ziorg          rs.s    1
  272. .fpuregs        rs.x    6
  273. .intregs        rs.l    11
  274.         rs.l    1
  275. .pspan          rs.l    1
  276.  
  277.  
  278. ******  Prologue. Global variables are put into registers or onto the stackframe
  279.  
  280.         movem.l d2-d7/a2-a6,-(sp)
  281.         fmovem.x        fp2-fp7,-(sp)
  282.         move.l  _bbextentt,a2
  283.         move.l  _tadjust,a3
  284.         move.l  _bbextents,a4
  285.         move.l  _sadjust,a5
  286.         move.l  _d_ziorigin,-(sp)
  287.         move.l  _d_zistepv,-(sp)
  288.         move.l  _d_zistepu,-(sp)
  289.         move.l  _d_tdivzorigin,-(sp)
  290.         move.l  _d_tdivzstepv,-(sp)
  291.         move.l  _d_tdivzstepu,-(sp)
  292.         move.l  _d_sdivzorigin,-(sp)
  293.         move.l  _d_sdivzstepv,-(sp)
  294.         move.l  _d_sdivzstepu,-(sp)
  295.         sub.l   #.szstpu,sp
  296.  
  297. ******  First loop. In every iteration one complete span is drawn
  298.  
  299. *        r_turb_turb = sintable + ((int)(cl.time*SPEED)&(CYCLE-1));
  300. *
  301. *        r_turb_pbase = (unsigned char *)cacheblock;
  302. *
  303. *        sdivz16stepu = d_sdivzstepu * 16;
  304. *        tdivz16stepu = d_tdivzstepu * 16;
  305. *        zi16stepu = d_zistepu * 16;
  306. *
  307. *        do
  308. *        {
  309. *                r_turb_pdest = (unsigned char *)((byte *)d_viewbuffer +
  310. *                                (screenwidth * pspan->v) + pspan->u);
  311. *
  312. *                count = pspan->count;
  313. *
  314. *        // calculate the initial s/z, t/z, 1/z, s, and t and clamp
  315. *                du = (float)pspan->u;
  316. *                dv = (float)pspan->v;
  317. *
  318. *                sdivz = d_sdivzorigin + dv*d_sdivzstepv + du*d_sdivzstepu;
  319. *                tdivz = d_tdivzorigin + dv*d_tdivzstepv + du*d_tdivzstepu;
  320. *                zi = d_ziorigin + dv*d_zistepv + du*d_zistepu;
  321. *                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
  322. *
  323.  
  324.         fmove.d _cl+CL_TIME,fp0         ;get cl.time
  325.         fmul.s  #SPEED,fp0              ;fp0 = cl.time*SPEED
  326.         fmove.l fp0,d0                  ;(int)(cl.time*SPEED)
  327.         and.l   #CYCLE-1,d0             ;(int)(cl.time*SPEED)&(CYCLE-1)
  328.         lsl.l   #2,d0
  329.         add.l   #_sintable,d0           ;r_turb_turb = _sintable + 4*d0
  330.         move.l  d0,a6
  331.         fmove.s #16,fp7
  332.         fmove.s .szstpu(sp),fp3
  333.         fmul    fp7,fp3                 ;sdivz16stepu = d_sdivzstepu * 16
  334.         fmove.s .tzstpu(sp),fp4
  335.         fmul    fp7,fp4                 ;tdivz16stepu = d_tdivzstepu * 16
  336.         fmove.s .zistpu(sp),fp5
  337.         fmul    fp7,fp5                 ;zi16stepu = d_zistepu * 16
  338.         move.l  .pspan(sp),a1           ;get function parameter
  339. .loop
  340.         move.l  a1,.savea1(sp)          ;save actual ptr to pspan
  341.         move.l  _d_viewbuffer,a0
  342.         move.l  _screenwidth,d0
  343.         move.l  (a1)+,d1
  344.         fmove.l d1,fp2                  ;du = (float)pspan->u
  345.         move.l  (a1)+,d2
  346.         fmove.l d2,fp7                  ;dv = (float)pspan->v
  347.         move.l  (a1)+,d4
  348.         muls    d2,d0                   ;d0 = screenwidth * pspan->v
  349.         add.l   d1,d0
  350.         add.l   d0,a0                   ;pdest = d_viewbuffer + pspan->u + d0
  351.         lea     .szstpu(sp),a1          ;a1 -> stackframe
  352.         fmove.s (a1)+,fp0
  353.         fmul    fp2,fp0                 ;fp0 = du * d_sdivzstepu
  354.         fmove.s (a1)+,fp1
  355.         fmul    fp7,fp1                 ;fp1 = dv * d_sdivzstepv
  356.         fadd    fp1,fp0
  357.         fadd.s  (a1)+,fp0               ;sdivz = d_sdivzorigin + fp0 + fp1
  358.         fmove.s (a1)+,fp1
  359.         fmul    fp2,fp1                 ;fp1 = du * d_tdivzstepu
  360.         fmove.s (a1)+,fp6
  361.         fmul    fp7,fp6                 ;fp6 = dv * d_tdivzstepv
  362.         fadd    fp6,fp1
  363.         fadd.s  (a1)+,fp1               ;tdivz = d_tdivzorigin + fp1 + fp6
  364.         fmul.s  (a1)+,fp2               ;fp2 = du * d_zistepu
  365.         fmul.s  (a1)+,fp7               ;fp7 = dv * d_zistepv
  366.         fadd    fp7,fp2
  367.         fadd.s  (a1)+,fp2               ;zi = d_ziorigin + fp2 + fp7
  368.         fmove.s #65536,fp6
  369.         fdiv    fp2,fp6                 ;z = (float)0x10000 / zi
  370.  
  371. *                s = (int)(sdivz * z) + sadjust;
  372. *                if (s > bbextents)
  373. *                        s = bbextents;
  374. *                else if (s < 0)
  375. *                        s = 0;
  376. *
  377. *                t = (int)(tdivz * z) + tadjust;
  378. *                if (t > bbextentt)
  379. *                        t = bbextentt;
  380. *                else if (t < 0)
  381. *                        t = 0;
  382.  
  383.  
  384.         fmove   fp6,fp7
  385.         fmul    fp0,fp7                 ;fp7 = sdivz * z
  386.         fmove.l fp7,d6                  ;convert to integer
  387.         add.l   a5,d6                   ;s = d6 + sadjust
  388.         cmp.l   a4,d6                   ;if (s > bbextents)
  389.         bgt.b   .down
  390.         tst.l   d6                      ;if (s < 0)
  391.         bge.b   .keep
  392. .up
  393.         moveq   #0,d6                   ;s = 0
  394.         bra.b   .keep
  395. .down
  396.         move.l  a4,d6                   ;s = bbextents
  397. .keep
  398.         fmul    fp1,fp6                 ;fp6 = tdivz * z
  399.         fmove.l fp6,d7                  ;convert to integer
  400.         add.l   a3,d7                   ;t = d7 + tadjust
  401.         cmp.l   a2,d7                   ;if (t > bbextentt)
  402.         bgt.b   .down2
  403.         tst.l   d7                      ;if (t < 0)
  404.         bge.b   .keep2
  405. .up2
  406.         moveq   #0,d7                   ;t = 0
  407.         bra.b   .keep2
  408. .down2
  409.         move.l  a2,d7                   ;t = bbextentt
  410. .keep2
  411.         move.l  d4,d1
  412.  
  413.  
  414. ******  Second loop. In every iteration one part of the whole span is drawn
  415. ******  d2 gets the value (spancount-1)! [NOT spancount]
  416.  
  417. ******  d1 = count
  418.  
  419. *                do
  420. *                {
  421. *                // calculate s and t at the far end of the span
  422. *                        if (count >= 16)
  423. *                                spancount = 16;
  424. *                        else
  425. *                                spancount = count;
  426. *
  427. *                        count -= spancount;
  428. *
  429. *                        if (count)
  430. *                        {
  431.  
  432. .loop2
  433.         moveq   #16-1,d2                ;spancount = 16
  434.         cmp.l   #16,d1                  ;if (count >= 16)
  435.         bgt.b   .cont
  436.         move.l  d1,d2                   ;spancount = count
  437.         subq.l  #1,d2
  438.         moveq   #0,d1                   ;count -= spancount
  439.         bra.w   .finalpart
  440. .cont
  441.         sub.l   #16,d1                  ;count -= spancount;
  442.  
  443.  
  444. ******  Evaluation of the values for the inner loop. This version is used for
  445. ******  span size = 16
  446.  
  447. ******  a2  : bbextentt
  448. ******  a3  : tadjust
  449. ******  a4  : bbextents
  450. ******  a5  : sadjust
  451. ******  fp0 : sdivz
  452. ******  fp1 : tdivz
  453. ******  fp2 : zi
  454. ******  fp3 : sdivz16stepu
  455. ******  fp4 : tdivz16stepu
  456. ******  fp5 : zi16stepu
  457.  
  458. *                        // calculate s/z, t/z, zi->fixed s and t at far end of span,
  459. *                        // calculate s and t steps across span by shifting
  460. *                                sdivz += sdivz16stepu;
  461. *                                tdivz += tdivz16stepu;
  462. *                                zi += zi16stepu;
  463. *                                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
  464. *
  465. *                                snext = (int)(sdivz * z) + sadjust;
  466. *                                if (snext > bbextents)
  467. *                                        snext = bbextents;
  468. *                                else if (snext < 16)
  469. *                                        snext = 16;     // prevent round-off error on <0 steps from
  470. *                                                                //  from causing overstepping & running off the
  471. *                                                                //  edge of the texture
  472. *
  473. *                                tnext = (int)(tdivz * z) + tadjust;
  474. *                                if (tnext > bbextentt)
  475. *                                        tnext = bbextentt;
  476. *                                else if (tnext < 16)
  477. *                                        tnext = 16;     // guard against round-off error on <0 steps
  478. *
  479. *                                r_turb_sstep = (snext - r_turb_s) >> 4;
  480. *                                r_turb_tstep = (tnext - r_turb_t) >> 4;
  481. *                        }
  482.  
  483.         fadd    fp3,fp0                 ;sdivz += sdivz16stepu
  484.         fadd    fp4,fp1                 ;tdivz += tdivz16stepu
  485.         fadd    fp5,fp2                 ;zi += zi16stepu
  486.         fmove.s #65536,fp7
  487.         fdiv    fp2,fp7                 ;z = (float)0x10000 / zi;
  488.         fmove   fp7,fp6
  489.         fmul    fp0,fp6                 ;fp2 = sdivz * z
  490.         fmove.l fp6,d4                  ;convert to integer
  491.         add.l   a5,d4                   ;snext = d4 + sadjust
  492.         cmp.l   a4,d4                   ;if (snext > bbextents)
  493.         bgt.b   .down3
  494.         cmp.l   #16,d4                  ;if (snext < 16)
  495.         bge.b   .keep3
  496. .up3
  497.         moveq   #16,d4                  ;snext = 16
  498.         bra.b   .keep3
  499. .down3
  500.         move.l  a4,d4                   ;snext = bbextents
  501. .keep3
  502.         fmul    fp1,fp7                 ;fp7 = tdivz * z
  503.         fmove.l fp7,d5                  ;convert to integer
  504.         add.l   a3,d5                   ;tnext = d5 + tadjust
  505.         cmp.l   a2,d5                   ;if (tnext > bbextentt)
  506.         bgt.b   .down4
  507.         cmp.l   #16,d5                  ;if (tnext < 16)
  508.         bge.b   .keep4
  509. .up4
  510.         moveq   #16,d5                  ;tnext = 16
  511.         bra.b   .keep4
  512. .down4
  513.         move.l  a2,d5                   ;tnext = bbextentt
  514. .keep4
  515.         move.l  d4,.saved4(sp)          ;save snext
  516.         move.l  d5,.saved5(sp)          ;save tnext
  517.         sub.l   d6,d4                   ;d4 = snext - s
  518.         sub.l   d7,d5                   ;d5 = tnext - t
  519.         asr.l   #4,d4                   ;r_turb_sstep = d4 >> 4
  520.         asr.l   #4,d5                   ;r_turb_tstep = d5 >> 4
  521.         bra.w   .mainloop
  522.  
  523.  
  524. ******  Evaluation of the values for the inner loop. This version is used for
  525. ******  span size < 16
  526.  
  527. ******  The original algorithm has two ugly divisions at the end of this part.
  528. ******  These are removed by the following optimization:
  529. ******  First, the divisors 1,2 and 4 are handled specially to gain speed. The
  530. ******  other divisors are handled using a reciprocal table.
  531.  
  532. ******  a2  : bbextentt
  533. ******  a3  : tadjust
  534. ******  a4  : bbextents
  535. ******  a5  : sadjust
  536. ******  fp0 : sdivz
  537. ******  fp1 : tdivz
  538. ******  fp2 : zi
  539.  
  540. *                        // calculate s/z, t/z, zi->fixed s and t at last pixel in span (so
  541. *                        // can't step off polygon), clamp, calculate s and t steps across
  542. *                        // span by division, biasing steps low so we don't run off the
  543. *                        // texture
  544. *                                spancountminus1 = (float)(r_turb_spancount - 1);
  545. *                                sdivz += d_sdivzstepu * spancountminus1;
  546. *                                tdivz += d_tdivzstepu * spancountminus1;
  547. *                                zi += d_zistepu * spancountminus1;
  548. *                                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
  549. *                                snext = (int)(sdivz * z) + sadjust;
  550. *                                if (snext > bbextents)
  551. *                                        snext = bbextents;
  552. *                                else if (snext < 16)
  553. *                                        snext = 16;     // prevent round-off error on <0 steps from
  554. *                                                                //  from causing overstepping & running off the
  555. *                                                                //  edge of the texture
  556. *
  557. *                                tnext = (int)(tdivz * z) + tadjust;
  558. *                                if (tnext > bbextentt)
  559. *                                        tnext = bbextentt;
  560. *                                else if (tnext < 16)
  561. *                                        tnext = 16;     // guard against round-off error on <0 steps
  562. *
  563. *                                if (r_turb_spancount > 1)
  564. *                                {
  565. *                                        r_turb_sstep = (snext - r_turb_s) / (r_turb_spancount - 1);
  566. *                                        r_turb_tstep = (tnext - r_turb_t) / (r_turb_spancount - 1);
  567. *                                }
  568. *                        }
  569.  
  570. .finalpart
  571.         fmove.l d2,fp7                  ;spancountminus1 = (float)(r_turb_spancount-1)
  572.         fmove   fp7,fp6
  573.         fmul.s  .szstpu(sp),fp6         ;fp6 = d_sdivzstepu * spancountminus1
  574.         fadd    fp6,fp0                 ;sdivz += fp6
  575.         fmove   fp7,fp6
  576.         fmul.s  .tzstpu(sp),fp6         ;fp6 = d_tdivzstepu * spancountminus1
  577.         fadd    fp6,fp1                 ;tdivz += fp6
  578.         fmul.s  .zistpu(sp),fp7         ;fp7 = d_zistepu * spancountminus1
  579.         fadd    fp7,fp2                 ;zi += fp7
  580.         fmove.s #65536,fp7
  581.         fdiv    fp2,fp7                 ;z = (float)0x10000 / zi;
  582.         fmove   fp7,fp6
  583.         fmul    fp0,fp6                 ;fp6 = sdivz * z
  584.         fmove.l fp6,d4                  ;convert to integer
  585.         add.l   a5,d4                   ;snext = d4 + sadjust
  586.         cmp.l   a4,d4                   ;if (snext > bbextents)
  587.         bgt.b   .down5
  588.         cmp.l   #16,d4                  ;if (snext < 16)
  589.         bge.b   .keep5
  590. .up5
  591.         moveq   #16,d4                  ;snext = 16
  592.         bra.b   .keep5
  593. .down5
  594.         move.l  a4,d4                   ;snext = bbextents
  595. .keep5
  596.         fmul    fp1,fp7                 ;fp7 = tdivz * z
  597.         fmove.l fp7,d5                  ;convert to integer
  598.         add.l   a3,d5                   ;tnext = d5 + tadjust
  599.         cmp.l   a2,d5                   ;if (tnext > bbextentt)
  600.         bgt.b   .down6
  601.         cmp.l   #16,d5                  ;if (tnext < 16)
  602.         bge.b   .keep6
  603. .up6
  604.         moveq   #16,d5                  ;tnext = 16
  605.         bra.b   .keep6
  606. .down6
  607.         move.l  a2,d5                   ;tnext = bbextentt
  608. .keep6
  609.         move.l  d4,.saved4(sp)          ;save snext
  610.         move.l  d5,.saved5(sp)          ;save tnext
  611.         sub.l   d6,d4                   ;d4 = snext - r_turb_s
  612.         sub.l   d7,d5                   ;d5 = tnext - r_turb_t
  613.         IFEQ    QDIV
  614.         tst.l   d2
  615.         beq.w   .mainloop
  616.         divs.l  d2,d4
  617.         divs.l  d2,d5
  618.         ELSEIF
  619.         cmp     #5,d2                   ;(r_turb_spancount-1) < 5?
  620.         blt.b   .special                ;yes -> special case
  621.         cmp     #8,d2
  622.         beq.b   .spec_8
  623. .qdiv
  624.         IFNE    NICE_DIV
  625.         lsl.l   #2,d4
  626.         lsl.l   #2,d5
  627.         lea     ReciprocTable,a1
  628.         move    0(a1,d2.w*2),d0
  629.         move.l  d4,d3
  630.         mulu    d0,d3
  631.         clr     d3
  632.         swap    d3
  633.         swap    d4
  634.         muls    d0,d4
  635.         add.l   d3,d4
  636.         move.l  d5,d3
  637.         mulu    d0,d3
  638.         clr     d3
  639.         swap    d3
  640.         swap    d5
  641.         muls    d0,d5
  642.         add.l   d3,d5
  643.         bra.b   .mainloop
  644.         ELSEIF
  645.         asr.l   #7,d4                   ;d4 >> 7
  646.         asr.l   #7,d5                   ;d5 >> 7
  647.         lea     ReciprocTable,a1        ;a1 -> reciprocal table
  648.         move    0(a1,d2.w*2),d0         ;d0 = (1/(r_turb_spancount-1))<<16
  649.         muls    d0,d4                   ;d4 = d4 / (r_turb_spancount-1)
  650.         asr.l   #7,d4                   ;sstep = d4 >> 7
  651.         muls    d0,d5                   ;d5 = d5 / (r_turb_spancount-1)
  652.         asr.l   #7,d5                   ;tstep = d5 >> 7
  653.         bra.b   .mainloop
  654.         ENDC
  655. .special
  656.         cmp     #1,d2                   ;switch (r_turb_spancount-1)
  657.         ble.b   .mainloop               ;0,1 -> no scaling needed
  658.         cmp     #3,d2                   ;3 -> standard qdiv
  659.         beq.b   .qdiv
  660.         blt.b   .spec_2
  661.         asr.l   #2,d4                   ;4 -> scale by shifting right
  662.         asr.l   #2,d5
  663.         bra.b   .mainloop
  664. .spec_8
  665.         asr.l   #3,d4                   ;8 -> scale by shifting right
  666.         asr.l   #3,d5
  667.         bra.b   .mainloop
  668. .spec_2
  669.         asr.l   #1,d4                   ;2 -> scale by shifting right
  670.         asr.l   #1,d5
  671.         ENDC
  672.  
  673. ******  D_DrawTurbulent8Span (inlined)
  674. ******  Main drawing loop.
  675.  
  676. ******  d2 : r_turb_spancount
  677. ******  d4 : r_turb_sstep
  678. ******  d5 : r_turb_tstep
  679. ******  d6 : r_turb_s
  680. ******  d7 : r_turb_t
  681. ******  a0 : r_turb_pdest
  682. ******  a6 : r_turb_turb
  683.  
  684. *        do
  685. *        {
  686. *                sturb = ((r_turb_s + r_turb_turb[(r_turb_t>>16)&(CYCLE-1)])>>16)&63;
  687. *                tturb = ((r_turb_t + r_turb_turb[(r_turb_s>>16)&(CYCLE-1)])>>16)&63;
  688. *                *r_turb_pdest++ = *(r_turb_pbase + (tturb<<6) + sturb);
  689. *                r_turb_s += r_turb_sstep;
  690. *                r_turb_t += r_turb_tstep;
  691. *        } while (--r_turb_spancount > 0);
  692.  
  693. .mainloop
  694.         move.l  d1,-(sp)
  695.         move.l  _cacheblock,a1          ;pbase = (unsigned char *)cacheblock
  696.         moveq   #10,d1
  697. .draw
  698.         swap    d6                      ;r_turb_s >> 16
  699.         swap    d7                      ;r_turb_t >> 16
  700.         and     #CYCLE-1,d6             ;(r_turb_s >> 16) & (CYCLE-1)
  701.         and     #CYCLE-1,d7             ;(r_turb_t >> 16) & (CYCLE-1)
  702.         move.l  0(a6,d7.w*4),d0         ;r_turb_turb [d7]
  703.         move.l  0(a6,d6.w*4),d3         ;r_turb_turb [d6]
  704.         swap    d6
  705.         swap    d7
  706.         add.l   d6,d0                   ;r_turb_s + r_turb_turb []
  707.         add.l   d7,d3                   ;r_turb_t + r_turb_turb []
  708.         swap    d0                      ;d0 >> 16
  709.         and.l   #$3f,d0                 ;sturb = (d0 >> 16) & 63
  710.         lsr.l   d1,d3                   ;(d3 >> (16-6))
  711.         and.l   #$fc0,d3                ;tturb<<6 = (d3 >> (16-6)) & (63 << 6)
  712.         add.l   d3,d0                   ;sturb + tturb << 6
  713.         move.b  0(a1,d0.l),(a0)+        ;*r_turb_pdest++ = *(r_turb_pbase + d0)
  714.         add.l   d4,d6                   ;r_turb_s += r_turb_sstep
  715.         add.l   d5,d7                   ;r_turb_t += r_turb_tstep
  716.         dbra    d2,.draw                ;while (--r_turb_spancount > 0)
  717.         move.l  (sp)+,d1
  718.  
  719. ******  loop terminations
  720.  
  721.  
  722.         move.l   .saved5(sp),d7         ;r_turb_t = tnext
  723.         move.l   .saved4(sp),d6         ;r_turb_s = snext
  724.  
  725.         tst.l   d1                      ;while (count > 0)
  726.         bgt.w   .loop2
  727.  
  728.         move.l  .savea1(sp),a1          ;while ((pspan = pspan->next) != NULL)
  729.         move.l  PSPAN_NEXT(a1),a1
  730.         tst.l   a1
  731.         bne.w   .loop
  732.         add.l   #.fpuregs,sp
  733.         fmovem.x        (sp)+,fp2-fp7
  734.         movem.l (sp)+,d2-d7/a2-a6
  735.         rts
  736.  
  737.  
  738.  
  739.  
  740.  
  741.  
  742.  
  743.  
  744.  
  745.  
  746.  
  747.  
  748. ******************************************************************************
  749. *
  750. *       void D_DrawSpans8 (espan_t *pspan)
  751. *
  752. *       standard scan drawing function (8 pixel subdivision)
  753. *
  754. ******************************************************************************
  755.  
  756.         cnop    0,4
  757. _D_DrawSpans8
  758.  
  759.  
  760. *****   stackframe
  761.  
  762.         rsreset
  763. .saved4         rs.l    1
  764. .saved5         rs.l    1
  765. .savea6         rs.l    1
  766. .szstpu         rs.s    1
  767. .szstpv         rs.s    1
  768. .szorg          rs.s    1
  769. .tzstpu         rs.s    1
  770. .tzstpv         rs.s    1
  771. .tzorg          rs.s    1
  772. .zistpu         rs.s    1
  773. .zistpv         rs.s    1
  774. .ziorg          rs.s    1
  775. .fpuregs        rs.x    6
  776. .intregs        rs.l    11
  777.         rs.l    1
  778. .pspan          rs.l    1
  779.  
  780.  
  781. ******  Prologue. Global variables are put into registers or onto the stackframe
  782.  
  783.         fmove.s _d_subdiv16+CVAR_VALUE,fp0
  784.         fcmp.s  #0,fp0
  785.         fbne    _D_DrawSpans16
  786.         movem.l d2-d7/a2-a6,-(sp)
  787.         fmovem.x        fp2-fp7,-(sp)
  788.         move.l  _bbextentt,a2
  789.         move.l  _tadjust,a3
  790.         move.l  _bbextents,a4
  791.         move.l  _sadjust,a5
  792.         move.l  _d_ziorigin,-(sp)
  793.         move.l  _d_zistepv,-(sp)
  794.         move.l  _d_zistepu,-(sp)
  795.         move.l  _d_tdivzorigin,-(sp)
  796.         move.l  _d_tdivzstepv,-(sp)
  797.         move.l  _d_tdivzstepu,-(sp)
  798.         move.l  _d_sdivzorigin,-(sp)
  799.         move.l  _d_sdivzstepv,-(sp)
  800.         move.l  _d_sdivzstepu,-(sp)
  801.         sub.l   #.szstpu,sp
  802.  
  803. ******  First loop. In every iteration one complete span is drawn
  804.  
  805. *        pbase = (unsigned char *)cacheblock;
  806. *
  807. *        sdivz8stepu = d_sdivzstepu * 8;
  808. *        tdivz8stepu = d_tdivzstepu * 8;
  809. *        zi8stepu = d_zistepu * 8;
  810. *
  811. *        do
  812. *        {
  813. *                pdest = (unsigned char *)((byte *)d_viewbuffer +
  814. *                                (screenwidth * pspan->v) + pspan->u);
  815. *
  816. *                count = pspan->count;
  817. *
  818. *        // calculate the initial s/z, t/z, 1/z, s, and t and clamp
  819. *                du = (float)pspan->u;
  820. *                dv = (float)pspan->v;
  821. *
  822. *                sdivz = d_sdivzorigin + dv*d_sdivzstepv + du*d_sdivzstepu;
  823. *                tdivz = d_tdivzorigin + dv*d_tdivzstepv + du*d_tdivzstepu;
  824. *                zi = d_ziorigin + dv*d_zistepv + du*d_zistepu;
  825. *                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
  826. *
  827.  
  828.         move.l  _cacheblock,a1          ;pbase = (unsigned char *)cacheblock
  829.         fmove.s #8,fp7
  830.         fmove.s .szstpu(sp),fp3
  831.         fmul    fp7,fp3                 ;sdivz8stepu = d_sdivzstepu * 8
  832.         fmove.s .tzstpu(sp),fp4
  833.         fmul    fp7,fp4                 ;tdivz8stepu = d_tdivzstepu * 8
  834.         fmove.s .zistpu(sp),fp5
  835.         fmul    fp7,fp5                 ;zi8stepu = d_zistepu * 8
  836.         move.l  .pspan(sp),a6           ;get function parameter
  837. .loop
  838.         move.l  a6,.savea6(sp)          ;save actual ptr to pspan
  839.         move.l  _d_viewbuffer,a0
  840.         move.l  _screenwidth,d0
  841.         move.l  (a6)+,d1
  842.         fmove.l d1,fp2                  ;du = (float)pspan->u
  843.         move.l  (a6)+,d2
  844.         fmove.l d2,fp7                  ;dv = (float)pspan->v
  845.         move.l  (a6)+,d4
  846.         muls    d2,d0                   ;d0 = screenwidth * pspan->v
  847.         add.l   d1,d0
  848.         add.l   d0,a0                   ;pdest = d_viewbuffer + pspan->u + d0
  849.         lea     .szstpu(sp),a6          ;a6 -> stackframe
  850.         fmove.s (a6)+,fp0
  851.         fmul    fp2,fp0                 ;fp0 = du * d_sdivzstepu
  852.         fmove.s (a6)+,fp1
  853.         fmul    fp7,fp1                 ;fp1 = dv * d_sdivzstepv
  854.         fadd    fp1,fp0
  855.         fadd.s  (a6)+,fp0               ;sdivz = d_sdivzorigin + fp0 + fp1
  856.         fmove.s (a6)+,fp1
  857.         fmul    fp2,fp1                 ;fp1 = du * d_tdivzstepu
  858.         fmove.s (a6)+,fp6
  859.         fmul    fp7,fp6                 ;fp6 = dv * d_tdivzstepv
  860.         fadd    fp6,fp1
  861.         fadd.s  (a6)+,fp1               ;tdivz = d_tdivzorigin + fp1 + fp6
  862.         fmul.s  (a6)+,fp2               ;fp2 = du * d_zistepu
  863.         fmul.s  (a6)+,fp7               ;fp7 = dv * d_zistepv
  864.         fadd    fp7,fp2
  865.         fadd.s  (a6)+,fp2               ;zi = d_ziorigin + fp2 + fp7
  866.         fmove.s #65536,fp6
  867.         fdiv    fp2,fp6                 ;z = (float)0x10000 / zi
  868.  
  869. *                s = (int)(sdivz * z) + sadjust;
  870. *                if (s > bbextents)
  871. *                        s = bbextents;
  872. *                else if (s < 0)
  873. *                        s = 0;
  874. *
  875. *                t = (int)(tdivz * z) + tadjust;
  876. *                if (t > bbextentt)
  877. *                        t = bbextentt;
  878. *                else if (t < 0)
  879. *                        t = 0;
  880.  
  881.  
  882.         fmove   fp6,fp7
  883.         fmul    fp0,fp7                 ;fp7 = sdivz * z
  884.         fmove.l fp7,d6                  ;convert to integer
  885.         add.l   a5,d6                   ;s = d6 + sadjust
  886.         cmp.l   a4,d6                   ;if (s > bbextents)
  887.         bgt.b   .down
  888.         tst.l   d6                      ;if (s < 0)
  889.         bge.b   .keep
  890. .up
  891.         moveq   #0,d6                   ;s = 0
  892.         bra.b   .keep
  893. .down
  894.         move.l  a4,d6                   ;s = bbextents
  895. .keep
  896.         fmul    fp1,fp6                 ;fp6 = tdivz * z
  897.         fmove.l fp6,d7                  ;convert to integer
  898.         add.l   a3,d7                   ;t = d7 + tadjust
  899.         cmp.l   a2,d7                   ;if (t > bbextentt)
  900.         bgt.b   .down2
  901.         tst.l   d7                      ;if (t < 0)
  902.         bge.b   .keep2
  903. .up2
  904.         moveq   #0,d7                   ;t = 0
  905.         bra.b   .keep2
  906. .down2
  907.         move.l  a2,d7                   ;t = bbextentt
  908. .keep2
  909.         move.l  d4,d1
  910.  
  911. ******  Second loop. In every iteration one part of the whole span is drawn
  912. ******  d2 gets the value (spancount-1)! [NOT spancount]
  913.  
  914. ******  d1 = count
  915.  
  916. *                do
  917. *                {
  918. *                // calculate s and t at the far end of the span
  919. *                        if (count >= 8)
  920. *                                spancount = 8;
  921. *                        else
  922. *                                spancount = count;
  923. *
  924. *                        count -= spancount;
  925. *
  926. *                        if (count)
  927. *                        {
  928.  
  929. .loop2
  930.         moveq   #8-1,d2                 ;spancount = 8
  931.         cmp.l   #8,d1                   ;if (count >= 8)
  932.         bgt.b   .cont
  933.         move.l  d1,d2                   ;spancount = count
  934.         subq.l  #1,d2
  935.         moveq   #0,d1                   ;count -= spancount
  936.         bra.w   .finalpart
  937. .cont
  938.         subq.l  #8,d1                   ;count -= spancount;
  939.  
  940. ******  Evaluation of the values for the inner loop. This version is used for
  941. ******  span size = 8
  942.  
  943. ******  a2  : bbextentt
  944. ******  a3  : tadjust
  945. ******  a4  : bbextents
  946. ******  a5  : sadjust
  947. ******  fp0 : sdivz
  948. ******  fp1 : tdivz
  949. ******  fp2 : zi
  950. ******  fp3 : sdivz8stepu
  951. ******  fp4 : tdivz8stepu
  952. ******  fp5 : zi8stepu
  953.  
  954. *                        // calculate s/z, t/z, zi->fixed s and t at far end of span,
  955. *                        // calculate s and t steps across span by shifting
  956. *                                sdivz += sdivz8stepu;
  957. *                                tdivz += tdivz8stepu;
  958. *                                zi += zi8stepu;
  959. *                                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
  960. *                                snext = (int)(sdivz * z) + sadjust;
  961. *                                if (snext > bbextents)
  962. *                                        snext = bbextents;
  963. *                                else if (snext < 8)
  964. *                                        snext = 8;      // prevent round-off error on <0 steps from
  965. *                                                                //  from causing overstepping & running off the
  966. *                                                                //  edge of the texture
  967. *                                tnext = (int)(tdivz * z) + tadjust;
  968. *                                if (tnext > bbextentt)
  969. *                                        tnext = bbextentt;
  970. *                                else if (tnext < 8)
  971. *                                        tnext = 8;      // guard against round-off error on <0 steps
  972. *                                sstep = (snext - s) >> 3;
  973. *                                tstep = (tnext - t) >> 3;
  974. *                        }
  975.  
  976.         fadd    fp3,fp0                 ;sdivz += sdivz8stepu
  977.         fadd    fp4,fp1                 ;tdivz += tdivz8stepu
  978.         fadd    fp5,fp2                 ;zi += zi8stepu
  979.         fmove.s #65536,fp7
  980.         fdiv    fp2,fp7                 ;z = (float)0x10000 / zi;
  981.         fmove   fp7,fp6
  982.         fmul    fp0,fp6                 ;fp2 = sdivz * z
  983.         fmove.l fp6,d4                  ;convert to integer
  984.         add.l   a5,d4                   ;snext = d4 + sadjust
  985.         cmp.l   a4,d4                   ;if (snext > bbextents)
  986.         bgt.b   .down3
  987.         cmp.l   #8,d4                   ;if (snext < 8)
  988.         bge.b   .keep3
  989. .up3
  990.         moveq   #8,d4                   ;snext = 8
  991.         bra.b   .keep3
  992. .down3
  993.         move.l  a4,d4                   ;snext = bbextents
  994. .keep3
  995.         fmul    fp1,fp7                 ;fp7 = tdivz * z
  996.         fmove.l fp7,d5                  ;convert to integer
  997.         add.l   a3,d5                   ;tnext = d5 + tadjust
  998.         cmp.l   a2,d5                   ;if (tnext > bbextentt)
  999.         bgt.b   .down4
  1000.         cmp.l   #8,d5                   ;if (tnext < 8)
  1001.         bge.b   .keep4
  1002. .up4
  1003.         moveq   #8,d5                   ;tnext = 8
  1004.         bra.b   .keep4
  1005. .down4
  1006.         move.l  a2,d5                   ;tnext = bbextentt
  1007. .keep4
  1008.         move.l  d4,.saved4(sp)          ;save snext
  1009.         move.l  d5,.saved5(sp)          ;save tnext
  1010.         sub.l   d6,d4                   ;d4 = snext - s
  1011.         sub.l   d7,d5                   ;d5 = tnext - t
  1012.         asr.l   #3,d4                   ;sstep = d4 >> 3
  1013.         asr.l   #3,d5                   ;tstep = d5 >> 3
  1014.         bra.w   .mainloop
  1015.  
  1016.  
  1017. ******  Evaluation of the values for the inner loop. This version is used for
  1018. ******  span size < 8
  1019.  
  1020. ******  The original algorithm has two ugly divisions at the end of this part.
  1021. ******  These are removed by the following optimization:
  1022. ******  First, the divisors 1,2 and 4 are handled specially to gain speed. The
  1023. ******  other divisors are handled using a reciprocal table.
  1024.  
  1025. ******  a2  : bbextentt
  1026. ******  a3  : tadjust
  1027. ******  a4  : bbextents
  1028. ******  a5  : sadjust
  1029. ******  fp0 : sdivz
  1030. ******  fp1 : tdivz
  1031. ******  fp2 : zi
  1032.  
  1033. *                        // calculate s/z, t/z, zi->fixed s and t at last pixel in span (so
  1034. *                        // can't step off polygon), clamp, calculate s and t steps across
  1035. *                        // span by division, biasing steps low so we don't run off the
  1036. *                        // texture
  1037. *                                spancountminus1 = (float)(spancount - 1);
  1038. *                                sdivz += d_sdivzstepu * spancountminus1;
  1039. *                                tdivz += d_tdivzstepu * spancountminus1;
  1040. *                                zi += d_zistepu * spancountminus1;
  1041. *                                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
  1042. *                                snext = (int)(sdivz * z) + sadjust;
  1043. *                                if (snext > bbextents)
  1044. *                                        snext = bbextents;
  1045. *                                else if (snext < 8)
  1046. *                                        snext = 8;      // prevent round-off error on <0 steps from
  1047. *                                                                //  from causing overstepping & running off the
  1048. *                                                                //  edge of the texture
  1049. *
  1050. *                                tnext = (int)(tdivz * z) + tadjust;
  1051. *                                if (tnext > bbextentt)
  1052. *                                        tnext = bbextentt;
  1053. *                                else if (tnext < 8)
  1054. *                                        tnext = 8;      // guard against round-off error on <0 steps
  1055. *
  1056. *                                if (spancount > 1)
  1057. *                                {
  1058. *                                        sstep = (snext - s) / (spancount - 1);
  1059. *                                        tstep = (tnext - t) / (spancount - 1);
  1060. *                                }
  1061. *                        }
  1062.  
  1063. .finalpart
  1064.         fmove.l d2,fp7                  ;spancountminus1 = (float)(spancount-1)
  1065.         fmove   fp7,fp6
  1066.         fmul.s  .szstpu(sp),fp6         ;fp6 = d_sdivzstepu * spancountminus1
  1067.         fadd    fp6,fp0                 ;sdivz += fp6
  1068.         fmove   fp7,fp6
  1069.         fmul.s  .tzstpu(sp),fp6         ;fp6 = d_tdivzstepu * spancountminus1
  1070.         fadd    fp6,fp1                 ;tdivz += fp6
  1071.         fmul.s  .zistpu(sp),fp7         ;fp7 = d_zistepu * spancountminus1
  1072.         fadd    fp7,fp2                 ;zi += fp7
  1073.         fmove.s #65536,fp7
  1074.         fdiv    fp2,fp7                 ;z = (float)0x10000 / zi;
  1075.         fmove   fp7,fp6
  1076.         fmul    fp0,fp6                 ;fp6 = sdivz * z
  1077.         fmove.l fp6,d4                  ;convert to integer
  1078.         add.l   a5,d4                   ;snext = d4 + sadjust
  1079.         cmp.l   a4,d4                   ;if (snext > bbextents)
  1080.         bgt.b   .down5
  1081.         cmp.l   #8,d4                   ;if (snext < 8)
  1082.         bge.b   .keep5
  1083. .up5
  1084.         moveq   #8,d4                   ;snext = 8
  1085.         bra.b   .keep5
  1086. .down5
  1087.         move.l  a4,d4                   ;snext = bbextents
  1088. .keep5
  1089.         fmul    fp1,fp7                 ;fp7 = tdivz * z
  1090.         fmove.l fp7,d5                  ;convert to integer
  1091.         add.l   a3,d5                   ;tnext = d5 + tadjust
  1092.         cmp.l   a2,d5                   ;if (tnext > bbextentt)
  1093.         bgt.b   .down6
  1094.         cmp.l   #8,d5                   ;if (tnext < 8)
  1095.         bge.b   .keep6
  1096. .up6
  1097.         moveq   #8,d5                   ;tnext = 8
  1098.         bra.b   .keep6
  1099. .down6
  1100.         move.l  a2,d5                   ;tnext = bbextentt
  1101. .keep6
  1102.         move.l  d4,.saved4(sp)          ;save snext
  1103.         move.l  d5,.saved5(sp)          ;save tnext
  1104.         sub.l   d6,d4                   ;d4 = snext - s
  1105.         sub.l   d7,d5                   ;d5 = tnext - t
  1106.         IFEQ    QDIV
  1107.         tst.l   d2
  1108.         beq.w   .mainloop
  1109.         divs.l  d2,d4
  1110.         divs.l  d2,d5
  1111.         ELSEIF
  1112.         cmp     #5,d2                   ;(spancount-1) < 5?
  1113.         blt.b   .special                ;yes -> special case
  1114. .qdiv
  1115.         IFNE    NICE_DIV
  1116.         lsl.l   #2,d4
  1117.         lsl.l   #2,d5
  1118.         lea     ReciprocTable,a6
  1119.         move    0(a6,d2.w*2),d0
  1120.         move.l  d4,d3
  1121.         mulu    d0,d3
  1122.         clr     d3
  1123.         swap    d3
  1124.         swap    d4
  1125.         muls    d0,d4
  1126.         add.l   d3,d4
  1127.         move.l  d5,d3
  1128.         mulu    d0,d3
  1129.         clr     d3
  1130.         swap    d3
  1131.         swap    d5
  1132.         muls    d0,d5
  1133.         add.l   d3,d5
  1134.         bra.b   .mainloop
  1135.         ELSEIF
  1136.         asr.l   #7,d4                   ;d4 >> 7
  1137.         asr.l   #7,d5                   ;d5 >> 7
  1138.         lea     ReciprocTable,a6        ;a6 -> reciprocal table
  1139.         move    0(a6,d2.w*2),d0         ;d0 = (1/(spancount-1))<<16
  1140.         muls    d0,d4                   ;d4 = d4 / (spancount-1)
  1141.         asr.l   #7,d4                   ;sstep = d4 >> 7
  1142.         muls    d0,d5                   ;d5 = d5 / (spancount-1)
  1143.         asr.l   #7,d5                   ;tstep = d5 >> 7
  1144.         bra.b   .mainloop
  1145.         ENDC
  1146. .special
  1147.         cmp     #1,d2                   ;switch (spancount-1)
  1148.         ble.b   .mainloop               ;0,1 -> no scaling needed
  1149.         cmp     #3,d2                   ;3 -> standard qdiv
  1150.         beq.b   .qdiv
  1151.         blt.b   .spec_2
  1152.         asr.l   #2,d4                   ;4 -> scale by shifting right
  1153.         asr.l   #2,d5
  1154.         bra.b   .mainloop
  1155. .spec_2
  1156.         asr.l   #1,d4                   ;2 -> scale by shifting right
  1157.         asr.l   #1,d5
  1158.         ENDC
  1159.  
  1160. ******  Main drawing loop. Here lies the speed.
  1161. ******  Very optimized (removed multiplication from inner loop)
  1162.  
  1163. ******  d2 : spancount
  1164. ******  d4 : sstep
  1165. ******  d5 : tstep
  1166. ******  d6 : s
  1167. ******  d7 : t
  1168. ******  a0 : pdest
  1169. ******  a1 : pbase
  1170.  
  1171. *                        do
  1172. *                        {
  1173. *                                *pdest++ = *(pbase + (s >> 16) + (t >> 16) * cachewidth);
  1174. *                                s += sstep;
  1175. *                                t += tstep;
  1176. *                        } while (--spancount > 0);
  1177.  
  1178. .mainloop
  1179.         move.l  d1,-(sp)
  1180.         lea     .PixTable,a6            ;a6 -> Functable
  1181.         move.l  _cachewidth,d3          ;read cachewidth
  1182.         move.l  0(a6,d2.w*4),a6         ;get pointer to function
  1183.         swap    d7
  1184.         swap    d4
  1185.         move.l  d7,d1
  1186.         swap    d5
  1187.         muls    d3,d7                   ;d7 = t integer part * cachewidth
  1188.         move    d5,d2
  1189.         clr     d1                      ;d1 = t fractional part
  1190.         muls    d3,d2                   ;tstep integer part * cachewidth
  1191.         move    d4,d0                   ;d0 = sstep integer part
  1192.         clr     d5                      ;d5 = tstep fractional part
  1193.         clr     d4                      ;d4 = sstep fractional part
  1194.         swap    d6                      ;d6 = s swapped
  1195.         jmp     (a6)
  1196. .Pix8
  1197.         lea     0(a1,d6.w),a6
  1198.         move.b  0(a6,d7.l),(a0)+
  1199.         add.l   d4,d6                   ;increment s fractional part
  1200.         addx.w  d0,d6                   ;increment s integer part
  1201.         add.l   d2,d7                   ;increment t integer part
  1202.         add.l   d5,d1                   ;increment t fractional part
  1203.         bcc.b   .Pix7                   ;check if carry
  1204.         add.l   d3,d7                   ;add cachewidth to t
  1205. .Pix7
  1206.         lea     0(a1,d6.w),a6           ;and so long...
  1207.         move.b  0(a6,d7.l),(a0)+
  1208.         add.l   d4,d6
  1209.         addx.w  d0,d6
  1210.         add.l   d2,d7
  1211.         add.l   d5,d1
  1212.         bcc.b   .Pix6
  1213.         add.l   d3,d7
  1214. .Pix6
  1215.         lea     0(a1,d6.w),a6
  1216.         move.b  0(a6,d7.l),(a0)+
  1217.         add.l   d4,d6
  1218.         addx.w  d0,d6
  1219.         add.l   d2,d7
  1220.         add.l   d5,d1
  1221.         bcc.b   .Pix5
  1222.         add.l   d3,d7
  1223. .Pix5
  1224.         lea     0(a1,d6.w),a6
  1225.         move.b  0(a6,d7.l),(a0)+
  1226.         add.l   d4,d6
  1227.         addx.w  d0,d6
  1228.         add.l   d2,d7
  1229.         add.l   d5,d1
  1230.         bcc.b   .Pix4
  1231.         add.l   d3,d7
  1232. .Pix4
  1233.         lea     0(a1,d6.w),a6
  1234.         move.b  0(a6,d7.l),(a0)+
  1235.         add.l   d4,d6
  1236.         addx.w  d0,d6
  1237.         add.l   d2,d7
  1238.         add.l   d5,d1
  1239.         bcc.b   .Pix3
  1240.         add.l   d3,d7
  1241. .Pix3
  1242.         lea     0(a1,d6.w),a6
  1243.         move.b  0(a6,d7.l),(a0)+
  1244.         add.l   d4,d6
  1245.         addx.w  d0,d6
  1246.         add.l   d2,d7
  1247.         add.l   d5,d1
  1248.         bcc.b   .Pix2
  1249.         add.l   d3,d7
  1250. .Pix2
  1251.         lea     0(a1,d6.w),a6
  1252.         move.b  0(a6,d7.l),(a0)+
  1253.         add.l   d4,d6
  1254.         addx.w  d0,d6
  1255.         add.l   d2,d7
  1256.         add.l   d5,d1
  1257.         bcc.b   .Pix1
  1258.         add.l   d3,d7
  1259. .Pix1
  1260.         lea     0(a1,d6.w),a6
  1261.         move.b  0(a6,d7.l),(a0)+
  1262.         add.l   d4,d6
  1263.         addx.w  d0,d6
  1264.         add.l   d2,d7
  1265.         add.l   d5,d1
  1266.         bcc.b   .Pix0
  1267.         add.l   d3,d7
  1268. .Pix0
  1269.         move.l  (sp)+,d1
  1270.  
  1271. ******  loop terminations
  1272.  
  1273.  
  1274.         move.l   .saved5(sp),d7         ;t = tnext
  1275.         move.l   .saved4(sp),d6         ;s = snext
  1276.  
  1277.         tst.l   d1                      ;while (count > 0)
  1278.         bgt.w   .loop2
  1279.  
  1280.         move.l  .savea6(sp),a6          ;while ((pspan = pspan->next) != NULL)
  1281.         move.l  PSPAN_NEXT(a6),a6
  1282.         tst.l   a6
  1283.         bne.w   .loop
  1284.         add.l   #.fpuregs,sp
  1285.         fmovem.x        (sp)+,fp2-fp7
  1286.         movem.l (sp)+,d2-d7/a2-a6
  1287.         rts
  1288.  
  1289. .PixTable
  1290.         dc.l    .Pix1
  1291.         dc.l    .Pix2
  1292.         dc.l    .Pix3
  1293.         dc.l    .Pix4
  1294.         dc.l    .Pix5
  1295.         dc.l    .Pix6
  1296.         dc.l    .Pix7
  1297.         dc.l    .Pix8
  1298.  
  1299.  
  1300.  
  1301.  
  1302.  
  1303.  
  1304.  
  1305.  
  1306. ******************************************************************************
  1307. *
  1308. *       void D_DrawSpans16 (espan_t *pspan)
  1309. *
  1310. *       standard scan drawing function (16 pixel subdivision)
  1311. *
  1312. ******************************************************************************
  1313.  
  1314.         cnop    0,4
  1315. _D_DrawSpans16
  1316.  
  1317.  
  1318. *****   stackframe
  1319.  
  1320.         rsreset
  1321. .saved4         rs.l    1
  1322. .saved5         rs.l    1
  1323. .savea6         rs.l    1
  1324. .szstpu         rs.s    1
  1325. .szstpv         rs.s    1
  1326. .szorg          rs.s    1
  1327. .tzstpu         rs.s    1
  1328. .tzstpv         rs.s    1
  1329. .tzorg          rs.s    1
  1330. .zistpu         rs.s    1
  1331. .zistpv         rs.s    1
  1332. .ziorg          rs.s    1
  1333. .fpuregs        rs.x    6
  1334. .intregs        rs.l    11
  1335.         rs.l    1
  1336. .pspan          rs.l    1
  1337.  
  1338. ******  Prologue. Global variables are put into registers or onto the stackframe
  1339.  
  1340.         movem.l d2-d7/a2-a6,-(sp)
  1341.         fmovem.x        fp2-fp7,-(sp)
  1342.         move.l  _bbextentt,a2
  1343.         move.l  _tadjust,a3
  1344.         move.l  _bbextents,a4
  1345.         move.l  _sadjust,a5
  1346.         move.l  _d_ziorigin,-(sp)
  1347.         move.l  _d_zistepv,-(sp)
  1348.         move.l  _d_zistepu,-(sp)
  1349.         move.l  _d_tdivzorigin,-(sp)
  1350.         move.l  _d_tdivzstepv,-(sp)
  1351.         move.l  _d_tdivzstepu,-(sp)
  1352.         move.l  _d_sdivzorigin,-(sp)
  1353.         move.l  _d_sdivzstepv,-(sp)
  1354.         move.l  _d_sdivzstepu,-(sp)
  1355.         sub.l   #.szstpu,sp
  1356.  
  1357. ******  First loop. In every iteration one complete span is drawn
  1358.  
  1359. *        pbase = (unsigned char *)cacheblock;
  1360. *
  1361. *        sdivz16stepu = d_sdivzstepu * 16;
  1362. *        tdivz16stepu = d_tdivzstepu * 16;
  1363. *        zi16stepu = d_zistepu * 16;
  1364. *
  1365. *        do
  1366. *        {
  1367. *                pdest = (unsigned char *)((byte *)d_viewbuffer +
  1368. *                                (screenwidth * pspan->v) + pspan->u);
  1369. *
  1370. *                count = pspan->count;
  1371. *
  1372. *        // calculate the initial s/z, t/z, 1/z, s, and t and clamp
  1373. *                du = (float)pspan->u;
  1374. *                dv = (float)pspan->v;
  1375. *
  1376. *                sdivz = d_sdivzorigin + dv*d_sdivzstepv + du*d_sdivzstepu;
  1377. *                tdivz = d_tdivzorigin + dv*d_tdivzstepv + du*d_tdivzstepu;
  1378. *                zi = d_ziorigin + dv*d_zistepv + du*d_zistepu;
  1379. *                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
  1380. *
  1381.  
  1382.         move.l  _cacheblock,a1          ;pbase = (unsigned char *)cacheblock
  1383.         fmove.s #16,fp7
  1384.         fmove.s .szstpu(sp),fp3
  1385.         fmul    fp7,fp3                 ;sdivz16stepu = d_sdivzstepu * 16
  1386.         fmove.s .tzstpu(sp),fp4
  1387.         fmul    fp7,fp4                 ;tdivz16stepu = d_tdivzstepu * 16
  1388.         fmove.s .zistpu(sp),fp5
  1389.         fmul    fp7,fp5                 ;zi16stepu = d_zistepu * 16
  1390.         move.l  .pspan(sp),a6           ;get function parameter
  1391. .loop
  1392.         move.l  a6,.savea6(sp)          ;save actual ptr to pspan
  1393.         move.l  _d_viewbuffer,a0
  1394.         move.l  _screenwidth,d0
  1395.         move.l  (a6)+,d1
  1396.         fmove.l d1,fp2                  ;du = (float)pspan->u
  1397.         move.l  (a6)+,d2
  1398.         fmove.l d2,fp7                  ;dv = (float)pspan->v
  1399.         move.l  (a6)+,d4
  1400.         muls    d2,d0                   ;d0 = screenwidth * pspan->v
  1401.         add.l   d1,d0
  1402.         add.l   d0,a0                   ;pdest = d_viewbuffer + pspan->u + d0
  1403.         lea     .szstpu(sp),a6          ;a6 -> stackframe
  1404.         fmove.s (a6)+,fp0
  1405.         fmul    fp2,fp0                 ;fp0 = du * d_sdivzstepu
  1406.         fmove.s (a6)+,fp1
  1407.         fmul    fp7,fp1                 ;fp1 = dv * d_sdivzstepv
  1408.         fadd    fp1,fp0
  1409.         fadd.s  (a6)+,fp0               ;sdivz = d_sdivzorigin + fp0 + fp1
  1410.         fmove.s (a6)+,fp1
  1411.         fmul    fp2,fp1                 ;fp1 = du * d_tdivzstepu
  1412.         fmove.s (a6)+,fp6
  1413.         fmul    fp7,fp6                 ;fp6 = dv * d_tdivzstepv
  1414.         fadd    fp6,fp1
  1415.         fadd.s  (a6)+,fp1               ;tdivz = d_tdivzorigin + fp1 + fp6
  1416.         fmul.s  (a6)+,fp2               ;fp2 = du * d_zistepu
  1417.         fmul.s  (a6)+,fp7               ;fp7 = dv * d_zistepv
  1418.         fadd    fp7,fp2
  1419.         fadd.s  (a6)+,fp2               ;zi = d_ziorigin + fp2 + fp7
  1420.         fmove.s #65536,fp6
  1421.         fdiv    fp2,fp6                 ;z = (float)0x10000 / zi
  1422.  
  1423. *                s = (int)(sdivz * z) + sadjust;
  1424. *                if (s > bbextents)
  1425. *                        s = bbextents;
  1426. *                else if (s < 0)
  1427. *                        s = 0;
  1428. *
  1429. *                t = (int)(tdivz * z) + tadjust;
  1430. *                if (t > bbextentt)
  1431. *                        t = bbextentt;
  1432. *                else if (t < 0)
  1433. *                        t = 0;
  1434.  
  1435.  
  1436.         fmove   fp6,fp7
  1437.         fmul    fp0,fp7                 ;fp7 = sdivz * z
  1438.         fmove.l fp7,d6                  ;convert to integer
  1439.         add.l   a5,d6                   ;s = d6 + sadjust
  1440.         cmp.l   a4,d6                   ;if (s > bbextents)
  1441.         bgt.b   .down
  1442.         tst.l   d6                      ;if (s < 0)
  1443.         bge.b   .keep
  1444. .up
  1445.         moveq   #0,d6                   ;s = 0
  1446.         bra.b   .keep
  1447. .down
  1448.         move.l  a4,d6                   ;s = bbextents
  1449. .keep
  1450.         fmul    fp1,fp6                 ;fp6 = tdivz * z
  1451.         fmove.l fp6,d7                  ;convert to integer
  1452.         add.l   a3,d7                   ;t = d7 + tadjust
  1453.         cmp.l   a2,d7                   ;if (t > bbextentt)
  1454.         bgt.b   .down2
  1455.         tst.l   d7                      ;if (t < 0)
  1456.         bge.b   .keep2
  1457. .up2
  1458.         moveq   #0,d7                   ;t = 0
  1459.         bra.b   .keep2
  1460. .down2
  1461.         move.l  a2,d7                   ;t = bbextentt
  1462. .keep2
  1463.         move.l  d4,d1
  1464.  
  1465. ******  Second loop. In every iteration one part of the whole span is drawn
  1466. ******  d2 gets the value (spancount-1)! [NOT spancount]
  1467.  
  1468. ******  d1 = count
  1469.  
  1470. *                do
  1471. *                {
  1472. *                // calculate s and t at the far end of the span
  1473. *                        if (count >= 16)
  1474. *                                spancount = 16;
  1475. *                        else
  1476. *                                spancount = count;
  1477. *
  1478. *                        count -= spancount;
  1479. *
  1480. *                        if (count)
  1481. *                        {
  1482.  
  1483. .loop2
  1484.         moveq   #16-1,d2                ;spancount = 16
  1485.         cmp.l   #16,d1                  ;if (count >= 16)
  1486.         bgt.b   .cont
  1487.         move.l  d1,d2                   ;spancount = count
  1488.         subq.l  #1,d2
  1489.         moveq   #0,d1                   ;count -= spancount
  1490.         bra.w   .finalpart
  1491. .cont
  1492.         sub.l   #16,d1                  ;count -= spancount;
  1493.  
  1494. ******  Evaluation of the values for the inner loop. This version is used for
  1495. ******  span size = 16
  1496.  
  1497. ******  a2  : bbextentt
  1498. ******  a3  : tadjust
  1499. ******  a4  : bbextents
  1500. ******  a5  : sadjust
  1501. ******  fp0 : sdivz
  1502. ******  fp1 : tdivz
  1503. ******  fp2 : zi
  1504. ******  fp3 : sdivz16stepu
  1505. ******  fp4 : tdivz16stepu
  1506. ******  fp5 : zi16stepu
  1507.  
  1508. *                        // calculate s/z, t/z, zi->fixed s and t at far end of span,
  1509. *                        // calculate s and t steps across span by shifting
  1510. *                                sdivz += sdivz16stepu;
  1511. *                                tdivz += tdivz16stepu;
  1512. *                                zi += zi16stepu;
  1513. *                                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
  1514. *                                snext = (int)(sdivz * z) + sadjust;
  1515. *                                if (snext > bbextents)
  1516. *                                        snext = bbextents;
  1517. *                                else if (snext < 16)
  1518. *                                        snext = 16;      // prevent round-off error on <0 steps from
  1519. *                                                                //  from causing overstepping & running off the
  1520. *                                                                //  edge of the texture
  1521. *                                tnext = (int)(tdivz * z) + tadjust;
  1522. *                                if (tnext > bbextentt)
  1523. *                                        tnext = bbextentt;
  1524. *                                else if (tnext < 16)
  1525. *                                        tnext = 16;      // guard against round-off error on <0 steps
  1526. *                                sstep = (snext - s) >> 4;
  1527. *                                tstep = (tnext - t) >> 4;
  1528. *                        }
  1529.  
  1530.         fadd    fp3,fp0                 ;sdivz += sdivz16stepu
  1531.         fadd    fp4,fp1                 ;tdivz += tdivz16stepu
  1532.         fadd    fp5,fp2                 ;zi += zi16stepu
  1533.         fmove.s #65536,fp7
  1534.         fdiv    fp2,fp7                 ;z = (float)0x10000 / zi;
  1535.         fmove   fp7,fp6
  1536.         fmul    fp0,fp6                 ;fp2 = sdivz * z
  1537.         fmove.l fp6,d4                  ;convert to integer
  1538.         add.l   a5,d4                   ;snext = d4 + sadjust
  1539.         cmp.l   a4,d4                   ;if (snext > bbextents)
  1540.         bgt.b   .down3
  1541.         cmp.l   #16,d4                  ;if (snext < 16)
  1542.         bge.b   .keep3
  1543. .up3
  1544.         moveq   #16,d4                  ;snext = 16
  1545.         bra.b   .keep3
  1546. .down3
  1547.         move.l  a4,d4                   ;snext = bbextents
  1548. .keep3
  1549.         fmul    fp1,fp7                 ;fp7 = tdivz * z
  1550.         fmove.l fp7,d5                  ;convert to integer
  1551.         add.l   a3,d5                   ;tnext = d5 + tadjust
  1552.         cmp.l   a2,d5                   ;if (tnext > bbextentt)
  1553.         bgt.b   .down4
  1554.         cmp.l   #16,d5                  ;if (tnext < 16)
  1555.         bge.b   .keep4
  1556. .up4
  1557.         moveq   #16,d5                  ;tnext = 16
  1558.         bra.b   .keep4
  1559. .down4
  1560.         move.l  a2,d5                   ;tnext = bbextentt
  1561. .keep4
  1562.         move.l  d4,.saved4(sp)          ;save snext
  1563.         move.l  d5,.saved5(sp)          ;save tnext
  1564.         sub.l   d6,d4                   ;d4 = snext - s
  1565.         sub.l   d7,d5                   ;d5 = tnext - t
  1566.         asr.l   #4,d4                   ;sstep = d4 >> 4
  1567.         asr.l   #4,d5                   ;tstep = d5 >> 4
  1568.         bra.w   .mainloop
  1569.  
  1570.  
  1571. ******  Evaluation of the values for the inner loop. This version is used for
  1572. ******  span size < 16
  1573.  
  1574. ******  The original algorithm has two ugly divisions at the end of this part.
  1575. ******  These are removed by the following optimization:
  1576. ******  First, the divisors 1,2 and 4 are handled specially to gain speed. The
  1577. ******  other divisors are handled using a reciprocal table.
  1578.  
  1579. ******  a2  : bbextentt
  1580. ******  a3  : tadjust
  1581. ******  a4  : bbextents
  1582. ******  a5  : sadjust
  1583. ******  fp0 : sdivz
  1584. ******  fp1 : tdivz
  1585. ******  fp2 : zi
  1586.  
  1587. *                        // calculate s/z, t/z, zi->fixed s and t at last pixel in span (so
  1588. *                        // can't step off polygon), clamp, calculate s and t steps across
  1589. *                        // span by division, biasing steps low so we don't run off the
  1590. *                        // texture
  1591. *                                spancountminus1 = (float)(spancount - 1);
  1592. *                                sdivz += d_sdivzstepu * spancountminus1;
  1593. *                                tdivz += d_tdivzstepu * spancountminus1;
  1594. *                                zi += d_zistepu * spancountminus1;
  1595. *                                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
  1596. *                                snext = (int)(sdivz * z) + sadjust;
  1597. *                                if (snext > bbextents)
  1598. *                                        snext = bbextents;
  1599. *                                else if (snext < 16)
  1600. *                                        snext = 16;      // prevent round-off error on <0 steps from
  1601. *                                                                //  from causing overstepping & running off the
  1602. *                                                                //  edge of the texture
  1603. *
  1604. *                                tnext = (int)(tdivz * z) + tadjust;
  1605. *                                if (tnext > bbextentt)
  1606. *                                        tnext = bbextentt;
  1607. *                                else if (tnext < 16)
  1608. *                                        tnext = 16;      // guard against round-off error on <0 steps
  1609. *
  1610. *                                if (spancount > 1)
  1611. *                                {
  1612. *                                        sstep = (snext - s) / (spancount - 1);
  1613. *                                        tstep = (tnext - t) / (spancount - 1);
  1614. *                                }
  1615. *                        }
  1616.  
  1617. .finalpart
  1618.         fmove.l d2,fp7                  ;spancountminus1 = (float)(spancount-1)
  1619.         fmove   fp7,fp6
  1620.         fmul.s  .szstpu(sp),fp6         ;fp6 = d_sdivzstepu * spancountminus1
  1621.         fadd    fp6,fp0                 ;sdivz += fp6
  1622.         fmove   fp7,fp6
  1623.         fmul.s  .tzstpu(sp),fp6         ;fp6 = d_tdivzstepu * spancountminus1
  1624.         fadd    fp6,fp1                 ;tdivz += fp6
  1625.         fmul.s  .zistpu(sp),fp7         ;fp7 = d_zistepu * spancountminus1
  1626.         fadd    fp7,fp2                 ;zi += fp7
  1627.         fmove.s #65536,fp7
  1628.         fdiv    fp2,fp7                 ;z = (float)0x10000 / zi;
  1629.         fmove   fp7,fp6
  1630.         fmul    fp0,fp6                 ;fp6 = sdivz * z
  1631.         fmove.l fp6,d4                  ;convert to integer
  1632.         add.l   a5,d4                   ;snext = d4 + sadjust
  1633.         cmp.l   a4,d4                   ;if (snext > bbextents)
  1634.         bgt.b   .down5
  1635.         cmp.l   #16,d4                  ;if (snext < 16)
  1636.         bge.b   .keep5
  1637. .up5
  1638.         moveq   #16,d4                  ;snext = 16
  1639.         bra.b   .keep5
  1640. .down5
  1641.         move.l  a4,d4                   ;snext = bbextents
  1642. .keep5
  1643.         fmul    fp1,fp7                 ;fp7 = tdivz * z
  1644.         fmove.l fp7,d5                  ;convert to integer
  1645.         add.l   a3,d5                   ;tnext = d5 + tadjust
  1646.         cmp.l   a2,d5                   ;if (tnext > bbextentt)
  1647.         bgt.b   .down6
  1648.         cmp.l   #16,d5                  ;if (tnext < 16)
  1649.         bge.b   .keep6
  1650. .up6
  1651.         moveq   #16,d5                  ;tnext = 16
  1652.         bra.b   .keep6
  1653. .down6
  1654.         move.l  a2,d5                   ;tnext = bbextentt
  1655. .keep6
  1656.         move.l  d4,.saved4(sp)          ;save snext
  1657.         move.l  d5,.saved5(sp)          ;save tnext
  1658.         sub.l   d6,d4                   ;d4 = snext - s
  1659.         sub.l   d7,d5                   ;d5 = tnext - t
  1660.         IFEQ    QDIV
  1661.         tst.l   d2
  1662.         beq.w   .mainloop
  1663.         divs.l  d2,d4
  1664.         divs.l  d2,d5
  1665.         ELSEIF
  1666.         cmp     #5,d2                   ;(spancount-1) < 5?
  1667.         blt.b   .special                ;yes -> special case
  1668.         cmp     #8,d2
  1669.         beq.b   .spec_8
  1670. .qdiv
  1671.         IFNE    NICE_DIV
  1672.         lsl.l   #2,d4
  1673.         lsl.l   #2,d5
  1674.         lea     ReciprocTable,a6
  1675.         move    0(a6,d2.w*2),d0
  1676.         move.l  d4,d3
  1677.         mulu    d0,d3
  1678.         clr     d3
  1679.         swap    d3
  1680.         swap    d4
  1681.         muls    d0,d4
  1682.         add.l   d3,d4
  1683.         move.l  d5,d3
  1684.         mulu    d0,d3
  1685.         clr     d3
  1686.         swap    d3
  1687.         swap    d5
  1688.         muls    d0,d5
  1689.         add.l   d3,d5
  1690.         bra.b   .mainloop
  1691.         ELSEIF
  1692.         asr.l   #7,d4                   ;d4 >> 7
  1693.         asr.l   #7,d5                   ;d5 >> 7
  1694.         lea     ReciprocTable,a6        ;a6 -> reciprocal table
  1695.         move    0(a6,d2.w*2),d0         ;d0 = (1/(spancount-1))<<16
  1696.         muls    d0,d4                   ;d4 = d4 / (spancount-1)
  1697.         asr.l   #7,d4                   ;sstep = d4 >> 7
  1698.         muls    d0,d5                   ;d5 = d5 / (spancount-1)
  1699.         asr.l   #7,d5                   ;tstep = d5 >> 7
  1700.         bra.b   .mainloop
  1701.         ENDC
  1702. .special
  1703.         cmp     #1,d2                   ;switch (spancount-1)
  1704.         ble.b   .mainloop               ;0,1 -> no scaling needed
  1705.         cmp     #3,d2                   ;3 -> standard qdiv
  1706.         beq.b   .qdiv
  1707.         blt.b   .spec_2
  1708.         asr.l   #2,d4                   ;4 -> scale by shifting right
  1709.         asr.l   #2,d5
  1710.         bra.b   .mainloop
  1711. .spec_8
  1712.         asr.l   #3,d4                   ;8 -> scale by shifting right
  1713.         asr.l   #3,d5
  1714.         bra.b   .mainloop
  1715. .spec_2
  1716.         asr.l   #1,d4                   ;2 -> scale by shifting right
  1717.         asr.l   #1,d5
  1718.         ENDC
  1719.  
  1720. ******  Main drawing loop. Here lies the speed.
  1721. ******  Very optimized (removed multiplication from inner loop)
  1722.  
  1723. ******  d2 : spancount
  1724. ******  d4 : sstep
  1725. ******  d5 : tstep
  1726. ******  d6 : s
  1727. ******  d7 : t
  1728. ******  a0 : pdest
  1729. ******  a1 : pbase
  1730.  
  1731. *                        do
  1732. *                        {
  1733. *                                *pdest++ = *(pbase + (s >> 16) + (t >> 16) * cachewidth);
  1734. *                                s += sstep;
  1735. *                                t += tstep;
  1736. *                        } while (--spancount > 0);
  1737.  
  1738. .mainloop
  1739.         move.l  d1,-(sp)
  1740.         lea     .PixTable,a6            ;a6 -> Functable
  1741.         move.l  _cachewidth,d3          ;read cachewidth
  1742.         move.l  0(a6,d2.w*4),a6         ;get pointer to function
  1743.         swap    d7
  1744.         swap    d4
  1745.         move.l  d7,d1
  1746.         swap    d5
  1747.         muls    d3,d7                   ;d7 = t integer part * cachewidth
  1748.         move    d5,d2
  1749.         clr     d1                      ;d1 = t fractional part
  1750.         muls    d3,d2                   ;tstep integer part * cachewidth
  1751.         move    d4,d0                   ;d0 = sstep integer part
  1752.         clr     d5                      ;d5 = tstep fractional part
  1753.         clr     d4                      ;d4 = sstep fractional part
  1754.         swap    d6                      ;d6 = s swapped
  1755.         jmp     (a6)
  1756. .Pix16
  1757.         lea     0(a1,d6.w),a6
  1758.         move.b  0(a6,d7.l),(a0)+
  1759.         add.l   d4,d6                   ;increment s fractional part
  1760.         addx.w  d0,d6                   ;increment s integer part
  1761.         add.l   d2,d7                   ;increment t integer part
  1762.         add.l   d5,d1                   ;increment t fractional part
  1763.         bcc.b   .Pix15                   ;check if carry
  1764.         add.l   d3,d7                   ;add cachewidth to t
  1765. .Pix15
  1766.         lea     0(a1,d6.w),a6           ;and so long...
  1767.         move.b  0(a6,d7.l),(a0)+
  1768.         add.l   d4,d6
  1769.         addx.w  d0,d6
  1770.         add.l   d2,d7
  1771.         add.l   d5,d1
  1772.         bcc.b   .Pix14
  1773.         add.l   d3,d7
  1774. .Pix14
  1775.         lea     0(a1,d6.w),a6
  1776.         move.b  0(a6,d7.l),(a0)+
  1777.         add.l   d4,d6
  1778.         addx.w  d0,d6
  1779.         add.l   d2,d7
  1780.         add.l   d5,d1
  1781.         bcc.b   .Pix13
  1782.         add.l   d3,d7
  1783. .Pix13
  1784.         lea     0(a1,d6.w),a6
  1785.         move.b  0(a6,d7.l),(a0)+
  1786.         add.l   d4,d6
  1787.         addx.w  d0,d6
  1788.         add.l   d2,d7
  1789.         add.l   d5,d1
  1790.         bcc.b   .Pix12
  1791.         add.l   d3,d7
  1792. .Pix12
  1793.         lea     0(a1,d6.w),a6
  1794.         move.b  0(a6,d7.l),(a0)+
  1795.         add.l   d4,d6
  1796.         addx.w  d0,d6
  1797.         add.l   d2,d7
  1798.         add.l   d5,d1
  1799.         bcc.b   .Pix11
  1800.         add.l   d3,d7
  1801. .Pix11
  1802.         lea     0(a1,d6.w),a6
  1803.         move.b  0(a6,d7.l),(a0)+
  1804.         add.l   d4,d6
  1805.         addx.w  d0,d6
  1806.         add.l   d2,d7
  1807.         add.l   d5,d1
  1808.         bcc.b   .Pix10
  1809.         add.l   d3,d7
  1810. .Pix10
  1811.         lea     0(a1,d6.w),a6
  1812.         move.b  0(a6,d7.l),(a0)+
  1813.         add.l   d4,d6
  1814.         addx.w  d0,d6
  1815.         add.l   d2,d7
  1816.         add.l   d5,d1
  1817.         bcc.b   .Pix9
  1818.         add.l   d3,d7
  1819. .Pix9
  1820.         lea     0(a1,d6.w),a6
  1821.         move.b  0(a6,d7.l),(a0)+
  1822.         add.l   d4,d6
  1823.         addx.w  d0,d6
  1824.         add.l   d2,d7
  1825.         add.l   d5,d1
  1826.         bcc.b   .Pix8
  1827.         add.l   d3,d7
  1828. .Pix8
  1829.         lea     0(a1,d6.w),a6
  1830.         move.b  0(a6,d7.l),(a0)+
  1831.         add.l   d4,d6
  1832.         addx.w  d0,d6
  1833.         add.l   d2,d7
  1834.         add.l   d5,d1
  1835.         bcc.b   .Pix7
  1836.         add.l   d3,d7
  1837. .Pix7
  1838.         lea     0(a1,d6.w),a6
  1839.         move.b  0(a6,d7.l),(a0)+
  1840.         add.l   d4,d6
  1841.         addx.w  d0,d6
  1842.         add.l   d2,d7
  1843.         add.l   d5,d1
  1844.         bcc.b   .Pix6
  1845.         add.l   d3,d7
  1846. .Pix6
  1847.         lea     0(a1,d6.w),a6
  1848.         move.b  0(a6,d7.l),(a0)+
  1849.         add.l   d4,d6
  1850.         addx.w  d0,d6
  1851.         add.l   d2,d7
  1852.         add.l   d5,d1
  1853.         bcc.b   .Pix5
  1854.         add.l   d3,d7
  1855. .Pix5
  1856.         lea     0(a1,d6.w),a6
  1857.         move.b  0(a6,d7.l),(a0)+
  1858.         add.l   d4,d6
  1859.         addx.w  d0,d6
  1860.         add.l   d2,d7
  1861.         add.l   d5,d1
  1862.         bcc.b   .Pix4
  1863.         add.l   d3,d7
  1864. .Pix4
  1865.         lea     0(a1,d6.w),a6
  1866.         move.b  0(a6,d7.l),(a0)+
  1867.         add.l   d4,d6
  1868.         addx.w  d0,d6
  1869.         add.l   d2,d7
  1870.         add.l   d5,d1
  1871.         bcc.b   .Pix3
  1872.         add.l   d3,d7
  1873. .Pix3
  1874.         lea     0(a1,d6.w),a6
  1875.         move.b  0(a6,d7.l),(a0)+
  1876.         add.l   d4,d6
  1877.         addx.w  d0,d6
  1878.         add.l   d2,d7
  1879.         add.l   d5,d1
  1880.         bcc.b   .Pix2
  1881.         add.l   d3,d7
  1882. .Pix2
  1883.         lea     0(a1,d6.w),a6
  1884.         move.b  0(a6,d7.l),(a0)+
  1885.         add.l   d4,d6
  1886.         addx.w  d0,d6
  1887.         add.l   d2,d7
  1888.         add.l   d5,d1
  1889.         bcc.b   .Pix1
  1890.         add.l   d3,d7
  1891. .Pix1
  1892.         lea     0(a1,d6.w),a6
  1893.         move.b  0(a6,d7.l),(a0)+
  1894.         add.l   d4,d6
  1895.         addx.w  d0,d6
  1896.         add.l   d2,d7
  1897.         add.l   d5,d1
  1898.         bcc.b   .Pix0
  1899.         add.l   d3,d7
  1900. .Pix0
  1901.         move.l  (sp)+,d1
  1902.  
  1903. ******  loop terminations
  1904.  
  1905.  
  1906.         move.l   .saved5(sp),d7         ;t = tnext
  1907.         move.l   .saved4(sp),d6         ;s = snext
  1908.  
  1909.         tst.l   d1                      ;while (count > 0)
  1910.         bgt.w   .loop2
  1911.  
  1912.         move.l  .savea6(sp),a6          ;while ((pspan = pspan->next) != NULL)
  1913.         move.l  PSPAN_NEXT(a6),a6
  1914.         tst.l   a6
  1915.         bne.w   .loop
  1916.         add.l   #.fpuregs,sp
  1917.         fmovem.x        (sp)+,fp2-fp7
  1918.         movem.l (sp)+,d2-d7/a2-a6
  1919.         rts
  1920.  
  1921. .PixTable
  1922.         dc.l    .Pix1
  1923.         dc.l    .Pix2
  1924.         dc.l    .Pix3
  1925.         dc.l    .Pix4
  1926.         dc.l    .Pix5
  1927.         dc.l    .Pix6
  1928.         dc.l    .Pix7
  1929.         dc.l    .Pix8
  1930.         dc.l    .Pix9
  1931.         dc.l    .Pix10
  1932.         dc.l    .Pix11
  1933.         dc.l    .Pix12
  1934.         dc.l    .Pix13
  1935.         dc.l    .Pix14
  1936.         dc.l    .Pix15
  1937.         dc.l    .Pix16
  1938.  
  1939.  
  1940.  
  1941.  
  1942.  
  1943.  
  1944.  
  1945.  
  1946.  
  1947. ******************************************************************************
  1948. *
  1949. *       void D_DrawZSpans (espan_t *pspan)
  1950. *
  1951. *       standard z-scan drawing function
  1952. *
  1953. ******************************************************************************
  1954.  
  1955.         cnop    0,4
  1956. _D_DrawZSpans
  1957.  
  1958.  
  1959. ******  Prologue. Global variables are put into registers or onto the stack
  1960.  
  1961. *****   stackframe
  1962.  
  1963.         rsreset
  1964. .fpuregs        rs.x    5
  1965. .intregs        rs.l    7
  1966.         rs.l    1
  1967. .pspan          rs.l    1
  1968.  
  1969.         movem.l d2-d7/a2,-(sp)
  1970.         fmovem.x        fp3-fp7,-(sp)
  1971.         move.l  .pspan(sp),a2
  1972.         move.l  _d_pzbuffer,a0
  1973.         move.l  _d_zwidth,d7
  1974.         fmove.s _d_ziorigin,fp5
  1975.         fmove.s _d_zistepv,fp6
  1976.         fmove.s _d_zistepu,fp7
  1977.         fmove.s #32768*65536,fp0
  1978.  
  1979. *        izistep = (int)(d_zistepu * 0x8000 * 0x10000);
  1980.  
  1981.         fmove   fp7,fp1                 ;fp1 = d_zistepu
  1982.         fmul    fp0,fp1                 ;multiply by $8000*$10000
  1983.         fmove.l fp1,d4                  ;izistep = d4
  1984.         moveq   #16,d6
  1985.  
  1986. *                pdest = d_pzbuffer + (d_zwidth * pspan->v) + pspan->u;
  1987. *
  1988. *                count = pspan->count;
  1989. *
  1990. *        // calculate the initial 1/z
  1991. *                du = (float)pspan->u;
  1992. *                dv = (float)pspan->v;
  1993. *
  1994. *                zi = d_ziorigin + dv*d_zistepv + du*d_zistepu;
  1995. *        // we count on FP exceptions being turned off to avoid range problems
  1996. *                izi = (int)(zi * 0x8000 * 0x10000);
  1997.  
  1998.  
  1999. .loop
  2000.         move.l  (a2)+,d0
  2001.         fmove   fp7,fp4
  2002.         fmul.l  d0,fp4                  ;fp4 = du * d_zistepu
  2003.         move.l  (a2)+,d1
  2004.         fmove   fp6,fp3
  2005.         fmul.l  d1,fp3                  ;fp3 = dv * d_zistepv
  2006.         move.l  (a2)+,d2
  2007.         fadd    fp3,fp4
  2008.         muls    d7,d1                   ;d1 = pspan->v * d_zwidth
  2009.         fadd    fp5,fp4                 ;fp4 = d_ziorigin + fp3 + fp4
  2010.         add.l   d0,d1                   ;d1 = d1 + pspan->u
  2011.         lea     0(a0,d1.l*2),a1         ;pdest = d_pzbuffer + d1
  2012.         fmul    fp0,fp4                 ;izi = zi * $8000 * $10000
  2013.         fmove.l fp4,d3                  ;convert to integer
  2014.  
  2015. *                if ((long)pdest & 0x02)
  2016. *                {
  2017. *                        *pdest++ = (short)(izi >> 16);
  2018. *                        izi += izistep;
  2019. *                        count--;
  2020. *                }
  2021.  
  2022.         move.l  a1,d0                   ;if ((long)pdest & 0x02)
  2023.         and.l   #2,d0
  2024.         beq.b   .cont
  2025.         swap    d3
  2026.         move    d3,(a1)+                ;*pdest++ = (short)(izi>>16)
  2027.         swap    d3
  2028.         add.l   d4,d3                   ;izi += izistep;
  2029.         subq    #1,d2                   ;count--
  2030. .cont
  2031.  
  2032. *                if ((doublecount = count >> 1) > 0)
  2033. *                {
  2034. *                        do
  2035. *                        {
  2036. *                                ltemp = izi >> 16;
  2037. *                                izi += izistep;
  2038. *                                ltemp |= izi & 0xFFFF0000;
  2039. *                                izi += izistep;
  2040. *                                *(int *)pdest = ltemp;
  2041. *                                pdest += 2;
  2042. *                        } while (--doublecount > 0);
  2043. *                }
  2044.  
  2045.         move.l  d2,d0                   ;if ((doublecount=count>>1)>0)
  2046.         asr.l   #1,d0
  2047.         ble.b   .cont2
  2048.         subq    #1,d0
  2049. .loop2
  2050.         move.l  d3,d5
  2051.         lsr.l   d6,d5                   ;temp = izi >> 16
  2052.         add.l   d4,d3                   ;izi += izistep
  2053.         move.l  d3,d1
  2054.         and.l   #$ffff0000,d1
  2055.         or.l    d1,d5                   ;ltemp |= izi & 0xFFFF0000
  2056.         add.l   d4,d3                   ;izi += izistep
  2057.         move.l  d5,(a1)+                ;*(int *)pdest = ltemp
  2058.         dbra    d0,.loop2               ;while (--doublecount > 0)
  2059. .cont2
  2060.  
  2061. *                if (count & 1)
  2062. *                        *pdest = (short)(izi >> 16);
  2063.  
  2064.         and.l   #$1,d2                  ;if (count & 1)
  2065.         beq.b   .cont3
  2066.         swap    d3
  2067.         move    d3,(a1)+                ;*pdest = (short)(izi >> 16)
  2068. .cont3
  2069.  
  2070. *        } while ((pspan = pspan->pnext) != NULL);
  2071.  
  2072.         move.l  (a2)+,a2
  2073.         tst.l   a2
  2074.         bne.w   .loop
  2075.         fmovem.x        (sp)+,fp3-fp7
  2076.         movem.l (sp)+,d2-d7/a2
  2077.         rts
  2078.  
  2079. ReciprocTable
  2080.         dc.w    0
  2081.         dc.w    0
  2082.         dc.w    0
  2083.         dc.w    16384/3
  2084.         dc.w    0
  2085.         dc.w    16384/5
  2086.         dc.w    16384/6
  2087.         dc.w    16384/7
  2088.         dc.w    0
  2089.         dc.w    16384/9
  2090.         dc.w    16384/10
  2091.         dc.w    16384/11
  2092.         dc.w    16384/12
  2093.         dc.w    16384/13
  2094.         dc.w    16384/14
  2095.         dc.w    16384/15
  2096. _SysBase        dc.l    0
  2097.