CGDoom/cgdoom/r_draw.c

// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id:$
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This source is available for distribution and/or modification
// only under the terms of the DOOM Source Code License as
// published by id Software. All rights reserved.
//
// The source is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
// for more details.
//
// $Log:$
//
// DESCRIPTION:
//	The actual span/column drawing functions.
//	Here find the main potential for optimization,
//	 e.g. inline assembly, different algorithms.
//
//-----------------------------------------------------------------------------


//static const char 


#include "doomdef.h"

#include "i_system.h"
#include "z_zone.h"
#include "w_wad.h"

#include "r_local.h"

// Needs access to LFB (guess what).
#include "v_video.h"

// State.
#include "doomstat.h"


// ?
#define MAXWIDTH			1120
#define MAXHEIGHT			832

// status bar height at bottom of screen
#define SBARHEIGHT			32

//
// All drawing to the view buffer is accomplished in this file.
// The other refresh files only know about ccordinates,
//  not the architecture of the frame buffer.
// Conveniently, the frame buffer is a linear one,
//  and we need only the base address,
//  and the total size == width*height*depth/8.,
//


byte*			viewimage; 
int				viewwidth;
int				scaledviewwidth;
int				viewheight;
int				viewwindowx;
int				viewwindowy; 
byte*			ylookup[MAXHEIGHT]; 
int				columnofs[MAXWIDTH]; 

// Color tables for different players,
//  translate a limited part to another
//  (color ramps used for  suit colors).
//
byte			translations[3][256];	




//
// R_DrawColumn
// Source is the top of the column to scale.
//
const lighttable_t*	dc_colormap; 
int				dc_x; 
int				dc_yl; 
int				dc_yh; 
fixed_t			dc_iscale; 
fixed_t			dc_texturemid;

// first pixel in a column (possibly virtual) 
const byte*		dc_source;		

// just for profiling 
int				dccount;

//
// A column is a vertical slice/span from a wall texture that,
//  given the DOOM style restrictions on the view orientation,
//  will always have constant z depth.
// Thus a special case loop for very fast rendering can
//  be used. It has also been used with Wolfenstein 3D.
// 
void R_DrawColumn (void) 
{ 
  int			count; 
  byte*		dest; 
  fixed_t		frac;
  fixed_t		fracstep;

  count = dc_yh - dc_yl; 

  // Zero length, column does not exceed a pixel.
  if (count < 0) 
    return; 

#ifdef RANGECHECK 
  if ((unsigned)dc_x >= SCREENWIDTH
    || dc_yl < 0
    || dc_yh >= SCREENHEIGHT) 
    I_Error ("R_DrawColumn: %i to %i at %i", dc_yl, dc_yh, dc_x); 
#endif 

  // Framebuffer destination address.
  // Use ylookup LUT to avoid multiply with ScreenWidth.
  // Use columnofs LUT for subwindows? 
  dest = ylookup[dc_yl] + columnofs[dc_x];  

  // Determine scaling,
  //  which is the only mapping to be done.
  fracstep = dc_iscale; 
  frac = dc_texturemid + (dc_yl-centery)*fracstep; 

  // Inner loop that does the actual texture mapping,
  //  e.g. a DDA-line scaling.
  // This is as fast as it gets.
  do 
  {
    // Re-map color indices from wall texture column
    //  using a lighting/special effects LUT.
    *dest = dc_colormap[dc_source[(frac>>FRACBITS)&127]];

    dest += SCREENWIDTH; 
    frac += fracstep;

  } while (count--); 
}

//
// Spectre/Invisibility.
//
#define FUZZTABLE		50 
#define FUZZOFF	(SCREENWIDTH)


static const int fuzzoffset[FUZZTABLE] =
{
  FUZZOFF,-FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
    FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
    FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,
    FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
    FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,
    FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,
    FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF 
}; 

int	fuzzpos = 0; 


