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