home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 113 / EnigmaAmiga113CD.iso / software / sviluppo / quakeworld_src / client / r_light68k.s < prev    next >
Encoding:
Text File  |  2000-06-17  |  10.0 KB  |  375 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. ** r_light.c assembler implementations by Frank Wille <frank@phoenix.owl.de>
  23. **
  24.  
  25.         XREF    _cl
  26.         XREF    _d_lightstylevalue
  27.  
  28.         XDEF    _RecursiveLightPoint
  29.  
  30. SURF_DRAWTILED          =       $20
  31. MAXLIGHTMAPS            =       4
  32.  
  33. NODE_CONTENTS           =       0
  34. NODE_VISFRAME           =       4
  35. NODE_MINMAXS            =       8
  36. NODE_PARENT             =       20
  37. NODE_PLANE              =       24
  38. NODE_CHILDREN           =       28
  39. NODE_FIRSTSURFACE       =       36
  40. NODE_NUMSURFACES        =       38
  41.  
  42. MSURFACE_VISFRAME       =       0
  43. MSURFACE_DLIGHTFRAME    =       4
  44. MSURFACE_DLIGHTBITS     =       8
  45. MSURFACE_PLANE          =       12
  46. MSURFACE_FLAGS          =       16
  47. MSURFACE_FIRSTEDGE      =       20
  48. MSURFACE_NUMEDGES       =       24
  49. MSURFACE_CACHESPOTS     =       28
  50. MSURFACE_TEXTUREMINS    =       44
  51. MSURFACE_EXTENTS        =       48
  52. MSURFACE_TEXINFO        =       52
  53. MSURFACE_STYLES         =       56
  54. MSURFACE_SAMPLES        =       60
  55. MSURFACE_SIZEOF_EXP     =       6
  56. MSURFACE_SIZEOF         =       (1<<MSURFACE_SIZEOF_EXP)
  57.  
  58. MPLANE_NORMAL           =       0
  59. MPLANE_DIST             =       12
  60. MPLANE_TYPE             =       16
  61. MPLANE_SIGNBITS         =       17
  62. MPLANE_SIZEOF           =       20
  63.  
  64. MTEXINFO_VECS           =       0
  65. MTEXINFO_MIPADJUST      =       32
  66. MTEXINFO_TEXTURE        =       36
  67. MTEXINFO_FLAGS          =       40
  68. MTEXINFO_SIZEOF         =       44
  69.  
  70. CL_WORLDMODEL           =       469172
  71. MODEL_SURFACES          =       208
  72.  
  73.         fpu
  74.  
  75.  
  76.  
  77.  
  78. ******************************************************************************
  79. *
  80. *       int _RecursiveLightPoint (mnode_t *node, vec3_t start, vec3_t end)
  81. *
  82. ******************************************************************************
  83.  
  84.         cnop    0,4
  85. _RecursiveLightPoint
  86.  
  87. *****   stackframe
  88.  
  89.         rsreset
  90. .intregs        rs.l    1
  91.         rs.l    1
  92. .node           rs.l    1
  93. .start          rs.l    1
  94. .end            rs.l    1
  95.  
  96.  
  97.         move.l  a2,-(sp)
  98.         move.l  .node(sp),a0
  99.         move.l  .start(sp),a1
  100.         move.l  .end(sp),a2
  101.         bsr     DoRecursion
  102.         move.l  (sp)+,a2
  103.         rts
  104.  
  105. DoRecursion
  106.         movem.l d2-d7/a2-a6,-(sp)
  107.         fmovem.x        fp2-fp7,-(sp)
  108.         lea     -12(sp),sp
  109.         move.l  sp,a6
  110.  
  111. *        if (node->contents < 0)
  112. *                return -1;              // didn't hit anything
  113.  
  114.         moveq   #-1,d0
  115.         tst.l   NODE_CONTENTS(a0)       ;if (node->contents < 0)
  116.         blt.w   .end                    ;return -1
  117.  
  118. *        plane = node->plane;
  119. *        front = DotProduct (start, plane->normal) - plane->dist;
  120. *        back = DotProduct (end, plane->normal) - plane->dist;
  121. *        side = front < 0;
  122. *
  123. *        if ( (back < 0) == side)
  124. *                return RecursiveLightPoint (node->children[side], start, end);
  125.  
  126.         move.l  a1,a5
  127.         move.l  a2,a4
  128.         move.l  NODE_PLANE(a0),a3       ;plane = node->plane
  129.         fmove.s MPLANE_DIST(a3),fp0
  130.         fmove.s (a3)+,fp7
  131.         fmove.s (a3)+,fp2
  132.         fmove.s (a3)+,fp3
  133.         move.l  a0,a3
  134.         fmove.s (a1)+,fp4
  135.         fmul    fp7,fp4
  136.         fmove.s (a1)+,fp5
  137.         fmul    fp2,fp5
  138.         fadd    fp5,fp4
  139.         fmove.s (a1)+,fp6
  140.         fmul    fp3,fp6
  141.         fadd    fp6,fp4
  142.         fsub    fp0,fp4                 ;fp4 = front
  143.         fmul.s  (a2)+,fp7
  144.         fmul.s  (a2)+,fp2
  145.         fadd    fp7,fp2
  146.         fmul.s  (a2)+,fp3
  147.         fadd    fp3,fp2
  148.         fsub    fp0,fp2                 ;fp2 = back
  149.         moveq   #1,d2                   ;side = front < 0
  150.         ftst    fp4
  151.         fbolt.b .cont
  152.         moveq   #0,d2
  153. .cont
  154.         moveq   #1,d3                   ;d3 = back < 0
  155.         ftst    fp2
  156.         fbolt.b .cont2
  157.         moveq   #0,d3
  158. .cont2
  159.         move.l  d2,d7
  160.         cmp.l   d2,d3                   ;if (back < 0) == side
  161.         bne.b   .cont3
  162.         move.l  NODE_CHILDREN(a3,d2.l*4),a0
  163.         move.l  a5,a1
  164.         move.l  a4,a2
  165.         bsr     DoRecursion
  166.         bra.w   .end
  167.  
  168. *        frac = front / (front-back);
  169. *        mid[0] = start[0] + (end[0] - start[0])*frac;
  170. *        mid[1] = start[1] + (end[1] - start[1])*frac;
  171. *        mid[2] = start[2] + (end[2] - start[2])*frac;
  172.  
  173. .cont3
  174.         fsub    fp4,fp2
  175.         fdiv    fp2,fp4
  176.         fneg    fp4                     ;frac = front / (front-back)
  177.  
  178.         fmove.s (a5)+,fp0
  179.         fmove.s (a4)+,fp7
  180.         fsub    fp0,fp7
  181.         fmul    fp4,fp7
  182.         fadd    fp0,fp7
  183.         fmove.s fp7,(a6)+               ;fp7 = mid[0]
  184.         fmove.s (a5)+,fp0
  185.         fmove.s (a4)+,fp2
  186.         fsub    fp0,fp2
  187.         fmul    fp4,fp2
  188.         fadd    fp0,fp2
  189.         fmove.s fp2,(a6)+               ;fp2 = mid[1]
  190.         fmove.s (a5)+,fp0
  191.         fmove.s (a4)+,fp3
  192.         fsub    fp0,fp3
  193.         fmul    fp4,fp3
  194.         fadd    fp0,fp3
  195.         fmove.s fp3,(a6)+               ;fp3 = mid[2]
  196.         lea     -12(a6),a6
  197.         lea     -12(a5),a5
  198.         lea     -12(a4),a4
  199.  
  200. *        r = RecursiveLightPoint (node->children[side], start, mid);
  201. *        if (r >= 0)
  202. *                return r;               // hit something
  203. *
  204. *        if ( (back < 0) == side )
  205. *                return -1;              // didn't hit anuthing
  206.  
  207.         move.l  NODE_CHILDREN(a3,d2.l*4),a0
  208.         move.l  a5,a1
  209.         move.l  a6,a2
  210.         bsr     DoRecursion
  211.         tst.l   d0                      ;if (r >= 0)
  212.         bge.w   .end                    ;return r
  213.         moveq   #-1,d0
  214.         cmp.l   d2,d3                   ;if ((back < 0) == side)
  215.         beq.w   .end                    ;return -1
  216.  
  217. *        surf = cl.worldmodel->surfaces + node->firstsurface;
  218. *        for (i=0 ; i<node->numsurfaces ; i++, surf++)
  219.  
  220.         move.l  _cl+CL_WORLDMODEL,a0    ;surf = cl.worldmodel + ...
  221.         move.l  MODEL_SURFACES(a0),a0
  222.         moveq   #0,d0
  223.         move    NODE_FIRSTSURFACE(a3),d0
  224.         asl.l   #MSURFACE_SIZEOF_EXP,d0
  225.         add.l   d0,a0
  226.  
  227.         move    NODE_NUMSURFACES(a3),d6 ;node->numsurfaces
  228.         subq    #1,d6
  229.         bmi.w   .skip
  230.         lea     _d_lightstylevalue,a1
  231.  
  232. *                if (surf->flags & SURF_DRAWTILED)
  233. *                        continue;       // no lightmaps
  234. *
  235. *                tex = surf->texinfo;
  236.  
  237. .loop
  238.         move.l  MSURFACE_FLAGS(a0),d0   ;if (surf->flags & SURF...)
  239.         and.l   #SURF_DRAWTILED,d0
  240.         bne.w   .loopend                ;continue
  241.         move.l  MSURFACE_TEXINFO(a0),a5 ;tex = surf->texinfo
  242.  
  243. *                s = DotProduct (mid, tex->vecs[0]) + tex->vecs[0][3];
  244. *                t = DotProduct (mid, tex->vecs[1]) + tex->vecs[1][3];;
  245.  
  246.         fmove.s (a5)+,fp4
  247.         fmove.s (a5)+,fp5
  248.         fmove.s (a5)+,fp6
  249.         fmul    fp7,fp4
  250.         fmul    fp2,fp5
  251.         fadd    fp5,fp4
  252.         fmul    fp3,fp6
  253.         fadd    fp6,fp4
  254.         fadd.s  (a5)+,fp4               ;d4 = s
  255.         fmove.l fp4,d4
  256.  
  257.  
  258.         fmove.s (a5)+,fp0
  259.         fmove.s (a5)+,fp5
  260.         fmove.s (a5)+,fp6
  261.         fmul    fp7,fp0
  262.         fmul    fp2,fp5
  263.         fadd    fp5,fp0
  264.         fmul    fp3,fp6
  265.         fadd    fp6,fp0
  266.         fadd.s  (a5)+,fp0
  267.         fmove.l fp0,d1                  ;d1 = t
  268.  
  269. *                if (s < surf->texturemins[0] ||
  270. *                t < surf->texturemins[1])
  271. *                        continue;
  272. *
  273. *                ds = s - surf->texturemins[0];
  274. *                dt = t - surf->texturemins[1];
  275.  
  276.         move    MSURFACE_TEXTUREMINS(a0),d2
  277.         ext.l   d2
  278.         move    MSURFACE_TEXTUREMINS+2(a0),d3
  279.         ext.l   d3
  280.         sub.l   d2,d4                   ;d4 = ds
  281.         bmi.b   .loopend
  282.         sub.l   d3,d1                   ;d1 = dt
  283.         bmi.b   .loopend
  284.  
  285. *                if ( ds > surf->extents[0] || dt > surf->extents[1] )
  286. *                        continue;
  287. *
  288. *                if (!surf->samples)
  289. *                        return 0;
  290. *
  291. *                ds >>= 4;
  292. *                dt >>= 4;
  293.  
  294.         move    MSURFACE_EXTENTS(a0),d2
  295.         ext.l   d2                      ;d2 = surf->extents[0]
  296.         cmp.l   d2,d4
  297.         bgt.b   .loopend
  298.         move    MSURFACE_EXTENTS+2(a0),d3
  299.         ext.l   d3                      ;d3 = surf->extents[1]
  300.         cmp.l   d3,d1
  301.         bgt.b   .loopend
  302.         moveq   #0,d0                   ;if (!surf->samples)
  303.         move.l  MSURFACE_SAMPLES(a0),d5 ;return 0
  304.         beq.w   .end
  305.         asr.l   #4,d4                   ;ds >>= 4
  306.         asr.l   #4,d1                   ;dt >>= 4
  307.  
  308. *                lightmap = surf->samples;
  309. *                r = 0;
  310. *                if (lightmap)
  311. *                {
  312. *
  313. *                        lightmap += dt * ((surf->extents[0]>>4)+1) + ds;
  314.  
  315.         move.l  d5,a2                   ;lightmap -> surf->samples
  316.         moveq   #0,d5                   ;r = 0
  317.         asr.l   #4,d2
  318.         asr.l   #4,d3
  319.         addq.l  #1,d2                   ;d2 = (surf->extents[0]>>4)+1
  320.         addq.l  #1,d3                   ;d3 = (surf->extents[1]>>4)+1
  321.  
  322.         muls.l  d2,d1
  323.         add.l   d4,d1
  324.         add.l   d1,a2                   ;lightmap += dt * ...
  325.  
  326. *                        for (maps = 0 ; maps < MAXLIGHTMAPS && surf->styles[maps] != 255 ;
  327. *                                        maps++)
  328. *                        {
  329. *                                scale = d_lightstylevalue[surf->styles[maps]];
  330. *                                r += *lightmap * scale;
  331. *                                lightmap += ((surf->extents[0]>>4)+1) *
  332. *                                                ((surf->extents[1]>>4)+1);
  333. *                        }
  334. *
  335. *                        r >>= 8;
  336. *                }
  337. *                return r;
  338.  
  339.         lea     MSURFACE_STYLES(a0),a5
  340.         muls.l  d2,d3
  341.         moveq   #MAXLIGHTMAPS-1,d0
  342.         moveq   #0,d1
  343. .loop2
  344.         move.b  (a5)+,d1                ;surf->styles[map]
  345.         cmp.b   #$ff,d1
  346.         beq.b   .leave
  347.         move.l  0(a1,d1.l*4),d2         ;scale = ...
  348.         move.b  (a2),d1
  349.         mulu.l  d1,d2
  350.         add.l   d2,d5                   ;r += *lightmap * scale
  351.         add.l   d3,a2                   ;lightmap += (...)
  352.         dbra    d0,.loop2
  353. .leave
  354.         asr.l   #8,d5                   ;r >>= 8
  355.         move.l  d5,d0                   ;return r
  356.         bra.b   .end
  357. .loopend
  358.         lea     MSURFACE_SIZEOF(a0),a0
  359.         dbra    d6,.loop
  360.  
  361. *        return RecursiveLightPoint (node->children[!side], mid, end);
  362.  
  363. .skip
  364.         eori.l  #1,d7
  365.         move.l  NODE_CHILDREN(a3,d7.l*4),a0
  366.         move.l  a6,a1
  367.         move.l  a4,a2
  368.         bsr     DoRecursion
  369. .end
  370.         lea     12(sp),sp
  371.         fmovem.x        (sp)+,fp2-fp7
  372.         movem.l (sp)+,d2-d7/a2-a6
  373.         rts
  374.  
  375.