home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 113 / EnigmaAmiga113CD.iso / software / sviluppo / quake_src / r_edge68k.s < prev    next >
Text File  |  2000-06-17  |  22KB  |  673 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_edge.c assembler implementations by Frank Wille <frank@phoenix.owl.de>
  23. **
  24.  
  25.         XREF    _r_bmodelactive
  26.         XREF    _surfaces
  27.         XREF    _span_p
  28.         XREF    _current_iv
  29.         XREF    _fv
  30.         XREF    _edge_head
  31.         XREF    _edge_tail
  32.         XREF    _edge_aftertail
  33.         XREF    _edge_head_u_shift20
  34.         XREF    _R_CleanupSpan
  35.  
  36.         XDEF    _R_RemoveEdges
  37.         XDEF    _R_InsertNewEdges
  38.         XDEF    _R_StepActiveU
  39.         XDEF    _R_GenerateSpans
  40.  
  41. SURF_NEXT               =       0
  42. SURF_PREV               =       4
  43. SURF_SPANS              =       8
  44. SURF_KEY                =       12
  45. SURF_LAST_U             =       16
  46. SURF_SPANSTATE          =       20
  47. SURF_INSUBMODEL         =       40
  48. SURF_D_ZIORIGIN         =       44
  49. SURF_D_ZISTEPU          =       48
  50. SURF_D_ZISTEPV          =       52
  51. SURF_SIZEOF_EXP         =       6
  52. SURF_SIZEOF             =       (1<<SURF_SIZEOF_EXP)
  53. SPAN_U                  =       0
  54. SPAN_V                  =       4
  55. SPAN_COUNT              =       8
  56. SPAN_PNEXT              =       12
  57. SPAN_SIZEOF             =       16
  58. EDGE_U                  =       0
  59. EDGE_U_STEP             =       4
  60. EDGE_PREV               =       8
  61. EDGE_NEXT               =       12
  62. EDGE_SURFS              =       16
  63. EDGE_NEXTREMOVE         =       20
  64.  
  65.         fpu
  66.  
  67. ******************************************************************************
  68. *
  69. *       void _R_InsertNewEdges (edge_t *edgestoadd, edge_t *edgelist)
  70. *
  71. ******************************************************************************
  72.  
  73.         cnop    0,4
  74. _R_InsertNewEdges
  75.  
  76. *****   stackframe
  77.  
  78.         rsreset
  79. .intregs        rs.l    1
  80.         rs.l    1
  81. .edgestoadd     rs.l    1
  82. .edgelist       rs.l    1
  83.  
  84.  
  85. *        do
  86. *        {
  87. *                next_edge = edgestoadd->next;
  88. *edgesearch:
  89. *                if (edgelist->u >= edgestoadd->u)
  90. *                        goto addedge;
  91. *                edgelist=edgelist->next;
  92. *                if (edgelist->u >= edgestoadd->u)
  93. *                        goto addedge;
  94. *                edgelist=edgelist->next;
  95. *                if (edgelist->u >= edgestoadd->u)
  96. *                        goto addedge;
  97. *                edgelist=edgelist->next;
  98. *                if (edgelist->u >= edgestoadd->u)
  99. *                        goto addedge;
  100. *                edgelist=edgelist->next;
  101. *                goto edgesearch;
  102. *
  103. *        // insert edgestoadd before edgelist
  104. *addedge:
  105. *                edgestoadd->next = edgelist;
  106. *                edgestoadd->prev = edgelist->prev;
  107. *                edgelist->prev->next = edgestoadd;
  108. *                edgelist->prev = edgestoadd;
  109. *        } while ((edgestoadd = next_edge) != NULL);
  110.  
  111.         move.l  a2,-(sp)
  112.         move.l  .edgestoadd(sp),a0
  113.         move.l  .edgelist(sp),a1
  114.         move.l  EDGE_U(a0),d1
  115. .loop
  116.         cmp.l   EDGE_U(a1),d1           ;if (edgelist->u >= edgestoadd->u)
  117.         ble.b   .addedge                ;goto addedge
  118.         move.l  EDGE_NEXT(a1),a1        ;edgelist=edgelist->next
  119.         cmp.l   EDGE_U(a1),d1
  120.         ble.b   .addedge
  121.         move.l  EDGE_NEXT(a1),a1
  122.         cmp.l   EDGE_U(a1),d1
  123.         ble.b   .addedge
  124.         move.l  EDGE_NEXT(a1),a1
  125.         cmp.l   EDGE_U(a1),d1
  126.         ble.b   .addedge
  127.         move.l  EDGE_NEXT(a1),a1
  128.         bra.b   .loop
  129. .addedge
  130.         move.l  EDGE_NEXT(a0),d0        ;next_edge = edgestoadd->next
  131.         move.l  a1,EDGE_NEXT(a0)        ;edgestoadd->next = edgelist
  132.         move.l  EDGE_PREV(a1),a2
  133.         move.l  a2,EDGE_PREV(a0)        ;edgestoadd->prev = edgelist->prev
  134.         move.l  a0,EDGE_NEXT(a2)        ;edgelist->prev->next = edgestoadd
  135.         move.l  a0,EDGE_PREV(a1)        ;edgelist->prev = edgestoadd
  136.         tst.l   d0                      ;while ((edgestoadd = next_edge) != NULL)
  137.         beq.b   .end
  138.         move.l  d0,a0
  139.         move.l  EDGE_U(a0),d1
  140.         bra.b   .loop
  141. .end
  142.         move.l  (sp)+,a2
  143.         rts
  144.  
  145.  
  146.  
  147.  
  148.  
  149.  
  150. ******************************************************************************
  151. *
  152. *       void _R_RemoveEdges (edge_t *pedge)
  153. *
  154. ******************************************************************************
  155.  
  156.         cnop    0,4
  157. _R_RemoveEdges
  158.  
  159. *****   stackframe
  160.  
  161.         rsreset
  162. .intregs        rs.l    1
  163.         rs.l    1
  164. .pedge          rs.l    1
  165.  
  166.  
  167. *        do
  168. *        {
  169. *                pedge->next->prev = pedge->prev;
  170. *                pedge->prev->next = pedge->next;
  171. *        } while ((pedge = pedge->nextremove) != NULL);
  172.  
  173.         move.l  a2,-(sp)
  174.         move.l  .pedge(sp),a0
  175. .loop
  176.         move.l  EDGE_NEXT(a0),a1
  177.         move.l  EDGE_PREV(a0),a2
  178.         move.l  a2,EDGE_PREV(a1)        ;pedge->next->prev = pedge->prev
  179.         move.l  a1,EDGE_NEXT(a2)        ;pedge->prev->next = pedge->next
  180.         move.l  EDGE_NEXTREMOVE(a0),a0  ;while ((pedge = pedge->nextremove) != NULL)
  181.         tst.l   a0
  182.         bne.b   .loop
  183.         move.l  (sp)+,a2
  184.         rts
  185.  
  186.  
  187.  
  188.  
  189.  
  190.  
  191.  
  192.  
  193. ******************************************************************************
  194. *
  195. *       void _R_StepActiveU (edge_t *pedge)
  196. *
  197. ******************************************************************************
  198.  
  199.         cnop    0,4
  200. _R_StepActiveU
  201.  
  202. *****   stackframe
  203.  
  204.         rsreset
  205. .intregs        rs.l    5
  206.         rs.l    1
  207. .pedge          rs.l    1
  208.  
  209.  
  210. *nextedge:
  211. *                pedge->u += pedge->u_step;
  212. *                if (pedge->u < pedge->prev->u)
  213. *                        goto pushback;
  214. *                pedge = pedge->next;
  215. *
  216. *                pedge->u += pedge->u_step;
  217. *                if (pedge->u < pedge->prev->u)
  218. *                        goto pushback;
  219. *                pedge = pedge->next;
  220. *
  221. *                pedge->u += pedge->u_step;
  222. *                if (pedge->u < pedge->prev->u)
  223. *                        goto pushback;
  224. *                pedge = pedge->next;
  225. *
  226. *                pedge->u += pedge->u_step;
  227. *                if (pedge->u < pedge->prev->u)
  228. *                        goto pushback;
  229. *                pedge = pedge->next;
  230. *
  231. *                goto nextedge;
  232.  
  233.         movem.l a2-a6,-(sp)
  234.         move.l  .pedge(sp),a0
  235.         move.l  EDGE_PREV(a0),a1
  236.         move.l  EDGE_U(a1),d1
  237.         lea     _edge_aftertail,a2
  238.         lea     _edge_tail,a3
  239. .loop
  240.         move.l  EDGE_U(a0),d0
  241.         add.l   EDGE_U_STEP(a0),d0
  242.         move.l  d0,EDGE_U(a0)           ;pedge->u += pedge->u_step
  243.         cmp.l   d1,d0                   ;if (pedge->u < pedge->prev->u)
  244.         blt.b   .pushback               ;goto pushback
  245.         move.l  d0,d1
  246.         move.l  EDGE_NEXT(a0),a0        ;pedge = pedge->next
  247.         move.l  EDGE_U(a0),d0
  248.         add.l   EDGE_U_STEP(a0),d0
  249.         move.l  d0,EDGE_U(a0)
  250.         cmp.l   d1,d0
  251.         blt.b   .pushback
  252.         move.l  d0,d1
  253.         move.l  EDGE_NEXT(a0),a0
  254.         move.l  EDGE_U(a0),d0
  255.         add.l   EDGE_U_STEP(a0),d0
  256.         move.l  d0,EDGE_U(a0)
  257.         cmp.l   d1,d0
  258.         blt.b   .pushback
  259.         move.l  d0,d1
  260.         move.l  EDGE_NEXT(a0),a0
  261.         move.l  EDGE_U(a0),d0
  262.         add.l   EDGE_U_STEP(a0),d0
  263.         move.l  d0,EDGE_U(a0)
  264.         cmp.l   d1,d0
  265.         blt.b   .pushback
  266.         move.l  d0,d1
  267.         move.l  EDGE_NEXT(a0),a0
  268.         bra.b   .loop
  269.  
  270. *                if (pedge == &edge_aftertail)
  271. *                        return;
  272. *
  273. *        // push it back to keep it sorted
  274. *                pnext_edge = pedge->next;
  275. *
  276. *        // pull the edge out of the edge list
  277. *                pedge->next->prev = pedge->prev;
  278. *                pedge->prev->next = pedge->next;
  279. *
  280. *        // find out where the edge goes in the edge list
  281. *                pwedge = pedge->prev->prev;
  282. *
  283. *                while (pwedge->u > pedge->u)
  284. *                {
  285. *                        pwedge = pwedge->prev;
  286. *                }
  287. *
  288. *        // put the edge back into the edge list
  289. *                pedge->next = pwedge->next;
  290. *                pedge->prev = pwedge;
  291. *                pedge->next->prev = pedge;
  292. *                pwedge->next = pedge;
  293. *
  294. *                pedge = pnext_edge;
  295. *                if (pedge == &edge_tail)
  296. *                        return;
  297.  
  298. .pushback
  299.         cmp.l   a0,a2                   ;if (pedge == &edge_aftertail)
  300.         beq.w   .end                    ;return
  301.         move.l  EDGE_NEXT(a0),a4        ;pnext_edge = pedge->next
  302.         move.l  EDGE_PREV(a0),a5
  303.         move.l  a5,EDGE_PREV(a4)        ;pedge->next->prev = pedge->prev
  304.         move.l  a4,EDGE_NEXT(a5)        ;pedge->prev->next = pedge->next
  305.         move.l  EDGE_PREV(a5),a5        ;pwedge = pedge->prev->prev
  306. .loop2
  307.         cmp.l   EDGE_U(a5),d0           ;while (pwedge->u > pedge->u)
  308.         bgt.b   .cont
  309.         move.l  EDGE_PREV(a5),a5        ;pwedge = pwedge->prev
  310.         bra.b   .loop2
  311. .cont
  312.         move.l  EDGE_NEXT(a5),a1
  313.         move.l  a1,EDGE_NEXT(a0)        ;pedge->next = pwedge->next
  314.         move.l  a5,EDGE_PREV(a0)        ;pedge->prev = pwedge
  315.         move.l  a0,EDGE_PREV(a1)        ;pedge->next->prev = pedge
  316.         move.l  a0,EDGE_NEXT(a5)        ;pwedge->next = pedge
  317.         move.l  a4,a0                   ;pedge = pnext_edge
  318.         cmp.l   a3,a0                   ;if (pedge == &edge_tail)
  319.         bne.b   .loop
  320. .end
  321.         movem.l (sp)+,a2-a6
  322.         rts
  323.  
  324.  
  325.  
  326.  
  327.  
  328.  
  329.  
  330.  
  331. ******************************************************************************
  332. *
  333. *       void _R_GenerateSpans (void)
  334. *
  335. *       R_TrailingEdge and R_LeadingEdge are inlined
  336. *
  337. *       notes:
  338. *       Increment and Decrement of _r_bmodelactive removed, because it's
  339. *       obsolete here
  340. *
  341. ******************************************************************************
  342.  
  343.         cnop    0,4
  344. _R_GenerateSpans
  345.  
  346. ******  prologue
  347.  
  348.         movem.l d2-d7/a2-a6,-(sp)
  349.         fmovem.x        fp2-fp7,-(sp)
  350.         clr.l   _r_bmodelactive
  351.         move.l  _current_iv,d2
  352.         move.l  _surfaces,a3
  353.         lea     1*SURF_SIZEOF(a3),a4
  354.         move.l  a4,SURF_NEXT(a4)
  355.         move.l  a4,SURF_PREV(a4)
  356.         move.l  _edge_head_u_shift20,SURF_LAST_U(a4)
  357.         move.l  _edge_head+EDGE_NEXT,a5
  358.         lea     _edge_tail,a6
  359.         move.l  _span_p,a4
  360.         bra.w   .try
  361. .loop
  362.         move.l  EDGE_U(a5),d4
  363.         move.l  d4,d7
  364.         moveq   #20,d0
  365.         asr.l   d0,d4
  366.         move.l  EDGE_SURFS(a5),d1
  367.         move.l  d1,d0
  368.         swap    d0
  369.         ext.l   d0
  370.         beq.b   .cont
  371.         asl.l   #SURF_SIZEOF_EXP,d0
  372.         lea     0(a3,d0.l),a0
  373.  
  374. ******  R_TrailingEdge (inlined)
  375.  
  376. *        if (--surf->spanstate == 0)
  377. *        {
  378. *                if (surf->insubmodel)
  379. *                        r_bmodelactive--;
  380. *
  381. *                if (surf == surfaces[1].next)
  382. *                {
  383. *                // emit a span (current top going away)
  384. *                        iu = edge->u >> 20;
  385. *                        if (iu > surf->last_u)
  386. *                        {
  387. *                                span = span_p++;
  388. *                                span->u = surf->last_u;
  389. *                                span->count = iu - span->u;
  390. *                                span->v = current_iv;
  391. *                                span->pnext = surf->spans;
  392. *                                surf->spans = span;
  393. *                        }
  394. *
  395. *                // set last_u on the surface below
  396. *                        surf->next->last_u = iu;
  397. *                }
  398. *
  399. *                surf->prev->next = surf->next;
  400. *                surf->next->prev = surf->prev;
  401. *        }
  402.  
  403.         subq.l  #1,SURF_SPANSTATE(a0)   ;if (--surf->spanstate) == 0
  404.         bne.b   .cont
  405.         move.l  SURF_NEXT(a0),a1
  406.         cmp.l   1*SURF_SIZEOF+SURF_NEXT(a3),a0 ;if (surf==surfaces[1].next)
  407.         bne.b   .te_cont2
  408.         move.l  d4,d0                   ;iu = edge->u >> 20
  409.         move.l  SURF_LAST_U(a0),d5
  410.         move.l  d0,SURF_LAST_U(a1)      ;surf->next->last_u = iu
  411.         sub.l   d5,d0                   ;if (iu > surf->last_u)
  412.         ble.b   .te_cont2
  413.         move.l  SURF_SPANS(a0),d3
  414.         move.l  a4,SURF_SPANS(a0)       ;surf->spans = span
  415.         move.l  d5,(a4)+                ;span->u = surf->last_u
  416.         move.l  d2,(a4)+                ;span->v = current_iv
  417.         move.l  d0,(a4)+                ;span->count = iu - span->u
  418.         move.l  d3,(a4)+                ;span->pnext = surf->spans
  419. .te_cont2
  420.         move.l  SURF_PREV(a0),a2
  421.         move.l  a1,SURF_NEXT(a2)        ;surf->prev->next = surf->next
  422.         move.l  a2,SURF_PREV(a1)        ;surf->next->prev = surf->prev
  423.  
  424. ******  end of R_TrailingEdge
  425.  
  426. .cont
  427.  
  428. ******  R_LeadingEdge (inlined)
  429.  
  430. *        if (edge->surfs[1])
  431. *        {
  432. *        // it's adding a new surface in, so find the correct place
  433. *                surf = &surfaces[edge->surfs[1]];
  434. *
  435.         ext.l   d1
  436.         beq.w   .next
  437.         asl.l   #SURF_SIZEOF_EXP,d1
  438.         lea     0(a3,d1.l),a1           ;surf = &surfaces[edge->surfs[1]]
  439. *
  440. *        // don't start a span if this is an inverted span, with the end
  441. *        // edge preceding the start edge (that is, we've already seen the
  442. *        // end edge)
  443. *                if (++surf->spanstate == 1)
  444. *                {
  445. *                        if (surf->insubmodel)
  446. *                                r_bmodelactive++;
  447. *
  448. *                        surf2 = surfaces[1].next;
  449. *
  450. *                        if (surf->key < surf2->key)
  451. *                                goto newtop;
  452. *                // if it's two surfaces on the same plane, the one that's already
  453. *                // active is in front, so keep going unless it's a bmodel
  454. *                        if (surf->insubmodel && (surf->key == surf2->key))
  455. *                        {
  456.  
  457.  
  458.         move.l  SURF_SPANSTATE(a1),d0   ;if (++surf->spanstate == 1)
  459.         beq.b   .le_zero
  460.         addq.l  #1,SURF_SPANSTATE(a1)
  461.         bra.w   .next
  462. .le_zero
  463.         addq.l  #1,d0
  464.         move.l  d0,SURF_SPANSTATE(a1)
  465.         move.l  SURF_INSUBMODEL(a1),d5  ;if (surf->insubmodel)
  466.         move.l  1*SURF_SIZEOF+SURF_NEXT(a3),a0  ;surf2 = surfaces[1].next
  467.         move.l  SURF_KEY(a1),d6
  468.         moveq   #0,d3
  469.         cmp.l   SURF_KEY(a0),d6         ;if (surf->key < surf2->key)
  470.         blt.b   .le_newtop              ;goto newtop
  471.         bgt.b   .le_search
  472.         tst.b   d5
  473.         beq.b   .le_search
  474.  
  475.         moveq   #-1,d3
  476.         move.l  d7,d0
  477.         sub.l   #$fffff,d0              ;edge->u - 0xFFFFF
  478.         fmove.l d0,fp0                  :(float)(edge->u - 0xFFFFF)
  479.         fmul.s  #(1.0/(16*65536)),fp0   ;fu = fp0 * (1 / $100000)
  480.         fmove.s _fv,fp1                 ;fv
  481.         fmove.s SURF_D_ZIORIGIN(a1),fp2
  482.         fmove.s SURF_D_ZISTEPV(a1),fp3
  483.         fmul    fp1,fp3                 ;fp1 = fv * surf->d_zistepv
  484.         fadd    fp3,fp2
  485.         fmove.s SURF_D_ZISTEPU(a1),fp3
  486.         fmove   fp3,fp4                 ;fp4 = surf->d_zistepu
  487.         fmul    fp0,fp3                 ;fp3 = fu * surf->d_zistepu
  488.         fadd    fp3,fp2                 ;newzi = d_ziorigin + fp1 + fp3
  489.         fmove   fp2,fp3
  490.         fmul.s  #0.99,fp2               ;newzibottom = newzi * 0.99
  491.         fmul.s  #1.01,fp3               ;newzitop = newzi * 1.01
  492.  
  493.  
  494. *                        // must be two bmodels in the same leaf; sort on 1/z
  495. *                                fu = (float)(edge->u - 0xFFFFF) * (1.0 / 0x100000);
  496. *                                newzi = surf->d_ziorigin + fv*surf->d_zistepv +
  497. *                                                fu*surf->d_zistepu;
  498. *                                newzibottom = newzi * 0.99;
  499. *
  500. *                                testzi = surf2->d_ziorigin + fv*surf2->d_zistepv +
  501. *                                                fu*surf2->d_zistepu;
  502. *
  503. *                                if (newzibottom >= testzi)
  504. *                                {
  505. *                                        goto newtop;
  506. *                                }
  507. *
  508. *                                newzitop = newzi * 1.01;
  509. *                                if (newzitop >= testzi)
  510. *                                {
  511. *                                        if (surf->d_zistepu >= surf2->d_zistepu)
  512. *                                        {
  513. *                                                goto newtop;
  514. *                                        }
  515. *                                }
  516.  
  517.         fmove.s SURF_D_ZIORIGIN(a0),fp5
  518.         fmove.s SURF_D_ZISTEPV(a0),fp6
  519.         fmul    fp1,fp6                 ;fp1 = fv * surf2->d_zistepv
  520.         fadd    fp6,fp5
  521.         fmove.s SURF_D_ZISTEPU(a0),fp6
  522.         fmove   fp6,fp7
  523.         fmul    fp0,fp6                 ;fp3 = fu * surf2->d_zistepu
  524.         fadd    fp6,fp5                 ;testzi = d_ziorigin + fp1 + fp3
  525.         fcmp    fp5,fp2                 ;if (newzibottom >= testzi)
  526.         fbge.b  .le_newtop              ;goto newtop
  527.         fcmp    fp5,fp3                 ;if (newzitop >= testzi)
  528.         fblt.b  .le_search
  529.         fcmp    fp7,fp4                 ;if (surf->d_zistepu >= surf2->d_zistepu)
  530.         fbge.b  .le_newtop              ;goto newtop
  531.  
  532. *                        do
  533. *                        {
  534. *                                surf2 = surf2->next;
  535. *                        } while (surf->key > surf2->key);
  536. *
  537.  
  538.  
  539. .le_search
  540.         move.l  SURF_NEXT(a0),a0        ;surf2 = surf2->next
  541.         cmp.l   SURF_KEY(a0),d6         ;while (surf->key > surf2->key)
  542.         bgt.b   .le_search
  543.  
  544. *                        if (surf->key == surf2->key)
  545. *                        {
  546. *                        // if it's two surfaces on the same plane, the one that's already
  547. *                        // active is in front, so keep going unless it's a bmodel
  548. *                                if (!surf->insubmodel)
  549. *                                        goto continue_search;
  550.  
  551.         bne.b   .le_gotposition
  552.         tst.b   d5
  553.         beq.b   .le_search
  554.         tst     d3
  555.         bne.b   .le_precalc_done
  556.         moveq   #-1,d3
  557.         move.l  d7,d0
  558.         sub.l   #$fffff,d0              ;edge->u - 0xFFFFF
  559.         fmove.l d0,fp0                  :(float)(edge->u - 0xFFFFF)
  560.         fmul.s  #(1.0/(16*65536)),fp0   ;fu = fp0 * (1 / $100000)
  561.         fmove.s _fv,fp1                 ;fv
  562.         fmove.s SURF_D_ZIORIGIN(a1),fp2
  563.         fmove.s SURF_D_ZISTEPV(a1),fp3
  564.         fmul    fp1,fp3                 ;fp1 = fv * surf->d_zistepv
  565.         fadd    fp3,fp2
  566.         fmove.s SURF_D_ZISTEPU(a1),fp3
  567.         fmove   fp3,fp4                 ;fp4 = surf->d_zistepu
  568.         fmul    fp0,fp3                 ;fp3 = fu * surf->d_zistepu
  569.         fadd    fp3,fp2                 ;newzi = d_ziorigin + fp1 + fp3
  570.         fmove   fp2,fp3
  571.         fmul.s  #0.99,fp2               ;newzibottom = newzi * 0.99
  572.         fmul.s  #1.01,fp3               ;newzitop = newzi * 1.01
  573. .le_precalc_done
  574.  
  575. *                        // must be two bmodels in the same leaf; sort on 1/z
  576. *                                fu = (float)(edge->u - 0xFFFFF) * (1.0 / 0x100000);
  577. *                                newzi = surf->d_ziorigin + fv*surf->d_zistepv +
  578. *                                                fu*surf->d_zistepu;
  579. *                                newzibottom = newzi * 0.99;
  580. *
  581. *                                testzi = surf2->d_ziorigin + fv*surf2->d_zistepv +
  582. *                                                fu*surf2->d_zistepu;
  583. *
  584. *                                if (newzibottom >= testzi)
  585. *                                {
  586. *                                        goto gotposition;
  587. *                                }
  588. *
  589. *                                newzitop = newzi * 1.01;
  590. *                                if (newzitop >= testzi)
  591. *                                {
  592. *                                        if (surf->d_zistepu >= surf2->d_zistepu)
  593. *                                        {
  594. *                                                goto gotposition;
  595. *                                        }
  596. *                                }
  597. *
  598. *                                goto continue_search;
  599. *                        }
  600. *
  601. *                        goto gotposition;
  602.  
  603.         fmove.s SURF_D_ZIORIGIN(a0),fp5
  604.         fmove.s SURF_D_ZISTEPV(a0),fp6
  605.         fmul    fp1,fp6                 ;fp1 = fv * surf2->d_zistepv
  606.         fadd    fp6,fp5
  607.         fmove.s SURF_D_ZISTEPU(a0),fp6
  608.         fmove   fp6,fp7
  609.         fmul    fp0,fp6                 ;fp3 = fu * surf2->d_zistepu
  610.         fadd    fp6,fp5                 ;testzi = d_ziorigin + fp1 + fp3
  611.         fcmp    fp5,fp2                 ;if (newzibottom >= testzi)
  612.         fbge.b  .le_gotposition         ;goto gotposition
  613.         fcmp    fp5,fp3                 ;if (newzitop >= testzi)
  614.         fblt.b  .le_search
  615.         fcmp    fp7,fp4                 ;if (surf->d_zistepu >= surf2->d_zistepu)
  616.         fbge.b  .le_gotposition         ;goto gotposition
  617.         bra.b   .le_search
  618.  
  619. *                // emit a span (obscures current top)
  620. *                        iu = edge->u >> 20;
  621. *
  622. *                        if (iu > surf2->last_u)
  623. *                        {
  624. *                                span = span_p++;
  625. *                                span->u = surf2->last_u;
  626. *                                span->count = iu - span->u;
  627. *                                span->v = current_iv;
  628. *                                span->pnext = surf2->spans;
  629. *                                surf2->spans = span;
  630. *                        }
  631. *
  632. *                        // set last_u on the new span
  633. *                        surf->last_u = iu;
  634.  
  635. .le_newtop
  636.         move.l  SURF_LAST_U(a0),d5
  637.         move.l  d4,SURF_LAST_U(a1)      ;surf->last_u = iu
  638.         sub.l   d5,d4                   ;if (iu > surf2->last_u)
  639.         ble.b   .le_cont2
  640.         move.l  SURF_SPANS(a0),d3
  641.         move.l  a4,SURF_SPANS(a0)       ;surf2->spans = span
  642.         move.l  d5,(a4)+                ;span->u = surf2->last_u
  643.         move.l  d2,(a4)+                ;span->v = current_iv
  644.         move.l  d4,(a4)+                ;span->count = iu - span->u
  645.         move.l  d3,(a4)+                ;span->pnext = surf2->spans
  646. .le_cont2
  647.  
  648. *                // insert before surf2
  649. *                        surf->next = surf2;
  650. *                        surf->prev = surf2->prev;
  651. *                        surf2->prev->next = surf;
  652. *                        surf2->prev = surf;
  653.  
  654. .le_gotposition
  655.         move.l  SURF_PREV(a0),a2
  656.         move.l  a2,SURF_PREV(a1)        ;surf->prev = surf2->prev
  657.         move.l  a0,SURF_NEXT(a1)        ;surf->next = surf2
  658.         move.l  a1,SURF_NEXT(a2)        ;surf2->prev->next = surf
  659.         move.l  a1,SURF_PREV(a0)        ;surf2->prev = surf
  660.  
  661. ******  end of R_LeadingEdge
  662.  
  663. .next
  664.         move.l  EDGE_NEXT(a5),a5
  665. .try
  666.         cmp.l   a5,a6
  667.         bne.b   .loop
  668.         move.l  a4,_span_p
  669.         jsr     _R_CleanupSpan
  670.         fmovem.x        (sp)+,fp2-fp7
  671.         movem.l (sp)+,d2-d7/a2-a6
  672.         rts
  673.