home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Amiga 14 / MA_Cover_14.iso / source / c / q1source_amy / qw / client / surf8.s < prev    next >
Encoding:
Text File  |  1999-12-21  |  13.6 KB  |  784 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. // surf8.s
  22. // x86 assembly-language 8 bpp surface block drawing code.
  23. //
  24.  
  25. #include "asm_i386.h"
  26. #include "quakeasm.h"
  27. #include "asm_draw.h"
  28.  
  29. #if    id386
  30.  
  31.     .data
  32.  
  33. sb_v:        .long    0
  34.  
  35.     .text
  36.  
  37.     .align 4
  38. .globl C(R_Surf8Start)
  39. C(R_Surf8Start):
  40.  
  41. //----------------------------------------------------------------------
  42. // Surface block drawer for mip level 0
  43. //----------------------------------------------------------------------
  44.  
  45.     .align 4
  46. .globl C(R_DrawSurfaceBlock8_mip0)
  47. C(R_DrawSurfaceBlock8_mip0):
  48.     pushl    %ebp                // preserve caller's stack frame
  49.     pushl    %edi
  50.     pushl    %esi                // preserve register variables
  51.     pushl    %ebx
  52.  
  53. //        for (v=0 ; v<numvblocks ; v++)
  54. //        {
  55.     movl    C(r_lightptr),%ebx
  56.     movl    C(r_numvblocks),%eax
  57.  
  58.     movl    %eax,sb_v
  59.     movl    C(prowdestbase),%edi
  60.  
  61.     movl    C(pbasesource),%esi
  62.  
  63. Lv_loop_mip0:
  64.  
  65. //            lightleft = lightptr[0];
  66. //            lightright = lightptr[1];
  67. //            lightdelta = (lightleft - lightright) & 0xFFFFF;
  68.     movl    (%ebx),%eax            // lightleft
  69.     movl    4(%ebx),%edx        // lightright
  70.  
  71.     movl    %eax,%ebp
  72.     movl    C(r_lightwidth),%ecx
  73.  
  74.     movl    %edx,C(lightright)
  75.     subl    %edx,%ebp
  76.  
  77.     andl    $0xFFFFF,%ebp
  78.     leal    (%ebx,%ecx,4),%ebx
  79.  
  80. //            lightptr += lightwidth;
  81.     movl    %ebx,C(r_lightptr)
  82.  
  83. //            lightleftstep = (lightptr[0] - lightleft) >> blockdivshift;
  84. //            lightrightstep = (lightptr[1] - lightright) >> blockdivshift;
  85. //            lightdeltastep = ((lightleftstep - lightrightstep) & 0xFFFFF) |
  86. //                    0xF0000000;
  87.     movl    4(%ebx),%ecx    // lightptr[1]
  88.     movl    (%ebx),%ebx        // lightptr[0]
  89.  
  90.     subl    %eax,%ebx
  91.     subl    %edx,%ecx
  92.  
  93.     sarl    $4,%ecx
  94.     orl        $0xF0000000,%ebp
  95.  
  96.     sarl    $4,%ebx
  97.     movl    %ecx,C(lightrightstep)
  98.  
  99.     subl    %ecx,%ebx
  100.     andl    $0xFFFFF,%ebx
  101.  
  102.     orl        $0xF0000000,%ebx
  103.     subl    %ecx,%ecx    // high word must be 0 in loop for addressing
  104.  
  105.     movl    %ebx,C(lightdeltastep)
  106.     subl    %ebx,%ebx    // high word must be 0 in loop for addressing
  107.  
  108. Lblockloop8_mip0:
  109.     movl    %ebp,C(lightdelta)
  110.     movb    14(%esi),%cl
  111.  
  112.     sarl    $4,%ebp
  113.     movb    %dh,%bh
  114.  
  115.     movb    15(%esi),%bl
  116.     addl    %ebp,%edx
  117.  
  118.     movb    %dh,%ch
  119.     addl    %ebp,%edx
  120.  
  121.     movb    0x12345678(%ebx),%ah
  122. LBPatch0:
  123.     movb    13(%esi),%bl
  124.  
  125.     movb    0x12345678(%ecx),%al
  126. LBPatch1:
  127.     movb    12(%esi),%cl
  128.  
  129.     movb    %dh,%bh
  130.     addl    %ebp,%edx
  131.  
  132.     rorl    $16,%eax
  133.     movb    %dh,%ch
  134.  
  135.     addl    %ebp,%edx
  136.     movb    0x12345678(%ebx),%ah
  137. LBPatch2:
  138.  
  139.     movb    11(%esi),%bl
  140.     movb    0x12345678(%ecx),%al
  141. LBPatch3:
  142.  
  143.     movb    10(%esi),%cl
  144.     movl    %eax,12(%edi)
  145.  
  146.     movb    %dh,%bh
  147.     addl    %ebp,%edx
  148.  
  149.     movb    %dh,%ch
  150.     addl    %ebp,%edx
  151.  
  152.     movb    0x12345678(%ebx),%ah
  153. LBPatch4:
  154.     movb    9(%esi),%bl
  155.  
  156.     movb    0x12345678(%ecx),%al
  157. LBPatch5:
  158.     movb    8(%esi),%cl
  159.  
  160.     movb    %dh,%bh
  161.     addl    %ebp,%edx
  162.  
  163.     rorl    $16,%eax
  164.     movb    %dh,%ch
  165.  
  166.     addl    %ebp,%edx
  167.     movb    0x12345678(%ebx),%ah
  168. LBPatch6:
  169.  
  170.     movb    7(%esi),%bl
  171.     movb    0x12345678(%ecx),%al
  172. LBPatch7:
  173.  
  174.     movb    6(%esi),%cl
  175.     movl    %eax,8(%edi)
  176.  
  177.     movb    %dh,%bh
  178.     addl    %ebp,%edx
  179.  
  180.     movb    %dh,%ch
  181.     addl    %ebp,%edx
  182.  
  183.     movb    0x12345678(%ebx),%ah
  184. LBPatch8:
  185.     movb    5(%esi),%bl
  186.  
  187.     movb    0x12345678(%ecx),%al
  188. LBPatch9:
  189.     movb    4(%esi),%cl
  190.  
  191.     movb    %dh,%bh
  192.     addl    %ebp,%edx
  193.  
  194.     rorl    $16,%eax
  195.     movb    %dh,%ch
  196.  
  197.     addl    %ebp,%edx
  198.     movb    0x12345678(%ebx),%ah
  199. LBPatch10:
  200.  
  201.     movb    3(%esi),%bl
  202.     movb    0x12345678(%ecx),%al
  203. LBPatch11:
  204.  
  205.     movb    2(%esi),%cl
  206.     movl    %eax,4(%edi)
  207.  
  208.     movb    %dh,%bh
  209.     addl    %ebp,%edx
  210.  
  211.     movb    %dh,%ch
  212.     addl    %ebp,%edx
  213.  
  214.     movb    0x12345678(%ebx),%ah
  215. LBPatch12:
  216.     movb    1(%esi),%bl
  217.  
  218.     movb    0x12345678(%ecx),%al
  219. LBPatch13:
  220.     movb    (%esi),%cl
  221.  
  222.     movb    %dh,%bh
  223.     addl    %ebp,%edx
  224.  
  225.     rorl    $16,%eax
  226.     movb    %dh,%ch
  227.  
  228.     movb    0x12345678(%ebx),%ah
  229. LBPatch14:
  230.     movl    C(lightright),%edx
  231.  
  232.     movb    0x12345678(%ecx),%al
  233. LBPatch15:
  234.     movl    C(lightdelta),%ebp
  235.  
  236.     movl    %eax,(%edi)
  237.  
  238.     addl    C(sourcetstep),%esi
  239.     addl    C(surfrowbytes),%edi
  240.  
  241.     addl    C(lightrightstep),%edx
  242.     addl    C(lightdeltastep),%ebp
  243.  
  244.     movl    %edx,C(lightright)
  245.     jc        Lblockloop8_mip0
  246.  
  247. //            if (pbasesource >= r_sourcemax)
  248. //                pbasesource -= stepback;
  249.  
  250.     cmpl    C(r_sourcemax),%esi
  251.     jb        LSkip_mip0
  252.     subl    C(r_stepback),%esi
  253. LSkip_mip0:
  254.  
  255.     movl    C(r_lightptr),%ebx
  256.     decl    sb_v
  257.  
  258.     jnz        Lv_loop_mip0
  259.  
  260.     popl    %ebx                // restore register variables
  261.     popl    %esi
  262.     popl    %edi
  263.     popl    %ebp                // restore the caller's stack frame
  264.     ret
  265.  
  266.  
  267. //----------------------------------------------------------------------
  268. // Surface block drawer for mip level 1
  269. //----------------------------------------------------------------------
  270.  
  271.     .align 4
  272. .globl C(R_DrawSurfaceBlock8_mip1)
  273. C(R_DrawSurfaceBlock8_mip1):
  274.     pushl    %ebp                // preserve caller's stack frame
  275.     pushl    %edi
  276.     pushl    %esi                // preserve register variables
  277.     pushl    %ebx
  278.  
  279. //        for (v=0 ; v<numvblocks ; v++)
  280. //        {
  281.     movl    C(r_lightptr),%ebx
  282.     movl    C(r_numvblocks),%eax
  283.  
  284.     movl    %eax,sb_v
  285.     movl    C(prowdestbase),%edi
  286.  
  287.     movl    C(pbasesource),%esi
  288.  
  289. Lv_loop_mip1:
  290.  
  291. //            lightleft = lightptr[0];
  292. //            lightright = lightptr[1];
  293. //            lightdelta = (lightleft - lightright) & 0xFFFFF;
  294.     movl    (%ebx),%eax            // lightleft
  295.     movl    4(%ebx),%edx        // lightright
  296.  
  297.     movl    %eax,%ebp
  298.     movl    C(r_lightwidth),%ecx
  299.  
  300.     movl    %edx,C(lightright)
  301.     subl    %edx,%ebp
  302.  
  303.     andl    $0xFFFFF,%ebp
  304.     leal    (%ebx,%ecx,4),%ebx
  305.  
  306. //            lightptr += lightwidth;
  307.     movl    %ebx,C(r_lightptr)
  308.  
  309. //            lightleftstep = (lightptr[0] - lightleft) >> blockdivshift;
  310. //            lightrightstep = (lightptr[1] - lightright) >> blockdivshift;
  311. //            lightdeltastep = ((lightleftstep - lightrightstep) & 0xFFFFF) |
  312. //                    0xF0000000;
  313.     movl    4(%ebx),%ecx    // lightptr[1]
  314.     movl    (%ebx),%ebx        // lightptr[0]
  315.  
  316.     subl    %eax,%ebx
  317.     subl    %edx,%ecx
  318.  
  319.     sarl    $3,%ecx
  320.     orl        $0x70000000,%ebp
  321.  
  322.     sarl    $3,%ebx
  323.     movl    %ecx,C(lightrightstep)
  324.  
  325.     subl    %ecx,%ebx
  326.     andl    $0xFFFFF,%ebx
  327.  
  328.     orl        $0xF0000000,%ebx
  329.     subl    %ecx,%ecx    // high word must be 0 in loop for addressing
  330.  
  331.     movl    %ebx,C(lightdeltastep)
  332.     subl    %ebx,%ebx    // high word must be 0 in loop for addressing
  333.  
  334. Lblockloop8_mip1:
  335.     movl    %ebp,C(lightdelta)
  336.     movb    6(%esi),%cl
  337.  
  338.     sarl    $3,%ebp
  339.     movb    %dh,%bh
  340.  
  341.     movb    7(%esi),%bl
  342.     addl    %ebp,%edx
  343.  
  344.     movb    %dh,%ch
  345.     addl    %ebp,%edx
  346.  
  347.     movb    0x12345678(%ebx),%ah
  348. LBPatch22:
  349.     movb    5(%esi),%bl
  350.  
  351.     movb    0x12345678(%ecx),%al
  352. LBPatch23:
  353.     movb    4(%esi),%cl
  354.  
  355.     movb    %dh,%bh
  356.     addl    %ebp,%edx
  357.  
  358.     rorl    $16,%eax
  359.     movb    %dh,%ch
  360.  
  361.     addl    %ebp,%edx
  362.     movb    0x12345678(%ebx),%ah
  363. LBPatch24:
  364.  
  365.     movb    3(%esi),%bl
  366.     movb    0x12345678(%ecx),%al
  367. LBPatch25:
  368.  
  369.     movb    2(%esi),%cl
  370.     movl    %eax,4(%edi)
  371.  
  372.     movb    %dh,%bh
  373.     addl    %ebp,%edx
  374.  
  375.     movb    %dh,%ch
  376.     addl    %ebp,%edx
  377.  
  378.     movb    0x12345678(%ebx),%ah
  379. LBPatch26:
  380.     movb    1(%esi),%bl
  381.  
  382.     movb    0x12345678(%ecx),%al
  383. LBPatch27:
  384.     movb    (%esi),%cl
  385.  
  386.     movb    %dh,%bh
  387.     addl    %ebp,%edx
  388.  
  389.     rorl    $16,%eax
  390.     movb    %dh,%ch
  391.  
  392.     movb    0x12345678(%ebx),%ah
  393. LBPatch28:
  394.     movl    C(lightright),%edx
  395.  
  396.     movb    0x12345678(%ecx),%al
  397. LBPatch29:
  398.     movl    C(lightdelta),%ebp
  399.  
  400.     movl    %eax,(%edi)
  401.     movl    C(sourcetstep),%eax
  402.  
  403.     addl    %eax,%esi
  404.     movl    C(surfrowbytes),%eax
  405.  
  406.     addl    %eax,%edi
  407.     movl    C(lightrightstep),%eax
  408.  
  409.     addl    %eax,%edx
  410.     movl    C(lightdeltastep),%eax
  411.  
  412.     addl    %eax,%ebp
  413.     movl    %edx,C(lightright)
  414.  
  415.     jc        Lblockloop8_mip1
  416.  
  417. //            if (pbasesource >= r_sourcemax)
  418. //                pbasesource -= stepback;
  419.  
  420.     cmpl    C(r_sourcemax),%esi
  421.     jb        LSkip_mip1
  422.     subl    C(r_stepback),%esi
  423. LSkip_mip1:
  424.  
  425.     movl    C(r_lightptr),%ebx
  426.     decl    sb_v
  427.  
  428.     jnz        Lv_loop_mip1
  429.  
  430.     popl    %ebx                // restore register variables
  431.     popl    %esi
  432.     popl    %edi
  433.     popl    %ebp                // restore the caller's stack frame
  434.     ret
  435.  
  436.  
  437. //----------------------------------------------------------------------
  438. // Surface block drawer for mip level 2
  439. //----------------------------------------------------------------------
  440.  
  441.     .align 4
  442. .globl C(R_DrawSurfaceBlock8_mip2)
  443. C(R_DrawSurfaceBlock8_mip2):
  444.     pushl    %ebp                // preserve caller's stack frame
  445.     pushl    %edi
  446.     pushl    %esi                // preserve register variables
  447.     pushl    %ebx
  448.  
  449. //        for (v=0 ; v<numvblocks ; v++)
  450. //        {
  451.     movl    C(r_lightptr),%ebx
  452.     movl    C(r_numvblocks),%eax
  453.  
  454.     movl    %eax,sb_v
  455.     movl    C(prowdestbase),%edi
  456.  
  457.     movl    C(pbasesource),%esi
  458.  
  459. Lv_loop_mip2:
  460.  
  461. //            lightleft = lightptr[0];
  462. //            lightright = lightptr[1];
  463. //            lightdelta = (lightleft - lightright) & 0xFFFFF;
  464.     movl    (%ebx),%eax            // lightleft
  465.     movl    4(%ebx),%edx        // lightright
  466.  
  467.     movl    %eax,%ebp
  468.     movl    C(r_lightwidth),%ecx
  469.  
  470.     movl    %edx,C(lightright)
  471.     subl    %edx,%ebp
  472.  
  473.     andl    $0xFFFFF,%ebp
  474.     leal    (%ebx,%ecx,4),%ebx
  475.  
  476. //            lightptr += lightwidth;
  477.     movl    %ebx,C(r_lightptr)
  478.  
  479. //            lightleftstep = (lightptr[0] - lightleft) >> blockdivshift;
  480. //            lightrightstep = (lightptr[1] - lightright) >> blockdivshift;
  481. //            lightdeltastep = ((lightleftstep - lightrightstep) & 0xFFFFF) |
  482. //                    0xF0000000;
  483.     movl    4(%ebx),%ecx    // lightptr[1]
  484.     movl    (%ebx),%ebx        // lightptr[0]
  485.  
  486.     subl    %eax,%ebx
  487.     subl    %edx,%ecx
  488.  
  489.     sarl    $2,%ecx
  490.     orl        $0x30000000,%ebp
  491.  
  492.     sarl    $2,%ebx
  493.     movl    %ecx,C(lightrightstep)
  494.  
  495.     subl    %ecx,%ebx
  496.  
  497.     andl    $0xFFFFF,%ebx
  498.  
  499.     orl        $0xF0000000,%ebx
  500.     subl    %ecx,%ecx    // high word must be 0 in loop for addressing
  501.  
  502.     movl    %ebx,C(lightdeltastep)
  503.     subl    %ebx,%ebx    // high word must be 0 in loop for addressing
  504.  
  505. Lblockloop8_mip2:
  506.     movl    %ebp,C(lightdelta)
  507.     movb    2(%esi),%cl
  508.  
  509.     sarl    $2,%ebp
  510.     movb    %dh,%bh
  511.  
  512.     movb    3(%esi),%bl
  513.     addl    %ebp,%edx
  514.  
  515.     movb    %dh,%ch
  516.     addl    %ebp,%edx
  517.  
  518.     movb    0x12345678(%ebx),%ah
  519. LBPatch18:
  520.     movb    1(%esi),%bl
  521.  
  522.     movb    0x12345678(%ecx),%al
  523. LBPatch19:
  524.     movb    (%esi),%cl
  525.  
  526.     movb    %dh,%bh
  527.     addl    %ebp,%edx
  528.  
  529.     rorl    $16,%eax
  530.     movb    %dh,%ch
  531.  
  532.     movb    0x12345678(%ebx),%ah
  533. LBPatch20:
  534.     movl    C(lightright),%edx
  535.  
  536.     movb    0x12345678(%ecx),%al
  537. LBPatch21:
  538.     movl    C(lightdelta),%ebp
  539.  
  540.     movl    %eax,(%edi)
  541.     movl    C(sourcetstep),%eax
  542.  
  543.     addl    %eax,%esi
  544.     movl    C(surfrowbytes),%eax
  545.  
  546.     addl    %eax,%edi
  547.     movl    C(lightrightstep),%eax
  548.  
  549.     addl    %eax,%edx
  550.     movl    C(lightdeltastep),%eax
  551.  
  552.     addl    %eax,%ebp
  553.     movl    %edx,C(lightright)
  554.  
  555.     jc        Lblockloop8_mip2
  556.  
  557. //            if (pbasesource >= r_sourcemax)
  558. //                pbasesource -= stepback;
  559.  
  560.     cmpl    C(r_sourcemax),%esi
  561.     jb        LSkip_mip2
  562.     subl    C(r_stepback),%esi
  563. LSkip_mip2:
  564.  
  565.     movl    C(r_lightptr),%ebx
  566.     decl    sb_v
  567.  
  568.     jnz        Lv_loop_mip2
  569.  
  570.     popl    %ebx                // restore register variables
  571.     popl    %esi
  572.     popl    %edi
  573.     popl    %ebp                // restore the caller's stack frame
  574.     ret
  575.  
  576.  
  577. //----------------------------------------------------------------------
  578. // Surface block drawer for mip level 3
  579. //----------------------------------------------------------------------
  580.  
  581.     .align 4
  582. .globl C(R_DrawSurfaceBlock8_mip3)
  583. C(R_DrawSurfaceBlock8_mip3):
  584.     pushl    %ebp                // preserve caller's stack frame
  585.     pushl    %edi
  586.     pushl    %esi                // preserve register variables
  587.     pushl    %ebx
  588.  
  589. //        for (v=0 ; v<numvblocks ; v++)
  590. //        {
  591.     movl    C(r_lightptr),%ebx
  592.     movl    C(r_numvblocks),%eax
  593.  
  594.     movl    %eax,sb_v
  595.     movl    C(prowdestbase),%edi
  596.  
  597.     movl    C(pbasesource),%esi
  598.  
  599. Lv_loop_mip3:
  600.  
  601. //            lightleft = lightptr[0];
  602. //            lightright = lightptr[1];
  603. //            lightdelta = (lightleft - lightright) & 0xFFFFF;
  604.     movl    (%ebx),%eax            // lightleft
  605.     movl    4(%ebx),%edx        // lightright
  606.  
  607.     movl    %eax,%ebp
  608.     movl    C(r_lightwidth),%ecx
  609.  
  610.     movl    %edx,C(lightright)
  611.     subl    %edx,%ebp
  612.  
  613.     andl    $0xFFFFF,%ebp
  614.     leal    (%ebx,%ecx,4),%ebx
  615.  
  616.     movl    %ebp,C(lightdelta)
  617. //            lightptr += lightwidth;
  618.     movl    %ebx,C(r_lightptr)
  619.  
  620. //            lightleftstep = (lightptr[0] - lightleft) >> blockdivshift;
  621. //            lightrightstep = (lightptr[1] - lightright) >> blockdivshift;
  622. //            lightdeltastep = ((lightleftstep - lightrightstep) & 0xFFFFF) |
  623. //                    0xF0000000;
  624.     movl    4(%ebx),%ecx    // lightptr[1]
  625.     movl    (%ebx),%ebx        // lightptr[0]
  626.  
  627.     subl    %eax,%ebx
  628.     subl    %edx,%ecx
  629.  
  630.     sarl    $1,%ecx
  631.  
  632.     sarl    $1,%ebx
  633.     movl    %ecx,C(lightrightstep)
  634.  
  635.     subl    %ecx,%ebx
  636.     andl    $0xFFFFF,%ebx
  637.  
  638.     sarl    $1,%ebp
  639.     orl        $0xF0000000,%ebx
  640.  
  641.     movl    %ebx,C(lightdeltastep)
  642.     subl    %ebx,%ebx    // high word must be 0 in loop for addressing
  643.  
  644.     movb    1(%esi),%bl
  645.     subl    %ecx,%ecx    // high word must be 0 in loop for addressing
  646.  
  647.     movb    %dh,%bh
  648.     movb    (%esi),%cl
  649.  
  650.     addl    %ebp,%edx
  651.     movb    %dh,%ch
  652.  
  653.     movb    0x12345678(%ebx),%al
  654. LBPatch16:
  655.     movl    C(lightright),%edx
  656.  
  657.     movb    %al,1(%edi)
  658.     movb    0x12345678(%ecx),%al
  659. LBPatch17:
  660.  
  661.     movb    %al,(%edi)
  662.     movl    C(sourcetstep),%eax
  663.  
  664.     addl    %eax,%esi
  665.     movl    C(surfrowbytes),%eax
  666.  
  667.     addl    %eax,%edi
  668.     movl    C(lightdeltastep),%eax
  669.  
  670.     movl    C(lightdelta),%ebp
  671.     movb    (%esi),%cl
  672.  
  673.     addl    %eax,%ebp
  674.     movl    C(lightrightstep),%eax
  675.  
  676.     sarl    $1,%ebp
  677.     addl    %eax,%edx
  678.  
  679.     movb    %dh,%bh
  680.     movb    1(%esi),%bl
  681.  
  682.     addl    %ebp,%edx
  683.     movb    %dh,%ch
  684.  
  685.     movb    0x12345678(%ebx),%al
  686. LBPatch30:
  687.     movl    C(sourcetstep),%edx
  688.  
  689.     movb    %al,1(%edi)
  690.     movb    0x12345678(%ecx),%al
  691. LBPatch31:
  692.  
  693.     movb    %al,(%edi)
  694.     movl    C(surfrowbytes),%ebp
  695.  
  696.     addl    %edx,%esi
  697.     addl    %ebp,%edi
  698.  
  699. //            if (pbasesource >= r_sourcemax)
  700. //                pbasesource -= stepback;
  701.  
  702.     cmpl    C(r_sourcemax),%esi
  703.     jb        LSkip_mip3
  704.     subl    C(r_stepback),%esi
  705. LSkip_mip3:
  706.  
  707.     movl    C(r_lightptr),%ebx
  708.     decl    sb_v
  709.  
  710.     jnz        Lv_loop_mip3
  711.  
  712.     popl    %ebx                // restore register variables
  713.     popl    %esi
  714.     popl    %edi
  715.     popl    %ebp                // restore the caller's stack frame
  716.     ret
  717.  
  718.  
  719. .globl C(R_Surf8End)
  720. C(R_Surf8End):
  721.  
  722. //----------------------------------------------------------------------
  723. // Code patching routines
  724. //----------------------------------------------------------------------
  725.     .data
  726.  
  727.     .align 4
  728. LPatchTable8:
  729.     .long    LBPatch0-4
  730.     .long    LBPatch1-4
  731.     .long    LBPatch2-4
  732.     .long    LBPatch3-4
  733.     .long    LBPatch4-4
  734.     .long    LBPatch5-4
  735.     .long    LBPatch6-4
  736.     .long    LBPatch7-4
  737.     .long    LBPatch8-4
  738.     .long    LBPatch9-4
  739.     .long    LBPatch10-4
  740.     .long    LBPatch11-4
  741.     .long    LBPatch12-4
  742.     .long    LBPatch13-4
  743.     .long    LBPatch14-4
  744.     .long    LBPatch15-4
  745.     .long    LBPatch16-4
  746.     .long    LBPatch17-4
  747.     .long    LBPatch18-4
  748.     .long    LBPatch19-4
  749.     .long    LBPatch20-4
  750.     .long    LBPatch21-4
  751.     .long    LBPatch22-4
  752.     .long    LBPatch23-4
  753.     .long    LBPatch24-4
  754.     .long    LBPatch25-4
  755.     .long    LBPatch26-4
  756.     .long    LBPatch27-4
  757.     .long    LBPatch28-4
  758.     .long    LBPatch29-4
  759.     .long    LBPatch30-4
  760.     .long    LBPatch31-4
  761.  
  762.     .text
  763.  
  764.     .align 4
  765. .globl C(R_Surf8Patch)
  766. C(R_Surf8Patch):
  767.     pushl    %ebx
  768.  
  769.     movl    C(colormap),%eax
  770.     movl    $LPatchTable8,%ebx
  771.     movl    $32,%ecx
  772. LPatchLoop8:
  773.     movl    (%ebx),%edx
  774.     addl    $4,%ebx
  775.     movl    %eax,(%edx)
  776.     decl    %ecx
  777.     jnz        LPatchLoop8
  778.  
  779.     popl    %ebx
  780.  
  781.     ret
  782.  
  783. #endif    // id386
  784.