home *** CD-ROM | disk | FTP | other *** search
/ ST-Computer Leser-CD 2000 January / LCD_01_2000.iso / games / doom / pmdoom / src / r_draw8.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-12-17  |  12.2 KB  |  510 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. #include "i_video.h"
  42.  
  43. /*  State. */
  44. #include "doomstat.h"
  45.  
  46. /*  */
  47. /*  R_DrawColumn */
  48. /*  Source is the top of the column to scale. */
  49. /*  */
  50.  
  51. /*  A column is a vertical slice/span from a wall texture that, */
  52. /*   given the DOOM style restrictions on the view orientation, */
  53. /*   will always have constant z depth. */
  54. /*  Thus a special case loop for very fast rendering can */
  55. /*   be used. It has also been used with Wolfenstein 3D. */
  56. /*   */
  57. #ifndef ATARI
  58. void R_DrawColumn8 (void) 
  59. { 
  60.     int            count; 
  61.     byte*        dest; 
  62.     fixed_t        frac;
  63.     fixed_t        fracstep;     
  64.  
  65.     count = dc_yh - dc_yl; 
  66.  
  67.     /*  Zero length, column does not exceed a pixel. */
  68.     if (count < 0) 
  69.     return; 
  70.                  
  71. #ifdef RANGECHECK 
  72.     if ((unsigned)dc_x >= SCREENWIDTH
  73.     || dc_yl < 0
  74.     || dc_yh >= SCREENHEIGHT) 
  75.     I_Error ("R_DrawColumn: %i to %i at %i", dc_yl, dc_yh, dc_x); 
  76. #endif 
  77.  
  78.     /*  Framebuffer destination address. */
  79.     /*  Use ylookup LUT to avoid multiply with ScreenWidth. */
  80.     /*  Use columnofs LUT for subwindows?  */
  81.     dest = ylookup[dc_yl] + columnofs[dc_x];  
  82.  
  83.     /*  Determine scaling, */
  84.     /*   which is the only mapping to be done. */
  85.     fracstep = dc_iscale; 
  86.     frac = dc_texturemid + (dc_yl-centery)*fracstep; 
  87.  
  88.     /*  Inner loop that does the actual texture mapping, */
  89.     /*   e.g. a DDA-lile scaling. */
  90.     /*  This is as fast as it gets. */
  91.     do 
  92.     {
  93.     /*  Re-map color indices from wall texture column */
  94.     /*   using a lighting/special effects LUT. */
  95.     *dest = dc_colormap[dc_source[(frac>>FRACBITS)&127]];
  96.     
  97.     dest += SCREENWIDTH;
  98.     frac += fracstep;
  99.     
  100.     } while (count--); 
  101. } 
  102.  
  103.  
  104. void R_DrawColumnLow8 (void) 
  105. { 
  106.     int            count; 
  107.     byte*        dest; 
  108.     byte*        dest2;
  109.     fixed_t        frac;
  110.     fixed_t        fracstep;     
  111.  
  112.     count = dc_yh - dc_yl; 
  113.  
  114.     /*  Zero length. */
  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.     {
  123.     
  124.     I_Error ("R_DrawColumn: %i to %i at %i", dc_yl, dc_yh, dc_x);
  125.     }
  126.     /*     dccount++;  */
  127. #endif 
  128.     /*  Blocky mode, need to multiply by 2. */
  129. /*     dc_x <<= 1; */
  130.     
  131.     dest = ylookup[dc_yl] + columnofs[dc_x << 1];
  132.     dest2 = ylookup[dc_yl] + columnofs[(dc_x <<1)+1];
  133.     
  134.     fracstep = dc_iscale; 
  135.     frac = dc_texturemid + (dc_yl-centery)*fracstep;
  136.     
  137.     do 
  138.     {
  139.     /*  Hack. Does not work corretly. */
  140.     *dest2 = *dest = dc_colormap[dc_source[(frac>>FRACBITS)&127]];
  141.     dest += SCREENWIDTH;
  142.     dest2 += SCREENWIDTH;
  143.     frac += fracstep; 
  144.  
  145.     } while (count--);
  146. }
  147. #endif
  148.  
  149. /*  */
  150. /*  Spectre/Invisibility. */
  151. /*  */
  152. #define FUZZTABLE        50 
  153. #define FUZZOFF    (SCREENWIDTH)
  154.  
  155.  
  156. int    fuzzoffset[FUZZTABLE] =
  157. {
  158.     FUZZOFF,-FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  159.     FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  160.     FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,
  161.     FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  162.     FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,
  163.     FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,
  164.     FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF 
  165. }; 
  166.  
  167. int    fuzzpos = 0; 
  168.  
  169.  
  170. /*  */
  171. /*  Framebuffer postprocessing. */
  172. /*  Creates a fuzzy image by copying pixels */
  173. /*   from adjacent ones to left and right. */
  174. /*  Used with an all black colormap, this */
  175. /*   could create the SHADOW effect, */
  176. /*   i.e. spectres and invisible players. */
  177. /*  */
  178. #ifndef ATARI
  179. void R_DrawFuzzColumn8 (void) 
  180. { 
  181.     int            count; 
  182.     byte*        dest; 
  183.     fixed_t        frac;
  184.     fixed_t        fracstep;     
  185.  
  186.     /*  Adjust borders. Low...  */
  187.     if (!dc_yl) 
  188.     dc_yl = 1;
  189.  
  190.     /*  .. and high. */
  191.     if (dc_yh == viewheight-1) 
  192.     dc_yh = viewheight - 2; 
  193.          
  194.     count = dc_yh - dc_yl; 
  195.  
  196.     /*  Zero length. */
  197.     if (count < 0) 
  198.     return; 
  199.  
  200.     
  201. #ifdef RANGECHECK 
  202.     if ((unsigned)dc_x >= SCREENWIDTH
  203.     || dc_yl < 0 || dc_yh >= SCREENHEIGHT)
  204.     {
  205.     I_Error ("R_DrawFuzzColumn: %i to %i at %i",
  206.          dc_yl, dc_yh, dc_x);
  207.     }
  208. #endif
  209.     
  210.     /*  Does not work with blocky mode. */
  211.     dest = ylookup[dc_yl] + columnofs[dc_x];
  212.  
  213.     /*  Looks familiar. */
  214.     fracstep = dc_iscale; 
  215.     frac = dc_texturemid + (dc_yl-centery)*fracstep; 
  216.  
  217.     /*  Looks like an attempt at dithering, */
  218.     /*   using the colormap #6 (of 0-31, a bit */
  219.     /*   brighter than average). */
  220.     do 
  221.     {
  222.     /*  Lookup framebuffer, and retrieve */
  223.     /*   a pixel that is either one column */
  224.     /*   left or right of the current one. */
  225.     /*  Add index from colormap to index. */
  226.     *dest = colormaps[6*256+dest[fuzzoffset[fuzzpos]]]; 
  227.  
  228.     /*  Clamp table lookup index. */
  229.     if (++fuzzpos == FUZZTABLE) 
  230.         fuzzpos = 0;
  231.     
  232.     dest += SCREENWIDTH;
  233.  
  234.     frac += fracstep; 
  235.     } while (count--); 
  236. } 
  237.  
  238. void R_DrawFuzzColumnLow8 (void) 
  239. { 
  240.     int            count; 
  241.     byte        *dest,*dest2; 
  242.     fixed_t        frac;
  243.     fixed_t        fracstep;     
  244.  
  245.     /*  Adjust borders. Low...  */
  246.     if (!dc_yl) 
  247.     dc_yl = 1;
  248.  
  249.     /*  .. and high. */
  250.     if (dc_yh == viewheight-1) 
  251.     dc_yh = viewheight - 2; 
  252.          
  253.     count = dc_yh - dc_yl; 
  254.  
  255.     /*  Zero length. */
  256.     if (count < 0) 
  257.     return; 
  258.  
  259.     
  260. #ifdef RANGECHECK 
  261.     if ((unsigned)dc_x >= SCREENWIDTH
  262.     || dc_yl < 0 || dc_yh >= SCREENHEIGHT)
  263.     {
  264.     I_Error ("R_DrawFuzzColumn: %i to %i at %i",
  265.          dc_yl, dc_yh, dc_x);
  266.     }
  267. #endif
  268.     
  269.     /*  Does not work with blocky mode. */
  270.     dest = ylookup[dc_yl] + columnofs[dc_x << 1];
  271.     dest2 = ylookup[dc_yl] + columnofs[(dc_x << 1)+1];
  272.  
  273.     /*  Looks familiar. */
  274.     fracstep = dc_iscale; 
  275.     frac = dc_texturemid + (dc_yl-centery)*fracstep; 
  276.  
  277.     /*  Looks like an attempt at dithering, */
  278.     /*   using the colormap #6 (of 0-31, a bit */
  279.     /*   brighter than average). */
  280.     do 
  281.     {
  282.     /*  Lookup framebuffer, and retrieve */
  283.     /*   a pixel that is either one column */
  284.     /*   left or right of the current one. */
  285.     /*  Add index from colormap to index. */
  286.     *dest = *dest2 = colormaps[6*256+dest[fuzzoffset[fuzzpos]]]; 
  287.  
  288.     /*  Clamp table lookup index. */
  289.     if (++fuzzpos == FUZZTABLE) 
  290.         fuzzpos = 0;
  291.     
  292.     dest += SCREENWIDTH;
  293.     dest2 += SCREENWIDTH;
  294.  
  295.     frac += fracstep; 
  296.     } while (count--); 
  297. }  
  298.  
  299. /*  */
  300. /*  R_DrawTranslatedColumn */
  301. /*  Used to draw player sprites */
  302. /*   with the green colorramp mapped to others. */
  303. /*  Could be used with different translation */
  304. /*   tables, e.g. the lighter colored version */
  305. /*   of the BaronOfHell, the HellKnight, uses */
  306. /*   identical sprites, kinda brightened up. */
  307. /*  */
  308. void R_DrawTranslatedColumn8 (void) 
  309. { 
  310.     int            count; 
  311.     byte*        dest; 
  312.     fixed_t        frac;
  313.     fixed_t        fracstep;     
  314.  
  315.     count = dc_yh - dc_yl; 
  316.     if (count < 0) 
  317.     return; 
  318.                  
  319. #ifdef RANGECHECK 
  320.     if ((unsigned)dc_x >= SCREENWIDTH
  321.     || dc_yl < 0
  322.     || dc_yh >= SCREENHEIGHT)
  323.     {
  324.     I_Error ( "R_DrawColumn: %i to %i at %i",
  325.           dc_yl, dc_yh, dc_x);
  326.     }
  327.     
  328. #endif 
  329.     
  330.     /*  FIXME. As above. */
  331.     dest = ylookup[dc_yl] + columnofs[dc_x]; 
  332.  
  333.     /*  Looks familiar. */
  334.     fracstep = dc_iscale; 
  335.     frac = dc_texturemid + (dc_yl-centery)*fracstep; 
  336.  
  337.     /*  Here we do an additional index re-mapping. */
  338.     do 
  339.     {
  340.     /*  Translation tables are used */
  341.     /*   to map certain colorramps to other ones, */
  342.     /*   used with PLAY sprites. */
  343.     /*  Thus the "green" ramp of the player 0 sprite */
  344.     /*   is mapped to gray, red, black/indigo.  */
  345.     *dest = dc_colormap[dc_translation[dc_source[frac>>FRACBITS]]];
  346.     dest += SCREENWIDTH;
  347.     
  348.     frac += fracstep; 
  349.     } while (count--); 
  350. } 
  351.  
  352. void R_DrawTranslatedColumnLow8 (void) 
  353. { 
  354.     int            count; 
  355.     byte        *dest,*dest2; 
  356.     fixed_t        frac;
  357.     fixed_t        fracstep;     
  358.  
  359.     count = dc_yh - dc_yl; 
  360.     if (count < 0) 
  361.     return; 
  362.                  
  363. #ifdef RANGECHECK 
  364.     if ((unsigned)dc_x >= SCREENWIDTH
  365.     || dc_yl < 0
  366.     || dc_yh >= SCREENHEIGHT)
  367.     {
  368.     I_Error ( "R_DrawColumn: %i to %i at %i",
  369.           dc_yl, dc_yh, dc_x);
  370.     }
  371.     
  372. #endif 
  373.     
  374.     /*  FIXME. As above. */
  375.     dest = ylookup[dc_yl] + columnofs[dc_x << 1]; 
  376.     dest2 = ylookup[dc_yl] + columnofs[(dc_x << 1)+1]; 
  377.  
  378.     /*  Looks familiar. */
  379.     fracstep = dc_iscale; 
  380.     frac = dc_texturemid + (dc_yl-centery)*fracstep; 
  381.  
  382.     /*  Here we do an additional index re-mapping. */
  383.     do 
  384.     {
  385.     /*  Translation tables are used */
  386.     /*   to map certain colorramps to other ones, */
  387.     /*   used with PLAY sprites. */
  388.     /*  Thus the "green" ramp of the player 0 sprite */
  389.     /*   is mapped to gray, red, black/indigo.  */
  390.     *dest = *dest2 = dc_colormap[dc_translation[dc_source[frac>>FRACBITS]]];
  391.     dest += SCREENWIDTH;
  392.     dest2 += SCREENWIDTH;
  393.     
  394.     frac += fracstep; 
  395.     } while (count--); 
  396. } 
  397.  
  398.  
  399. /*  */
  400. /*  R_DrawSpan  */
  401. /*  With DOOM style restrictions on view orientation, */
  402. /*   the floors and ceilings consist of horizontal slices */
  403. /*   or spans with constant z depth. */
  404. /*  However, rotation around the world z axis is possible, */
  405. /*   thus this mapping, while simpler and faster than */
  406. /*   perspective correct texture mapping, has to traverse */
  407. /*   the texture at an angle in all but a few cases. */
  408. /*  In consequence, flats are not stored by column (like walls), */
  409. /*   and the inner loop has to step in texture space u and v. */
  410. /*  */
  411.  
  412. /*  */
  413. /*  Draws the actual span. */
  414. void R_DrawSpan8 (void) 
  415. { 
  416.     fixed_t        xfrac;
  417.     fixed_t        yfrac; 
  418.     byte*        dest; 
  419.     int            count;
  420.     int            spot; 
  421.      
  422. #ifdef RANGECHECK 
  423.     if (ds_x2 < ds_x1
  424.     || ds_x1<0
  425.     || ds_x2>=SCREENWIDTH  
  426.     || (unsigned)ds_y>SCREENHEIGHT)
  427.     {
  428.     I_Error( "R_DrawSpan: %i to %i at %i",
  429.          ds_x1,ds_x2,ds_y);
  430.     }
  431. /*     dscount++;  */
  432. #endif 
  433.  
  434.     
  435.     xfrac = ds_xfrac; 
  436.     yfrac = ds_yfrac; 
  437.      
  438.     dest = ylookup[ds_y] + columnofs[ds_x1];
  439.  
  440.     /*  We do not check for zero spans here? */
  441.     count = ds_x2 - ds_x1; 
  442.  
  443.     do 
  444.     {
  445.     /*  Current texture index in u,v. */
  446.     spot = ((yfrac>>(16-6))&(63*64)) + ((xfrac>>16)&63);
  447.  
  448.     /*  Lookup pixel from flat texture tile, */
  449.     /*   re-index using light/colormap. */
  450.     *dest++ = ds_colormap[ds_source[spot]];
  451.  
  452.     /*  Next step in u,v. */
  453.     xfrac += ds_xstep; 
  454.     yfrac += ds_ystep;
  455.     
  456.     } while (count--); 
  457. } 
  458.  
  459.  
  460.  
  461.  
  462. /*  */
  463. /*  Again.. */
  464. /*  */
  465. void R_DrawSpanLow8 (void) 
  466. { 
  467.     fixed_t        xfrac;
  468.     fixed_t        yfrac; 
  469.     byte*        dest; 
  470.     int            count;
  471.     int            spot; 
  472.      
  473. #ifdef RANGECHECK 
  474.     if (ds_x2 < ds_x1
  475.     || ds_x1<0
  476.     || ds_x2>=SCREENWIDTH  
  477.     || (unsigned)ds_y>SCREENHEIGHT)
  478.     {
  479.     I_Error( "R_DrawSpan: %i to %i at %i",
  480.          ds_x1,ds_x2,ds_y);
  481.     }
  482. /*     dscount++;  */
  483. #endif 
  484.      
  485.     xfrac = ds_xfrac; 
  486.     yfrac = ds_yfrac; 
  487.  
  488.     /*  Blocky mode, need to multiply by 2. */
  489. /*     ds_x1 <<= 1; */
  490. /*     ds_x2 <<= 1; */
  491.     
  492.     dest = ylookup[ds_y] + columnofs[ds_x1 << 1];
  493.   
  494.     
  495.     count = ds_x2 - ds_x1; 
  496.     do 
  497.     { 
  498.     spot = ((yfrac>>(16-6))&(63*64)) + ((xfrac>>16)&63);
  499.     /*  Lowres/blocky mode does it twice, */
  500.     /*   while scale is adjusted appropriately. */
  501.     *dest++ = ds_colormap[ds_source[spot]]; 
  502.     *dest++ = ds_colormap[ds_source[spot]];
  503.     
  504.     xfrac += ds_xstep; 
  505.     yfrac += ds_ystep; 
  506.  
  507.     } while (count--); 
  508. }
  509. #endif
  510.