mirror of
https://github.com/Rockbox/rockbox.git
synced 2025-10-14 10:37:38 -04:00
Patch #2969 - Doom! Currently only working on the H300.
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@9312 a1c6a512-1295-4272-9138-f99709370657
This commit is contained in:
Dave Chapman
parent
fff7d6157d
commit
47f4a458d6
130 changed files with 65584 additions and 1 deletions
531
apps/plugins/doom/r_main.c
Normal file
531
apps/plugins/doom/r_main.c
Normal file
|
|
@ -0,0 +1,531 @@
|
|||
/* 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
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
*-----------------------------------------------------------------------------*/
|
||||
|
||||
#include "doomstat.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 "i_system.h"
|
||||
//#include "lprintf.h"
|
||||
#include "st_stuff.h"
|
||||
#include "rockmacros.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
|
||||
lighttable_t *fixedcolormap;
|
||||
int centerx IBSS_ATTR;
|
||||
int centery IBSS_ATTR;
|
||||
fixed_t centerxfrac, centeryfrac;
|
||||
fixed_t projection;
|
||||
fixed_t viewx, viewy, viewz;
|
||||
angle_t viewangle;
|
||||
fixed_t viewcos, viewsin;
|
||||
player_t *viewplayer;
|
||||
extern lighttable_t **walllights;
|
||||
|
||||
//
|
||||
// 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[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;
|
||||
lighttable_t *(*c_scalelight)[LIGHTLEVELS][MAXLIGHTSCALE];
|
||||
lighttable_t *(*c_zlight)[LIGHTLEVELS][MAXLIGHTZ];
|
||||
lighttable_t *(*scalelight)[MAXLIGHTSCALE];
|
||||
lighttable_t *(*zlight)[MAXLIGHTZ];
|
||||
lighttable_t *fullcolormap;
|
||||
lighttable_t **colormaps;
|
||||
|
||||
// killough 3/20/98, 4/4/98: end dynamic colormaps
|
||||
|
||||
int extralight; // bumped light from gun blasts
|
||||
|
||||
void (*colfunc)(void);
|
||||
|
||||
//
|
||||
// R_PointOnSide
|
||||
// Traverse BSP (sub) tree,
|
||||
// check point against partition plane.
|
||||
// Returns side 0 (front) or 1 (back).
|
||||
//
|
||||
// killough 5/2/98: reformatted
|
||||
//
|
||||
|
||||
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
|
||||
|
||||
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
|
||||
|
||||
angle_t R_PointToAngle(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;
|
||||
}
|
||||
|
||||
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
|
||||
// Only inits the zlight table,
|
||||
// because the scalelight table changes with view size.
|
||||
//
|
||||
|
||||
#define DISTMAP 2
|
||||
|
||||
void R_InitLightTables (void)
|
||||
{
|
||||
int i;
|
||||
|
||||
// killough 4/4/98: dynamic colormaps
|
||||
c_zlight = malloc(sizeof(*c_zlight) * numcolormaps);
|
||||
c_scalelight = malloc(sizeof(*c_scalelight) * 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;
|
||||
}
|
||||
else
|
||||
{
|
||||
scaledviewwidth = setblocks*32;
|
||||
viewheight = (setblocks*168/10)&~7;
|
||||
}
|
||||
|
||||
viewwidth = scaledviewwidth;
|
||||
|
||||
centery = viewheight/2;
|
||||
centerx = viewwidth/2;
|
||||
centerxfrac = centerx<<FRACBITS;
|
||||
centeryfrac = centery<<FRACBITS;
|
||||
projection = centerxfrac;
|
||||
|
||||
R_InitBuffer (scaledviewwidth, viewheight);
|
||||
|
||||
R_InitTextureMapping();
|
||||
|
||||
// psprite scales
|
||||
pspritescale = FRACUNIT*viewwidth/SCREENWIDTH;
|
||||
pspriteiscale = FRACUNIT*SCREENWIDTH/viewwidth;
|
||||
|
||||
// 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);
|
||||
yslope[i] = FixedDiv ( (viewwidth)/2*FRACUNIT, dy);
|
||||
}
|
||||
|
||||
for (i=0 ; i<viewwidth ; i++)
|
||||
{
|
||||
fixed_t cosadj = D_abs(finecosine[xtoviewangle[i]>>ANGLETOFINESHIFT]);
|
||||
distscale[i] = FixedDiv(FRACUNIT,cosadj);
|
||||
}
|
||||
|
||||
// Calculate the light levels to use
|
||||
// for each level / scale combination.
|
||||
for (i=0; i<LIGHTLEVELS; i++)
|
||||
{
|
||||
int j, startmap = ((LIGHTLEVELS-1-i)*2)*NUMCOLORMAPS/LIGHTLEVELS;
|
||||
for (j=0 ; j<MAXLIGHTSCALE ; 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;
|
||||
|
||||
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_scalelight[t][i][j] = colormaps[t] + level;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// R_Init
|
||||
//
|
||||
|
||||
extern int screenblocks;
|
||||
|
||||
void R_Init (void)
|
||||
{
|
||||
// CPhipps - R_DrawColumn isn't constant anymore, so must
|
||||
// initialise in code
|
||||
colfunc = R_DrawColumn; // current column draw function
|
||||
if (SCREENWIDTH<320)
|
||||
I_Error("R_Init: Screenwidth(%d) < 320",SCREENWIDTH);
|
||||
#if 1
|
||||
printf("\nR_LoadTrigTables: ");
|
||||
R_LoadTrigTables();
|
||||
#endif
|
||||
printf("\nR_InitData: ");
|
||||
R_InitData();
|
||||
R_SetViewSize(screenblocks);
|
||||
printf("\nR_Init: R_InitPlanes ");
|
||||
R_InitPlanes();
|
||||
printf("R_InitLightTables ");
|
||||
R_InitLightTables();
|
||||
printf("R_InitSkyMap ");
|
||||
R_InitSkyMap();
|
||||
printf("R_InitTranslationsTables ");
|
||||
R_InitTranslationTables();
|
||||
}
|
||||
|
||||
//
|
||||
// R_PointInSubsector
|
||||
//
|
||||
// killough 5/2/98: reformatted, cleaned up
|
||||
|
||||
subsector_t *R_PointInSubsector(fixed_t x, fixed_t y)
|
||||
{
|
||||
int nodenum = numnodes-1;
|
||||
while (!(nodenum & NF_SUBSECTOR))
|
||||
nodenum = nodes[nodenum].children[R_PointOnSide(x, y, nodes+nodenum)];
|
||||
return &subsectors[nodenum & ~NF_SUBSECTOR];
|
||||
}
|
||||
|
||||
//
|
||||
// R_SetupFrame
|
||||
//
|
||||
|
||||
void R_SetupFrame (player_t *player)
|
||||
{
|
||||
int i, cm;
|
||||
|
||||
viewplayer = player;
|
||||
viewx = player->mo->x;
|
||||
viewy = player->mo->y;
|
||||
viewangle = player->mo->angle + viewangleoffset;
|
||||
extralight = player->extralight;
|
||||
|
||||
viewz = player->viewz;
|
||||
|
||||
viewsin = finesine[viewangle>>ANGLETOFINESHIFT];
|
||||
viewcos = finecosine[viewangle>>ANGLETOFINESHIFT];
|
||||
|
||||
// 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];
|
||||
scalelight = c_scalelight[cm];
|
||||
|
||||
if (player->fixedcolormap)
|
||||
{
|
||||
// killough 3/20/98: localize scalelightfixed (readability/optimization)
|
||||
static lighttable_t *scalelightfixed[MAXLIGHTSCALE];
|
||||
|
||||
fixedcolormap = fullcolormap // killough 3/20/98: use fullcolormap
|
||||
+ player->fixedcolormap*256*sizeof(lighttable_t);
|
||||
|
||||
walllights = scalelightfixed;
|
||||
|
||||
for (i=0 ; i<MAXLIGHTSCALE ; i++)
|
||||
scalelightfixed[i] = fixedcolormap;
|
||||
}
|
||||
else
|
||||
fixedcolormap = 0;
|
||||
|
||||
validcount++;
|
||||
}
|
||||
|
||||
//
|
||||
// R_RenderView
|
||||
//
|
||||
void R_RenderPlayerView (player_t* player)
|
||||
{
|
||||
R_SetupFrame (player);
|
||||
|
||||
// Clear buffers.
|
||||
R_ClearClipSegs ();
|
||||
R_ClearDrawSegs ();
|
||||
R_ClearPlanes ();
|
||||
R_ClearSprites ();
|
||||
|
||||
// check for new console commands.
|
||||
// NetUpdate ();
|
||||
|
||||
// The head node is the last node output.
|
||||
R_RenderBSPNode (numnodes-1);
|
||||
|
||||
// Check for new console commands.
|
||||
// NetUpdate ();
|
||||
|
||||
R_DrawPlanes ();
|
||||
|
||||
// Check for new console commands.
|
||||
// NetUpdate ();
|
||||
|
||||
R_DrawMasked ();
|
||||
|
||||
// Check for new console commands.
|
||||
// NetUpdate ();
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue