home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 113 / EnigmaAmiga113CD.iso / software / sviluppo / quake_src / r_bsp68k.s < prev    next >
Encoding:
Text File  |  2000-06-17  |  21.1 KB  |  770 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_bsp.c assembler implementations by Frank Wille <frank@phoenix.owl.de>
  23. **
  24.  
  25.         XREF    _r_visframecount
  26.         XREF    _r_framecount
  27.         XREF    _r_currentkey
  28.         XREF    _r_drawpolys
  29.         XREF    _r_worldpolysbacktofront
  30.         XREF    _pbtofpolys
  31.         XREF    _numbtofpolys
  32.         XREF    _pfrustum_indexes
  33.         XREF    _modelorg
  34.         XREF    _vpn
  35.         XREF    _vright
  36.         XREF    _vup
  37.         XREF    _cl
  38.         XREF    _view_clipplanes
  39.         XREF    _currententity
  40.         XREF    _screenedge
  41.         XREF    _entity_rotation
  42.  
  43.         XREF    _R_StoreEfrags
  44.         XREF    _R_RenderPoly
  45.         XREF    _R_RenderFace
  46.  
  47.         XDEF    _R_RotateBmodel
  48.         XDEF    _R_RecursiveWorldNode
  49.  
  50.  
  51.  
  52. CONTENTS_SOLID          =       -2              ;bspfile.h
  53. PLANE_X                 =       0
  54. PLANE_Y                 =       1
  55. PLANE_Z                 =       2
  56. SURF_PLANEBACK          =       2
  57. BACKFACE_EPSILON        equ.s   0.01            ;r_local.h
  58. MAX_BTOFPOLYS           =       5000
  59. PITCH                   =       0
  60. YAW                     =       1
  61. ROLL                    =       2
  62.  
  63. CLIP_NORMAL             =       0
  64. CLIP_DIST               =       12
  65. CLIP_NEXT               =       16
  66. CLIP_LEFTEDGE           =       20
  67. CLIP_RIGHTEDGE          =       21
  68. CLIP_RESERVED           =       22
  69. CLIP_SIZEOF             =       24
  70.  
  71. NODE_CONTENTS           =       0
  72. NODE_VISFRAME           =       4
  73. NODE_MINMAXS            =       8
  74. NODE_PARENT             =       20
  75. NODE_PLANE              =       24
  76. NODE_CHILDREN           =       28
  77. NODE_FIRSTSURFACE       =       36
  78. NODE_NUMSURFACES        =       38
  79.  
  80. LEAF_CONTENTS           =       0
  81. LEAF_VISFRAME           =       4
  82. LEAF_MINMAXS            =       8
  83. LEAF_PARENT             =       20
  84. LEAF_COMPRESSED_VIS     =       24
  85. LEAF_EFRAGS             =       28
  86. LEAF_FIRSTMARKSURFACE   =       32
  87. LEAF_NUMMARKSURFACES    =       36
  88. LEAF_KEY                =       40
  89.  
  90. MSURFACE_VISFRAME       =       0
  91. MSURFACE_DLIGHTFRAME    =       4
  92. MSURFACE_DLIGHTBITS     =       8
  93. MSURFACE_PLANE          =       12
  94. MSURFACE_FLAGS          =       16
  95. MSURFACE_FIRSTEDGE      =       20
  96. MSURFACE_NUMEDGES       =       24
  97. MSURFACE_CACHESPOTS     =       28
  98. MSURFACE_TEXTUREMINS    =       44
  99. MSURFACE_EXTENTS        =       48
  100. MSURFACE_TEXINFO        =       52
  101. MSURFACE_STYLES         =       56
  102. MSURFACE_SAMPLES        =       60
  103. MSURFACE_SIZEOF_EXP     =       6
  104. MSURFACE_SIZEOF         =       (1<<MSURFACE_SIZEOF_EXP)
  105.  
  106. MPLANE_NORMAL           =       0
  107. MPLANE_DIST             =       12
  108. MPLANE_TYPE             =       16
  109. MPLANE_SIGNBITS         =       17
  110. MPLANE_SIZEOF           =       20
  111.  
  112. ENTITY_FORCELINK        =       0
  113. ENTITY_UPDATE_TYPE      =       4
  114. ENTITY_BASELINE         =       8
  115. ENTITY_MSGTIME          =       52
  116. ENTITY_MSG_ORIGINS      =       60
  117. ENTITY_ORIGIN           =       84
  118. ENTITY_MSG_ANGLES       =       96
  119. ENTITY_ANGLES           =       120
  120. ENTITY_MODEL            =       132
  121. ENTITY_EFRAG            =       136
  122. ENTITY_FRAME            =       140
  123. ENTITY_SYNCBASE         =       144
  124. ENTITY_COLORMAP         =       148
  125. ENTITY_EFFECTS          =       152
  126. ENTITY_SKINNUM          =       156
  127. ENTITY_VISFRAME         =       160
  128. ENTITY_DLIGHTFRAME      =       164
  129. ENTITY_DLIGHTBITS       =       168
  130. ENTITY_TRIVIAL_ACCEPT   =       172
  131. ENTITY_TOPNODE          =       176
  132. ENTITY_SIZEOF           =       216
  133.  
  134. BTOFPOLY_CLIPFLAGS      =       0
  135. BTOFPOLY_PSURF          =       4
  136.  
  137. CL_WORLDMODEL           =       2692
  138. MODEL_SURFACES          =       180
  139.  
  140.  
  141.  
  142.  
  143.  
  144.  
  145.  
  146. ******************************************************************************
  147. *
  148. *       void _R_RotateBmodel (void)
  149. *
  150. ******************************************************************************
  151.  
  152.         cnop    0,4
  153. _R_RotateBmodel
  154.  
  155.         movem.l a2/a3,-(sp)
  156.         fmovem.x        fp2-fp7,-(sp)
  157.         lea     -9*4(sp),sp
  158.         move.l  sp,a2                   ;a2 -> temp2
  159.         lea     _entity_rotation,a3
  160.         move.l  _currententity,a0
  161.         lea     sincostab,a1
  162.         fmove.s #8,fp7
  163.         fmove.s ENTITY_ANGLES+YAW*4(a0),fp0
  164.         fmul    fp7,fp0
  165.         fmove.l fp0,d0                  ;d0 = angle
  166.         fmove.s 0(a1,d0.l*8),fp0
  167.         fmove.s 4(a1,d0.l*8),fp1
  168.         fmove.s ENTITY_ANGLES+PITCH*4(a0),fp2
  169.         fmul    fp7,fp2
  170.         fmove.l fp2,d0                  ;d0 = angle
  171.         fmove.s 0(a1,d0.l*8),fp2
  172.         fmove.s 4(a1,d0.l*8),fp3
  173.         fmove   fp3,fp5
  174.         fmul    fp1,fp5
  175.         fmove.s fp5,(a3)
  176.         fmove   fp3,fp4
  177.         fmul    fp0,fp4
  178.         fmove.s fp4,4(a2)
  179.         fneg    fp2
  180.         fmove.s fp2,8(a2)
  181.         fneg    fp2
  182.         fneg    fp0
  183.         fmove.s fp0,12(a3)
  184.         fneg    fp0
  185.         fmove   fp1,fp5
  186.         fmove   fp2,fp4
  187.         fmul    fp1,fp4
  188.         fmove.s fp4,24(a3)
  189.         fmove   fp2,fp4
  190.         fmul    fp0,fp4
  191.         fmove.s fp4,28(a2)
  192.         fmove.s fp3,32(a2)
  193.         fmove.s ENTITY_ANGLES+ROLL*4(a0),fp6
  194.         fmul    fp7,fp6
  195.         fmove.l fp6,d0                  ;d0 = angle
  196.         fmove.s 0(a1,d0.l*8),fp6
  197.         fmove.s 4(a1,d0.l*8),fp7
  198.         fmove.s 4(a2),fp0
  199.         fmove.s 8(a2),fp1
  200.         fmove   fp0,fp2
  201.         fmul    fp7,fp2
  202.         fmove   fp1,fp3
  203.         fmul    fp6,fp3
  204.         fsub    fp3,fp2
  205.         fmove.s fp2,4(a3)
  206.         fmul    fp6,fp0
  207.         fmul    fp7,fp1
  208.         fadd    fp1,fp0
  209.         fmove.s fp0,8(a3)
  210.         fmove   fp5,fp0
  211.         fmul    fp7,fp0
  212.         fmove.s fp0,16(a3)
  213.         fmul    fp6,fp5
  214.         fmove.s fp5,20(a3)
  215.         fmove.s 28(a2),fp0
  216.         fmove.s 32(a2),fp1
  217.         fmove   fp0,fp2
  218.         fmul    fp7,fp2
  219.         fmove   fp1,fp3
  220.         fmul    fp6,fp3
  221.         fsub    fp3,fp2
  222.         fmove.s fp2,28(a3)
  223.         fmul    fp6,fp0
  224.         fmul    fp7,fp1
  225.         fadd    fp1,fp0
  226.         fmove.s fp0,32(a3)
  227.  
  228.         fmove.s (a3)+,fp0
  229.         fmove.s (a3)+,fp1
  230.         fmove.s (a3)+,fp2
  231.  
  232. *        R_EntityRotate (modelorg);
  233. *        R_EntityRotate (vpn);
  234. *        R_EntityRotate (vright);
  235. *        R_EntityRotate (vup);
  236.  
  237.         lea     _modelorg,a0
  238.         bsr     EntityRotate
  239.         lea     -(36-12)(a3),a3
  240.         lea     _vpn,a0
  241.         bsr     EntityRotate
  242.         lea     -(36-12)(a3),a3
  243.         lea     _vright,a0
  244.         bsr     EntityRotate
  245.         lea     -(36-12)(a3),a3
  246.         lea     _vup,a0
  247.         bsr     EntityRotate
  248.  
  249. ****** R_TransformFrustum (inlined)
  250.  
  251.         moveq   #4-1,d0
  252.         lea     _screenedge,a0
  253.         lea     _view_clipplanes,a1
  254.         lea     _modelorg,a3
  255.         fmove.s (a3)+,fp7
  256. .loop
  257.         fmove.s (a0)+,fp1
  258.         fneg    fp1
  259.         fmove.s (a0)+,fp2
  260.         fmove.s (a0)+,fp0
  261.         lea     _vright,a2
  262.         fmove.s (a2)+,fp3
  263.         fmove.s (a2)+,fp4
  264.         fmove.s (a2)+,fp5
  265.         fmul    fp1,fp3
  266.         fmul    fp1,fp4
  267.         fmul    fp1,fp5
  268.         lea     _vup,a2
  269.         fmove.s (a2)+,fp6
  270.         fmul    fp2,fp6
  271.         fadd    fp6,fp3
  272.         fmove.s (a2)+,fp6
  273.         fmul    fp2,fp6
  274.         fadd    fp6,fp4
  275.         fmove.s (a2)+,fp6
  276.         fmul    fp2,fp6
  277.         fadd    fp6,fp5
  278.         lea     _vpn,a2
  279.         fmove.s (a2)+,fp6
  280.         fmul    fp0,fp6
  281.         fadd    fp6,fp3
  282.         fmove.s fp3,(a1)+
  283.         fmove.s (a2)+,fp6
  284.         fmul    fp0,fp6
  285.         fadd    fp6,fp4
  286.         fmove.s fp4,(a1)+
  287.         fmove.s (a2)+,fp6
  288.         fmul    fp0,fp6
  289.         fadd    fp6,fp5
  290.         fmove.s fp5,(a1)+
  291.  
  292.         fmul    fp7,fp3
  293.         fmul.s  (a3),fp4
  294.         fadd    fp4,fp3
  295.         fmul.s  4(a3),fp5
  296.         fadd    fp5,fp3
  297.         fmove.s fp3,(a1)+
  298.         lea     CLIP_SIZEOF-16(a1),a1
  299.         lea     MPLANE_SIZEOF-12(a0),a0
  300.         dbra    d0,.loop
  301.  
  302. ******  end of R_TransformFrustum
  303.  
  304.         lea     9*4(sp),sp
  305.         fmovem.x        (sp)+,fp2-fp7
  306.         movem.l (sp)+,a2/a3
  307.         rts
  308.  
  309. ******  EntityRotate (inlined)
  310.  
  311. EntityRotate
  312.         fmove.s (a0)+,fp3
  313.         fmove.s (a0)+,fp4
  314.         fmove.s (a0)+,fp5
  315.         lea     -12(a0),a0
  316.         fmove   fp3,fp6
  317.         fmul    fp0,fp6
  318.         fmove   fp4,fp7
  319.         fmul    fp1,fp7
  320.         fadd    fp7,fp6
  321.         fmove   fp5,fp7
  322.         fmul    fp2,fp7
  323.         fadd    fp7,fp6
  324.         fmove.s fp6,(a0)+
  325.         fmove.s (a3)+,fp6
  326.         fmul    fp3,fp6
  327.         fmove.s (a3)+,fp7
  328.         fmul    fp4,fp7
  329.         fadd    fp7,fp6
  330.         fmove.s (a3)+,fp7
  331.         fmul    fp5,fp7
  332.         fadd    fp7,fp6
  333.         fmove.s fp6,(a0)+
  334.         fmove.s (a3)+,fp6
  335.         fmul    fp3,fp6
  336.         fmove.s (a3)+,fp7
  337.         fmul    fp4,fp7
  338.         fadd    fp7,fp6
  339.         fmove.s (a3)+,fp7
  340.         fmul    fp5,fp7
  341.         fadd    fp7,fp6
  342.         fmove.s fp6,(a0)+
  343.         rts
  344.  
  345. ******  end of EntityRotate
  346.  
  347.  
  348.  
  349.  
  350.  
  351.  
  352. ******************************************************************************
  353. *
  354. *       void _R_RecursiveWorldNode (mnode_t *node, int clipflags)
  355. *
  356. ******************************************************************************
  357.  
  358.         cnop    0,4
  359. _R_RecursiveWorldNode
  360.  
  361.         rsreset
  362.         rs.l    1
  363. .node           rs.l    1
  364. .clipflags      rs.l    1
  365.  
  366.         move.l  .node(sp),a0
  367.         move.l  .clipflags(sp),d0
  368.         bsr     DoRecursion
  369.         rts
  370.  
  371. DoRecursion
  372.         movem.l d2-d5/a2/a3,-(sp)
  373.         fmovem.x        fp2-fp6,-(sp)
  374.         move.l  d0,d2
  375.         move.l  a0,a2
  376.  
  377. *        if (node->contents == CONTENTS_SOLID)
  378. *                return;         // solid
  379. *
  380. *        if (node->visframe != r_visframecount)
  381. *                return;
  382.  
  383.         cmp.l   #CONTENTS_SOLID,NODE_CONTENTS(a2)
  384.         beq.w   .end
  385.         move.l  NODE_VISFRAME(a2),d0
  386.         cmp.l   _r_visframecount,d0
  387.         bne.w   .end
  388.  
  389. *        if (clipflags)
  390. *        {
  391. *                for (i=0 ; i<4 ; i++)
  392.  
  393.         tst.l   d2
  394.         beq.b   .noclip
  395.         move.l  d2,d1
  396.         moveq   #4-1,d0
  397.         lea     _pfrustum_indexes,a0
  398.         lea     _view_clipplanes,a1
  399.         moveq   #0,d4
  400.  
  401. *                        if (! (clipflags & (1<<i)) )
  402. *                                continue;       // don't need to clip against it
  403.  
  404. .loop
  405.         lsr.b   #1,d1                   ; if (! (clipflags & (1<<i))
  406.         bcc.b   .next
  407.  
  408. *                        pindex = pfrustum_indexes[i];
  409. *
  410. *                        rejectpt[0] = (float)node->minmaxs[pindex[0]];
  411. *                        rejectpt[1] = (float)node->minmaxs[pindex[1]];
  412. *                        rejectpt[2] = (float)node->minmaxs[pindex[2]];
  413. *
  414. *                        d = DotProduct (rejectpt, view_clipplanes[i].normal);
  415. *                        d -= view_clipplanes[i].dist;
  416. *
  417. *                        if (d <= 0)
  418. *                                return;
  419.  
  420.         fmove.s (a1)+,fp3
  421.         fmove.s (a1)+,fp4
  422.         fmove.s (a1)+,fp5
  423.         fmove.s (a1)+,fp6
  424.         lea     -16(a1),a1
  425.         move.l  (a0),a3
  426.         move.l  (a3)+,d3
  427.         fmove.w NODE_MINMAXS(a2,d3.l*2),fp0 ;rejectpt[0] = ...
  428.         move.l  (a3)+,d3
  429.         fmove.w NODE_MINMAXS(a2,d3.l*2),fp1 ;rejectpt[1] = ...
  430.         move.l  (a3)+,d3
  431.         fmove.w NODE_MINMAXS(a2,d3.l*2),fp2 ;rejectpt[2] = ...
  432.         fmul    fp3,fp0
  433.         fmul    fp4,fp1
  434.         fmul    fp5,fp2
  435.         fadd    fp1,fp0
  436.         fadd    fp2,fp0                 ;d = DotProduct(...)
  437.         fsub    fp6,fp0                 ;d -= view_clipplanes[1].dist
  438.         ftst    fp0                     ;if (d <= 0)
  439.         fbole.w .end                    ;return
  440.  
  441. *                        acceptpt[0] = (float)node->minmaxs[pindex[3+0]];
  442. *                        acceptpt[1] = (float)node->minmaxs[pindex[3+1]];
  443. *                        acceptpt[2] = (float)node->minmaxs[pindex[3+2]];
  444. *
  445. *                        d = DotProduct (acceptpt, view_clipplanes[i].normal);
  446. *                        d -= view_clipplanes[i].dist;
  447. *
  448. *                        if (d >= 0)
  449. *                                clipflags &= ~(1<<i);   // node is entirely on screen
  450.  
  451.         move.l  (a3)+,d3
  452.         fmove.w NODE_MINMAXS(a2,d3.l*2),fp0 ;acceptpt[0] = ...
  453.         move.l  (a3)+,d3
  454.         fmove.w NODE_MINMAXS(a2,d3.l*2),fp1 ;acceptpt[1] = ...
  455.         move.l  (a3)+,d3
  456.         fmove.w NODE_MINMAXS(a2,d3.l*2),fp2 ;acceptpt[2] = ...
  457.         fmul    fp3,fp0
  458.         fmul    fp4,fp1
  459.         fmul    fp5,fp2
  460.         fadd    fp1,fp0
  461.         fadd    fp2,fp0                 ;d = DotProduct(...)
  462.         fsub    fp6,fp0                 ;d -= view_clipplanes[1].dist
  463.         ftst    fp0                     ;if (d >= 0)
  464.         fbolt.b .next
  465.         bclr    d4,d2                   ;clipflags &= ~(1<<i)
  466. .next
  467.         addq    #1,d4
  468.         lea     CLIP_SIZEOF(a1),a1
  469.         addq.l  #4,a0
  470.         dbra    d0,.loop
  471.  
  472. *        if (node->contents < 0)
  473.  
  474. .noclip
  475.         tst.l   NODE_CONTENTS(a2)
  476.         bge.b   .else
  477.  
  478. *                pleaf = (mleaf_t *)node;
  479. *
  480. *                mark = pleaf->firstmarksurface;
  481. *                c = pleaf->nummarksurfaces;
  482. *
  483. *                if (c)
  484. *                {
  485. *                        do
  486. *                        {
  487. *                                (*mark)->visframe = r_framecount;
  488. *                                mark++;
  489. *                        } while (--c);
  490. *                }
  491.  
  492.         move.l  LEAF_FIRSTMARKSURFACE(a2),a3 ;mark = pleaf->first...
  493.         move.l  LEAF_NUMMARKSURFACES(a2),d0  ;c = pleaf->nummark...
  494.         subq    #1,d0                   ;if (c)
  495.         bmi.b   .cont
  496.         move.l  _r_framecount,d1
  497. .loop2
  498.         move.l  (a3)+,a0                ;(*mark)->visframe = r_framecount
  499.         move.l  d1,MSURFACE_VISFRAME(a0)
  500.         dbra    d0,.loop2
  501.  
  502. *                if (pleaf->efrags)
  503. *                {
  504. *                        R_StoreEfrags (&pleaf->efrags);
  505. *                }
  506. *
  507. *                pleaf->key = r_currentkey;
  508. *                r_currentkey++;         // all bmodels in a leaf share the same key
  509.  
  510. .cont
  511.         tst.l   LEAF_EFRAGS(a2)         ;if (pleaf->efrags)
  512.         beq.b   .cont2
  513.         pea     LEAF_EFRAGS(a2)
  514.         jsr     _R_StoreEfrags          ;R_StoreEfrags (...)
  515.         addq    #4,sp
  516. .cont2
  517.         move.l  _r_currentkey,LEAF_KEY(a2)
  518.         addq.l  #1,_r_currentkey        ;r_currentkey++
  519.         bra.w   .end
  520.  
  521. *                plane = node->plane;
  522. *
  523. *                switch (plane->type)
  524. *                {
  525. *                case PLANE_X:
  526. *                        dot = modelorg[0] - plane->dist;
  527. *                        break;
  528. *                case PLANE_Y:
  529. *                        dot = modelorg[1] - plane->dist;
  530. *                        break;
  531. *                case PLANE_Z:
  532. *                        dot = modelorg[2] - plane->dist;
  533. *                        break;
  534. *                default:
  535. *                        dot = DotProduct (modelorg, plane->normal) - plane->dist;
  536. *                        break;
  537.  
  538. .else
  539.         move.l  NODE_PLANE(a2),a0       ;plane = node->plane
  540.         lea     _modelorg,a1
  541.         move.b  MPLANE_TYPE(a0),d0      ;switch (plane->type)
  542.         fmove.s MPLANE_DIST(a0),fp0
  543.         cmp.b   #PLANE_X,d0             ;case PLANE_X
  544.         beq.b   .x
  545.         cmp.b   #PLANE_Y,d0             ;case PLANE_Y
  546.         beq.b   .y
  547.         cmp.b   #PLANE_Z,d0             ;case PLANE_Z
  548.         beq.b   .z
  549. .def
  550.         fmove.s (a1)+,fp1               ;dot = DotProduct(...)
  551.         fmove.s (a1)+,fp2
  552.         fmove.s (a1)+,fp3
  553.         fmul.s  (a0)+,fp1
  554.         fmul.s  (a0)+,fp2
  555.         fmul.s  (a0)+,fp3
  556.         fadd    fp1,fp2
  557.         fadd    fp3,fp2
  558.         fsub    fp0,fp2
  559.         bra.b   .cont3
  560. .x
  561.         fmove.s (a1),fp2                ;dot = modelorg[0] - plane->dist
  562.         fsub    fp0,fp2
  563.         bra.b   .cont3
  564. .y
  565.         fmove.s 4(a1),fp2               ;dot = modelorg[1] - plane->dist
  566.         fsub    fp0,fp2
  567.         bra.b   .cont3
  568. .z
  569.         fmove.s 8(a1),fp2               ;dot = modelorg[2] - plane->dist
  570.         fsub    fp0,fp2
  571.  
  572. *                if (dot >= 0)
  573. *                        side = 0;
  574. *                else
  575. *                        side = 1;
  576.  
  577.  
  578. .cont3
  579.         ftst    fp2                     ;if (dot >= 0)
  580.         fbolt.b .lt
  581.         moveq   #0,d3                   ;side = 0
  582.         bra.b   .ge
  583. .lt
  584.         moveq   #1,d3                   ;side = 1
  585. .ge
  586.  
  587. *                R_RecursiveWorldNode (node->children[side], clipflags);
  588.  
  589.         move.l  d2,d0
  590.         move.l  NODE_CHILDREN(a2,d3.l*4),a0
  591.         bsr     DoRecursion
  592.         move.l  _r_framecount,d5
  593.  
  594. *                c = node->numsurfaces;
  595. *
  596. *                if (c)
  597.  
  598.         move    NODE_NUMSURFACES(a2),d4 ;c = node->numsurfaces
  599.         subq    #1,d4                   ;if (c)
  600.         bmi.w   .skip
  601.  
  602. *                        surf = cl.worldmodel->surfaces + node->firstsurface;
  603. *
  604. *                        if (dot < -BACKFACE_EPSILON)
  605. *                        {
  606.  
  607.         move.l  _cl+CL_WORLDMODEL,a0    ;surf = cl.worldmodel + ...
  608.         move.l  MODEL_SURFACES(a0),a3
  609.         moveq   #0,d0
  610.         move    NODE_FIRSTSURFACE(a2),d0
  611.         asl.l   #MSURFACE_SIZEOF_EXP,d0
  612.         add.l   d0,a3
  613.         fcmp.s  #-BACKFACE_EPSILON,fp2   ;if (dot < -BACKFACE_EPSILON)
  614.         fboge.b .else2
  615.  
  616. *                                        if ((surf->flags & SURF_PLANEBACK) &&
  617. *                                                (surf->visframe == r_framecount))
  618. *                                        {
  619. *                                                if (r_drawpolys)
  620. *                                                {
  621. *                                                        if (r_worldpolysbacktofront)
  622. *                                                        {
  623. *                                                                if (numbtofpolys < MAX_BTOFPOLYS)
  624. *                                                                {
  625. *                                                                        pbtofpolys[numbtofpolys].clipflags =
  626. *                                                                                        clipflags;
  627. *                                                                        pbtofpolys[numbtofpolys].psurf = surf;
  628. *                                                                        numbtofpolys++;
  629. *                                                                }
  630. *                                                        }
  631. *                                                        else
  632. *                                                        {
  633. *                                                                R_RenderPoly (surf, clipflags);
  634. *                                                        }
  635. *                                                }
  636. *                                                else
  637. *                                                {
  638. *                                                        R_RenderFace (surf, clipflags);
  639. *                                                }
  640. *                                        }
  641.  
  642. .loop3
  643.         move.l  MSURFACE_FLAGS(a3),d0   ;if ((surf->flags & SURF_PLANEBACK) &&
  644.         and.l   #SURF_PLANEBACK,d0
  645.         beq.b   .next2
  646.         cmp.l   MSURFACE_VISFRAME(a3),d5 ;(surf->visframe == r_framecount))
  647.         bne.b   .next2
  648.         tst.l   _r_drawpolys            ;if (r_drawpolys)
  649.         beq.b   .nopoly
  650.         tst.l   _r_worldpolysbacktofront ;if (r_worldpolysbacktofront)
  651.         beq.b   .renderpoly
  652.         move.l  _numbtofpolys,d0
  653.         cmp.l   #MAX_BTOFPOLYS,d0
  654.         bge.b   .next2
  655.         move.l  _pbtofpolys,a1
  656.         move.l  d2,BTOFPOLY_CLIPFLAGS(a1,d0.l*8)
  657.         move.l  a3,BTOFPOLY_PSURF(a1,d0.l*8)
  658.         addq.l  #1,_numbtofpolys
  659.         bra.b   .next2
  660. .renderpoly
  661.         move.l  d2,-(sp)
  662.         move.l  a3,-(sp)
  663.         jsr     _R_RenderPoly
  664.         addq    #8,sp
  665.         bra.b   .next2
  666. .nopoly
  667.         move.l  d2,-(sp)
  668.         move.l  a3,-(sp)
  669.         jsr     _R_RenderFace
  670.         addq    #8,sp
  671. .next2
  672.  
  673. *                                        surf++;
  674. *                                } while (--c);
  675.  
  676.         lea     MSURFACE_SIZEOF(a3),a3
  677.         dbra    d4,.loop3
  678.         bra.b   .else3
  679. .else2
  680.  
  681. *                        else if (dot > BACKFACE_EPSILON)
  682. *                        {
  683.  
  684.         fcmp.s  #BACKFACE_EPSILON,fp2
  685.         fbole.b .else3
  686.  
  687. *                                        if (!(surf->flags & SURF_PLANEBACK) &&
  688. *                                                (surf->visframe == r_framecount))
  689. *                                        {
  690. *                                                if (r_drawpolys)
  691. *                                                {
  692. *                                                        if (r_worldpolysbacktofront)
  693. *                                                        {
  694. *                                                                if (numbtofpolys < MAX_BTOFPOLYS)
  695. *                                                                {
  696. *                                                                        pbtofpolys[numbtofpolys].clipflags =
  697. *                                                                                        clipflags;
  698. *                                                                        pbtofpolys[numbtofpolys].psurf = surf;
  699. *                                                                        numbtofpolys++;
  700. *                                                                }
  701. *                                                        }
  702. *                                                        else
  703. *                                                        {
  704. *                                                                R_RenderPoly (surf, clipflags);
  705. *                                                        }
  706. *                                                }
  707. *                                                else
  708. *                                                {
  709. *                                                        R_RenderFace (surf, clipflags);
  710. *                                                }
  711. *                                        }
  712.  
  713. .loop4
  714.         move.l  MSURFACE_FLAGS(a3),d0
  715.         and.l   #SURF_PLANEBACK,d0
  716.         bne.b   .next3
  717.         cmp.l   MSURFACE_VISFRAME(a3),d5
  718.         bne.b   .next3
  719.         tst.l   _r_drawpolys
  720.         beq.b   .nopoly2
  721.         tst.l   _r_worldpolysbacktofront
  722.         beq.b   .renderpoly2
  723.         move.l  _numbtofpolys,d0
  724.         cmp.l   #MAX_BTOFPOLYS,d0
  725.         bge.b   .next3
  726.         move.l  _pbtofpolys,a1
  727.         move.l  d2,BTOFPOLY_CLIPFLAGS(a1,d0.l*8)
  728.         move.l  a3,BTOFPOLY_PSURF(a1,d0.l*8)
  729.         addq.l  #1,_numbtofpolys
  730.         bra.b   .next3
  731. .renderpoly2
  732.         move.l  d2,-(sp)
  733.         move.l  a3,-(sp)
  734.         jsr     _R_RenderPoly
  735.         addq    #8,sp
  736.         bra.b   .next3
  737. .nopoly2
  738.         move.l  d2,-(sp)
  739.         move.l  a3,-(sp)
  740.         jsr     _R_RenderFace
  741.         addq    #8,sp
  742. .next3
  743.  
  744. *                                        surf++;
  745. *                                } while (--c);
  746.  
  747.         lea     MSURFACE_SIZEOF(a3),a3
  748.         dbra    d4,.loop4
  749. .else3
  750.  
  751. *                        r_currentkey++;
  752.  
  753.         addq.l  #1,_r_currentkey
  754. .skip
  755.  
  756. *                R_RecursiveWorldNode (node->children[!side], clipflags);
  757.  
  758.         move.l  d2,d0
  759.         eori.l  #1,d3
  760.         move.l  NODE_CHILDREN(a2,d3.l*4),a0
  761.         bsr     DoRecursion
  762. .end
  763.         fmovem.x        (sp)+,fp2-fp6
  764.         movem.l (sp)+,d2-d5/a2/a3
  765.         rts
  766.  
  767.  
  768. sincostab       incbin  "sincos.bin"
  769.  
  770.