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