home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 113 / EnigmaAmiga113CD.iso / software / sviluppo / quakeworld_src / client / d_scanppc.s < prev    next >
Encoding:
Text File  |  2000-06-17  |  48.6 KB  |  1,536 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. ##
  23. ## d_scanPPC.s
  24. ##
  25. ## Define WOS for PowerOpen ABI, otherwise SVR4-ABI is used.
  26. ##
  27.  
  28. .set NOLR,1
  29. .include        "macrosPPC.i"
  30.  
  31. .macro    rsreset
  32. .set    rscnt,0
  33. .endm
  34.  
  35. .macro    rs
  36. .set    \1,rscnt
  37. .set    rscnt,rscnt+\2
  38. .endm
  39.  
  40. #
  41. # external references
  42. #
  43.     xrefv    cacheblock
  44.     xrefv    d_sdivzorigin
  45.     xrefv    d_sdivzstepu
  46.     xrefv    d_sdivzstepv
  47.     xrefv    d_tdivzorigin
  48.     xrefv    d_tdivzstepu
  49.     xrefv    d_tdivzstepv
  50.     xrefv    d_ziorigin
  51.     xrefv    d_zistepu
  52.     xrefv    d_zistepv
  53.     xrefv    sadjust
  54.     xrefv    tadjust
  55.     xrefv    sdivz
  56.     xrefv    tdivz
  57.     xrefv    bbextents
  58.     xrefv    bbextentt
  59.     xrefv    d_viewbuffer
  60.     xrefv    screenwidth
  61.     xrefv    cachewidth
  62.     xrefv    d_zwidth
  63.     xrefv    d_pzbuffer
  64.     xrefv    sintable
  65.  
  66.     xrefa    d_subdiv16
  67.     xrefa    cl
  68.     xrefa    intsintable
  69.     xrefa    sintable
  70.     xrefa    vid
  71.     xrefa    scr_vrect
  72.     xrefa    r_refdef
  73.  
  74.     xrefv    INT2DBL_0
  75.     xrefv    c0
  76.     xrefv    c2
  77.     xrefv    c65536
  78.     xrefa    _ReciprocTable
  79.  
  80.  
  81. #
  82. # defines
  83. #
  84.  
  85. .set    QDIV,1
  86. .set    NICE_DIV,1
  87.  
  88. .set    PSPAN_NEXT,12
  89. .set    CL_TIME,438452
  90. .set    VID_BUFFER,0
  91. .set    VID_ROWBYTES,16
  92.  
  93. .set    SCR_VRECT_X,0
  94. .set    SCR_VRECT_Y,4
  95. .set    SCR_VRECT_WIDTH,8
  96. .set    SCR_VRECT_HEIGHT,12
  97.  
  98. .set    REFDEF_VRECT_X,0
  99. .set    REFDEF_VRECT_Y,4
  100. .set    REFDEF_VRECT_WIDTH,8
  101. .set    REFDEF_VRECT_HEIGHT,12
  102. .set    CVAR_VALUE,16
  103.  
  104. # MUST match the #define in d_iface.h!
  105. .set    CYCLE,128
  106. .set    AMP2,3
  107. .set    SPEED,20
  108.  
  109.  
  110.  
  111.  
  112.  
  113. ###########################################################################
  114. #
  115. #       void D_WarpScreen (void)
  116. #
  117. #       water effect algorithm
  118. #
  119. ###########################################################################
  120.  
  121.     funcdef    D_WarpScreen
  122.  
  123.     rsreset
  124.     rs    int2dbl_tmp1,8
  125.     rs    dbl2int_tmp1,8
  126.     rs    rowptr,1024*4
  127.     rs    column,1280*4
  128.  
  129.     init    0,rscnt+512,8,0
  130.     stmw    r24,gb(r1)
  131.     la    r4,local+rowptr(r1)        #r4 -> rowptr[1024]
  132.     la    r5,local+column(r1)        #r5 -> column[1280]
  133.     lf    f1,INT2DBL_0            #f1 = 0x4330000080000000
  134.     stfd    f1,local+int2dbl_tmp1(r1)    #int2dbl_tmp1 = 0x43300000...
  135.  
  136.     lxa    r6,vid                #r6 -> vid
  137.     lxa    r7,r_refdef            #r7 -> r_refdef
  138.     lxa    r8,scr_vrect            #r8 -> scr_vrect
  139.     lwz    r9,SCR_VRECT_WIDTH(r8)        #r9 = scr_vrect.width
  140.     lwz    r10,SCR_VRECT_HEIGHT(r8)    #r10 = scr_vrect.height
  141.     lwz    r11,REFDEF_VRECT_X(r7)        #r11 = r_refdef.vrect.x
  142.     lwz    r12,REFDEF_VRECT_Y(r7)        #r12 = r_refdef.vrect.y
  143.     lwz    r0,REFDEF_VRECT_WIDTH(r7)
  144.     int2dbl    f2,r0,r0,local+int2dbl_tmp1,f1    #f2 = (float)r_refdef.vrect.width
  145.     lwz    r0,REFDEF_VRECT_HEIGHT(r7)
  146.     int2dbl f3,r0,r0,local+int2dbl_tmp1,f1    #f3 = (float)r_refdef.vrect.height
  147.     lw      r31,screenwidth            #r31 = screenwidth
  148.     ls      f4,cAMP2times2            #f4 = AMP2*2
  149.  
  150. #        w = r_refdef.vrect.width;
  151. #        h = r_refdef.vrect.height;
  152. #
  153. #        wratio = w / (float)scr_vrect.width;
  154. #        hratio = h / (float)scr_vrect.height;
  155.  
  156.     fadds    f5,f2,f4                #f5 = w + AMP2*2
  157.     fadds    f6,f3,f4                #f6 = h + AMP2*2
  158.     int2dbl f0,r9,r0,local+int2dbl_tmp1,f1
  159.     fmuls    f5,f5,f0        #* (float)scr_vrect.width
  160.     int2dbl    f0,r10,r0,local+int2dbl_tmp1,f1
  161.     fmuls    f6,f6,f0        #* (float)scr_vrect.height
  162.     fmuls    f2,f2,f2        #w*w
  163.     fmuls    f3,f3,f3        #h*h
  164.     fdivs    f2,f2,f5        #f2 = wratio*w/(w+AMP2*2)
  165.     fdivs    f3,f3,f6        #f3 = hratio*h/(h+AMP2*2)
  166.     mullw    r12,r12,r31        #r12 = r_refdef.vrect.y*screenwidth
  167.     lw    r29,d_viewbuffer
  168.     add    r12,r12,r29        #r12 = d_viewbuffer + r12
  169.     lwz    r29,VID_ROWBYTES(r6)    #r29 = vid.rowbytes
  170.     addi    r27,r9,AMP2*2
  171.     addi    r28,r10,AMP2*2
  172.  
  173. #        for (v=0 ; v<scr_vrect.height+AMP2*2 ; v++)
  174. #        {
  175. #                rowptr[v] = d_viewbuffer + (r_refdef.vrect.y * screenwidth) +
  176. #                                 (screenwidth * (int)((float)v * hratio * h / (h + AMP2 * 2)));
  177. #        }
  178.  
  179.     li    r26,0            #v = 0
  180.     subi    r25,r4,4        #r25 -> rowptr[0] - 4
  181. .wsloop:
  182.     int2dbl    f7,r26,r0,local+int2dbl_tmp1,f1 #f7 = (float)v
  183.     fmuls    f7,f7,f3                #(float)v*hratio*h/(h+AMP2*2)
  184.     fctiwz    f0,f7
  185.     stfd    f0,local+dbl2int_tmp1(r1)
  186.     lwz    r24,local+dbl2int_tmp1+4(r1) #r24 = (int)f7
  187.     mullw    r24,r24,r31
  188.     add    r24,r24,r12
  189.     addi    r26,r26,1               #v++
  190.     stwu    r24,4(r25)              #rowptr[v] = r24
  191.     cmpw    r26,r28
  192.     blt    .wsloop
  193.  
  194. #        for (u=0 # u<scr_vrect.width+AMP2*2 ; u++)
  195. #        {
  196. #                column[u] = r_refdef.vrect.x +
  197. #                                (int)((float)u * wratio * w / (w + AMP2 * 2));
  198. #        }
  199.     li    r26,0                   #u = 0
  200.     subi    r25,r5,4                #r25 -> column[0]
  201. .wsloop2:
  202.     int2dbl    f7,r26,r0,local+int2dbl_tmp1,f1 #f7 = (float)u
  203.     fmuls    f7,f7,f2        #(float)u*wratio*w/(w+AMP2*2)
  204.     fctiwz    f0,f7
  205.     stfd    f0,local+dbl2int_tmp1(r1)
  206.     lwz    r24,local+dbl2int_tmp1+4(r1) #r24 = (int)f7
  207.     add    r24,r24,r11
  208.     addi    r26,r26,1        #u++
  209.     stwu    r24,4(r25)        #column[u] = r24
  210.     cmpw    r26,r27
  211.     blt    .wsloop2
  212.  
  213. #        turb = intsintable + ((int)(cl.time*SPEED)&(CYCLE-1));
  214. #        dest = vid.buffer + scr_vrect.y * vid.rowbytes + scr_vrect.x;
  215. #        for (v=0 ; v<scr_vrect.height ; v++, dest += vid.rowbytes)
  216. #        {
  217. #                col = &column[turb[v]];
  218. #                row = &rowptr[v];
  219. #                for (u=0 ; u<scr_vrect.width ; u+=4)
  220. #                {
  221. #                        dest[u+0] = row[turb[u+0]][col[u+0]];
  222. #                        dest[u+1] = row[turb[u+1]][col[u+1]];
  223. #                        dest[u+2] = row[turb[u+2]][col[u+2]];
  224. #                        dest[u+3] = row[turb[u+3]][col[u+3]];
  225. #                }
  226. #        }
  227.  
  228.     srawi    r9,r9,2
  229.     lxa    r28,cl
  230.     addis    r28,r28,CL_TIME@ha
  231.     lfd    f7,CL_TIME@l(r28)
  232.     ls    f0,cSPEED
  233.     fmuls    f7,f7,f0
  234.     fctiwz    f0,f7
  235.     stfd    f0,local+dbl2int_tmp1(r1)
  236.     lwz    r27,local+dbl2int_tmp1+4(r1)
  237.     andi.    r27,r27,CYCLE-1
  238.     slwi    r27,r27,2
  239.     lxa    r26,intsintable
  240.     add    r27,r27,r26        #r27 = turb = sintable + ...
  241.  
  242.     lwz    r28,SCR_VRECT_Y(r8)
  243.     mullw    r28,r28,r29
  244.     lwz    r26,SCR_VRECT_X(r8)
  245.     add    r26,r26,r28
  246.     lwz    r28,VID_BUFFER(r6)
  247.     add    r26,r26,r28        #r26 = dest = vid.buffer + ...
  248.  
  249.     li    r6,0
  250. .wsloop3:
  251.     slwi    r0,r6,2
  252.     mtctr    r9
  253.     subi    r7,r27,4        #r7 -> turb[u] - 4
  254.     lwzx    r8,r27,r0        #r8 = turb[v]
  255.     subi    r11,r26,1        #r11 -> dest[u] - 1
  256.     slwi    r8,r8,2
  257.     add    r12,r5,r8        #r12 = col = &column[turb[v]]
  258.     subi    r12,r12,4
  259.     add    r31,r4,r0        #r31 = row = &rowptr[v]
  260. .wsloop4:
  261.     lwzu    r0,4(r7)        #r0 = turb[u+0]
  262.     slwi    r0,r0,2
  263.     lwzx    r30,r31,r0        #r30 = row[turb[u+0]]
  264.     lwzu    r0,4(r12)        #r0 = col[u+0]
  265.     lbzx    r0,r30,r0        #r0 = row[turb[u+0][col[u+0]]
  266.     stbu    r0,1(r11)        #dest[u+0] = r0
  267.     lwzu    r0,4(r7)        #r0 = turb[u+0]
  268.     slwi    r0,r0,2
  269.     lwzx    r30,r31,r0        #r30 = row[turb[u+0]]
  270.     lwzu    r0,4(r12)        #r0 = col[u+0]
  271.     lbzx    r0,r30,r0        #r0 = row[turb[u+0][col[u+0]]
  272.     stbu    r0,1(r11)        #dest[u+0] = r0
  273.     lwzu    r0,4(r7)        #r0 = turb[u+0]
  274.     slwi    r0,r0,2
  275.     lwzx    r30,r31,r0        #r30 = row[turb[u+0]]
  276.     lwzu    r0,4(r12)        #r0 = col[u+0]
  277.     lbzx    r0,r30,r0        #r0 = row[turb[u+0][col[u+0]]
  278.     stbu    r0,1(r11)        #dest[u+0] = r0
  279.     lwzu    r0,4(r7)        #r0 = turb[u+0]
  280.     slwi    r0,r0,2
  281.     lwzx    r30,r31,r0        #r30 = row[turb[u+0]]
  282.     lwzu    r0,4(r12)        #r0 = col[u+0]
  283.     lbzx    r0,r30,r0        #r0 = row[turb[u+0][col[u+0]]
  284.     stbu    r0,1(r11)        #dest[u+0] = r0
  285.     bdnz    .wsloop4
  286.     add    r26,r26,r29        #dest += vid.rowbytes
  287.     addi    r6,r6,1
  288.     cmpw    r6,r10
  289.     blt    .wsloop3
  290.  
  291.     lmw    r24,gb(r1)
  292.     exit
  293.  
  294.     funcend    D_WarpScreen
  295.  
  296.  
  297.  
  298.  
  299. ###########################################################################
  300. #
  301. #       void Turbulent8 (espan_t *pspan)
  302. #
  303. #       standard scan drawing function for animated textures
  304. #       Note: The function D_DrawTurbulent8Span was inlined into this
  305. #       function, because it's never used anywhere else.
  306. #
  307. ###########################################################################
  308.  
  309.     funcdef    Turbulent8
  310.  
  311.     init    0,16,7,16        # 16 local bytes for int2dbl/dbl2int
  312.     stmw    r25,gb(r1)
  313.     stfd    f14,fb+0*8(r1)
  314.     stfd    f15,fb+1*8(r1)
  315.     stfd    f16,fb+2*8(r1)
  316.     stfd    f17,fb+3*8(r1)
  317.     stfd    f18,fb+4*8(r1)
  318.     stfd    f19,fb+5*8(r1)
  319.     stfd    f20,fb+6*8(r1)
  320.     stfd    f21,fb+7*8(r1)
  321.     stfd    f22,fb+8*8(r1)
  322.     stfd    f23,fb+9*8(r1)
  323.     stfd    f24,fb+10*8(r1)
  324.     stfd    f25,fb+11*8(r1)
  325.     stfd    f26,fb+12*8(r1)
  326.     stfd    f27,fb+13*8(r1)
  327.     stfd    f28,fb+14*8(r1)
  328.     stfd    f29,fb+15*8(r1)
  329.  
  330.     lxa    r26,_ReciprocTable
  331.     lw      r27,cacheblock          #r27 = r_turb_pbase
  332.     lxa     r5,cl
  333.     addis    r5,r5,CL_TIME@ha
  334.     lfd     f1,CL_TIME@l(r5)
  335.     ls      f2,cSPEED
  336.     fmuls   f1,f1,f2
  337.     fctiwz  f0,f1
  338.     stfd    f0,local+8(r1)
  339.     lwz     r4,local+12(r1)
  340.     andi.   r4,r4,CYCLE-1
  341.     slwi    r4,r4,2
  342.     lxa     r5,sintable
  343.     add     r4,r4,r5                #r4 = r_turb_turb = sintable + ...
  344.     ls      f1,d_sdivzstepu         #f1 = d_sdivzstepu
  345.     ls      f2,d_sdivzstepv         #f2 = d_sdivzstepv
  346.     ls      f3,d_sdivzorigin        #f3 = d_sdivzorigin
  347.     ls      f4,d_tdivzstepu         #f4 = d_tdivzstepu
  348.     ls      f5,d_tdivzstepv         #f5 = d_tdivzstepv
  349.     ls      f6,d_tdivzorigin        #f6 = d_tdivzorigin
  350.     ls      f7,d_zistepu            #f7 = d_zistepu
  351.     ls      f8,d_zistepv            #f8 = d_zistepv
  352.     ls      f9,d_ziorigin           #f9 = d_ziorigin
  353.     lf      f10,INT2DBL_0           #for int2dbl_setup
  354.     stfd    f10,local(r1)
  355.     lw      r6,sadjust
  356.     int2dbl f11,r6,r0,local,f10    #f11 = sadjust
  357.     lw      r6,tadjust
  358.     int2dbl f12,r6,r0,local,f10    #f12 = tadjust
  359.     lw      r6,bbextents
  360.     int2dbl f13,r6,r0,local,f10    #f13 = bbextents
  361.     lw      r6,bbextentt
  362.     int2dbl f14,r6,r0,local,f10    #f14 = bbextentt
  363.     lw      r6,d_viewbuffer         #r6 = d_viewbuffer
  364.     lw      r7,screenwidth          #r7 = screenwidth
  365.     ls      f15,c65536              #f15 = 65536
  366.     ls      f16,c16                    #f16 = 16
  367.     ls      f25,c0                  #f25 = 0
  368.     ls      f28,c2                  #f28 = 2
  369.     fmuls   f17,f1,f16              #f17 = sdivz16stepu
  370.     fmuls   f18,f4,f16              #f18 = tdivz16stepu
  371.     fmuls   f19,f7,f16              #f19 = zi16stepu
  372.     subi    r3,r3,4                 #prepare for postincrement
  373.  
  374. ######  First loop. In every iteration one complete span is drawn
  375.  
  376. #        pbase = (unsigned char *)cacheblock;
  377. #
  378. #        sdivz16stepu = d_sdivzstepu * 16;
  379. #        tdivz16stepu = d_tdivzstepu * 16;
  380. #        zi16stepu = d_zistepu * 16;
  381. #
  382. #        do
  383. #        {
  384. #                r_turb_pdest = (unsigned char *)((byte *)d_viewbuffer +
  385. #                                (screenwidth * pspan->v) + pspan->u);
  386. #
  387. #                count = pspan->count;
  388. #
  389. #        // calculate the initial s/z, t/z, 1/z, s, and t and clamp
  390. #                du = (float)pspan->u;
  391. #                dv = (float)pspan->v;
  392. #
  393. #                sdivz = d_sdivzorigin + dv*d_sdivzstepv + du*d_sdivzstepu;
  394. #                tdivz = d_tdivzorigin + dv*d_tdivzstepv + du*d_tdivzstepu;
  395. #                zi = d_ziorigin + dv*d_zistepv + du*d_zistepu;
  396. #                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
  397. #
  398.  
  399. .t8loop:
  400.     lwzu    r8,4(r3)
  401.     int2dbl f20,r8,r0,local,f10    #f20 = du
  402.     lwzu    r9,4(r3)
  403.     int2dbl f21,r9,r0,local,f10    #f21 = dv
  404.     fmadds  f24,f21,f8,f9
  405.     fmadds  f22,f21,f2,f3
  406.     fmadds  f23,f21,f5,f6
  407.     fmadds  f26,f20,f7,f24          #f26 = zi
  408.     fmadds  f22,f20,f1,f22          #f22 = sdivz
  409.     fmadds  f23,f20,f4,f23          #f23 = tdivz
  410.     fmuls   f0,f26,f26
  411.     frsqrte f0,f0
  412.     mullw   r10,r9,r7               #r10 = pspan->v * screenwidth
  413.     fnmsubs f29,f0,f26,f28
  414.     add     r10,r10,r8              #r10 = r10 + pspan->u
  415.     fmuls   f0,f0,f29
  416.     add     r11,r6,r10              #r11 = pdest
  417.     fnmsubs f29,f0,f26,f28
  418.     subi    r11,r11,1               #prepare for postincrement
  419.     fmuls   f0,f0,f29
  420.     lwzu    r12,4(r3)               #r12 = count
  421.     fmuls   f24,f0,f15
  422.     fmadds  f20,f22,f24,f11         #f20 = s
  423.     fsubs   f0,f20,f13
  424.     fsel    f20,f0,f13,f20          #if (s>bb...) s = bbextents
  425.     fsel    f20,f20,f20,f25         #if (s<0) s = 0
  426.     fctiwz  f0,f20
  427.     stfd    f0,local+8(r1)
  428.     lwz     r8,local+12(r1)         #r8 = (int)s
  429.     fmadds  f21,f23,f24,f12         #f21 = t
  430.     fsubs   f0,f21,f14
  431.     fsel    f21,f0,f14,f21          #if (t>bb...) t = bbextentt
  432.     fsel    f21,f21,f21,f25         #if (t<0) t = 0
  433.     fctiwz  f0,f21
  434.     stfd    f0,local+8(r1)
  435.     lwz     r9,local+12(r1)         #r9 = (int)t
  436.  
  437.  
  438. ######  Second loop. In every iteration one part of the whole span is drawn
  439.  
  440. #                do
  441. #                {
  442. #                // calculate s and t at the far end of the span
  443. #                        if (count >= 16)
  444. #                                r_turb_spancount = 16;
  445. #                        else
  446. #                                r_turb_spancount = count;
  447. #
  448. #                        count -= r_turb_spancount;
  449. #
  450. #                        if (count)
  451. #                        {
  452.  
  453. .t8loop2:
  454.     cmpwi   r12,16
  455.     bgt     .t8cont
  456.     mtctr   r12
  457.     subi    r10,r12,1
  458.     int2dbl f21,r10,r0,local,f10    #spancountminus1 = (float)...
  459.     li      r12,0                   #r12 = count -= spancount
  460.     fmadds  f26,f21,f7,f26          #zi += d_zistepu * ...
  461.     b       .t8finalpart
  462. .t8cont:
  463.     fadds   f26,f26,f19             #zi += zi16stepu
  464.     li      r10,16                  #r10 = spancount = 16
  465.     fmuls   f0,f26,f26
  466.     subf    r12,r10,r12             #r12 = count -= spancount
  467.     frsqrte f0,f0
  468.     mtctr   r10
  469.  
  470. ######  Evaluation of the values for the inner loop. This version is used for
  471. ######  span size = 16
  472.  
  473. #                        // calculate s/z, t/z, zi->fixed s and t at far end of span,
  474. #                        // calculate s and t steps across span by shifting
  475. #                                sdivz += sdivz16stepu;
  476. #                                tdivz += tdivz16stepu;
  477. #                                zi += zi16stepu;
  478. #                                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
  479. #                                snext = (int)(sdivz * z) + sadjust;
  480. #                                if (snext > bbextents)
  481. #                                        snext = bbextents;
  482. #                                else if (snext < 16)
  483. #                                        snext = 16;      // prevent round-off error on <0 steps from
  484. #                                                                //  from causing overstepping & running off the
  485. #                                                                //  edge of the texture
  486. #                                tnext = (int)(tdivz * z) + tadjust;
  487. #                                if (tnext > bbextentt)
  488. #                                        tnext = bbextentt;
  489. #                                else if (tnext < 16)
  490. #                                        tnext = 16;      // guard against round-off error on <0 steps
  491. #                                r_turb_sstep = (snext - r_turb_s) >> 4;
  492. #                                r_turb_tstep = (tnext - r_turb_t) >> 4;
  493. #                        }
  494.  
  495.     fnmsubs f20,f0,f26,f28
  496.     fadds   f22,f22,f17             #sdivz += sdivz16stepu
  497.     fmuls   f0,f0,f20
  498.     fadds   f23,f23,f18             #tdivz += tdivz16stepu
  499.     fnmsubs f20,f0,f26,f28
  500.     fmuls   f0,f0,f20
  501.     fmuls   f24,f0,f15
  502.     fmadds  f20,f22,f24,f11         #f20 = snext
  503.     fsubs   f0,f20,f13
  504.     fsel    f20,f0,f13,f20          #if (snext>bb...) snext = bbextents
  505.     fsubs   f0,f20,f16
  506.     fsel    f20,f0,f20,f16          #if (snext<16) snext = 16
  507.     fctiwz  f0,f20
  508.     stfd    f0,local+8(r1)
  509.     lwz     r31,local+12(r1)        #r31 = (int)snext
  510.     fmadds  f21,f23,f24,f12         #f21 = tnext
  511.     fsubs   f0,f21,f14
  512.     fsel    f21,f0,f14,f21          #if (tnext>bb...) tnext = bbextentt
  513.     subf    r29,r8,r31
  514.     fsubs   f0,f21,f16
  515.     srawi   r29,r29,4               #r29 = sstep = (snext - s) >> 4
  516.     fsel    f21,f0,f21,f16          #if (tnext<16) tnext = 16
  517.     fctiwz  f0,f21
  518.     stfd    f0,local+8(r1)
  519.     lwz     r30,local+12(r1)        #r30 = (int)tnext
  520.     subf    r28,r9,r30
  521.     srawi   r28,r28,4               #r28 = tstep = (tnext - t) >> 4
  522.     b       .t8mainloop
  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. #                        // calculate s/z, t/z, zi->fixed s and t at last pixel in span (so
  533. #                        // can't step off polygon), clamp, calculate s and t steps across
  534. #                        // span by division, biasing steps low so we don't run off the
  535. #                        // texture
  536. #                                spancountminus1 = (float)(r_turb_spancount - 1);
  537. #                                sdivz += d_sdivzstepu * spancountminus1;
  538. #                                tdivz += d_tdivzstepu * spancountminus1;
  539. #                                zi += d_zistepu * spancountminus1;
  540. #                                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
  541. #                                snext = (int)(sdivz * z) + sadjust;
  542. #                                if (snext > bbextents)
  543. #                                        snext = bbextents;
  544. #                                else if (snext < 16)
  545. #                                        snext = 16;      // prevent round-off error on <0 steps from
  546. #                                                                //  from causing overstepping & running off the
  547. #                                                                //  edge of the texture
  548. #
  549. #                                tnext = (int)(tdivz * z) + tadjust;
  550. #                                if (tnext > bbextentt)
  551. #                                        tnext = bbextentt;
  552. #                                else if (tnext < 16)
  553. #                                        tnext = 16;      // guard against round-off error on <0 steps
  554. #
  555. #                                if (r_turb_spancount > 1)
  556. #                                {
  557. #                                        r_turb_sstep = (snext - r_turb_s) / (spancount - 1);
  558. #                                        r_turb_tstep = (tnext - r_turb_t) / (spancount - 1);
  559. #                                }
  560. #                        }
  561.  
  562. .t8finalpart:
  563.     fmuls   f0,f26,f26
  564.     fmadds  f22,f21,f1,f22          #sdivz += d_sdivzstepu * ...
  565.     frsqrte f0,f0
  566.     fmadds  f23,f21,f4,f23          #tdivs += d_tdivzstepu * ...
  567.     fnmsubs f20,f0,f26,f28
  568.     cmplwi  r10,5
  569.     fmuls   f0,f0,f20
  570.     fnmsubs f20,f0,f26,f28
  571.     fmuls   f0,f0,f20
  572.     fmuls   f24,f0,f15
  573.     fmadds  f20,f22,f24,f11         #f27 = snext
  574.     fsubs   f0,f20,f13
  575.     fsel    f20,f0,f13,f20          #if (snext>bb...) snext = bbextents
  576.     fsubs   f0,f20,f16
  577.     fsel    f20,f0,f20,f16          #if (snext<16) snext = 16
  578.     fctiwz  f0,f20
  579.     stfd    f0,local+8(r1)
  580.     lwz     r31,local+12(r1)        #r31 = (int)snext
  581.     fmadds  f21,f23,f24,f12         #f21 = tnext
  582.     fsubs   f0,f21,f14
  583.     fsel    f21,f0,f14,f21          #if (tnext>bb...) tnext = bbextentt
  584.     subf    r29,r8,r31
  585.     fsubs   f0,f21,f16
  586.     fsel    f21,f0,f21,f16          #if (tnext<16) tnext = 16
  587.     fctiwz  f0,f21
  588.     stfd    f0,local+8(r1)
  589.     lwz     r30,local+12(r1)        #r30 = (int)tnext
  590.     subf    r28,r9,r30
  591.     blt     .t8special
  592. .t8qdiv:
  593.     slwi    r0,r10,2
  594.     lwzx    r0,r26,r0
  595.     mulhw   r29,r29,r0
  596.     mulhw   r28,r28,r0
  597.     b       .t8mainloop
  598. .t8special:
  599.     cmplwi  r10,1
  600.     ble     .t8mainloop
  601.     cmplwi  r10,3
  602.     beq     .t8qdiv
  603.     blt     .t8spec_2
  604.     srawi   r29,r29,2
  605.     srawi   r28,r28,2
  606.     b       .t8mainloop
  607. .t8spec_2:
  608.     srawi   r29,r29,1
  609.     srawi   r28,r28,1
  610.  
  611. ######  D_DrawTurbulent8Span (inlined)
  612. ######  Main drawing loop.
  613.  
  614. #        do
  615. #        {
  616. #                sturb = ((r_turb_s + r_turb_turb[(r_turb_t>>16)&(CYCLE-1)])>>16)&63;
  617. #                tturb = ((r_turb_t + r_turb_turb[(r_turb_s>>16)&(CYCLE-1)])>>16)&63;
  618. #                *r_turb_pdest++ = *(r_turb_pbase + (tturb<<6) + sturb);
  619. #                r_turb_s += r_turb_sstep;
  620. #                r_turb_t += r_turb_tstep;
  621. #        } while (--r_turb_spancount > 0);
  622.  
  623.  
  624. .t8mainloop:
  625.     andis.  r8,r8,CYCLE-1
  626.     andis.  r9,r9,CYCLE-1
  627. .t8draw:
  628.     rlwinm  r0,r9,18,23,29        #implicit: CYCLE = 128
  629.     rlwinm  r25,r8,18,23,29        #implicit: CYCLE = 128
  630.     lwzx    r10,r4,r0
  631.     add     r10,r10,r8
  632.     lwzx    r25,r4,r25
  633.     add     r8,r8,r29
  634.     add     r25,r25,r9
  635.     extrwi  r10,r10,6,10
  636.     rlwinm  r25,r25,22,20,25
  637.     add     r10,r10,r25
  638.     add     r9,r9,r28
  639.     lbzx    r0,r27,r10
  640.     stbu    r0,1(r11)
  641.     bdnz    .t8draw
  642.  
  643.     mr      r8,r31
  644.     mr      r9,r30
  645.     mr.    r12,r12
  646.     bgt     .t8loop2
  647.     lwz     r3,4(r3)                #while (...)
  648.     mr.    r3,r3
  649.     subi    r3,r3,4
  650.     bne     .t8loop
  651.  
  652.     lmw    r25,gb(r1)
  653.     lfd    f14,fb+0*8(r1)
  654.     lfd    f15,fb+1*8(r1)
  655.     lfd    f16,fb+2*8(r1)
  656.     lfd    f17,fb+3*8(r1)
  657.     lfd    f18,fb+4*8(r1)
  658.     lfd    f19,fb+5*8(r1)
  659.     lfd    f20,fb+6*8(r1)
  660.     lfd    f21,fb+7*8(r1)
  661.     lfd    f22,fb+8*8(r1)
  662.     lfd    f23,fb+9*8(r1)
  663.     lfd    f24,fb+10*8(r1)
  664.     lfd    f25,fb+11*8(r1)
  665.     lfd    f26,fb+12*8(r1)
  666.     lfd    f27,fb+13*8(r1)
  667.     lfd    f28,fb+14*8(r1)
  668.     lfd    f29,fb+15*8(r1)
  669.     exit
  670.  
  671.     funcend    Turbulent8
  672.  
  673.  
  674.  
  675.  
  676. ###########################################################################
  677. #
  678. #       void D_DrawSpans8 (espan_t *pspan)
  679. #
  680. #       standard scan drawing function (8 pixel subdivision)
  681. #
  682. ###########################################################################
  683.  
  684.     funcdef    D_DrawSpans8
  685.  
  686.     lxa     r4,d_subdiv16        # subdiv16? then call DrawSpans16!
  687.     lfs     f0,CVAR_VALUE(r4)
  688.     ls      f1,c0
  689.     fcmpo   0,f0,f1
  690. .ifdef    WOS
  691.     bne     _D_DrawSpans16
  692. .else
  693.     bne    D_DrawSpans16
  694. .endif
  695.  
  696.     init    0,16,6,16        # 16 local bytes for int2dbl/dbl2int
  697.     stmw    r26,gb(r1)
  698.     stfd    f14,fb+0*8(r1)
  699.     stfd    f15,fb+1*8(r1)
  700.     stfd    f16,fb+2*8(r1)
  701.     stfd    f17,fb+3*8(r1)
  702.     stfd    f18,fb+4*8(r1)
  703.     stfd    f19,fb+5*8(r1)
  704.     stfd    f20,fb+6*8(r1)
  705.     stfd    f21,fb+7*8(r1)
  706.     stfd    f22,fb+8*8(r1)
  707.     stfd    f23,fb+9*8(r1)
  708.     stfd    f24,fb+10*8(r1)
  709.     stfd    f25,fb+11*8(r1)
  710.     stfd    f26,fb+12*8(r1)
  711.     stfd    f27,fb+13*8(r1)
  712.     stfd    f28,fb+14*8(r1)
  713.     stfd    f29,fb+15*8(r1)
  714.  
  715.     lxa     r26,_ReciprocTable
  716.     lw      r27,cacheblock          #r27 = pbase
  717.     lw      r4,cachewidth           #r4 = cachewidth
  718.     ls      f1,d_sdivzstepu         #f1 = d_sdivzstepu
  719.     ls      f2,d_sdivzstepv         #f2 = d_sdivzstepv
  720.     ls      f3,d_sdivzorigin        #f3 = d_sdivzorigin
  721.     ls      f4,d_tdivzstepu         #f4 = d_tdivzstepu
  722.     ls      f5,d_tdivzstepv         #f5 = d_tdivzstepv
  723.     ls      f6,d_tdivzorigin        #f6 = d_tdivzorigin
  724.     ls      f7,d_zistepu            #f7 = d_zistepu
  725.     ls      f8,d_zistepv            #f8 = d_zistepv
  726.     ls      f9,d_ziorigin           #f9 = d_ziorigin
  727.     lf      f10,INT2DBL_0           #for int2dbl_setup
  728.     stfd    f10,local(r1)
  729.     lw      r6,sadjust
  730.     int2dbl f11,r6,r0,local,f10    #f11 = sadjust
  731.     lw      r6,tadjust
  732.     int2dbl f12,r6,r0,local,f10    #f12 = tadjust
  733.     lw      r6,bbextents
  734.     int2dbl f13,r6,r0,local,f10    #f13 = bbextents
  735.     lw      r6,bbextentt
  736.     int2dbl f14,r6,r0,local,f10    #f14 = bbextentt
  737.     lw      r6,d_viewbuffer         #r6 = d_viewbuffer
  738.     lw      r7,screenwidth          #r7 = screenwidth
  739.     ls      f15,c65536              #f15 = 65536
  740.     ls      f16,c8            #f16 = 8
  741.     ls      f25,c0                  #f25 = 0
  742.     ls      f28,c2                  #f28 = 2
  743.     fmuls   f17,f1,f16              #f17 = sdivz8stepu
  744.     fmuls   f18,f4,f16              #f18 = tdivz8stepu
  745.     fmuls   f19,f7,f16              #f19 = zi8stepu
  746.     subi    r3,r3,4                 #prepare for postincrement
  747.  
  748. ######  First loop. In every iteration one complete span is drawn
  749.  
  750. #        pbase = (unsigned char *)cacheblock;
  751. #
  752. #        sdivz8stepu = d_sdivzstepu * 8;
  753. #        tdivz8stepu = d_tdivzstepu * 8;
  754. #        zi8stepu = d_zistepu * 8;
  755. #
  756. #        do
  757. #        {
  758. #                pdest = (unsigned char *)((byte *)d_viewbuffer +
  759. #                                (screenwidth * pspan->v) + pspan->u);
  760. #
  761. #                count = pspan->count;
  762. #
  763. #        // calculate the initial s/z, t/z, 1/z, s, and t and clamp
  764. #                du = (float)pspan->u;
  765. #                dv = (float)pspan->v;
  766. #
  767. #                sdivz = d_sdivzorigin + dv*d_sdivzstepv + du*d_sdivzstepu;
  768. #                tdivz = d_tdivzorigin + dv*d_tdivzstepv + du*d_tdivzstepu;
  769. #                zi = d_ziorigin + dv*d_zistepv + du*d_zistepu;
  770. #                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
  771. #
  772.  
  773. .d8loop:
  774.     lwzu    r8,4(r3)
  775.     int2dbl f20,r8,r0,local,f10    #f20 = du
  776.     lwzu    r9,4(r3)
  777.     int2dbl f21,r9,r0,local,f10    #f21 = dv
  778.     fmadds  f24,f21,f8,f9
  779.     fmadds  f22,f21,f2,f3
  780.     fmadds  f23,f21,f5,f6
  781.     fmadds  f26,f20,f7,f24          #f26 = zi
  782.     fmadds  f22,f20,f1,f22          #f22 = sdivz
  783.     fmadds  f23,f20,f4,f23          #f23 = tdivz
  784.     fmuls   f0,f26,f26
  785.     frsqrte f0,f0
  786.     mullw   r10,r9,r7               #r10 = pspan->v * screenwidth
  787.     fnmsubs f29,f0,f26,f28
  788.     add     r10,r10,r8              #r10 = r10 + pspan->u
  789.     fmuls   f0,f0,f29
  790.     add     r11,r6,r10              #r11 = pdest
  791.     fnmsubs f29,f0,f26,f28
  792.     subi    r11,r11,1               #prepare for postincrement
  793.     fmuls   f0,f0,f29
  794.     lwzu    r12,4(r3)               #r12 = count
  795.     fmuls   f24,f0,f15
  796.     fmadds  f20,f22,f24,f11         #f20 = s
  797.     fsubs   f0,f20,f13
  798.     fsel    f20,f0,f13,f20          #if (s>bb...) s = bbextents
  799.     fsel    f20,f20,f20,f25         #if (s<0) s = 0
  800.     fctiwz  f0,f20
  801.     stfd    f0,local+8(r1)
  802.     lwz     r8,local+12(r1)         #r8 = (int)s
  803.     fmadds  f21,f23,f24,f12         #f21 = t
  804.     fsubs   f0,f21,f14
  805.     fsel    f21,f0,f14,f21          #if (t>bb...) t = bbextentt
  806.     fsel    f21,f21,f21,f25         #if (t<0) t = 0
  807.     fctiwz  f0,f21
  808.     stfd    f0,local+8(r1)
  809.     lwz     r9,local+12(r1)         #r9 = (int)t
  810.     li      r0,1
  811.     dcbtst  r11,r0
  812.  
  813.  
  814. ######  Second loop. In every iteration one part of the whole span is drawn
  815.  
  816. #                do
  817. #                {
  818. #                // calculate s and t at the far end of the span
  819. #                        if (count >= 8)
  820. #                                spancount = 8;
  821. #                        else
  822. #                                spancount = count;
  823. #
  824. #                        count -= spancount;
  825. #
  826. #                        if (count)
  827. #                        {
  828.  
  829. .d8loop2:
  830.     cmpwi   r12,8
  831.     bgt     .d8cont
  832.     mtctr   r12
  833.     subi    r10,r12,1
  834.     int2dbl f21,r10,r0,local,f10    #spancountminus1 = (float)...
  835.     li      r12,0                   #r12 = count -= spancount
  836.     fmadds  f26,f21,f7,f26          #zi += d_zistepu # ...
  837.     b       .d8finalpart
  838. .d8cont:
  839.     fadds   f26,f26,f19             #zi += zi8stepu
  840.     li      r10,8                   #r10 = spancount = 8
  841.     fmuls   f0,f26,f26
  842.     subf    r12,r10,r12             #r12 = count -= spancount
  843.     frsqrte f0,f0
  844.     mtctr   r10
  845.  
  846. ######  Evaluation of the values for the inner loop. This version is used for
  847. ######  span size = 8
  848.  
  849. #                        // calculate s/z, t/z, zi->fixed s and t at far end of span,
  850. #                        // calculate s and t steps across span by shifting
  851. #                                sdivz += sdivz8stepu;
  852. #                                tdivz += tdivz8stepu;
  853. #                                zi += zi8stepu;
  854. #                                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
  855. #                                snext = (int)(sdivz * z) + sadjust;
  856. #                                if (snext > bbextents)
  857. #                                        snext = bbextents;
  858. #                                else if (snext < 8)
  859. #                                        snext = 8;      // prevent round-off error on <0 steps from
  860. #                                                                //  from causing overstepping & running off the
  861. #                                                                //  edge of the texture
  862. #                                tnext = (int)(tdivz * z) + tadjust;
  863. #                                if (tnext > bbextentt)
  864. #                                        tnext = bbextentt;
  865. #                                else if (tnext < 8)
  866. #                                        tnext = 8;      // guard against round-off error on <0 steps
  867. #                                sstep = (snext - s) >> 3;
  868. #                                tstep = (tnext - t) >> 3;
  869. #                        }
  870.  
  871.     fnmsubs f20,f0,f26,f28
  872.     fadds   f22,f22,f17             #sdivz += sdivz8stepu
  873.     fmuls   f0,f0,f20
  874.     fadds   f23,f23,f18             #tdivz += tdivz8stepu
  875.     fnmsubs f20,f0,f26,f28
  876.     fmuls   f0,f0,f20
  877.     fmuls   f24,f0,f15
  878.     fmadds  f20,f22,f24,f11         #f20 = snext
  879.     fsubs   f0,f20,f13
  880.     fsel    f20,f0,f13,f20          #if (snext>bb...) snext = bbextents
  881.     fsubs   f0,f20,f16
  882.     fsel    f20,f0,f20,f16          #if (snext<8) snext = 8
  883.     fctiwz  f0,f20
  884.     stfd    f0,local+8(r1)
  885.     lwz     r31,local+12(r1)        #r31 = (int)snext
  886.     fmadds  f21,f23,f24,f12         #f21 = tnext
  887.     fsubs   f0,f21,f14
  888.     fsel    f21,f0,f14,f21          #if (tnext>bb...) tnext = bbextentt
  889.     subf    r29,r8,r31
  890.     fsubs   f0,f21,f16
  891.     srawi   r29,r29,3               #r29 = sstep = (snext - s) >> 3
  892.     fsel    f21,f0,f21,f16          #if (tnext<8) tnext = 8
  893.     fctiwz  f0,f21
  894.     stfd    f0,local+8(r1)
  895.     lwz     r30,local+12(r1)        #r30 = (int)tnext
  896.     subf    r28,r9,r30
  897.     srawi   r28,r28,3               #r28 = tstep = (tnext - t) >> 3
  898.     b       .d8mainloop
  899.  
  900. ######  Evaluation of the values for the inner loop. This version is used for
  901. ######  span size < 8
  902.  
  903. ######  The original algorithm has two ugly divisions at the end of this part.
  904. ######  These are removed by the following optimization:
  905. ######  First, the divisors 1,2 and 4 are handled specially to gain speed. The
  906. ######  other divisors are handled using a reciprocal table.
  907.  
  908. #                        // calculate s/z, t/z, zi->fixed s and t at last pixel in span (so
  909. #                        // can't step off polygon), clamp, calculate s and t steps across
  910. #                        // span by division, biasing steps low so we don't run off the
  911. #                        // texture
  912. #                                spancountminus1 = (float)(spancount - 1);
  913. #                                sdivz += d_sdivzstepu * spancountminus1;
  914. #                                tdivz += d_tdivzstepu * spancountminus1;
  915. #                                zi += d_zistepu * spancountminus1;
  916. #                                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
  917. #                                snext = (int)(sdivz * z) + sadjust;
  918. #                                if (snext > bbextents)
  919. #                                        snext = bbextents;
  920. #                                else if (snext < 8)
  921. #                                        snext = 8;      // prevent round-off error on <0 steps from
  922. #                                                                //  from causing overstepping & running off the
  923. #                                                                //  edge of the texture
  924. #
  925. #                                tnext = (int)(tdivz * z) + tadjust;
  926. #                                if (tnext > bbextentt)
  927. #                                        tnext = bbextentt;
  928. #                                else if (tnext < 8)
  929. #                                        tnext = 8;      // guard against round-off error on <0 steps
  930. #
  931. #                                if (spancount > 1)
  932. #                                {
  933. #                                        sstep = (snext - s) / (spancount - 1);
  934. #                                        tstep = (tnext - t) / (spancount - 1);
  935. #                                }
  936. #                        }
  937.  
  938. .d8finalpart:
  939.     fmuls   f0,f26,f26
  940.     fmadds  f22,f21,f1,f22          #sdivz += d_sdivzstepu * ...
  941.     frsqrte f0,f0
  942.     fmadds  f23,f21,f4,f23          #tdivs += d_tdivzstepu * ...
  943.     fnmsubs f20,f0,f26,f28
  944.     cmplwi  r10,5
  945.     fmuls   f0,f0,f20
  946.     fnmsubs f20,f0,f26,f28
  947.     fmuls   f0,f0,f20
  948.     fmuls   f24,f0,f15
  949.     fmadds  f20,f22,f24,f11         #f27 = snext
  950.     fsubs   f0,f20,f13
  951.     fsel    f20,f0,f13,f20          #if (snext>bb...) snext = bbextents
  952.     fsubs   f0,f20,f16
  953.     fsel    f20,f0,f20,f16          #if (snext<8) snext = 8
  954.     fctiwz  f0,f20
  955.     stfd    f0,local+8(r1)
  956.     lwz     r31,local+12(r1)        #r31 = (int)snext
  957.     fmadds  f21,f23,f24,f12         #f21 = tnext
  958.     fsubs   f0,f21,f14
  959.     fsel    f21,f0,f14,f21          #if (tnext>bb...) tnext = bbextentt
  960.     subf    r29,r8,r31
  961.     fsubs   f0,f21,f16
  962.     fsel    f21,f0,f21,f16          #if (tnext<8) tnext = 8
  963.     fctiwz  f0,f21
  964.     stfd    f0,local+8(r1)
  965.     lwz     r30,local+12(r1)        #r30 = (int)tnext
  966.     subf    r28,r9,r30
  967.     blt     .d8special
  968. .d8qdiv:
  969.     slwi    r0,r10,2
  970.     lwzx    r0,r26,r0
  971.     mulhw   r29,r29,r0
  972.     mulhw   r28,r28,r0
  973.     b       .d8mainloop
  974. .d8special:
  975.     cmplwi  r10,1
  976.     ble     .d8mainloop
  977.     cmplwi  r10,3
  978.     beq     .d8qdiv
  979.     blt     .d8spec_2
  980.     srawi   r29,r29,2
  981.     srawi   r28,r28,2
  982.     b       .d8mainloop
  983. .d8spec_2:
  984.     srawi   r29,r29,1
  985.     srawi   r28,r28,1
  986.  
  987. ######  Main drawing loop. Here lies the speed.
  988.  
  989. #                        do
  990. #                        {
  991. #                                *pdest++ = *(pbase + (s >> 16) + (t >> 16) * cachewidth);
  992. #                                s += sstep;
  993. #                                t += tstep;
  994. #                        } while (--spancount > 0);
  995.  
  996. .d8mainloop:
  997.     srawi   r0,r9,16
  998.     srawi   r10,r8,16
  999.     mullw   r0,r0,r4
  1000.     add     r9,r9,r28
  1001.     add     r0,r0,r10
  1002.     add     r8,r8,r29
  1003.     lbzx    r0,r27,r0
  1004.     stbu    r0,1(r11)
  1005.     bdnz    .d8mainloop
  1006.     mr      r8,r31
  1007.     mr      r9,r30
  1008.     mr.    r12,r12
  1009.     bgt     .d8loop2
  1010.     lwz     r3,4(r3)                #while (...)
  1011.     mr.    r3,r3
  1012.     subi    r3,r3,4
  1013.     bne     .d8loop
  1014.  
  1015.     lmw    r26,gb(r1)
  1016.     lfd    f14,fb+0*8(r1)
  1017.     lfd    f15,fb+1*8(r1)
  1018.     lfd    f16,fb+2*8(r1)
  1019.     lfd    f17,fb+3*8(r1)
  1020.     lfd    f18,fb+4*8(r1)
  1021.     lfd    f19,fb+5*8(r1)
  1022.     lfd    f20,fb+6*8(r1)
  1023.     lfd    f21,fb+7*8(r1)
  1024.     lfd    f22,fb+8*8(r1)
  1025.     lfd    f23,fb+9*8(r1)
  1026.     lfd    f24,fb+10*8(r1)
  1027.     lfd    f25,fb+11*8(r1)
  1028.     lfd    f26,fb+12*8(r1)
  1029.     lfd    f27,fb+13*8(r1)
  1030.     lfd    f28,fb+14*8(r1)
  1031.     lfd    f29,fb+15*8(r1)
  1032.     exit
  1033.  
  1034.     funcend    D_DrawSpans8
  1035.  
  1036.  
  1037.  
  1038.  
  1039. ###########################################################################
  1040. #
  1041. #       void D_DrawSpans16 (espan_t *pspan)
  1042. #
  1043. #       standard scan drawing function (16 pixel subdivision)
  1044. #
  1045. ###########################################################################
  1046.  
  1047.     funcdef    D_DrawSpans16
  1048.  
  1049.     init    0,16,6,16        # 16 local bytes for int2dbl/dbl2int
  1050.     stmw    r26,gb(r1)
  1051.     stfd    f14,fb+0*8(r1)
  1052.     stfd    f15,fb+1*8(r1)
  1053.     stfd    f16,fb+2*8(r1)
  1054.     stfd    f17,fb+3*8(r1)
  1055.     stfd    f18,fb+4*8(r1)
  1056.     stfd    f19,fb+5*8(r1)
  1057.     stfd    f20,fb+6*8(r1)
  1058.     stfd    f21,fb+7*8(r1)
  1059.     stfd    f22,fb+8*8(r1)
  1060.     stfd    f23,fb+9*8(r1)
  1061.     stfd    f24,fb+10*8(r1)
  1062.     stfd    f25,fb+11*8(r1)
  1063.     stfd    f26,fb+12*8(r1)
  1064.     stfd    f27,fb+13*8(r1)
  1065.     stfd    f28,fb+14*8(r1)
  1066.     stfd    f29,fb+15*8(r1)
  1067.  
  1068.     lxa     r26,_ReciprocTable
  1069.     lw      r27,cacheblock          #r27 = pbase
  1070.     lw      r4,cachewidth           #r4 = cachewidth
  1071.     ls      f1,d_sdivzstepu         #f1 = d_sdivzstepu
  1072.     ls      f2,d_sdivzstepv         #f2 = d_sdivzstepv
  1073.     ls      f3,d_sdivzorigin        #f3 = d_sdivzorigin
  1074.     ls      f4,d_tdivzstepu         #f4 = d_tdivzstepu
  1075.     ls      f5,d_tdivzstepv         #f5 = d_tdivzstepv
  1076.     ls      f6,d_tdivzorigin        #f6 = d_tdivzorigin
  1077.     ls      f7,d_zistepu            #f7 = d_zistepu
  1078.     ls      f8,d_zistepv            #f8 = d_zistepv
  1079.     ls      f9,d_ziorigin           #f9 = d_ziorigin
  1080.     lf      f10,INT2DBL_0           #for int2dbl_setup
  1081.     stfd    f10,local(r1)
  1082.     lw      r6,sadjust
  1083.     int2dbl f11,r6,r0,local,f10    #f11 = sadjust
  1084.     lw      r6,tadjust
  1085.     int2dbl f12,r6,r0,local,f10    #f12 = tadjust
  1086.     lw      r6,bbextents
  1087.     int2dbl f13,r6,r0,local,f10    #f13 = bbextents
  1088.     lw      r6,bbextentt
  1089.     int2dbl f14,r6,r0,local,f10    #f14 = bbextentt
  1090.     lw      r6,d_viewbuffer         #r6 = d_viewbuffer
  1091.     lw      r7,screenwidth          #r7 = screenwidth
  1092.     ls      f15,c65536              #f15 = 65536
  1093.     ls      f16,c16                 #f16 = 16
  1094.     ls      f25,c0                  #f25 = 0
  1095.     ls      f28,c2                  #f28 = 2
  1096.     fmuls   f17,f1,f16              #f17 = sdivz16stepu
  1097.     fmuls   f18,f4,f16              #f18 = tdivz16stepu
  1098.     fmuls   f19,f7,f16              #f19 = zi16stepu
  1099.     subi    r3,r3,4                 #prepare for postincrement
  1100.  
  1101. ######  First loop. In every iteration one complete span is drawn
  1102.  
  1103. #        pbase = (unsigned char *)cacheblock;
  1104. #
  1105. #        sdivz16stepu = d_sdivzstepu * 16;
  1106. #        tdivz16stepu = d_tdivzstepu * 16;
  1107. #        zi16stepu = d_zistepu * 16;
  1108. #
  1109. #        do
  1110. #        {
  1111. #                pdest = (unsigned char *)((byte *)d_viewbuffer +
  1112. #                                (screenwidth * pspan->v) + pspan->u);
  1113. #
  1114. #                count = pspan->count;
  1115. #
  1116. #        // calculate the initial s/z, t/z, 1/z, s, and t and clamp
  1117. #                du = (float)pspan->u;
  1118. #                dv = (float)pspan->v;
  1119. #
  1120. #                sdivz = d_sdivzorigin + dv*d_sdivzstepv + du*d_sdivzstepu;
  1121. #                tdivz = d_tdivzorigin + dv*d_tdivzstepv + du*d_tdivzstepu;
  1122. #                zi = d_ziorigin + dv*d_zistepv + du*d_zistepu;
  1123. #                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
  1124. #
  1125.  
  1126. .d16loop:
  1127.     lwzu    r8,4(r3)
  1128.     int2dbl f20,r8,r0,local,f10    #f20 = du
  1129.     lwzu    r9,4(r3)
  1130.     int2dbl f21,r9,r0,local,f10    #f21 = dv
  1131.     fmadds  f24,f21,f8,f9
  1132.     fmadds  f22,f21,f2,f3
  1133.     fmadds  f23,f21,f5,f6
  1134.     fmadds  f26,f20,f7,f24          #f26 = zi
  1135.     fmadds  f22,f20,f1,f22          #f22 = sdivz
  1136.     fmadds  f23,f20,f4,f23          #f23 = tdivz
  1137.     fmuls   f0,f26,f26
  1138.     frsqrte f0,f0
  1139.     mullw   r10,r9,r7               #r10 = pspan->v * screenwidth
  1140.     fnmsubs f29,f0,f26,f28
  1141.     add     r10,r10,r8              #r10 = r10 + pspan->u
  1142.     fmuls   f0,f0,f29
  1143.     add     r11,r6,r10              #r11 = pdest
  1144.     fnmsubs f29,f0,f26,f28
  1145.     subi    r11,r11,1               #prepare for postincrement
  1146.     fmuls   f0,f0,f29
  1147.     lwzu    r12,4(r3)               #r12 = count
  1148.     fmuls   f24,f0,f15
  1149.     fmadds  f20,f22,f24,f11         #f20 = s
  1150.     fsubs   f0,f20,f13
  1151.     fsel    f20,f0,f13,f20          #if (s>bb...) s = bbextents
  1152.     fsel    f20,f20,f20,f25         #if (s<0) s = 0
  1153.     fctiwz  f0,f20
  1154.     stfd    f0,local+8(r1)
  1155.     lwz     r8,local+12(r1)         #r8 = (int)s
  1156.     fmadds  f21,f23,f24,f12         #f21 = t
  1157.     fsubs   f0,f21,f14
  1158.     fsel    f21,f0,f14,f21          #if (t>bb...) t = bbextentt
  1159.     fsel    f21,f21,f21,f25         #if (t<0) t = 0
  1160.     fctiwz  f0,f21
  1161.     stfd    f0,local+8(r1)
  1162.     lwz     r9,local+12(r1)         #r9 = (int)t
  1163.     li      r0,1
  1164.     dcbtst  r11,r0
  1165.  
  1166. ######  Second loop. In every iteration one part of the whole span is drawn
  1167.  
  1168. #                do
  1169. #                {
  1170. #                // calculate s and t at the far end of the span
  1171. #                        if (count >= 16)
  1172. #                                spancount = 16;
  1173. #                        else
  1174. #                                spancount = count;
  1175. #
  1176. #                        count -= spancount;
  1177. #
  1178. #                        if (count)
  1179. #                        {
  1180.  
  1181. .d16loop2:
  1182.     cmpwi   r12,16
  1183.     bgt     .d16cont
  1184.     mtctr   r12
  1185.     subi    r10,r12,1
  1186.     int2dbl f21,r10,r0,local,f10    #spancountminus1 = (float)...
  1187.     li      r12,0                   #r12 = count -= spancount
  1188.     fmadds  f26,f21,f7,f26          #zi += d_zistepu * ...
  1189.     b       .d16finalpart
  1190. .d16cont:
  1191.     fadds   f26,f26,f19             #zi += zi16stepu
  1192.     li      r10,16                  #r10 = spancount = 16
  1193.     fmuls   f0,f26,f26
  1194.     subf    r12,r10,r12             #r12 = count -= spancount
  1195.     frsqrte f0,f0
  1196.     mtctr   r10
  1197.  
  1198. #######  Evaluation of the values for the inner loop. This version is used for
  1199. #######  span size = 16
  1200.  
  1201. #                        // calculate s/z, t/z, zi->fixed s and t at far end of span,
  1202. #                        // calculate s and t steps across span by shifting
  1203. #                                sdivz += sdivz16stepu;
  1204. #                                tdivz += tdivz16stepu;
  1205. #                                zi += zi16stepu;
  1206. #                                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
  1207. #                                snext = (int)(sdivz * z) + sadjust;
  1208. #                                if (snext > bbextents)
  1209. #                                        snext = bbextents;
  1210. #                                else if (snext < 16)
  1211. #                                        snext = 16;      // prevent round-off error on <0 steps from
  1212. #                                                                //  from causing overstepping & running off the
  1213. #                                                                //  edge of the texture
  1214. #                                tnext = (int)(tdivz * z) + tadjust;
  1215. #                                if (tnext > bbextentt)
  1216. #                                        tnext = bbextentt;
  1217. #                                else if (tnext < 16)
  1218. #                                        tnext = 16;      // guard against round-off error on <0 steps
  1219. #                                sstep = (snext - s) >> 4;
  1220. #                                tstep = (tnext - t) >> 4;
  1221. #                        }
  1222.  
  1223.     fnmsubs f20,f0,f26,f28
  1224.     fadds   f22,f22,f17             #sdivz += sdivz16stepu
  1225.     fmuls   f0,f0,f20
  1226.     fadds   f23,f23,f18             #tdivz += tdivz16stepu
  1227.     fnmsubs f20,f0,f26,f28
  1228.     fmuls   f0,f0,f20
  1229.     fmuls   f24,f0,f15
  1230.     fmadds  f20,f22,f24,f11         #f20 = snext
  1231.     fsubs   f0,f20,f13
  1232.     fsel    f20,f0,f13,f20          #if (snext>bb...) snext = bbextents
  1233.     fsubs   f0,f20,f16
  1234.     fsel    f20,f0,f20,f16          #if (snext<16) snext = 16
  1235.     fctiwz  f0,f20
  1236.     stfd    f0,local+8(r1)
  1237.     lwz     r31,local+12(r1)        #r31 = (int)snext
  1238.     fmadds  f21,f23,f24,f12         #f21 = tnext
  1239.     fsubs   f0,f21,f14
  1240.     fsel    f21,f0,f14,f21          #if (tnext>bb...) tnext = bbextentt
  1241.     subf    r29,r8,r31
  1242.     fsubs   f0,f21,f16
  1243.     srawi   r29,r29,4               #r29 = sstep = (snext - s) >> 4
  1244.     fsel    f21,f0,f21,f16          #if (tnext<16) tnext = 16
  1245.     fctiwz  f0,f21
  1246.     stfd    f0,local+8(r1)
  1247.     lwz     r30,local+12(r1)        #r30 = (int)tnext
  1248.     subf    r28,r9,r30
  1249.     srawi   r28,r28,4               #r28 = tstep = (tnext - t) >> 4
  1250.     b       .d16mainloop
  1251.  
  1252. ######  Evaluation of the values for the inner loop. This version is used for
  1253. ######  span size < 16
  1254.  
  1255. ######  The original algorithm has two ugly divisions at the end of this part.
  1256. ######  These are removed by the following optimization:
  1257. ######  First, the divisors 1,2 and 4 are handled specially to gain speed. The
  1258. ######  other divisors are handled using a reciprocal table.
  1259.  
  1260. #                        // calculate s/z, t/z, zi->fixed s and t at last pixel in span (so
  1261. #                        // can't step off polygon), clamp, calculate s and t steps across
  1262. #                        // span by division, biasing steps low so we don't run off the
  1263. #                        // texture
  1264. #                                spancountminus1 = (float)(spancount - 1);
  1265. #                                sdivz += d_sdivzstepu * spancountminus1;
  1266. #                                tdivz += d_tdivzstepu * spancountminus1;
  1267. #                                zi += d_zistepu * spancountminus1;
  1268. #                                z = (float)0x10000 / zi;        // prescale to 16.16 fixed-point
  1269. #                                snext = (int)(sdivz * z) + sadjust;
  1270. #                                if (snext > bbextents)
  1271. #                                        snext = bbextents;
  1272. #                                else if (snext < 16)
  1273. #                                        snext = 16;      // prevent round-off error on <0 steps from
  1274. #                                                                //  from causing overstepping & running off the
  1275. #                                                                //  edge of the texture
  1276. #
  1277. #                                tnext = (int)(tdivz * z) + tadjust;
  1278. #                                if (tnext > bbextentt)
  1279. #                                        tnext = bbextentt;
  1280. #                                else if (tnext < 16)
  1281. #                                        tnext = 16;      // guard against round-off error on <0 steps
  1282. #
  1283. #                                if (spancount > 1)
  1284. #                                {
  1285. #                                        sstep = (snext - s) / (spancount - 1);
  1286. #                                        tstep = (tnext - t) / (spancount - 1);
  1287. #                                }
  1288. #                        }
  1289.  
  1290. .d16finalpart:
  1291.     fmuls   f0,f26,f26
  1292.     fmadds  f22,f21,f1,f22          #sdivz += d_sdivzstepu * ...
  1293.     frsqrte f0,f0
  1294.     fmadds  f23,f21,f4,f23          #tdivs += d_tdivzstepu * ...
  1295.     fnmsubs f20,f0,f26,f28
  1296.     cmplwi  r10,5
  1297.     fmuls   f0,f0,f20
  1298.     fnmsubs f20,f0,f26,f28
  1299.     fmuls   f0,f0,f20
  1300.     fmuls   f24,f0,f15
  1301.     fmadds  f20,f22,f24,f11         #f27 = snext
  1302.     fsubs   f0,f20,f13
  1303.     fsel    f20,f0,f13,f20          #if (snext>bb...) snext = bbextents
  1304.     fsubs   f0,f20,f16
  1305.     fsel    f20,f0,f20,f16          #if (snext<16) snext = 16
  1306.     fctiwz  f0,f20
  1307.     stfd    f0,local+8(r1)
  1308.     lwz     r31,local+12(r1)        #r31 = (int)snext
  1309.     fmadds  f21,f23,f24,f12         #f21 = tnext
  1310.     fsubs   f0,f21,f14
  1311.     fsel    f21,f0,f14,f21          #if (tnext>bb...) tnext = bbextentt
  1312.     subf    r29,r8,r31
  1313.     fsubs   f0,f21,f16
  1314.     fsel    f21,f0,f21,f16          #if (tnext<16) tnext = 16
  1315.     fctiwz  f0,f21
  1316.     stfd    f0,local+8(r1)
  1317.     lwz     r30,local+12(r1)        #r30 = (int)tnext
  1318.     subf    r28,r9,r30
  1319.     blt     .d16special
  1320. .d16qdiv:
  1321.     slwi    r0,r10,2
  1322.     lwzx    r0,r26,r0
  1323.     mulhw   r29,r29,r0
  1324.     mulhw   r28,r28,r0
  1325.     b       .d16mainloop
  1326. .d16special:
  1327.     cmplwi  r10,1
  1328.     ble     .d16mainloop
  1329.     cmplwi  r10,3
  1330.     beq     .d16qdiv
  1331.     blt     .d16spec_2
  1332.     srawi   r29,r29,2
  1333.     srawi   r28,r28,2
  1334.     b       .d16mainloop
  1335. .d16spec_2:
  1336.     srawi   r29,r29,1
  1337.     srawi   r28,r28,1
  1338.  
  1339. ######  Main drawing loop. Here lies the speed.
  1340.  
  1341. #                        do
  1342. #                        {
  1343. #                                *pdest++ = *(pbase + (s >> 16) + (t >> 16) * cachewidth);
  1344. #                                s += sstep;
  1345. #                                t += tstep;
  1346. #                        } while (--spancount > 0);
  1347.  
  1348. .d16mainloop:
  1349.     srawi   r0,r9,16
  1350.     srawi   r10,r8,16
  1351.     mullw   r0,r0,r4
  1352.     add     r9,r9,r28
  1353.     add     r0,r0,r10
  1354.     add     r8,r8,r29
  1355.     lbzx    r0,r27,r0
  1356.     stbu    r0,1(r11)
  1357.     bdnz    .d16mainloop
  1358.     mr      r8,r31
  1359.     mr      r9,r30
  1360.     mr.    r12,r12
  1361.     bgt     .d16loop2
  1362.     lwz     r3,4(r3)                #while (...)
  1363.     mr.    r3,r3
  1364.     subi    r3,r3,4
  1365.     bne     .d16loop
  1366.  
  1367.     lmw    r26,gb(r1)
  1368.     lfd    f14,fb+0*8(r1)
  1369.     lfd    f15,fb+1*8(r1)
  1370.     lfd    f16,fb+2*8(r1)
  1371.     lfd    f17,fb+3*8(r1)
  1372.     lfd    f18,fb+4*8(r1)
  1373.     lfd    f19,fb+5*8(r1)
  1374.     lfd    f20,fb+6*8(r1)
  1375.     lfd    f21,fb+7*8(r1)
  1376.     lfd    f22,fb+8*8(r1)
  1377.     lfd    f23,fb+9*8(r1)
  1378.     lfd    f24,fb+10*8(r1)
  1379.     lfd    f25,fb+11*8(r1)
  1380.     lfd    f26,fb+12*8(r1)
  1381.     lfd    f27,fb+13*8(r1)
  1382.     lfd    f28,fb+14*8(r1)
  1383.     lfd    f29,fb+15*8(r1)
  1384.     exit
  1385.  
  1386.     funcend    D_DrawSpans16
  1387.  
  1388.  
  1389.  
  1390.  
  1391. ###########################################################################
  1392. #
  1393. #       void D_DrawZSpans (espan_t *pspan)
  1394. #                          r3
  1395. #
  1396. #       standard z-scan drawing function
  1397. #
  1398. ###########################################################################
  1399.  
  1400.     funcdef    D_DrawZSpans
  1401.  
  1402.     init    0,16,0,0        # 16 local bytes for int2dbl/dbl2int
  1403.     lf      f1,INT2DBL_0            #for int2dbl_setup
  1404.     stfd    f1,local(r1)
  1405.  
  1406.     ls      f2,cHUGE                #f2 = 0x8000*0x10000
  1407.     ls      f3,d_zistepu            #f3 = d_zistepu
  1408.     ls      f4,d_zistepv            #f4 = d_zistepv
  1409.     ls      f5,d_ziorigin           #f5 = d_ziorigin
  1410.     lw      r5,d_pzbuffer           #r5 = d_pzbuffer
  1411.     lw      r6,d_zwidth             #r6 = d_zwidth
  1412.  
  1413. #        izistep = (int)(d_zistepu * 0x8000 * 0x10000);
  1414.  
  1415.     fmuls   f6,f3,f2
  1416.     fctiwz  f0,f6
  1417.     stfd    f0,local+8(r1)
  1418.     lwz     r7,local+12(r1)         #r7 = izistep
  1419.     subi    r3,r3,4                 #prepare for postincrement
  1420.  
  1421. #                pdest = d_pzbuffer + (d_zwidth * pspan->v) + pspan->u;
  1422. #
  1423. #                count = pspan->count;
  1424. #
  1425. #        // calculate the initial 1/z
  1426. #                du = (float)pspan->u;
  1427. #                dv = (float)pspan->v;
  1428. #
  1429. #                zi = d_ziorigin + dv*d_zistepv + du*d_zistepu;
  1430. #        // we count on FP exceptions being turned off to avoid range problems
  1431. #                izi = (int)(zi * 0x8000 * 0x10000);
  1432.  
  1433.  
  1434. .zloop:
  1435.     lwzu    r8,4(r3)                #r8 = pspan->u
  1436.     lwzu    r9,4(r3)                #r9 = pspan->v
  1437.     lwzu    r10,4(r3)               #r10 = pspan->count
  1438.     mullw   r11,r9,r6
  1439.     add     r11,r11,r8
  1440.     add     r11,r11,r11
  1441.     add     r12,r5,r11              #r12 = pdest = d_pzbuffer + ...
  1442.     int2dbl f7,r8,r0,local,f1    #f7 = du
  1443.     int2dbl f8,r9,r0,local,f1    #f8 = dv
  1444.     fmadds  f10,f8,f4,f5
  1445.     subi    r12,r12,4
  1446.     fmadds  f10,f7,f3,f10           #zi = d_ziorigin + ...
  1447.     fmuls   f7,f10,f2
  1448.     fctiwz  f0,f7
  1449.     stfd    f0,local+8(r1)
  1450.     lwz     r8,local+12(r1)         #r8 = izi = (int)(zi * ...)
  1451.  
  1452. #                if ((long)pdest & 0x02)
  1453. #                {
  1454. #                        *pdest++ = (short)(izi >> 16);
  1455. #                        izi += izistep;
  1456. #                        count--;
  1457. #                }
  1458.  
  1459.     andi.   r0,r12,2                #if (long)pdest & 0x02
  1460.     beq     .zcont
  1461.     srawi   r0,r8,16
  1462.     sth     r0,4(r12)               #*pdest++ (short)(izi >> 16)
  1463.     addi    r12,r12,2
  1464.     add     r8,r8,r7                #izi += izistep
  1465.     subi    r10,r10,1               #count--
  1466. .zcont:
  1467.  
  1468.  
  1469. #                if ((doublecount = count >> 1) > 0)
  1470. #                {
  1471. #                        do
  1472. #                        {
  1473. #                                ltemp = izi >> 16;
  1474. #                                izi += izistep;
  1475. #                                ltemp |= izi & 0xFFFF0000;
  1476. #                                izi += izistep;
  1477. #                                *(int *)pdest = ltemp;
  1478. #                                pdest += 2;
  1479. #                        } while (--doublecount > 0);
  1480. #                }
  1481.  
  1482.     srawi.  r0,r10,1                #if ((doublecount = count >> 1))
  1483.     ble     .zcont2
  1484.     mtctr   r0
  1485. .zloop2:
  1486.     srawi   r0,r8,16                #ltemp = izi >> 16
  1487.     add     r8,r8,r7                #izi += izistep
  1488.     inslwi  r0,r8,16,0              #ltemp |= izi & 0xFFFF0000
  1489.     add     r8,r8,r7                #izi += izistep
  1490.     stwu    r0,4(r12)               #*(int *)pdest = ltemp
  1491.     bdnz    .zloop2
  1492. .zcont2:
  1493.  
  1494. #                if (count & 1)
  1495. #                        *pdest = (short)(izi >> 16);
  1496.  
  1497.     andi.   r0,r10,1                #if (count & 1)
  1498.     beq     .zcont3
  1499.     srawi   r0,r8,16                #*pdest = (short)(izi >> 16)
  1500.     sth     r0,4(r12)
  1501. .zcont3:
  1502.  
  1503. #        } while ((pspan = pspan->pnext) != NULL);
  1504.  
  1505.     lwz     r3,4(r3)                #while (...)
  1506.     mr.    r3,r3
  1507.     subi    r3,r3,4
  1508.     bne     .zloop
  1509.  
  1510.     exit
  1511.  
  1512.     funcend    D_DrawZSpans
  1513.  
  1514.  
  1515.  
  1516.  
  1517. .ifdef    WOS
  1518.     .tocd
  1519. .else
  1520.     .data
  1521. .endif
  1522.  
  1523. lab c8
  1524.     .float    8.0
  1525. lab c16
  1526.     .float    16.0
  1527. lab cHUGE
  1528.     .float    2147483648.0
  1529. lab cSPEED
  1530.     .float    20
  1531. lab cAMP2times2
  1532.     .float    6.0    # 2 * AMP2
  1533. .ifne AMP2-3
  1534. .fail "AMP2 must be 3!"
  1535. .endif
  1536.