home *** CD-ROM | disk | FTP | other *** search
/ Amiga ACS 1998 #2 / amigaacscoverdisc1998-021998.iso / games / doom / source / linuxdoom-1.10 / r_draw.c < prev    next >
C/C++ Source or Header  |  1997-12-22  |  19KB  |  878 lines
  1. // Emacs style mode select   -*- C++ -*- 
  2. //-----------------------------------------------------------------------------
  3. //
  4. // $Id:$
  5. //
  6. // Copyright (C) 1993-1996 by id Software, Inc.
  7. //
  8. // This source is available for distribution and/or modification
  9. // only under the terms of the DOOM Source Code License as
  10. // published by id Software. All rights reserved.
  11. //
  12. // The source is distributed in the hope that it will be useful,
  13. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. // FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
  15. // for more details.
  16. //
  17. // $Log:$
  18. //
  19. // DESCRIPTION:
  20. //    The actual span/column drawing functions.
  21. //    Here find the main potential for optimization,
  22. //     e.g. inline assembly, different algorithms.
  23. //
  24. //-----------------------------------------------------------------------------
  25.  
  26.  
  27. static const char
  28. rcsid[] = "$Id: r_draw.c,v 1.4 1997/02/03 16:47:55 b1 Exp $";
  29.  
  30.  
  31. #include "doomdef.h"
  32.  
  33. #include "i_system.h"
  34. #include "z_zone.h"
  35. #include "w_wad.h"
  36.  
  37. #include "r_local.h"
  38.  
  39. // Needs access to LFB (guess what).
  40. #include "v_video.h"
  41.  
  42. // State.
  43. #include "doomstat.h"
  44.  
  45.  
  46. // ?
  47. #define MAXWIDTH            1120
  48. #define MAXHEIGHT            832
  49.  
  50. // status bar height at bottom of screen
  51. #define SBARHEIGHT        32
  52.  
  53. //
  54. // All drawing to the view buffer is accomplished in this file.
  55. // The other refresh files only know about ccordinates,
  56. //  not the architecture of the frame buffer.
  57. // Conveniently, the frame buffer is a linear one,
  58. //  and we need only the base address,
  59. //  and the total size == width*height*depth/8.,
  60. //
  61.  
  62.  
  63. byte*        viewimage; 
  64. int        viewwidth;
  65. int        scaledviewwidth;
  66. int        viewheight;
  67. int        viewwindowx;
  68. int        viewwindowy; 
  69. byte*        ylookup[MAXHEIGHT]; 
  70. int        columnofs[MAXWIDTH]; 
  71.  
  72. // Color tables for different players,
  73. //  translate a limited part to another
  74. //  (color ramps used for  suit colors).
  75. //
  76. byte        translations[3][256];    
  77.  
  78.  
  79.  
  80.  
  81. //
  82. // R_DrawColumn
  83. // Source is the top of the column to scale.
  84. //
  85. lighttable_t*        dc_colormap; 
  86. int            dc_x; 
  87. int            dc_yl; 
  88. int            dc_yh; 
  89. fixed_t            dc_iscale; 
  90. fixed_t            dc_texturemid;
  91.  
  92. // first pixel in a column (possibly virtual) 
  93. byte*            dc_source;        
  94.  
  95. // just for profiling 
  96. int            dccount;
  97.  
  98. //
  99. // A column is a vertical slice/span from a wall texture that,
  100. //  given the DOOM style restrictions on the view orientation,
  101. //  will always have constant z depth.
  102. // Thus a special case loop for very fast rendering can
  103. //  be used. It has also been used with Wolfenstein 3D.
  104. // 
  105. void R_DrawColumn (void) 
  106. { 
  107.     int            count; 
  108.     byte*        dest; 
  109.     fixed_t        frac;
  110.     fixed_t        fracstep;     
  111.  
  112.     count = dc_yh - dc_yl; 
  113.  
  114.     // Zero length, column does not exceed a pixel.
  115.     if (count < 0) 
  116.     return; 
  117.                  
  118. #ifdef RANGECHECK 
  119.     if ((unsigned)dc_x >= SCREENWIDTH
  120.     || dc_yl < 0
  121.     || dc_yh >= SCREENHEIGHT) 
  122.     I_Error ("R_DrawColumn: %i to %i at %i", dc_yl, dc_yh, dc_x); 
  123. #endif 
  124.  
  125.     // Framebuffer destination address.
  126.     // Use ylookup LUT to avoid multiply with ScreenWidth.
  127.     // Use columnofs LUT for subwindows? 
  128.     dest = ylookup[dc_yl] + columnofs[dc_x];  
  129.  
  130.     // Determine scaling,
  131.     //  which is the only mapping to be done.
  132.     fracstep = dc_iscale; 
  133.     frac = dc_texturemid + (dc_yl-centery)*fracstep; 
  134.  
  135.     // Inner loop that does the actual texture mapping,
  136.     //  e.g. a DDA-lile scaling.
  137.     // This is as fast as it gets.
  138.     do 
  139.     {
  140.     // Re-map color indices from wall texture column
  141.     //  using a lighting/special effects LUT.
  142.     *dest = dc_colormap[dc_source[(frac>>FRACBITS)&127]];
  143.     
  144.     dest += SCREENWIDTH; 
  145.     frac += fracstep;
  146.     
  147.     } while (count--); 
  148. } 
  149.  
  150.  
  151.  
  152. // UNUSED.
  153. // Loop unrolled.
  154. #if 0
  155. void R_DrawColumn (void) 
  156. { 
  157.     int            count; 
  158.     byte*        source;
  159.     byte*        dest;
  160.     byte*        colormap;
  161.     
  162.     unsigned        frac;
  163.     unsigned        fracstep;
  164.     unsigned        fracstep2;
  165.     unsigned        fracstep3;
  166.     unsigned        fracstep4;     
  167.  
  168.     count = dc_yh - dc_yl + 1; 
  169.  
  170.     source = dc_source;
  171.     colormap = dc_colormap;         
  172.     dest = ylookup[dc_yl] + columnofs[dc_x];  
  173.      
  174.     fracstep = dc_iscale<<9; 
  175.     frac = (dc_texturemid + (dc_yl-centery)*dc_iscale)<<9; 
  176.  
  177.     fracstep2 = fracstep+fracstep;
  178.     fracstep3 = fracstep2+fracstep;
  179.     fracstep4 = fracstep3+fracstep;
  180.     
  181.     while (count >= 8) 
  182.     { 
  183.     dest[0] = colormap[source[frac>>25]]; 
  184.     dest[SCREENWIDTH] = colormap[source[(frac+fracstep)>>25]]; 
  185.     dest[SCREENWIDTH*2] = colormap[source[(frac+fracstep2)>>25]]; 
  186.     dest[SCREENWIDTH*3] = colormap[source[(frac+fracstep3)>>25]];
  187.     
  188.     frac += fracstep4; 
  189.  
  190.     dest[SCREENWIDTH*4] = colormap[source[frac>>25]]; 
  191.     dest[SCREENWIDTH*5] = colormap[source[(frac+fracstep)>>25]]; 
  192.     dest[SCREENWIDTH*6] = colormap[source[(frac+fracstep2)>>25]]; 
  193.     dest[SCREENWIDTH*7] = colormap[source[(frac+fracstep3)>>25]]; 
  194.  
  195.     frac += fracstep4; 
  196.     dest += SCREENWIDTH*8; 
  197.     count -= 8;
  198.     } 
  199.     
  200.     while (count > 0)
  201.     { 
  202.     *dest = colormap[source[frac>>25]]; 
  203.     dest += SCREENWIDTH; 
  204.     frac += fracstep; 
  205.     count--;
  206.     } 
  207. }
  208. #endif
  209.  
  210.  
  211. void R_DrawColumnLow (void) 
  212. { 
  213.     int            count; 
  214.     byte*        dest; 
  215.     byte*        dest2;
  216.     fixed_t        frac;
  217.     fixed_t        fracstep;     
  218.  
  219.     count = dc_yh - dc_yl; 
  220.  
  221.     // Zero length.
  222.     if (count < 0) 
  223.     return; 
  224.                  
  225. #ifdef RANGECHECK 
  226.     if ((unsigned)dc_x >= SCREENWIDTH
  227.     || dc_yl < 0
  228.     || dc_yh >= SCREENHEIGHT)
  229.     {
  230.     
  231.     I_Error ("R_DrawColumn: %i to %i at %i", dc_yl, dc_yh, dc_x);
  232.     }
  233.     //    dccount++; 
  234. #endif 
  235.     // Blocky mode, need to multiply by 2.
  236.     dc_x <<= 1;
  237.     
  238.     dest = ylookup[dc_yl] + columnofs[dc_x];
  239.     dest2 = ylookup[dc_yl] + columnofs[dc_x+1];
  240.     
  241.     fracstep = dc_iscale; 
  242.     frac = dc_texturemid + (dc_yl-centery)*fracstep;
  243.     
  244.     do 
  245.     {
  246.     // Hack. Does not work corretly.
  247.     *dest2 = *dest = dc_colormap[dc_source[(frac>>FRACBITS)&127]];
  248.     dest += SCREENWIDTH;
  249.     dest2 += SCREENWIDTH;
  250.     frac += fracstep; 
  251.  
  252.     } while (count--);
  253. }
  254.  
  255.  
  256. //
  257. // Spectre/Invisibility.
  258. //
  259. #define FUZZTABLE        50 
  260. #define FUZZOFF    (SCREENWIDTH)
  261.  
  262.  
  263. int    fuzzoffset[FUZZTABLE] =
  264. {
  265.     FUZZOFF,-FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  266.     FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  267.     FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,
  268.     FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  269.     FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,
  270.     FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,
  271.     FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF 
  272. }; 
  273.  
  274. int    fuzzpos = 0; 
  275.  
  276.  
  277. //
  278. // Framebuffer postprocessing.
  279. // Creates a fuzzy image by copying pixels
  280. //  from adjacent ones to left and right.
  281. // Used with an all black colormap, this
  282. //  could create the SHADOW effect,
  283. //  i.e. spectres and invisible players.
  284. //
  285. void R_DrawFuzzColumn (void) 
  286. { 
  287.     int            count; 
  288.     byte*        dest; 
  289.     fixed_t        frac;
  290.     fixed_t        fracstep;     
  291.  
  292.     // Adjust borders. Low... 
  293.     if (!dc_yl) 
  294.     dc_yl = 1;
  295.  
  296.     // .. and high.
  297.     if (dc_yh == viewheight-1) 
  298.     dc_yh = viewheight - 2; 
  299.          
  300.     count = dc_yh - dc_yl; 
  301.  
  302.     // Zero length.
  303.     if (count < 0) 
  304.     return; 
  305.  
  306.     
  307. #ifdef RANGECHECK 
  308.     if ((unsigned)dc_x >= SCREENWIDTH
  309.     || dc_yl < 0 || dc_yh >= SCREENHEIGHT)
  310.     {
  311.     I_Error ("R_DrawFuzzColumn: %i to %i at %i",
  312.          dc_yl, dc_yh, dc_x);
  313.     }
  314. #endif
  315.  
  316.  
  317.     // Keep till detailshift bug in blocky mode fixed,
  318.     //  or blocky mode removed.
  319.     /* WATCOM code 
  320.     if (detailshift)
  321.     {
  322.     if (dc_x & 1)
  323.     {
  324.         outpw (GC_INDEX,GC_READMAP+(2<<8) ); 
  325.         outp (SC_INDEX+1,12); 
  326.     }
  327.     else
  328.     {
  329.         outpw (GC_INDEX,GC_READMAP); 
  330.         outp (SC_INDEX+1,3); 
  331.     }
  332.     dest = destview + dc_yl*80 + (dc_x>>1); 
  333.     }
  334.     else
  335.     {
  336.     outpw (GC_INDEX,GC_READMAP+((dc_x&3)<<8) ); 
  337.     outp (SC_INDEX+1,1<<(dc_x&3)); 
  338.     dest = destview + dc_yl*80 + (dc_x>>2); 
  339.     }*/
  340.  
  341.     
  342.     // Does not work with blocky mode.
  343.     dest = ylookup[dc_yl] + columnofs[dc_x];
  344.  
  345.     // Looks familiar.
  346.     fracstep = dc_iscale; 
  347.     frac = dc_texturemid + (dc_yl-centery)*fracstep; 
  348.  
  349.     // Looks like an attempt at dithering,
  350.     //  using the colormap #6 (of 0-31, a bit
  351.     //  brighter than average).
  352.     do 
  353.     {
  354.     // Lookup framebuffer, and retrieve
  355.     //  a pixel that is either one column
  356.     //  left or right of the current one.
  357.     // Add index from colormap to index.
  358.     *dest = colormaps[6*256+dest[fuzzoffset[fuzzpos]]]; 
  359.  
  360.     // Clamp table lookup index.
  361.     if (++fuzzpos == FUZZTABLE) 
  362.         fuzzpos = 0;
  363.     
  364.     dest += SCREENWIDTH;
  365.  
  366.     frac += fracstep; 
  367.     } while (count--); 
  368. } 
  369.  
  370.   
  371.  
  372.  
  373. //
  374. // R_DrawTranslatedColumn
  375. // Used to draw player sprites
  376. //  with the green colorramp mapped to others.
  377. // Could be used with different translation
  378. //  tables, e.g. the lighter colored version
  379. //  of the BaronOfHell, the HellKnight, uses
  380. //  identical sprites, kinda brightened up.
  381. //
  382. byte*    dc_translation;
  383. byte*    translationtables;
  384.  
  385. void R_DrawTranslatedColumn (void) 
  386. { 
  387.     int            count; 
  388.     byte*        dest; 
  389.     fixed_t        frac;
  390.     fixed_t        fracstep;     
  391.  
  392.     count = dc_yh - dc_yl; 
  393.     if (count < 0) 
  394.     return; 
  395.                  
  396. #ifdef RANGECHECK 
  397.     if ((unsigned)dc_x >= SCREENWIDTH
  398.     || dc_yl < 0
  399.     || dc_yh >= SCREENHEIGHT)
  400.     {
  401.     I_Error ( "R_DrawColumn: %i to %i at %i",
  402.           dc_yl, dc_yh, dc_x);
  403.     }
  404.     
  405. #endif 
  406.  
  407.  
  408.     // WATCOM VGA specific.
  409.     /* Keep for fixing.
  410.     if (detailshift)
  411.     {
  412.     if (dc_x & 1)
  413.         outp (SC_INDEX+1,12); 
  414.     else
  415.         outp (SC_INDEX+1,3);
  416.     
  417.     dest = destview + dc_yl*80 + (dc_x>>1); 
  418.     }
  419.     else
  420.     {
  421.     outp (SC_INDEX+1,1<<(dc_x&3)); 
  422.  
  423.     dest = destview + dc_yl*80 + (dc_x>>2); 
  424.     }*/
  425.  
  426.     
  427.     // FIXME. As above.
  428.     dest = ylookup[dc_yl] + columnofs[dc_x]; 
  429.  
  430.     // Looks familiar.
  431.     fracstep = dc_iscale; 
  432.     frac = dc_texturemid + (dc_yl-centery)*fracstep; 
  433.  
  434.     // Here we do an additional index re-mapping.
  435.     do 
  436.     {
  437.     // Translation tables are used
  438.     //  to map certain colorramps to other ones,
  439.     //  used with PLAY sprites.
  440.     // Thus the "green" ramp of the player 0 sprite
  441.     //  is mapped to gray, red, black/indigo. 
  442.     *dest = dc_colormap[dc_translation[dc_source[frac>>FRACBITS]]];
  443.     dest += SCREENWIDTH;
  444.     
  445.     frac += fracstep; 
  446.     } while (count--); 
  447. } 
  448.  
  449.  
  450.  
  451.  
  452. //
  453. // R_InitTranslationTables
  454. // Creates the translation tables to map
  455. //  the green color ramp to gray, brown, red.
  456. // Assumes a given structure of the PLAYPAL.
  457. // Could be read from a lump instead.
  458. //
  459. void R_InitTranslationTables (void)
  460. {
  461.     int        i;
  462.     
  463.     translationtables = Z_Malloc (256*3+255, PU_STATIC, 0);
  464.     translationtables = (byte *)(( (int)translationtables + 255 )& ~255);
  465.     
  466.     // translate just the 16 green colors
  467.     for (i=0 ; i<256 ; i++)
  468.     {
  469.     if (i >= 0x70 && i<= 0x7f)
  470.     {
  471.         // map green ramp to gray, brown, red
  472.         translationtables[i] = 0x60 + (i&0xf);
  473.         translationtables [i+256] = 0x40 + (i&0xf);
  474.         translationtables [i+512] = 0x20 + (i&0xf);
  475.     }
  476.     else
  477.     {
  478.         // Keep all other colors as is.
  479.         translationtables[i] = translationtables[i+256] 
  480.         = translationtables[i+512] = i;
  481.     }
  482.     }
  483. }
  484.  
  485.  
  486.  
  487.  
  488. //
  489. // R_DrawSpan 
  490. // With DOOM style restrictions on view orientation,
  491. //  the floors and ceilings consist of horizontal slices
  492. //  or spans with constant z depth.
  493. // However, rotation around the world z axis is possible,
  494. //  thus this mapping, while simpler and faster than
  495. //  perspective correct texture mapping, has to traverse
  496. //  the texture at an angle in all but a few cases.
  497. // In consequence, flats are not stored by column (like walls),
  498. //  and the inner loop has to step in texture space u and v.
  499. //
  500. int            ds_y; 
  501. int            ds_x1; 
  502. int            ds_x2;
  503.  
  504. lighttable_t*        ds_colormap; 
  505.  
  506. fixed_t            ds_xfrac; 
  507. fixed_t            ds_yfrac; 
  508. fixed_t            ds_xstep; 
  509. fixed_t            ds_ystep;
  510.  
  511. // start of a 64*64 tile image 
  512. byte*            ds_source;    
  513.  
  514. // just for profiling
  515. int            dscount;
  516.  
  517.  
  518. //
  519. // Draws the actual span.
  520. void R_DrawSpan (void) 
  521. { 
  522.     fixed_t        xfrac;
  523.     fixed_t        yfrac; 
  524.     byte*        dest; 
  525.     int            count;
  526.     int            spot; 
  527.      
  528. #ifdef RANGECHECK 
  529.     if (ds_x2 < ds_x1
  530.     || ds_x1<0
  531.     || ds_x2>=SCREENWIDTH  
  532.     || (unsigned)ds_y>SCREENHEIGHT)
  533.     {
  534.     I_Error( "R_DrawSpan: %i to %i at %i",
  535.          ds_x1,ds_x2,ds_y);
  536.     }
  537. //    dscount++; 
  538. #endif 
  539.  
  540.     
  541.     xfrac = ds_xfrac; 
  542.     yfrac = ds_yfrac; 
  543.      
  544.     dest = ylookup[ds_y] + columnofs[ds_x1];
  545.  
  546.     // We do not check for zero spans here?
  547.     count = ds_x2 - ds_x1; 
  548.  
  549.     do 
  550.     {
  551.     // Current texture index in u,v.
  552.     spot = ((yfrac>>(16-6))&(63*64)) + ((xfrac>>16)&63);
  553.  
  554.     // Lookup pixel from flat texture tile,
  555.     //  re-index using light/colormap.
  556.     *dest++ = ds_colormap[ds_source[spot]];
  557.  
  558.     // Next step in u,v.
  559.     xfrac += ds_xstep; 
  560.     yfrac += ds_ystep;
  561.     
  562.     } while (count--); 
  563. } 
  564.  
  565.  
  566.  
  567. // UNUSED.
  568. // Loop unrolled by 4.
  569. #if 0
  570. void R_DrawSpan (void) 
  571. { 
  572.     unsigned    position, step;
  573.  
  574.     byte*    source;
  575.     byte*    colormap;
  576.     byte*    dest;
  577.     
  578.     unsigned    count;
  579.     usingned    spot; 
  580.     unsigned    value;
  581.     unsigned    temp;
  582.     unsigned    xtemp;
  583.     unsigned    ytemp;
  584.         
  585.     position = ((ds_xfrac<<10)&0xffff0000) | ((ds_yfrac>>6)&0xffff);
  586.     step = ((ds_xstep<<10)&0xffff0000) | ((ds_ystep>>6)&0xffff);
  587.         
  588.     source = ds_source;
  589.     colormap = ds_colormap;
  590.     dest = ylookup[ds_y] + columnofs[ds_x1];     
  591.     count = ds_x2 - ds_x1 + 1; 
  592.     
  593.     while (count >= 4) 
  594.     { 
  595.     ytemp = position>>4;
  596.     ytemp = ytemp & 4032;
  597.     xtemp = position>>26;
  598.     spot = xtemp | ytemp;
  599.     position += step;
  600.     dest[0] = colormap[source[spot]]; 
  601.  
  602.     ytemp = position>>4;
  603.     ytemp = ytemp & 4032;
  604.     xtemp = position>>26;
  605.     spot = xtemp | ytemp;
  606.     position += step;
  607.     dest[1] = colormap[source[spot]];
  608.     
  609.     ytemp = position>>4;
  610.     ytemp = ytemp & 4032;
  611.     xtemp = position>>26;
  612.     spot = xtemp | ytemp;
  613.     position += step;
  614.     dest[2] = colormap[source[spot]];
  615.     
  616.     ytemp = position>>4;
  617.     ytemp = ytemp & 4032;
  618.     xtemp = position>>26;
  619.     spot = xtemp | ytemp;
  620.     position += step;
  621.     dest[3] = colormap[source[spot]]; 
  622.         
  623.     count -= 4;
  624.     dest += 4;
  625.     } 
  626.     while (count > 0) 
  627.     { 
  628.     ytemp = position>>4;
  629.     ytemp = ytemp & 4032;
  630.     xtemp = position>>26;
  631.     spot = xtemp | ytemp;
  632.     position += step;
  633.     *dest++ = colormap[source[spot]]; 
  634.     count--;
  635.     } 
  636. } 
  637. #endif
  638.  
  639.  
  640. //
  641. // Again..
  642. //
  643. void R_DrawSpanLow (void) 
  644. { 
  645.     fixed_t        xfrac;
  646.     fixed_t        yfrac; 
  647.     byte*        dest; 
  648.     int            count;
  649.     int            spot; 
  650.      
  651. #ifdef RANGECHECK 
  652.     if (ds_x2 < ds_x1
  653.     || ds_x1<0
  654.     || ds_x2>=SCREENWIDTH  
  655.     || (unsigned)ds_y>SCREENHEIGHT)
  656.     {
  657.     I_Error( "R_DrawSpan: %i to %i at %i",
  658.          ds_x1,ds_x2,ds_y);
  659.     }
  660. //    dscount++; 
  661. #endif 
  662.      
  663.     xfrac = ds_xfrac; 
  664.     yfrac = ds_yfrac; 
  665.  
  666.     // Blocky mode, need to multiply by 2.
  667.     ds_x1 <<= 1;
  668.     ds_x2 <<= 1;
  669.     
  670.     dest = ylookup[ds_y] + columnofs[ds_x1];
  671.   
  672.     
  673.     count = ds_x2 - ds_x1; 
  674.     do 
  675.     { 
  676.     spot = ((yfrac>>(16-6))&(63*64)) + ((xfrac>>16)&63);
  677.     // Lowres/blocky mode does it twice,
  678.     //  while scale is adjusted appropriately.
  679.     *dest++ = ds_colormap[ds_source[spot]]; 
  680.     *dest++ = ds_colormap[ds_source[spot]];
  681.     
  682.     xfrac += ds_xstep; 
  683.     yfrac += ds_ystep; 
  684.  
  685.     } while (count--); 
  686. }
  687.  
  688. //
  689. // R_InitBuffer 
  690. // Creats lookup tables that avoid
  691. //  multiplies and other hazzles
  692. //  for getting the framebuffer address
  693. //  of a pixel to draw.
  694. //
  695. void
  696. R_InitBuffer
  697. ( int        width,
  698.   int        height ) 
  699. { 
  700.     int        i; 
  701.  
  702.     // Handle resize,
  703.     //  e.g. smaller view windows
  704.     //  with border and/or status bar.
  705.     viewwindowx = (SCREENWIDTH-width) >> 1; 
  706.  
  707.     // Column offset. For windows.
  708.     for (i=0 ; i<width ; i++) 
  709.     columnofs[i] = viewwindowx + i;
  710.  
  711.     // Samw with base row offset.
  712.     if (width == SCREENWIDTH) 
  713.     viewwindowy = 0; 
  714.     else 
  715.     viewwindowy = (SCREENHEIGHT-SBARHEIGHT-height) >> 1; 
  716.  
  717.     // Preclaculate all row offsets.
  718.     for (i=0 ; i<height ; i++) 
  719.     ylookup[i] = screens[0] + (i+viewwindowy)*SCREENWIDTH; 
  720. } 
  721.  
  722.  
  723.  
  724.  
  725. //
  726. // R_FillBackScreen
  727. // Fills the back screen with a pattern
  728. //  for variable screen sizes
  729. // Also draws a beveled edge.
  730. //
  731. void R_FillBackScreen (void) 
  732. { 
  733.     byte*    src;
  734.     byte*    dest; 
  735.     int        x;
  736.     int        y; 
  737.     patch_t*    patch;
  738.  
  739.     // DOOM border patch.
  740.     char    name1[] = "FLOOR7_2";
  741.  
  742.     // DOOM II border patch.
  743.     char    name2[] = "GRNROCK";    
  744.  
  745.     char*    name;
  746.     
  747.     if (scaledviewwidth == 320)
  748.     return;
  749.     
  750.     if ( gamemode == commercial)
  751.     name = name2;
  752.     else
  753.     name = name1;
  754.     
  755.     src = W_CacheLumpName (name, PU_CACHE); 
  756.     dest = screens[1]; 
  757.      
  758.     for (y=0 ; y<SCREENHEIGHT-SBARHEIGHT ; y++) 
  759.     { 
  760.     for (x=0 ; x<SCREENWIDTH/64 ; x++) 
  761.     { 
  762.         memcpy (dest, src+((y&63)<<6), 64); 
  763.         dest += 64; 
  764.     } 
  765.  
  766.     if (SCREENWIDTH&63) 
  767.     { 
  768.         memcpy (dest, src+((y&63)<<6), SCREENWIDTH&63); 
  769.         dest += (SCREENWIDTH&63); 
  770.     } 
  771.     } 
  772.     
  773.     patch = W_CacheLumpName ("brdr_t",PU_CACHE);
  774.  
  775.     for (x=0 ; x<scaledviewwidth ; x+=8)
  776.     V_DrawPatch (viewwindowx+x,viewwindowy-8,1,patch);
  777.     patch = W_CacheLumpName ("brdr_b",PU_CACHE);
  778.  
  779.     for (x=0 ; x<scaledviewwidth ; x+=8)
  780.     V_DrawPatch (viewwindowx+x,viewwindowy+viewheight,1,patch);
  781.     patch = W_CacheLumpName ("brdr_l",PU_CACHE);
  782.  
  783.     for (y=0 ; y<viewheight ; y+=8)
  784.     V_DrawPatch (viewwindowx-8,viewwindowy+y,1,patch);
  785.     patch = W_CacheLumpName ("brdr_r",PU_CACHE);
  786.  
  787.     for (y=0 ; y<viewheight ; y+=8)
  788.     V_DrawPatch (viewwindowx+scaledviewwidth,viewwindowy+y,1,patch);
  789.  
  790.  
  791.     // Draw beveled edge. 
  792.     V_DrawPatch (viewwindowx-8,
  793.          viewwindowy-8,
  794.          1,
  795.          W_CacheLumpName ("brdr_tl",PU_CACHE));
  796.     
  797.     V_DrawPatch (viewwindowx+scaledviewwidth,
  798.          viewwindowy-8,
  799.          1,
  800.          W_CacheLumpName ("brdr_tr",PU_CACHE));
  801.     
  802.     V_DrawPatch (viewwindowx-8,
  803.          viewwindowy+viewheight,
  804.          1,
  805.          W_CacheLumpName ("brdr_bl",PU_CACHE));
  806.     
  807.     V_DrawPatch (viewwindowx+scaledviewwidth,
  808.          viewwindowy+viewheight,
  809.          1,
  810.          W_CacheLumpName ("brdr_br",PU_CACHE));
  811. } 
  812.  
  813.  
  814. //
  815. // Copy a screen buffer.
  816. //
  817. void
  818. R_VideoErase
  819. ( unsigned    ofs,
  820.   int        count ) 
  821. { 
  822.   // LFB copy.
  823.   // This might not be a good idea if memcpy
  824.   //  is not optiomal, e.g. byte by byte on
  825.   //  a 32bit CPU, as GNU GCC/Linux libc did
  826.   //  at one point.
  827.     memcpy (screens[0]+ofs, screens[1]+ofs, count); 
  828. } 
  829.  
  830.  
  831. //
  832. // R_DrawViewBorder
  833. // Draws the border around the view
  834. //  for different size windows?
  835. //
  836. void
  837. V_MarkRect
  838. ( int        x,
  839.   int        y,
  840.   int        width,
  841.   int        height ); 
  842.  
  843. void R_DrawViewBorder (void) 
  844. { 
  845.     int        top;
  846.     int        side;
  847.     int        ofs;
  848.     int        i; 
  849.  
  850.     if (scaledviewwidth == SCREENWIDTH) 
  851.     return; 
  852.   
  853.     top = ((SCREENHEIGHT-SBARHEIGHT)-viewheight)/2; 
  854.     side = (SCREENWIDTH-scaledviewwidth)/2; 
  855.  
  856.     // copy top and one line of left side 
  857.     R_VideoErase (0, top*SCREENWIDTH+side); 
  858.  
  859.     // copy one line of right side and bottom 
  860.     ofs = (viewheight+top)*SCREENWIDTH-side; 
  861.     R_VideoErase (ofs, top*SCREENWIDTH+side); 
  862.  
  863.     // copy sides using wraparound 
  864.     ofs = top*SCREENWIDTH + SCREENWIDTH-side; 
  865.     side <<= 1;
  866.     
  867.     for (i=1 ; i<viewheight ; i++) 
  868.     { 
  869.     R_VideoErase (ofs, side); 
  870.     ofs += SCREENWIDTH; 
  871.     } 
  872.  
  873.     // ? 
  874.     V_MarkRect (0,0,SCREENWIDTH, SCREENHEIGHT-SBARHEIGHT); 
  875. } 
  876.  
  877.  
  878.