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