//
// Framebuffer postprocessing.
// Creates a fuzzy image by copying pixels
//  from adjacent ones to left and right.
// Used with an all black colormap, this
//  could create the SHADOW effect,
//  i.e. spectres and invisible players.
//
void R_DrawFuzzColumn (void) 
{ 
  int			count; 
  byte*		dest; 
  fixed_t		frac;
  fixed_t		fracstep;	 

  // Adjust borders. Low... 
  if (!dc_yl) 
    dc_yl = 1;

  // .. and high.
  if (dc_yh == viewheight-1) 
    dc_yh = viewheight - 2; 

  count = dc_yh - dc_yl; 

  // Zero length.
  if (count < 0) 
    return; 


#ifdef RANGECHECK 
  if ((unsigned)dc_x >= SCREENWIDTH
    || dc_yl < 0 || dc_yh >= SCREENHEIGHT)
  {
    I_Error ("R_DrawFuzzColumn: %i to %i at %i",
      dc_yl, dc_yh, dc_x);
  }
#endif


  // Keep till detailshift bug in blocky mode fixed,
  //  or blocky mode removed.
  /* WATCOM code 
  if (detailshift)
  {
  if (dc_x & 1)
  {
  outpw (GC_INDEX,GC_READMAP+(2<<8) ); 
  outp (SC_INDEX+1,12); 
  }
  else
  {
  outpw (GC_INDEX,GC_READMAP); 
  outp (SC_INDEX+1,3); 
  }
  dest = destview + dc_yl*80 + (dc_x>>1); 
  }
  else
  {
  outpw (GC_INDEX,GC_READMAP+((dc_x&3)<<8) ); 
  outp (SC_INDEX+1,1<<(dc_x&3)); 
  dest = destview + dc_yl*80 + (dc_x>>2); 
  }*/


  // Does not work with blocky mode.
  dest = ylookup[dc_yl] + columnofs[dc_x];

  // Looks familiar.
  fracstep = dc_iscale; 
  frac = dc_texturemid + (dc_yl-centery)*fracstep; 

  // Looks like an attempt at dithering,
  //  using the colormap #6 (of 0-31, a bit
  //  brighter than average).
  do 
  {
    // Lookup framebuffer, and retrieve
    //  a pixel that is either one column
    //  left or right of the current one.
    // Add index from colormap to index.
    *dest = colormaps[6*256+dest[fuzzoffset[fuzzpos]]]; 

    // Clamp table lookup index.
    if (++fuzzpos == FUZZTABLE) 
      fuzzpos = 0;

    dest += SCREENWIDTH;

    frac += fracstep; 
  } while (count--); 
} 




//
// R_DrawTranslatedColumn
// Used to draw player sprites
//  with the green colorramp mapped to others.
// Could be used with different translation
//  tables, e.g. the lighter colored version
//  of the BaronOfHell, the HellKnight, uses
//  identical sprites, kinda brightened up.
//
byte*	dc_translation;
byte*	translationtables;

void R_DrawTranslatedColumn (void) 
{ 
  int			count; 
  byte*		dest; 
  fixed_t		frac;
  fixed_t		fracstep;	 

  count = dc_yh - dc_yl; 
  if (count < 0) 
    return; 

#ifdef RANGECHECK 
  if ((unsigned)dc_x >= SCREENWIDTH
    || dc_yl < 0
    || dc_yh >= SCREENHEIGHT)
  {
    I_Error ( "R_DrawColumn: %i to %i at %i", dc_yl, dc_yh, dc_x);
  }

#endif 

  // WATCOM VGA specific.
  /* Keep for fixing.
  if (detailshift)
  {
  if (dc_x & 1)
  outp (SC_INDEX+1,12); 
  else
  outp (SC_INDEX+1,3);

  dest = destview + dc_yl*80 + (dc_x>>1); 
  }
  else
  {
  outp (SC_INDEX+1,1<<(dc_x&3)); 

  dest = destview + dc_yl*80 + (dc_x>>2); 
  }*/


  // FIXME. As above.
  dest = ylookup[dc_yl] + columnofs[dc_x]; 

  // Looks familiar.
  fracstep = dc_iscale; 
  frac = dc_texturemid + (dc_yl-centery)*fracstep; 

  // Here we do an additional index re-mapping.
  do 
  {
    // Translation tables are used
    //  to map certain colorramps to other ones,
    //  used with PLAY sprites.
    // Thus the "green" ramp of the player 0 sprite
    //  is mapped to gray, red, black/indigo. 
    *dest = dc_colormap[dc_translation[dc_source[frac>>FRACBITS]]];
    dest += SCREENWIDTH;

    frac += fracstep; 
  } while (count--); 
} 




//
// R_InitTranslationTables
// Creates the translation tables to map
//  the green color ramp to gray, brown, red.
// Assumes a given structure of the PLAYPAL.
// Could be read from a lump instead.
//
void R_InitTranslationTables (void)
{
  int		i;

  translationtables = (byte *)Z_Malloc (256*3+255, PU_STATIC, 0);
  translationtables = (byte *)(( (uintptr_t)translationtables + 255 )& ~255);

  // translate just the 16 green colors
  for (i=0 ; i<256 ; i++)
  {
    if (i >= 0x70 && i<= 0x7f)
    {
      // map green ramp to gray, brown, red
      translationtables[i]      =(byte)( 0x60 + (i&0xf));
      translationtables [i+256] =(byte)( 0x40 + (i&0xf));
      translationtables [i+512] =(byte)( 0x20 + (i&0xf));
    }
    else
    {
      // Keep all other colors as is.
      translationtables[i] = translationtables[i+256] = translationtables[i+512] = (byte)i;
    }
  }
}




