home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 113 / EnigmaAmiga113CD.iso / software / sviluppo / quakeworld_src / client / r_draw68k.s < prev    next >
Encoding:
Text File  |  2000-06-17  |  43.0 KB  |  1,471 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_draw.c assembler implementations by Frank Wille <frank@phoenix.owl.de>
  23. **
  24.  
  25.         XREF    _r_lastvertvalid
  26.         XREF    _r_u1
  27.         XREF    _r_v1
  28.         XREF    _r_lzi1
  29.         XREF    _r_ceilv1
  30.         XREF    _r_nearzi
  31.         XREF    _r_nearzionly
  32.         XREF    _r_emitted
  33.         XREF    _r_framecount
  34.         XREF    _r_pedge
  35.         XREF    _r_refdef
  36.         XREF    _r_leftclipped
  37.         XREF    _r_rightclipped
  38.         XREF    _r_leftexit
  39.         XREF    _r_rightexit
  40.         XREF    _r_leftenter
  41.         XREF    _r_rightenter
  42.         XREF    _r_edges
  43.         XREF    _r_outofsurfaces
  44.         XREF    _r_outofedges
  45.         XREF    _r_pcurrentvertbase
  46.         XREF    _r_polycount
  47.         XREF    _r_currentkey
  48.         XREF    _c_faceclip
  49.         XREF    _modelorg
  50.         XREF    _xscale
  51.         XREF    _yscale
  52.         XREF    _xscaleinv
  53.         XREF    _yscaleinv
  54.         XREF    _xcenter
  55.         XREF    _ycenter
  56.         XREF    _vright
  57.         XREF    _vup
  58.         XREF    _vpn
  59.         XREF    _cacheoffset
  60.         XREF    _edge_p
  61.         XREF    _surfaces
  62.         XREF    _surface_p
  63.         XREF    _surf_max
  64.         XREF    _edge_max
  65.         XREF    _newedges
  66.         XREF    _removeedges
  67.         XREF    _view_clipplanes
  68.         XREF    _insubmodel
  69.         XREF    _currententity
  70.         XREF    _makeleftedge
  71.         XREF    _makerightedge
  72.  
  73.         XDEF    _R_EmitEdge
  74.         XDEF    _R_ClipEdge
  75.         XDEF    _R_RenderFace
  76.  
  77. NEAR_CLIP               equ.s   0.01            ;must match the def. in r_local.h
  78. FULLY_CLIPPED_CACHED    =       $80000000
  79. FRAMECOUNT_MASK         =       $7FFFFFFF
  80.  
  81. REFDEF_FVRECTX_ADJ      =       68
  82. REFDEF_FVRECTY_ADJ      =       72
  83. REFDEF_VRECTX_ADJ_S20   =       76
  84. REFDEF_VRECTXR_ADJ_S20  =       80
  85. REFDEF_FVRECTRIGHT_ADJ  =       84
  86. REFDEF_FVRECTBOTTOM_ADJ =       88
  87.  
  88. EDGE_U                  =       0
  89. EDGE_U_STEP             =       4
  90. EDGE_PREV               =       8
  91. EDGE_NEXT               =       12
  92. EDGE_SURFS              =       16
  93. EDGE_NEXTREMOVE         =       20
  94. EDGE_NEARZI             =       24
  95. EDGE_OWNER              =       28
  96. EDGE_SIZEOF_EXP         =       5
  97. EDGE_SIZEOF             =       (1<<EDGE_SIZEOF_EXP)
  98.  
  99. CLIP_NORMAL             =       0
  100. CLIP_DIST               =       12
  101. CLIP_NEXT               =       16
  102. CLIP_LEFTEDGE           =       20
  103. CLIP_RIGHTEDGE          =       21
  104. CLIP_RESERVED           =       22
  105. CLIP_SIZEOF             =       24
  106.  
  107. MVERTEX_SIZEOF          =       12
  108.  
  109. MEDGE_V                 =       0
  110. MEDGE_CEO               =       4
  111. MEDGE_SIZEOF_EXP        =       3
  112. MEDGE_SIZEOF            =       (1<<MEDGE_SIZEOF_EXP)
  113.  
  114. MSURFACE_VISFRAME       =       0
  115. MSURFACE_DLIGHTFRAME    =       4
  116. MSURFACE_DLIGHTBITS     =       8
  117. MSURFACE_PLANE          =       12
  118. MSURFACE_FLAGS          =       16
  119. MSURFACE_FIRSTEDGE      =       20
  120. MSURFACE_NUMEDGES       =       24
  121. MSURFACE_CACHESPOTS     =       28
  122. MSURFACE_TEXTUREMINS    =       44
  123. MSURFACE_EXTENTS        =       48
  124. MSURFACE_TEXINFO        =       52
  125. MSURFACE_STYLES         =       56
  126. MSURFACE_SAMPLES        =       60
  127. MSURFACE_SIZEOF_EXP     =       6
  128. MSURFACE_SIZEOF         =       (1<<MSURFACE_SIZEOF_EXP)
  129.  
  130. MPLANE_NORMAL           =       0
  131. MPLANE_DIST             =       12
  132. MPLANE_TYPE             =       16
  133. MPLANE_SIGNBITS         =       17
  134. MPLANE_SIZEOF           =       20
  135.  
  136. SURF_NEXT               =       0
  137. SURF_PREV               =       4
  138. SURF_SPANS              =       8
  139. SURF_KEY                =       12
  140. SURF_LAST_U             =       16
  141. SURF_SPANSTATE          =       20
  142. SURF_FLAGS              =       24
  143. SURF_DATA               =       28
  144. SURF_ENTITY             =       32
  145. SURF_NEARZI             =       36
  146. SURF_INSUBMODEL         =       40
  147. SURF_D_ZIORIGIN         =       44
  148. SURF_D_ZISTEPU          =       48
  149. SURF_D_ZISTEPV          =       52
  150. SURF_SIZEOF_EXP         =       6
  151. SURF_SIZEOF             =       (1<<SURF_SIZEOF_EXP)
  152.  
  153. ENTITY_KEYNUM        =    0
  154. ENTITY_ORIGIN        =    4
  155. ENTITY_ANGLES        =    16
  156. ENTITY_MODEL        =    28
  157. ENTITY_FRAME        =    32
  158. ENTITY_COLORMAP        =    36
  159. ENTITY_SKINNUM        =    40
  160. ENTITY_SCOREBOARD    =    44
  161. ENTITY_SYNCBASE        =    48
  162. ENTITY_EFRAG        =    52
  163. ENTITY_VISFRAME        =    56
  164. ENTITY_DLIGHTFRAME    =    60
  165. ENTITY_DLIGHTBITS    =    64
  166. ENTITY_TRIVIAL_ACCEPT    =    68
  167. ENTITY_TOPNODE        =    72
  168. ENTITY_SIZEOF           =       76
  169.  
  170. MODEL_NAME              =       0
  171. MODEL_NEEDLOAD          =       64
  172. MODEL_TYPE              =       68
  173. MODEL_NUMFRAMES         =       72
  174. MODEL_SYNCTYPE          =       76
  175. MODEL_FLAGS             =       80
  176. MODEL_MINS              =       84
  177. MODEL_MAXS              =       96
  178. MODEL_RADIUS            =       108
  179. MODEL_CLIPBOX        =    112
  180. MODEL_CLIPMINS        =    116
  181. MODEL_CLIPMAXS        =    128
  182. MODEL_FIRSTMS           =       140
  183. MODEL_NUMMS             =       144
  184. MODEL_NUMSUBMODELS      =       148
  185. MODEL_SUBMODELS         =       152
  186. MODEL_NUMPLANES         =       156
  187. MODEL_PLANES            =       160
  188. MODEL_NUMLEAFS          =       164
  189. MODEL_LEAFS             =       168
  190. MODEL_NUMVERTEXES       =       172
  191. MODEL_VERTEXES          =       176
  192. MODEL_NUMEDGES          =       180
  193. MODEL_EDGES             =       184
  194. MODEL_NUMNODES          =       188
  195. MODEL_NODES             =       192
  196. MODEL_NUMTEXINFO        =       196
  197. MODEL_TEXINFO           =       200
  198. MODEL_NUMSURFACES       =       204
  199. MODEL_SURFACES          =       208
  200. MODEL_NUMSURFEDGES      =       212
  201. MODEL_SURFEDGES         =       216
  202. MODEL_NUMCLIPNODES      =       220
  203. MODEL_CLIPNODES         =       224
  204. MODEL_NUMMARKSURFACES   =       228
  205. MODEL_MARKSURFACES      =       232
  206.  
  207. ******************************************************************************
  208. *
  209. *       void _R_EmitEdge (mvertex_t *pv0, mvertex_t *pv1)
  210. *
  211. ******************************************************************************
  212.  
  213.         cnop    0,4
  214. _R_EmitEdge
  215.  
  216.         rsreset
  217. .fpuregs        rs.x    6
  218. .intregs        rs.l    7
  219.         rs.l    1
  220. .pv0            rs.l    1
  221. .pv1            rs.l    1
  222.  
  223.         movem.l d2-d5/a2-a4,-(sp)
  224.         fmovem.x        fp2-fp7,-(sp)
  225.         fmove.l fpcr,d5
  226.         fmove.l #$000000b0,fpcr
  227.         move.l  .pv0(sp),a0
  228.         move.l  .pv1(sp),a1
  229.         lea     _r_refdef,a4
  230.  
  231. *        if (r_lastvertvalid)
  232. *        {
  233. *                u0 = r_u1;
  234. *                v0 = r_v1;
  235. *                lzi0 = r_lzi1;
  236. *                ceilv0 = r_ceilv1;
  237. *        }
  238.  
  239.         tst.l   _r_lastvertvalid
  240.         beq.b   .else
  241.         fmove.s _r_u1,fp0               ;u0 = r_u1
  242.         fmove.s _r_v1,fp1               ;v0 = r_v1
  243.         fmove.s _r_lzi1,fp2             ;lzi0 = r_lzi1
  244.         move.l  _r_ceilv1,d0            ;ceilv0 = r_ceilv1
  245.         bra.b   .next
  246.  
  247. *                world = &pv0->position[0];
  248. *
  249. *                VectorSubtract (world, modelorg, local);
  250. *                TransformVector (local, transformed);
  251. *
  252. *                if (transformed[2] < NEAR_CLIP)
  253. *                        transformed[2] = NEAR_CLIP;
  254. *
  255. *                lzi0 = 1.0 / transformed[2];
  256. *
  257. *                scale = xscale * lzi0;
  258. *                u0 = (xcenter + scale*transformed[0]);
  259. *                if (u0 < r_refdef.fvrectx_adj)
  260. *                        u0 = r_refdef.fvrectx_adj;
  261. *                if (u0 > r_refdef.fvrectright_adj)
  262. *                        u0 = r_refdef.fvrectright_adj;
  263. *
  264. *                scale = yscale * lzi0;
  265. *                v0 = (ycenter - scale*transformed[1]);
  266. *                if (v0 < r_refdef.fvrecty_adj)
  267. *                        v0 = r_refdef.fvrecty_adj;
  268. *                if (v0 > r_refdef.fvrectbottom_adj)
  269. *                        v0 = r_refdef.fvrectbottom_adj;
  270. *
  271. *                ceilv0 = (int) ceil(v0);
  272.  
  273. .else
  274.         lea     _modelorg,a2
  275.  
  276. ******  VectorSubtract (inlined)
  277.  
  278.         fmove.s (a0)+,fp3               ;VectorSubtract (world,
  279.         fsub.s  (a2)+,fp3               ;modelorg,local)
  280.         fmove.s (a0)+,fp4
  281.         fsub.s  (a2)+,fp4
  282.         fmove.s (a0)+,fp5
  283.         fsub.s  (a2)+,fp5
  284.  
  285. ******  TransformVector (inlined)
  286.  
  287.         lea     _vright,a3              ;TransformVector (local,
  288.         fmove.s (a3)+,fp0               ;transformed)
  289.         fmul    fp3,fp0
  290.         fmove.s (a3)+,fp1
  291.         fmul    fp4,fp1
  292.         fadd    fp1,fp0
  293.         fmove.s (a3)+,fp1
  294.         fmul    fp5,fp1
  295.         fadd    fp1,fp0                 ;fp0 = transformed[0]
  296.         lea     _vup,a3
  297.         fmove.s (a3)+,fp1
  298.         fmul    fp3,fp1
  299.         fmove.s (a3)+,fp2
  300.         fmul    fp4,fp2
  301.         fadd    fp2,fp1
  302.         fmove.s (a3)+,fp2
  303.         fmul    fp5,fp2
  304.         fadd    fp2,fp1                 ;fp1 = transformed[1]
  305.         lea     _vpn,a3
  306.         fmul.s  (a3)+,fp3
  307.         fmul.s  (a3)+,fp4
  308.         fmul.s  (a3)+,fp5
  309.         fadd    fp4,fp3
  310.         fadd    fp5,fp3                 ;fp3 = transformed[2]
  311.  
  312. ******  end of TransformVector
  313.  
  314.         fcmp.s  #NEAR_CLIP,fp3          ;if transformed[2] < NEAR_CLIP
  315.         fboge.b .cont
  316.         fmove.s #NEAR_CLIP,fp3          ;transformed[2] = NEAR_CLIP
  317. .cont
  318.         fmove.s #1,fp2
  319.         fdiv    fp3,fp2                 ;lzi0 = 1.0 / transformed[2]
  320.         fmul    fp2,fp0
  321.         fmul.s  _xscale,fp0             ;scale = scale * lzi0
  322.         fadd.s  _xcenter,fp0            ;u0 = xcenter + (scale * lzi0)
  323.         fmove.s REFDEF_FVRECTX_ADJ(a4),fp7 ;if (u0 < r_refdef.fvrectx ...
  324.         fcmp    fp7,fp0
  325.         fboge.b .cont2
  326.         fmove   fp7,fp0                 ;u0 = r_refdef.fvrectx_adj
  327. .cont2
  328.         fmove.s REFDEF_FVRECTRIGHT_ADJ(a4),fp7
  329.         fcmp    fp7,fp0                 ;if (u0 > r_refdef.fvrec...
  330.         fbole.b .cont3
  331.         fmove   fp7,fp0                 ;u0 = r_refdef.fvrectright_adj
  332. .cont3
  333.         fmul    fp2,fp1
  334.         fmul.s  _yscale,fp1
  335.         fsub.s  _ycenter,fp1
  336.         fneg    fp1                     ;scale = yscale * lzi0
  337.         fmove.s REFDEF_FVRECTY_ADJ(a4),fp7
  338.         fcmp    fp7,fp1                 ;if (v0 < refdef.fvrecty_adj)
  339.         fboge.b .cont4
  340.         fmove   fp7,fp1                 ;v0 = ycenter - scale*transformed[1]
  341. .cont4
  342.         fmove.s REFDEF_FVRECTBOTTOM_ADJ(a4),fp7
  343.         fcmp    fp7,fp1                 ;if (v0 > r_refdef.fvrectb...
  344.         fbole.b .cont5
  345.         fmove   fp7,fp1                 ;v0 = r_refdef.fvrectbottom_adj
  346. .cont5
  347.         fmove.l fp1,d0
  348. .next
  349.  
  350. *        world = &pv1->position[0];
  351. *
  352. *// transform and project
  353. *        VectorSubtract (world, modelorg, local);
  354. *        TransformVector (local, transformed);
  355. *
  356. *        if (transformed[2] < NEAR_CLIP)
  357. *                transformed[2] = NEAR_CLIP;
  358. *
  359. *        r_lzi1 = 1.0 / transformed[2];
  360. *
  361. *        scale = xscale * r_lzi1;
  362. *        r_u1 = (xcenter + scale*transformed[0]);
  363. *        if (r_u1 < r_refdef.fvrectx_adj)
  364. *                r_u1 = r_refdef.fvrectx_adj;
  365. *        if (r_u1 > r_refdef.fvrectright_adj)
  366. *                r_u1 = r_refdef.fvrectright_adj;
  367. *
  368. *        scale = yscale * r_lzi1;
  369. *        r_v1 = (ycenter - scale*transformed[1]);
  370. *        if (r_v1 < r_refdef.fvrecty_adj)
  371. *                r_v1 = r_refdef.fvrecty_adj;
  372. *        if (r_v1 > r_refdef.fvrectbottom_adj)
  373. *                r_v1 = r_refdef.fvrectbottom_adj;
  374.  
  375.         fmove.s fp0,-(sp)
  376.  
  377. ******  VectorSubtract (inlined)
  378.  
  379.         lea     _modelorg,a2
  380.         fmove.s (a1)+,fp3               ;VectorSubtract (world, modelorg
  381.         fsub.s  (a2)+,fp3               ;local)
  382.         fmove.s (a1)+,fp4
  383.         fsub.s  (a2)+,fp4
  384.         fmove.s (a1)+,fp5
  385.         fsub.s  (a2)+,fp5
  386.  
  387. ******  TransformVector (inlined)
  388.  
  389.         lea     _vright,a3              ;TransformVector (local, transformed)
  390.         fmove.s (a3)+,fp6
  391.         fmul    fp3,fp6
  392.         fmove.s (a3)+,fp7
  393.         fmul    fp4,fp7
  394.         fadd    fp7,fp6
  395.         fmove.s (a3)+,fp7
  396.         fmul    fp5,fp7
  397.         fadd    fp6,fp7                 ;fp7 = transformed[0]
  398.         lea     _vup,a3
  399.         fmove.s (a3)+,fp6
  400.         fmul    fp3,fp6
  401.         fmove.s (a3)+,fp0
  402.         fmul    fp4,fp0
  403.         fadd    fp0,fp6
  404.         fmove.s (a3)+,fp0
  405.         fmul    fp5,fp0
  406.         fadd    fp0,fp6                 ;fp6 = transformed[1]
  407.         fmove.s (sp)+,fp0
  408.         lea     _vpn,a3
  409.         fmul.s  (a3)+,fp3
  410.         fmul.s  (a3)+,fp4
  411.         fmul.s  (a3)+,fp5
  412.         fadd    fp4,fp3
  413.         fadd    fp5,fp3                 ;fp3 = transformed[2]
  414.  
  415. ******  end of TransformVector
  416.  
  417.         fcmp.s  #NEAR_CLIP,fp3          ;if transformed[2] < NEAR_CLIP
  418.         fboge.b .cont6
  419.         fmove.s #NEAR_CLIP,fp3          ;transformed[2] = NEAR_CLIP
  420. .cont6
  421.         fmove.s #1,fp5
  422.         fdiv    fp3,fp5                 ;r_lzi1 = 1.0 / transformed[2]
  423.         fmul    fp5,fp7
  424.         fmul.s  _xscale,fp7
  425.         fadd.s  _xcenter,fp7            ;scale = xscale * r_lzi
  426.         fmove.s REFDEF_FVRECTX_ADJ(a4),fp4
  427.         fcmp    fp4,fp7                 ;if (r_u1 < r_refdef...
  428.         fboge.b .cont7
  429.         fmove   fp4,fp7                 ;r_u1 = r_refdef.fvrectx_adj)
  430. .cont7
  431.         fmove.s REFDEF_FVRECTRIGHT_ADJ(a4),fp4
  432.         fcmp    fp4,fp7                 ;if (r_u1 > r_refdef...
  433.         fbole.b .cont8
  434.         fmove   fp4,fp7                 ;r_u1 = r_refdef.fvrectright_adj)
  435. .cont8
  436.         fmul    fp5,fp6
  437.         fmul.s  _yscale,fp6
  438.         fsub.s  _ycenter,fp6
  439.         fneg    fp6                     ;scale = yscale * r_lzi1
  440.         fmove.s REFDEF_FVRECTY_ADJ(a4),fp4
  441.         fcmp    fp4,fp6                 ;if (r_v1 < r_refdef...
  442.         fboge.b .cont9
  443.         fmove   fp4,fp6                 ;r_v1 = r_refdef.fvrecty_adj
  444. .cont9
  445.         fmove.s REFDEF_FVRECTBOTTOM_ADJ(a4),fp4
  446.         fcmp    fp4,fp6                 ;if (r_v1 > r_refdef...
  447.         fbole.b .cont10
  448.         fmove   fp4,fp6                 ;r_v1 = r_refdef.fvrectbottom_adj)
  449. .cont10
  450.  
  451. *        if (r_lzi1 > lzi0)
  452. *                lzi0 = r_lzi1;
  453. *
  454. *        if (lzi0 > r_nearzi)    // for mipmap finding
  455. *                r_nearzi = lzi0;
  456. *
  457. *// for right edges, all we want is the effect on 1/z
  458. *        if (r_nearzionly)
  459. *                return;
  460. *
  461. *        r_emitted = 1;
  462. *
  463. *        r_ceilv1 = (int) ceil(r_v1);
  464.  
  465.         fcmp    fp5,fp2                 ;if (r_lzi1 > lzi0)
  466.         fboge.b .cont11
  467.         fmove   fp5,fp2                 ;lzi0 = r_lzi1
  468. .cont11
  469.         fcmp.s  _r_nearzi,fp2           ;if (lzi0 > r_nearzi)
  470.         fbole.b .cont12
  471.         fmove.s fp2,_r_nearzi           ;r_nearzi = lzi0
  472. .cont12
  473.         fmove.l fp6,d1                  ;r_ceilv1 = (int) ceil(r_v1)
  474.         fmove.l d5,fpcr
  475.         tst.l   _r_nearzionly           ;if (r_nearzionly)
  476.         bne.b   .exit2                  ;return
  477.         move.l  #1,_r_emitted           ;r_emitted = 1
  478.  
  479. *        if (ceilv0 == r_ceilv1)
  480. *        {
  481. *        // we cache unclipped horizontal edges as fully clipped
  482. *                if (cacheoffset != 0x7FFFFFFF)
  483. *                {
  484. *                        cacheoffset = FULLY_CLIPPED_CACHED |
  485. *                                        (r_framecount & FRAMECOUNT_MASK);
  486. *                }
  487. *
  488. *                return;         // horizontal edge
  489. *        }
  490.  
  491.         cmp.l   d0,d1                   ;if (ceilv0 == r_ceilv1)
  492.         bne.b   .cont13
  493.         cmp.l   #$7fffffff,_cacheoffset ;if (cacheoffset != 0x7fffffff)
  494.         beq.b   .exit1
  495.         move.l  _r_framecount,d2
  496.         and.l   #FRAMECOUNT_MASK,d2
  497.         or.l    #FULLY_CLIPPED_CACHED,d2
  498.         move.l  d2,_cacheoffset         ;cacheoffset = FULLY...
  499.         bra.b   .exit1
  500.  
  501. *        side = ceilv0 > r_ceilv1;
  502. *
  503. *        edge = edge_p++;
  504. *
  505. *        edge->owner = r_pedge;
  506. *
  507. *        edge->nearzi = lzi0;
  508.  
  509. .cont13
  510.         move.l  _edge_p,a2
  511.         add.l   #EDGE_SIZEOF,_edge_p    ;edge = edge_p++
  512.         move.l  _r_pedge,EDGE_OWNER(a2) ;edge->owner = r_pedge
  513.         fmove.s fp2,EDGE_NEARZI(a2)     ;edge->nearzi = lzi0
  514.  
  515. *        if (side == 0)
  516. *        {
  517. *        // trailing edge (go from p1 to p2)
  518. *                v = ceilv0;
  519. *                v2 = r_ceilv1 - 1;
  520. *
  521. *                edge->surfs[0] = surface_p - surfaces;
  522. *                edge->surfs[1] = 0;
  523. *
  524. *                u_step = ((r_u1 - u0) / (r_v1 - v0));
  525. *                u = u0 + ((float)v - v0) * u_step;
  526. *        }
  527.  
  528.         cmp.l   d1,d0                   ;if (side == 0)
  529.         bgt.b   .else2
  530.         move.l  d0,d2                   ;v = ceilv0
  531.         move.l  d1,d3
  532.         subq.l  #1,d3                   ;v2 = r_ceilv1 - 1
  533.         move.l  _surface_p,d0           ;edge->surfs[0] = surface_p - surfaces
  534.         sub.l   _surfaces,d0
  535.         asr.l   #6,d0
  536.         swap    d0
  537.         clr     d0
  538.         move.l  d0,EDGE_SURFS(a2)       ;edge->surfs[1] = 0
  539.         fmove.l d2,fp3
  540.         fmove   fp0,fp2
  541.         fsub    fp1,fp3
  542.         fsub    fp7,fp0
  543.         fsub    fp6,fp1
  544.         fdiv    fp1,fp0                 ;u_step = ((r_u1-u0)/(r_v1-v0))
  545.         fmul    fp0,fp3
  546.         fadd    fp2,fp3                 ;u = u0 + ((float)v-v0)*u_step
  547.         bra.b   .cont14
  548.  
  549. *        {
  550. *        // leading edge (go from p2 to p1)
  551. *                v2 = ceilv0 - 1;
  552. *                v = r_ceilv1;
  553. *
  554. *                edge->surfs[0] = 0;
  555. *                edge->surfs[1] = surface_p - surfaces;
  556. *
  557. *                u_step = ((u0 - r_u1) / (v0 - r_v1));
  558. *                u = r_u1 + ((float)v - r_v1) * u_step;
  559. *        }
  560.  
  561. .else2
  562.         move.l  d1,d2                   ;v = r_ceilv1
  563.         move.l  d0,d3
  564.         subq.l  #1,d3                   ;v2 = ceilv0 - 1
  565.         move.l  _surface_p,d0           ;edge->surfs[0] = 0
  566.         sub.l   _surfaces,d0
  567.         asr.l   #6,d0
  568.         and.l   #$ffff,d0
  569.         move.l  d0,EDGE_SURFS(a2)       ;edge->surfs[1] = surface_p-surfaces
  570.         fmove.l d2,fp3
  571.         fsub    fp6,fp3
  572.         fsub    fp7,fp0
  573.         fsub    fp6,fp1
  574.         fdiv    fp1,fp0                 ;u_step = ((u0-r_u1)/(v0-r_v1))
  575.         fmul    fp0,fp3
  576.         fadd    fp7,fp3                 ;u = r_u1+((float)v-r_v1)*u_step
  577.  
  578. *        edge->u_step = u_step*0x100000;
  579. *        edge->u = u*0x100000 + 0xFFFFF;
  580.  
  581. .cont14
  582.         fmove.s #16*65536,fp4
  583.         fmul    fp4,fp0
  584.         fmove.l fp0,EDGE_U_STEP(a2)     ;edge->u_step = u_step*$100000
  585.         fmul    fp4,fp3
  586.         fadd.s  #(16*65536)-1,fp3       ;edge->u = u*$100000 + $fffff
  587.         fmove.l fp3,d0
  588.  
  589. *        if (edge->u < r_refdef.vrect_x_adj_shift20)
  590. *                edge->u = r_refdef.vrect_x_adj_shift20;
  591. *        if (edge->u > r_refdef.vrectright_adj_shift20)
  592. *                edge->u = r_refdef.vrectright_adj_shift20;
  593.  
  594.         move.l  REFDEF_VRECTX_ADJ_S20(a4),d4
  595.         cmp.l   d4,d0
  596.         bge.b   .cont15
  597.         move.l  d4,d0
  598. .cont15
  599.         move.l  REFDEF_VRECTXR_ADJ_S20(a4),d4
  600.         cmp.l   d4,d0
  601.         ble.b   .cont16
  602.         move.l  d4,d0
  603.  
  604. *        u_check = edge->u;
  605. *        if (edge->surfs[0])
  606. *                u_check++;      // sort trailers after leaders
  607. *
  608. *        if (!newedges[v] || newedges[v]->u >= u_check)
  609. *        {
  610. *                edge->next = newedges[v];
  611. *                newedges[v] = edge;
  612. *        }
  613. *        else
  614. *        {
  615. *                pcheck = newedges[v];
  616. *                while (pcheck->next && pcheck->next->u < u_check)
  617. *                        pcheck = pcheck->next;
  618. *                edge->next = pcheck->next;
  619. *                pcheck->next = edge;
  620. *        }
  621.  
  622. .cont16
  623.         move.l  d0,EDGE_U(a2)
  624.         tst     EDGE_SURFS(a2)          ;if (edge->surfs[0])
  625.         beq.b   .cont17
  626.         addq.l  #1,d0                   ;u_check++
  627. .cont17
  628.         lea     _newedges,a0            ;if (!newedges[v] || ...
  629.         move.l  0(a0,d2.l*4),d4
  630.         beq.b   .cont18
  631.         move.l  d4,a1
  632.         cmp.l   EDGE_U(a1),d0
  633.         bgt.b   .cont19
  634. .cont18
  635.         move.l  d4,EDGE_NEXT(a2)        ;edge->next = newedges[v]
  636.         move.l  a2,0(a0,d2.l*4)         ;newedges[v] = edge
  637.         bra.b   .cont21
  638. .cont19
  639.         move.l  d4,a1                   ;pcheck = newedges[v]
  640. .loop
  641.         move.l  EDGE_NEXT(a1),d4        ;while (pcheck->next &&...
  642.         beq.b   .cont20
  643.         move.l  a1,d2
  644.         move.l  d4,a1                   ;pcheck = pcheck->next
  645.         cmp.l   EDGE_U(a1),d0
  646.         bgt.b   .loop
  647.         move.l  d2,a1
  648. .cont20
  649.         move.l  d4,EDGE_NEXT(a2)        ;edge->next = pcheck->next
  650.         move.l  a2,EDGE_NEXT(a1)        ;pcheck->next = edge
  651.  
  652. *        edge->nextremove = removeedges[v2];
  653. *        removeedges[v2] = edge;
  654.  
  655. .cont21
  656.         lea     _removeedges,a0
  657.         move.l  0(a0,d3.l*4),EDGE_NEXTREMOVE(a2)
  658.         move.l  a2,0(a0,d3.l*4)
  659. .exit1
  660.         move.l  d1,_r_ceilv1
  661. .exit2
  662.         fmove.s fp5,_r_lzi1
  663.         fmove.s fp7,_r_u1
  664.         fmove.s fp6,_r_v1
  665.         fmovem.x        (sp)+,fp2-fp7
  666.         movem.l (sp)+,d2-d5/a2-a4
  667.         rts
  668.  
  669.  
  670. ******************************************************************************
  671. *
  672. *       void _R_ClipEdge (mvertex_t *pv0, mvertex_t *pv1, clipplane_t *clip)
  673. *
  674. ******************************************************************************
  675.  
  676.         cnop    0,4
  677. _R_ClipEdge
  678.  
  679.         rsreset
  680. .fpuregs        rs.x    6
  681. .intregs        rs.l    2
  682.         rs.l    1
  683. .pv0            rs.l    1
  684. .pv1            rs.l    1
  685. .cp             rs.l    1
  686.  
  687.         movem.l a2/a3,-(sp)
  688.         fmovem.x        fp2-fp7,-(sp)
  689.         move.l  .pv0(sp),a0
  690.         move.l  .pv1(sp),a1
  691.         move.l  .cp(sp),a2
  692.         bsr     DoRecursion
  693.         fmovem.x        (sp)+,fp2-fp7
  694.         movem.l (sp)+,a2/a3
  695.         rts
  696.  
  697. DoRecursion
  698.         lea     -CLIP_SIZEOF(sp),sp
  699.         move.l  sp,a3
  700.         tst.l   a2
  701.         beq.w   .add
  702. .loop
  703.  
  704. *                        d0 = DotProduct (pv0->position, clip->normal) - clip->dist;
  705. *                        d1 = DotProduct (pv1->position, clip->normal) - clip->dist;
  706.  
  707.         fmove.s CLIP_NORMAL(a2),fp0
  708.         fmove.s CLIP_NORMAL+4(a2),fp1
  709.         fmove.s CLIP_NORMAL+8(a2),fp2
  710.         fmove.s (a0),fp3
  711.         fmove   fp3,fp5                 ;fp5 = pv0->position[0]
  712.         fmul    fp0,fp3
  713.         fmove.s 4(a0),fp4
  714.         fmove   fp4,fp6                 ;fp6 = pv0->position[1]
  715.         fmul    fp1,fp4
  716.         fadd    fp4,fp3
  717.         fmove.s 8(a0),fp4
  718.         fmove   fp4,fp7                 ;fp7 = pv0->position[2]
  719.         fmul    fp2,fp4
  720.         fadd    fp4,fp3
  721.         fmove.s (a1),fp4                ;fp4 = pv1->position[0]
  722.         fmul    fp4,fp0
  723.         fmul.s  4(a1),fp1
  724.         fadd    fp1,fp0
  725.         fmove.s 8(a1),fp1               ;fp1 = pv1->position[2]
  726.         fmul    fp1,fp2
  727.         fadd    fp2,fp0
  728.         fmove.s CLIP_DIST(a2),fp2
  729.         fsub    fp2,fp3                 ;fp3 = d0
  730.         fsub    fp2,fp0                 ;fp0 = d1
  731.         fmove.s 4(a1),fp2               ;fp2 = pv1->position[1]
  732.  
  733. *                        if (d0 >= 0)
  734. *                        {
  735. *                        // point 0 is unclipped
  736. *                                if (d1 >= 0)
  737. *                                {
  738. *                                // both points are unclipped
  739. *                                        continue;
  740. *                                }
  741.  
  742.         ftst    fp3
  743.         fbolt   .less
  744.         ftst    fp0
  745.         fboge   .loopend
  746.  
  747. *                                cacheoffset = 0x7FFFFFFF;
  748. *
  749. *                                f = d0 / (d0 - d1);
  750. *                                clipvert.position[0] = pv0->position[0] +
  751. *                                                f * (pv1->position[0] - pv0->position[0]);
  752. *                                clipvert.position[1] = pv0->position[1] +
  753. *                                                f * (pv1->position[1] - pv0->position[1]);
  754. *                                clipvert.position[2] = pv0->position[2] +
  755. *                                                f * (pv1->position[2] - pv0->position[2]);
  756.  
  757.         move.l  #$7fffffff,_cacheoffset
  758.         fsub    fp3,fp0
  759.         fdiv    fp0,fp3
  760.         fneg    fp3                     ;fp3 = f
  761.         fsub    fp5,fp4
  762.         fmul    fp3,fp4
  763.         fadd    fp5,fp4
  764.         fmove.s fp4,(a3)                ;clipvert.position[0]
  765.         fsub    fp6,fp2
  766.         fmul    fp3,fp2
  767.         fadd    fp6,fp2
  768.         fmove.s fp2,4(a3)               ;clipvert.position[1]
  769.         fsub    fp7,fp1
  770.         fmul    fp3,fp1
  771.         fadd    fp7,fp1
  772.         fmove.s fp1,8(a3)               ;clipvert.position[2]
  773.  
  774. *                                if (clip->leftedge)
  775. *                                {
  776. *                                        r_leftclipped = true;
  777. *                                        r_leftexit = clipvert;
  778. *                                }
  779.  
  780.         tst.b   CLIP_LEFTEDGE(a2)
  781.         beq.b   .else
  782.         move.l  #1,_r_leftclipped
  783.         lea     _r_leftexit,a1
  784.         move.l  (a3)+,(a1)+
  785.         move.l  (a3)+,(a1)+
  786.         move.l  (a3)+,(a1)+
  787.         bra.b   .cont
  788.  
  789. *                                else if (clip->rightedge)
  790. *                                {
  791. *                                        r_rightclipped = true;
  792. *                                        r_rightexit = clipvert;
  793. *                                }
  794.  
  795. .else
  796.         move.l  #1,_r_rightclipped
  797.         lea     _r_rightexit,a1
  798.         move.l  (a3)+,(a1)+
  799.         move.l  (a3)+,(a1)+
  800.         move.l  (a3)+,(a1)+
  801.  
  802. *                                R_ClipEdge (pv0, &clipvert, clip->next);
  803. *                                return;
  804.  
  805. .cont
  806.         sub     #12,a3
  807.         move.l  a3,a1
  808.         move.l  CLIP_NEXT(a2),a2
  809.         bsr     DoRecursion
  810.         bra.w   .exit
  811.  
  812. *                                if (d1 < 0)
  813. *                                {
  814. *                                // both points are clipped
  815. *                                // we do cache fully clipped edges
  816. *                                        if (!r_leftclipped)
  817. *                                                cacheoffset = FULLY_CLIPPED_CACHED |
  818. *                                                                (r_framecount & FRAMECOUNT_MASK);
  819. *                                        return;
  820. *                                }
  821.  
  822. .less
  823.         ftst    fp0
  824.         fboge.b .cont2
  825.         tst.l   _r_leftclipped
  826.         bne.w   .exit
  827.         move.l  _r_framecount,d0
  828.         and.l   #FRAMECOUNT_MASK,d0
  829.         or.l    #FULLY_CLIPPED_CACHED,d0
  830.         move.l  d0,_cacheoffset
  831.         bra.w   .exit
  832.  
  833. *                                r_lastvertvalid = false;
  834. *
  835. *                        // we don't cache partially clipped edges
  836. *                                cacheoffset = 0x7FFFFFFF;
  837. *
  838. *                                f = d0 / (d0 - d1);
  839. *                                clipvert.position[0] = pv0->position[0] +
  840. *                                                f * (pv1->position[0] - pv0->position[0]);
  841. *                                clipvert.position[1] = pv0->position[1] +
  842. *                                                f * (pv1->position[1] - pv0->position[1]);
  843. *                                clipvert.position[2] = pv0->position[2] +
  844. *                                                f * (pv1->position[2] - pv0->position[2]);
  845.  
  846. .cont2
  847.         clr.l   _r_lastvertvalid
  848.         move.l  #$7fffffff,_cacheoffset
  849.         fsub    fp3,fp0
  850.         fdiv    fp0,fp3
  851.         fneg    fp3                     ;fp3 = f
  852.         fsub    fp5,fp4
  853.         fmul    fp3,fp4
  854.         fadd    fp5,fp4
  855.         fmove.s fp4,(a3)                ;clipvert.position[0]
  856.         fsub    fp6,fp2
  857.         fmul    fp3,fp2
  858.         fadd    fp6,fp2
  859.         fmove.s fp2,4(a3)               ;clipvert.position[1]
  860.         fsub    fp7,fp1
  861.         fmul    fp3,fp1
  862.         fadd    fp7,fp1
  863.         fmove.s fp1,8(a3)               ;clipvert.position[2]
  864.  
  865. *                                if (clip->leftedge)
  866. *                                {
  867. *                                        r_leftclipped = true;
  868. *                                        r_leftenter = clipvert;
  869. *                                }
  870.  
  871.         tst.b   CLIP_LEFTEDGE(a2)
  872.         beq.b   .else2
  873.         move.l  #1,_r_leftclipped
  874.         lea     _r_leftenter,a0
  875.         move.l  (a3)+,(a0)+
  876.         move.l  (a3)+,(a0)+
  877.         move.l  (a3)+,(a0)+
  878.         bra.b   .cont3
  879.  
  880. *                                else if (clip->rightedge)
  881. *                                {
  882. *                                        r_rightclipped = true;
  883. *                                        r_rightenter = clipvert;
  884. *                                }
  885.  
  886. .else2
  887.         move.l  #1,_r_rightclipped
  888.         lea     _r_rightenter,a0
  889.         move.l  (a3)+,(a0)+
  890.         move.l  (a3)+,(a0)+
  891.         move.l  (a3)+,(a0)+
  892.  
  893. *                                R_ClipEdge (&clipvert, pv1, clip->next);
  894. *                                return;
  895.  
  896. .cont3
  897.         sub     #12,a3
  898.         move.l  a3,a0
  899.         move.l  CLIP_NEXT(a2),a2
  900.         bsr     DoRecursion
  901.         bra.w   .exit
  902.  
  903. *                } while ((clip = clip->next) != NULL);
  904.  
  905. .loopend
  906.         move.l  CLIP_NEXT(a2),d0
  907.         beq.b   .add
  908.         move.l  d0,a2
  909.         bra.w   .loop
  910.  
  911. *        R_EmitEdge (pv0, pv1);
  912.  
  913. .add
  914.         move.l  a1,-(sp)
  915.         move.l  a0,-(sp)
  916.         bsr     _R_EmitEdge
  917.         addq    #8,sp
  918. .exit
  919.         lea     CLIP_SIZEOF(sp),sp
  920.         rts
  921.  
  922.  
  923.  
  924.  
  925. ******************************************************************************
  926. *
  927. *       void _R_RenderFace (msurface_t *fa, int clipflags)
  928. *
  929. ******************************************************************************
  930.  
  931.         cnop    0,4
  932. _R_RenderFace
  933.  
  934.  
  935.         rsreset
  936. .fpuregs        rs.x    5
  937. .intregs        rs.l    11
  938.         rs.l    1
  939. .fa             rs.l    1
  940. .clipflags      rs.l    1
  941.  
  942.  
  943.         movem.l d2-d7/a2-a6,-(sp)
  944.         fmovem.x        fp2-fp6,-(sp)
  945.         move.l  .fa(sp),a3
  946.         move.l  .clipflags(sp),d0
  947.  
  948. *// skip out if no more surfs
  949. *        if ((surface_p) >= surf_max)
  950. *        {
  951. *                r_outofsurfaces++;
  952. *                return;
  953. *        }
  954.  
  955.         move.l  _surface_p,a2
  956.         cmp.l   _surf_max,a2            ;if ((surface_p) >= surf_max)
  957.         blo.b   .cont
  958.         addq.l  #1,_r_outofsurfaces     ;r_outofsurfaces++
  959.         bra.w   .end                    ;return
  960.  
  961. *        if ((edge_p + fa->numedges + 4) >= edge_max)
  962. *        {
  963. *                r_outofedges += fa->numedges;
  964. *                return;
  965. *        }
  966. *
  967. *        c_faceclip++;
  968.  
  969. .cont
  970.         move.l  MSURFACE_NUMEDGES(a3),d1
  971.         move.l  d1,d2
  972.         asl.l   #EDGE_SIZEOF_EXP,d1
  973.         add.l   #4*EDGE_SIZEOF,d1
  974.         move.l  _edge_p,d6
  975.         add.l   d6,d1                   ;edge_p + fa->numedges + 4
  976.         cmp.l   _edge_max,d1            ;if d1 >= edge_max
  977.         blo.b   .cont2
  978.         add.l   d2,_r_outofedges        ;r_outofedges += fa->numedges
  979.         bra.w   .end                    ;return
  980. .cont2
  981.         addq.l  #1,_c_faceclip          ;c_faceclip++
  982.  
  983. *        pclip = NULL;
  984. *
  985. *        for (i=3, mask = 0x08 ; i>=0 ; i--, mask >>= 1)
  986. *        {
  987. *                if (clipflags & mask)
  988. *                {
  989. *                        view_clipplanes[i].next = pclip;
  990. *                        pclip = &view_clipplanes[i];
  991. *                }
  992. *        }
  993.  
  994.         sub.l   a0,a0                   ;pclip = NULL
  995.         lea     _view_clipplanes,a1
  996.         lsl.b   #4,d0
  997.         lsl.b   #1,d0                   ;if (clipflags & mask)
  998.         bcc.b   .nocarry1
  999.         move.l  a0,CLIP_NEXT+3*CLIP_SIZEOF(a1)
  1000.         lea     3*CLIP_SIZEOF(a1),a0
  1001. .nocarry1
  1002.         lsl.b   #1,d0
  1003.         bcc.b   .nocarry2
  1004.         move.l  a0,CLIP_NEXT+2*CLIP_SIZEOF(a1)
  1005.         lea     2*CLIP_SIZEOF(a1),a0
  1006. .nocarry2
  1007.         lsl.b   #1,d0
  1008.         bcc.b   .nocarry3
  1009.         move.l  a0,CLIP_NEXT+1*CLIP_SIZEOF(a1)
  1010.         lea     1*CLIP_SIZEOF(a1),a0
  1011. .nocarry3
  1012.         lsl.b   #1,d0
  1013.         bcc.b   .nocarry4
  1014.         move.l  a0,CLIP_NEXT(a1)        ;view_clipplanes[0].next=pclip
  1015.         move.l  a1,a0                   ;pclip = &view_clipplanes[i]
  1016. .nocarry4
  1017.         move.l  a0,a2
  1018.  
  1019. *        r_emitted = 0;
  1020. *        r_nearzi = 0;
  1021. *        r_nearzionly = false;
  1022. *        makeleftedge = makerightedge = false;
  1023. *        pedges = currententity->model->edges;
  1024. *        r_lastvertvalid = false;
  1025.  
  1026.         clr.l   _r_emitted
  1027.         clr.l   _r_nearzi
  1028.         clr.l   _r_nearzionly
  1029.         clr.l   _makeleftedge
  1030.         clr.l   _makerightedge
  1031.         move.l  _currententity,a0
  1032.         move.l  ENTITY_MODEL(a0),a6
  1033.         move.l  MODEL_EDGES(a6),d4      ;pedges = currententity->mod...
  1034.         clr.l   _r_lastvertvalid
  1035.         move.l  _r_edges,d5
  1036.         move.l  _r_pcurrentvertbase,a4
  1037.         move.l  _surface_p,d7
  1038.         sub.l   _surfaces,d7
  1039.         asr.l   #6,d7
  1040.         subq    #1,d2
  1041.         bmi.w   .noloop
  1042.         moveq   #0,d3
  1043.  
  1044. *        for (i=0 ; i<fa->numedges ; i++)
  1045. *        {
  1046. *                lindex = currententity->model->surfedges[fa->firstedge + i];
  1047.  
  1048. .loop
  1049.         move.l  MODEL_SURFEDGES(a6),a1  ;¤tentity->model->surfedges
  1050.         move.l  MSURFACE_FIRSTEDGE(a3),d0
  1051.         add.l   d3,d0                   ;fa->firstedge + i
  1052.         move.l  0(a1,d0.l*4),d0         ;lindex = currententity->model...
  1053.  
  1054. *                if (lindex > 0)
  1055.  
  1056.         ble.b   .cont3                  ;if (lindex > 0)
  1057.  
  1058. *                        r_pedge = &pedges[lindex];
  1059. *
  1060. *                // if the edge is cached, we can just reuse the edge
  1061. *                        if (!insubmodel)
  1062.  
  1063.         asl.l   #MEDGE_SIZEOF_EXP,d0
  1064.         add.l   d4,d0
  1065.         move.l  d0,a5
  1066.         move.l  a5,_r_pedge             ;r_pedge = &pedges[lindex]
  1067.         tst.l   _insubmodel             ;if (!insubmodel)
  1068.         bne.b   .nosub
  1069.  
  1070. *                                if (r_pedge->cachededgeoffset & FULLY_CLIPPED_CACHED)
  1071. *                                {
  1072. *                                        if ((r_pedge->cachededgeoffset & FRAMECOUNT_MASK) ==
  1073. *                                                r_framecount)
  1074. *                                        {
  1075. *                                                r_lastvertvalid = false;
  1076. *                                                continue;
  1077. *                                        }
  1078. *                                }
  1079.  
  1080.         move.l  MEDGE_CEO(a5),d0        ;if (r_pedge->cache... & FULLY...)
  1081.         move.l  d0,d1
  1082.         and.l   #FULLY_CLIPPED_CACHED,d0
  1083.         beq.b   .else
  1084.         and.l   #FRAMECOUNT_MASK,d1     ;if ((r_pedge->cache... & FRA...)
  1085.         cmp.l   _r_framecount,d1
  1086.         bne.b   .nosub
  1087.         clr.l   _r_lastvertvalid        ;r_lastvertvalid = false
  1088.         bra.w   .loopend
  1089.  
  1090. *                                        if ((((unsigned long)edge_p - (unsigned long)r_edges) >
  1091. *                                                 r_pedge->cachededgeoffset) &&
  1092. *                                                (((edge_t *)((unsigned long)r_edges +
  1093. *                                                 r_pedge->cachededgeoffset))->owner == r_pedge))
  1094. *                                        {
  1095. *                                                R_EmitCachedEdge ();
  1096. *                                                r_lastvertvalid = false;
  1097. *                                                continue;
  1098. *                                        }
  1099.  
  1100. .else
  1101.         move.l  d6,d0
  1102.         sub.l   d5,d0
  1103.         cmp.l   d1,d0
  1104.         bls.b   .nosub
  1105.         move.l  d1,a0
  1106.         add.l   d5,a0
  1107.         cmp.l   EDGE_OWNER(a0),a5
  1108.         bne.b   .nosub
  1109.  
  1110.  
  1111. ******  EmitCachedEdge (inlined)
  1112.  
  1113. *        pedge_t = (edge_t *)((unsigned long)r_edges + r_pedge->cachededgeoffset);
  1114. *
  1115. *        if (!pedge_t->surfs[0])
  1116. *                pedge_t->surfs[0] = surface_p - surfaces;
  1117. *        else
  1118. *                pedge_t->surfs[1] = surface_p - surfaces;
  1119. *
  1120. *        if (pedge_t->nearzi > r_nearzi) // for mipmap finding
  1121. *                r_nearzi = pedge_t->nearzi;
  1122. *
  1123. *        r_emitted = 1;
  1124.  
  1125.         tst     EDGE_SURFS(a0)
  1126.         bne.b   .contE
  1127.         move    d7,EDGE_SURFS(a0)
  1128.         bra.b   .cont2E
  1129. .contE
  1130.         move    d7,EDGE_SURFS+1*2(a0)
  1131. .cont2E
  1132.         fmove.s EDGE_NEARZI(a0),fp0
  1133.         fcmp.s  _r_nearzi,fp0
  1134.         fbole.b .cont3E
  1135.         move.l  EDGE_NEARZI(a0),_r_nearzi
  1136. .cont3E
  1137.         move.l  #1,_r_emitted
  1138.  
  1139. ******  End of EmitCachedEdge
  1140.  
  1141.  
  1142.         clr.l   _r_lastvertvalid
  1143.         bra.w   .loopend
  1144.  
  1145. *                        cacheoffset = (byte *)edge_p - (byte *)r_edges;
  1146. *                        r_leftclipped = r_rightclipped = false;
  1147. *                        R_ClipEdge (&r_pcurrentvertbase[r_pedge->v[0]],
  1148. *                                                &r_pcurrentvertbase[r_pedge->v[1]],
  1149. *                                                pclip);
  1150. *                        r_pedge->cachededgeoffset = cacheoffset;
  1151. *
  1152. *                        if (r_leftclipped)
  1153. *                                makeleftedge = true;
  1154. *                        if (r_rightclipped)
  1155. *                                makerightedge = true;
  1156. *                        r_lastvertvalid = true;
  1157.  
  1158. .nosub
  1159.         move.l  d6,d0
  1160.         sub.l   d5,d0
  1161.         move.l  d0,_cacheoffset         ;cacheoffset = (byte*)edge_p...
  1162.         clr.l   _r_leftclipped
  1163.         clr.l   _r_rightclipped
  1164.         move.l  a2,-(sp)
  1165.         move    MEDGE_V+1*2(a5),d0
  1166.         muls    #MVERTEX_SIZEOF,d0
  1167.         pea     0(a4,d0.l)
  1168.         move    MEDGE_V+0*2(a5),d0
  1169.         muls    #MVERTEX_SIZEOF,d0
  1170.         pea     0(a4,d0.l)
  1171.         jsr     _R_ClipEdge             ;R_ClipEdge (&r_pcu...
  1172.         add     #12,sp
  1173.         move.l  _edge_p,d6
  1174.         move.l  _cacheoffset,MEDGE_CEO(a5) ;r_pedge->cache... = cacheoffset
  1175.         tst.l   _r_leftclipped          ;if (r_leftclipped)
  1176.         beq.b   .noLC
  1177.         move.l  #1,_makeleftedge        ;makeleftedge = true
  1178. .noLC
  1179.         tst.l   _r_rightclipped         ;if (r_rightclipped)
  1180.         beq.b   .noRC
  1181.         move.l  #1,_makerightedge       ;makerightedge = true
  1182. .noRC
  1183.         move.l  #1,_r_lastvertvalid     ;r_lastvertvalid = true
  1184.         bra.b   .loopend
  1185. .cont3
  1186.         neg.l   d0                      ;lindex = -lindex
  1187.  
  1188. *                        r_pedge = &pedges[lindex];
  1189. *
  1190. *                // if the edge is cached, we can just reuse the edge
  1191. *                        if (!insubmodel)
  1192.  
  1193.         asl.l   #MEDGE_SIZEOF_EXP,d0
  1194.         add.l   d4,d0
  1195.         move.l  d0,a5
  1196.         move.l  a5,_r_pedge             ;r_pedge = &pedges[lindex]
  1197.         tst.l   _insubmodel             ;if (!insubmodel)
  1198.         bne.b   .nosub2
  1199.  
  1200. *                                if (r_pedge->cachededgeoffset & FULLY_CLIPPED_CACHED)
  1201. *                                {
  1202. *                                        if ((r_pedge->cachededgeoffset & FRAMECOUNT_MASK) ==
  1203. *                                                r_framecount)
  1204. *                                        {
  1205. *                                                r_lastvertvalid = false;
  1206. *                                                continue;
  1207. *                                        }
  1208. *                                }
  1209.  
  1210.         move.l  MEDGE_CEO(a5),d0        ;if (r_pedge->cache... & FULLY...)
  1211.         move.l  d0,d1
  1212.         and.l   #FULLY_CLIPPED_CACHED,d0
  1213.         beq.b   .else2
  1214.         and.l   #FRAMECOUNT_MASK,d1     ;if ((r_pedge->cache... & FRA...)
  1215.         cmp.l   _r_framecount,d1
  1216.         bne.b   .nosub2
  1217.         clr.l   _r_lastvertvalid        ;r_lastvertvalid = false
  1218.         bra.w   .loopend
  1219.  
  1220. *                                        if ((((unsigned long)edge_p - (unsigned long)r_edges) >
  1221. *                                                 r_pedge->cachededgeoffset) &&
  1222. *                                                (((edge_t *)((unsigned long)r_edges +
  1223. *                                                 r_pedge->cachededgeoffset))->owner == r_pedge))
  1224. *                                        {
  1225. *                                                R_EmitCachedEdge ();
  1226. *                                                r_lastvertvalid = false;
  1227. *                                                continue;
  1228. *                                        }
  1229.  
  1230. .else2
  1231.         move.l  d6,d0
  1232.         sub.l   d5,d0
  1233.         cmp.l   d1,d0
  1234.         bls.b   .nosub2
  1235.         move.l  d1,a0
  1236.         add.l   d5,a0
  1237.         cmp.l   EDGE_OWNER(a0),a5
  1238.         bne.b   .nosub2
  1239.  
  1240.  
  1241. ******  EmitCachedEdge (inlined)
  1242.  
  1243. *        pedge_t = (edge_t *)((unsigned long)r_edges + r_pedge->cachededgeoffset);
  1244. *
  1245. *        if (!pedge_t->surfs[0])
  1246. *                pedge_t->surfs[0] = surface_p - surfaces;
  1247. *        else
  1248. *                pedge_t->surfs[1] = surface_p - surfaces;
  1249. *
  1250. *        if (pedge_t->nearzi > r_nearzi) // for mipmap finding
  1251. *                r_nearzi = pedge_t->nearzi;
  1252. *
  1253. *        r_emitted = 1;
  1254.  
  1255.         tst     EDGE_SURFS(a0)
  1256.         bne.b   .contE2
  1257.         move    d7,EDGE_SURFS(a0)
  1258.         bra.b   .cont2E2
  1259. .contE2
  1260.         move    d7,EDGE_SURFS+1*2(a0)
  1261. .cont2E2
  1262.         fmove.s EDGE_NEARZI(a0),fp0
  1263.         fcmp.s  _r_nearzi,fp0
  1264.         fbole.b .cont3E2
  1265.         move.l  EDGE_NEARZI(a0),_r_nearzi
  1266. .cont3E2
  1267.         move.l  #1,_r_emitted
  1268.  
  1269. ******  End of EmitCachedEdge
  1270.  
  1271.         clr.l   _r_lastvertvalid
  1272.         bra.w   .loopend
  1273.  
  1274. *                        cacheoffset = (byte *)edge_p - (byte *)r_edges;
  1275. *                        r_leftclipped = r_rightclipped = false;
  1276. *                        R_ClipEdge (&r_pcurrentvertbase[r_pedge->v[0]],
  1277. *                                                &r_pcurrentvertbase[r_pedge->v[1]],
  1278. *                                                pclip);
  1279. *                        r_pedge->cachededgeoffset = cacheoffset;
  1280. *
  1281. *                        if (r_leftclipped)
  1282. *                                makeleftedge = true;
  1283. *                        if (r_rightclipped)
  1284. *                                makerightedge = true;
  1285. *                        r_lastvertvalid = true;
  1286.  
  1287. .nosub2
  1288.         move.l  d6,d0
  1289.         sub.l   d5,d0
  1290.         move.l  d0,_cacheoffset         ;cacheoffset = (byte*)edge_p...
  1291.         clr.l   _r_leftclipped
  1292.         clr.l   _r_rightclipped
  1293.         move.l  a2,-(sp)
  1294.         move    MEDGE_V+0*2(a5),d0
  1295.         muls    #MVERTEX_SIZEOF,d0
  1296.         pea     0(a4,d0.l)
  1297.         move    MEDGE_V+1*2(a5),d0
  1298.         muls    #MVERTEX_SIZEOF,d0
  1299.         pea     0(a4,d0.l)
  1300.         jsr     _R_ClipEdge             ;R_ClipEdge (&r_pcu...
  1301.         add     #12,sp
  1302.         move.l  _edge_p,d6
  1303.         move.l  _cacheoffset,MEDGE_CEO(a5) ;r_pedge->cache... = cacheoffset
  1304.         tst.l   _r_leftclipped          ;if (r_leftclipped)
  1305.         beq.b   .noLC2
  1306.         move.l  #1,_makeleftedge        ;makeleftedge = true
  1307. .noLC2
  1308.         tst.l   _r_rightclipped         ;if (r_rightclipped)
  1309.         beq.b   .noRC2
  1310.         move.l  #1,_makerightedge       ;makerightedge = true
  1311. .noRC2
  1312.         move.l  #1,_r_lastvertvalid     ;r_lastvertvalid = true
  1313. .loopend
  1314.         addq    #1,d3
  1315.         dbra    d2,.loop
  1316.  
  1317. *        if (makeleftedge)
  1318. *        {
  1319. *                r_pedge = &tedge;
  1320. *                r_lastvertvalid = false;
  1321. *                R_ClipEdge (&r_leftexit, &r_leftenter, pclip->next);
  1322. *        }
  1323.  
  1324. .noloop
  1325.         tst.l   _makeleftedge           ;if (makeleftedge)
  1326.         beq.b   .noLE
  1327.         clr.l   _r_lastvertvalid        ;r_lastvertvalid = false
  1328.         move.l  a2,a0
  1329.         move.l  CLIP_NEXT(a0),-(sp)
  1330.         move.l  #_r_leftenter,-(sp)
  1331.         move.l  #_r_leftexit,-(sp)
  1332.         jsr     _R_ClipEdge             ;R_ClipEdge (&r_leftexit,...)
  1333.         add     #12,sp
  1334.  
  1335. *        if (makerightedge)
  1336. *        {
  1337. *                r_pedge = &tedge;
  1338. *                r_lastvertvalid = false;
  1339. *                r_nearzionly = true;
  1340. *                R_ClipEdge (&r_rightexit, &r_rightenter, view_clipplanes[1].next);
  1341. *        }
  1342.  
  1343. .noLE
  1344.         tst.l   _makerightedge          ;if (makerightedge)
  1345.         beq.b   .noRE
  1346.         clr.l   _r_lastvertvalid        ;r_lastvertvalid = false
  1347.         move.l  #1,_r_nearzionly        ;r_nearzionly = true
  1348.         lea     _view_clipplanes,a0
  1349.         move.l  CLIP_NEXT+1*CLIP_SIZEOF(a0),-(sp)
  1350.         move.l  #_r_rightenter,-(sp)
  1351.         move.l  #_r_rightexit,-(sp)
  1352.         jsr     _R_ClipEdge             ;R_ClipEdge (&r_rightexit...)
  1353.         add     #12,sp
  1354.  
  1355. *        if (!r_emitted)
  1356. *                return;
  1357.  
  1358. .noRE
  1359.         tst.l   _r_emitted              ;if (!r_emitted)
  1360.         beq.w   .end                    ;return
  1361.  
  1362. *        r_polycount++;
  1363. *
  1364. *        surface_p->data = (void *)fa;
  1365. *        surface_p->nearzi = r_nearzi;
  1366. *        surface_p->flags = fa->flags;
  1367. *        surface_p->insubmodel = insubmodel;
  1368. *        surface_p->spanstate = 0;
  1369. *        surface_p->entity = currententity;
  1370. *        surface_p->key = r_currentkey++;
  1371. *        surface_p->spans = NULL;
  1372.  
  1373.         move.l  _r_currentkey,d0        ;r_currentkey++
  1374.         addq.l  #1,_r_currentkey
  1375.         addq.l  #1,_r_polycount         ;r_polycount++
  1376.         move.l  _surface_p,a0
  1377.         addq.l  #8,a0
  1378.         clr.l   (a0)+                   ;surface_p->spans = NULL
  1379.         move.l  d0,(a0)+                ;surface_p->key = r_currentkey++
  1380.         addq.l  #4,a0
  1381.         clr.l   (a0)+                   ;surface_p->spanstate = 0
  1382.         move.l  MSURFACE_FLAGS(a3),(a0)+ ;surface_p->flags = fa->flags
  1383.         move.l  a3,(a0)+                ;surface_p->data = (void *)fa
  1384.         move.l  _currententity,(a0)+    ;surface_p->entity = currententity
  1385.         move.l  _r_nearzi,(a0)+         ;surface_p->nearzi = r_nearzi
  1386.         move.l  _insubmodel,(a0)+       ;surface_p->insubmodel = insubmodel
  1387.  
  1388. *        pplane = fa->plane;
  1389.  
  1390.         move.l  MSURFACE_PLANE(a3),a1   ;pplane = fa->plane
  1391.  
  1392. *        TransformVector (pplane->normal, p_normal);
  1393.  
  1394. ******  TransformVector (inlined)
  1395.  
  1396.         fmove.s (a1)+,fp3
  1397.         fmove.s (a1)+,fp4
  1398.         fmove.s (a1)+,fp5
  1399.         lea     _vright,a2
  1400.         fmove.s (a2)+,fp0
  1401.         fmul    fp3,fp0
  1402.         fmove.s (a2)+,fp1
  1403.         fmul    fp4,fp1
  1404.         fadd    fp1,fp0
  1405.         fmove.s (a2)+,fp1
  1406.         fmul    fp5,fp1
  1407.         fadd    fp1,fp0                 ;fp0 = p_normal[0]
  1408.         lea     _vup,a2
  1409.         fmove.s (a2)+,fp1
  1410.         fmul    fp3,fp1
  1411.         fmove.s (a2)+,fp2
  1412.         fmul    fp4,fp2
  1413.         fadd    fp2,fp1
  1414.         fmove.s (a2)+,fp2
  1415.         fmul    fp5,fp2
  1416.         fadd    fp2,fp1
  1417.         fneg    fp1                     ;fp1 = -p_normal[1]
  1418.         lea     _vpn,a2
  1419.         fmove.s (a2)+,fp2
  1420.         fmul    fp3,fp2
  1421.         fmove.s (a2)+,fp6
  1422.         fmul    fp4,fp6
  1423.         fadd    fp6,fp2
  1424.         fmove.s (a2)+,fp6
  1425.         fmul    fp5,fp6
  1426.         fadd    fp6,fp2                 ;fp2 = p_normal[2]
  1427.  
  1428. ******  End of TransformVector
  1429.  
  1430. *        distinv = 1.0 / (pplane->dist - DotProduct (modelorg, pplane->normal));
  1431. *
  1432. *        surface_p->d_zistepu = p_normal[0] * xscaleinv * distinv;
  1433. *        surface_p->d_zistepv = -p_normal[1] * yscaleinv * distinv;
  1434. *        surface_p->d_ziorigin = p_normal[2] * distinv -
  1435. *                        xcenter * surface_p->d_zistepu -
  1436. *                        ycenter * surface_p->d_zistepv;
  1437.  
  1438.         lea     _modelorg,a2            ;DotProduct (modelorg, pp...)
  1439.         fmul.s  (a2)+,fp3
  1440.         fmul.s  (a2)+,fp4
  1441.         fadd    fp4,fp3
  1442.         fmul.s  (a2)+,fp5
  1443.         fadd    fp5,fp3
  1444.         fsub.s  (a1)+,fp3
  1445.         fneg    fp3                     ;pplane->dist - DotProduct(...)
  1446.         fmove.s #1,fp5
  1447.         fdiv    fp3,fp5                 ;distinv = 1.0 / fp3
  1448.         fmove.s _xscaleinv,fp3
  1449.         fmul    fp5,fp3                 ;xscaleinv * distinv
  1450.         fmul    fp3,fp0                 ;p_normal[0] * fp3
  1451.         addq.l  #4,a0
  1452.         fmove.s fp0,(a0)+               ;surface_p->d_zistepu = fp0
  1453.         fmove.s _yscaleinv,fp4
  1454.         fmul    fp5,fp4                 ;yscaleinv * distinv
  1455.         fmul    fp4,fp1                 ;-p_normal[1] * fp4
  1456.         fmove.s fp1,(a0)+               ;surface_p->d_zistepv * fp1
  1457.         fmul.s  _xcenter,fp0            ;xcenter * fp0
  1458.         fmul.s  _ycenter,fp1            ;ycenter * fp1
  1459.         fmul    fp5,fp2                 ;p_normal[2] * distinv
  1460.         fsub    fp0,fp2                 ;- xcenter * fp0
  1461.         fsub    fp1,fp2                 ;- ycenter * fp1
  1462.         fmove.s fp2,-12(a0)             ;surface_p->d_ziorigin = fp2
  1463.  
  1464. *        surface_p++;
  1465.  
  1466.         add.l   #SURF_SIZEOF,_surface_p ;surface_p++
  1467. .end
  1468.         fmovem.x        (sp)+,fp2-fp6
  1469.         movem.l (sp)+,d2-d7/a2-a6
  1470.         rts
  1471.