mirror of
https://github.com/id-Software/DOOM-iOS.git
synced 2026-03-20 08:59:41 +01:00
The DOOM Classic for iPhone 1.0 source as released on November 3, 2009
This commit is contained in:
Travis Bradshaw
655
code/prboom/r_main.c
Normal file
655
code/prboom/r_main.c
Normal file
@@ -0,0 +1,655 @@
|
||||
/* Emacs style mode select -*- C++ -*-
|
||||
*-----------------------------------------------------------------------------
|
||||
*
|
||||
*
|
||||
* PrBoom: a Doom port merged with LxDoom and LSDLDoom
|
||||
* based on BOOM, a modified and improved DOOM engine
|
||||
* Copyright (C) 1999 by
|
||||
* id Software, Chi Hoang, Lee Killough, Jim Flynn, Rand Phares, Ty Halderman
|
||||
* Copyright (C) 1999-2000 by
|
||||
* Jess Haas, Nicolas Kalkhof, Colin Phipps, Florian Schulze
|
||||
* Copyright 2005, 2006 by
|
||||
* Florian Schulze, Colin Phipps, Neil Stevens, Andrey Budko
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
|
||||
* 02111-1307, USA.
|
||||
*
|
||||
* DESCRIPTION:
|
||||
* Rendering main loop and setup functions,
|
||||
* utility functions (BSP, geometry, trigonometry).
|
||||
* See tables.c, too.
|
||||
*
|
||||
*-----------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
#endif
|
||||
#ifdef USE_SDL
|
||||
#include "SDL.h"
|
||||
#endif
|
||||
#include "doomstat.h"
|
||||
#include "d_net.h"
|
||||
#include "w_wad.h"
|
||||
#include "r_main.h"
|
||||
#include "r_things.h"
|
||||
#include "r_plane.h"
|
||||
#include "r_bsp.h"
|
||||
#include "r_draw.h"
|
||||
#include "m_bbox.h"
|
||||
#include "r_sky.h"
|
||||
#include "v_video.h"
|
||||
#include "lprintf.h"
|
||||
#include "st_stuff.h"
|
||||
#include "i_main.h"
|
||||
#include "i_system.h"
|
||||
#include "g_game.h"
|
||||
#include "r_demo.h"
|
||||
#include "r_fps.h"
|
||||
|
||||
// Fineangles in the SCREENWIDTH wide window.
|
||||
#define FIELDOFVIEW 2048
|
||||
|
||||
// killough: viewangleoffset is a legacy from the pre-v1.2 days, when Doom
|
||||
// had Left/Mid/Right viewing. +/-ANG90 offsets were placed here on each
|
||||
// node, by d_net.c, to set up a L/M/R session.
|
||||
|
||||
int viewangleoffset;
|
||||
int validcount = 1; // increment every time a check is made
|
||||
const lighttable_t *fixedcolormap;
|
||||
int centerx, centery;
|
||||
fixed_t centerxfrac, centeryfrac;
|
||||
fixed_t viewheightfrac; //e6y: for correct clipping of things
|
||||
fixed_t projection;
|
||||
// proff 11/06/98: Added for high-res
|
||||
fixed_t projectiony;
|
||||
fixed_t viewx, viewy, viewz;
|
||||
angle_t viewangle;
|
||||
fixed_t viewcos, viewsin;
|
||||
player_t *viewplayer;
|
||||
extern lighttable_t **walllights;
|
||||
|
||||
static mobj_t *oviewer;
|
||||
|
||||
//
|
||||
// precalculated math tables
|
||||
//
|
||||
|
||||
angle_t clipangle;
|
||||
|
||||
// The viewangletox[viewangle + FINEANGLES/4] lookup
|
||||
// maps the visible view angles to screen X coordinates,
|
||||
// flattening the arc to a flat projection plane.
|
||||
// There will be many angles mapped to the same X.
|
||||
|
||||
int viewangletox[FINEANGLES/2];
|
||||
|
||||
// The xtoviewangleangle[] table maps a screen pixel
|
||||
// to the lowest viewangle that maps back to x ranges
|
||||
// from clipangle to -clipangle.
|
||||
|
||||
angle_t xtoviewangle[MAX_SCREENWIDTH+1]; // killough 2/8/98
|
||||
|
||||
// killough 3/20/98: Support dynamic colormaps, e.g. deep water
|
||||
// killough 4/4/98: support dynamic number of them as well
|
||||
|
||||
int numcolormaps;
|
||||
const lighttable_t *(*c_zlight)[LIGHTLEVELS][MAXLIGHTZ];
|
||||
const lighttable_t *(*zlight)[MAXLIGHTZ];
|
||||
const lighttable_t *fullcolormap;
|
||||
const lighttable_t **colormaps;
|
||||
|
||||
// killough 3/20/98, 4/4/98: end dynamic colormaps
|
||||
|
||||
int extralight; // bumped light from gun blasts
|
||||
|
||||
//
|
||||
// R_PointOnSide
|
||||
// Traverse BSP (sub) tree,
|
||||
// check point against partition plane.
|
||||
// Returns side 0 (front) or 1 (back).
|
||||
//
|
||||
// killough 5/2/98: reformatted
|
||||
//
|
||||
|
||||
PUREFUNC int R_PointOnSide(fixed_t x, fixed_t y, const node_t *node)
|
||||
{
|
||||
if (!node->dx)
|
||||
return x <= node->x ? node->dy > 0 : node->dy < 0;
|
||||
|
||||
if (!node->dy)
|
||||
return y <= node->y ? node->dx < 0 : node->dx > 0;
|
||||
|
||||
x -= node->x;
|
||||
y -= node->y;
|
||||
|
||||
// Try to quickly decide by looking at sign bits.
|
||||
if ((node->dy ^ node->dx ^ x ^ y) < 0)
|
||||
return (node->dy ^ x) < 0; // (left is negative)
|
||||
return FixedMul(y, node->dx>>FRACBITS) >= FixedMul(node->dy>>FRACBITS, x);
|
||||
}
|
||||
|
||||
// killough 5/2/98: reformatted
|
||||
|
||||
PUREFUNC int R_PointOnSegSide(fixed_t x, fixed_t y, const seg_t *line)
|
||||
{
|
||||
fixed_t lx = line->v1->x;
|
||||
fixed_t ly = line->v1->y;
|
||||
fixed_t ldx = line->v2->x - lx;
|
||||
fixed_t ldy = line->v2->y - ly;
|
||||
|
||||
if (!ldx)
|
||||
return x <= lx ? ldy > 0 : ldy < 0;
|
||||
|
||||
if (!ldy)
|
||||
return y <= ly ? ldx < 0 : ldx > 0;
|
||||
|
||||
x -= lx;
|
||||
y -= ly;
|
||||
|
||||
// Try to quickly decide by looking at sign bits.
|
||||
if ((ldy ^ ldx ^ x ^ y) < 0)
|
||||
return (ldy ^ x) < 0; // (left is negative)
|
||||
return FixedMul(y, ldx>>FRACBITS) >= FixedMul(ldy>>FRACBITS, x);
|
||||
}
|
||||
|
||||
//
|
||||
// R_PointToAngle
|
||||
// To get a global angle from cartesian coordinates,
|
||||
// the coordinates are flipped until they are in
|
||||
// the first octant of the coordinate system, then
|
||||
// the y (<=x) is scaled and divided by x to get a
|
||||
// tangent (slope) value which is looked up in the
|
||||
// tantoangle[] table. The +1 size of tantoangle[]
|
||||
// is to handle the case when x==y without additional
|
||||
// checking.
|
||||
//
|
||||
// killough 5/2/98: reformatted, cleaned up
|
||||
|
||||
#include <math.h>
|
||||
|
||||
angle_t R_PointToAngle(fixed_t x, fixed_t y)
|
||||
{
|
||||
#if 0
|
||||
// JDC: the oldresult case only hit 10%, making it a net loss.
|
||||
// JDC: added parenthesis to force constant evaluation
|
||||
return (int)(atan2(y-viewy, x-viewx) * (ANG180/M_PI) );
|
||||
#else
|
||||
static fixed_t oldx, oldy;
|
||||
static angle_t oldresult;
|
||||
|
||||
x -= viewx; y -= viewy;
|
||||
|
||||
if ( /* !render_precise && */
|
||||
// e6y: here is where "slime trails" can SOMETIMES occur
|
||||
#ifdef GL_DOOM
|
||||
(V_GetMode() != VID_MODEGL) &&
|
||||
#endif
|
||||
(x < INT_MAX/4 && x > -INT_MAX/4 && y < INT_MAX/4 && y > -INT_MAX/4)
|
||||
)
|
||||
{
|
||||
// old R_PointToAngle
|
||||
return (x || y) ?
|
||||
x >= 0 ?
|
||||
y >= 0 ?
|
||||
(x > y) ? tantoangle[SlopeDiv(y,x)] : // octant 0
|
||||
ANG90-1-tantoangle[SlopeDiv(x,y)] : // octant 1
|
||||
x > (y = -y) ? 0-tantoangle[SlopeDiv(y,x)] : // octant 8
|
||||
ANG270+tantoangle[SlopeDiv(x,y)] : // octant 7
|
||||
y >= 0 ? (x = -x) > y ? ANG180-1-tantoangle[SlopeDiv(y,x)] : // octant 3
|
||||
ANG90 + tantoangle[SlopeDiv(x,y)] : // octant 2
|
||||
(x = -x) > (y = -y) ? ANG180+tantoangle[ SlopeDiv(y,x)] : // octant 4
|
||||
ANG270-1-tantoangle[SlopeDiv(x,y)] : // octant 5
|
||||
0;
|
||||
}
|
||||
|
||||
// R_PointToAngleEx merged into R_PointToAngle
|
||||
// e6y: The precision of the code above is abysmal so use the CRT atan2 function instead!
|
||||
if (oldx != x || oldy != y)
|
||||
{
|
||||
oldx = x;
|
||||
oldy = y;
|
||||
oldresult = (int)(atan2(y, x) * ANG180/M_PI );
|
||||
}
|
||||
return oldresult;
|
||||
#endif
|
||||
}
|
||||
|
||||
angle_t R_PointToAngle2(fixed_t viewx, fixed_t viewy, fixed_t x, fixed_t y)
|
||||
{
|
||||
return (y -= viewy, (x -= viewx) || y) ?
|
||||
x >= 0 ?
|
||||
y >= 0 ?
|
||||
(x > y) ? tantoangle[SlopeDiv(y,x)] : // octant 0
|
||||
ANG90-1-tantoangle[SlopeDiv(x,y)] : // octant 1
|
||||
x > (y = -y) ? 0-tantoangle[SlopeDiv(y,x)] : // octant 8
|
||||
ANG270+tantoangle[SlopeDiv(x,y)] : // octant 7
|
||||
y >= 0 ? (x = -x) > y ? ANG180-1-tantoangle[SlopeDiv(y,x)] : // octant 3
|
||||
ANG90 + tantoangle[SlopeDiv(x,y)] : // octant 2
|
||||
(x = -x) > (y = -y) ? ANG180+tantoangle[ SlopeDiv(y,x)] : // octant 4
|
||||
ANG270-1-tantoangle[SlopeDiv(x,y)] : // octant 5
|
||||
0;
|
||||
}
|
||||
|
||||
//
|
||||
// R_InitTextureMapping
|
||||
//
|
||||
// killough 5/2/98: reformatted
|
||||
|
||||
static void R_InitTextureMapping (void)
|
||||
{
|
||||
register int i,x;
|
||||
fixed_t focallength;
|
||||
|
||||
// Use tangent table to generate viewangletox:
|
||||
// viewangletox will give the next greatest x
|
||||
// after the view angle.
|
||||
//
|
||||
// Calc focallength
|
||||
// so FIELDOFVIEW angles covers SCREENWIDTH.
|
||||
|
||||
focallength = FixedDiv(centerxfrac, finetangent[FINEANGLES/4+FIELDOFVIEW/2]);
|
||||
|
||||
for (i=0 ; i<FINEANGLES/2 ; i++)
|
||||
{
|
||||
int t;
|
||||
if (finetangent[i] > FRACUNIT*2)
|
||||
t = -1;
|
||||
else
|
||||
if (finetangent[i] < -FRACUNIT*2)
|
||||
t = viewwidth+1;
|
||||
else
|
||||
{
|
||||
t = FixedMul(finetangent[i], focallength);
|
||||
t = (centerxfrac - t + FRACUNIT-1) >> FRACBITS;
|
||||
if (t < -1)
|
||||
t = -1;
|
||||
else
|
||||
if (t > viewwidth+1)
|
||||
t = viewwidth+1;
|
||||
}
|
||||
viewangletox[i] = t;
|
||||
}
|
||||
|
||||
// Scan viewangletox[] to generate xtoviewangle[]:
|
||||
// xtoviewangle will give the smallest view angle
|
||||
// that maps to x.
|
||||
|
||||
for (x=0; x<=viewwidth; x++)
|
||||
{
|
||||
for (i=0; viewangletox[i] > x; i++)
|
||||
;
|
||||
xtoviewangle[x] = (i<<ANGLETOFINESHIFT)-ANG90;
|
||||
}
|
||||
|
||||
// Take out the fencepost cases from viewangletox.
|
||||
for (i=0; i<FINEANGLES/2; i++)
|
||||
if (viewangletox[i] == -1)
|
||||
viewangletox[i] = 0;
|
||||
else
|
||||
if (viewangletox[i] == viewwidth+1)
|
||||
viewangletox[i] = viewwidth;
|
||||
|
||||
clipangle = xtoviewangle[0];
|
||||
}
|
||||
|
||||
//
|
||||
// R_InitLightTables
|
||||
//
|
||||
|
||||
#define DISTMAP 2
|
||||
|
||||
static void R_InitLightTables (void)
|
||||
{
|
||||
int i;
|
||||
|
||||
// killough 4/4/98: dynamic colormaps
|
||||
c_zlight = malloc(sizeof(*c_zlight) * numcolormaps);
|
||||
|
||||
// Calculate the light levels to use
|
||||
// for each level / distance combination.
|
||||
for (i=0; i< LIGHTLEVELS; i++)
|
||||
{
|
||||
int j, startmap = ((LIGHTLEVELS-1-i)*2)*NUMCOLORMAPS/LIGHTLEVELS;
|
||||
for (j=0; j<MAXLIGHTZ; j++)
|
||||
{
|
||||
// CPhipps - use 320 here instead of SCREENWIDTH, otherwise hires is
|
||||
// brighter than normal res
|
||||
int scale = FixedDiv ((320/2*FRACUNIT), (j+1)<<LIGHTZSHIFT);
|
||||
int t, level = startmap - (scale >>= LIGHTSCALESHIFT)/DISTMAP;
|
||||
|
||||
if (level < 0)
|
||||
level = 0;
|
||||
else
|
||||
if (level >= NUMCOLORMAPS)
|
||||
level = NUMCOLORMAPS-1;
|
||||
|
||||
// killough 3/20/98: Initialize multiple colormaps
|
||||
level *= 256;
|
||||
for (t=0; t<numcolormaps; t++) // killough 4/4/98
|
||||
c_zlight[t][i][j] = colormaps[t] + level;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// R_SetViewSize
|
||||
// Do not really change anything here,
|
||||
// because it might be in the middle of a refresh.
|
||||
// The change will take effect next refresh.
|
||||
//
|
||||
|
||||
boolean setsizeneeded;
|
||||
int setblocks;
|
||||
|
||||
void R_SetViewSize(int blocks)
|
||||
{
|
||||
setsizeneeded = true;
|
||||
setblocks = blocks;
|
||||
}
|
||||
|
||||
//
|
||||
// R_ExecuteSetViewSize
|
||||
//
|
||||
|
||||
void R_ExecuteSetViewSize (void)
|
||||
{
|
||||
int i;
|
||||
|
||||
setsizeneeded = false;
|
||||
|
||||
if (setblocks == 11)
|
||||
{
|
||||
scaledviewwidth = SCREENWIDTH;
|
||||
viewheight = SCREENHEIGHT;
|
||||
}
|
||||
// proff 09/24/98: Added for high-res
|
||||
else if (setblocks == 10)
|
||||
{
|
||||
scaledviewwidth = SCREENWIDTH;
|
||||
viewheight = SCREENHEIGHT-ST_SCALED_HEIGHT;
|
||||
}
|
||||
else
|
||||
{
|
||||
// proff 08/17/98: Changed for high-res
|
||||
scaledviewwidth = setblocks*SCREENWIDTH/10;
|
||||
viewheight = (setblocks*(SCREENHEIGHT-ST_SCALED_HEIGHT)/10) & ~7;
|
||||
}
|
||||
|
||||
viewwidth = scaledviewwidth;
|
||||
|
||||
viewheightfrac = viewheight<<FRACBITS;//e6y
|
||||
|
||||
centery = viewheight/2;
|
||||
centerx = viewwidth/2;
|
||||
centerxfrac = centerx<<FRACBITS;
|
||||
centeryfrac = centery<<FRACBITS;
|
||||
projection = centerxfrac;
|
||||
// proff 11/06/98: Added for high-res
|
||||
projectiony = ((SCREENHEIGHT * centerx * 320) / 200) / SCREENWIDTH * FRACUNIT;
|
||||
|
||||
R_InitBuffer (scaledviewwidth, viewheight);
|
||||
|
||||
R_InitTextureMapping();
|
||||
|
||||
// psprite scales
|
||||
// proff 08/17/98: Changed for high-res
|
||||
pspritescale = FRACUNIT*viewwidth/320;
|
||||
pspriteiscale = FRACUNIT*320/viewwidth;
|
||||
// proff 11/06/98: Added for high-res
|
||||
pspriteyscale = (((SCREENHEIGHT*viewwidth)/SCREENWIDTH) << FRACBITS) / 200;
|
||||
|
||||
// thing clipping
|
||||
for (i=0 ; i<viewwidth ; i++)
|
||||
screenheightarray[i] = viewheight;
|
||||
|
||||
// planes
|
||||
for (i=0 ; i<viewheight ; i++)
|
||||
{ // killough 5/2/98: reformatted
|
||||
fixed_t dy = D_abs(((i-viewheight/2)<<FRACBITS)+FRACUNIT/2);
|
||||
// proff 08/17/98: Changed for high-res
|
||||
yslope[i] = FixedDiv(projectiony, dy);
|
||||
}
|
||||
|
||||
for (i=0 ; i<viewwidth ; i++)
|
||||
{
|
||||
fixed_t cosadj = D_abs(finecosine[xtoviewangle[i]>>ANGLETOFINESHIFT]);
|
||||
distscale[i] = FixedDiv(FRACUNIT,cosadj);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
//
|
||||
// R_Init
|
||||
//
|
||||
|
||||
extern int screenblocks;
|
||||
|
||||
void R_Init (void)
|
||||
{
|
||||
// CPhipps - R_DrawColumn isn't constant anymore, so must
|
||||
// initialise in code
|
||||
// current column draw function
|
||||
lprintf(LO_INFO, "\nR_LoadTrigTables: ");
|
||||
R_LoadTrigTables();
|
||||
lprintf(LO_INFO, "\nR_InitData: ");
|
||||
R_InitData();
|
||||
R_SetViewSize(screenblocks);
|
||||
lprintf(LO_INFO, "\nR_Init: R_InitPlanes ");
|
||||
R_InitPlanes();
|
||||
lprintf(LO_INFO, "R_InitLightTables ");
|
||||
R_InitLightTables();
|
||||
lprintf(LO_INFO, "R_InitSkyMap ");
|
||||
R_InitSkyMap();
|
||||
lprintf(LO_INFO, "R_InitTranslationsTables ");
|
||||
R_InitTranslationTables();
|
||||
lprintf(LO_INFO, "R_InitPatches ");
|
||||
R_InitPatches();
|
||||
}
|
||||
|
||||
//
|
||||
// R_PointInSubsector
|
||||
//
|
||||
// killough 5/2/98: reformatted, cleaned up
|
||||
|
||||
subsector_t *R_PointInSubsector(fixed_t x, fixed_t y)
|
||||
{
|
||||
int nodenum = numnodes-1;
|
||||
|
||||
// special case for trivial maps (single subsector, no nodes)
|
||||
if (numnodes == 0)
|
||||
return subsectors;
|
||||
|
||||
while (!(nodenum & NF_SUBSECTOR))
|
||||
nodenum = nodes[nodenum].children[R_PointOnSide(x, y, nodes+nodenum)];
|
||||
return &subsectors[nodenum & ~NF_SUBSECTOR];
|
||||
}
|
||||
|
||||
//
|
||||
// R_SetupFrame
|
||||
//
|
||||
|
||||
static void R_SetupFrame (player_t *player)
|
||||
{
|
||||
int cm;
|
||||
boolean NoInterpolate = paused || (menuactive && !demoplayback);
|
||||
|
||||
viewplayer = player;
|
||||
|
||||
if (player->mo != oviewer || NoInterpolate)
|
||||
{
|
||||
R_ResetViewInterpolation ();
|
||||
oviewer = player->mo;
|
||||
}
|
||||
tic_vars.frac = I_GetTimeFrac ();
|
||||
if (NoInterpolate)
|
||||
tic_vars.frac = FRACUNIT;
|
||||
R_InterpolateView (player, tic_vars.frac);
|
||||
|
||||
extralight = player->extralight;
|
||||
|
||||
viewsin = finesine[viewangle>>ANGLETOFINESHIFT];
|
||||
viewcos = finecosine[viewangle>>ANGLETOFINESHIFT];
|
||||
|
||||
R_DoInterpolations(tic_vars.frac);
|
||||
|
||||
// killough 3/20/98, 4/4/98: select colormap based on player status
|
||||
|
||||
if (player->mo->subsector->sector->heightsec != -1)
|
||||
{
|
||||
const sector_t *s = player->mo->subsector->sector->heightsec + sectors;
|
||||
cm = viewz < s->floorheight ? s->bottommap : viewz > s->ceilingheight ?
|
||||
s->topmap : s->midmap;
|
||||
if (cm < 0 || cm > numcolormaps)
|
||||
cm = 0;
|
||||
}
|
||||
else
|
||||
cm = 0;
|
||||
|
||||
fullcolormap = colormaps[cm];
|
||||
zlight = c_zlight[cm];
|
||||
|
||||
if (player->fixedcolormap)
|
||||
{
|
||||
fixedcolormap = fullcolormap // killough 3/20/98: use fullcolormap
|
||||
+ player->fixedcolormap*256*sizeof(lighttable_t);
|
||||
}
|
||||
else
|
||||
fixedcolormap = 0;
|
||||
|
||||
validcount++;
|
||||
}
|
||||
|
||||
int autodetect_hom = 0; // killough 2/7/98: HOM autodetection flag
|
||||
|
||||
//
|
||||
// R_ShowStats
|
||||
//
|
||||
int rendered_visplanes, rendered_segs, rendered_vissprites;
|
||||
boolean rendering_stats;
|
||||
|
||||
static void R_ShowStats(void)
|
||||
{
|
||||
//e6y
|
||||
#if USE_SDL
|
||||
static unsigned int FPS_SavedTick = 0, FPS_FrameCount = 0;
|
||||
unsigned int tick = SDL_GetTicks();
|
||||
FPS_FrameCount++;
|
||||
if(tick >= FPS_SavedTick + 1000)
|
||||
{
|
||||
doom_printf((V_GetMode() == VID_MODEGL)
|
||||
?"Frame rate %d fps\nWalls %d, Flats %d, Sprites %d"
|
||||
:"Frame rate %d fps\nSegs %d, Visplanes %d, Sprites %d",
|
||||
1000 * FPS_FrameCount / (tick - FPS_SavedTick), rendered_segs,
|
||||
rendered_visplanes, rendered_vissprites);
|
||||
FPS_SavedTick = tick;
|
||||
FPS_FrameCount = 0;
|
||||
}
|
||||
#else
|
||||
|
||||
#define KEEPTIMES 10
|
||||
static int keeptime[KEEPTIMES], showtime;
|
||||
int now = I_GetTime();
|
||||
|
||||
if (now - showtime > 35) {
|
||||
doom_printf((V_GetMode() == VID_MODEGL)
|
||||
?"Frame rate %d fps\nWalls %d, Flats %d, Sprites %d"
|
||||
:"Frame rate %d fps\nSegs %d, Visplanes %d, Sprites %d",
|
||||
(35*KEEPTIMES)/(now - keeptime[0]), rendered_segs,
|
||||
rendered_visplanes, rendered_vissprites);
|
||||
showtime = now;
|
||||
}
|
||||
memmove(keeptime, keeptime+1, sizeof(keeptime[0]) * (KEEPTIMES-1));
|
||||
keeptime[KEEPTIMES-1] = now;
|
||||
|
||||
#endif //e6y
|
||||
}
|
||||
|
||||
//
|
||||
// R_RenderView
|
||||
//
|
||||
void R_RenderPlayerView (player_t* player)
|
||||
{
|
||||
R_SetupFrame (player);
|
||||
|
||||
// Clear buffers.
|
||||
R_ClearClipSegs ();
|
||||
R_ClearDrawSegs ();
|
||||
R_ClearPlanes ();
|
||||
R_ClearSprites ();
|
||||
|
||||
rendered_segs = rendered_visplanes = 0;
|
||||
if (V_GetMode() == VID_MODEGL)
|
||||
{
|
||||
#ifdef GL_DOOM
|
||||
// proff 11/99: clear buffers
|
||||
gld_InitDrawScene();
|
||||
// proff 11/99: switch to perspective mode
|
||||
gld_StartDrawScene();
|
||||
#endif
|
||||
} else {
|
||||
if (autodetect_hom)
|
||||
{ // killough 2/10/98: add flashing red HOM indicators
|
||||
unsigned char color=(gametic % 20) < 9 ? 0xb0 : 0;
|
||||
V_FillRect(0, viewwindowx, viewwindowy, viewwidth, viewheight, color);
|
||||
R_DrawViewBorder();
|
||||
}
|
||||
}
|
||||
|
||||
// check for new console commands.
|
||||
#ifdef HAVE_NET
|
||||
NetUpdate ();
|
||||
#endif
|
||||
|
||||
// The head node is the last node output.
|
||||
R_RenderBSPNode (numnodes-1);
|
||||
R_ResetColumnBuffer();
|
||||
|
||||
// Check for new console commands.
|
||||
#ifdef HAVE_NET
|
||||
NetUpdate ();
|
||||
#endif
|
||||
|
||||
if (V_GetMode() != VID_MODEGL)
|
||||
R_DrawPlanes ();
|
||||
|
||||
// Check for new console commands.
|
||||
#ifdef HAVE_NET
|
||||
NetUpdate ();
|
||||
#endif
|
||||
|
||||
if (V_GetMode() != VID_MODEGL) {
|
||||
R_DrawMasked ();
|
||||
R_ResetColumnBuffer();
|
||||
}
|
||||
|
||||
// Check for new console commands.
|
||||
#ifdef HAVE_NET
|
||||
NetUpdate ();
|
||||
#endif
|
||||
|
||||
if (V_GetMode() == VID_MODEGL) {
|
||||
#ifdef GL_DOOM
|
||||
// proff 11/99: draw the scene
|
||||
gld_DrawScene(player);
|
||||
// proff 11/99: finishing off
|
||||
gld_EndDrawScene();
|
||||
#endif
|
||||
}
|
||||
|
||||
if (rendering_stats) R_ShowStats();
|
||||
|
||||
R_RestoreInterpolations();
|
||||
}
|
||||
Reference in New Issue
Block a user