//
// R_DrawSpan 
// With DOOM style restrictions on view orientation,
//  the floors and ceilings consist of horizontal slices
//  or spans with constant z depth.
// However, rotation around the world z axis is possible,
//  thus this mapping, while simpler and faster than
//  perspective correct texture mapping, has to traverse
//  the texture at an angle in all but a few cases.
// In consequence, flats are not stored by column (like walls),
//  and the inner loop has to step in texture space u and v.
//
int			ds_y; 
int			ds_x1; 
int			ds_x2;

const lighttable_t*	ds_colormap; 

fixed_t			ds_xfrac; 
fixed_t			ds_yfrac; 
fixed_t			ds_xstep; 
fixed_t			ds_ystep;

// start of a 64*64 tile image 
const byte*			ds_source;	

// just for profiling
int			dscount;


//
// Draws the actual span.
void R_DrawSpan (void) 
{ 
  fixed_t		xfrac;
  fixed_t		yfrac; 
  byte*		dest; 
  int			count;
  int			spot; 

#ifdef RANGECHECK 
  if (ds_x2 < ds_x1
    || ds_x1<0
    || ds_x2>=SCREENWIDTH  
    || (unsigned)ds_y>SCREENHEIGHT)
  {
    I_Error( "R_DrawSpan: %i to %i at %i",
      ds_x1,ds_x2,ds_y);
  }
  //	dscount++; 
#endif 

  xfrac = ds_xfrac; 
  yfrac = ds_yfrac; 

  dest = ylookup[ds_y] + columnofs[ds_x1];

  // We do not check for zero spans here?
  count = ds_x2 - ds_x1; 

  do 
  {
    // Current texture index in u,v.
    spot = ((yfrac>>(16-6))&(63*64)) + ((xfrac>>16)&63);

    // Lookup pixel from flat texture tile,
    //  re-index using light/colormap.
    *dest++ = ds_colormap[ds_source[spot]];

    // Next step in u,v.
    xfrac += ds_xstep; 
    yfrac += ds_ystep;

  } while (count--); 
}

//
// R_InitBuffer 
// Creats lookup tables that avoid
//  multiplies and other hazzles
//  for getting the framebuffer address
//  of a pixel to draw.
//
void R_InitBuffer( int	width,  int	height ) 
{ 
  int		i; 

  // Handle resize,
  //  e.g. smaller view windows
  //  with border and/or status bar.
  viewwindowx = (SCREENWIDTH-width) >> 1; 

  // Column offset. For windows.
  for (i=0 ; i<width ; i++) 
    columnofs[i] = viewwindowx + i;

  // Samw with base row offset.
  if (width == SCREENWIDTH) 
    viewwindowy = 0; 
  else 
    viewwindowy = (SCREENHEIGHT-SBARHEIGHT-height) >> 1; 

  // Preclaculate all row offsets.
  for (i=0 ; i<height ; i++) 
    ylookup[i] = screens[0] + (i+viewwindowy)*SCREENWIDTH; 
} 



//
// Copy a screen buffer.
//
void R_VideoErase ( unsigned ofs, int count ) 
{ 
  // LFB copy.
  // This might not be a good idea if memcpy
  //  is not optiomal, e.g. byte by byte on
  //  a 32bit CPU, as GNU GCC/Linux libc did
  //  at one point.
  if(count <0)return;//hack
  memcpy (screens[0]+ofs, screens[1]+ofs, count); 
} 


//
// R_DrawViewBorder
// Draws the border around the view
//  for different size windows?
//
void V_MarkRect( int x,  int y, int	width,
                int		height ); 

void R_DrawViewBorder (void) 
{ 
  int		top;
  int		side;
  int		ofs;
  int		i; 

  if (scaledviewwidth == SCREENWIDTH) 
    return; 

  top = ((SCREENHEIGHT-SBARHEIGHT)-viewheight)/2; 
  side = (SCREENWIDTH-scaledviewwidth)/2; 

  // copy top and one line of left side 
  R_VideoErase (0, top*SCREENWIDTH+side); 

  // copy one line of right side and bottom 
  ofs = (viewheight+top)*SCREENWIDTH-side; 
  R_VideoErase (ofs, top*SCREENWIDTH+side); 

  // copy sides using wraparound 
  ofs = top*SCREENWIDTH + SCREENWIDTH-side; 
  side <<= 1;

  for (i=1 ; i<viewheight ; i++) 
  { 
    R_VideoErase (ofs, side); 
    ofs += SCREENWIDTH; 
  } 

  // ? 
  V_MarkRect (0,0,SCREENWIDTH, SCREENHEIGHT-SBARHEIGHT); 
}