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