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