mirror of
https://git.do.srb2.org/STJr/SRB2.git
synced 2024-11-23 04:42:47 +00:00
Delete old and unused rendering-related code
- Deleted view border code - Deleted highcolor code - Deleted pre-NEWCLIP code - Deleted ylookup and columnofs - Deleted the last remnants of con_clipviewtop and dc_hires
This commit is contained in:
Lactozilla
parent
6d645acbc8
commit
07656de1d2
36 changed files with 153 additions and 2240 deletions
|
|
@ -11,8 +11,6 @@
|
|||
rendermode_t rendermode = render_soft;
|
||||
rendermode_t chosenrendermode = render_none;
|
||||
|
||||
boolean highcolor = false;
|
||||
|
||||
boolean allow_fullscreen = false;
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -70,14 +70,9 @@ static boolean consoleready; // console prompt is ready
|
|||
INT32 con_destlines; // vid lines used by console at final position
|
||||
static INT32 con_curlines; // vid lines currently used by console
|
||||
|
||||
INT32 con_clipviewtop; // (useless)
|
||||
|
||||
static UINT8 con_hudlines; // number of console heads up message lines
|
||||
static UINT32 con_hudtime[MAXHUDLINES]; // remaining time of display for hud msg lines
|
||||
|
||||
INT32 con_clearlines; // top screen lines to refresh when view reduced
|
||||
boolean con_hudupdate; // when messages scroll, we need a backgrnd refresh
|
||||
|
||||
// console text output
|
||||
static char *con_line; // console text output current line
|
||||
static size_t con_cx; // cursor position in current line
|
||||
|
|
@ -473,9 +468,6 @@ void CON_Init(void)
|
|||
|
||||
Lock_state();
|
||||
|
||||
//note: CON_Ticker should always execute at least once before D_Display()
|
||||
con_clipviewtop = -1; // -1 does not clip
|
||||
|
||||
con_hudlines = atoi(cons_hudlines.defaultvalue);
|
||||
|
||||
Unlock_state();
|
||||
|
|
@ -751,7 +743,6 @@ void CON_ToggleOff(void)
|
|||
con_curlines = 0;
|
||||
CON_ClearHUD();
|
||||
con_forcepic = 0;
|
||||
con_clipviewtop = -1; // remove console clipping of view
|
||||
|
||||
I_UpdateMouseGrab();
|
||||
|
||||
|
|
@ -800,18 +791,6 @@ void CON_Ticker(void)
|
|||
CON_ChangeHeight();
|
||||
}
|
||||
|
||||
// clip the view, so that the part under the console is not drawn
|
||||
con_clipviewtop = -1;
|
||||
if (cons_backpic.value) // clip only when using an opaque background
|
||||
{
|
||||
if (con_curlines > 0)
|
||||
con_clipviewtop = con_curlines - viewwindowy - 1 - 10;
|
||||
// NOTE: BIG HACK::SUBTRACT 10, SO THAT WATER DON'T COPY LINES OF THE CONSOLE
|
||||
// WINDOW!!! (draw some more lines behind the bottom of the console)
|
||||
if (con_clipviewtop < 0)
|
||||
con_clipviewtop = -1; // maybe not necessary, provided it's < 0
|
||||
}
|
||||
|
||||
// check if console ready for prompt
|
||||
if (con_destlines >= minheight)
|
||||
consoleready = true;
|
||||
|
|
@ -1358,9 +1337,6 @@ static void CON_Linefeed(void)
|
|||
|
||||
con_line = &con_buffer[(con_cy%con_totallines)*con_width];
|
||||
memset(con_line, ' ', con_width);
|
||||
|
||||
// make sure the view borders are refreshed if hud messages scroll
|
||||
con_hudupdate = true; // see HU_Erase()
|
||||
}
|
||||
|
||||
// Outputs text into the console text buffer
|
||||
|
|
@ -1749,9 +1725,6 @@ static void CON_DrawHudlines(void)
|
|||
//V_DrawCharacter(x, y, (p[c]&0xff) | cv_constextsize.value | V_NOSCALESTART, true);
|
||||
y += charheight;
|
||||
}
|
||||
|
||||
// top screen lines that might need clearing when view is reduced
|
||||
con_clearlines = y; // this is handled by HU_Erase();
|
||||
}
|
||||
|
||||
// Lactozilla: Draws the console's background picture.
|
||||
|
|
@ -1817,10 +1790,6 @@ static void CON_DrawConsole(void)
|
|||
if (con_curlines <= 0)
|
||||
return;
|
||||
|
||||
//FIXME: refresh borders only when console bg is translucent
|
||||
con_clearlines = con_curlines; // clear console draw from view borders
|
||||
con_hudupdate = true; // always refresh while console is on
|
||||
|
||||
// draw console background
|
||||
if (cons_backpic.value || con_forcepic)
|
||||
CON_DrawBackpic();
|
||||
|
|
|
|||
|
|
@ -34,14 +34,9 @@ extern boolean con_startup;
|
|||
// needs explicit screen refresh until we are in the main game loop
|
||||
extern boolean con_refresh;
|
||||
|
||||
// top clip value for view render: do not draw part of view hidden by console
|
||||
extern INT32 con_clipviewtop;
|
||||
|
||||
// 0 means console if off, or moving out
|
||||
extern INT32 con_destlines;
|
||||
|
||||
extern INT32 con_clearlines; // lines of top of screen to refresh
|
||||
extern boolean con_hudupdate; // hud messages have changed, need refresh
|
||||
extern UINT32 con_scalefactor; // console text scale factor
|
||||
|
||||
extern consvar_t cons_backcolor;
|
||||
|
|
|
|||
27
src/d_main.c
27
src/d_main.c
|
|
@ -408,13 +408,11 @@ static void D_Display(void)
|
|||
case GS_LEVEL:
|
||||
if (!gametic)
|
||||
break;
|
||||
HU_Erase();
|
||||
AM_Drawer();
|
||||
break;
|
||||
|
||||
case GS_INTERMISSION:
|
||||
Y_IntermissionDrawer();
|
||||
HU_Erase();
|
||||
HU_Drawer();
|
||||
break;
|
||||
|
||||
|
|
@ -429,13 +427,11 @@ static void D_Display(void)
|
|||
|
||||
case GS_ENDING:
|
||||
F_EndingDrawer();
|
||||
HU_Erase();
|
||||
HU_Drawer();
|
||||
break;
|
||||
|
||||
case GS_CUTSCENE:
|
||||
F_CutsceneDrawer();
|
||||
HU_Erase();
|
||||
HU_Drawer();
|
||||
break;
|
||||
|
||||
|
|
@ -445,7 +441,6 @@ static void D_Display(void)
|
|||
|
||||
case GS_EVALUATION:
|
||||
F_GameEvaluationDrawer();
|
||||
HU_Erase();
|
||||
HU_Drawer();
|
||||
break;
|
||||
|
||||
|
|
@ -455,7 +450,6 @@ static void D_Display(void)
|
|||
|
||||
case GS_CREDITS:
|
||||
F_CreditDrawer();
|
||||
HU_Erase();
|
||||
HU_Drawer();
|
||||
break;
|
||||
|
||||
|
|
@ -465,7 +459,6 @@ static void D_Display(void)
|
|||
{
|
||||
// I don't think HOM from nothing drawing is independent...
|
||||
F_WaitingPlayersDrawer();
|
||||
HU_Erase();
|
||||
HU_Drawer();
|
||||
}
|
||||
case GS_DEDICATEDSERVER:
|
||||
|
|
@ -480,8 +473,6 @@ static void D_Display(void)
|
|||
{
|
||||
wipegamestate = gamestate;
|
||||
|
||||
// clean up border stuff
|
||||
// see if the border needs to be initially drawn
|
||||
if (gamestate == GS_LEVEL || (gamestate == GS_TITLESCREEN && titlemapinaction && curbghide && (!hidetitlemap)))
|
||||
{
|
||||
// draw the view directly
|
||||
|
|
@ -506,23 +497,21 @@ static void D_Display(void)
|
|||
// render the second screen
|
||||
if (splitscreen && players[secondarydisplayplayer].mo)
|
||||
{
|
||||
#ifdef HWRENDER
|
||||
if (rendermode != render_soft)
|
||||
viewwindowy = vid.height / 2;
|
||||
|
||||
#ifdef HWRENDER
|
||||
if (rendermode == render_opengl)
|
||||
HWR_RenderPlayerView(1, &players[secondarydisplayplayer]);
|
||||
else
|
||||
#endif
|
||||
#endif
|
||||
if (rendermode != render_none)
|
||||
{
|
||||
viewwindowy = vid.height / 2;
|
||||
M_Memcpy(ylookup, ylookup2, viewheight*sizeof (ylookup[0]));
|
||||
|
||||
topleft = screens[0] + viewwindowy*vid.width + viewwindowx;
|
||||
|
||||
R_RenderPlayerView(&players[secondarydisplayplayer]);
|
||||
|
||||
viewwindowy = 0;
|
||||
M_Memcpy(ylookup, ylookup1, viewheight*sizeof (ylookup[0]));
|
||||
}
|
||||
|
||||
viewwindowy = 0;
|
||||
}
|
||||
|
||||
// Image postprocessing effect
|
||||
|
|
@ -1512,9 +1501,7 @@ void D_SRB2Main(void)
|
|||
G_LoadGameData(clientGamedata);
|
||||
M_CopyGameData(serverGamedata, clientGamedata);
|
||||
|
||||
#if defined (__unix__) || defined (UNIXCOMMON) || defined (HAVE_SDL)
|
||||
VID_PrepareModeList(); // Regenerate Modelist according to cv_fullscreen
|
||||
#endif
|
||||
|
||||
// set user default mode or mode set at cmdline
|
||||
SCR_CheckDefaultMode();
|
||||
|
|
|
|||
|
|
@ -5,8 +5,6 @@
|
|||
rendermode_t rendermode = render_none;
|
||||
rendermode_t chosenrendermode = render_none;
|
||||
|
||||
boolean highcolor = false;
|
||||
|
||||
boolean allow_fullscreen = false;
|
||||
|
||||
consvar_t cv_vidwait = CVAR_INIT ("vid_wait", "On", CV_SAVE, CV_OnOff, NULL);
|
||||
|
|
|
|||
|
|
@ -709,13 +709,6 @@ extern int
|
|||
/// Experimental attempts at preventing MF_PAPERCOLLISION objects from getting stuck in walls.
|
||||
//#define PAPER_COLLISIONCORRECTION
|
||||
|
||||
/// FINALLY some real clipping that doesn't make walls dissappear AND speeds the game up
|
||||
/// (that was the original comment from SRB2CB, sadly it is a lie and actually slows game down)
|
||||
/// on the bright side it fixes some weird issues with translucent walls
|
||||
/// \note SRB2CB port.
|
||||
/// SRB2CB itself ported this from PrBoom+
|
||||
#define NEWCLIP
|
||||
|
||||
/// OpenGL shaders
|
||||
#define GL_SHADERS
|
||||
|
||||
|
|
|
|||
|
|
@ -5,8 +5,6 @@
|
|||
rendermode_t rendermode = render_none;
|
||||
rendermode_t chosenrendermode = render_none;
|
||||
|
||||
boolean highcolor = false;
|
||||
|
||||
boolean allow_fullscreen = false;
|
||||
|
||||
consvar_t cv_vidwait = CVAR_INIT ("vid_wait", "On", CV_SAVE, CV_OnOff, NULL);
|
||||
|
|
|
|||
|
|
@ -320,16 +320,13 @@ void gld_clipper_Clear(void)
|
|||
|
||||
#define RMUL (1.6f/1.333333f)
|
||||
|
||||
angle_t gld_FrustumAngle(angle_t tiltangle)
|
||||
angle_t gld_FrustumAngle(float render_fov, angle_t tiltangle)
|
||||
{
|
||||
double floatangle;
|
||||
angle_t a1;
|
||||
|
||||
float tilt = (float)fabs(((double)(int)tiltangle) / ANG1);
|
||||
|
||||
// NEWCLIP TODO: SRB2CBTODO: make a global render_fov for this function
|
||||
|
||||
float render_fov = FIXED_TO_FLOAT(cv_fov.value);
|
||||
float render_fovratio = (float)BASEVIDWIDTH / (float)BASEVIDHEIGHT; // SRB2CBTODO: NEWCLIPTODO: Is this right?
|
||||
float render_multiplier = 64.0f / render_fovratio / RMUL;
|
||||
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@
|
|||
boolean gld_clipper_SafeCheckRange(angle_t startAngle, angle_t endAngle);
|
||||
void gld_clipper_SafeAddClipRange(angle_t startangle, angle_t endangle);
|
||||
void gld_clipper_Clear(void);
|
||||
angle_t gld_FrustumAngle(angle_t tiltangle);
|
||||
angle_t gld_FrustumAngle(float render_fov, angle_t tiltangle);
|
||||
#ifdef HAVE_SPHEREFRUSTRUM
|
||||
void gld_FrustrumSetup(void);
|
||||
boolean gld_SphereInFrustum(float x, float y, float z, float radius);
|
||||
|
|
|
|||
|
|
@ -22,7 +22,6 @@
|
|||
#include "hw_drv.h"
|
||||
|
||||
#include "../m_misc.h" //FIL_WriteFile()
|
||||
#include "../r_draw.h" //viewborderlump
|
||||
#include "../r_main.h"
|
||||
#include "../w_wad.h"
|
||||
#include "../z_zone.h"
|
||||
|
|
@ -32,11 +31,7 @@
|
|||
#include "../g_game.h" // players
|
||||
|
||||
#include <fcntl.h>
|
||||
#include "../i_video.h" // for rendermode != render_glide
|
||||
|
||||
#ifndef O_BINARY
|
||||
#define O_BINARY 0
|
||||
#endif
|
||||
#include "../i_video.h"
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
#pragma pack(1)
|
||||
|
|
@ -62,63 +57,6 @@ static UINT8 softwaretranstogl[11] = { 0, 25, 51, 76,102,127,153,178,204,229
|
|||
static UINT8 softwaretranstogl_hi[11] = { 0, 51,102,153,204,255,255,255,255,255,255};
|
||||
static UINT8 softwaretranstogl_lo[11] = { 0, 12, 24, 36, 48, 60, 71, 83, 95,111,127};
|
||||
|
||||
//
|
||||
// -----------------+
|
||||
// HWR_DrawPatch : Draw a 'tile' graphic
|
||||
// Notes : x,y : positions relative to the original Doom resolution
|
||||
// : textes(console+score) + menus + status bar
|
||||
// -----------------+
|
||||
void HWR_DrawPatch(patch_t *gpatch, INT32 x, INT32 y, INT32 option)
|
||||
{
|
||||
FOutVector v[4];
|
||||
FBITFIELD flags;
|
||||
GLPatch_t *hwrPatch;
|
||||
|
||||
// 3--2
|
||||
// | /|
|
||||
// |/ |
|
||||
// 0--1
|
||||
float sdup = FIXED_TO_FLOAT(vid.fdup)*2.0f;
|
||||
float pdup = FIXED_TO_FLOAT(vid.fdup)*2.0f;
|
||||
|
||||
// make patch ready in hardware cache
|
||||
HWR_GetPatch(gpatch);
|
||||
hwrPatch = ((GLPatch_t *)gpatch->hardware);
|
||||
|
||||
switch (option & V_SCALEPATCHMASK)
|
||||
{
|
||||
case V_NOSCALEPATCH:
|
||||
pdup = 2.0f;
|
||||
break;
|
||||
case V_SMALLSCALEPATCH:
|
||||
pdup = 2.0f * FIXED_TO_FLOAT(vid.fsmalldup);
|
||||
break;
|
||||
case V_MEDSCALEPATCH:
|
||||
pdup = 2.0f * FIXED_TO_FLOAT(vid.fmeddup);
|
||||
break;
|
||||
}
|
||||
|
||||
if (option & V_NOSCALESTART)
|
||||
sdup = 2.0f;
|
||||
|
||||
v[0].x = v[3].x = (x*sdup-(gpatch->leftoffset)*pdup)/vid.width - 1;
|
||||
v[2].x = v[1].x = (x*sdup+(gpatch->width-gpatch->leftoffset)*pdup)/vid.width - 1;
|
||||
v[0].y = v[1].y = 1-(y*sdup-(gpatch->topoffset)*pdup)/vid.height;
|
||||
v[2].y = v[3].y = 1-(y*sdup+(gpatch->height-gpatch->topoffset)*pdup)/vid.height;
|
||||
|
||||
v[0].z = v[1].z = v[2].z = v[3].z = 1.0f;
|
||||
|
||||
v[0].s = v[3].s = 0.0f;
|
||||
v[2].s = v[1].s = hwrPatch->max_s;
|
||||
v[0].t = v[1].t = 0.0f;
|
||||
v[2].t = v[3].t = hwrPatch->max_t;
|
||||
|
||||
flags = PF_Translucent|PF_NoDepthTest;
|
||||
|
||||
// clip it since it is used for bunny scroll in doom I
|
||||
HWD.pfnDrawPolygon(NULL, v, 4, flags);
|
||||
}
|
||||
|
||||
void HWR_DrawStretchyFixedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale, fixed_t vscale, INT32 option, const UINT8 *colormap)
|
||||
{
|
||||
FOutVector v[4];
|
||||
|
|
@ -960,136 +898,6 @@ void HWR_DrawTutorialBack(UINT32 color, INT32 boxheight)
|
|||
HWD.pfnDrawPolygon(&Surf, v, 4, PF_NoTexture|PF_Modulated|PF_Translucent|PF_NoDepthTest);
|
||||
}
|
||||
|
||||
|
||||
// ==========================================================================
|
||||
// R_DRAW.C STUFF
|
||||
// ==========================================================================
|
||||
|
||||
// ------------------
|
||||
// HWR_DrawViewBorder
|
||||
// Fill the space around the view window with a Doom flat texture, draw the
|
||||
// beveled edges.
|
||||
// 'clearlines' is useful to clear the heads up messages, when the view
|
||||
// window is reduced, it doesn't refresh all the view borders.
|
||||
// ------------------
|
||||
void HWR_DrawViewBorder(INT32 clearlines)
|
||||
{
|
||||
INT32 x, y;
|
||||
INT32 top, side;
|
||||
INT32 baseviewwidth, baseviewheight;
|
||||
INT32 basewindowx, basewindowy;
|
||||
patch_t *patch;
|
||||
|
||||
// if (gl_viewwidth == vid.width)
|
||||
// return;
|
||||
|
||||
if (!clearlines)
|
||||
clearlines = BASEVIDHEIGHT; // refresh all
|
||||
|
||||
// calc view size based on original game resolution
|
||||
baseviewwidth = FixedInt(FixedDiv(FLOAT_TO_FIXED(gl_viewwidth), vid.fdup)); //(cv_viewsize.value * BASEVIDWIDTH/10)&~7;
|
||||
baseviewheight = FixedInt(FixedDiv(FLOAT_TO_FIXED(gl_viewheight), vid.fdup));
|
||||
top = FixedInt(FixedDiv(FLOAT_TO_FIXED(gl_baseviewwindowy), vid.fdup));
|
||||
side = FixedInt(FixedDiv(FLOAT_TO_FIXED(gl_viewwindowx), vid.fdup));
|
||||
|
||||
// top
|
||||
HWR_DrawFlatFill(0, 0,
|
||||
BASEVIDWIDTH, (top < clearlines ? top : clearlines),
|
||||
st_borderpatchnum);
|
||||
|
||||
// left
|
||||
if (top < clearlines)
|
||||
HWR_DrawFlatFill(0, top, side,
|
||||
(clearlines-top < baseviewheight ? clearlines-top : baseviewheight),
|
||||
st_borderpatchnum);
|
||||
|
||||
// right
|
||||
if (top < clearlines)
|
||||
HWR_DrawFlatFill(side + baseviewwidth, top, side,
|
||||
(clearlines-top < baseviewheight ? clearlines-top : baseviewheight),
|
||||
st_borderpatchnum);
|
||||
|
||||
// bottom
|
||||
if (top + baseviewheight < clearlines)
|
||||
HWR_DrawFlatFill(0, top + baseviewheight,
|
||||
BASEVIDWIDTH, BASEVIDHEIGHT, st_borderpatchnum);
|
||||
|
||||
//
|
||||
// draw the view borders
|
||||
//
|
||||
|
||||
basewindowx = (BASEVIDWIDTH - baseviewwidth)>>1;
|
||||
if (baseviewwidth == BASEVIDWIDTH)
|
||||
basewindowy = 0;
|
||||
else
|
||||
basewindowy = top;
|
||||
|
||||
// top edge
|
||||
if (clearlines > basewindowy - 8)
|
||||
{
|
||||
patch = W_CachePatchNum(viewborderlump[BRDR_T], PU_PATCH);
|
||||
for (x = 0; x < baseviewwidth; x += 8)
|
||||
HWR_DrawPatch(patch, basewindowx + x, basewindowy - 8,
|
||||
0);
|
||||
}
|
||||
|
||||
// bottom edge
|
||||
if (clearlines > basewindowy + baseviewheight)
|
||||
{
|
||||
patch = W_CachePatchNum(viewborderlump[BRDR_B], PU_PATCH);
|
||||
for (x = 0; x < baseviewwidth; x += 8)
|
||||
HWR_DrawPatch(patch, basewindowx + x,
|
||||
basewindowy + baseviewheight, 0);
|
||||
}
|
||||
|
||||
// left edge
|
||||
if (clearlines > basewindowy)
|
||||
{
|
||||
patch = W_CachePatchNum(viewborderlump[BRDR_L], PU_PATCH);
|
||||
for (y = 0; y < baseviewheight && basewindowy + y < clearlines;
|
||||
y += 8)
|
||||
{
|
||||
HWR_DrawPatch(patch, basewindowx - 8, basewindowy + y,
|
||||
0);
|
||||
}
|
||||
}
|
||||
|
||||
// right edge
|
||||
if (clearlines > basewindowy)
|
||||
{
|
||||
patch = W_CachePatchNum(viewborderlump[BRDR_R], PU_PATCH);
|
||||
for (y = 0; y < baseviewheight && basewindowy+y < clearlines;
|
||||
y += 8)
|
||||
{
|
||||
HWR_DrawPatch(patch, basewindowx + baseviewwidth,
|
||||
basewindowy + y, 0);
|
||||
}
|
||||
}
|
||||
|
||||
// Draw beveled corners.
|
||||
if (clearlines > basewindowy - 8)
|
||||
HWR_DrawPatch(W_CachePatchNum(viewborderlump[BRDR_TL],
|
||||
PU_PATCH),
|
||||
basewindowx - 8, basewindowy - 8, 0);
|
||||
|
||||
if (clearlines > basewindowy - 8)
|
||||
HWR_DrawPatch(W_CachePatchNum(viewborderlump[BRDR_TR],
|
||||
PU_PATCH),
|
||||
basewindowx + baseviewwidth, basewindowy - 8, 0);
|
||||
|
||||
if (clearlines > basewindowy+baseviewheight)
|
||||
HWR_DrawPatch(W_CachePatchNum(viewborderlump[BRDR_BL],
|
||||
PU_PATCH),
|
||||
basewindowx - 8, basewindowy + baseviewheight, 0);
|
||||
|
||||
if (clearlines > basewindowy + baseviewheight)
|
||||
HWR_DrawPatch(W_CachePatchNum(viewborderlump[BRDR_BR],
|
||||
PU_PATCH),
|
||||
basewindowx + baseviewwidth,
|
||||
basewindowy + baseviewheight, 0);
|
||||
}
|
||||
|
||||
|
||||
// ==========================================================================
|
||||
// AM_MAP.C DRAWING STUFF
|
||||
// ==========================================================================
|
||||
|
|
@ -1499,7 +1307,7 @@ static inline boolean saveTGA(const char *file_name, void *buffer,
|
|||
INT32 i;
|
||||
UINT8 *buf8 = buffer;
|
||||
|
||||
fd = open(file_name, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666);
|
||||
fd = open(file_name, O_WRONLY | O_CREAT | O_TRUNC, 0666);
|
||||
if (fd < 0)
|
||||
return false;
|
||||
|
||||
|
|
|
|||
|
|
@ -29,9 +29,6 @@ EXPORT boolean HWRAPI(Init) (void);
|
|||
#ifndef HAVE_SDL
|
||||
EXPORT void HWRAPI(Shutdown) (void);
|
||||
#endif
|
||||
#ifdef _WINDOWS
|
||||
EXPORT void HWRAPI(GetModeList) (vmode_t **pvidmodes, INT32 *numvidmodes);
|
||||
#endif
|
||||
EXPORT void HWRAPI(SetPalette) (RGBA_t *ppal);
|
||||
EXPORT void HWRAPI(FinishUpdate) (INT32 waitvbl);
|
||||
EXPORT void HWRAPI(Draw2DLine) (F2DCoord *v1, F2DCoord *v2, RGBA_t Color);
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -35,11 +35,8 @@ void HWR_RenderSkyboxView(INT32 viewnumber, player_t *player);
|
|||
void HWR_RenderPlayerView(INT32 viewnumber, player_t *player);
|
||||
void HWR_ClearSkyDome(void);
|
||||
void HWR_BuildSkyDome(void);
|
||||
void HWR_DrawViewBorder(INT32 clearlines);
|
||||
void HWR_DrawFlatFill(INT32 x, INT32 y, INT32 w, INT32 h, lumpnum_t flatlumpnum);
|
||||
void HWR_InitTextureMapping(void);
|
||||
void HWR_SetViewSize(void);
|
||||
void HWR_DrawPatch(patch_t *gpatch, INT32 x, INT32 y, INT32 option);
|
||||
void HWR_DrawStretchyFixedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale, fixed_t vscale, INT32 option, const UINT8 *colormap);
|
||||
void HWR_DrawCroppedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale, fixed_t vscale, INT32 option, const UINT8 *colormap, fixed_t sx, fixed_t sy, fixed_t w, fixed_t h);
|
||||
void HWR_MakePatch(const patch_t *patch, GLPatch_t *grPatch, GLMipmap_t *grMipmap, boolean makebitmap);
|
||||
|
|
@ -108,16 +105,11 @@ extern consvar_t cv_glbatching;
|
|||
|
||||
extern consvar_t cv_glwireframe;
|
||||
|
||||
extern float gl_viewwidth, gl_viewheight, gl_baseviewwindowy;
|
||||
|
||||
extern float gl_viewwindowx, gl_basewindowcentery;
|
||||
|
||||
// BP: big hack for a test in lighting ref : 1249753487AB
|
||||
extern fixed_t *hwbbox;
|
||||
extern FTransform atransform;
|
||||
extern float gl_viewsin, gl_viewcos;
|
||||
|
||||
|
||||
// Render stats
|
||||
extern ps_metric_t ps_hw_skyboxtime;
|
||||
extern ps_metric_t ps_hw_nodesorttime;
|
||||
|
|
|
|||
|
|
@ -2044,76 +2044,6 @@ void HU_Drawer(void)
|
|||
}
|
||||
}
|
||||
|
||||
//======================================================================
|
||||
// HUD MESSAGES CLEARING FROM SCREEN
|
||||
//======================================================================
|
||||
|
||||
// Clear old messages from the borders around the view window
|
||||
// (only for reduced view, refresh the borders when needed)
|
||||
//
|
||||
// startline: y coord to start clear,
|
||||
// clearlines: how many lines to clear.
|
||||
//
|
||||
static INT32 oldclearlines;
|
||||
|
||||
void HU_Erase(void)
|
||||
{
|
||||
INT32 topline, bottomline;
|
||||
INT32 y, yoffset;
|
||||
|
||||
#ifdef HWRENDER
|
||||
// clear hud msgs on double buffer (OpenGL mode)
|
||||
boolean secondframe;
|
||||
static INT32 secondframelines;
|
||||
#endif
|
||||
|
||||
if (con_clearlines == oldclearlines && !con_hudupdate && !chat_on)
|
||||
return;
|
||||
|
||||
#ifdef HWRENDER
|
||||
// clear the other frame in double-buffer modes
|
||||
secondframe = (con_clearlines != oldclearlines);
|
||||
if (secondframe)
|
||||
secondframelines = oldclearlines;
|
||||
#endif
|
||||
|
||||
// clear the message lines that go away, so use _oldclearlines_
|
||||
bottomline = oldclearlines;
|
||||
oldclearlines = con_clearlines;
|
||||
if (chat_on && OLDCHAT)
|
||||
if (bottomline < 8)
|
||||
bottomline = 8; // only do it for consolechat. consolechat is gay.
|
||||
|
||||
if (automapactive || viewwindowx == 0) // hud msgs don't need to be cleared
|
||||
return;
|
||||
|
||||
// software mode copies view border pattern & beveled edges from the backbuffer
|
||||
if (rendermode == render_soft)
|
||||
{
|
||||
topline = 0;
|
||||
for (y = topline, yoffset = y*vid.width; y < bottomline; y++, yoffset += vid.width)
|
||||
{
|
||||
if (y < viewwindowy || y >= viewwindowy + viewheight)
|
||||
R_VideoErase(yoffset, vid.width); // erase entire line
|
||||
else
|
||||
{
|
||||
R_VideoErase(yoffset, viewwindowx); // erase left border
|
||||
// erase right border
|
||||
R_VideoErase(yoffset + viewwindowx + viewwidth, viewwindowx);
|
||||
}
|
||||
}
|
||||
con_hudupdate = false; // if it was set..
|
||||
}
|
||||
#ifdef HWRENDER
|
||||
else if (rendermode != render_none)
|
||||
{
|
||||
// refresh just what is needed from the view borders
|
||||
HWR_DrawViewBorder(secondframelines);
|
||||
con_hudupdate = secondframe;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
//======================================================================
|
||||
// IN-LEVEL MULTIPLAYER RANKINGS
|
||||
//======================================================================
|
||||
|
|
|
|||
|
|
@ -111,7 +111,6 @@ boolean HU_Responder(event_t *ev);
|
|||
void HU_Ticker(void);
|
||||
void HU_Drawer(void);
|
||||
char HU_dequeueChatChar(void);
|
||||
void HU_Erase(void);
|
||||
void HU_clearChatChars(void);
|
||||
void HU_drawPing(INT32 x, INT32 y, UINT32 ping, boolean notext, INT32 flags); // Lat': Ping drawer for scoreboard.
|
||||
void HU_DrawTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scorelines, INT32 whiteplayer);
|
||||
|
|
|
|||
|
|
@ -40,10 +40,6 @@ extern rendermode_t rendermode;
|
|||
*/
|
||||
extern rendermode_t chosenrendermode;
|
||||
|
||||
/** \brief use highcolor modes if true
|
||||
*/
|
||||
extern boolean highcolor;
|
||||
|
||||
/** \brief setup video mode
|
||||
*/
|
||||
void I_StartupGraphics(void);
|
||||
|
|
@ -108,8 +104,8 @@ void VID_CheckGLLoaded(rendermode_t oldrender);
|
|||
\return name of video mode
|
||||
*/
|
||||
const char *VID_GetModeName(INT32 modenum);
|
||||
void VID_PrepareModeList(void); /// note hack for SDL
|
||||
|
||||
void VID_PrepareModeList(void);
|
||||
|
||||
/** \brief can video system do fullscreen
|
||||
*/
|
||||
|
|
|
|||
60
src/m_menu.c
60
src/m_menu.c
|
|
@ -4098,53 +4098,6 @@ void M_DrawTextBox(INT32 x, INT32 y, INT32 width, INT32 boxlines)
|
|||
{
|
||||
// Solid color textbox.
|
||||
V_DrawFill(x+5, y+5, width*8+6, boxlines*8+6, 159);
|
||||
//V_DrawFill(x+8, y+8, width*8, boxlines*8, 31);
|
||||
/*
|
||||
patch_t *p;
|
||||
INT32 cx, cy, n;
|
||||
INT32 step, boff;
|
||||
|
||||
step = 8;
|
||||
boff = 8;
|
||||
|
||||
// draw left side
|
||||
cx = x;
|
||||
cy = y;
|
||||
V_DrawScaledPatch(cx, cy, 0, W_CachePatchNum(viewborderlump[BRDR_TL], PU_PATCH));
|
||||
cy += boff;
|
||||
p = W_CachePatchNum(viewborderlump[BRDR_L], PU_PATCH);
|
||||
for (n = 0; n < boxlines; n++)
|
||||
{
|
||||
V_DrawScaledPatch(cx, cy, 0, p);
|
||||
cy += step;
|
||||
}
|
||||
V_DrawScaledPatch(cx, cy, 0, W_CachePatchNum(viewborderlump[BRDR_BL], PU_PATCH));
|
||||
|
||||
// draw middle
|
||||
V_DrawFlatFill(x + boff, y + boff, width*step, boxlines*step, st_borderpatchnum);
|
||||
|
||||
cx += boff;
|
||||
cy = y;
|
||||
while (width > 0)
|
||||
{
|
||||
V_DrawScaledPatch(cx, cy, 0, W_CachePatchNum(viewborderlump[BRDR_T], PU_PATCH));
|
||||
V_DrawScaledPatch(cx, y + boff + boxlines*step, 0, W_CachePatchNum(viewborderlump[BRDR_B], PU_PATCH));
|
||||
width--;
|
||||
cx += step;
|
||||
}
|
||||
|
||||
// draw right side
|
||||
cy = y;
|
||||
V_DrawScaledPatch(cx, cy, 0, W_CachePatchNum(viewborderlump[BRDR_TR], PU_PATCH));
|
||||
cy += boff;
|
||||
p = W_CachePatchNum(viewborderlump[BRDR_R], PU_PATCH);
|
||||
for (n = 0; n < boxlines; n++)
|
||||
{
|
||||
V_DrawScaledPatch(cx, cy, 0, p);
|
||||
cy += step;
|
||||
}
|
||||
V_DrawScaledPatch(cx, cy, 0, W_CachePatchNum(viewborderlump[BRDR_BR], PU_PATCH));
|
||||
*/
|
||||
}
|
||||
|
||||
//
|
||||
|
|
@ -13672,23 +13625,14 @@ static void M_VideoModeMenu(INT32 choice)
|
|||
|
||||
memset(modedescs, 0, sizeof(modedescs));
|
||||
|
||||
#if defined (__unix__) || defined (UNIXCOMMON) || defined (HAVE_SDL)
|
||||
VID_PrepareModeList(); // FIXME: hack
|
||||
#endif
|
||||
|
||||
vidm_nummodes = 0;
|
||||
vidm_selected = 0;
|
||||
nummodes = VID_NumModes();
|
||||
|
||||
#ifdef _WINDOWS
|
||||
// clean that later: skip windowed mode 0, video modes menu only shows FULL SCREEN modes
|
||||
if (nummodes <= NUMSPECIALMODES)
|
||||
i = 0; // unless we have nothing
|
||||
else
|
||||
i = NUMSPECIALMODES;
|
||||
#else
|
||||
// DOS does not skip mode 0, because mode 0 is ALWAYS present
|
||||
i = 0;
|
||||
#endif
|
||||
|
||||
for (; i < nummodes && vidm_nummodes < MAXMODEDESCS; i++)
|
||||
{
|
||||
desc = VID_GetModeName(i);
|
||||
|
|
|
|||
44
src/r_data.c
44
src/r_data.c
|
|
@ -50,10 +50,6 @@ lighttable_t *fadecolormap;
|
|||
// for debugging/info purposes
|
||||
size_t flatmemory, spritememory, texturememory;
|
||||
|
||||
// highcolor stuff
|
||||
INT16 color8to16[256]; // remap color index to highcolor rgb value
|
||||
INT16 *hicolormaps; // test a 32k colormap remaps high -> high
|
||||
|
||||
// Blends two pixels together, using the equation
|
||||
// that matches the specified alpha style.
|
||||
UINT32 ASTBlendPixel(RGBA_t background, RGBA_t foreground, int style, UINT8 alpha)
|
||||
|
|
@ -1170,40 +1166,6 @@ const char *R_NameForColormap(extracolormap_t *extra_colormap)
|
|||
}
|
||||
#endif
|
||||
|
||||
//
|
||||
// build a table for quick conversion from 8bpp to 15bpp
|
||||
//
|
||||
|
||||
//
|
||||
// added "static inline" keywords, linking with the debug version
|
||||
// of allegro, it have a makecol15 function of it's own, now
|
||||
// with "static inline" keywords,it sloves this problem ;)
|
||||
//
|
||||
FUNCMATH static inline int makecol15(int r, int g, int b)
|
||||
{
|
||||
return (((r >> 3) << 10) | ((g >> 3) << 5) | ((b >> 3)));
|
||||
}
|
||||
|
||||
static void R_Init8to16(void)
|
||||
{
|
||||
UINT8 *palette;
|
||||
int i;
|
||||
|
||||
palette = W_CacheLumpName("PLAYPAL",PU_CACHE);
|
||||
|
||||
for (i = 0; i < 256; i++)
|
||||
{
|
||||
// PLAYPAL uses 8 bit values
|
||||
color8to16[i] = (INT16)makecol15(palette[0], palette[1], palette[2]);
|
||||
palette += 3;
|
||||
}
|
||||
|
||||
// test a big colormap
|
||||
hicolormaps = Z_Malloc(16384*sizeof(*hicolormaps), PU_STATIC, NULL);
|
||||
for (i = 0; i < 16384; i++)
|
||||
hicolormaps[i] = (INT16)(i<<1);
|
||||
}
|
||||
|
||||
//
|
||||
// R_InitData
|
||||
//
|
||||
|
|
@ -1212,12 +1174,6 @@ static void R_Init8to16(void)
|
|||
//
|
||||
void R_InitData(void)
|
||||
{
|
||||
if (highcolor)
|
||||
{
|
||||
CONS_Printf("InitHighColor...\n");
|
||||
R_Init8to16();
|
||||
}
|
||||
|
||||
CONS_Printf("R_LoadParsedTranslations()...\n");
|
||||
R_LoadParsedTranslations();
|
||||
|
||||
|
|
|
|||
|
|
@ -36,9 +36,6 @@ UINT8 ASTBlendPaletteIndexes(UINT8 background, UINT8 foreground, int style, UINT
|
|||
|
||||
extern INT32 ASTTextureBlendingThreshold[2];
|
||||
|
||||
extern INT16 color8to16[256]; // remap color index to highcolor
|
||||
extern INT16 *hicolormaps; // remap high colors to high colors..
|
||||
|
||||
extern CV_PossibleValue_t Color_cons_t[];
|
||||
|
||||
// I/O, setting up the stuff.
|
||||
|
|
|
|||
183
src/r_draw.c
183
src/r_draw.c
|
|
@ -40,23 +40,6 @@
|
|||
*/
|
||||
INT32 viewwidth, scaledviewwidth, viewheight, viewwindowx, viewwindowy;
|
||||
|
||||
/** \brief pointer to the start of each line of the screen,
|
||||
*/
|
||||
UINT8 *ylookup[MAXVIDHEIGHT*4];
|
||||
|
||||
/** \brief pointer to the start of each line of the screen, for view1 (splitscreen)
|
||||
*/
|
||||
UINT8 *ylookup1[MAXVIDHEIGHT*4];
|
||||
|
||||
/** \brief pointer to the start of each line of the screen, for view2 (splitscreen)
|
||||
*/
|
||||
UINT8 *ylookup2[MAXVIDHEIGHT*4];
|
||||
|
||||
/** \brief x byte offset for columns inside the viewwindow,
|
||||
so the first column starts at (SCRWIDTH - VIEWWIDTH)/2
|
||||
*/
|
||||
INT32 columnofs[MAXVIDWIDTH*4];
|
||||
|
||||
UINT8 *topleft;
|
||||
|
||||
// =========================================================================
|
||||
|
|
@ -67,8 +50,6 @@ lighttable_t *dc_colormap;
|
|||
INT32 dc_x = 0, dc_yl = 0, dc_yh = 0;
|
||||
|
||||
fixed_t dc_iscale, dc_texturemid;
|
||||
UINT8 dc_hires; // under MSVC boolean is a byte, while on other systems, it a bit,
|
||||
// soo lets make it a byte on all system for the ASM code
|
||||
UINT8 *dc_source;
|
||||
|
||||
// -----------------------
|
||||
|
|
@ -677,7 +658,7 @@ UINT16 R_GetSuperColorByName(const char *name)
|
|||
|
||||
void R_InitViewBuffer(INT32 width, INT32 height)
|
||||
{
|
||||
INT32 i, bytesperpixel = vid.bpp;
|
||||
INT32 bytesperpixel = vid.bpp;
|
||||
|
||||
if (width > MAXVIDWIDTH)
|
||||
width = MAXVIDWIDTH;
|
||||
|
|
@ -689,118 +670,13 @@ void R_InitViewBuffer(INT32 width, INT32 height)
|
|||
// Handle resize, e.g. smaller view windows with border and/or status bar.
|
||||
viewwindowx = (vid.width - width) >> 1;
|
||||
|
||||
// Column offset for those columns of the view window, but relative to the entire screen
|
||||
for (i = 0; i < width; i++)
|
||||
columnofs[i] = (viewwindowx + i) * bytesperpixel;
|
||||
|
||||
// Same with base row offset.
|
||||
if (width == vid.width)
|
||||
viewwindowy = 0;
|
||||
else
|
||||
viewwindowy = (vid.height - height) >> 1;
|
||||
|
||||
// Precalculate all row offsets.
|
||||
for (i = 0; i < height; i++)
|
||||
{
|
||||
ylookup[i] = ylookup1[i] = screens[0] + (i+viewwindowy)*vid.width*bytesperpixel;
|
||||
ylookup2[i] = screens[0] + (i+(vid.height>>1))*vid.width*bytesperpixel; // for splitscreen
|
||||
}
|
||||
}
|
||||
|
||||
/** \brief viewborder patches lump numbers
|
||||
*/
|
||||
lumpnum_t viewborderlump[8];
|
||||
|
||||
/** \brief Store the lumpnumber of the viewborder patches
|
||||
*/
|
||||
|
||||
void R_InitViewBorder(void)
|
||||
{
|
||||
viewborderlump[BRDR_T] = W_GetNumForName("brdr_t");
|
||||
viewborderlump[BRDR_B] = W_GetNumForName("brdr_b");
|
||||
viewborderlump[BRDR_L] = W_GetNumForName("brdr_l");
|
||||
viewborderlump[BRDR_R] = W_GetNumForName("brdr_r");
|
||||
viewborderlump[BRDR_TL] = W_GetNumForName("brdr_tl");
|
||||
viewborderlump[BRDR_BL] = W_GetNumForName("brdr_bl");
|
||||
viewborderlump[BRDR_TR] = W_GetNumForName("brdr_tr");
|
||||
viewborderlump[BRDR_BR] = W_GetNumForName("brdr_br");
|
||||
}
|
||||
|
||||
#if 0
|
||||
/** \brief R_FillBackScreen
|
||||
|
||||
Fills the back screen with a pattern for variable screen sizes
|
||||
Also draws a beveled edge.
|
||||
*/
|
||||
void R_FillBackScreen(void)
|
||||
{
|
||||
UINT8 *src, *dest;
|
||||
patch_t *patch;
|
||||
INT32 x, y, step, boff;
|
||||
|
||||
// quickfix, don't cache lumps in both modes
|
||||
if (rendermode != render_soft)
|
||||
return;
|
||||
|
||||
// draw pattern around the status bar too (when hires),
|
||||
// so return only when in full-screen without status bar.
|
||||
if (scaledviewwidth == vid.width && viewheight == vid.height)
|
||||
return;
|
||||
|
||||
src = scr_borderpatch;
|
||||
dest = screens[1];
|
||||
|
||||
for (y = 0; y < vid.height; y++)
|
||||
{
|
||||
for (x = 0; x < vid.width/128; x++)
|
||||
{
|
||||
M_Memcpy (dest, src+((y&127)<<7), 128);
|
||||
dest += 128;
|
||||
}
|
||||
|
||||
if (vid.width&127)
|
||||
{
|
||||
M_Memcpy(dest, src+((y&127)<<7), vid.width&127);
|
||||
dest += (vid.width&127);
|
||||
}
|
||||
}
|
||||
|
||||
// don't draw the borders when viewwidth is full vid.width.
|
||||
if (scaledviewwidth == vid.width)
|
||||
return;
|
||||
|
||||
step = 8;
|
||||
boff = 8;
|
||||
|
||||
patch = W_CacheLumpNum(viewborderlump[BRDR_T], PU_CACHE);
|
||||
for (x = 0; x < scaledviewwidth; x += step)
|
||||
V_DrawPatch(viewwindowx + x, viewwindowy - boff, 1, patch);
|
||||
|
||||
patch = W_CacheLumpNum(viewborderlump[BRDR_B], PU_CACHE);
|
||||
for (x = 0; x < scaledviewwidth; x += step)
|
||||
V_DrawPatch(viewwindowx + x, viewwindowy + viewheight, 1, patch);
|
||||
|
||||
patch = W_CacheLumpNum(viewborderlump[BRDR_L], PU_CACHE);
|
||||
for (y = 0; y < viewheight; y += step)
|
||||
V_DrawPatch(viewwindowx - boff, viewwindowy + y, 1, patch);
|
||||
|
||||
patch = W_CacheLumpNum(viewborderlump[BRDR_R],PU_CACHE);
|
||||
for (y = 0; y < viewheight; y += step)
|
||||
V_DrawPatch(viewwindowx + scaledviewwidth, viewwindowy + y, 1,
|
||||
patch);
|
||||
|
||||
// Draw beveled corners.
|
||||
V_DrawPatch(viewwindowx - boff, viewwindowy - boff, 1,
|
||||
W_CacheLumpNum(viewborderlump[BRDR_TL], PU_CACHE));
|
||||
V_DrawPatch(viewwindowx + scaledviewwidth, viewwindowy - boff, 1,
|
||||
W_CacheLumpNum(viewborderlump[BRDR_TR], PU_CACHE));
|
||||
V_DrawPatch(viewwindowx - boff, viewwindowy + viewheight, 1,
|
||||
W_CacheLumpNum(viewborderlump[BRDR_BL], PU_CACHE));
|
||||
V_DrawPatch(viewwindowx + scaledviewwidth, viewwindowy + viewheight, 1,
|
||||
W_CacheLumpNum(viewborderlump[BRDR_BR], PU_CACHE));
|
||||
}
|
||||
#endif
|
||||
|
||||
/** \brief The R_VideoErase function
|
||||
|
||||
Copy a screen buffer.
|
||||
|
|
@ -822,55 +698,6 @@ void R_VideoErase(size_t ofs, INT32 count)
|
|||
M_Memcpy(screens[0] + ofs, screens[1] + ofs, count);
|
||||
}
|
||||
|
||||
#if 0
|
||||
/** \brief The R_DrawViewBorder
|
||||
|
||||
Draws the border around the view
|
||||
for different size windows?
|
||||
*/
|
||||
void R_DrawViewBorder(void)
|
||||
{
|
||||
INT32 top, side, ofs;
|
||||
|
||||
if (rendermode == render_none)
|
||||
return;
|
||||
#ifdef HWRENDER
|
||||
if (rendermode != render_soft)
|
||||
{
|
||||
HWR_DrawViewBorder(0);
|
||||
return;
|
||||
}
|
||||
else
|
||||
#endif
|
||||
|
||||
#ifdef DEBUG
|
||||
fprintf(stderr,"RDVB: vidwidth %d vidheight %d scaledviewwidth %d viewheight %d\n",
|
||||
vid.width, vid.height, scaledviewwidth, viewheight);
|
||||
#endif
|
||||
|
||||
if (scaledviewwidth == vid.width)
|
||||
return;
|
||||
|
||||
top = (vid.height - viewheight)>>1;
|
||||
side = (vid.width - scaledviewwidth)>>1;
|
||||
|
||||
// copy top and one line of left side
|
||||
R_VideoErase(0, top*vid.width+side);
|
||||
|
||||
// copy one line of right side and bottom
|
||||
ofs = (viewheight+top)*vid.width - side;
|
||||
R_VideoErase(ofs, top*vid.width + side);
|
||||
|
||||
// copy sides using wraparound
|
||||
ofs = top*vid.width + vid.width-side;
|
||||
side <<= 1;
|
||||
|
||||
// simpler using our VID_Blit routine
|
||||
VID_BlitLinearScreen(screens[1] + ofs, screens[0] + ofs, side, viewheight - 1,
|
||||
vid.width, vid.width);
|
||||
}
|
||||
#endif
|
||||
|
||||
// R_CalcTiltedLighting
|
||||
// Exactly what it says on the tin. I wish I wasn't too lazy to explain things properly.
|
||||
static INT32 tiltlighting[MAXVIDWIDTH];
|
||||
|
|
@ -912,11 +739,3 @@ static void R_CalcSlopeLight(void)
|
|||
|
||||
#include "r_draw8.c"
|
||||
#include "r_draw8_npo2.c"
|
||||
|
||||
// ==========================================================================
|
||||
// INCLUDE 16bpp DRAWING CODE HERE
|
||||
// ==========================================================================
|
||||
|
||||
#ifdef HIGHCOLOR
|
||||
#include "r_draw16.c"
|
||||
#endif
|
||||
|
|
|
|||
45
src/r_draw.h
45
src/r_draw.h
|
|
@ -19,10 +19,6 @@
|
|||
// -------------------------------
|
||||
// COMMON STUFF FOR 8bpp AND 16bpp
|
||||
// -------------------------------
|
||||
extern UINT8 *ylookup[MAXVIDHEIGHT*4];
|
||||
extern UINT8 *ylookup1[MAXVIDHEIGHT*4];
|
||||
extern UINT8 *ylookup2[MAXVIDHEIGHT*4];
|
||||
extern INT32 columnofs[MAXVIDWIDTH*4];
|
||||
extern UINT8 *topleft;
|
||||
|
||||
// -------------------------
|
||||
|
|
@ -32,7 +28,6 @@ extern UINT8 *topleft;
|
|||
extern lighttable_t *dc_colormap;
|
||||
extern INT32 dc_x, dc_yl, dc_yh;
|
||||
extern fixed_t dc_iscale, dc_texturemid;
|
||||
extern UINT8 dc_hires;
|
||||
|
||||
extern UINT8 *dc_source; // first pixel in a column
|
||||
|
||||
|
|
@ -77,25 +72,6 @@ extern UINT32 nflatyshift;
|
|||
extern UINT32 nflatshiftup;
|
||||
extern UINT32 nflatmask;
|
||||
|
||||
/// \brief Top border
|
||||
#define BRDR_T 0
|
||||
/// \brief Bottom border
|
||||
#define BRDR_B 1
|
||||
/// \brief Left border
|
||||
#define BRDR_L 2
|
||||
/// \brief Right border
|
||||
#define BRDR_R 3
|
||||
/// \brief Topleft border
|
||||
#define BRDR_TL 4
|
||||
/// \brief Topright border
|
||||
#define BRDR_TR 5
|
||||
/// \brief Bottomleft border
|
||||
#define BRDR_BL 6
|
||||
/// \brief Bottomright border
|
||||
#define BRDR_BR 7
|
||||
|
||||
extern lumpnum_t viewborderlump[8];
|
||||
|
||||
// ------------------------------------------------
|
||||
// r_draw.c COMMON ROUTINES FOR BOTH 8bpp and 16bpp
|
||||
// ------------------------------------------------
|
||||
|
|
@ -169,17 +145,8 @@ boolean R_BlendLevelVisible(INT32 blendmode, INT32 alphalevel);
|
|||
extern boolean skincolor_modified[];
|
||||
|
||||
void R_InitViewBuffer(INT32 width, INT32 height);
|
||||
void R_InitViewBorder(void);
|
||||
void R_VideoErase(size_t ofs, INT32 count);
|
||||
|
||||
// Rendering function.
|
||||
#if 0
|
||||
void R_FillBackScreen(void);
|
||||
|
||||
// If the view size is not full screen, draws a border around it.
|
||||
void R_DrawViewBorder(void);
|
||||
#endif
|
||||
|
||||
#define TRANSPARENTPIXEL 255
|
||||
|
||||
// -----------------
|
||||
|
|
@ -240,17 +207,5 @@ void R_DrawTiltedTransSolidColorSpan_8(void);
|
|||
void R_DrawWaterSolidColorSpan_8(void);
|
||||
void R_DrawTiltedWaterSolidColorSpan_8(void);
|
||||
|
||||
// ------------------
|
||||
// 16bpp DRAWING CODE
|
||||
// ------------------
|
||||
|
||||
#ifdef HIGHCOLOR
|
||||
void R_DrawColumn_16(void);
|
||||
void R_DrawWallColumn_16(void);
|
||||
void R_DrawTranslucentColumn_16(void);
|
||||
void R_DrawTranslatedColumn_16(void);
|
||||
void R_DrawSpan_16(void);
|
||||
#endif
|
||||
|
||||
// =========================================================================
|
||||
#endif // __R_DRAW__
|
||||
|
|
|
|||
214
src/r_draw16.c
214
src/r_draw16.c
|
|
@ -1,214 +0,0 @@
|
|||
// SONIC ROBO BLAST 2
|
||||
//-----------------------------------------------------------------------------
|
||||
// Copyright (C) 1998-2000 by DooM Legacy Team.
|
||||
// Copyright (C) 1999-2023 by Sonic Team Junior.
|
||||
//
|
||||
// This program is free software distributed under the
|
||||
// terms of the GNU General Public License, version 2.
|
||||
// See the 'LICENSE' file for more details.
|
||||
//-----------------------------------------------------------------------------
|
||||
/// \file r_draw16.c
|
||||
/// \brief 16bpp (HIGHCOLOR) span/column drawer functions
|
||||
/// \note no includes because this is included as part of r_draw.c
|
||||
|
||||
// ==========================================================================
|
||||
// COLUMNS
|
||||
// ==========================================================================
|
||||
|
||||
/// \brief kick out the upper bit of each component (we're in 5 : 5 : 5)
|
||||
#define HIMASK1 0x7bde
|
||||
|
||||
/** \brief The R_DrawColumn_16 function
|
||||
standard upto 128high posts column drawer
|
||||
*/
|
||||
void R_DrawColumn_16(void)
|
||||
{
|
||||
INT32 count;
|
||||
INT16 *dest;
|
||||
fixed_t frac, fracstep;
|
||||
|
||||
count = dc_yh - dc_yl + 1;
|
||||
|
||||
// Zero length, column does not exceed a pixel.
|
||||
if (count <= 0)
|
||||
return;
|
||||
|
||||
#ifdef RANGECHECK
|
||||
if (dc_x >= vid.width || dc_yl < 0 || dc_yh >= vid.height)
|
||||
I_Error("R_DrawColumn_16: %d to %d at %d", dc_yl, dc_yh, dc_x);
|
||||
#endif
|
||||
|
||||
// Framebuffer destination address.
|
||||
// Use ylookup LUT to avoid multiply with ScreenWidth.
|
||||
// Use columnofs LUT for subwindows?
|
||||
dest = (INT16 *)(void *)(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-like scaling.
|
||||
// This is as fast as it gets.
|
||||
|
||||
do
|
||||
{
|
||||
// Re-map color indices from wall texture column using a lighting/special effects LUT.
|
||||
*dest = hicolormaps[((INT16 *)(void *)dc_source)[(frac>>FRACBITS)&127]>>1];
|
||||
|
||||
dest += vid.width;
|
||||
frac += fracstep;
|
||||
} while (--count);
|
||||
}
|
||||
|
||||
/** \brief The R_DrawWallColumn_16 function
|
||||
LAME cutnpaste: same as R_DrawColumn_16 but wraps around 256
|
||||
instead of 128 for the tall sky textures (256x240)
|
||||
*/
|
||||
void R_DrawWallColumn_16(void)
|
||||
{
|
||||
INT32 count;
|
||||
INT16 *dest;
|
||||
fixed_t frac, fracstep;
|
||||
|
||||
count = dc_yh - dc_yl + 1;
|
||||
|
||||
// Zero length, column does not exceed a pixel.
|
||||
if (count <= 0)
|
||||
return;
|
||||
|
||||
#ifdef RANGECHECK
|
||||
if (dc_x >= vid.width || dc_yl < 0 || dc_yh >= vid.height)
|
||||
I_Error("R_DrawWallColumn_16: %d to %d at %d", dc_yl, dc_yh, dc_x);
|
||||
#endif
|
||||
|
||||
dest = (INT16 *)(void *)(ylookup[dc_yl] + columnofs[dc_x]);
|
||||
|
||||
fracstep = dc_iscale;
|
||||
frac = dc_texturemid + (dc_yl - centery)*fracstep;
|
||||
|
||||
do
|
||||
{
|
||||
*dest = hicolormaps[((INT16 *)(void *)dc_source)[(frac>>FRACBITS)&255]>>1];
|
||||
|
||||
dest += vid.width;
|
||||
frac += fracstep;
|
||||
} while (--count);
|
||||
}
|
||||
|
||||
/** \brief The R_DrawTranslucentColumn_16 function
|
||||
LAME cutnpaste: same as R_DrawColumn_16 but does
|
||||
translucent
|
||||
*/
|
||||
void R_DrawTranslucentColumn_16(void)
|
||||
{
|
||||
INT32 count;
|
||||
INT16 *dest;
|
||||
fixed_t frac, fracstep;
|
||||
|
||||
// check out coords for src*
|
||||
if ((dc_yl < 0) || (dc_x >= vid.width))
|
||||
return;
|
||||
|
||||
count = dc_yh - dc_yl;
|
||||
if (count < 0)
|
||||
return;
|
||||
|
||||
#ifdef RANGECHECK
|
||||
if (dc_x >= vid.width || dc_yl < 0 || dc_yh >= vid.height)
|
||||
I_Error("R_DrawTranslucentColumn_16: %d to %d at %d", dc_yl, dc_yh, dc_x);
|
||||
#endif
|
||||
|
||||
// FIXME. As above.
|
||||
dest = (INT16 *)(void *)(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
|
||||
{
|
||||
*dest = (INT16)((INT16)((color8to16[dc_source[frac>>FRACBITS]]>>1) & 0x39ce)
|
||||
+ (INT16)(((*dest & HIMASK1)) & 0x7fff));
|
||||
|
||||
dest += vid.width;
|
||||
frac += fracstep;
|
||||
} while (count--);
|
||||
}
|
||||
|
||||
/** \brief The R_DrawTranslatedColumn_16 function
|
||||
?
|
||||
*/
|
||||
void R_DrawTranslatedColumn_16(void)
|
||||
{
|
||||
INT32 count;
|
||||
INT16 *dest;
|
||||
fixed_t frac, fracstep;
|
||||
|
||||
count = dc_yh - dc_yl;
|
||||
if (count < 0)
|
||||
return;
|
||||
|
||||
#ifdef RANGECHECK
|
||||
if (dc_x >= vid.width || dc_yl < 0 || dc_yh >= vid.height)
|
||||
I_Error("R_DrawTranslatedColumn_16: %d to %d at %d", dc_yl, dc_yh, dc_x);
|
||||
#endif
|
||||
|
||||
dest = (INT16 *)(void *)(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
|
||||
{
|
||||
*dest = color8to16[dc_colormap[dc_translation[dc_source[frac>>FRACBITS]]]];
|
||||
dest += vid.width;
|
||||
|
||||
frac += fracstep;
|
||||
} while (count--);
|
||||
}
|
||||
|
||||
// ==========================================================================
|
||||
// SPANS
|
||||
// ==========================================================================
|
||||
|
||||
/** \brief The R_*_16 function
|
||||
Draws the actual span.
|
||||
*/
|
||||
void R_DrawSpan_16(void)
|
||||
{
|
||||
fixed_t xfrac, yfrac;
|
||||
INT16 *dest;
|
||||
INT32 count, spot;
|
||||
|
||||
#ifdef RANGECHECK
|
||||
if (ds_x2 < ds_x1 || ds_x1 < 0 || ds_x2 >= vid.width || ds_y > vid.height)
|
||||
I_Error("R_DrawSpan_16: %d to %d at %d", ds_x1, ds_x2, ds_y);
|
||||
#endif
|
||||
|
||||
xfrac = ds_xfrac;
|
||||
yfrac = ds_yfrac;
|
||||
|
||||
dest = (INT16 *)(void *)(ylookup[ds_y] + columnofs[ds_x1]);
|
||||
|
||||
// We do not check for zero spans here?
|
||||
count = ds_x2 - ds_x1;
|
||||
|
||||
if (count <= 0) // We do now!
|
||||
return;
|
||||
|
||||
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++ = hicolormaps[((INT16 *)(void *)ds_source)[spot]>>1];
|
||||
|
||||
// Next step in u, v.
|
||||
xfrac += ds_xstep;
|
||||
yfrac += ds_ystep;
|
||||
} while (count--);
|
||||
}
|
||||
|
|
@ -40,18 +40,13 @@ void R_DrawColumn_8(void)
|
|||
#endif
|
||||
|
||||
// Framebuffer destination address.
|
||||
// Use ylookup LUT to avoid multiply with ScreenWidth.
|
||||
// Use columnofs LUT for subwindows?
|
||||
|
||||
//dest = ylookup[dc_yl] + columnofs[dc_x];
|
||||
dest = &topleft[dc_yl*vid.width + dc_x];
|
||||
|
||||
count++;
|
||||
|
||||
// Determine scaling, which is the only mapping to be done.
|
||||
fracstep = dc_iscale;
|
||||
//frac = dc_texturemid + (dc_yl - centery)*fracstep;
|
||||
frac = (dc_texturemid + FixedMul((dc_yl << FRACBITS) - centeryfrac, fracstep))*(!dc_hires);
|
||||
frac = dc_texturemid + FixedMul((dc_yl << FRACBITS) - centeryfrac, fracstep);
|
||||
|
||||
// Inner loop that does the actual texture mapping, e.g. a DDA-like scaling.
|
||||
// This is as fast as it gets.
|
||||
|
|
@ -127,14 +122,11 @@ void R_DrawShadeColumn_8(void)
|
|||
I_Error("R_DrawShadeColumn_8: %d to %d at %d", dc_yl, dc_yh, dc_x);
|
||||
#endif
|
||||
|
||||
// FIXME. As above.
|
||||
//dest = ylookup[dc_yl] + columnofs[dc_x];
|
||||
dest = &topleft[dc_yl*vid.width + dc_x];
|
||||
|
||||
// Looks familiar.
|
||||
fracstep = dc_iscale;
|
||||
//frac = dc_texturemid + (dc_yl - centery)*fracstep;
|
||||
frac = (dc_texturemid + FixedMul((dc_yl << FRACBITS) - centeryfrac, fracstep))*(!dc_hires);
|
||||
frac = dc_texturemid + FixedMul((dc_yl << FRACBITS) - centeryfrac, fracstep);
|
||||
|
||||
// Here we do an additional index re-mapping.
|
||||
do
|
||||
|
|
@ -166,14 +158,11 @@ void R_DrawTranslucentColumn_8(void)
|
|||
I_Error("R_DrawTranslucentColumn_8: %d to %d at %d", dc_yl, dc_yh, dc_x);
|
||||
#endif
|
||||
|
||||
// FIXME. As above.
|
||||
//dest = ylookup[dc_yl] + columnofs[dc_x];
|
||||
dest = &topleft[dc_yl*vid.width + dc_x];
|
||||
|
||||
// Looks familiar.
|
||||
fracstep = dc_iscale;
|
||||
//frac = dc_texturemid + (dc_yl - centery)*fracstep;
|
||||
frac = (dc_texturemid + FixedMul((dc_yl << FRACBITS) - centeryfrac, fracstep))*(!dc_hires);
|
||||
frac = dc_texturemid + FixedMul((dc_yl << FRACBITS) - centeryfrac, fracstep);
|
||||
|
||||
// Inner loop that does the actual texture mapping, e.g. a DDA-like scaling.
|
||||
// This is as fast as it gets.
|
||||
|
|
@ -271,14 +260,11 @@ void R_DrawTranslatedTranslucentColumn_8(void)
|
|||
if (count <= 0) // Zero length, column does not exceed a pixel.
|
||||
return;
|
||||
|
||||
// FIXME. As above.
|
||||
//dest = ylookup[dc_yl] + columnofs[dc_x];
|
||||
dest = &topleft[dc_yl*vid.width + dc_x];
|
||||
|
||||
// Looks familiar.
|
||||
fracstep = dc_iscale;
|
||||
//frac = dc_texturemid + (dc_yl - centery)*fracstep;
|
||||
frac = (dc_texturemid + FixedMul((dc_yl << FRACBITS) - centeryfrac, fracstep))*(!dc_hires);
|
||||
frac = dc_texturemid + FixedMul((dc_yl << FRACBITS) - centeryfrac, fracstep);
|
||||
|
||||
// Inner loop that does the actual texture mapping, e.g. a DDA-like scaling.
|
||||
// This is as fast as it gets.
|
||||
|
|
@ -347,14 +333,11 @@ void R_DrawTranslatedColumn_8(void)
|
|||
I_Error("R_DrawTranslatedColumn_8: %d to %d at %d", dc_yl, dc_yh, dc_x);
|
||||
#endif
|
||||
|
||||
// FIXME. As above.
|
||||
//dest = ylookup[dc_yl] + columnofs[dc_x];
|
||||
dest = &topleft[dc_yl*vid.width + dc_x];
|
||||
|
||||
// Looks familiar.
|
||||
fracstep = dc_iscale;
|
||||
//frac = dc_texturemid + (dc_yl-centery)*fracstep;
|
||||
frac = (dc_texturemid + FixedMul((dc_yl << FRACBITS) - centeryfrac, fracstep))*(!dc_hires);
|
||||
frac = dc_texturemid + FixedMul((dc_yl << FRACBITS) - centeryfrac, fracstep);
|
||||
|
||||
// Here we do an additional index re-mapping.
|
||||
do
|
||||
|
|
@ -410,7 +393,7 @@ void R_DrawSpan_8 (void)
|
|||
|
||||
source = ds_source;
|
||||
colormap = ds_colormap;
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
|
||||
if (dest+8 > deststop)
|
||||
return;
|
||||
|
|
@ -489,7 +472,7 @@ void R_DrawTiltedSpan_8(void)
|
|||
|
||||
R_CalcSlopeLight();
|
||||
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
source = ds_source;
|
||||
//colormap = ds_colormap;
|
||||
|
||||
|
|
@ -611,7 +594,7 @@ void R_DrawTiltedTranslucentSpan_8(void)
|
|||
|
||||
R_CalcSlopeLight();
|
||||
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
source = ds_source;
|
||||
//colormap = ds_colormap;
|
||||
|
||||
|
|
@ -733,7 +716,7 @@ void R_DrawTiltedWaterSpan_8(void)
|
|||
|
||||
R_CalcSlopeLight();
|
||||
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
dsrc = screens[1] + (ds_y+ds_bgofs)*vid.width + ds_x1;
|
||||
source = ds_source;
|
||||
//colormap = ds_colormap;
|
||||
|
|
@ -854,7 +837,7 @@ void R_DrawTiltedSplat_8(void)
|
|||
|
||||
R_CalcSlopeLight();
|
||||
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
source = ds_source;
|
||||
//colormap = ds_colormap;
|
||||
|
||||
|
|
@ -991,7 +974,7 @@ void R_DrawSplat_8 (void)
|
|||
|
||||
source = ds_source;
|
||||
colormap = ds_colormap;
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
|
||||
while (count >= 8)
|
||||
{
|
||||
|
|
@ -1111,7 +1094,7 @@ void R_DrawTranslucentSplat_8 (void)
|
|||
|
||||
source = ds_source;
|
||||
colormap = ds_colormap;
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
|
||||
while (count >= 8)
|
||||
{
|
||||
|
|
@ -1214,7 +1197,7 @@ void R_DrawFloorSprite_8 (void)
|
|||
source = (UINT16 *)ds_source;
|
||||
colormap = ds_colormap;
|
||||
translation = ds_translation;
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
|
||||
while (count >= 8)
|
||||
{
|
||||
|
|
@ -1325,7 +1308,7 @@ void R_DrawTranslucentFloorSprite_8 (void)
|
|||
source = (UINT16 *)ds_source;
|
||||
colormap = ds_colormap;
|
||||
translation = ds_translation;
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
|
||||
while (count >= 8)
|
||||
{
|
||||
|
|
@ -1420,7 +1403,7 @@ void R_DrawTiltedFloorSprite_8(void)
|
|||
uz = ds_su.z + ds_su.y*(centery-ds_y) + ds_su.x*(ds_x1-centerx);
|
||||
vz = ds_sv.z + ds_sv.y*(centery-ds_y) + ds_sv.x*(ds_x1-centerx);
|
||||
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
source = (UINT16 *)ds_source;
|
||||
colormap = ds_colormap;
|
||||
translation = ds_translation;
|
||||
|
|
@ -1529,7 +1512,7 @@ void R_DrawTiltedTranslucentFloorSprite_8(void)
|
|||
uz = ds_su.z + ds_su.y*(centery-ds_y) + ds_su.x*(ds_x1-centerx);
|
||||
vz = ds_sv.z + ds_sv.y*(centery-ds_y) + ds_sv.x*(ds_x1-centerx);
|
||||
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
source = (UINT16 *)ds_source;
|
||||
colormap = ds_colormap;
|
||||
translation = ds_translation;
|
||||
|
|
@ -1644,7 +1627,7 @@ void R_DrawTranslucentSpan_8 (void)
|
|||
|
||||
source = ds_source;
|
||||
colormap = ds_colormap;
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
|
||||
while (count >= 8)
|
||||
{
|
||||
|
|
@ -1721,7 +1704,7 @@ void R_DrawWaterSpan_8(void)
|
|||
|
||||
source = ds_source;
|
||||
colormap = ds_colormap;
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
dsrc = screens[1] + (ds_y+ds_bgofs)*vid.width + ds_x1;
|
||||
count = ds_x2 - ds_x1 + 1;
|
||||
|
||||
|
|
@ -1784,7 +1767,6 @@ void R_DrawFogSpan_8(void)
|
|||
size_t count;
|
||||
|
||||
colormap = ds_colormap;
|
||||
//dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
dest = &topleft[ds_y *vid.width + ds_x1];
|
||||
|
||||
count = ds_x2 - ds_x1 + 1;
|
||||
|
|
@ -1814,7 +1796,7 @@ void R_DrawTiltedFogSpan_8(void)
|
|||
{
|
||||
int width = ds_x2 - ds_x1;
|
||||
|
||||
UINT8 *dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
UINT8 *dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
|
||||
R_CalcSlopeLight();
|
||||
|
||||
|
|
@ -1834,7 +1816,7 @@ void R_DrawSolidColorSpan_8(void)
|
|||
size_t count = (ds_x2 - ds_x1 + 1);
|
||||
|
||||
UINT8 source = ds_colormap[ds_source[0]];
|
||||
UINT8 *dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
UINT8 *dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
|
||||
memset(dest, source, count);
|
||||
}
|
||||
|
|
@ -1847,7 +1829,7 @@ void R_DrawTransSolidColorSpan_8(void)
|
|||
size_t count = (ds_x2 - ds_x1 + 1);
|
||||
|
||||
UINT8 source = ds_colormap[ds_source[0]];
|
||||
UINT8 *dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
UINT8 *dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
|
||||
const UINT8 *deststop = screens[0] + vid.rowbytes * vid.height;
|
||||
|
||||
|
|
@ -1866,7 +1848,7 @@ void R_DrawTiltedSolidColorSpan_8(void)
|
|||
int width = ds_x2 - ds_x1;
|
||||
|
||||
UINT8 source = ds_source[0];
|
||||
UINT8 *dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
UINT8 *dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
|
||||
R_CalcSlopeLight();
|
||||
|
||||
|
|
@ -1885,7 +1867,7 @@ void R_DrawTiltedTransSolidColorSpan_8(void)
|
|||
int width = ds_x2 - ds_x1;
|
||||
|
||||
UINT8 source = ds_source[0];
|
||||
UINT8 *dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
UINT8 *dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
|
||||
R_CalcSlopeLight();
|
||||
|
||||
|
|
@ -1904,7 +1886,7 @@ void R_DrawWaterSolidColorSpan_8(void)
|
|||
{
|
||||
UINT8 source = ds_source[0];
|
||||
UINT8 *colormap = ds_colormap;
|
||||
UINT8 *dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
UINT8 *dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
UINT8 *dsrc = screens[1] + (ds_y+ds_bgofs)*vid.width + ds_x1;
|
||||
|
||||
size_t count = (ds_x2 - ds_x1 + 1);
|
||||
|
|
@ -1925,7 +1907,7 @@ void R_DrawTiltedWaterSolidColorSpan_8(void)
|
|||
int width = ds_x2 - ds_x1;
|
||||
|
||||
UINT8 source = ds_source[0];
|
||||
UINT8 *dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
UINT8 *dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
UINT8 *dsrc = screens[1] + (ds_y+ds_bgofs)*vid.width + ds_x1;
|
||||
|
||||
R_CalcSlopeLight();
|
||||
|
|
@ -1957,9 +1939,6 @@ void R_DrawFogColumn_8(void)
|
|||
#endif
|
||||
|
||||
// Framebuffer destination address.
|
||||
// Use ylookup LUT to avoid multiply with ScreenWidth.
|
||||
// Use columnofs LUT for subwindows?
|
||||
//dest = ylookup[dc_yl] + columnofs[dc_x];
|
||||
dest = &topleft[dc_yl*vid.width + dc_x];
|
||||
|
||||
// Determine scaling, which is the only mapping to be done.
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@ void R_DrawSpan_NPO2_8 (void)
|
|||
|
||||
source = ds_source;
|
||||
colormap = ds_colormap;
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
|
||||
if (dest+8 > deststop)
|
||||
return;
|
||||
|
|
@ -120,7 +120,7 @@ void R_DrawTiltedSpan_NPO2_8(void)
|
|||
|
||||
R_CalcSlopeLight();
|
||||
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
source = ds_source;
|
||||
//colormap = ds_colormap;
|
||||
|
||||
|
|
@ -309,7 +309,7 @@ void R_DrawTiltedTranslucentSpan_NPO2_8(void)
|
|||
|
||||
R_CalcSlopeLight();
|
||||
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
source = ds_source;
|
||||
//colormap = ds_colormap;
|
||||
|
||||
|
|
@ -496,7 +496,7 @@ void R_DrawTiltedSplat_NPO2_8(void)
|
|||
|
||||
R_CalcSlopeLight();
|
||||
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
source = ds_source;
|
||||
//colormap = ds_colormap;
|
||||
|
||||
|
|
@ -690,7 +690,7 @@ void R_DrawSplat_NPO2_8 (void)
|
|||
|
||||
source = ds_source;
|
||||
colormap = ds_colormap;
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
|
||||
fixedwidth = ds_flatwidth << FRACBITS;
|
||||
fixedheight = ds_flatheight << FRACBITS;
|
||||
|
|
@ -758,7 +758,7 @@ void R_DrawTranslucentSplat_NPO2_8 (void)
|
|||
|
||||
source = ds_source;
|
||||
colormap = ds_colormap;
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
|
||||
fixedwidth = ds_flatwidth << FRACBITS;
|
||||
fixedheight = ds_flatheight << FRACBITS;
|
||||
|
|
@ -828,7 +828,7 @@ void R_DrawFloorSprite_NPO2_8 (void)
|
|||
source = (UINT16 *)ds_source;
|
||||
colormap = ds_colormap;
|
||||
translation = ds_translation;
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
|
||||
fixedwidth = ds_flatwidth << FRACBITS;
|
||||
fixedheight = ds_flatheight << FRACBITS;
|
||||
|
|
@ -898,7 +898,7 @@ void R_DrawTranslucentFloorSprite_NPO2_8 (void)
|
|||
source = (UINT16 *)ds_source;
|
||||
colormap = ds_colormap;
|
||||
translation = ds_translation;
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
|
||||
fixedwidth = ds_flatwidth << FRACBITS;
|
||||
fixedheight = ds_flatheight << FRACBITS;
|
||||
|
|
@ -971,7 +971,7 @@ void R_DrawTiltedFloorSprite_NPO2_8(void)
|
|||
uz = ds_su.z + ds_su.y*(centery-ds_y) + ds_su.x*(ds_x1-centerx);
|
||||
vz = ds_sv.z + ds_sv.y*(centery-ds_y) + ds_sv.x*(ds_x1-centerx);
|
||||
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
source = (UINT16 *)ds_source;
|
||||
colormap = ds_colormap;
|
||||
translation = ds_translation;
|
||||
|
|
@ -1127,7 +1127,7 @@ void R_DrawTiltedTranslucentFloorSprite_NPO2_8(void)
|
|||
uz = ds_su.z + ds_su.y*(centery-ds_y) + ds_su.x*(ds_x1-centerx);
|
||||
vz = ds_sv.z + ds_sv.y*(centery-ds_y) + ds_sv.x*(ds_x1-centerx);
|
||||
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
source = (UINT16 *)ds_source;
|
||||
colormap = ds_colormap;
|
||||
translation = ds_translation;
|
||||
|
|
@ -1278,7 +1278,7 @@ void R_DrawTranslucentSpan_NPO2_8 (void)
|
|||
|
||||
source = ds_source;
|
||||
colormap = ds_colormap;
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
|
||||
fixedwidth = ds_flatwidth << FRACBITS;
|
||||
fixedheight = ds_flatheight << FRACBITS;
|
||||
|
|
@ -1342,7 +1342,7 @@ void R_DrawWaterSpan_NPO2_8(void)
|
|||
|
||||
source = ds_source;
|
||||
colormap = ds_colormap;
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
dsrc = screens[1] + (ds_y+ds_bgofs)*vid.width + ds_x1;
|
||||
|
||||
fixedwidth = ds_flatwidth << FRACBITS;
|
||||
|
|
@ -1414,7 +1414,7 @@ void R_DrawTiltedWaterSpan_NPO2_8(void)
|
|||
|
||||
R_CalcSlopeLight();
|
||||
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
dest = &topleft[ds_y*vid.width + ds_x1];
|
||||
dsrc = screens[1] + (ds_y+ds_bgofs)*vid.width + ds_x1;
|
||||
source = ds_source;
|
||||
//colormap = ds_colormap;
|
||||
|
|
|
|||
26
src/r_main.c
26
src/r_main.c
|
|
@ -318,7 +318,6 @@ angle_t R_PointToAngle(fixed_t x, fixed_t y)
|
|||
}
|
||||
|
||||
// This version uses 64-bit variables to avoid overflows with large values.
|
||||
// Currently used only by OpenGL rendering.
|
||||
angle_t R_PointToAngle64(INT64 x, INT64 y)
|
||||
{
|
||||
return (y -= viewy, (x -= viewx) || y) ?
|
||||
|
|
@ -384,29 +383,6 @@ fixed_t R_PointToDist(fixed_t x, fixed_t y)
|
|||
return R_PointToDist2(viewx, viewy, x, y);
|
||||
}
|
||||
|
||||
angle_t R_PointToAngleEx(INT32 x2, INT32 y2, INT32 x1, INT32 y1)
|
||||
{
|
||||
INT64 dx = x1-x2;
|
||||
INT64 dy = y1-y2;
|
||||
if (dx < INT32_MIN || dx > INT32_MAX || dy < INT32_MIN || dy > INT32_MAX)
|
||||
{
|
||||
x1 = (int)(dx / 2 + x2);
|
||||
y1 = (int)(dy / 2 + y2);
|
||||
}
|
||||
return (y1 -= y2, (x1 -= x2) || y1) ?
|
||||
x1 >= 0 ?
|
||||
y1 >= 0 ?
|
||||
(x1 > y1) ? tantoangle[SlopeDivEx(y1,x1)] : // octant 0
|
||||
ANGLE_90-tantoangle[SlopeDivEx(x1,y1)] : // octant 1
|
||||
x1 > (y1 = -y1) ? 0-tantoangle[SlopeDivEx(y1,x1)] : // octant 8
|
||||
ANGLE_270+tantoangle[SlopeDivEx(x1,y1)] : // octant 7
|
||||
y1 >= 0 ? (x1 = -x1) > y1 ? ANGLE_180-tantoangle[SlopeDivEx(y1,x1)] : // octant 3
|
||||
ANGLE_90 + tantoangle[SlopeDivEx(x1,y1)] : // octant 2
|
||||
(x1 = -x1) > (y1 = -y1) ? ANGLE_180+tantoangle[SlopeDivEx(y1,x1)] : // octant 4
|
||||
ANGLE_270-tantoangle[SlopeDivEx(x1,y1)] : // octant 5
|
||||
0;
|
||||
}
|
||||
|
||||
//
|
||||
// R_ScaleFromGlobalAngle
|
||||
// Returns the texture mapping scale for the current line (horizontal span)
|
||||
|
|
@ -1001,8 +977,6 @@ void R_Init(void)
|
|||
//I_OutputMsg("\nR_InitData");
|
||||
R_InitData();
|
||||
|
||||
//I_OutputMsg("\nR_InitViewBorder");
|
||||
R_InitViewBorder();
|
||||
R_SetViewSize(); // setsizeneeded is set true
|
||||
|
||||
// this is now done by SCR_Recalc() at the first mode set
|
||||
|
|
|
|||
|
|
@ -77,7 +77,6 @@ INT32 R_PointOnSegSide(fixed_t x, fixed_t y, seg_t *line);
|
|||
angle_t R_PointToAngle(fixed_t x, fixed_t y);
|
||||
angle_t R_PointToAngle64(INT64 x, INT64 y);
|
||||
angle_t R_PointToAngle2(fixed_t px2, fixed_t py2, fixed_t px1, fixed_t py1);
|
||||
angle_t R_PointToAngleEx(INT32 x2, INT32 y2, INT32 x1, INT32 y1);
|
||||
fixed_t R_PointToDist(fixed_t x, fixed_t y);
|
||||
fixed_t R_PointToDist2(fixed_t px2, fixed_t py2, fixed_t px1, fixed_t py1);
|
||||
|
||||
|
|
|
|||
|
|
@ -626,7 +626,7 @@ static void R_DrawSkyPlane(visplane_t *pl)
|
|||
{
|
||||
INT32 texture = texturetranslation[skytexture];
|
||||
|
||||
// Reset column drawer function (note: couldn't we just call walldrawerfunc directly?)
|
||||
// Reset column drawer function (note: couldn't we just call colfuncs[BASEDRAWFUNC] directly?)
|
||||
// (that is, unless we'll need to switch drawers in future for some reason)
|
||||
colfunc = colfuncs[BASEDRAWFUNC];
|
||||
|
||||
|
|
|
|||
|
|
@ -20,11 +20,7 @@
|
|||
|
||||
#include "w_wad.h"
|
||||
#include "z_zone.h"
|
||||
#include "netcode/d_netcmd.h"
|
||||
#include "m_misc.h"
|
||||
#include "p_local.h" // Camera...
|
||||
#include "p_slopes.h"
|
||||
#include "console.h" // con_clipviewtop
|
||||
#include "taglist.h"
|
||||
|
||||
// OPTIMIZE: closed two sided lines as single sided
|
||||
|
|
@ -484,8 +480,6 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
|
|||
sector_t tempsec;
|
||||
INT32 templight;
|
||||
INT32 i, p;
|
||||
fixed_t bottombounds = viewheight << FRACBITS;
|
||||
fixed_t topbounds = (con_clipviewtop - 1) << FRACBITS;
|
||||
fixed_t offsetvalue;
|
||||
lightlist_t *light;
|
||||
r_lightlist_t *rlight;
|
||||
|
|
@ -791,7 +785,7 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
|
|||
bottom_frac += bottom_step;
|
||||
|
||||
// SoM: If column is out of range, why bother with it??
|
||||
if (windowbottom < topbounds || windowtop > bottombounds)
|
||||
if (windowbottom < 0 || windowtop > (viewheight << FRACBITS))
|
||||
{
|
||||
if (dc_numlights)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -941,7 +941,6 @@ static void R_DrawVisSprite(vissprite_t *vis)
|
|||
}
|
||||
|
||||
colfunc = colfuncs[BASEDRAWFUNC];
|
||||
dc_hires = 0;
|
||||
|
||||
vis->x1 = x1;
|
||||
vis->x2 = x2;
|
||||
|
|
@ -3011,9 +3010,6 @@ void R_InitDrawNodes(void)
|
|||
//
|
||||
// R_DrawSprite
|
||||
//
|
||||
//Fab : 26-04-98:
|
||||
// NOTE : uses con_clipviewtop, so that when console is on,
|
||||
// don't draw the part of sprites hidden under the console
|
||||
static void R_DrawSprite(vissprite_t *spr)
|
||||
{
|
||||
mfloorclip = spr->clipbot;
|
||||
|
|
|
|||
28
src/screen.c
28
src/screen.c
|
|
@ -8,7 +8,7 @@
|
|||
// See the 'LICENSE' file for more details.
|
||||
//-----------------------------------------------------------------------------
|
||||
/// \file screen.c
|
||||
/// \brief Handles multiple resolutions, 8bpp/16bpp(highcolor) modes
|
||||
/// \brief Handles multiple resolutions
|
||||
|
||||
#include "doomdef.h"
|
||||
#include "doomstat.h"
|
||||
|
|
@ -91,19 +91,15 @@ consvar_t cv_fullscreen = CVAR_INIT ("fullscreen", "Yes", CV_SAVE|CV_CALL, CV_Ye
|
|||
// =========================================================================
|
||||
|
||||
INT32 scr_bpp; // current video mode bytes per pixel
|
||||
UINT8 *scr_borderpatch; // flat used to fill the reduced view borders set at ST_Init()
|
||||
|
||||
// =========================================================================
|
||||
|
||||
// Short and Tall sky drawer, for the current color mode
|
||||
void (*walldrawerfunc)(void);
|
||||
|
||||
void SCR_SetDrawFuncs(void)
|
||||
{
|
||||
//
|
||||
// setup the right draw routines for either 8bpp or 16bpp
|
||||
// setup the right draw routines
|
||||
//
|
||||
if (true)//vid.bpp == 1) //Always run in 8bpp. todo: remove all 16bpp code?
|
||||
if (vid.bpp == 1) //Always run in 8bpp.
|
||||
{
|
||||
colfuncs[BASEDRAWFUNC] = R_DrawColumn_8;
|
||||
spanfuncs[BASEDRAWFUNC] = R_DrawSpan_8;
|
||||
|
|
@ -139,7 +135,6 @@ void SCR_SetDrawFuncs(void)
|
|||
spanfuncs[SPANDRAWFUNC_FOG] = R_DrawFogSpan_8;
|
||||
spanfuncs[SPANDRAWFUNC_TILTEDFOG] = R_DrawTiltedFogSpan_8;
|
||||
|
||||
// Lactozilla: Non-powers-of-two
|
||||
spanfuncs_npo2[BASEDRAWFUNC] = R_DrawSpan_NPO2_8;
|
||||
spanfuncs_npo2[SPANDRAWFUNC_TRANS] = R_DrawTranslucentSpan_NPO2_8;
|
||||
spanfuncs_npo2[SPANDRAWFUNC_TILTED] = R_DrawTiltedSpan_NPO2_8;
|
||||
|
|
@ -153,26 +148,9 @@ void SCR_SetDrawFuncs(void)
|
|||
spanfuncs_npo2[SPANDRAWFUNC_TILTEDTRANSSPRITE] = R_DrawTiltedTranslucentFloorSprite_NPO2_8;
|
||||
spanfuncs_npo2[SPANDRAWFUNC_WATER] = R_DrawWaterSpan_NPO2_8;
|
||||
spanfuncs_npo2[SPANDRAWFUNC_TILTEDWATER] = R_DrawTiltedWaterSpan_NPO2_8;
|
||||
|
||||
}
|
||||
/* else if (vid.bpp > 1)
|
||||
{
|
||||
I_OutputMsg("using highcolor mode\n");
|
||||
spanfunc = basespanfunc = R_DrawSpan_16;
|
||||
transcolfunc = R_DrawTranslatedColumn_16;
|
||||
transtransfunc = R_DrawTranslucentColumn_16; // No 16bit operation for this function
|
||||
|
||||
colfunc = basecolfunc = R_DrawColumn_16;
|
||||
shadecolfunc = NULL; // detect error if used somewhere..
|
||||
fuzzcolfunc = R_DrawTranslucentColumn_16;
|
||||
walldrawerfunc = R_DrawWallColumn_16;
|
||||
}*/
|
||||
else
|
||||
I_Error("unknown bytes per pixel mode %d\n", vid.bpp);
|
||||
/*
|
||||
if (SCR_IsAspectCorrect(vid.width, vid.height))
|
||||
CONS_Alert(CONS_WARNING, M_GetText("Resolution is not aspect-correct!\nUse a multiple of %dx%d\n"), BASEVIDWIDTH, BASEVIDHEIGHT);
|
||||
*/
|
||||
}
|
||||
|
||||
void SCR_SetMode(void)
|
||||
|
|
|
|||
34
src/screen.h
34
src/screen.h
|
|
@ -8,7 +8,7 @@
|
|||
// See the 'LICENSE' file for more details.
|
||||
//-----------------------------------------------------------------------------
|
||||
/// \file screen.h
|
||||
/// \brief Handles multiple resolutions, 8bpp/16bpp(highcolor) modes
|
||||
/// \brief Handles multiple resolutions
|
||||
|
||||
#ifndef __SCREEN_H__
|
||||
#define __SCREEN_H__
|
||||
|
|
@ -61,7 +61,7 @@ typedef struct viddef_s
|
|||
UINT8 *direct; // linear frame buffer, or vga base mem.
|
||||
INT32 dup; // scale 1, 2, 3 value for menus & overlays
|
||||
INT32/*fixed_t*/ fdup; // same as dup, but exact value when aspect ratio isn't 320/200
|
||||
INT32 bpp; // BYTES per pixel: 1 = 256color, 2 = highcolor
|
||||
INT32 bpp; // BYTES per pixel: 1 = 256color
|
||||
|
||||
INT32 baseratio; // Used to get the correct value for lighting walls
|
||||
|
||||
|
|
@ -83,35 +83,6 @@ enum
|
|||
VID_GL_LIBRARY_ERROR = -1,
|
||||
};
|
||||
|
||||
// internal additional info for vesa modes only
|
||||
typedef struct
|
||||
{
|
||||
INT32 vesamode; // vesa mode number plus LINEAR_MODE bit
|
||||
void *plinearmem; // linear address of start of frame buffer
|
||||
} vesa_extra_t;
|
||||
// a video modes from the video modes list,
|
||||
// note: video mode 0 is always standard VGA320x200.
|
||||
typedef struct vmode_s
|
||||
{
|
||||
struct vmode_s *pnext;
|
||||
char *name;
|
||||
UINT32 width, height;
|
||||
UINT32 rowbytes; // bytes per scanline
|
||||
UINT32 bytesperpixel; // 1 for 256c, 2 for highcolor
|
||||
INT32 windowed; // if true this is a windowed mode
|
||||
INT32 numpages;
|
||||
vesa_extra_t *pextradata; // vesa mode extra data
|
||||
#ifdef _WIN32
|
||||
INT32 (WINAPI *setmode)(viddef_t *lvid, struct vmode_s *pcurrentmode);
|
||||
#else
|
||||
INT32 (*setmode)(viddef_t *lvid, struct vmode_s *pcurrentmode);
|
||||
#endif
|
||||
INT32 misc; // misc for display driver (r_opengl.dll etc)
|
||||
} vmode_t;
|
||||
|
||||
#define NUMSPECIALMODES 4
|
||||
extern vmode_t specialmodes[NUMSPECIALMODES];
|
||||
|
||||
// ---------------------------------------------
|
||||
// color mode dependent drawer function pointers
|
||||
// ---------------------------------------------
|
||||
|
|
@ -184,7 +155,6 @@ void SCR_ChangeRenderer(void);
|
|||
extern CV_PossibleValue_t cv_renderer_t[];
|
||||
|
||||
extern INT32 scr_bpp;
|
||||
extern UINT8 *scr_borderpatch; // patch used to fill the view borders
|
||||
|
||||
extern consvar_t cv_scr_width, cv_scr_height, cv_scr_width_w, cv_scr_height_w, cv_scr_depth, cv_fullscreen;
|
||||
extern consvar_t cv_renderview, cv_renderer;
|
||||
|
|
|
|||
|
|
@ -572,9 +572,6 @@
|
|||
<ClCompile Include="..\r_bsp.c" />
|
||||
<ClCompile Include="..\r_data.c" />
|
||||
<ClCompile Include="..\r_draw.c" />
|
||||
<ClCompile Include="..\r_draw16.c">
|
||||
<ExcludedFromBuild>true</ExcludedFromBuild>
|
||||
</ClCompile>
|
||||
<ClCompile Include="..\r_draw8.c">
|
||||
<ExcludedFromBuild>true</ExcludedFromBuild>
|
||||
</ClCompile>
|
||||
|
|
|
|||
|
|
@ -976,9 +976,6 @@
|
|||
<ClCompile Include="..\r_draw.c">
|
||||
<Filter>R_Rend</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="..\r_draw16.c">
|
||||
<Filter>R_Rend</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="..\r_draw8.c">
|
||||
<Filter>R_Rend</Filter>
|
||||
</ClCompile>
|
||||
|
|
|
|||
|
|
@ -100,8 +100,6 @@ static char vidModeName[33][32]; // allow 33 different modes
|
|||
rendermode_t rendermode = render_soft;
|
||||
rendermode_t chosenrendermode = render_none; // set by command line arguments
|
||||
|
||||
boolean highcolor = false;
|
||||
|
||||
static void VidWaitChanged(void);
|
||||
|
||||
// synchronize page flipping with screen refresh
|
||||
|
|
@ -1395,103 +1393,12 @@ INT32 VID_GetModeForSize(INT32 w, INT32 h)
|
|||
}
|
||||
}
|
||||
return -1;
|
||||
#if 0
|
||||
INT32 matchMode = -1, i;
|
||||
VID_PrepareModeList();
|
||||
if (USE_FULLSCREEN && numVidModes != -1)
|
||||
{
|
||||
for (i=firstEntry; i<numVidModes; i++)
|
||||
{
|
||||
if (modeList[i]->w == w &&
|
||||
modeList[i]->h == h)
|
||||
{
|
||||
matchMode = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (-1 == matchMode) // use smaller mode
|
||||
{
|
||||
w -= w%BASEVIDWIDTH;
|
||||
h -= h%BASEVIDHEIGHT;
|
||||
for (i=firstEntry; i<numVidModes; i++)
|
||||
{
|
||||
if (modeList[i]->w == w &&
|
||||
modeList[i]->h == h)
|
||||
{
|
||||
matchMode = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (-1 == matchMode) // use smallest mode
|
||||
matchMode = numVidModes-1;
|
||||
}
|
||||
matchMode -= firstEntry;
|
||||
}
|
||||
else
|
||||
{
|
||||
for (i=0; i<MAXWINMODES; i++)
|
||||
{
|
||||
if (windowedModes[i][0] == w &&
|
||||
windowedModes[i][1] == h)
|
||||
{
|
||||
matchMode = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (-1 == matchMode) // use smaller mode
|
||||
{
|
||||
w -= w%BASEVIDWIDTH;
|
||||
h -= h%BASEVIDHEIGHT;
|
||||
for (i=0; i<MAXWINMODES; i++)
|
||||
{
|
||||
if (windowedModes[i][0] == w &&
|
||||
windowedModes[i][1] == h)
|
||||
{
|
||||
matchMode = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (-1 == matchMode) // use smallest mode
|
||||
matchMode = MAXWINMODES-1;
|
||||
}
|
||||
}
|
||||
return matchMode;
|
||||
#endif
|
||||
}
|
||||
|
||||
void VID_PrepareModeList(void)
|
||||
{
|
||||
// Under SDL2, we just use the windowed modes list, and scale in windowed fullscreen.
|
||||
allow_fullscreen = true;
|
||||
#if 0
|
||||
INT32 i;
|
||||
|
||||
firstEntry = 0;
|
||||
|
||||
#ifdef HWRENDER
|
||||
if (rendermode == render_opengl)
|
||||
modeList = SDL_ListModes(NULL, SDL_OPENGL|SDL_FULLSCREEN);
|
||||
else
|
||||
#endif
|
||||
modeList = SDL_ListModes(NULL, surfaceFlagsF|SDL_HWSURFACE); //Alam: At least hardware surface
|
||||
|
||||
if (disable_fullscreen?0:cv_fullscreen.value) // only fullscreen needs preparation
|
||||
{
|
||||
if (-1 != numVidModes)
|
||||
{
|
||||
for (i=0; i<numVidModes; i++)
|
||||
{
|
||||
if (modeList[i]->w <= MAXVIDWIDTH &&
|
||||
modeList[i]->h <= MAXVIDHEIGHT)
|
||||
{
|
||||
firstEntry = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
allow_fullscreen = true;
|
||||
#endif
|
||||
}
|
||||
|
||||
static SDL_bool Impl_CreateContext(void)
|
||||
|
|
|
|||
|
|
@ -253,10 +253,6 @@ void ST_LoadGraphics(void)
|
|||
{
|
||||
int i;
|
||||
|
||||
// SRB2 border patch
|
||||
// st_borderpatchnum = W_GetNumForName("GFZFLR01");
|
||||
// scr_borderpatch = W_CacheLumpNum(st_borderpatchnum, PU_HUDGFX);
|
||||
|
||||
// the original Doom uses 'STF' as base name for all face graphics
|
||||
// Graue 04-08-2004: face/name graphics are now indexed by skins
|
||||
// but load them in R_AddSkins, that gets called
|
||||
|
|
|
|||
|
|
@ -81,7 +81,7 @@ extern angle_t tantoangle[SLOPERANGE+1];
|
|||
|
||||
// Utility function, called by R_PointToAngle.
|
||||
FUNCMATH unsigned SlopeDiv(unsigned num, unsigned den);
|
||||
// Only called by R_PointToAngleEx
|
||||
// Only called by R_PointToAngle64
|
||||
UINT64 SlopeDivEx(unsigned int num, unsigned int den);
|
||||
|
||||
// 360 - angle_t(ANGLE_45) = ANGLE_315
|
||||
|
|
|
|||
Loading…
Reference in a new issue