home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 113 / EnigmaAmiga113CD.iso / software / sviluppo / quakeworld_src / client / d_polyset68k.s < prev    next >
Encoding:
Text File  |  2000-06-17  |  55.1 KB  |  1,974 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_polyset.c assembler implementations by Frank Wille <frank@phoenix.owl.de>
  23. **
  24.  
  25.         XREF    _acolormap
  26.         XREF    _d_aspancount
  27.         XREF    _errorterm
  28.         XREF    _erroradjustup
  29.         XREF    _erroradjustdown
  30.         XREF    _d_countextrastep
  31.         XREF    _ubasestep
  32.         XREF    _r_affinetridesc
  33.         XREF    _a_ststepxwhole
  34.         XREF    _a_sstepxfrac
  35.         XREF    _a_tstepxfrac
  36.         XREF    _r_lstepx
  37.         XREF    _r_lstepy
  38.         XREF    _r_sstepx
  39.         XREF    _r_sstepy
  40.         XREF    _r_tstepx
  41.         XREF    _r_tstepy
  42.         XREF    _r_zistepx
  43.         XREF    _r_zistepy
  44.         XREF    _zspantable
  45.         XREF    _skintable
  46.         XREF    _r_p0
  47.         XREF    _r_p1
  48.         XREF    _r_p2
  49.         XREF    _d_xdenom
  50.         XREF    _d_pcolormap
  51.         XREF    _d_scantable
  52.         XREF    _d_viewbuffer
  53.         XREF    _d_pedgespanpackage
  54.         XREF    _d_pdest
  55.         XREF    _d_pz
  56.         XREF    _d_aspancount
  57.         XREF    _d_ptex
  58.         XREF    _d_sfrac
  59.         XREF    _d_tfrac
  60.         XREF    _d_light
  61.         XREF    _d_zi
  62.         XREF    _d_pdestextrastep
  63.         XREF    _d_pzextrastep
  64.         XREF    _d_countextrastep
  65.         XREF    _d_ptexextrastep
  66.         XREF    _d_sfracextrastep
  67.         XREF    _d_tfracextrastep
  68.         XREF    _d_lightextrastep
  69.         XREF    _d_ziextrastep
  70.         XREF    _d_pdestbasestep
  71.         XREF    _d_pzbasestep
  72.         XREF    _d_ptexbasestep
  73.         XREF    _d_sfracbasestep
  74.         XREF    _d_tfracbasestep
  75.         XREF    _d_lightbasestep
  76.         XREF    _d_zibasestep
  77.         XREF    _d_zwidth
  78.         XREF    _d_pzbuffer
  79.         XREF    _a_spans
  80.         XREF    _pedgetable
  81.         XREF    _edgetables
  82.         XREF    _screenwidth
  83.         XREF    _FloorDivMod
  84.  
  85.         XDEF    _D_DrawNonSubdiv
  86.         XDEF    _D_PolysetRecursiveTriangle
  87.         XDEF    _D_RasterizeAliasPolySmooth
  88.  
  89. ALIAS_ONSEAM            =       $20             ;must match the def. in r_shared.h
  90.  
  91. PSPANP_PDEST            =       0
  92. PSPANP_PZ               =       4
  93. PSPANP_COUNT            =       8
  94. PSPANP_PTEX             =       12
  95. PSPANP_SFRAC            =       16
  96. PSPANP_TFRAC            =       20
  97. PSPANP_LIGHT            =       24
  98. PSPANP_ZI               =       28
  99. PSPANP_SIZEOF           =       32
  100. PSPANP_SIZEOF_EXP       =       5
  101.  
  102. R_PSKIN                 =       0
  103. R_PSKINDESC             =       4
  104. R_SKINWIDTH             =       8
  105. R_SKINHEIGHT            =       12
  106. R_PTRIANGLES            =       16
  107. R_PFINALVERTS           =       20
  108. R_NUMTRIANGLES          =       24
  109. R_DRAWTYPE              =       28
  110. R_SEAMFIXUP16           =       32
  111. R_SIZEOF                =       36
  112.  
  113. PTEMP_QUOTIENT          =       0
  114. PTEMP_REMAINDER         =       4
  115.  
  116. ETAB_ISFLATTOP          =       0
  117. ETAB_NUMLEFTEDGES       =       4
  118. ETAB_PLEV0              =       8
  119. ETAB_PLEV1              =       12
  120. ETAB_PLEV2              =       16
  121. ETAB_NUMRIGHTEDGES      =       20
  122. ETAB_PREV0              =       24
  123. ETAB_PREV1              =       28
  124. ETAB_PREV2              =       32
  125. ETAB_SIZEOF             =       36
  126.  
  127. MT_FACESFRONT           =       0
  128. MT_VERTINDEX            =       4
  129. MT_SIZEOF               =       16
  130.  
  131. FV_V                    =       0
  132. FV_FLAGS                =       24
  133. FV_RESERVED             =       28
  134. FV_SIZEOF               =       32
  135. FV_SIZEOF_EXP           =       5
  136.  
  137. EDGETABLE_SIZEOF        =       36
  138.  
  139. ******************************************************************************
  140. *
  141. *       void D_PolysetDrawSpans8 (spanpackage_t *pspanpackage)
  142. *
  143. *       standard scan drawing function for alias models
  144. *
  145. ******************************************************************************
  146.  
  147.         cnop    0,4
  148. _D_PolysetDrawSpans8
  149.  
  150.  
  151. *****   stackframe
  152.  
  153.         rsreset
  154. .intregs        rs.l    11
  155.         rs.l    1
  156. .pspan          rs.l    1
  157.  
  158.  
  159. ****** prologue
  160.  
  161.         movem.l d2-d7/a2-a6,-(sp)
  162.         move.l  .pspan(sp),a0
  163.         move.l  _d_aspancount,d0
  164.         move.l  _errorterm,d1
  165.         move.l  _erroradjustup,d2
  166.         move.l  _erroradjustdown,d3
  167.         move.l  _d_countextrastep,a1
  168.         move.l  _ubasestep,d5
  169.         move.l  _acolormap,a3
  170.         move.l  _r_zistepx,d4
  171.         move.l  _a_ststepxwhole,a5
  172.         move.l  _a_sstepxfrac,a4
  173.         move.l  _a_tstepxfrac,d6
  174.         swap    d6
  175.         move.l  _r_lstepx,a6
  176.         move.l  _r_affinetridesc+R_SKINWIDTH,d7
  177.         move    d7,d6
  178. .loop
  179.  
  180. *                lcount = d_aspancount - pspanpackage->count;
  181. *
  182. *                errorterm += erroradjustup;
  183. *                if (errorterm >= 0)
  184. *                {
  185. *                        d_aspancount += d_countextrastep;
  186. *                        errorterm -= erroradjustdown;
  187. *                }
  188. *                else
  189. *                {
  190. *                        d_aspancount += ubasestep;
  191. *                }
  192.  
  193.         move.l  d0,d7
  194.         sub.l   PSPANP_COUNT(a0),d7     ;lcount = d_aspancount-pspa...
  195.         add.l   d2,d1                   ;errorterm += erroradjustup
  196.         blt.b   .else                   ;if (errorterm >= 0)
  197.         add.l   a1,d0                   ;d_aspancount += d_countextrastep
  198.         sub.l   d3,d1                   ;errorterm -= error adjustdown
  199.         bra.b   .next
  200. .else
  201.         add.l   d5,d0                   ;d_aspancount += ubasestep
  202. .next
  203.         subq.l  #1,d7
  204.         blt.b   .loopend
  205.  
  206. *                        lpdest = pspanpackage->pdest;
  207. *                        lptex = pspanpackage->ptex;
  208. *                        lpz = pspanpackage->pz;
  209. *                        lsfrac = pspanpackage->sfrac;
  210. *                        ltfrac = pspanpackage->tfrac;
  211. *                        llight = pspanpackage->light;
  212. *                        lzi = pspanpackage->zi;
  213.  
  214.         movem.l d0-d3/d5/a0/a1,-(sp)
  215.         move.l  (a0)+,d2                ;lpdest = pspanpackage->dest
  216.         move.l  (a0)+,a1                ;lpz = pspanpackage->pz
  217.         addq.l  #4,a0
  218.         move.l  (a0)+,a2                ;lptex = pspanpackage->ptex
  219.         move.l  (a0)+,d3                ;lsfrac = pspanpackage->sfrac
  220.         move.l  (a0)+,d5                ;tsfrac = pspanpackage->tfrac
  221.         swap    d5
  222.         move.l  (a0)+,d1                ;llight = pspanpackage->light
  223.         move.l  (a0)+,d0                ;lzi = pspanpackage->zi
  224.         move.l  d2,a0
  225.         moveq   #0,d2
  226.  
  227. ****** main drawing loop
  228.  
  229. ****** d0 = lzi
  230. ****** d1 = llight
  231. ****** d3 = lsfrac
  232. ****** d4 = r_zistepx
  233. ****** d5 = ltfrac
  234. ****** d6 = a_tstepxfrac [high] and r_affinetridesc.skinwidth [low]
  235. ****** d7 = lcount-1
  236. ****** a0 -> lpdest
  237. ****** a1 -> lpz
  238. ****** a2 -> lptex
  239. ****** a3 -> acolormap
  240. ****** a4 = a_sstepxfrac
  241. ****** a5 = a_ststepxwhole
  242. ****** a6 = r_lstepx
  243.  
  244. *                        do
  245. *                        {
  246. *                                if ((lzi >> 16) >= *lpz)
  247. *                                {
  248. *                                        *lpdest = ((byte *)acolormap)[*lptex + (llight & 0xFF00)];
  249. *                                        *lpz = lzi >> 16;
  250. *                                }
  251. *                                lpdest++;
  252. *                                lzi += r_zistepx;
  253. *                                lpz++;
  254. *                                llight += r_lstepx;
  255. *                                lptex += a_ststepxwhole;
  256. *                                lsfrac += a_sstepxfrac;
  257. *                                lptex += lsfrac >> 16;
  258. *                                lsfrac &= 0xFFFF;
  259. *                                ltfrac += a_tstepxfrac;
  260. *                                if (ltfrac & 0x10000)
  261. *                                {
  262. *                                        lptex += r_affinetridesc.skinwidth;
  263. *                                        ltfrac &= 0xFFFF;
  264. *                                }
  265. *                        } while (--lcount);
  266.  
  267. .loop2
  268.         swap    d0
  269.         cmp     (a1)+,d0                ;if ((lzi >> 16) >= *lpz)
  270.         blt.b   .cont
  271.         move    d1,d2
  272.         move.b  (a2),d2                 ;d3 = *lptex + (llight & $ff00)
  273.         move.b  0(a3,d2.l),(a0)         ;*lpdest = ((byte *)acolormap[d2]
  274.         move    d0,-2(a1)               ;*lpz = lzi >> 16
  275. .cont
  276.         addq.l  #1,a0                   ;lpdest++
  277.         swap    d0
  278.         add.l   d4,d0                   ;lzi += r_zistepx
  279.         add.l   a6,d1                   ;llight += r_lstepx
  280.         add.l   a5,a2                   ;lptex += a_ststepxwhole
  281.         add.l   a4,d3                   ;lsfrac += a_sstepxfrac
  282.         swap    d3
  283.         add     d3,a2                   ;lptex += lsfrac >> 16
  284.         clr     d3
  285.         swap    d3                      ;lsfrac &= $ffff
  286.         add.l   d6,d5                   ;ltfrac += a_tstepxfrac
  287.         bcc.b   .cont2                  ;if (ltfrac & $10000)
  288.         add     d6,a2                   ;lptex += r_affine...
  289. .cont2
  290.         dbra    d7,.loop2               ;while (--lcount)
  291.         movem.l (sp)+,d0-d3/d5/a0/a1
  292. .loopend
  293.  
  294. *                pspanpackage++;
  295. *        } while (pspanpackage->count != -999999);
  296.  
  297.         lea     PSPANP_SIZEOF(a0),a0    ;pspanpackage++
  298.         cmp.l   #-999999,PSPANP_COUNT(a0) ; while (pspanpackage->count...)
  299.         bne.b   .loop
  300.         movem.l (sp)+,d2-d7/a2-a6
  301.         rts
  302.  
  303.  
  304.  
  305.  
  306.  
  307.  
  308.  
  309.  
  310.  
  311. ******************************************************************************
  312. *
  313. *       void D_PolysetRecursiveTriangle (int *lp1, int *lp2, int *lp3)
  314. *
  315. ******************************************************************************
  316.  
  317.         cnop    0,4
  318. _D_PolysetRecursiveTriangle
  319.  
  320.  
  321. *****   stackframe
  322.  
  323.         rsreset
  324. .new            rs.l    6
  325. .intregs        rs.l    11
  326.         rs.l    1
  327. .lp1            rs.l    1
  328. .lp2            rs.l    1
  329. .lp3            rs.l    1
  330.  
  331.  
  332.         movem.l d2-d7/a2-a6,-(sp)
  333.         sub.l   #.intregs,sp
  334.         move.l  .lp1(sp),a0
  335.         move.l  .lp2(sp),a1
  336.         move.l  .lp3(sp),a2
  337.         lea     _zspantable,a5
  338.         move.l  _d_viewbuffer,a6
  339.         bsr     DoRecursion
  340.         add.l   #.intregs,sp
  341.         movem.l (sp)+,d2-d7/a2-a6
  342.         rts
  343.  
  344. ****** a0 -> lp1
  345. ****** a1 -> lp2
  346. ****** a2 -> lp3
  347.  
  348. DoRecursion
  349.         lea     -6*4(sp),sp
  350.         move.l  sp,a4
  351.  
  352. *        d = lp2[0] - lp1[0];
  353. *        if (d < -1 || d > 1)
  354. *                goto split;
  355. *        d = lp2[1] - lp1[1];
  356. *        if (d < -1 || d > 1)
  357. *                goto split;
  358. *
  359. *        d = lp3[0] - lp2[0];
  360. *        if (d < -1 || d > 1)
  361. *                goto split2;
  362. *        d = lp3[1] - lp2[1];
  363. *        if (d < -1 || d > 1)
  364. *                goto split2;
  365. *
  366. *        d = lp1[0] - lp3[0];
  367. *        if (d < -1 || d > 1)
  368. *                goto split3;
  369. *        d = lp1[1] - lp3[1];
  370. *        if (d < -1 || d > 1)
  371.  
  372.         move.l  (a1),d0
  373.         move.l  (a0),d1
  374.         move.l  1*4(a1),d2
  375.         move.l  1*4(a0),d3
  376.         move.l  d0,d4
  377.         sub.l   d1,d4                   ;d = lp2[0] - lp1[0]
  378.         addq.l  #1,d4
  379.         cmp.l   #2,d4                   ;if (d < -1 || d > 1)
  380.         bhi.b   .split                  ;goto split
  381.         move.l  d2,d5
  382.         sub.l   d3,d5                   ;d = lp2[1] - lp1[1]
  383.         addq.l  #1,d5
  384.         cmp.l   #2,d5                   ;if (d < -1 || d > 1)
  385.         bhi.b   .split                  ;goto split
  386.         move.l  (a2),d4
  387.         move.l  d4,d5
  388.         sub.l   d0,d4                   ;d = lp3[0] - lp2[0]
  389.         addq.l  #1,d4
  390.         cmp.l   #2,d4                   ;if (d < -1 || d > 1)
  391.         bhi.b   .split2                 ;goto split2
  392.         move.l  1*4(a2),d4
  393.         move.l  d4,d6
  394.         sub.l   d2,d4                   ;d = lp3[1] - lp2[1]
  395.         addq.l  #1,d4
  396.         cmp.l   #2,d4                   ;if (d < -1 || d > 1)
  397.         bhi.b   .split2                 ;goto split2
  398.         sub.l   d1,d5                   ;d = lp1[0] - lp3[0]
  399.         addq.l  #1,d5
  400.         cmp.l   #2,d5                   ;if (d < -1 || d > 1)
  401.         bhi.b   .split3                 ;goto split3
  402.         sub.l   d3,d6                   ;d = lp1[1] - lp3[1]
  403.         addq.l  #1,d6
  404.         cmp.l   #2,d6                   ;if (d < -1 || d > 1)
  405.         bls.b   .exit
  406.  
  407. *split3:
  408. *                temp = lp1;
  409. *                lp1 = lp3;
  410. *                lp3 = lp2;
  411. *                lp2 = temp;
  412. *
  413. *                goto split;
  414. *
  415. *split2:
  416. *        temp = lp1;
  417. *        lp1 = lp2;
  418. *        lp2 = lp3;
  419. *        lp3 = temp;
  420.  
  421. .split3
  422.         exg     a1,a2                   ;rotate forward
  423.         exg     a1,a0
  424.         move.l  (a1),d0
  425.         move.l  (a0),d1
  426.         move.l  1*4(a1),d2
  427.         move.l  1*4(a0),d3
  428.         bra.b   .split
  429. .split2
  430.         exg     a1,a0                   ;rotate backward
  431.         exg     a1,a2
  432.         move.l  (a1),d0
  433.         move.l  (a0),d1
  434.         move.l  1*4(a1),d2
  435.         move.l  1*4(a0),d3
  436. .split
  437.  
  438. *        new[0] = (lp1[0] + lp2[0]) >> 1;
  439. *        new[1] = (lp1[1] + lp2[1]) >> 1;
  440. *        new[2] = (lp1[2] + lp2[2]) >> 1;
  441. *        new[3] = (lp1[3] + lp2[3]) >> 1;
  442. *        new[5] = (lp1[5] + lp2[5]) >> 1;
  443.  
  444.         move.l  d0,d4
  445.         move.l  d0,a3
  446.         add.l   d1,d4
  447.         asr.l   #1,d4                   ;d4 = new[0]
  448.         move.l  d2,d5
  449.         add.l   d3,d5
  450.         asr.l   #1,d5                   ;d5 = new[1]
  451.         move.l  2*4(a0),d6
  452.         add.l   2*4(a1),d6
  453.         asr.l   #1,d6                   ;d6 = new[2]
  454.         move.l  3*4(a0),d7
  455.         add.l   3*4(a1),d7
  456.         asr.l   #1,d7                   ;d7 = new[3]
  457.         move.l  5*4(a0),d0
  458.         add.l   5*4(a1),d0
  459.         asr.l   #1,d0                   ;d0 = new[5]
  460.  
  461. *        if (lp2[1] > lp1[1])
  462. *                goto nodraw;
  463. *        if ((lp2[1] == lp1[1]) && (lp2[0] < lp1[0]))
  464. *                goto nodraw;
  465.  
  466.         move.l  d4,(a4)+                ;store new[]
  467.         move.l  d5,(a4)+
  468.         move.l  d6,(a4)+
  469.         move.l  d7,(a4)+
  470.         move.l  d0,4(a4)
  471.         lea     -16(a4),a4
  472.         swap    d0                      ;z = new[5]>>16
  473.         cmp.l   d3,d2                   ;if (lp2[1] > lp1[1])
  474.         bgt.b   .nodraw                 ;goto nodraw
  475.         cmp.l   d2,d3                   ;if (lp2[1] == lp1[1)
  476.         bne.b   .draw
  477.         cmp.l   d1,a3                   ;&& (lp2[0] < lp1[0])
  478.         blt.b   .nodraw                 ;goto nodraw
  479. .draw
  480.  
  481. *        z = new[5]>>16;
  482. *        zbuf = zspantable[new[1]] + new[0];
  483. *        if (z >= *zbuf)
  484. *        {
  485. *                int             pix;
  486. *
  487. *                *zbuf = z;
  488. *                pix = d_pcolormap[skintable[new[3]>>16][new[2]>>16]];
  489. *                d_viewbuffer[d_scantable[new[1]] + new[0]] = pix;
  490. *        }
  491.  
  492.         move.l  0(a5,d5.l*4),a3
  493.         cmp     0(a3,d4.l*2),d0         ;if (z >= *zbuf)
  494.         blt.b   .nodraw
  495.         move    d0,0(a3,d4.l*2)         ;*zbuf = z
  496.         swap    d6
  497.         swap    d7
  498.         lea     _skintable,a3
  499.         move.l  0(a3,d7.w*4),a3         ;skintable[new[3]]
  500.         move.b  0(a3,d6.w),d2           ;d2 = skintable[new[3]][new[2]>>16]
  501.         and     #$ff,d2
  502.         move.l  _d_pcolormap,a3
  503.         move.b  0(a3,d2.w),d2           ;pix = d_pcolormap[d2]
  504.         lea     _d_scantable,a3
  505.         move.l  0(a3,d5.l*4),d1         ;d_scantable[new[1]]
  506.         add.l   d4,d1                   ;+new[0]
  507.         move.b  d2,0(a6,d1.l)           ;d_viewbuffer[d1] = pix
  508. .nodraw
  509.  
  510. *// recursively continue
  511. *        D_PolysetRecursiveTriangle (lp3, lp1, new);
  512. *        D_PolysetRecursiveTriangle (lp3, new, lp2);
  513.  
  514.         movem.l a1/a2/a4,-(sp)
  515.         move.l  a0,a1
  516.         move.l  a2,a0
  517.         move.l  a4,a2
  518.         bsr     DoRecursion             ;DRT (lp3, lp1, new)
  519.         movem.l (sp)+,a1/a2/a4
  520.         move.l  a2,a0
  521.         move.l  a1,a2
  522.         move.l  a4,a1
  523.         bsr     DoRecursion             ;DRT (lp3, new, lp2)
  524. .exit
  525.         lea     6*4(sp),sp
  526.         rts
  527.  
  528.  
  529.  
  530.  
  531.  
  532.  
  533.  
  534. ******************************************************************************
  535. *
  536. *       void D_PolysetSetUpForLineScan (fixed8_t startvertu,
  537. *               fixed8_t startvertv, fixed8_t endvertu, fixed8_t endvertv)
  538. *
  539. *       Parameters are transferred in registers d0-d3
  540. ******************************************************************************
  541.  
  542.         cnop    0,4
  543. _D_PolysetSetUpForLineScan
  544.  
  545.  
  546. *****   stackframe
  547.  
  548.         rsreset
  549. .intregs        rs.l    2
  550.         rs.l    1
  551. .startvertu     rs.l    1
  552. .startvertv     rs.l    1
  553. .endvertu       rs.l    1
  554. .endvertv       rs.l    1
  555.  
  556.  
  557. *        errorterm = -1;
  558. *
  559. *        tm = endvertu - startvertu;
  560. *        tn = endvertv - startvertv;
  561.  
  562.         move.l  #-1,_errorterm
  563.         sub.l   d0,d2
  564.         sub.l   d1,d3
  565.         add.l   #15,d2
  566.         add.l   #15,d3
  567.  
  568. *        if (((tm <= 16) && (tm >= -15)) &&
  569. *                ((tn <= 16) && (tn >= -15)))
  570. *        {
  571. *                ptemp = &adivtab[((tm+15) << 5) + (tn+15)];
  572. *                ubasestep = ptemp->quotient;
  573. *                erroradjustup = ptemp->remainder;
  574. *                erroradjustdown = tn;
  575. *        }
  576.  
  577.         cmp.l   #31,d2
  578.         bhi.b   .else
  579.         cmp.l   #31,d3
  580.         bhi.b   .else
  581.         lea     _adivtab,a0
  582.         lsl.l   #5,d2
  583.         add.l   d3,d2
  584.         lea     0(a0,d2.l*8),a0
  585.         move.l  PTEMP_QUOTIENT(a0),_ubasestep
  586.         move.l  PTEMP_REMAINDER(a0),_erroradjustup
  587.         sub.l   #15,d3
  588.         move.l  d3,_erroradjustdown
  589.         bra.b   .exit
  590.  
  591. *        {
  592. *                dm = (double)tm;
  593. *                dn = (double)tn;
  594. *
  595. *                FloorDivMod (dm, dn, &ubasestep, &erroradjustup);
  596. *
  597. *                erroradjustdown = dn;
  598. *        }
  599.  
  600. .else
  601.         sub.l   #15,d2
  602.         sub.l   #15,d3
  603.         fmove.l d2,fp0
  604.         fmove.l d3,fp1
  605.         move.l  #_erroradjustup,-(sp)
  606.         move.l  #_ubasestep,-(sp)
  607.         fmove.d fp1,-(sp)
  608.         fmove.d fp0,-(sp)
  609.         jsr     _FloorDivMod
  610.         add     #24,sp
  611.         move.l  d3,_erroradjustdown
  612. .exit
  613.         rts
  614.  
  615.  
  616.  
  617.  
  618.  
  619.  
  620. *****************************************************************************
  621. *
  622. *       void D_PolysetCalcGradients (int skinwidth)
  623. *
  624. ******************************************************************************
  625.  
  626.         cnop    0,4
  627. _D_PolysetCalcGradients
  628.  
  629.  
  630. *****   stackframe
  631.         rsreset
  632. .fpuregs        rs.x    6
  633. .intregs        rs.l    3
  634.         rs.l    1
  635. .skinwidth      rs.l    1
  636.  
  637. ***** prologue
  638.  
  639.         movem.l d2/d3/a2,-(sp)
  640.         fmovem.x        fp2-fp7,-(sp)
  641.  
  642. *        p00_minus_p20 = r_p0[0] - r_p2[0];
  643. *        p01_minus_p21 = r_p0[1] - r_p2[1];
  644. *        p10_minus_p20 = r_p1[0] - r_p2[0];
  645. *        p11_minus_p21 = r_p1[1] - r_p2[1];
  646. *
  647. *        xstepdenominv = 1.0 / (float)d_xdenom;
  648. *
  649. *        ystepdenominv = -xstepdenominv;
  650.  
  651.         lea     _r_p2,a0
  652.         lea     _r_p1,a1
  653.         lea     _r_p0,a2
  654.         move.l  (a2),d0
  655.         move.l  1*4(a2),d1
  656.         move.l  (a0),d2
  657.         sub.l   d2,d0
  658.         fmove.l d0,fp0                  ;fp0 = p00_minus_p20
  659.         move.l  1*4(a0),d3
  660.         sub.l   d3,d1
  661.         fmove.l d1,fp1                  ;fp1 = p01_minus_p21
  662.         sub.l   (a1),d2
  663.         neg.l   d2
  664.         fmove.l d2,fp2                  ;fp2 = p10_minus_p20
  665.         sub.l   4(a1),d3
  666.         neg.l   d3
  667.         fmove.l d3,fp3                  ;fp3 = p11_minus_p21
  668.  
  669.         fmove.l _d_xdenom,fp4
  670.         fmove.s #1,fp5
  671.         fdiv    fp4,fp5                 ;fp5 = 1.0 / (float)d_xdenom
  672.         fneg    fp5,fp6                 ;fp6 = ystepdenominv
  673.         fmul    fp5,fp1
  674.         fmul    fp5,fp3
  675.         fmul    fp6,fp0
  676.         fmul    fp6,fp2
  677.  
  678. *        t0 = r_p0[4] - r_p2[4];
  679. *        t1 = r_p1[4] - r_p2[4];
  680. *        r_lstepx = (int)
  681. *                        ceil((t1 * p01_minus_p21 - t0 * p11_minus_p21) * xstepdenominv);
  682. *        r_lstepy = (int)
  683. *                        ceil((t1 * p00_minus_p20 - t0 * p10_minus_p20) * ystepdenominv);
  684.  
  685.         fmove.l fpcr,d2
  686.         fmove.l #$000000b0,fpcr
  687.         move.l  4*4(a0),d0
  688.         move.l  d0,d1
  689.         sub.l   4*4(a2),d0
  690.         neg.l   d0
  691.         fmove.l d0,fp4                  ;fp4 = t0
  692.         sub.l   4*4(a1),d1
  693.         neg.l   d1
  694.         fmove.l d1,fp5                  ;fp5 = t1
  695.         fmove   fp4,fp6
  696.         fmul    fp3,fp6
  697.         fmove   fp5,fp7
  698.         fmul    fp1,fp7
  699.         fsub    fp6,fp7
  700.         fmove.l fp7,_r_lstepx
  701.         fmul    fp2,fp4
  702.         fmul    fp0,fp5
  703.         fsub    fp4,fp5
  704.         fmove.l fp5,_r_lstepy
  705.         fmove.l d2,fpcr
  706.  
  707. *        t0 = r_p0[2] - r_p2[2];
  708. *        t1 = r_p1[2] - r_p2[2];
  709. *        r_sstepx = (int)((t1 * p01_minus_p21 - t0 * p11_minus_p21) *
  710. *                        xstepdenominv);
  711. *        r_sstepy = (int)((t1 * p00_minus_p20 - t0* p10_minus_p20) *
  712. *                        ystepdenominv);
  713.  
  714.         move.l  2*4(a0),d0
  715.         move.l  d0,d1
  716.         sub.l   2*4(a2),d0
  717.         neg.l   d0
  718.         fmove.l d0,fp4                  ;fp4 = t0
  719.         sub.l   2*4(a1),d1
  720.         neg.l   d1
  721.         fmove.l d1,fp5                  ;fp5 = t1
  722.         fmove   fp4,fp6
  723.         fmul    fp3,fp6
  724.         fmove   fp5,fp7
  725.         fmul    fp1,fp7
  726.         fsub    fp6,fp7
  727.         fmove.l fp7,d2
  728.         move.l  d2,_r_sstepx
  729.         fmul    fp2,fp4
  730.         fmul    fp0,fp5
  731.         fsub    fp4,fp5
  732.         fmove.l fp5,_r_sstepy
  733.  
  734. *        t0 = r_p0[3] - r_p2[3];
  735. *        t1 = r_p1[3] - r_p2[3];
  736. *        r_tstepx = (int)((t1 * p01_minus_p21 - t0 * p11_minus_p21) *
  737. *                        xstepdenominv);
  738. *        r_tstepy = (int)((t1 * p00_minus_p20 - t0 * p10_minus_p20) *
  739. *                        ystepdenominv);
  740.  
  741.         move.l  3*4(a0),d0
  742.         move.l  d0,d1
  743.         sub.l   3*4(a2),d0
  744.         neg.l   d0
  745.         fmove.l d0,fp4                  ;fp4 = t0
  746.         sub.l   3*4(a1),d1
  747.         neg.l   d1
  748.         fmove.l d1,fp5                  ;fp5 = t1
  749.         fmove   fp4,fp6
  750.         fmul    fp3,fp6
  751.         fmove   fp5,fp7
  752.         fmul    fp1,fp7
  753.         fsub    fp6,fp7
  754.         fmove.l fp7,d3
  755.         move.l  d3,_r_tstepx
  756.         fmul    fp2,fp4
  757.         fmul    fp0,fp5
  758.         fsub    fp4,fp5
  759.         fmove.l fp5,_r_tstepy
  760.  
  761. *        t0 = r_p0[5] - r_p2[5];
  762. *        t1 = r_p1[5] - r_p2[5];
  763. *        r_zistepx = (int)((t1 * p01_minus_p21 - t0 * p11_minus_p21) *
  764. *                        xstepdenominv);
  765. *        r_zistepy = (int)((t1 * p00_minus_p20 - t0 * p10_minus_p20) *
  766. *                        ystepdenominv);
  767.  
  768.         move.l  5*4(a0),d0
  769.         move.l  d0,d1
  770.         sub.l   5*4(a2),d0
  771.         neg.l   d0
  772.         fmove.l d0,fp4                  ;fp4 = t0
  773.         sub.l   5*4(a1),d1
  774.         neg.l   d1
  775.         fmove.l d1,fp5                  ;fp5 = t1
  776.         fmove   fp4,fp6
  777.         fmul    fp3,fp6
  778.         fmove   fp5,fp7
  779.         fmul    fp1,fp7
  780.         fsub    fp6,fp7
  781.         fmove.l fp7,_r_zistepx
  782.         fmul    fp2,fp4
  783.         fmul    fp0,fp5
  784.         fsub    fp4,fp5
  785.         fmove.l fp5,_r_zistepy
  786.  
  787. *        a_sstepxfrac = r_sstepx & 0xFFFF;
  788. *        a_tstepxfrac = r_tstepx & 0xFFFF;
  789. *        a_ststepxwhole = skinwidth * (r_tstepx >> 16) + (r_sstepx >> 16);
  790.  
  791.         move.l  .skinwidth(sp),d0
  792.         swap    d3
  793.         muls    d3,d0
  794.         clr     d3
  795.         swap    d3
  796.         move.l  d2,d1
  797.         swap    d1
  798.         ext.l   d1
  799.         add.l   d1,d0
  800.         and.l   #$ffff,d2
  801.         move.l  d2,_a_sstepxfrac
  802.         move.l  d3,_a_tstepxfrac
  803.         move.l  d0,_a_ststepxwhole
  804.         fmovem.x        (sp)+,fp2-fp7
  805.         movem.l (sp)+,d2/d3/a2
  806.         rts
  807.  
  808.  
  809.  
  810.  
  811. ******************************************************************************
  812. *
  813. *       void D_RasterizeAliasPolySmooth (void)
  814. *
  815. ******************************************************************************
  816.         cnop    0,4
  817. _D_RasterizeAliasPolySmooth
  818.  
  819. *****   stackframe
  820.         rsreset
  821. .pdestx         rs.l    1
  822. .pzx            rs.l    1
  823. .aspanx         rs.l    1
  824. .ptexx          rs.l    1
  825. .sfracx         rs.l    1
  826. .tfracx         rs.l    1
  827. .lightx         rs.l    1
  828. .zix            rs.l    1
  829. .pdestb         rs.l    1
  830. .pzb            rs.l    1
  831. .aspanb         rs.l    1
  832. .ptexb          rs.l    1
  833. .sfracb         rs.l    1
  834. .tfracb         rs.l    1
  835. .lightb         rs.l    1
  836. .zib            rs.l    1
  837. .r_affine       rs.l    1
  838. .height         rs.l    1
  839. .initLH         rs.l    1
  840. .initRH         rs.l    1
  841. .savearea       rs.l    11
  842. .intregs        rs.l    11
  843.         rs.l    1
  844.  
  845.         movem.l d2-d7/a2-a6,-(sp)
  846.         sub     #.intregs,sp
  847.  
  848. *        plefttop = pedgetable->pleftedgevert0;
  849. *        prighttop = pedgetable->prightedgevert0;
  850. *
  851. *        pleftbottom = pedgetable->pleftedgevert1;
  852. *        prightbottom = pedgetable->prightedgevert1;
  853. *
  854. *        initialleftheight = pleftbottom[1] - plefttop[1];
  855. *        initialrightheight = prightbottom[1] - prighttop[1];
  856.  
  857.         move.l  _pedgetable,a0
  858.         move.l  ETAB_PLEV0(a0),a6       ;a6 = plefttop
  859.         move.l  ETAB_PREV0(a0),a2       ;a2 = prighttop
  860.         move.l  ETAB_PLEV1(a0),a3       ;a3 = pleftbottom
  861.         move.l  ETAB_PREV1(a0),a4       ;a4 = prightbottom
  862.         lea     _r_affinetridesc,a5
  863.         move.l  4(a3),d6
  864.         move.l  4(a6),d7                ;d7 = plefttop[1]
  865.         move.l  d6,d2
  866.         sub.l   d7,d2
  867.         move.l  d2,.initLH(sp)          ;initialleftheight
  868.         move.l  4(a4),d3
  869.         move.l  4(a2),d4
  870.         move.l  d3,d5
  871.         sub.l   d4,d5
  872.         move.l  d5,.initRH(sp)          ;initialrightheight
  873.         move.l  R_SKINWIDTH(a5),d4
  874.         move.l  d4,.r_affine(sp)
  875.         move.l  d4,-(sp)
  876.         bsr     _D_PolysetCalcGradients
  877.         addq    #4,sp
  878.         move.l  d6,d3
  879.         move.l  (a3),d2
  880.         move.l  d7,d1
  881.         move.l  (a6),d0
  882.         bsr     _D_PolysetSetUpForLineScan
  883.  
  884. *        d_pedgespanpackage = a_spans;
  885. *
  886. *        ystart = plefttop[1];
  887. *        d_aspancount = plefttop[0] - prighttop[0];
  888. *
  889. *        d_ptex = (byte *)r_affinetridesc.pskin + (plefttop[2] >> 16) +
  890. *                        (plefttop[3] >> 16) * r_affinetridesc.skinwidth;
  891. *        d_sfrac = plefttop[2] & 0xFFFF;
  892. *        d_tfrac = plefttop[3] & 0xFFFF;
  893. *        d_pzbasestep = d_zwidth + ubasestep;
  894. *        d_pzextrastep = d_pzbasestep + 1;
  895. *        d_light = plefttop[4];
  896. *        d_zi = plefttop[5];
  897. *
  898. *        d_pdestbasestep = screenwidth + ubasestep;
  899. *        d_pdestextrastep = d_pdestbasestep + 1;
  900. *        d_pdest = (byte *)d_viewbuffer +
  901. *                        ystart * screenwidth + plefttop[0];
  902. *        d_pz = d_pzbuffer + ystart * d_zwidth + plefttop[0];
  903.  
  904.         move.l  _a_spans,_d_pedgespanpackage
  905.         move.l  (a6),d2
  906.         sub.l   (a2),d2
  907.         move.l  d2,_d_aspancount        ;d_aspancount = plefttop[0] - ...
  908.         move.l  2*4(a6),d0
  909.         move.l  3*4(a6),d1
  910.         move.l  d0,d3                   ;d3 = plefttop[2]
  911.         move.l  d1,d6                   ;d6 = plefttop[3]
  912.         swap    d0
  913.         swap    d1
  914.         and.l   #$ffff,d0
  915.         and.l   #$ffff,d1
  916.         mulu    d4,d1
  917.         add.l   d0,d1
  918.         add.l   R_PSKIN(a5),d1
  919.         move.l  d1,_d_ptex              ;d_ptex = ...
  920.         and.l   #$ffff,d3
  921.         and.l   #$ffff,d6
  922.         move.l  d3,_d_sfrac             ;d_sfrac = plefttop[2]&$ffff
  923.         move.l  d6,_d_tfrac             ;d_tfrac = plefttop[3]&$ffff
  924.         move.l  _d_zwidth,d0
  925.         move.l  d0,d3                   ;d3 = d_zwidth
  926.         move.l  _ubasestep,d1
  927.         move.l  d1,.aspanb(sp)
  928.         move.l  d1,d5                   ;d5 = ubasestep
  929.         add.l   d1,d0
  930.         addq.l  #1,d1
  931.         move.l  d1,_d_countextrastep
  932.         move.l  d1,.aspanx(sp)
  933.         add.l   d0,d0
  934.         move.l  d0,.pzb(sp)             ;d_pzbasestep = d_zwidth + ubasestep
  935.         addq.l  #2,d0
  936.         move.l  d0,.pzx(sp)             ;d_pzextrastep = d_pzbasestep + 1
  937.         move.l  4*4(a6),_d_light        ;d_light = plefttop[4]
  938.         move.l  5*4(a6),_d_zi           ;d_zi = plefttop[5]
  939.         move.l  _screenwidth,d0
  940.         add.l   d0,d1
  941.         move.l  d1,.pdestx(sp)          ;d_pdestextrastep = ...
  942.         subq.l  #1,d1
  943.         move.l  d1,.pdestb(sp)          ;d_pdestbasestep = screenwidth + ..
  944.         mulu    d7,d0                   ;screenwidth * ystart
  945.         move.l  (a6),d6
  946.         add.l   d6,d0                   ;+ plefttop[0]
  947.         add.l   _d_viewbuffer,d0
  948.         move.l  d0,_d_pdest             ;d_pdest + d_viewbuffer + ...
  949.         mulu    d7,d3                   ;d_zwidth * ystart
  950.         add.l   d6,d3                   ;+ plefttop[0]
  951.         add.l   d3,d3
  952.         add.l   _d_pzbuffer,d3
  953.         move.l  d3,_d_pz                ;d_pz = d_pzbuffer + ...
  954.  
  955. *        if (ubasestep < 0)
  956. *                working_lstepx = r_lstepx - 1;
  957. *        else
  958. *                working_lstepx = r_lstepx;
  959. *
  960. *        d_countextrastep = ubasestep + 1;
  961. *        d_ptexbasestep = ((r_sstepy + r_sstepx * ubasestep) >> 16) +
  962. *                        ((r_tstepy + r_tstepx * ubasestep) >> 16) *
  963. *                        r_affinetridesc.skinwidth;
  964. *        d_sfracbasestep = (r_sstepy + r_sstepx * ubasestep) & 0xFFFF;
  965. *        d_tfracbasestep = (r_tstepy + r_tstepx * ubasestep) & 0xFFFF;
  966. *        d_lightbasestep = r_lstepy + working_lstepx * ubasestep;
  967. *        d_zibasestep = r_zistepy + r_zistepx * ubasestep;
  968. *
  969. *        d_ptexextrastep = ((r_sstepy + r_sstepx * d_countextrastep) >> 16) +
  970. *                        ((r_tstepy + r_tstepx * d_countextrastep) >> 16) *
  971. *                        r_affinetridesc.skinwidth;
  972. *        d_sfracextrastep = (r_sstepy + r_sstepx*d_countextrastep) & 0xFFFF;
  973. *        d_tfracextrastep = (r_tstepy + r_tstepx*d_countextrastep) & 0xFFFF;
  974. *        d_lightextrastep = d_lightbasestep + working_lstepx;
  975. *        d_ziextrastep = d_zibasestep + r_zistepx;
  976. *
  977.  
  978.         move.l  _r_sstepy,a0
  979.         move.l  _r_sstepx,d1
  980.         move.l  _r_tstepy,a1
  981.         move.l  _r_tstepx,d6
  982.         move.l  d1,d2
  983.         muls.l  d5,d2
  984.         move.l  d6,d7
  985.         muls.l  d5,d7
  986.         add.l   a0,d2
  987.         add.l   a1,d7
  988.         move.l  d2,d0
  989.         move.l  d7,d3
  990.         and.l   #$ffff,d0
  991.         move.l  d0,.sfracb(sp)
  992.         and.l   #$ffff,d3
  993.         swap    d3
  994.         move.l  d3,.tfracb(sp)
  995.         swap    d3
  996.         add.l   d1,d0
  997.         add.l   d6,d3
  998.         and.l   #$ffff,d0
  999.         move.l  d0,.sfracx(sp)
  1000.         and.l   #$ffff,d3
  1001.         swap    d3
  1002.         move.l  d3,.tfracx(sp)
  1003.         swap    d3
  1004.         move.l  d2,d0
  1005.         move.l  d7,d3
  1006.         swap    d2
  1007.         ext.l   d2
  1008.         swap    d7
  1009.         muls    d4,d7
  1010.         add.l   d2,d7
  1011.         move.l  d7,.ptexb(sp)
  1012.         add.l   d1,d0
  1013.         add.l   d6,d3
  1014.         swap    d0
  1015.         ext.l   d0
  1016.         swap    d3
  1017.         muls    d4,d3
  1018.         add.l   d0,d3
  1019.         move.l  d3,.ptexx(sp)
  1020.         move.l  _r_lstepy,d0
  1021.         move.l  _r_lstepx,d1
  1022.         tst.l   d5                      ;(if ubasestep < 0)
  1023.         bge.b   .ge
  1024.         subq.l  #1,d1                   ;working_lstepx = r_lstepx - 1
  1025. .ge
  1026.         move.l  d1,d2
  1027.         muls.l  d5,d1
  1028.         add.l   d0,d1
  1029.         move.l  d1,.lightb(sp)
  1030.         add.l   d2,d1
  1031.         move.l  d1,.lightx(sp)
  1032.         move.l  _r_zistepy,d0
  1033.         move.l  _r_zistepx,d1
  1034.         move.l  d1,d2
  1035.         muls.l  d5,d1
  1036.         add.l   d0,d1
  1037.         move.l  d1,.zib(sp)
  1038.         add.l   d2,d1
  1039.         move.l  d1,.zix(sp)
  1040.  
  1041.  
  1042.  
  1043. *****   D_PolysetScanLeftEdge (inlined)
  1044.  
  1045.  
  1046.         movem.l d2-d7/a2-a6,.savearea(sp)
  1047.         move.l  _d_pedgespanpackage,a0
  1048.         move.l  _d_pdest,a1
  1049.         move.l  _d_pz,a2
  1050.         move.l  _d_aspancount,d6
  1051.         move.l  _d_ptex,a3
  1052.         move.l  _d_sfrac,d4
  1053.         move.l  _d_tfrac,d5
  1054.         swap    d5
  1055.         move.l  _d_light,a5
  1056.         move.l  _d_zi,a4
  1057.         move.l  _errorterm,d2
  1058.         move.l  _erroradjustup,d1
  1059.         move.l  _erroradjustdown,d0
  1060.         move.l  .initLH(sp),d7
  1061.         subq    #1,d7
  1062. .loopA
  1063.  
  1064. *                d_pedgespanpackage->pdest = d_pdest;
  1065. *                d_pedgespanpackage->pz = d_pz;
  1066. *                d_pedgespanpackage->count = d_aspancount;
  1067. *                d_pedgespanpackage->ptex = d_ptex;
  1068. *
  1069. *                d_pedgespanpackage->sfrac = d_sfrac;
  1070. *                d_pedgespanpackage->tfrac = d_tfrac;
  1071. *
  1072. *                d_pedgespanpackage->light = d_light;
  1073. *                d_pedgespanpackage->zi = d_zi;
  1074. *
  1075. *                d_pedgespanpackage++;
  1076. *
  1077. *                errorterm += erroradjustup;
  1078. *                if (errorterm >= 0)
  1079.  
  1080.         move.l  a1,(a0)+
  1081.         move.l  a2,(a0)+
  1082.         move.l  d6,(a0)+
  1083.         move.l  a3,(a0)+
  1084.         move.l  d4,(a0)+
  1085.         swap    d5
  1086.         clr     (a0)+
  1087.         move    d5,(a0)+
  1088.         swap    d5
  1089.         move.l  a5,(a0)+
  1090.         move.l  a4,(a0)+
  1091.         add.l   d1,d2
  1092.         blt.b   .elseA
  1093.  
  1094. *                        d_pdest += d_pdestextrastep;
  1095. *                        d_pz += d_pzextrastep;
  1096. *                        d_aspancount += d_countextrastep;
  1097. *                        d_ptex += d_ptexextrastep;
  1098. *                        d_sfrac += d_sfracextrastep;
  1099. *                        d_ptex += d_sfrac >> 16;
  1100. *
  1101. *                        d_sfrac &= 0xFFFF;
  1102. *                        d_tfrac += d_tfracextrastep;
  1103. *                        if (d_tfrac & 0x10000)
  1104. *                        {
  1105. *                                d_ptex += r_affinetridesc.skinwidth;
  1106. *                                d_tfrac &= 0xFFFF;
  1107. *                        }
  1108. *                        d_light += d_lightextrastep;
  1109. *                        d_zi += d_ziextrastep;
  1110. *                        errorterm -= erroradjustdown;
  1111.  
  1112.         lea     .pdestx(sp),a6
  1113.         add.l   (a6)+,a1
  1114.         add.l   (a6)+,a2
  1115.         add.l   (a6)+,d6
  1116.         add.l   (a6)+,a3
  1117.         add.l   (a6)+,d4
  1118.         swap    d4
  1119.         add     d4,a3
  1120.         clr     d4
  1121.         swap    d4
  1122.         add.l   (a6)+,d5
  1123.         bcc.b   .contA
  1124.         add.l   .r_affine(sp),a3
  1125. .contA
  1126.         add.l   (a6)+,a5
  1127.         add.l   (a6)+,a4
  1128.         sub.l   d0,d2
  1129.         bra.b   .nextA
  1130. .elseA
  1131.  
  1132. *                        d_pdest += d_pdestbasestep;
  1133. *                        d_pz += d_pzbasestep;
  1134. *                        d_aspancount += ubasestep;
  1135. *                        d_ptex += d_ptexbasestep;
  1136. *                        d_sfrac += d_sfracbasestep;
  1137. *                        d_ptex += d_sfrac >> 16;
  1138. *                        d_sfrac &= 0xFFFF;
  1139. *                        d_tfrac += d_tfracbasestep;
  1140. *                        if (d_tfrac & 0x10000)
  1141. *                        {
  1142. *                                d_ptex += r_affinetridesc.skinwidth;
  1143. *                                d_tfrac &= 0xFFFF;
  1144. *                        }
  1145. *                        d_light += d_lightbasestep;
  1146. *                        d_zi += d_zibasestep;
  1147.  
  1148.         lea     .pdestb(sp),a6
  1149.         add.l   (a6)+,a1
  1150.         add.l   (a6)+,a2
  1151.         add.l   (a6)+,d6
  1152.         add.l   (a6)+,a3
  1153.         add.l   (a6)+,d4
  1154.         swap    d4
  1155.         add     d4,a3
  1156.         clr     d4
  1157.         swap    d4
  1158.         add.l   (a6)+,d5
  1159.         bcc.b   .cont2A
  1160.         add.l   .r_affine(sp),a3
  1161. .cont2A
  1162.         add.l   (a6)+,a5
  1163.         add.l   (a6)+,a4
  1164. .nextA
  1165.         dbra    d7,.loopA
  1166.         move.l  a0,_d_pedgespanpackage
  1167.         movem.l .savearea(sp),d2-d7/a2-a6
  1168.  
  1169. ******  End of D_PolysetScanLeftEdge
  1170.  
  1171.  
  1172.  
  1173.  
  1174. *        if (pedgetable->numleftedges == 2)
  1175. *        {
  1176. *                int             height;
  1177. *
  1178. *                plefttop = pleftbottom;
  1179. *                pleftbottom = pedgetable->pleftedgevert2;
  1180. *
  1181. *                D_PolysetSetUpForLineScan(plefttop[0], plefttop[1],
  1182. *                                                          pleftbottom[0], pleftbottom[1]);
  1183. *
  1184. *                height = pleftbottom[1] - plefttop[1];
  1185. *
  1186. *// TODO: make this a function; modularize this function in general
  1187. *
  1188. *                ystart = plefttop[1];
  1189. *                d_aspancount = plefttop[0] - prighttop[0];
  1190. *                d_ptex = (byte *)r_affinetridesc.pskin + (plefttop[2] >> 16) +
  1191. *                                (plefttop[3] >> 16) * r_affinetridesc.skinwidth;
  1192. *                d_sfrac = 0;
  1193. *                d_tfrac = 0;
  1194. *                d_light = plefttop[4];
  1195. *                d_zi = plefttop[5];
  1196. *
  1197. *                d_pdestbasestep = screenwidth + ubasestep;
  1198. *                d_pdestextrastep = d_pdestbasestep + 1;
  1199. *                d_pdest = (byte *)d_viewbuffer + ystart * screenwidth + plefttop[0];
  1200. *                d_pzbasestep = d_zwidth + ubasestep;
  1201. *                d_pzextrastep = d_pzbasestep + 1;
  1202. *                d_pz = d_pzbuffer + ystart * d_zwidth + plefttop[0];
  1203. *
  1204. *                if (ubasestep < 0)
  1205. *                        working_lstepx = r_lstepx - 1;
  1206. *                else
  1207. *                        working_lstepx = r_lstepx;
  1208. *
  1209. *                d_countextrastep = ubasestep + 1;
  1210. *                d_ptexbasestep = ((r_sstepy + r_sstepx * ubasestep) >> 16) +
  1211. *                                ((r_tstepy + r_tstepx * ubasestep) >> 16) *
  1212. *                                r_affinetridesc.skinwidth;
  1213. *                d_sfracbasestep = (r_sstepy + r_sstepx * ubasestep) & 0xFFFF;
  1214. *                d_tfracbasestep = (r_tstepy + r_tstepx * ubasestep) & 0xFFFF;
  1215. *                d_lightbasestep = r_lstepy + working_lstepx * ubasestep;
  1216. *                d_zibasestep = r_zistepy + r_zistepx * ubasestep;
  1217. *
  1218. *                d_ptexextrastep = ((r_sstepy + r_sstepx * d_countextrastep) >> 16) +
  1219. *                                ((r_tstepy + r_tstepx * d_countextrastep) >> 16) *
  1220. *                                r_affinetridesc.skinwidth;
  1221. *                d_sfracextrastep = (r_sstepy+r_sstepx*d_countextrastep) & 0xFFFF;
  1222. *                d_tfracextrastep = (r_tstepy+r_tstepx*d_countextrastep) & 0xFFFF;
  1223. *                d_lightextrastep = d_lightbasestep + working_lstepx;
  1224. *                d_ziextrastep = d_zibasestep + r_zistepx;
  1225.  
  1226.  
  1227.         move.l  _pedgetable,a0
  1228.         cmp.l   #2,ETAB_NUMLEFTEDGES(a0)
  1229.         bne.b   .cont
  1230.         move.l  a3,a6
  1231.         move.l  ETAB_PLEV2(a0),a3
  1232.         move.l  4(a3),d5
  1233.         move.l  d5,d3
  1234.         move.l  (a3),d2
  1235.         move.l  4(a6),d7
  1236.         move.l  d7,d1
  1237.         move.l  (a6),d6
  1238.         move.l  d6,d0
  1239.         bsr     _D_PolysetSetUpForLineScan
  1240.         sub.l   d7,d5
  1241.         move.l  d5,.height(sp)
  1242.         sub.l   (a2),d6
  1243.         move.l  d6,_d_aspancount        ;d_aspancount = plefttop[0] - ...
  1244.  
  1245.         move.l  2*4(a6),d0
  1246.         move.l  3*4(a6),d1
  1247.         move.l  d0,d3                   ;d3 = plefttop[2]
  1248.         move.l  d1,d6                   ;d6 = plefttop[3]
  1249.         swap    d0
  1250.         swap    d1
  1251.         and.l   #$ffff,d0
  1252.         and.l   #$ffff,d1
  1253.         mulu    d4,d1
  1254.         add.l   d0,d1
  1255.         add.l   R_PSKIN(a5),d1
  1256.         move.l  d1,_d_ptex              ;d_ptex = ...
  1257.         clr.l   _d_sfrac
  1258.         clr.l   _d_tfrac
  1259.         move.l  _d_zwidth,d0
  1260.         move.l  d0,d3                   ;d3 = d_zwidth
  1261.         move.l  _ubasestep,d1
  1262.         move.l  d1,.aspanb(sp)
  1263.         move.l  d1,d5                   ;d5 = ubasestep
  1264.         add.l   d1,d0
  1265.         addq.l  #1,d1
  1266.         move.l  d1,_d_countextrastep
  1267.         move.l  d1,.aspanx(sp)
  1268.         add.l   d0,d0
  1269.         move.l  d0,.pzb(sp)             ;d_pzbasestep = d_zwidth + ubasestep
  1270.         addq.l  #2,d0
  1271.         move.l  d0,.pzx(sp)             ;d_pzextrastep = d_pzbasestep + 1
  1272.         move.l  4*4(a6),_d_light        ;d_light = plefttop[4]
  1273.         move.l  5*4(a6),_d_zi           ;d_zi = plefttop[5]
  1274.         move.l  _screenwidth,d0
  1275.         add.l   d0,d1
  1276.         move.l  d1,.pdestx(sp)          ;d_pdestextrastep = ...
  1277.         subq.l  #1,d1
  1278.         move.l  d1,.pdestb(sp)          ;d_pdestbasestep = screenwidth + ..
  1279.         mulu    d7,d0                   ;screenwidth * ystart
  1280.         move.l  (a6),d6
  1281.         add.l   d6,d0                   ;+ plefttop[0]
  1282.         add.l   _d_viewbuffer,d0
  1283.         move.l  d0,_d_pdest             ;d_pdest + d_viewbuffer + ...
  1284.         mulu    d7,d3                   ;d_zwidth * ystart
  1285.         add.l   d6,d3                   ;+ plefttop[0]
  1286.         add.l   d3,d3
  1287.         add.l   _d_pzbuffer,d3
  1288.         move.l  d3,_d_pz                ;d_pz = d_pzbuffer + ...
  1289.  
  1290.         move.l  _r_sstepy,a0
  1291.         move.l  _r_sstepx,d1
  1292.         move.l  _r_tstepy,a1
  1293.         move.l  _r_tstepx,d6
  1294.         move.l  d1,d2
  1295.         muls.l  d5,d2
  1296.         move.l  d6,d7
  1297.         muls.l  d5,d7
  1298.         add.l   a0,d2
  1299.         add.l   a1,d7
  1300.         move.l  d2,d0
  1301.         move.l  d7,d3
  1302.         and.l   #$ffff,d0
  1303.         move.l  d0,.sfracb(sp)
  1304.         and.l   #$ffff,d3
  1305.         swap    d3
  1306.         move.l  d3,.tfracb(sp)
  1307.         swap    d3
  1308.         add.l   d1,d0
  1309.         add.l   d6,d3
  1310.         and.l   #$ffff,d0
  1311.         move.l  d0,.sfracx(sp)
  1312.         and.l   #$ffff,d3
  1313.         swap    d3
  1314.         move.l  d3,.tfracx(sp)
  1315.         swap    d3
  1316.         move.l  d2,d0
  1317.         move.l  d7,d3
  1318.         swap    d2
  1319.         ext.l   d2
  1320.         swap    d7
  1321.         muls    d4,d7
  1322.         add.l   d2,d7
  1323.         move.l  d7,.ptexb(sp)
  1324.         add.l   d1,d0
  1325.         add.l   d6,d3
  1326.         swap    d0
  1327.         ext.l   d0
  1328.         swap    d3
  1329.         muls    d4,d3
  1330.         add.l   d0,d3
  1331.         move.l  d3,.ptexx(sp)
  1332.         move.l  _r_lstepy,d0
  1333.         move.l  _r_lstepx,d1
  1334.         tst.l   d5                      ;(if ubasestep < 0)
  1335.         bge.b   .ge2
  1336.         subq.l  #1,d1                   ;working_lstepx = r_lstepx - 1
  1337. .ge2
  1338.         move.l  d1,d2
  1339.         muls.l  d5,d1
  1340.         add.l   d0,d1
  1341.         move.l  d1,.lightb(sp)
  1342.         add.l   d2,d1
  1343.         move.l  d1,.lightx(sp)
  1344.         move.l  _r_zistepy,d0
  1345.         move.l  _r_zistepx,d1
  1346.         move.l  d1,d2
  1347.         muls.l  d5,d1
  1348.         add.l   d0,d1
  1349.         move.l  d1,.zib(sp)
  1350.         add.l   d2,d1
  1351.         move.l  d1,.zix(sp)
  1352.  
  1353.  
  1354. *****   D_PolysetScanLeftEdge (inlined)
  1355.  
  1356.  
  1357.         movem.l d2-d7/a2-a6,.savearea(sp)
  1358.         move.l  _d_pedgespanpackage,a0
  1359.         move.l  _d_pdest,a1
  1360.         move.l  _d_pz,a2
  1361.         move.l  _d_aspancount,d6
  1362.         move.l  _d_ptex,a3
  1363.         move.l  _d_sfrac,d4
  1364.         move.l  _d_tfrac,d5
  1365.         swap    d5
  1366.         move.l  _d_light,a5
  1367.         move.l  _d_zi,a4
  1368.         move.l  _errorterm,d2
  1369.         move.l  _erroradjustup,d1
  1370.         move.l  _erroradjustdown,d0
  1371.         move.l  .height(sp),d7
  1372.         subq    #1,d7
  1373. .loopB
  1374.  
  1375. *                d_pedgespanpackage->pdest = d_pdest;
  1376. *                d_pedgespanpackage->pz = d_pz;
  1377. *                d_pedgespanpackage->count = d_aspancount;
  1378. *                d_pedgespanpackage->ptex = d_ptex;
  1379. *
  1380. *                d_pedgespanpackage->sfrac = d_sfrac;
  1381. *                d_pedgespanpackage->tfrac = d_tfrac;
  1382. *
  1383. *                d_pedgespanpackage->light = d_light;
  1384. *                d_pedgespanpackage->zi = d_zi;
  1385. *
  1386. *                d_pedgespanpackage++;
  1387. *
  1388. *                errorterm += erroradjustup;
  1389. *                if (errorterm >= 0)
  1390.  
  1391.         move.l  a1,(a0)+
  1392.         move.l  a2,(a0)+
  1393.         move.l  d6,(a0)+
  1394.         move.l  a3,(a0)+
  1395.         move.l  d4,(a0)+
  1396.         swap    d5
  1397.         clr     (a0)+
  1398.         move    d5,(a0)+
  1399.         swap    d5
  1400.         move.l  a5,(a0)+
  1401.         move.l  a4,(a0)+
  1402.         add.l   d1,d2
  1403.         blt.b   .elseB
  1404.  
  1405. *                        d_pdest += d_pdestextrastep;
  1406. *                        d_pz += d_pzextrastep;
  1407. *                        d_aspancount += d_countextrastep;
  1408. *                        d_ptex += d_ptexextrastep;
  1409. *                        d_sfrac += d_sfracextrastep;
  1410. *                        d_ptex += d_sfrac >> 16;
  1411. *
  1412. *                        d_sfrac &= 0xFFFF;
  1413. *                        d_tfrac += d_tfracextrastep;
  1414. *                        if (d_tfrac & 0x10000)
  1415. *                        {
  1416. *                                d_ptex += r_affinetridesc.skinwidth;
  1417. *                                d_tfrac &= 0xFFFF;
  1418. *                        }
  1419. *                        d_light += d_lightextrastep;
  1420. *                        d_zi += d_ziextrastep;
  1421. *                        errorterm -= erroradjustdown;
  1422.  
  1423.         lea     .pdestx(sp),a6
  1424.         add.l   (a6)+,a1
  1425.         add.l   (a6)+,a2
  1426.         add.l   (a6)+,d6
  1427.         add.l   (a6)+,a3
  1428.         add.l   (a6)+,d4
  1429.         swap    d4
  1430.         add     d4,a3
  1431.         clr     d4
  1432.         swap    d4
  1433.         add.l   (a6)+,d5
  1434.         bcc.b   .contB
  1435.         add.l   .r_affine(sp),a3
  1436. .contB
  1437.         add.l   (a6)+,a5
  1438.         add.l   (a6)+,a4
  1439.         sub.l   d0,d2
  1440.         bra.b   .nextB
  1441. .elseB
  1442.  
  1443. *                        d_pdest += d_pdestbasestep;
  1444. *                        d_pz += d_pzbasestep;
  1445. *                        d_aspancount += ubasestep;
  1446. *                        d_ptex += d_ptexbasestep;
  1447. *                        d_sfrac += d_sfracbasestep;
  1448. *                        d_ptex += d_sfrac >> 16;
  1449. *                        d_sfrac &= 0xFFFF;
  1450. *                        d_tfrac += d_tfracbasestep;
  1451. *                        if (d_tfrac & 0x10000)
  1452. *                        {
  1453. *                                d_ptex += r_affinetridesc.skinwidth;
  1454. *                                d_tfrac &= 0xFFFF;
  1455. *                        }
  1456. *                        d_light += d_lightbasestep;
  1457. *                        d_zi += d_zibasestep;
  1458.  
  1459.         lea     .pdestb(sp),a6
  1460.         add.l   (a6)+,a1
  1461.         add.l   (a6)+,a2
  1462.         add.l   (a6)+,d6
  1463.         add.l   (a6)+,a3
  1464.         add.l   (a6)+,d4
  1465.         swap    d4
  1466.         add     d4,a3
  1467.         clr     d4
  1468.         swap    d4
  1469.         add.l   (a6)+,d5
  1470.         bcc.b   .cont2B
  1471.         add.l   .r_affine(sp),a3
  1472. .cont2B
  1473.         add.l   (a6)+,a5
  1474.         add.l   (a6)+,a4
  1475. .nextB
  1476.         dbra    d7,.loopB
  1477.         move.l  a0,_d_pedgespanpackage
  1478.         movem.l .savearea(sp),d2-d7/a2-a6
  1479.  
  1480.  
  1481. .cont
  1482.  
  1483. *        d_pedgespanpackage = a_spans;
  1484. *
  1485. *        D_PolysetSetUpForLineScan(prighttop[0], prighttop[1],
  1486. *                                                  prightbottom[0], prightbottom[1]);
  1487. *        d_aspancount = 0;
  1488. *        d_countextrastep = ubasestep + 1;
  1489. *        originalcount = a_spans[initialrightheight].count;
  1490. *        a_spans[initialrightheight].count = -999999; // mark end of the spanpackages
  1491. *        D_PolysetDrawSpans8 (a_spans);
  1492.  
  1493.         move.l  _a_spans,_d_pedgespanpackage
  1494.         move.l  4(a4),d3
  1495.         move.l  (a4),d2
  1496.         move.l  4(a2),d1
  1497.         move.l  (a2),d0
  1498.         bsr     _D_PolysetSetUpForLineScan
  1499.         clr.l   _d_aspancount
  1500.         move.l  _ubasestep,d0
  1501.         addq.l  #1,d0
  1502.         move.l  d0,_d_countextrastep
  1503.         move.l  _a_spans,a3
  1504.         move.l  .initRH(sp),d6
  1505.         move.l  d6,d0
  1506.         asl.l   #PSPANP_SIZEOF_EXP,d0
  1507.         move.l  PSPANP_COUNT(a3,d0.l),d7
  1508.         move.l  #-999999,PSPANP_COUNT(a3,d0.l)
  1509.         move.l  a3,-(sp)
  1510.         bsr     _D_PolysetDrawSpans8
  1511.         addq    #4,sp
  1512.  
  1513. *        if (pedgetable->numrightedges == 2)
  1514. *        {
  1515. *                int                             height;
  1516. *                spanpackage_t   *pstart;
  1517. *
  1518. *                pstart = a_spans + initialrightheight;
  1519. *                pstart->count = originalcount;
  1520. *
  1521. *                d_aspancount = prightbottom[0] - prighttop[0];
  1522. *
  1523. *                prighttop = prightbottom;
  1524. *                prightbottom = pedgetable->prightedgevert2;
  1525. *
  1526. *                height = prightbottom[1] - prighttop[1];
  1527. *
  1528. *                D_PolysetSetUpForLineScan(prighttop[0], prighttop[1],
  1529. *                                                          prightbottom[0], prightbottom[1]);
  1530. *
  1531. *                d_countextrastep = ubasestep + 1;
  1532. *                a_spans[initialrightheight + height].count = -999999;
  1533. *                                                                                        // mark end of the spanpackages
  1534. *                D_PolysetDrawSpans8 (pstart);
  1535.  
  1536.         move.l  _pedgetable,a0
  1537.         cmp.l   #2,ETAB_NUMRIGHTEDGES(a0)
  1538.         bne.b   .exit
  1539.         move.l  a3,a6
  1540.         move.l  d6,d0
  1541.         asl.l   #PSPANP_SIZEOF_EXP,d0
  1542.         add.l   d0,a6
  1543.         move.l  d7,PSPANP_COUNT(a6)
  1544.         move.l  (a4),d0
  1545.         sub.l   (a2),d0
  1546.         move.l  d0,_d_aspancount
  1547.         move.l  a4,a2
  1548.         move.l  ETAB_PREV2(a0),a4
  1549.         move.l  4(a4),d5
  1550.         move.l  d5,d3
  1551.         move.l  4(a2),d0
  1552.         sub.l   d0,d5
  1553.         move.l  (a4),d2
  1554.         move.l  d0,d1
  1555.         move.l  (a2),d0
  1556.         bsr     _D_PolysetSetUpForLineScan
  1557.         move.l  _ubasestep,d4
  1558.         addq.l  #1,d4
  1559.         move.l  d4,_d_countextrastep
  1560.         add.l   d6,d5
  1561.         asl.l   #PSPANP_SIZEOF_EXP,d5
  1562.         move.l  #-999999,PSPANP_COUNT(a3,d5.l)
  1563.         move.l  a6,-(sp)
  1564.         bsr     _D_PolysetDrawSpans8
  1565.         addq    #4,sp
  1566. .exit
  1567.         add     #.intregs,sp
  1568.         movem.l (sp)+,d2-d7/a2-a6
  1569.         rts
  1570.  
  1571.  
  1572.  
  1573.  
  1574.  
  1575.  
  1576. ******************************************************************************
  1577. *
  1578. *       void D_DrawNonSubdiv (void)
  1579. *
  1580. ******************************************************************************
  1581.         cnop    0,4
  1582. _D_DrawNonSubdiv
  1583.  
  1584.         movem.l d2-d7/a2-a6,-(sp)
  1585.  
  1586. *        pfv = r_affinetridesc.pfinalverts;
  1587. *        ptri = r_affinetridesc.ptriangles;
  1588. *        lnumtriangles = r_affinetridesc.numtriangles;
  1589.  
  1590.         lea     _r_affinetridesc,a0
  1591.         move.l  R_PFINALVERTS(a0),a2    ;pfv = f_affinetridesc.pfinalverts
  1592.         move.l  R_PTRIANGLES(a0),a3     ;ptri = f_affinetridesc.ptriangles
  1593.         move.l  R_NUMTRIANGLES(a0),d3   ;lnumtriangles = r_affine...
  1594.         subq    #1,d3
  1595. .loop
  1596.  
  1597. *                index0 = pfv + ptri->vertindex[0];
  1598. *                index1 = pfv + ptri->vertindex[1];
  1599. *                index2 = pfv + ptri->vertindex[2];
  1600. *
  1601. *                d_xdenom = (index0->v[1]-index1->v[1]) *
  1602. *                                (index0->v[0]-index2->v[0]) -
  1603. *                                (index0->v[0]-index1->v[0])*(index0->v[1]-index2->v[1]);
  1604.  
  1605.         move.l  MT_VERTINDEX+0*4(a3),d0
  1606.         asl.l   #FV_SIZEOF_EXP,d0
  1607.         lea     0(a2,d0.l),a0           ;a0 = index0
  1608.         move.l  MT_VERTINDEX+1*4(a3),d0
  1609.         asl.l   #FV_SIZEOF_EXP,d0
  1610.         lea     0(a2,d0.l),a1           ;a1 = index1
  1611.         move.l  MT_VERTINDEX+2*4(a3),d0
  1612.         asl.l   #FV_SIZEOF_EXP,d0
  1613.         lea     0(a2,d0.l),a4           ;a2 = index2
  1614.         movem.l d3/a3,-(sp)
  1615.         move.l  (a0)+,d0                ;d0 = index0->v[0]
  1616.         move.l  (a0)+,d1                ;d1 = index0->v[1]
  1617.         move.l  (a1)+,a6                ;d2 = index1->v[0]
  1618.         move.l  (a1)+,d2                ;a6 = index1->v[1]
  1619.         move.l  (a4)+,d4                ;d4 = index2->v[0]
  1620.         move.l  (a4)+,d5                ;d5 = index2->v[1]
  1621.         move.l  d0,d6
  1622.         move.l  d1,d7
  1623.         sub.l   d4,d6                   ;index0->v[0]-index2->v[0]
  1624.         sub.l   d2,d7                   ;index0->v[1]-index1->v[1]
  1625.         move.l  d6,d3
  1626.         muls.l  d7,d3
  1627.         move.l  d0,d6
  1628.         move.l  d1,d7
  1629.         sub.l   a6,d6                   ;index0->v[0]-index1->v[0]
  1630.         sub.l   d5,d7                   ;index0->v[1]-index2->v[1]
  1631.         muls.l  d6,d7
  1632.  
  1633. *                if (d_xdenom >= 0)
  1634. *                {
  1635. *                        continue;
  1636. *                }
  1637.  
  1638.         sub.l   d7,d3
  1639.         bge.w   .next                   ;if (d_xdenom >= 0)
  1640.         move.l  d3,_d_xdenom            ;d_xdenom = ...
  1641.  
  1642. *                r_p0[0] = index0->v[0];         // u
  1643. *                r_p0[1] = index0->v[1];         // v
  1644. *                r_p0[2] = index0->v[2];         // s
  1645. *                r_p0[3] = index0->v[3];         // t
  1646. *                r_p0[4] = index0->v[4];         // light
  1647. *                r_p0[5] = index0->v[5];         // iz
  1648. *
  1649. *                r_p1[0] = index1->v[0];
  1650. *                r_p1[1] = index1->v[1];
  1651. *                r_p1[2] = index1->v[2];
  1652. *                r_p1[3] = index1->v[3];
  1653. *                r_p1[4] = index1->v[4];
  1654. *                r_p1[5] = index1->v[5];
  1655. *
  1656. *                r_p2[0] = index2->v[0];
  1657. *                r_p2[1] = index2->v[1];
  1658. *                r_p2[2] = index2->v[2];
  1659. *                r_p2[3] = index2->v[3];
  1660. *                r_p2[4] = index2->v[4];
  1661. *                r_p2[5] = index2->v[5];
  1662.  
  1663.         lea     _r_p1,a5
  1664.         move.l  a6,(a5)+                ;r_p1[0] = index1->v[0]
  1665.         move.l  d2,(a5)+                ;r_p1[1] = index1->v[1]
  1666.         move.l  (a1)+,(a5)+             ;...
  1667.         move.l  (a1)+,(a5)+
  1668.         move.l  (a1)+,(a5)+
  1669.         move.l  (a1)+,(a5)+
  1670.         lea     _r_p0,a6
  1671.         move.l  d0,(a6)+                ;r_p0[0] = index0->v[0]
  1672.         move.l  d1,(a6)+                ;...
  1673.         move.l  (a0)+,(a6)+
  1674.         move.l  (a0)+,(a6)+
  1675.         move.l  (a0)+,(a6)+
  1676.         move.l  (a0)+,(a6)+
  1677.         move.l  MT_FACESFRONT(a3),d6
  1678.         lea     _r_p2,a3                ;r_p2[0] = index2->v[0]
  1679.         move.l  d4,(a3)+                ;...
  1680.         move.l  d5,(a3)+
  1681.         move.l  (a4)+,(a3)+
  1682.         move.l  (a4)+,(a3)+
  1683.         move.l  (a4)+,(a3)+
  1684.         move.l  (a4)+,(a3)+
  1685.  
  1686. *                if (!ptri->facesfront)
  1687. *                {
  1688. *                        if (index0->flags & ALIAS_ONSEAM)
  1689. *                                r_p0[2] += r_affinetridesc.seamfixupX16;
  1690. *                        if (index1->flags & ALIAS_ONSEAM)
  1691. *                                r_p1[2] += r_affinetridesc.seamfixupX16;
  1692. *                        if (index2->flags & ALIAS_ONSEAM)
  1693. *                                r_p2[2] += r_affinetridesc.seamfixupX16;
  1694. *                }
  1695.  
  1696.         tst.l   d6                      ;if (!ptri->facesfront)
  1697.         bne.b   .cont
  1698.         move.l  _r_affinetridesc+R_SEAMFIXUP16,d3
  1699.         move.l  (a0),d0                 ;if (index0->flags & ALIAS_ONSEAM)
  1700.         and.l   #ALIAS_ONSEAM,d0
  1701.         beq.b   .1
  1702.         add.l   d3,-16(a6)              ;r_p0[2] += r_affinetridesc.se...
  1703. .1
  1704.         move.l  (a1),d0
  1705.         and.l   #ALIAS_ONSEAM,d0
  1706.         beq.b   .2
  1707.         add.l   d3,-16(a5)
  1708. .2
  1709.         move.l  (a4),d0
  1710.         and.l   #ALIAS_ONSEAM,d0
  1711.         beq.b   .cont
  1712.         add.l   d3,-16(a3)
  1713. .cont
  1714.  
  1715. ******  D_PolysetSetEdgeTable (inlined)
  1716.  
  1717.         cmp.l   d2,d1
  1718.         blt.b   .lt1
  1719.         beq.b   .eq1
  1720. .gt1
  1721.         moveq   #EDGETABLE_SIZEOF,d0
  1722.         cmp.l   d5,d1
  1723.         beq.b   .eq2
  1724.         cmp.l   d5,d2
  1725.         beq.b   .eq3
  1726.         cmp.l   d5,d1
  1727.         ble.b   .skip
  1728.         add.l   #2*EDGETABLE_SIZEOF,d0
  1729. .skip
  1730.         cmp.l   d5,d2
  1731.         ble.b   .skip2
  1732.         add.l   #4*EDGETABLE_SIZEOF,d0
  1733. .skip2
  1734.         add.l   #_edgetables,d0
  1735.         move.l  d0,_pedgetable
  1736.         bra.b   .done
  1737. .eq2
  1738.         move.l  #_edgetables+8*EDGETABLE_SIZEOF,_pedgetable
  1739.         bra.b   .done
  1740. .eq3
  1741.         move.l  #_edgetables+10*EDGETABLE_SIZEOF,_pedgetable
  1742.         bra.b   .done
  1743. .eq1
  1744.         cmp.l   d5,d1
  1745.         bge.b   .ge
  1746.         move.l  #_edgetables+2*EDGETABLE_SIZEOF,_pedgetable
  1747.         bra.b   .done
  1748. .ge
  1749.         move.l  #_edgetables+5*EDGETABLE_SIZEOF,_pedgetable
  1750.         bra.b   .done
  1751. .lt1
  1752.         moveq   #0,d0
  1753.         cmp.l   d5,d1
  1754.         beq.b   .eq4
  1755.         cmp.l   d5,d2
  1756.         beq.b   .eq5
  1757.         cmp.l   d5,d1
  1758.         ble.b   .skip3
  1759.         add.l   #2*EDGETABLE_SIZEOF,d0
  1760. .skip3
  1761.         cmp.l   d5,d2
  1762.         ble.b   .skip4
  1763.         add.l   #4*EDGETABLE_SIZEOF,d0
  1764. .skip4
  1765.         add.l   #_edgetables,d0
  1766.         move.l  d0,_pedgetable
  1767.         bra.b   .done
  1768. .eq4
  1769.         move.l  #_edgetables+9*EDGETABLE_SIZEOF,_pedgetable
  1770.         bra.b   .done
  1771. .eq5
  1772.         move.l  #_edgetables+11*EDGETABLE_SIZEOF,_pedgetable
  1773. .done
  1774.  
  1775. ******  end of D_PolysetSetEdgeTable
  1776.  
  1777.         bsr     _D_RasterizeAliasPolySmooth
  1778. .next
  1779.         movem.l (sp)+,d3/a3
  1780.         lea     MT_SIZEOF(a3),a3        ;ptri++
  1781.         dbra    d3,.loop
  1782.         movem.l (sp)+,d2-d7/a2-a6
  1783.         rts
  1784.  
  1785. _adivtab
  1786.     dc.l    1,0,1,-1,1,-2,1,-3,1,-4,1
  1787.     dc.l    -5,1,-6,1,-7,2,-1,2,-3,3,0
  1788.     dc.l    3,-3,5,0,7,-1,$F,0,0,0,-$F
  1789.     dc.l    0,-$8,1,-5,0,-4,1,-3,0,-3,3
  1790.     dc.l    -3,6,-2,1,-2,3,-2,5,-2,7,-2
  1791.     dc.l    $9,-2,$B,-2,$D,-1,0,-1,1,0,-$E
  1792.     dc.l    1,0,1,-1,1,-2,1,-3,1,-4,1
  1793.     dc.l    -5,1,-6,2,0,2,-2,2,-4,3,-2
  1794.     dc.l    4,-2,7,0,$E,0,0,0,-$E,0,-7
  1795.     dc.l    0,-5,1,-4,2,-3,1,-3,4,-2,0
  1796.     dc.l    -2,2,-2,4,-2,6,-2,$8,-2,$A,-2
  1797.     dc.l    $C,-1,0,-1,1,-1,2,0,-$D,0,-$D
  1798.     dc.l    1,0,1,-1,1,-2,1,-3,1,-4,1
  1799.     dc.l    -5,1,-6,2,-1,2,-3,3,-1,4,-1
  1800.     dc.l    6,-1,$D,0,0,0,-$D,0,-7,1,-5
  1801.     dc.l    2,-4,3,-3,2,-3,5,-2,1,-2,3
  1802.     dc.l    -2,5,-2,7,-2,$9,-2,$B,-1,0,-1
  1803.     dc.l    1,-1,2,-1,3,0,-$C,0,-$C,0,-$C
  1804.     dc.l    1,0,1,-1,1,-2,1,-3,1,-4,1
  1805.     dc.l    -5,2,0,2,-2,3,0,4,0,6,0
  1806.     dc.l    $C,0,0,0,-$C,0,-6,0,-4,0,-3
  1807.     dc.l    0,-3,3,-2,0,-2,2,-2,4,-2,6
  1808.     dc.l    -2,$8,-2,$A,-1,0,-1,1,-1,2,-1
  1809.     dc.l    3,-1,4,0,-$B,0,-$B,0,-$B,0,-$B
  1810.     dc.l    1,0,1,-1,1,-2,1,-3,1,-4,1
  1811.     dc.l    -5,2,-1,2,-3,3,-2,5,-1,$B,0
  1812.     dc.l    0,0,-$B,0,-6,1,-4,1,-3,1,-3
  1813.     dc.l    4,-2,1,-2,3,-2,5,-2,7,-2,$9
  1814.     dc.l    -1,0,-1,1,-1,2,-1,3,-1,4,-1
  1815.     dc.l    5,0,-$A,0,-$A,0,-$A,0,-$A,0,-$A
  1816.     dc.l    1,0,1,-1,1,-2,1,-3,1,-4,2
  1817.     dc.l    0,2,-2,3,-1,5,0,$A,0,0,0
  1818.     dc.l    -$A,0,-5,0,-4,2,-3,2,-2,0,-2
  1819.     dc.l    2,-2,4,-2,6,-2,$8,-1,0,-1,1
  1820.     dc.l    -1,2,-1,3,-1,4,-1,5,-1,6,0
  1821.     dc.l    -$9,0,-$9,0,-$9,0,-$9,0,-$9,0,-$9
  1822.     dc.l    1,0,1,-1,1,-2,1,-3,1,-4,2
  1823.     dc.l    -1,3,0,4,-1,$9,0,0,0,-$9,0
  1824.     dc.l    -5,1,-3,0,-3,3,-2,1,-2,3,-2
  1825.     dc.l    5,-2,7,-1,0,-1,1,-1,2,-1,3
  1826.     dc.l    -1,4,-1,5,-1,6,-1,7,0,-$8,0
  1827.     dc.l    -$8,0,-$8,0,-$8,0,-$8,0,-$8,0,-$8
  1828.     dc.l    1,0,1,-1,1,-2,1,-3,2,0,2
  1829.     dc.l    -2,4,0,$8,0,0,0,-$8,0,-4,0
  1830.     dc.l    -3,1,-2,0,-2,2,-2,4,-2,6,-1
  1831.     dc.l    0,-1,1,-1,2,-1,3,-1,4,-1,5
  1832.     dc.l    -1,6,-1,7,-1,$8,0,-7,0,-7,0
  1833.     dc.l    -7,0,-7,0,-7,0,-7,0,-7,0,-7
  1834.     dc.l    1,0,1,-1,1,-2,1,-3,2,-1,3
  1835.     dc.l    -1,7,0,0,0,-7,0,-4,1,-3,2
  1836.     dc.l    -2,1,-2,3,-2,5,-1,0,-1,1,-1
  1837.     dc.l    2,-1,3,-1,4,-1,5,-1,6,-1,7
  1838.     dc.l    -1,$8,-1,$9,0,-6,0,-6,0,-6,0
  1839.     dc.l    -6,0,-6,0,-6,0,-6,0,-6,0,-6
  1840.     dc.l    1,0,1,-1,1,-2,2,0,3,0,6
  1841.     dc.l    0,0,0,-6,0,-3,0,-2,0,-2,2
  1842.     dc.l    -2,4,-1,0,-1,1,-1,2,-1,3,-1
  1843.     dc.l    4,-1,5,-1,6,-1,7,-1,$8,-1,$9
  1844.     dc.l    -1,$A,0,-5,0,-5,0,-5,0,-5,0
  1845.     dc.l    -5,0,-5,0,-5,0,-5,0,-5,0,-5
  1846.     dc.l    1,0,1,-1,1,-2,2,-1,5,0,0
  1847.     dc.l    0,-5,0,-3,1,-2,1,-2,3,-1,0
  1848.     dc.l    -1,1,-1,2,-1,3,-1,4,-1,5,-1
  1849.     dc.l    6,-1,7,-1,$8,-1,$9,-1,$A,-1,$B
  1850.     dc.l    0,-4,0,-4,0,-4,0,-4,0,-4,0
  1851.     dc.l    -4,0,-4,0,-4,0,-4,0,-4,0,-4
  1852.     dc.l    1,0,1,-1,2,0,4,0,0,0,-4
  1853.     dc.l    0,-2,0,-2,2,-1,0,-1,1,-1,2
  1854.     dc.l    -1,3,-1,4,-1,5,-1,6,-1,7,-1
  1855.     dc.l    $8,-1,$9,-1,$A,-1,$B,-1,$C,0,-3
  1856.     dc.l    0,-3,0,-3,0,-3,0,-3,0,-3,0
  1857.     dc.l    -3,0,-3,0,-3,0,-3,0,-3,0,-3
  1858.     dc.l    1,0,1,-1,3,0,0,0,-3,0,-2
  1859.     dc.l    1,-1,0,-1,1,-1,2,-1,3,-1,4
  1860.     dc.l    -1,5,-1,6,-1,7,-1,$8,-1,$9,-1
  1861.     dc.l    $A,-1,$B,-1,$C,-1,$D,0,-2,0,-2
  1862.     dc.l    0,-2,0,-2,0,-2,0,-2,0,-2,0
  1863.     dc.l    -2,0,-2,0,-2,0,-2,0,-2,0,-2
  1864.     dc.l    1,0,2,0,0,0,-2,0,-1,0,-1
  1865.     dc.l    1,-1,2,-1,3,-1,4,-1,5,-1,6
  1866.     dc.l    -1,7,-1,$8,-1,$9,-1,$A,-1,$B,-1
  1867.     dc.l    $C,-1,$D,-1,$E,0,-1,0,-1,0,-1
  1868.     dc.l    0,-1,0,-1,0,-1,0,-1,0,-1,0
  1869.     dc.l    -1,0,-1,0,-1,0,-1,0,-1,0,-1
  1870.     dc.l    1,0,0,0,-1,0,-1,1,-1,2,-1
  1871.     dc.l    3,-1,4,-1,5,-1,6,-1,7,-1,$8
  1872.     dc.l    -1,$9,-1,$A,-1,$B,-1,$C,-1,$D,-1
  1873.     dc.l    $E,-1,$F,0,0,0,0,0,0,0,0
  1874.     dc.l    0,0,0,0,0,0,0,0,0,0,0
  1875.     dc.l    0,0,0,0,0,0,0,0,0,0,0
  1876.     dc.l    0,0,0,0,0,0,0,0,0,0,0
  1877.     dc.l    0,0,0,0,0,0,0,0,0,0,0
  1878.     dc.l    0,0,0,0,0,0,0,0,0,0,0
  1879.     dc.l    0,-1,-$E,-1,-$D,-1,-$C,-1,-$B,-1,-$A
  1880.     dc.l    -1,-$9,-1,-$8,-1,-7,-1,-6,-1,-5,-1
  1881.     dc.l    -4,-1,-3,-1,-2,-1,-1,-1,0,0,0
  1882.     dc.l    1,0,0,1,0,1,0,1,0,1,0
  1883.     dc.l    1,0,1,0,1,0,1,0,1,0,1
  1884.     dc.l    0,1,0,1,0,1,0,1,0,1,-1
  1885.     dc.l    -$D,-1,-$C,-1,-$B,-1,-$A,-1,-$9,-1,-$8
  1886.     dc.l    -1,-7,-1,-6,-1,-5,-1,-4,-1,-3,-1
  1887.     dc.l    -2,-1,-1,-1,0,-2,0,0,0,2,0
  1888.     dc.l    1,0,0,2,0,2,0,2,0,2,0
  1889.     dc.l    2,0,2,0,2,0,2,0,2,0,2
  1890.     dc.l    0,2,0,2,0,2,0,2,-1,-$C,-1
  1891.     dc.l    -$B,-1,-$A,-1,-$9,-1,-$8,-1,-7,-1,-6
  1892.     dc.l    -1,-5,-1,-4,-1,-3,-1,-2,-1,-1,-1
  1893.     dc.l    0,-2,-1,-3,0,0,0,3,0,1,1
  1894.     dc.l    1,0,0,3,0,3,0,3,0,3,0
  1895.     dc.l    3,0,3,0,3,0,3,0,3,0,3
  1896.     dc.l    0,3,0,3,0,3,-1,-$B,-1,-$A,-1
  1897.     dc.l    -$9,-1,-$8,-1,-7,-1,-6,-1,-5,-1,-4
  1898.     dc.l    -1,-3,-1,-2,-1,-1,-1,0,-2,-2,-2
  1899.     dc.l    0,-4,0,0,0,4,0,2,0,1,1
  1900.     dc.l    1,0,0,4,0,4,0,4,0,4,0
  1901.     dc.l    4,0,4,0,4,0,4,0,4,0,4
  1902.     dc.l    0,4,0,4,-1,-$A,-1,-$9,-1,-$8,-1
  1903.     dc.l    -7,-1,-6,-1,-5,-1,-4,-1,-3,-1,-2
  1904.     dc.l    -1,-1,-1,0,-2,-3,-2,-1,-3,-1,-5
  1905.     dc.l    0,0,0,5,0,2,1,1,2,1,1
  1906.     dc.l    1,0,0,5,0,5,0,5,0,5,0
  1907.     dc.l    5,0,5,0,5,0,5,0,5,0,5
  1908.     dc.l    0,5,-1,-$9,-1,-$8,-1,-7,-1,-6,-1
  1909.     dc.l    -5,-1,-4,-1,-3,-1,-2,-1,-1,-1,0
  1910.     dc.l    -2,-4,-2,-2,-2,0,-3,0,-6,0,0
  1911.     dc.l    0,6,0,3,0,2,0,1,2,1,1
  1912.     dc.l    1,0,0,6,0,6,0,6,0,6,0
  1913.     dc.l    6,0,6,0,6,0,6,0,6,0,6
  1914.     dc.l    -1,-$8,-1,-7,-1,-6,-1,-5,-1,-4,-1
  1915.     dc.l    -3,-1,-2,-1,-1,-1,0,-2,-5,-2,-3
  1916.     dc.l    -2,-1,-3,-2,-4,-1,-7,0,0,0,7
  1917.     dc.l    0,3,1,2,1,1,3,1,2,1,1
  1918.     dc.l    1,0,0,7,0,7,0,7,0,7,0
  1919.     dc.l    7,0,7,0,7,0,7,0,7,-1,-7
  1920.     dc.l    -1,-6,-1,-5,-1,-4,-1,-3,-1,-2,-1
  1921.     dc.l    -1,-1,0,-2,-6,-2,-4,-2,-2,-2,0
  1922.     dc.l    -3,-1,-4,0,-$8,0,0,0,$8,0,4
  1923.     dc.l    0,2,2,2,0,1,3,1,2,1,1
  1924.     dc.l    1,0,0,$8,0,$8,0,$8,0,$8,0
  1925.     dc.l    $8,0,$8,0,$8,0,$8,-1,-6,-1,-5
  1926.     dc.l    -1,-4,-1,-3,-1,-2,-1,-1,-1,0,-2
  1927.     dc.l    -7,-2,-5,-2,-3,-2,-1,-3,-3,-3,0
  1928.     dc.l    -5,-1,-$9,0,0,0,$9,0,4,1,3
  1929.     dc.l    0,2,1,1,4,1,3,1,2,1,1
  1930.     dc.l    1,0,0,$9,0,$9,0,$9,0,$9,0
  1931.     dc.l    $9,0,$9,0,$9,-1,-5,-1,-4,-1,-3
  1932.     dc.l    -1,-2,-1,-1,-1,0,-2,-$8,-2,-6,-2
  1933.     dc.l    -4,-2,-2,-2,0,-3,-2,-4,-2,-5,0
  1934.     dc.l    -$A,0,0,0,$A,0,5,0,3,1,2
  1935.     dc.l    2,2,0,1,4,1,3,1,2,1,1
  1936.     dc.l    1,0,0,$A,0,$A,0,$A,0,$A,0
  1937.     dc.l    $A,0,$A,-1,-4,-1,-3,-1,-2,-1,-1
  1938.     dc.l    -1,0,-2,-$9,-2,-7,-2,-5,-2,-3,-2
  1939.     dc.l    -1,-3,-4,-3,-1,-4,-1,-6,-1,-$B,0
  1940.     dc.l    0,0,$B,0,5,1,3,2,2,3,2
  1941.     dc.l    1,1,5,1,4,1,3,1,2,1,1
  1942.     dc.l    1,0,0,$B,0,$B,0,$B,0,$B,0
  1943.     dc.l    $B,-1,-3,-1,-2,-1,-1,-1,0,-2,-$A
  1944.     dc.l    -2,-$8,-2,-6,-2,-4,-2,-2,-2,0,-3
  1945.     dc.l    -3,-3,0,-4,0,-6,0,-$C,0,0,0
  1946.     dc.l    $C,0,6,0,4,0,3,0,2,2,2
  1947.     dc.l    0,1,5,1,4,1,3,1,2,1,1
  1948.     dc.l    1,0,0,$C,0,$C,0,$C,0,$C,-1
  1949.     dc.l    -2,-1,-1,-1,0,-2,-$B,-2,-$9,-2,-7
  1950.     dc.l    -2,-5,-2,-3,-2,-1,-3,-5,-3,-2,-4
  1951.     dc.l    -3,-5,-2,-7,-1,-$D,0,0,0,$D,0
  1952.     dc.l    6,1,4,1,3,1,2,3,2,1,1
  1953.     dc.l    6,1,5,1,4,1,3,1,2,1,1
  1954.     dc.l    1,0,0,$D,0,$D,0,$D,-1,-1,-1
  1955.     dc.l    0,-2,-$C,-2,-$A,-2,-$8,-2,-6,-2,-4
  1956.     dc.l    -2,-2,-2,0,-3,-4,-3,-1,-4,-2,-5
  1957.     dc.l    -1,-7,0,-$E,0,0,0,$E,0,7,0
  1958.     dc.l    4,2,3,2,2,4,2,2,2,0,1
  1959.     dc.l    6,1,5,1,4,1,3,1,2,1,1
  1960.     dc.l    1,0,0,$E,0,$E,-1,0,-2,-$D,-2
  1961.     dc.l    -$B,-2,-$9,-2,-7,-2,-5,-2,-3,-2,-1
  1962.     dc.l    -3,-6,-3,-3,-3,0,-4,-1,-5,0,-$8
  1963.     dc.l    -1,-$F,0,0,0,$F,0,7,1,5,0
  1964.     dc.l    3,3,3,0,2,3,2,1,1,7,1
  1965.     dc.l    6,1,5,1,4,1,3,1,2,1,1
  1966.     dc.l    1,0,0,$F,-2,-$E,-2,-$C,-2,-$A,-2
  1967.     dc.l    -$8,-2,-6,-2,-4,-2,-2,-2,0,-3,-5
  1968.     dc.l    -3,-2,-4,-4,-4,0,-6,-2,-$8,0,-$10
  1969.     dc.l    0,0,0,$10,0,$8,0,5,1,4,0
  1970.     dc.l    3,1,2,4,2,2,2,0,1,7,1
  1971.     dc.l    6,1,5,1,4,1,3,1,2,1,1
  1972.     dc.l    1,0
  1973.  
  1974.