home *** CD-ROM | disk | FTP | other *** search
/ ST-Computer Leser-CD 2000 January / LCD_01_2000.iso / games / doom / pmdoom / src / r_draw.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-12-17  |  9.6 KB  |  406 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. /*  All drawing to the view buffer is accomplished in this file. */
  48. /*  The other refresh files only know about ccordinates, */
  49. /*   not the architecture of the frame buffer. */
  50. /*  Conveniently, the frame buffer is a linear one, */
  51. /*   and we need only the base address, */
  52. /*   and the total size == width*height*depth/8., */
  53. /*  */
  54.  
  55.  
  56. byte*        viewimage; 
  57. int        viewwidth;
  58. int        scaledviewwidth;
  59. int        viewheight;
  60. int        viewwindowx;
  61. int        viewwindowy; 
  62. int        columnofs[MAXWIDTH]; 
  63.  
  64. byte    *ylookup[MAXHEIGHT]; 
  65.  
  66. /*  Color tables for different players, */
  67. /*   translate a limited part to another */
  68. /*   (color ramps used for  suit colors). */
  69. /*  */
  70. byte        translations[3][256];    
  71.  
  72.  
  73.  
  74.  
  75. /*  */
  76. /*  R_DrawColumn */
  77. /*  Source is the top of the column to scale. */
  78. /*  */
  79. lighttable_t*        dc_colormap; 
  80. int            dc_x; 
  81. int            dc_yl; 
  82. int            dc_yh; 
  83. fixed_t            dc_iscale; 
  84. fixed_t            dc_texturemid;
  85.  
  86. /*  first pixel in a column (possibly virtual)  */
  87. byte*            dc_source;        
  88.  
  89. /*  just for profiling  */
  90. int            dccount;
  91.  
  92. byte*    dc_translation;
  93. byte*    translationtables;
  94.  
  95. /*  */
  96. /*  R_InitTranslationTables */
  97. /*  Creates the translation tables to map */
  98. /*   the green color ramp to gray, brown, red. */
  99. /*  Assumes a given structure of the PLAYPAL. */
  100. /*  Could be read from a lump instead. */
  101. /*  */
  102. void R_InitTranslationTables (void)
  103. {
  104.     int        i;
  105.     
  106. #if 0
  107.     translationtables = Z_Malloc (256*3+255, PU_STATIC, 0);
  108.     translationtables = (byte *)(( (int)translationtables + 255 )& ~255);
  109. #else
  110.     translationtables = Z_Malloc (256*3, PU_STATIC, 0);
  111. #endif
  112.     
  113.     /*  translate just the 16 green colors */
  114.     for (i=0 ; i<256 ; i++)
  115.     {
  116.     if (i >= 0x70 && i<= 0x7f)
  117.     {
  118.         /*  map green ramp to gray, brown, red */
  119.         translationtables[i] = 0x60 + (i&0xf);
  120.         translationtables [i+256] = 0x40 + (i&0xf);
  121.         translationtables [i+512] = 0x20 + (i&0xf);
  122.     }
  123.     else
  124.     {
  125.         /*  Keep all other colors as is. */
  126.         translationtables[i] = translationtables[i+256] 
  127.         = translationtables[i+512] = i;
  128.     }
  129.     }
  130. }
  131.  
  132. /*  */
  133. /*  R_DrawSpan  */
  134. /*  With DOOM style restrictions on view orientation, */
  135. /*   the floors and ceilings consist of horizontal slices */
  136. /*   or spans with constant z depth. */
  137. /*  However, rotation around the world z axis is possible, */
  138. /*   thus this mapping, while simpler and faster than */
  139. /*   perspective correct texture mapping, has to traverse */
  140. /*   the texture at an angle in all but a few cases. */
  141. /*  In consequence, flats are not stored by column (like walls), */
  142. /*   and the inner loop has to step in texture space u and v. */
  143. /*  */
  144. int            ds_y; 
  145. int            ds_x1; 
  146. int            ds_x2;
  147.  
  148. lighttable_t*        ds_colormap; 
  149.  
  150. fixed_t            ds_xfrac; 
  151. fixed_t            ds_yfrac; 
  152. fixed_t            ds_xstep; 
  153. fixed_t            ds_ystep;
  154.  
  155. /*  start of a 64*64 tile image  */
  156. byte*            ds_source;    
  157.  
  158. /*  just for profiling */
  159. int            dscount;
  160.  
  161.  
  162. /*  */
  163. /*  R_InitBuffer  */
  164. /*  Creats lookup tables that avoid */
  165. /*   multiplies and other hazzles */
  166. /*   for getting the framebuffer address */
  167. /*   of a pixel to draw. */
  168. /*  */
  169. void
  170. R_InitBuffer
  171. ( int        width,
  172.   int        height ) 
  173. { 
  174.     int        i; 
  175.  
  176.     /*  Handle resize, */
  177.     /*   e.g. smaller view windows */
  178.     /*   with border and/or status bar. */
  179.     viewwindowx = (SCREENWIDTH-width) >> 1; 
  180.  
  181.     /*  Column offset. For windows. */
  182.     for (i=0 ; i<width ; i++) 
  183.     columnofs[i] = (viewwindowx + i)*pixel_size;
  184.  
  185.     /*  Samw with base row offset. */
  186.     if (width == SCREENWIDTH) 
  187.     viewwindowy = 0; 
  188.     else 
  189.     viewwindowy = (SCREENHEIGHT-SBARHEIGHT-height) >> 1; 
  190.  
  191.     /*  Preclaculate all row offsets. */
  192.     for (i=0 ; i<height ; i++) 
  193.     ylookup[i] = screens[0] + (i+viewwindowy)*SCREENWIDTH*pixel_size; 
  194. } 
  195.  
  196. /*  */
  197. /*  R_FillBackScreen */
  198. /*  Fills the back screen with a pattern */
  199. /*   for variable screen sizes */
  200. /*  Also draws a beveled edge. */
  201. /*  */
  202. void R_FillBackScreen (void) 
  203. { 
  204.     byte    *src,*src1;
  205.     byte    *dest; 
  206.     unsigned short *destsrc;
  207.     unsigned long *destsrc32;
  208.     int        x;
  209.     int        y; 
  210.     patch_t*    patch;
  211.  
  212.     /*  DOOM border patch. */
  213.     char    name1[] = "FLOOR7_2";
  214.  
  215.     /*  DOOM II border patch. */
  216.     char    name2[] = "GRNROCK";    
  217.  
  218.     char*    name;
  219.     
  220.     if (scaledviewwidth == 320)
  221.     return;
  222.     
  223.     if ( gamemode == commercial)
  224.     name = name2;
  225.     else
  226.     name = name1;
  227.     
  228.     src = W_CacheLumpName (name, PU_CACHE); 
  229.      
  230.     switch (pixel_size)
  231.     {
  232.         case 1:
  233.             dest = screens[1]; 
  234.             for (y=0 ; y<SCREENHEIGHT-SBARHEIGHT ; y++) 
  235.             { 
  236.                 for (x=0 ; x<SCREENWIDTH/64 ; x++) 
  237.                 { 
  238.                     memcpy (dest, src+((y&63)<<6), 64); 
  239.                     dest += 64; 
  240.                 } 
  241.  
  242.                 if (SCREENWIDTH&63)
  243.                 { 
  244.                     memcpy (dest, src+((y&63)<<6), SCREENWIDTH&63); 
  245.                     dest += (SCREENWIDTH&63); 
  246.                 } 
  247.             } 
  248.             break;
  249.         case 2:
  250.             destsrc = (unsigned short *) screens[1]; 
  251.      
  252.             for (y=0 ; y<SCREENHEIGHT-SBARHEIGHT ; y++) 
  253.             { 
  254.                 unsigned short *dest1;
  255.  
  256.                 src1 = src + ((y & 63) << 6);
  257.                 dest1 = destsrc;
  258.  
  259.                 for (x=0; x<SCREENWIDTH ; x++)
  260.                     *dest1++ = truecolor_palette[ src1[x & 63] ];            
  261.                 destsrc += SCREENWIDTH;
  262.             } 
  263.             break;
  264.         case 3:
  265.             dest=screens[1];
  266.             for (y=0 ; y<SCREENHEIGHT-SBARHEIGHT ; y++) 
  267.             { 
  268.                 byte    *dest1;
  269.  
  270.                 src1 = src + ((y & 63) << 6);
  271.                 dest1 = dest;
  272.  
  273.                 for (x=0; x<SCREENWIDTH ; x++)
  274.                 {
  275.                     unsigned long couleur;
  276.  
  277.                     couleur = truecolor_palette[ src1[x & 63] ];
  278.  
  279.                     *dest1++ = couleur;
  280.                     *dest1++ = couleur >> 8;
  281.                     *dest1++ = couleur >> 16;            
  282.                 }
  283.                 dest += SCREENWIDTH*3;
  284.             } 
  285.             break;
  286.         case 4:
  287.             destsrc32 = (unsigned long *) screens[1]; 
  288.      
  289.             for (y=0 ; y<SCREENHEIGHT-SBARHEIGHT ; y++) 
  290.             { 
  291.                 unsigned long *dest1;
  292.  
  293.                 src1 = src + ((y & 63) << 6);
  294.                 dest1 = destsrc32;
  295.  
  296.                 for (x=0; x<SCREENWIDTH ; x++)
  297.                     *dest1++ = truecolor_palette[ src1[x & 63] ];            
  298.                 destsrc32 += SCREENWIDTH;
  299.             } 
  300.             break;
  301.     }
  302.     
  303.     patch = W_CacheLumpName ("brdr_t",PU_CACHE);
  304.  
  305.     for (x=0 ; x<scaledviewwidth ; x+=8)
  306.     V_DrawPatch (viewwindowx+x,viewwindowy-8,1,patch);
  307.     patch = W_CacheLumpName ("brdr_b",PU_CACHE);
  308.  
  309.     for (x=0 ; x<scaledviewwidth ; x+=8)
  310.     V_DrawPatch (viewwindowx+x,viewwindowy+viewheight,1,patch);
  311.     patch = W_CacheLumpName ("brdr_l",PU_CACHE);
  312.  
  313.     for (y=0 ; y<viewheight ; y+=8)
  314.     V_DrawPatch (viewwindowx-8,viewwindowy+y,1,patch);
  315.     patch = W_CacheLumpName ("brdr_r",PU_CACHE);
  316.  
  317.     for (y=0 ; y<viewheight ; y+=8)
  318.     V_DrawPatch (viewwindowx+scaledviewwidth,viewwindowy+y,1,patch);
  319.  
  320.  
  321.     /*  Draw beveled edge.  */
  322.     V_DrawPatch (viewwindowx-8,
  323.          viewwindowy-8,
  324.          1,
  325.          W_CacheLumpName ("brdr_tl",PU_CACHE));
  326.     
  327.     V_DrawPatch (viewwindowx+scaledviewwidth,
  328.          viewwindowy-8,
  329.          1,
  330.          W_CacheLumpName ("brdr_tr",PU_CACHE));
  331.     
  332.     V_DrawPatch (viewwindowx-8,
  333.          viewwindowy+viewheight,
  334.          1,
  335.          W_CacheLumpName ("brdr_bl",PU_CACHE));
  336.     
  337.     V_DrawPatch (viewwindowx+scaledviewwidth,
  338.          viewwindowy+viewheight,
  339.          1,
  340.          W_CacheLumpName ("brdr_br",PU_CACHE));
  341. } 
  342.  
  343.  
  344. /*  */
  345. /*  Copy a screen buffer. */
  346. /*  */
  347. void
  348. R_VideoErase
  349. ( unsigned    ofs,
  350.   int        count ) 
  351. { 
  352.   /*  LFB copy. */
  353.   /*  This might not be a good idea if memcpy */
  354.   /*   is not optiomal, e.g. byte by byte on */
  355.   /*   a 32bit CPU, as GNU GCC/Linux libc did */
  356.   /*   at one point. */
  357.     memcpy (screens[0]+ofs*pixel_size, screens[1]+ofs*pixel_size, count*pixel_size); 
  358. } 
  359.  
  360.  
  361. /*  */
  362. /*  R_DrawViewBorder */
  363. /*  Draws the border around the view */
  364. /*   for different size windows? */
  365. /*  */
  366. void
  367. V_MarkRect
  368. ( int        x,
  369.   int        y,
  370.   int        width,
  371.   int        height ); 
  372.  
  373. void R_DrawViewBorder (void) 
  374. { 
  375.     int        top;
  376.     int        side;
  377.     int        ofs;
  378.     int        i; 
  379.  
  380.     if (scaledviewwidth == SCREENWIDTH) 
  381.     return; 
  382.   
  383.     top = ((SCREENHEIGHT-SBARHEIGHT)-viewheight)/2; 
  384.     side = (SCREENWIDTH-scaledviewwidth)/2; 
  385.  
  386.     /*  copy top and one line of left side  */
  387.     R_VideoErase (0, top*SCREENWIDTH+side); 
  388.  
  389.     /*  copy one line of right side and bottom  */
  390.     ofs = (viewheight+top)*SCREENWIDTH-side; 
  391.     R_VideoErase (ofs, top*SCREENWIDTH+side); 
  392.  
  393.     /*  copy sides using wraparound  */
  394.     ofs = top*SCREENWIDTH + SCREENWIDTH-side; 
  395.     side <<= 1;
  396.     
  397.     for (i=1 ; i<viewheight ; i++) 
  398.     { 
  399.     R_VideoErase (ofs, side); 
  400.     ofs += SCREENWIDTH; 
  401.     } 
  402.  
  403.     /*  ?  */
  404.     V_MarkRect (0,0,SCREENWIDTH, SCREENHEIGHT-SBARHEIGHT); 
  405. } 
  406.