home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 113 / EnigmaAmiga113CD.iso / software / sviluppo / quake_src / d_sky68k.s < prev    next >
Encoding:
Text File  |  2000-06-17  |  12.6 KB  |  448 lines
  1. * 
  2. * Copyright (C) 1996-1997 Id Software, Inc. 
  3. * 
  4. * This program is free software; you can redistribute it and/or 
  5. * modify it under the terms of the GNU General Public License 
  6. * as published by the Free Software Foundation; either version 2 
  7. * of the License, or (at your option) any later version. 
  8. * 
  9. * This program is distributed in the hope that it will be useful, 
  10. * but WITHOUT ANY WARRANTY; without even the implied warranty of 
  11. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.   
  12. * 
  13. * See the GNU General Public License for more details. 
  14. * 
  15. * You should have received a copy of the GNU General Public License 
  16. * along with this program; if not, write to the Free Software 
  17. * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA. 
  18. * 
  19.  
  20. **
  21. ** Quake for AMIGA
  22. ** d_sky.c assembler implementations by Frank Wille <frank@phoenix.owl.de>
  23. **
  24.  
  25.         XREF    _d_viewbuffer
  26.         XREF    _screenwidth
  27.         XREF    _r_refdef
  28.         XREF    _r_skysource
  29.         XREF    _vid
  30.         XREF    _vright
  31.         XREF    _vpn
  32.         XREF    _vup
  33.         XREF    _skytime
  34.         XREF    _skyspeed
  35.  
  36.         XDEF    _D_DrawSkyScans8
  37.  
  38. PSPAN_NEXT              =       $C
  39. REFDEF_VRECT_X          =       0
  40. REFDEF_VRECT_Y          =       4
  41. REFDEF_VRECT_WIDTH      =       8
  42. REFDEF_VRECT_HEIGHT     =       12
  43. VID_WIDTH               =       20
  44. VID_HEIGHT              =       24
  45.  
  46. SKYSHIFT                =       7
  47. SKYSIZE                 =       (1 << SKYSHIFT)
  48. SKYMASK                 =       (SKYSIZE - 1)
  49. SKY_SPAN_SHIFT          =       5
  50. SKY_SPAN_MAX            =       (1 << SKY_SPAN_SHIFT)
  51. R_SKY_SMASK             =       $007f
  52. R_SKY_TMASK             =       $007f
  53.  
  54.  
  55.  
  56.  
  57. ******************************************************************************
  58. *
  59. *       void D_DrawSkyScans8 (espan_t *pspan)
  60. *
  61. *       standard scan drawing function for the sky
  62. *
  63. *       D_Sky_uv_To_st is inlined.
  64. *
  65. *       IMPORTANT!! SKY_SPAN_SHIFT must *NOT* exceed 5 (The ReciprocTable
  66. *       has to be extended)
  67. *
  68. ******************************************************************************
  69.  
  70.         cnop    0,4
  71. _D_DrawSkyScans8
  72.  
  73.  
  74. *****   stackframe
  75.  
  76.         rsreset
  77. .savefp1        rs.x    1
  78. .saved4         rs.l    1
  79. .saved5         rs.l    1
  80. .vr0            rs.s    1
  81. .vr1            rs.s    1
  82. .vr2            rs.s    1
  83. .fpuregs        rs.x    6
  84. .intregs        rs.l    11
  85.         rs.l    1
  86. .pspan          rs.l    1
  87.  
  88.  
  89. ******  Prologue. Global variables are put into registers or onto the stackframe
  90.  
  91.         movem.l d2-d7/a2-a6,-(sp)
  92.         fmovem.x        fp2-fp7,-(sp)
  93.         sub.l   #.fpuregs,sp
  94.  
  95. ******  First loop. In every iteration one complete span is drawn
  96.  
  97.  
  98.         move.l  .pspan(sp),a6           ;get function parameter
  99.  
  100.         lea     _r_refdef,a1
  101.         move.l  REFDEF_VRECT_HEIGHT(a1),d0
  102.         move.l  REFDEF_VRECT_WIDTH(a1),d1
  103.         cmp.l   d0,d1                   ;if (r_refdef.vrect.width >= r_...)
  104.         blt.b   .height
  105.         fmove.l d1,fp0                  ;temp = (float)r_refdef.vrect.height
  106.         bra.b   .width
  107. .height
  108.         fmove.l d0,fp0                  ;temp = (float)r_refdef.vrect.width
  109. .width
  110.         fmove.s #8192,fp1
  111.         fdiv    fp0,fp1                 ;fp1 = 8192 / temp
  112.         move.l  _r_skysource,a5
  113. .loop
  114.         fmove.x fp1,.savefp1(sp)
  115.         move.l  _d_viewbuffer,a0
  116.         move.l  _screenwidth,d0
  117.         move.l  (a6)+,d3
  118.         move.l  (a6)+,d2
  119.         fmove.l d2,fp4
  120.         muls    d2,d0                   ;d0 = screenwidth * pspan->v
  121.         add.l   d3,d0
  122.         add.l   d0,a0                   ;pdest = d_viewbuffer + pspan->u + d0
  123.  
  124.         fmove.s #4096,fp7
  125.         lea     _vpn,a2
  126.         fmove.s (a2)+,fp5
  127.         fmul    fp7,fp5                 ;fp5 = 4096*vpn[0]
  128.         fmove.s (a2)+,fp6
  129.         fmul    fp7,fp6                 ;fp6 = 4096*vpn[1]
  130.         fmul.s  (a2)+,fp7               ;fp7 = 4096*vpn[2]
  131.         lea     _vid,a1
  132.         move.l  VID_WIDTH(a1),d0
  133.         move.l  VID_HEIGHT(a1),d1
  134.         asr.l   #1,d0
  135.         move.l  d0,a2                   ;a2 = vid.width>>1
  136.         asr.l   #1,d1
  137.         fmove.l d1,fp0
  138.         fsub    fp4,fp0                 ;fp0 = ((vid.height>>1)-v)
  139.         fmul    fp1,fp0                 ;wv = 8192 * fp0 / temp
  140.         lea     _vup,a1
  141.         fmove.s (a1)+,fp2
  142.         fmul    fp0,fp2                 ;fp2 = wv*vup[0]
  143.         fadd    fp2,fp5                 ;fp5 = 4096*vpn[0] + wv*vup[0]
  144.         fmove.s (a1)+,fp3
  145.         fmul    fp0,fp3                 ;fp3 = wv*vup[1]
  146.         fadd    fp3,fp6                 ;fp6 = 4096*vpn[1] + wv*vup[0]
  147.         fmul.s  (a1)+,fp0               ;fp0 = wv*vup[2]
  148.         fadd    fp0,fp7                 ;fp7 = 4096*vpn[2] + wv*vup[2]
  149.         lea     _vright,a1
  150.         fmove.s (a1)+,fp2
  151.         fmove.s (a1)+,fp3
  152.         fmove.s (a1)+,fp4
  153.         fmul    fp1,fp2                 ;fp2 = 8192 * vright[0] / temp
  154.         fmul    fp1,fp3                 ;fp3 = 8192 * vright[1] / temp
  155.         fmul    fp1,fp4                 ;fp4 = 8192 * vright[2] / temp
  156.         fmove.s fp2,.vr0(sp)
  157.         fmove.s fp3,.vr1(sp)
  158.         fmove.s #3,fp1
  159.         fmul    fp1,fp7                 ;multiply by 3
  160.         fmul    fp1,fp4
  161.         fmove.s fp4,.vr2(sp)
  162.         move.l  (a6)+,d1                ;count = pspan->count
  163.         fmove.s _skytime,fp0
  164.         fmul.s  _skyspeed,fp0
  165.         fmul.s  #65536,fp0
  166.         fmove.l fp0,d0                  ;d0 = skytime*skyspeed*$10000
  167.         move.l  d0,a4
  168.  
  169. ******  D_Sky_uv_To_st (inlined)
  170.  
  171.         move.l  d3,d0
  172.         sub.l   a2,d0
  173.         fmove.l d0,fp0                  ;fp0 = (float(u-(vid.width>>1)))
  174.         fmove   fp0,fp2
  175.         fmul.s  .vr0(sp),fp2            ;fp2 = wu*vright[0]
  176.         fadd    fp5,fp2                 ;fp2 = end[0]
  177.         fmove   fp2,fp1
  178.         fmul    fp2,fp2
  179.         fmove   fp0,fp3
  180.         fmul.s  .vr1(sp),fp3            ;fp3 = wu*vright[1]
  181.         fadd    fp6,fp3                 ;fp3 = end[1]
  182.         fmove   fp3,fp4
  183.         fmul    fp3,fp3
  184.         fadd    fp3,fp2
  185.         fmul.s  .vr2(sp),fp0            ;fp0 = wu*vright[2]
  186.         fadd    fp7,fp0                 ;fp0 = end[2]
  187.         fmul    fp0,fp0
  188.         fadd    fp0,fp2
  189.         fsqrt   fp2                     ;fp2 = length(end)
  190.         fmove.s #(65536*6*(SKYSIZE/2-1)),fp0
  191.         fdiv    fp2,fp0
  192.         fmul    fp0,fp1                 ;fp1 = 6*(SKYSIZE/2-1)*end[0]
  193.         fmul    fp0,fp4                 ;fp4 = 6*(SKYSIZE/2-1)*end[1]
  194.         fmove.l fp1,d6
  195.         add.l   a4,d6                   ;d6 = s
  196.         fmove.l fp4,d7
  197.         add.l   a4,d7                   ;d7 = t
  198.  
  199. ******  end of D_Sky_uv_To_st
  200.  
  201. ******  Second loop. In every iteration one part of the whole span is drawn
  202. ******  d2 gets the value (spancount-1)! [NOT spancount]
  203.  
  204. ******  d1 = count
  205.  
  206. *                do
  207. *                {
  208. *                        if (count >= SKY_SPAN_MAX)
  209. *                                spancount = SKY_SPAN_MAX;
  210. *                        else
  211. *                                spancount = count;
  212. *
  213. *                        count -= spancount;
  214. *
  215. *                        if (count)
  216. *                        {
  217.  
  218. .loop2
  219.         move.l  #SKY_SPAN_MAX-1,d2      ;spancount = SKY_SPAN_MAX
  220.         cmp.l   #SKY_SPAN_MAX,d1        ;if (count >= SKY_SPAN_MAX)
  221.         bgt.b   .cont
  222.         move.l  d1,d2                   ;spancount = count
  223.         subq.l  #1,d2
  224.         moveq   #0,d1                   ;count -= spancount
  225.         bra.w   .finalpart
  226. .cont
  227.         sub.l   #SKY_SPAN_MAX,d1        ;count -= spancount;
  228.  
  229.  
  230. ******  Evaluation of the values for the inner loop. This version is used for
  231. ******  span size = SKY_SPAN_MAX
  232.  
  233. *                        // calculate s and t at far end of span,
  234. *                        // calculate s and t steps across span by shifting
  235. *                                u += spancount;
  236. *
  237. *                                D_Sky_uv_To_st (u, v, &snext, &tnext);
  238. *
  239. *                                sstep = (snext - s) >> SKY_SPAN_SHIFT;
  240. *                                tstep = (tnext - t) >> SKY_SPAN_SHIFT;
  241. *                        }
  242.  
  243.  
  244.         add.l   d2,d3
  245.         addq.l  #1,d3
  246.  
  247. ******  D_Sky_uv_To_st (inlined)
  248.  
  249.         move.l  d3,d0
  250.         sub.l   a2,d0
  251.         fmove.l d0,fp0                  ;fp0 = (float(u-(vid.width>>1)))
  252.         fmove   fp0,fp2
  253.         fmul.s  .vr0(sp),fp2            ;fp2 = wu*vright[0]
  254.         fadd    fp5,fp2                 ;fp2 = end[0]
  255.         fmove   fp2,fp1
  256.         fmul    fp2,fp2
  257.         fmove   fp0,fp3
  258.         fmul.s  .vr1(sp),fp3            ;fp3 = wu*vright[1]
  259.         fadd    fp6,fp3                 ;fp3 = end[1]
  260.         fmove   fp3,fp4
  261.         fmul    fp3,fp3
  262.         fadd    fp3,fp2
  263.         fmul.s  .vr2(sp),fp0            ;fp0 = wu*vright[2]
  264.         fadd    fp7,fp0                 ;fp0 = end[2]
  265.         fmul    fp0,fp0
  266.         fadd    fp0,fp2
  267.         fsqrt   fp2                     ;fp2 = length(end)
  268.         fmove.s #(65536*6*(SKYSIZE/2-1)),fp0
  269.         fdiv    fp2,fp0
  270.         fmul    fp0,fp1                 ;fp1 = 6*(SKYSIZE/2-1)*end[0]
  271.         fmul    fp0,fp4                 ;fp4 = 6*(SKYSIZE/2-1)*end[1]
  272.         fmove.l fp1,d4
  273.         add.l   a4,d4                   ;d6 = snext
  274.         fmove.l fp4,d5
  275.         add.l   a4,d5                   ;d7 = tnext
  276.  
  277. ******  end of D_Sky_uv_To_st
  278.  
  279.         move.l  d4,.saved4(sp)          ;save snext
  280.         move.l  d5,.saved5(sp)          ;save tnext
  281.         sub.l   d6,d4                   ;d4 = snext - s
  282.         sub.l   d7,d5                   ;d5 = tnext - t
  283.         asr.l   #SKY_SPAN_SHIFT,d4      ;sstep = d4 >> SKY_SPAN_SHIFT
  284.         asr.l   #SKY_SPAN_SHIFT,d5      ;tstep = d5 >> SKY_SPAN_SHIFT
  285.         bra.w   .mainloop
  286.  
  287.  
  288. .finalpart
  289.         add.l   d2,d3
  290.  
  291. ******  D_Sky_uv_To_st (inlined)
  292.  
  293.         move.l  d3,d0
  294.         sub.l   a2,d0
  295.         fmove.l d0,fp0                  ;fp0 = (float(u-(vid.width>>1)))
  296.         fmove   fp0,fp2
  297.         fmul.s  .vr0(sp),fp2            ;fp2 = wu*vright[0]
  298.         fadd    fp5,fp2                 ;fp2 = end[0]
  299.         fmove   fp2,fp1
  300.         fmul    fp2,fp2
  301.         fmove   fp0,fp3
  302.         fmul.s  .vr1(sp),fp3            ;fp3 = wu*vright[1]
  303.         fadd    fp6,fp3                 ;fp3 = end[1]
  304.         fmove   fp3,fp4
  305.         fmul    fp3,fp3
  306.         fadd    fp3,fp2
  307.         fmul.s  .vr2(sp),fp0            ;fp0 = wu*vright[2]
  308.         fadd    fp7,fp0                 ;fp0 = end[2]
  309.         fmul    fp0,fp0
  310.         fadd    fp0,fp2
  311.         fsqrt   fp2                     ;fp2 = length(end)
  312.         fmove.s #(65536*6*(SKYSIZE/2-1)),fp0
  313.         fdiv    fp2,fp0
  314.         fmul    fp0,fp1                 ;fp1 = 6*(SKYSIZE/2-1)*end[0]
  315.         fmul    fp0,fp4                 ;fp4 = 6*(SKYSIZE/2-1)*end[1]
  316.         fmove.l fp1,d4
  317.         add.l   a4,d4                   ;d6 = snext
  318.         fmove.l fp4,d5
  319.         add.l   a4,d5                   ;d7 = tnext
  320.  
  321. ******  end of D_Sky_uv_To_st
  322.  
  323.         move.l  d4,.saved4(sp)          ;save snext
  324.         move.l  d5,.saved5(sp)          ;save tnext
  325.         sub.l   d6,d4                   ;d4 = snext - s
  326.         sub.l   d7,d5                   ;d5 = tnext - t
  327.         cmp     #5,d2                   ;(spancount-1) < 5?
  328.         blt.b   .special                ;yes -> special case
  329. .qdiv
  330.         asr.l   #7,d4                   ;d4 >> 7
  331.         asr.l   #7,d5                   ;d5 >> 7
  332.         lea     ReciprocTable,a3        ;a3 -> reciprocal table
  333.         move    0(a3,d2.w*2),d0         ;d0 = (1/(spancount-1))<<16
  334.         muls    d0,d4                   ;d4 = d4 / (spancount-1)
  335.         asr.l   #7,d4                   ;sstep = d4 >> 7
  336.         muls    d0,d5                   ;d5 = d5 / (spancount-1)
  337.         asr.l   #7,d5                   ;tstep = d5 >> 7
  338.         bra.b   .mainloop
  339. .special
  340.         cmp     #1,d2                   ;switch (spancount-1)
  341.         ble.b   .mainloop               ;0,1 -> no scaling needed
  342.         cmp     #3,d2                   ;3 -> standard qdiv
  343.         beq.b   .qdiv
  344.         blt.b   .spec_2
  345.         asr.l   #2,d4                   ;4 -> scale by shifting right
  346.         asr.l   #2,d5
  347.         bra.b   .mainloop
  348. .spec_2
  349.         asr.l   #1,d4                   ;2 -> scale by shifting right
  350.         asr.l   #1,d5
  351.  
  352.  
  353. ******  Main drawing loop.
  354.  
  355. ******  d2 : spancount
  356. ******  d4 : sstep
  357. ******  d5 : tstep
  358. ******  d6 : s
  359. ******  d7 : t
  360. ******  a0 : pdest
  361. ******  a5 : r_skysource
  362.  
  363. *                        do
  364. *                        {
  365. *                                *pdest++ = r_skysource[((t & R_SKY_TMASK) >> 8) +
  366. *                                                ((s & R_SKY_SMASK) >> 16)];
  367. *                                s += sstep;
  368. *                                t += tstep;
  369. *                        } while (--spancount > 0);
  370.  
  371.  
  372. .mainloop
  373.         move.l  d1,-(sp)
  374.         swap    d4
  375.         swap    d5
  376.         swap    d6
  377.         swap    d7
  378.         move    d5,d1                   ;d2 = tstep integer part
  379.         move    d4,d0                   ;d0 = sstep integer part
  380.         clr     d5                      ;d5 = tstep fractional part
  381.         clr     d4                      ;d4 = sstep fractional part
  382. .loop3
  383.         and     #R_SKY_TMASK,d7
  384.         asl     #8,d7
  385.         lea     0(a5,d7.w),a3
  386.         asr     #8,d7
  387.         and     #R_SKY_SMASK,d6
  388.         move.b  0(a3,d6.w),(a0)+
  389.         add.l   d4,d6
  390.         addx.w  d0,d6
  391.         add.l   d5,d7
  392.         addx.w  d1,d7
  393.         dbra    d2,.loop3
  394.         move.l  (sp)+,d1
  395.  
  396. ******  loop terminations
  397.  
  398.  
  399.         move.l   .saved5(sp),d7         ;t = tnext
  400.         move.l   .saved4(sp),d6         ;s = snext
  401.  
  402.         tst.l   d1                      ;while (count > 0)
  403.         bgt.w   .loop2
  404.         fmove.x .savefp1(sp),fp1
  405.  
  406.         move.l  (a6)+,a6
  407.         tst.l   a6
  408.         bne.w   .loop
  409.         add.l   #.fpuregs,sp
  410.         fmovem.x        (sp)+,fp2-fp7
  411.         movem.l (sp)+,d2-d7/a2-a6
  412.         rts
  413.  
  414. ReciprocTable
  415.         dc.w    0
  416.         dc.w    0
  417.         dc.w    0
  418.         dc.w    16384/3
  419.         dc.w    0
  420.         dc.w    16384/5
  421.         dc.w    16384/6
  422.         dc.w    16384/7
  423.         dc.w    16384/8
  424.         dc.w    16384/9
  425.         dc.w    16384/10
  426.         dc.w    16384/11
  427.         dc.w    16384/12
  428.         dc.w    16384/13
  429.         dc.w    16384/14
  430.         dc.w    16384/15
  431.         dc.w    16384/16
  432.         dc.w    16384/17
  433.         dc.w    16384/18
  434.         dc.w    16384/19
  435.         dc.w    16384/20
  436.         dc.w    16384/21
  437.         dc.w    16384/22
  438.         dc.w    16384/23
  439.         dc.w    16384/24
  440.         dc.w    16384/25
  441.         dc.w    16384/26
  442.         dc.w    16384/27
  443.         dc.w    16384/28
  444.         dc.w    16384/29
  445.         dc.w    16384/30
  446.         dc.w    16384/31
  447.  
  448.