Merge remote-tracking branch 'refs/remotes/srb2public/next'
# Conflicts: # src/f_finale.c # src/hardware/hw_draw.c # src/hardware/hw_main.c # src/m_misc.c
This commit is contained in:
TehRealSalt
commit
36b52e1c67
|
|
@ -836,8 +836,9 @@ boolean CON_Responder(event_t *ev)
|
|||
return true;
|
||||
}
|
||||
|
||||
// don't eat the key
|
||||
return false;
|
||||
// ...why shouldn't it eat the key? if it doesn't, it just means you
|
||||
// can control Sonic from the console, which is silly
|
||||
return true; //return false;
|
||||
}
|
||||
|
||||
// command completion forward (tab) and backward (shift-tab)
|
||||
|
|
@ -1036,7 +1037,7 @@ boolean CON_Responder(event_t *ev)
|
|||
|
||||
// enter a char into the command prompt
|
||||
if (key < 32 || key > 127)
|
||||
return false;
|
||||
return true; // even if key can't be printed, eat it anyway
|
||||
|
||||
// add key to cmd line here
|
||||
if (key >= 'A' && key <= 'Z' && !shiftdown) //this is only really necessary for dedicated servers
|
||||
|
|
|
|||
|
|
@ -1214,22 +1214,37 @@ static inline void CL_DrawConnectionStatus(void)
|
|||
if (lastfilenum != -1)
|
||||
{
|
||||
INT32 dldlength;
|
||||
static char tempname[32];
|
||||
static char tempname[28];
|
||||
fileneeded_t *file = &fileneeded[lastfilenum];
|
||||
char *filename = file->filename;
|
||||
|
||||
Net_GetNetStat();
|
||||
dldlength = (INT32)((fileneeded[lastfilenum].currentsize/(double)fileneeded[lastfilenum].totalsize) * 256);
|
||||
dldlength = (INT32)((file->currentsize/(double)file->totalsize) * 256);
|
||||
if (dldlength > 256)
|
||||
dldlength = 256;
|
||||
V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, 256, 8, 175);
|
||||
V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, dldlength, 8, 160);
|
||||
|
||||
memset(tempname, 0, sizeof(tempname));
|
||||
nameonly(strncpy(tempname, fileneeded[lastfilenum].filename, 31));
|
||||
// offset filename to just the name only part
|
||||
filename += strlen(filename) - nameonlylength(filename);
|
||||
|
||||
if (strlen(filename) > sizeof(tempname)-1) // too long to display fully
|
||||
{
|
||||
size_t endhalfpos = strlen(filename)-10;
|
||||
// display as first 14 chars + ... + last 10 chars
|
||||
// which should add up to 27 if our math(s) is correct
|
||||
snprintf(tempname, sizeof(tempname), "%.14s...%.10s", filename, filename+endhalfpos);
|
||||
}
|
||||
else // we can copy the whole thing in safely
|
||||
{
|
||||
strncpy(tempname, filename, sizeof(tempname)-1);
|
||||
}
|
||||
|
||||
V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-24-32, V_YELLOWMAP,
|
||||
va(M_GetText("Downloading \"%s\""), tempname));
|
||||
V_DrawString(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE,
|
||||
va(" %4uK/%4uK",fileneeded[lastfilenum].currentsize>>10,fileneeded[lastfilenum].totalsize>>10));
|
||||
va(" %4uK/%4uK",fileneeded[lastfilenum].currentsize>>10,file->totalsize>>10));
|
||||
V_DrawRightAlignedString(BASEVIDWIDTH/2+128, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE,
|
||||
va("%3.1fK/s ", ((double)getbps)/1024));
|
||||
}
|
||||
|
|
@ -4148,7 +4163,8 @@ FILESTAMP
|
|||
INT32 k = *txtpak++; // playernum
|
||||
const size_t txtsize = txtpak[0]+1;
|
||||
|
||||
M_Memcpy(D_GetTextcmd(i, k), txtpak, txtsize);
|
||||
if (i >= gametic) // Don't copy old net commands
|
||||
M_Memcpy(D_GetTextcmd(i, k), txtpak, txtsize);
|
||||
txtpak += txtsize;
|
||||
}
|
||||
}
|
||||
|
|
@ -4650,6 +4666,7 @@ static void Local_Maketic(INT32 realtics)
|
|||
void SV_SpawnPlayer(INT32 playernum, INT32 x, INT32 y, angle_t angle)
|
||||
{
|
||||
tic_t tic;
|
||||
UINT8 numadjust = 0;
|
||||
|
||||
(void)x;
|
||||
(void)y;
|
||||
|
|
@ -4659,7 +4676,21 @@ void SV_SpawnPlayer(INT32 playernum, INT32 x, INT32 y, angle_t angle)
|
|||
// spawning, but will be applied afterwards.
|
||||
|
||||
for (tic = server ? maketic : (neededtic - 1); tic >= gametic; tic--)
|
||||
{
|
||||
if (numadjust++ == BACKUPTICS)
|
||||
{
|
||||
DEBFILE(va("SV_SpawnPlayer: All netcmds for player %d adjusted!\n", playernum));
|
||||
// We already adjusted them all, waste of time doing the same thing over and over
|
||||
// This shouldn't happen normally though, either gametic was 0 (which is handled now anyway)
|
||||
// or maketic >= gametic + BACKUPTICS
|
||||
// -- Monster Iestyn 16/01/18
|
||||
break;
|
||||
}
|
||||
netcmds[tic%BACKUPTICS][playernum].angleturn = (INT16)((angle>>16) | TICCMD_RECEIVED);
|
||||
|
||||
if (!tic) // failsafe for gametic == 0 -- Monster Iestyn 16/01/18
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// create missed tic
|
||||
|
|
|
|||
|
|
@ -677,7 +677,6 @@ void D_RegisterServerCommands(void)
|
|||
*/
|
||||
void D_RegisterClientCommands(void)
|
||||
{
|
||||
const char *username;
|
||||
INT32 i;
|
||||
|
||||
for (i = 0; i < MAXSKINCOLORS; i++)
|
||||
|
|
@ -738,8 +737,6 @@ void D_RegisterClientCommands(void)
|
|||
#endif
|
||||
|
||||
// register these so it is saved to config
|
||||
if ((username = I_GetUserName()))
|
||||
cv_playername.defaultvalue = username;
|
||||
CV_RegisterVar(&cv_playername);
|
||||
CV_RegisterVar(&cv_playercolor);
|
||||
CV_RegisterVar(&cv_skin); // r_things.c (skin NAME)
|
||||
|
|
@ -1800,7 +1797,12 @@ static void Command_Playdemo_f(void)
|
|||
|
||||
CONS_Printf(M_GetText("Playing back demo '%s'.\n"), name);
|
||||
|
||||
G_DoPlayDemo(name);
|
||||
// Internal if no extension, external if one exists
|
||||
// If external, convert the file name to a path in SRB2's home directory
|
||||
if (FIL_CheckExtension(name))
|
||||
G_DoPlayDemo(va("%s"PATHSEP"%s", srb2home, name));
|
||||
else
|
||||
G_DoPlayDemo(name);
|
||||
}
|
||||
|
||||
static void Command_Timedemo_f(void)
|
||||
|
|
|
|||
|
|
@ -1883,7 +1883,6 @@ static void readframe(MYFILE *f, INT32 num)
|
|||
char *word1;
|
||||
char *word2 = NULL;
|
||||
char *tmp;
|
||||
INT32 j;
|
||||
|
||||
do
|
||||
{
|
||||
|
|
@ -1898,16 +1897,6 @@ static void readframe(MYFILE *f, INT32 num)
|
|||
if (s == tmp)
|
||||
continue; // Skip comment lines, but don't break.
|
||||
|
||||
for (j = 0; s[j] != '\n'; j++)
|
||||
{
|
||||
if (s[j] == '=')
|
||||
{
|
||||
j += 2;
|
||||
j = atoi(&s[j]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
word1 = strtok(s, " ");
|
||||
if (word1)
|
||||
strupr(word1);
|
||||
|
|
|
|||
|
|
@ -222,11 +222,19 @@ static void F_SkyScroll(INT32 scrollspeed)
|
|||
#ifdef HWRENDER
|
||||
else if (rendermode != render_none)
|
||||
{ // if only software rendering could be this simple and retarded
|
||||
scrolled = animtimer;
|
||||
if (scrolled > 0)
|
||||
V_DrawScaledPatch(scrolled - SHORT(pat->width), 0, 0, pat);
|
||||
for (x = 0; x < fakedwidth; x += SHORT(pat->width))
|
||||
V_DrawScaledPatch(x + scrolled, 0, 0, pat);
|
||||
INT32 dupz = (vid.dupx < vid.dupy ? vid.dupx : vid.dupy);
|
||||
INT32 y, pw = SHORT(pat->width) * dupz, ph = SHORT(pat->height) * dupz;
|
||||
scrolled = animtimer * dupz;
|
||||
for (x = 0; x < vid.width; x += pw)
|
||||
{
|
||||
for (y = 0; y < vid.height; y += ph)
|
||||
{
|
||||
if (scrolled > 0)
|
||||
V_DrawScaledPatch(scrolled - pw, y, V_NOSCALESTART, pat);
|
||||
|
||||
V_DrawScaledPatch(x + scrolled, y, V_NOSCALESTART, pat);
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -20,8 +20,8 @@
|
|||
#define _HWR_DEFS_
|
||||
#include "../doomtype.h"
|
||||
|
||||
#define ZCLIP_PLANE 4.0f
|
||||
#define NZCLIP_PLANE 0.9f
|
||||
#define ZCLIP_PLANE 4.0f // Used for the actual game drawing
|
||||
#define NZCLIP_PLANE 0.9f // Seems to be only used for the HUD and screen textures
|
||||
|
||||
// ==========================================================================
|
||||
// SIMPLE TYPES
|
||||
|
|
@ -134,12 +134,13 @@ enum EPolyFlags
|
|||
|
||||
PF_Masked = 0x00000001, // Poly is alpha scaled and 0 alpha pels are discarded (holes in texture)
|
||||
PF_Translucent = 0x00000002, // Poly is transparent, alpha = level of transparency
|
||||
PF_Additive = 0x00000024, // Poly is added to the frame buffer
|
||||
PF_Additive = 0x00000004, // Poly is added to the frame buffer
|
||||
PF_Environment = 0x00000008, // Poly should be drawn environment mapped.
|
||||
// Hurdler: used for text drawing
|
||||
PF_Substractive = 0x00000010, // for splat
|
||||
PF_NoAlphaTest = 0x00000020, // hiden param
|
||||
PF_Blending = (PF_Environment|PF_Additive|PF_Translucent|PF_Masked|PF_Substractive)&~PF_NoAlphaTest,
|
||||
PF_Fog = 0x00000040, // Fog blocks
|
||||
PF_Blending = (PF_Environment|PF_Additive|PF_Translucent|PF_Masked|PF_Substractive|PF_Fog)&~PF_NoAlphaTest,
|
||||
|
||||
// other flag bits
|
||||
|
||||
|
|
|
|||
|
|
@ -147,10 +147,7 @@ void HWR_DrawFixedPatch(GLPatch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale,
|
|||
// | /|
|
||||
// |/ |
|
||||
// 0--1
|
||||
float sdupx = FIXED_TO_FLOAT(vid.fdupx)*2.0f;
|
||||
float sdupy = FIXED_TO_FLOAT(vid.fdupy)*2.0f;
|
||||
float pdupx = FIXED_TO_FLOAT(vid.fdupx)*2.0f*FIXED_TO_FLOAT(pscale);
|
||||
float pdupy = FIXED_TO_FLOAT(vid.fdupy)*2.0f*FIXED_TO_FLOAT(pscale);
|
||||
float dupx, dupy, fscale, fwidth, fheight;
|
||||
|
||||
if (alphalevel >= 10 && alphalevel < 13)
|
||||
return;
|
||||
|
|
@ -161,23 +158,40 @@ void HWR_DrawFixedPatch(GLPatch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale,
|
|||
else
|
||||
HWR_GetMappedPatch(gpatch, colormap);
|
||||
|
||||
dupx = (float)vid.dupx;
|
||||
dupy = (float)vid.dupy;
|
||||
|
||||
switch (option & V_SCALEPATCHMASK)
|
||||
{
|
||||
case V_NOSCALEPATCH:
|
||||
pdupx = pdupy = 2.0f;
|
||||
dupx = dupy = 1.0f;
|
||||
break;
|
||||
case V_SMALLSCALEPATCH:
|
||||
pdupx = 2.0f * FIXED_TO_FLOAT(vid.fsmalldupx);
|
||||
pdupy = 2.0f * FIXED_TO_FLOAT(vid.fsmalldupy);
|
||||
dupx = (float)vid.smalldupx;
|
||||
dupy = (float)vid.smalldupy;
|
||||
break;
|
||||
case V_MEDSCALEPATCH:
|
||||
pdupx = 2.0f * FIXED_TO_FLOAT(vid.fmeddupx);
|
||||
pdupy = 2.0f * FIXED_TO_FLOAT(vid.fmeddupy);
|
||||
dupx = (float)vid.meddupx;
|
||||
dupy = (float)vid.meddupy;
|
||||
break;
|
||||
}
|
||||
|
||||
if (option & V_NOSCALESTART)
|
||||
sdupx = sdupy = 2.0f;
|
||||
dupx = dupy = (dupx < dupy ? dupx : dupy);
|
||||
fscale = FIXED_TO_FLOAT(pscale);
|
||||
|
||||
if (option & V_OFFSET)
|
||||
{
|
||||
cx -= (float)gpatch->leftoffset * dupx * fscale;
|
||||
cy -= (float)gpatch->topoffset * dupy * fscale;
|
||||
}
|
||||
else
|
||||
{
|
||||
cy -= (float)gpatch->topoffset * fscale;
|
||||
if (option & V_FLIP)
|
||||
cx -= ((float)gpatch->width - (float)gpatch->leftoffset) * fscale;
|
||||
else
|
||||
cx -= (float)gpatch->leftoffset * fscale;
|
||||
}
|
||||
|
||||
if (option & V_SPLITSCREEN)
|
||||
cy += FIXED_TO_FLOAT((BASEVIDHEIGHT/2)<<FRACBITS);
|
||||
|
|
@ -185,19 +199,70 @@ void HWR_DrawFixedPatch(GLPatch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale,
|
|||
if (option & V_HORZSCREEN)
|
||||
cx += FIXED_TO_FLOAT((BASEVIDWIDTH/2)<<FRACBITS);
|
||||
|
||||
if (option & V_FLIP) // Need to flip both this and sow
|
||||
if (!(option & V_NOSCALESTART))
|
||||
{
|
||||
v[0].x = v[3].x = (cx*sdupx-(gpatch->width-gpatch->leftoffset)*pdupx)/vid.width - 1;
|
||||
v[2].x = v[1].x = (cx*sdupx+gpatch->leftoffset*pdupx)/vid.width - 1;
|
||||
cx = cx * dupx;
|
||||
cy = cy * dupy;
|
||||
|
||||
if (!(option & V_SCALEPATCHMASK))
|
||||
{
|
||||
// if it's meant to cover the whole screen, black out the rest
|
||||
// cx and cy are possibly *slightly* off from float maths
|
||||
// This is done before here compared to software because we directly alter cx and cy to centre
|
||||
if (cx >= -0.1f && cx <= 0.1f && SHORT(gpatch->width) == BASEVIDWIDTH && cy >= -0.1f && cy <= 0.1f && SHORT(gpatch->height) == BASEVIDHEIGHT)
|
||||
{
|
||||
// Need to temporarily cache the real patch to get the colour of the top left pixel
|
||||
patch_t *realpatch = W_CacheLumpNumPwad(gpatch->wadnum, gpatch->lumpnum, PU_STATIC);
|
||||
const column_t *column = (const column_t *)((const UINT8 *)(realpatch) + LONG((realpatch)->columnofs[0]));
|
||||
const UINT8 *source = (const UINT8 *)(column) + 3;
|
||||
HWR_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, (column->topdelta == 0xff ? 31 : source[0]));
|
||||
Z_Free(realpatch);
|
||||
}
|
||||
// centre screen
|
||||
if (vid.width != BASEVIDWIDTH * vid.dupx)
|
||||
{
|
||||
if (option & V_SNAPTORIGHT)
|
||||
cx += ((float)vid.width - ((float)BASEVIDWIDTH * dupx));
|
||||
else if (!(option & V_SNAPTOLEFT))
|
||||
cx += ((float)vid.width - ((float)BASEVIDWIDTH * dupx))/2;
|
||||
}
|
||||
if (vid.height != BASEVIDHEIGHT * vid.dupy)
|
||||
{
|
||||
if ((option & (V_SPLITSCREEN|V_SNAPTOBOTTOM)) == (V_SPLITSCREEN|V_SNAPTOBOTTOM))
|
||||
cy += ((float)vid.height/2 - ((float)BASEVIDHEIGHT/2 * dupy));
|
||||
else if (option & V_SNAPTOBOTTOM)
|
||||
cy += ((float)vid.height - ((float)BASEVIDHEIGHT * dupy));
|
||||
else if (!(option & V_SNAPTOTOP))
|
||||
cy += ((float)vid.height - ((float)BASEVIDHEIGHT * dupy))/2;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (pscale != FRACUNIT)
|
||||
{
|
||||
fwidth = (float)gpatch->width * fscale * dupx;
|
||||
fheight = (float)gpatch->height * fscale * dupy;
|
||||
}
|
||||
else
|
||||
{
|
||||
v[0].x = v[3].x = (cx*sdupx-gpatch->leftoffset*pdupx)/vid.width - 1;
|
||||
v[2].x = v[1].x = (cx*sdupx+(gpatch->width-gpatch->leftoffset)*pdupx)/vid.width - 1;
|
||||
fwidth = (float)gpatch->width * dupx;
|
||||
fheight = (float)gpatch->height * dupy;
|
||||
}
|
||||
|
||||
v[0].y = v[1].y = 1-(cy*sdupy-gpatch->topoffset*pdupy)/vid.height;
|
||||
v[2].y = v[3].y = 1-(cy*sdupy+(gpatch->height-gpatch->topoffset)*pdupy)/vid.height;
|
||||
// positions of the cx, cy, are between 0 and vid.width/vid.height now, we need them to be between -1 and 1
|
||||
cx = -1 + (cx / (vid.width/2));
|
||||
cy = 1 - (cy / (vid.height/2));
|
||||
|
||||
// fwidth and fheight are similar
|
||||
fwidth /= vid.width / 2;
|
||||
fheight /= vid.height / 2;
|
||||
|
||||
// set the polygon vertices to the right positions
|
||||
v[0].x = v[3].x = cx;
|
||||
v[2].x = v[1].x = cx + fwidth;
|
||||
|
||||
v[0].y = v[1].y = cy;
|
||||
v[2].y = v[3].y = cy - fheight;
|
||||
|
||||
v[0].z = v[1].z = v[2].z = v[3].z = 1.0f;
|
||||
|
||||
|
|
@ -250,10 +315,7 @@ void HWR_DrawCroppedPatch(GLPatch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscal
|
|||
// | /|
|
||||
// |/ |
|
||||
// 0--1
|
||||
float sdupx = FIXED_TO_FLOAT(vid.fdupx)*2.0f;
|
||||
float sdupy = FIXED_TO_FLOAT(vid.fdupy)*2.0f;
|
||||
float pdupx = FIXED_TO_FLOAT(vid.fdupx)*2.0f*FIXED_TO_FLOAT(pscale);
|
||||
float pdupy = FIXED_TO_FLOAT(vid.fdupy)*2.0f*FIXED_TO_FLOAT(pscale);
|
||||
float dupx, dupy, fscale, fwidth, fheight;
|
||||
|
||||
if (alphalevel >= 10 && alphalevel < 13)
|
||||
return;
|
||||
|
|
@ -261,28 +323,109 @@ void HWR_DrawCroppedPatch(GLPatch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscal
|
|||
// make patch ready in hardware cache
|
||||
HWR_GetPatch(gpatch);
|
||||
|
||||
dupx = (float)vid.dupx;
|
||||
dupy = (float)vid.dupy;
|
||||
|
||||
switch (option & V_SCALEPATCHMASK)
|
||||
{
|
||||
case V_NOSCALEPATCH:
|
||||
pdupx = pdupy = 2.0f;
|
||||
dupx = dupy = 1.0f;
|
||||
break;
|
||||
case V_SMALLSCALEPATCH:
|
||||
pdupx = 2.0f * FIXED_TO_FLOAT(vid.fsmalldupx);
|
||||
pdupy = 2.0f * FIXED_TO_FLOAT(vid.fsmalldupy);
|
||||
dupx = (float)vid.smalldupx;
|
||||
dupy = (float)vid.smalldupy;
|
||||
break;
|
||||
case V_MEDSCALEPATCH:
|
||||
pdupx = 2.0f * FIXED_TO_FLOAT(vid.fmeddupx);
|
||||
pdupy = 2.0f * FIXED_TO_FLOAT(vid.fmeddupy);
|
||||
dupx = (float)vid.meddupx;
|
||||
dupy = (float)vid.meddupy;
|
||||
break;
|
||||
}
|
||||
|
||||
if (option & V_NOSCALESTART)
|
||||
sdupx = sdupy = 2.0f;
|
||||
dupx = dupy = (dupx < dupy ? dupx : dupy);
|
||||
fscale = FIXED_TO_FLOAT(pscale);
|
||||
|
||||
v[0].x = v[3].x = (cx*sdupx - gpatch->leftoffset * pdupx) / vid.width - 1;
|
||||
v[2].x = v[1].x = (cx*sdupx + ((w-sx) - gpatch->leftoffset) * pdupx) / vid.width - 1;
|
||||
v[0].y = v[1].y = 1 - (cy*sdupy - gpatch->topoffset * pdupy) / vid.height;
|
||||
v[2].y = v[3].y = 1 - (cy*sdupy + ((h-sy) - gpatch->topoffset) * pdupy) / vid.height;
|
||||
cy -= (float)gpatch->topoffset * fscale;
|
||||
cx -= (float)gpatch->leftoffset * fscale;
|
||||
|
||||
if (!(option & V_NOSCALESTART))
|
||||
{
|
||||
cx = cx * dupx;
|
||||
cy = cy * dupy;
|
||||
|
||||
if (!(option & V_SCALEPATCHMASK))
|
||||
{
|
||||
// if it's meant to cover the whole screen, black out the rest
|
||||
// cx and cy are possibly *slightly* off from float maths
|
||||
// This is done before here compared to software because we directly alter cx and cy to centre
|
||||
if (cx >= -0.1f && cx <= 0.1f && SHORT(gpatch->width) == BASEVIDWIDTH && cy >= -0.1f && cy <= 0.1f && SHORT(gpatch->height) == BASEVIDHEIGHT)
|
||||
{
|
||||
// Need to temporarily cache the real patch to get the colour of the top left pixel
|
||||
patch_t *realpatch = W_CacheLumpNumPwad(gpatch->wadnum, gpatch->lumpnum, PU_STATIC);
|
||||
const column_t *column = (const column_t *)((const UINT8 *)(realpatch) + LONG((realpatch)->columnofs[0]));
|
||||
const UINT8 *source = (const UINT8 *)(column) + 3;
|
||||
HWR_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, (column->topdelta == 0xff ? 31 : source[0]));
|
||||
Z_Free(realpatch);
|
||||
}
|
||||
// centre screen
|
||||
if (vid.width != BASEVIDWIDTH * vid.dupx)
|
||||
{
|
||||
if (option & V_SNAPTORIGHT)
|
||||
cx += ((float)vid.width - ((float)BASEVIDWIDTH * dupx));
|
||||
else if (!(option & V_SNAPTOLEFT))
|
||||
cx += ((float)vid.width - ((float)BASEVIDWIDTH * dupx))/2;
|
||||
}
|
||||
if (vid.height != BASEVIDHEIGHT * vid.dupy)
|
||||
{
|
||||
if ((option & (V_SPLITSCREEN|V_SNAPTOBOTTOM)) == (V_SPLITSCREEN|V_SNAPTOBOTTOM))
|
||||
cy += ((float)vid.height/2 - ((float)BASEVIDHEIGHT/2 * dupy));
|
||||
else if (option & V_SNAPTOBOTTOM)
|
||||
cy += ((float)vid.height - ((float)BASEVIDHEIGHT * dupy));
|
||||
else if (!(option & V_SNAPTOTOP))
|
||||
cy += ((float)vid.height - ((float)BASEVIDHEIGHT * dupy))/2;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fwidth = w;
|
||||
fheight = h;
|
||||
|
||||
if (fwidth > w - sx)
|
||||
fwidth = w - sx;
|
||||
|
||||
if (fheight > h - sy)
|
||||
fheight = h - sy;
|
||||
|
||||
if (fwidth > gpatch->width)
|
||||
fwidth = gpatch->width;
|
||||
|
||||
if (fheight > gpatch->height)
|
||||
fheight = gpatch->height;
|
||||
|
||||
if (pscale != FRACUNIT)
|
||||
{
|
||||
fwidth *= fscale * dupx;
|
||||
fheight *= fscale * dupy;
|
||||
}
|
||||
else
|
||||
{
|
||||
fwidth *= dupx;
|
||||
fheight *= dupy;
|
||||
}
|
||||
|
||||
// positions of the cx, cy, are between 0 and vid.width/vid.height now, we need them to be between -1 and 1
|
||||
cx = -1 + (cx / (vid.width/2));
|
||||
cy = 1 - (cy / (vid.height/2));
|
||||
|
||||
// fwidth and fheight are similar
|
||||
fwidth /= vid.width / 2;
|
||||
fheight /= vid.height / 2;
|
||||
|
||||
// set the polygon vertices to the right positions
|
||||
v[0].x = v[3].x = cx;
|
||||
v[2].x = v[1].x = cx + fwidth;
|
||||
|
||||
v[0].y = v[1].y = cy;
|
||||
v[2].y = v[3].y = cy - fheight;
|
||||
|
||||
v[0].z = v[1].z = v[2].z = v[3].z = 1.0f;
|
||||
|
||||
|
|
@ -659,7 +802,7 @@ void HWR_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 color)
|
|||
{
|
||||
FOutVector v[4];
|
||||
FSurfaceInfo Surf;
|
||||
float sdupx, sdupy;
|
||||
float fx, fy, fw, fh;
|
||||
|
||||
if (w < 0 || h < 0)
|
||||
return; // consistency w/ software
|
||||
|
|
@ -668,16 +811,79 @@ void HWR_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 color)
|
|||
// | /|
|
||||
// |/ |
|
||||
// 0--1
|
||||
sdupx = FIXED_TO_FLOAT(vid.fdupx)*2.0f;
|
||||
sdupy = FIXED_TO_FLOAT(vid.fdupy)*2.0f;
|
||||
|
||||
if (color & V_NOSCALESTART)
|
||||
sdupx = sdupy = 2.0f;
|
||||
fx = (float)x;
|
||||
fy = (float)y;
|
||||
fw = (float)w;
|
||||
fh = (float)h;
|
||||
|
||||
v[0].x = v[3].x = (x*sdupx)/vid.width - 1;
|
||||
v[2].x = v[1].x = (x*sdupx + w*sdupx)/vid.width - 1;
|
||||
v[0].y = v[1].y = 1-(y*sdupy)/vid.height;
|
||||
v[2].y = v[3].y = 1-(y*sdupy + h*sdupy)/vid.height;
|
||||
if (!(color & V_NOSCALESTART))
|
||||
{
|
||||
float dupx = (float)vid.dupx, dupy = (float)vid.dupy;
|
||||
|
||||
if (x == 0 && y == 0 && w == BASEVIDWIDTH && h == BASEVIDHEIGHT)
|
||||
{
|
||||
RGBA_t rgbaColour = V_GetColor(color);
|
||||
FRGBAFloat clearColour;
|
||||
clearColour.red = (float)rgbaColour.s.red / 255;
|
||||
clearColour.green = (float)rgbaColour.s.green / 255;
|
||||
clearColour.blue = (float)rgbaColour.s.blue / 255;
|
||||
clearColour.alpha = 1;
|
||||
HWD.pfnClearBuffer(true, false, &clearColour);
|
||||
return;
|
||||
}
|
||||
|
||||
fx *= dupx;
|
||||
fy *= dupy;
|
||||
fw *= dupx;
|
||||
fh *= dupy;
|
||||
|
||||
if (vid.width != BASEVIDWIDTH * vid.dupx)
|
||||
{
|
||||
if (color & V_SNAPTORIGHT)
|
||||
fx += ((float)vid.width - ((float)BASEVIDWIDTH * dupx));
|
||||
else if (!(color & V_SNAPTOLEFT))
|
||||
fx += ((float)vid.width - ((float)BASEVIDWIDTH * dupx)) / 2;
|
||||
}
|
||||
if (vid.height != BASEVIDHEIGHT * dupy)
|
||||
{
|
||||
// same thing here
|
||||
if (color & V_SNAPTOBOTTOM)
|
||||
fy += ((float)vid.height - ((float)BASEVIDHEIGHT * dupy));
|
||||
else if (!(color & V_SNAPTOTOP))
|
||||
fy += ((float)vid.height - ((float)BASEVIDHEIGHT * dupy)) / 2;
|
||||
}
|
||||
}
|
||||
|
||||
if (fx >= vid.width || fy >= vid.height)
|
||||
return;
|
||||
if (fx < 0)
|
||||
{
|
||||
fw += fx;
|
||||
fx = 0;
|
||||
}
|
||||
if (fy < 0)
|
||||
{
|
||||
fh += fy;
|
||||
fy = 0;
|
||||
}
|
||||
|
||||
if (fw <= 0 || fh <= 0)
|
||||
return;
|
||||
if (fx + fw > vid.width)
|
||||
fw = (float)vid.width - fx;
|
||||
if (fy + fh > vid.height)
|
||||
fh = (float)vid.height - fy;
|
||||
|
||||
fx = -1 + fx / (vid.width / 2);
|
||||
fy = 1 - fy / (vid.height / 2);
|
||||
fw = fw / (vid.width / 2);
|
||||
fh = fh / (vid.height / 2);
|
||||
|
||||
v[0].x = v[3].x = fx;
|
||||
v[2].x = v[1].x = fx + fw;
|
||||
v[0].y = v[1].y = fy;
|
||||
v[2].y = v[3].y = fy - fh;
|
||||
|
||||
//Hurdler: do we still use this argb color? if not, we should remove it
|
||||
v[0].argb = v[1].argb = v[2].argb = v[3].argb = 0xff00ff00; //;
|
||||
|
|
|
|||
|
|
@ -79,6 +79,7 @@ EXPORT char *HWRAPI(GetRenderer) (void);
|
|||
#define SCREENVERTS 10
|
||||
EXPORT void HWRAPI(PostImgRedraw) (float points[SCREENVERTS][SCREENVERTS][2]);
|
||||
#endif
|
||||
EXPORT void HWRAPI(FlushScreenTextures) (void);
|
||||
EXPORT void HWRAPI(StartScreenWipe) (void);
|
||||
EXPORT void HWRAPI(EndScreenWipe) (void);
|
||||
EXPORT void HWRAPI(DoScreenWipe) (float alpha);
|
||||
|
|
@ -124,6 +125,7 @@ struct hwdriver_s
|
|||
#ifdef SHUFFLE
|
||||
PostImgRedraw pfnPostImgRedraw;
|
||||
#endif
|
||||
FlushScreenTextures pfnFlushScreenTextures;
|
||||
StartScreenWipe pfnStartScreenWipe;
|
||||
EndScreenWipe pfnEndScreenWipe;
|
||||
DoScreenWipe pfnDoScreenWipe;
|
||||
|
|
|
|||
|
|
@ -68,6 +68,7 @@ typedef struct gr_vissprite_s
|
|||
struct gr_vissprite_s *prev;
|
||||
struct gr_vissprite_s *next;
|
||||
float x1, x2;
|
||||
float z1, z2;
|
||||
float tz, ty;
|
||||
lumpnum_t patchlumpnum;
|
||||
boolean flip;
|
||||
|
|
@ -78,7 +79,6 @@ typedef struct gr_vissprite_s
|
|||
//Hurdler: 25/04/2000: now support colormap in hardware mode
|
||||
UINT8 *colormap;
|
||||
INT32 dispoffset; // copy of info->dispoffset, affects ordering but not drawing
|
||||
float z1, z2;
|
||||
} gr_vissprite_t;
|
||||
|
||||
// --------
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -59,7 +59,7 @@ typedef struct GLRGBAFloat GLRGBAFloat;
|
|||
#define N_PI_DEMI (M_PIl/2.0f) //(1.5707963268f)
|
||||
|
||||
#define ASPECT_RATIO (1.0f) //(320.0f/200.0f)
|
||||
#define FAR_CLIPPING_PLANE 150000.0f // Draw further! Tails 01-21-2001
|
||||
#define FAR_CLIPPING_PLANE 32768.0f // Draw further! Tails 01-21-2001
|
||||
static float NEAR_CLIPPING_PLANE = NZCLIP_PLANE;
|
||||
|
||||
// **************************************************************************
|
||||
|
|
@ -107,10 +107,19 @@ static GLint viewport[4];
|
|||
#endif
|
||||
|
||||
// Yay for arbitrary numbers! NextTexAvail is buggy for some reason.
|
||||
static GLuint screentexture = 60000;
|
||||
static GLuint startScreenWipe = 60001;
|
||||
static GLuint endScreenWipe = 60002;
|
||||
static GLuint finalScreenTexture = 60003;
|
||||
// Sryder: NextTexAvail is broken for these because palette changes or changes to the texture filter or antialiasing
|
||||
// flush all of the stored textures, leaving them unavailable at times such as between levels
|
||||
// These need to start at 0 and be set to their number, and be reset to 0 when deleted so that intel GPUs
|
||||
// can know when the textures aren't there, as textures are always considered resident in their virtual memory
|
||||
// TODO: Store them in a more normal way
|
||||
#define SCRTEX_SCREENTEXTURE 65535
|
||||
#define SCRTEX_STARTSCREENWIPE 65534
|
||||
#define SCRTEX_ENDSCREENWIPE 65533
|
||||
#define SCRTEX_FINALSCREENTEXTURE 65532
|
||||
static GLuint screentexture = 0;
|
||||
static GLuint startScreenWipe = 0;
|
||||
static GLuint endScreenWipe = 0;
|
||||
static GLuint finalScreenTexture = 0;
|
||||
#if 0
|
||||
GLuint screentexture = FIRST_TEX_AVAIL;
|
||||
#endif
|
||||
|
|
@ -263,6 +272,7 @@ FUNCPRINTF void DBG_Printf(const char *lpFmt, ...)
|
|||
/* texture mapping */ //GL_EXT_copy_texture
|
||||
#ifndef KOS_GL_COMPATIBILITY
|
||||
#define pglCopyTexImage2D glCopyTexImage2D
|
||||
#define pglCopyTexSubImage2D glCopyTexSubImage2D
|
||||
#endif
|
||||
|
||||
#else //!STATIC_OPENGL
|
||||
|
|
@ -387,6 +397,8 @@ static PFNglBindTexture pglBindTexture;
|
|||
/* texture mapping */ //GL_EXT_copy_texture
|
||||
typedef void (APIENTRY * PFNglCopyTexImage2D) (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
|
||||
static PFNglCopyTexImage2D pglCopyTexImage2D;
|
||||
typedef void (APIENTRY * PFNglCopyTexSubImage2D) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
|
||||
static PFNglCopyTexSubImage2D pglCopyTexSubImage2D;
|
||||
#endif
|
||||
/* GLU functions */
|
||||
typedef GLint (APIENTRY * PFNgluBuild2DMipmaps) (GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *data);
|
||||
|
|
@ -503,6 +515,7 @@ boolean SetupGLfunc(void)
|
|||
GETOPENGLFUNC(pglBindTexture , glBindTexture)
|
||||
|
||||
GETOPENGLFUNC(pglCopyTexImage2D , glCopyTexImage2D)
|
||||
GETOPENGLFUNC(pglCopyTexSubImage2D , glCopyTexSubImage2D)
|
||||
|
||||
#undef GETOPENGLFUNC
|
||||
|
||||
|
|
@ -654,6 +667,10 @@ void SetModelView(GLint w, GLint h)
|
|||
{
|
||||
// DBG_Printf("SetModelView(): %dx%d\n", (int)w, (int)h);
|
||||
|
||||
// The screen textures need to be flushed if the width or height change so that they be remade for the correct size
|
||||
if (screen_width != w || screen_height != h)
|
||||
FlushScreenTextures();
|
||||
|
||||
screen_width = w;
|
||||
screen_height = h;
|
||||
|
||||
|
|
@ -801,6 +818,7 @@ void Flush(void)
|
|||
screentexture = FIRST_TEX_AVAIL;
|
||||
}
|
||||
#endif
|
||||
|
||||
tex_downloaded = 0;
|
||||
}
|
||||
|
||||
|
|
@ -1056,30 +1074,56 @@ EXPORT void HWRAPI(SetBlend) (FBITFIELD PolyFlags)
|
|||
switch (PolyFlags & PF_Blending) {
|
||||
case PF_Translucent & PF_Blending:
|
||||
pglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // alpha = level of transparency
|
||||
#ifndef KOS_GL_COMPATIBILITY
|
||||
pglAlphaFunc(GL_NOTEQUAL, 0.0f);
|
||||
#endif
|
||||
break;
|
||||
case PF_Masked & PF_Blending:
|
||||
// Hurdler: does that mean lighting is only made by alpha src?
|
||||
// it sounds ok, but not for polygonsmooth
|
||||
pglBlendFunc(GL_SRC_ALPHA, GL_ZERO); // 0 alpha = holes in texture
|
||||
#ifndef KOS_GL_COMPATIBILITY
|
||||
pglAlphaFunc(GL_GREATER, 0.5f);
|
||||
#endif
|
||||
break;
|
||||
case PF_Additive & PF_Blending:
|
||||
#ifdef ATI_RAGE_PRO_COMPATIBILITY
|
||||
pglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // alpha = level of transparency
|
||||
#else
|
||||
pglBlendFunc(GL_SRC_ALPHA, GL_ONE); // src * alpha + dest
|
||||
#endif
|
||||
#ifndef KOS_GL_COMPATIBILITY
|
||||
pglAlphaFunc(GL_NOTEQUAL, 0.0f);
|
||||
#endif
|
||||
break;
|
||||
case PF_Environment & PF_Blending:
|
||||
pglBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
|
||||
#ifndef KOS_GL_COMPATIBILITY
|
||||
pglAlphaFunc(GL_NOTEQUAL, 0.0f);
|
||||
#endif
|
||||
break;
|
||||
case PF_Substractive & PF_Blending:
|
||||
// good for shadow
|
||||
// not realy but what else ?
|
||||
pglBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
|
||||
#ifndef KOS_GL_COMPATIBILITY
|
||||
pglAlphaFunc(GL_NOTEQUAL, 0.0f);
|
||||
#endif
|
||||
break;
|
||||
case PF_Fog & PF_Fog:
|
||||
// Sryder: Fog
|
||||
// multiplies input colour by input alpha, and destination colour by input colour, then adds them
|
||||
pglBlendFunc(GL_SRC_ALPHA, GL_SRC_COLOR);
|
||||
#ifndef KOS_GL_COMPATIBILITY
|
||||
pglAlphaFunc(GL_NOTEQUAL, 0.0f);
|
||||
#endif
|
||||
break;
|
||||
default : // must be 0, otherwise it's an error
|
||||
// No blending
|
||||
pglBlendFunc(GL_ONE, GL_ZERO); // the same as no blending
|
||||
#ifndef KOS_GL_COMPATIBILITY
|
||||
pglAlphaFunc(GL_GREATER, 0.5f);
|
||||
#endif
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -1339,6 +1383,7 @@ EXPORT void HWRAPI(SetTexture) (FTextureInfo *pTexInfo)
|
|||
tex[w*j+i].s.green = 0;
|
||||
tex[w*j+i].s.blue = 0;
|
||||
tex[w*j+i].s.alpha = 0;
|
||||
pTexInfo->flags |= TF_TRANSPARENT; // there is a hole in it
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -1409,8 +1454,22 @@ EXPORT void HWRAPI(SetTexture) (FTextureInfo *pTexInfo)
|
|||
tex_downloaded = pTexInfo->downloaded;
|
||||
pglBindTexture(GL_TEXTURE_2D, pTexInfo->downloaded);
|
||||
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mag_filter);
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, min_filter);
|
||||
// disable texture filtering on any texture that has holes so there's no dumb borders or blending issues
|
||||
if (pTexInfo->flags & TF_TRANSPARENT)
|
||||
{
|
||||
#ifdef KOS_GL_COMPATIBILITY
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NONE);
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NONE);
|
||||
#else
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mag_filter);
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, min_filter);
|
||||
}
|
||||
|
||||
#ifdef KOS_GL_COMPATIBILITY
|
||||
pglTexImage2D(GL_TEXTURE_2D, 0, GL_ARGB4444, w, h, 0, GL_ARGB4444, GL_UNSIGNED_BYTE, ptex);
|
||||
|
|
@ -1864,12 +1923,6 @@ static void DrawMD2Ex(INT32 *gl_cmd_buffer, md2_frame_t *frame, INT32 duration,
|
|||
ambient[1] = 0.75f;
|
||||
if (ambient[2] > 0.75f)
|
||||
ambient[2] = 0.75f;
|
||||
|
||||
if (color[3] < 255)
|
||||
{
|
||||
pglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
||||
pglDepthMask(GL_FALSE);
|
||||
}
|
||||
}
|
||||
|
||||
pglEnable(GL_CULL_FACE);
|
||||
|
|
@ -1898,10 +1951,12 @@ static void DrawMD2Ex(INT32 *gl_cmd_buffer, md2_frame_t *frame, INT32 duration,
|
|||
pglMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambient);
|
||||
pglMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diffuse);
|
||||
#endif
|
||||
if (color[3] < 255)
|
||||
SetBlend(PF_Translucent|PF_Modulated|PF_Clip);
|
||||
else
|
||||
SetBlend(PF_Masked|PF_Modulated|PF_Occlude|PF_Clip);
|
||||
}
|
||||
|
||||
DrawPolygon(NULL, NULL, 0, PF_Masked|PF_Modulated|PF_Occlude|PF_Clip);
|
||||
|
||||
pglPushMatrix(); // should be the same as glLoadIdentity
|
||||
//Hurdler: now it seems to work
|
||||
pglTranslatef(pos->x, pos->z, pos->y);
|
||||
|
|
@ -1909,14 +1964,6 @@ static void DrawMD2Ex(INT32 *gl_cmd_buffer, md2_frame_t *frame, INT32 duration,
|
|||
scaley = -scaley;
|
||||
pglRotatef(pos->angley, 0.0f, -1.0f, 0.0f);
|
||||
pglRotatef(pos->anglex, -1.0f, 0.0f, 0.0f);
|
||||
//pglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // alpha = level of transparency
|
||||
|
||||
// Remove depth mask when the model is transparent so it doesn't cut thorugh sprites // SRB2CBTODO: For all stuff too?!
|
||||
if (color && color[3] < 255)
|
||||
{
|
||||
pglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // alpha = level of transparency
|
||||
pglDepthMask(GL_FALSE);
|
||||
}
|
||||
|
||||
val = *gl_cmd_buffer++;
|
||||
|
||||
|
|
@ -1984,7 +2031,6 @@ static void DrawMD2Ex(INT32 *gl_cmd_buffer, md2_frame_t *frame, INT32 duration,
|
|||
if (color)
|
||||
pglDisable(GL_LIGHTING);
|
||||
pglShadeModel(GL_FLAT);
|
||||
pglDepthMask(GL_TRUE);
|
||||
pglDisable(GL_CULL_FACE);
|
||||
}
|
||||
|
||||
|
|
@ -2139,10 +2185,25 @@ EXPORT void HWRAPI(PostImgRedraw) (float points[SCREENVERTS][SCREENVERTS][2])
|
|||
}
|
||||
#endif //SHUFFLE
|
||||
|
||||
// Sryder: This needs to be called whenever the screen changes resolution in order to reset the screen textures to use
|
||||
// a new size
|
||||
EXPORT void HWRAPI(FlushScreenTextures) (void)
|
||||
{
|
||||
pglDeleteTextures(1, &screentexture);
|
||||
pglDeleteTextures(1, &startScreenWipe);
|
||||
pglDeleteTextures(1, &endScreenWipe);
|
||||
pglDeleteTextures(1, &finalScreenTexture);
|
||||
screentexture = 0;
|
||||
startScreenWipe = 0;
|
||||
endScreenWipe = 0;
|
||||
finalScreenTexture = 0;
|
||||
}
|
||||
|
||||
// Create Screen to fade from
|
||||
EXPORT void HWRAPI(StartScreenWipe) (void)
|
||||
{
|
||||
INT32 texsize = 2048;
|
||||
boolean firstTime = (startScreenWipe == 0);
|
||||
|
||||
// Use a power of two texture, dammit
|
||||
if(screen_width <= 512)
|
||||
|
|
@ -2151,27 +2212,38 @@ EXPORT void HWRAPI(StartScreenWipe) (void)
|
|||
texsize = 1024;
|
||||
|
||||
// Create screen texture
|
||||
if (firstTime)
|
||||
startScreenWipe = SCRTEX_STARTSCREENWIPE;
|
||||
pglBindTexture(GL_TEXTURE_2D, startScreenWipe);
|
||||
|
||||
if (firstTime)
|
||||
{
|
||||
#ifdef KOS_GL_COMPATIBILITY
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_FILTER_NONE);
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_FILTER_NONE);
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_FILTER_NONE);
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_FILTER_NONE);
|
||||
#else
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||||
#endif
|
||||
Clamp2D(GL_TEXTURE_WRAP_S);
|
||||
Clamp2D(GL_TEXTURE_WRAP_T);
|
||||
Clamp2D(GL_TEXTURE_WRAP_S);
|
||||
Clamp2D(GL_TEXTURE_WRAP_T);
|
||||
#ifndef KOS_GL_COMPATIBILITY
|
||||
pglCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, texsize, texsize, 0);
|
||||
pglCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, texsize, texsize, 0);
|
||||
#endif
|
||||
}
|
||||
else
|
||||
#ifndef KOS_GL_COMPATIBILITY
|
||||
pglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, texsize, texsize);
|
||||
#endif
|
||||
|
||||
tex_downloaded = 0; // 0 so it knows it doesn't have any of the cached patches downloaded right now
|
||||
tex_downloaded = startScreenWipe;
|
||||
}
|
||||
|
||||
// Create Screen to fade to
|
||||
EXPORT void HWRAPI(EndScreenWipe)(void)
|
||||
{
|
||||
INT32 texsize = 2048;
|
||||
boolean firstTime = (endScreenWipe == 0);
|
||||
|
||||
// Use a power of two texture, dammit
|
||||
if(screen_width <= 512)
|
||||
|
|
@ -2180,21 +2252,32 @@ EXPORT void HWRAPI(EndScreenWipe)(void)
|
|||
texsize = 1024;
|
||||
|
||||
// Create screen texture
|
||||
if (firstTime)
|
||||
endScreenWipe = SCRTEX_ENDSCREENWIPE;
|
||||
pglBindTexture(GL_TEXTURE_2D, endScreenWipe);
|
||||
|
||||
if (firstTime)
|
||||
{
|
||||
#ifdef KOS_GL_COMPATIBILITY
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_FILTER_NONE);
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_FILTER_NONE);
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_FILTER_NONE);
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_FILTER_NONE);
|
||||
#else
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||||
#endif
|
||||
Clamp2D(GL_TEXTURE_WRAP_S);
|
||||
Clamp2D(GL_TEXTURE_WRAP_T);
|
||||
Clamp2D(GL_TEXTURE_WRAP_S);
|
||||
Clamp2D(GL_TEXTURE_WRAP_T);
|
||||
#ifndef KOS_GL_COMPATIBILITY
|
||||
pglCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, texsize, texsize, 0);
|
||||
pglCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, texsize, texsize, 0);
|
||||
#endif
|
||||
}
|
||||
else
|
||||
#ifndef KOS_GL_COMPATIBILITY
|
||||
pglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, texsize, texsize);
|
||||
#endif
|
||||
|
||||
tex_downloaded = 0; // 0 so it knows it doesn't have any of the cached patches downloaded right now
|
||||
|
||||
tex_downloaded = endScreenWipe;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -2236,7 +2319,7 @@ EXPORT void HWRAPI(DrawIntermissionBG)(void)
|
|||
|
||||
pglEnd();
|
||||
|
||||
tex_downloaded = 0; // 0 so it knows it doesn't have any of the cached patches downloaded right now
|
||||
tex_downloaded = screentexture;
|
||||
}
|
||||
|
||||
// Do screen fades!
|
||||
|
|
@ -2327,6 +2410,7 @@ EXPORT void HWRAPI(DoScreenWipe)(float alpha)
|
|||
|
||||
pglDisable(GL_TEXTURE_2D); // disable the texture in the 2nd texture unit
|
||||
pglActiveTexture(GL_TEXTURE0);
|
||||
tex_downloaded = endScreenWipe;
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -2352,11 +2436,10 @@ EXPORT void HWRAPI(DoScreenWipe)(float alpha)
|
|||
pglTexCoord2f(xfix, 0.0f);
|
||||
pglVertex3f(1.0f, -1.0f, 1.0f);
|
||||
pglEnd();
|
||||
tex_downloaded = endScreenWipe;
|
||||
#ifndef MINI_GL_COMPATIBILITY
|
||||
}
|
||||
#endif
|
||||
|
||||
tex_downloaded = 0; // 0 so it knows it doesn't have any of the cached patches downloaded right now
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -2364,6 +2447,7 @@ EXPORT void HWRAPI(DoScreenWipe)(float alpha)
|
|||
EXPORT void HWRAPI(MakeScreenTexture) (void)
|
||||
{
|
||||
INT32 texsize = 2048;
|
||||
boolean firstTime = (screentexture == 0);
|
||||
|
||||
// Use a power of two texture, dammit
|
||||
if(screen_width <= 512)
|
||||
|
|
@ -2372,26 +2456,37 @@ EXPORT void HWRAPI(MakeScreenTexture) (void)
|
|||
texsize = 1024;
|
||||
|
||||
// Create screen texture
|
||||
if (firstTime)
|
||||
screentexture = SCRTEX_SCREENTEXTURE;
|
||||
pglBindTexture(GL_TEXTURE_2D, screentexture);
|
||||
|
||||
if (firstTime)
|
||||
{
|
||||
#ifdef KOS_GL_COMPATIBILITY
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_FILTER_NONE);
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_FILTER_NONE);
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_FILTER_NONE);
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_FILTER_NONE);
|
||||
#else
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||||
#endif
|
||||
Clamp2D(GL_TEXTURE_WRAP_S);
|
||||
Clamp2D(GL_TEXTURE_WRAP_T);
|
||||
Clamp2D(GL_TEXTURE_WRAP_S);
|
||||
Clamp2D(GL_TEXTURE_WRAP_T);
|
||||
#ifndef KOS_GL_COMPATIBILITY
|
||||
pglCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, texsize, texsize, 0);
|
||||
pglCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, texsize, texsize, 0);
|
||||
#endif
|
||||
}
|
||||
else
|
||||
#ifndef KOS_GL_COMPATIBILITY
|
||||
pglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, texsize, texsize);
|
||||
#endif
|
||||
|
||||
tex_downloaded = 0; // 0 so it knows it doesn't have any of the cached patches downloaded right now
|
||||
tex_downloaded = screentexture;
|
||||
}
|
||||
|
||||
EXPORT void HWRAPI(MakeScreenFinalTexture) (void)
|
||||
{
|
||||
INT32 texsize = 2048;
|
||||
boolean firstTime = (finalScreenTexture == 0);
|
||||
|
||||
// Use a power of two texture, dammit
|
||||
if(screen_width <= 512)
|
||||
|
|
@ -2400,27 +2495,40 @@ EXPORT void HWRAPI(MakeScreenFinalTexture) (void)
|
|||
texsize = 1024;
|
||||
|
||||
// Create screen texture
|
||||
if (firstTime)
|
||||
finalScreenTexture = SCRTEX_FINALSCREENTEXTURE;
|
||||
pglBindTexture(GL_TEXTURE_2D, finalScreenTexture);
|
||||
|
||||
if (firstTime)
|
||||
{
|
||||
#ifdef KOS_GL_COMPATIBILITY
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_FILTER_NONE);
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_FILTER_NONE);
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_FILTER_NONE);
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_FILTER_NONE);
|
||||
#else
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||||
#endif
|
||||
Clamp2D(GL_TEXTURE_WRAP_S);
|
||||
Clamp2D(GL_TEXTURE_WRAP_T);
|
||||
Clamp2D(GL_TEXTURE_WRAP_S);
|
||||
Clamp2D(GL_TEXTURE_WRAP_T);
|
||||
#ifndef KOS_GL_COMPATIBILITY
|
||||
pglCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, texsize, texsize, 0);
|
||||
pglCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, texsize, texsize, 0);
|
||||
#endif
|
||||
}
|
||||
else
|
||||
#ifndef KOS_GL_COMPATIBILITY
|
||||
pglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, texsize, texsize);
|
||||
#endif
|
||||
|
||||
tex_downloaded = 0; // 0 so it knows it doesn't have any of the cached patches downloaded right now
|
||||
tex_downloaded = finalScreenTexture;
|
||||
|
||||
}
|
||||
|
||||
EXPORT void HWRAPI(DrawScreenFinalTexture)(int width, int height)
|
||||
{
|
||||
float xfix, yfix;
|
||||
float origaspect, newaspect;
|
||||
float xoff = 1, yoff = 1; // xoffset and yoffset for the polygon to have black bars around the screen
|
||||
FRGBAFloat clearColour;
|
||||
INT32 texsize = 2048;
|
||||
|
||||
if(screen_width <= 1024)
|
||||
|
|
@ -2431,35 +2539,47 @@ EXPORT void HWRAPI(DrawScreenFinalTexture)(int width, int height)
|
|||
xfix = 1/((float)(texsize)/((float)((screen_width))));
|
||||
yfix = 1/((float)(texsize)/((float)((screen_height))));
|
||||
|
||||
//pglClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
|
||||
origaspect = (float)screen_width / screen_height;
|
||||
newaspect = (float)width / height;
|
||||
if (origaspect < newaspect)
|
||||
{
|
||||
xoff = origaspect / newaspect;
|
||||
yoff = 1;
|
||||
}
|
||||
else if (origaspect > newaspect)
|
||||
{
|
||||
xoff = 1;
|
||||
yoff = newaspect / origaspect;
|
||||
}
|
||||
|
||||
pglViewport(0, 0, width, height);
|
||||
|
||||
clearColour.red = clearColour.green = clearColour.blue = 0;
|
||||
clearColour.alpha = 1;
|
||||
ClearBuffer(true, false, &clearColour);
|
||||
pglBindTexture(GL_TEXTURE_2D, finalScreenTexture);
|
||||
pglBegin(GL_QUADS);
|
||||
|
||||
pglColor4f(1.0f, 1.0f, 1.0f, 1.0f);
|
||||
// Bottom left
|
||||
pglTexCoord2f(0.0f, 0.0f);
|
||||
pglVertex3f(-1, -1, 1.0f);
|
||||
pglVertex3f(-xoff, -yoff, 1.0f);
|
||||
|
||||
// Top left
|
||||
pglTexCoord2f(0.0f, yfix);
|
||||
pglVertex3f(-1, 1, 1.0f);
|
||||
pglVertex3f(-xoff, yoff, 1.0f);
|
||||
|
||||
// Top right
|
||||
pglTexCoord2f(xfix, yfix);
|
||||
pglVertex3f(1, 1, 1.0f);
|
||||
pglVertex3f(xoff, yoff, 1.0f);
|
||||
|
||||
// Bottom right
|
||||
pglTexCoord2f(xfix, 0.0f);
|
||||
pglVertex3f(1, -1, 1.0f);
|
||||
pglVertex3f(xoff, -yoff, 1.0f);
|
||||
|
||||
pglEnd();
|
||||
|
||||
SetModelView(screen_width, screen_height);
|
||||
SetStates();
|
||||
|
||||
tex_downloaded = 0; // 0 so it knows it doesn't have any of the cached patches downloaded right now
|
||||
tex_downloaded = finalScreenTexture;
|
||||
}
|
||||
|
||||
#endif //HWRENDER
|
||||
|
|
|
|||
|
|
@ -479,10 +479,10 @@ static const struct {
|
|||
{NULL, ARCH_NULL}
|
||||
};
|
||||
|
||||
static UINT8 GetUserdataArchType(void)
|
||||
static UINT8 GetUserdataArchType(int index)
|
||||
{
|
||||
UINT8 i;
|
||||
lua_getmetatable(gL, -1);
|
||||
lua_getmetatable(gL, index);
|
||||
|
||||
for (i = 0; meta2arch[i].meta; i++)
|
||||
{
|
||||
|
|
@ -561,7 +561,7 @@ static UINT8 ArchiveValue(int TABLESINDEX, int myindex)
|
|||
break;
|
||||
}
|
||||
case LUA_TUSERDATA:
|
||||
switch (GetUserdataArchType())
|
||||
switch (GetUserdataArchType(myindex))
|
||||
{
|
||||
case ARCH_MOBJINFO:
|
||||
{
|
||||
|
|
@ -768,16 +768,25 @@ static void ArchiveTables(void)
|
|||
lua_pushnil(gL);
|
||||
while (lua_next(gL, -2))
|
||||
{
|
||||
ArchiveValue(TABLESINDEX, -2); // key should be either a number or a string, ArchiveValue can handle this.
|
||||
// Write key
|
||||
e = ArchiveValue(TABLESINDEX, -2); // key should be either a number or a string, ArchiveValue can handle this.
|
||||
if (e == 2) // invalid key type (function, thread, lightuserdata, or anything we don't recognise)
|
||||
{
|
||||
lua_pushvalue(gL, -2);
|
||||
CONS_Alert(CONS_ERROR, "Index '%s' (%s) of table %d could not be archived!\n", lua_tostring(gL, -1), luaL_typename(gL, -1), i);
|
||||
lua_pop(gL, 1);
|
||||
}
|
||||
// Write value
|
||||
e = ArchiveValue(TABLESINDEX, -1);
|
||||
if (e == 1)
|
||||
n++; // the table contained a new table we'll have to archive. :(
|
||||
else if (e == 2)
|
||||
else if (e == 2) // invalid value type
|
||||
{
|
||||
lua_pushvalue(gL, -2);
|
||||
CONS_Alert(CONS_ERROR, "Type of value for table %d entry '%s' (%s) could not be archived!\n", i, lua_tostring(gL, -1), luaL_typename(gL, -1));
|
||||
lua_pop(gL, 1);
|
||||
}
|
||||
|
||||
lua_pop(gL, 1);
|
||||
}
|
||||
lua_pop(gL, 1);
|
||||
|
|
@ -913,11 +922,17 @@ static void UnArchiveTables(void)
|
|||
lua_rawgeti(gL, TABLESINDEX, i);
|
||||
while (true)
|
||||
{
|
||||
if (UnArchiveValue(TABLESINDEX) == 1)
|
||||
if (UnArchiveValue(TABLESINDEX) == 1) // read key
|
||||
break;
|
||||
if (UnArchiveValue(TABLESINDEX) == 2)
|
||||
if (UnArchiveValue(TABLESINDEX) == 2) // read value
|
||||
n++;
|
||||
lua_rawset(gL, -3);
|
||||
if (lua_isnil(gL, -2)) // if key is nil (if a function etc was accidentally saved)
|
||||
{
|
||||
CONS_Alert(CONS_ERROR, "A nil key in table %d was found! (Invalid key type or corrupted save?)\n", i);
|
||||
lua_pop(gL, 2); // pop key and value instead of setting them in the table, to prevent Lua panic errors
|
||||
}
|
||||
else
|
||||
lua_rawset(gL, -3);
|
||||
}
|
||||
lua_pop(gL, 1);
|
||||
}
|
||||
|
|
|
|||
26
src/m_misc.c
26
src/m_misc.c
|
|
@ -644,13 +644,12 @@ static void M_PNGhdr(png_structp png_ptr, png_infop png_info_ptr, PNG_CONST png_
|
|||
static void M_PNGText(png_structp png_ptr, png_infop png_info_ptr, PNG_CONST png_byte movie)
|
||||
{
|
||||
#ifdef PNG_TEXT_SUPPORTED
|
||||
#define SRB2PNGTXT 11 //PNG_KEYWORD_MAX_LENGTH(79) is the max
|
||||
#define SRB2PNGTXT 10 //PNG_KEYWORD_MAX_LENGTH(79) is the max
|
||||
png_text png_infotext[SRB2PNGTXT];
|
||||
char keytxt[SRB2PNGTXT][12] = {
|
||||
"Title", "Author", "Description", "Playername", "Mapnum", "Mapname",
|
||||
"Title", "Description", "Playername", "Mapnum", "Mapname",
|
||||
"Location", "Interface", "Revision", "Build Date", "Build Time"};
|
||||
char titletxt[] = "SRB2Kart " VERSIONSTRING;
|
||||
png_charp authortxt = I_GetUserName();
|
||||
png_charp playertxt = cv_playername.zstring;
|
||||
char desctxt[] = "SRB2Kart Screenshot";
|
||||
char Movietxt[] = "SRB2Kart Movie";
|
||||
|
|
@ -701,19 +700,18 @@ static void M_PNGText(png_structp png_ptr, png_infop png_info_ptr, PNG_CONST png
|
|||
png_infotext[i].key = keytxt[i];
|
||||
|
||||
png_infotext[0].text = titletxt;
|
||||
png_infotext[1].text = authortxt;
|
||||
if (movie)
|
||||
png_infotext[2].text = Movietxt;
|
||||
png_infotext[1].text = Movietxt;
|
||||
else
|
||||
png_infotext[2].text = desctxt;
|
||||
png_infotext[3].text = playertxt;
|
||||
png_infotext[4].text = maptext;
|
||||
png_infotext[5].text = lvlttltext;
|
||||
png_infotext[6].text = locationtxt;
|
||||
png_infotext[7].text = interfacetxt;
|
||||
png_infotext[8].text = strncpy(ctrevision, comprevision, sizeof(ctrevision)-1);
|
||||
png_infotext[9].text = strncpy(ctdate, compdate, sizeof(ctdate)-1);
|
||||
png_infotext[10].text = strncpy(cttime, comptime, sizeof(cttime)-1);
|
||||
png_infotext[1].text = desctxt;
|
||||
png_infotext[2].text = playertxt;
|
||||
png_infotext[3].text = maptext;
|
||||
png_infotext[4].text = lvlttltext;
|
||||
png_infotext[5].text = locationtxt;
|
||||
png_infotext[6].text = interfacetxt;
|
||||
png_infotext[7].text = strncpy(ctrevision, comprevision, sizeof(ctrevision)-1);
|
||||
png_infotext[8].text = strncpy(ctdate, compdate, sizeof(ctdate)-1);
|
||||
png_infotext[9].text = strncpy(cttime, comptime, sizeof(cttime)-1);
|
||||
|
||||
png_set_text(png_ptr, png_info_ptr, png_infotext, SRB2PNGTXT);
|
||||
#undef SRB2PNGTXT
|
||||
|
|
|
|||
|
|
@ -94,6 +94,7 @@ void *hwSym(const char *funcName,void *handle)
|
|||
#ifdef SHUFFLE
|
||||
GETFUNC(PostImgRedraw);
|
||||
#endif //SHUFFLE
|
||||
GETFUNC(FlushScreenTextures);
|
||||
GETFUNC(StartScreenWipe);
|
||||
GETFUNC(EndScreenWipe);
|
||||
GETFUNC(DoScreenWipe);
|
||||
|
|
|
|||
|
|
@ -3371,7 +3371,7 @@ const char *I_LocateWad(void)
|
|||
return waddir;
|
||||
}
|
||||
|
||||
#if defined(LINUX) || defined(LINUX64)
|
||||
#ifdef __linux__
|
||||
#define MEMINFO_FILE "/proc/meminfo"
|
||||
#define MEMTOTAL "MemTotal:"
|
||||
#define MEMFREE "MemFree:"
|
||||
|
|
@ -3391,20 +3391,23 @@ UINT32 I_GetFreeMem(UINT32 *total)
|
|||
};
|
||||
if ((kd = kvm_open(NULL, NULL, NULL, O_RDONLY, "kvm_open")) == NULL)
|
||||
{
|
||||
*total = 0L;
|
||||
if (total)
|
||||
*total = 0L;
|
||||
return 0;
|
||||
}
|
||||
if (kvm_nlist(kd, namelist) != 0)
|
||||
{
|
||||
kvm_close (kd);
|
||||
*total = 0L;
|
||||
if (total)
|
||||
*total = 0L;
|
||||
return 0;
|
||||
}
|
||||
if (kvm_read(kd, namelist[X_SUM].n_value, &sum,
|
||||
sizeof (sum)) != sizeof (sum))
|
||||
{
|
||||
kvm_close(kd);
|
||||
*total = 0L;
|
||||
if (total)
|
||||
*total = 0L;
|
||||
return 0;
|
||||
}
|
||||
kvm_close(kd);
|
||||
|
|
@ -3435,7 +3438,7 @@ UINT32 I_GetFreeMem(UINT32 *total)
|
|||
(PVOID) &pr_arena, sizeof (UINT32));
|
||||
|
||||
return pr_arena;
|
||||
#elif defined (LINUX) || defined (LINUX64)
|
||||
#elif defined (__linux__)
|
||||
/* Linux */
|
||||
char buf[1024];
|
||||
char *memTag;
|
||||
|
|
@ -3451,25 +3454,28 @@ UINT32 I_GetFreeMem(UINT32 *total)
|
|||
if (n < 0)
|
||||
{
|
||||
// Error
|
||||
*total = 0L;
|
||||
if (total)
|
||||
*total = 0L;
|
||||
return 0;
|
||||
}
|
||||
|
||||
buf[n] = '\0';
|
||||
if (NULL == (memTag = strstr(buf, MEMTOTAL)))
|
||||
if ((memTag = strstr(buf, MEMTOTAL)) == NULL)
|
||||
{
|
||||
// Error
|
||||
*total = 0L;
|
||||
if (total)
|
||||
*total = 0L;
|
||||
return 0;
|
||||
}
|
||||
|
||||
memTag += sizeof (MEMTOTAL);
|
||||
totalKBytes = atoi(memTag);
|
||||
|
||||
if (NULL == (memTag = strstr(buf, MEMFREE)))
|
||||
if ((memTag = strstr(buf, MEMFREE)) == NULL)
|
||||
{
|
||||
// Error
|
||||
*total = 0L;
|
||||
if (total)
|
||||
*total = 0L;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -3484,7 +3490,7 @@ UINT32 I_GetFreeMem(UINT32 *total)
|
|||
if (total)
|
||||
*total = 48<<20;
|
||||
return 48<<20;
|
||||
#endif /* LINUX */
|
||||
#endif
|
||||
}
|
||||
|
||||
const CPUInfoFlags *I_CPUInfo(void)
|
||||
|
|
|
|||
|
|
@ -1506,6 +1506,7 @@ void I_StartupGraphics(void)
|
|||
#ifdef SHUFFLE
|
||||
HWD.pfnPostImgRedraw = hwSym("PostImgRedraw",NULL);
|
||||
#endif
|
||||
HWD.pfnFlushScreenTextures=hwSym("FlushScreenTextures",NULL);
|
||||
HWD.pfnStartScreenWipe = hwSym("StartScreenWipe",NULL);
|
||||
HWD.pfnEndScreenWipe = hwSym("EndScreenWipe",NULL);
|
||||
HWD.pfnDoScreenWipe = hwSym("DoScreenWipe",NULL);
|
||||
|
|
|
|||
|
|
@ -214,8 +214,11 @@ void OglSdlFinishUpdate(boolean waitvbl)
|
|||
HWR_DrawScreenFinalTexture(sdlw, sdlh);
|
||||
SDL_GL_SwapWindow(window);
|
||||
|
||||
SetModelView(realwidth, realheight);
|
||||
SetStates();
|
||||
GClipRect(0, 0, realwidth, realheight, NZCLIP_PLANE);
|
||||
|
||||
// Sryder: We need to draw the final screen texture again into the other buffer in the original position so that
|
||||
// effects that want to take the old screen can do so after this
|
||||
HWR_DrawScreenFinalTexture(realwidth, realheight);
|
||||
}
|
||||
|
||||
EXPORT void HWRAPI( OglSdlSetPalette) (RGBA_t *palette, RGBA_t *pgamma)
|
||||
|
|
|
|||
|
|
@ -100,6 +100,7 @@ void *hwSym(const char *funcName,void *handle)
|
|||
#ifdef SHUFFLE
|
||||
GETFUNC(PostImgRedraw);
|
||||
#endif //SHUFFLE
|
||||
GETFUNC(FlushScreenTextures);
|
||||
GETFUNC(StartScreenWipe);
|
||||
GETFUNC(EndScreenWipe);
|
||||
GETFUNC(DoScreenWipe);
|
||||
|
|
|
|||
|
|
@ -1972,6 +1972,7 @@ void I_StartupGraphics(void)
|
|||
#ifdef SHUFFLE
|
||||
HWD.pfnPostImgRedraw = hwSym("PostImgRedraw",NULL);
|
||||
#endif
|
||||
HWD.pfnFlushScreenTextures=hwSym("FlushScreenTextures",NULL);
|
||||
HWD.pfnStartScreenWipe = hwSym("StartScreenWipe",NULL);
|
||||
HWD.pfnEndScreenWipe = hwSym("EndScreenWipe",NULL);
|
||||
HWD.pfnDoScreenWipe = hwSym("DoScreenWipe",NULL);
|
||||
|
|
|
|||
|
|
@ -943,14 +943,6 @@ void V_DrawPatchFill(patch_t *pat)
|
|||
INT32 dupz = (vid.dupx < vid.dupy ? vid.dupx : vid.dupy);
|
||||
INT32 x, y, pw = SHORT(pat->width) * dupz, ph = SHORT(pat->height) * dupz;
|
||||
|
||||
#ifdef HWRENDER
|
||||
if (rendermode == render_opengl)
|
||||
{
|
||||
pw = FixedMul(SHORT(pat->width)*FRACUNIT, vid.fdupx)>>FRACBITS;
|
||||
ph = FixedMul(SHORT(pat->height)*FRACUNIT, vid.fdupy)>>FRACBITS;
|
||||
}
|
||||
#endif
|
||||
|
||||
for (x = 0; x < vid.width; x += pw)
|
||||
{
|
||||
for (y = 0; y < vid.height; y += ph)
|
||||
|
|
|
|||
|
|
@ -117,6 +117,7 @@ static loadfunc_t hwdFuncTable[] = {
|
|||
#ifdef SHUFFLE
|
||||
{"PostImgRedraw@4", &hwdriver.pfnPostImgRedraw},
|
||||
#endif
|
||||
{"FlushScreenTextures@0",&hwdriver.pfnFlushScreenTextures},
|
||||
{"StartScreenWipe@0", &hwdriver.pfnStartScreenWipe},
|
||||
{"EndScreenWipe@0", &hwdriver.pfnEndScreenWipe},
|
||||
{"DoScreenWipe@4", &hwdriver.pfnDoScreenWipe},
|
||||
|
|
@ -147,6 +148,7 @@ static loadfunc_t hwdFuncTable[] = {
|
|||
#ifdef SHUFFLE
|
||||
{"PostImgRedraw", &hwdriver.pfnPostImgRedraw},
|
||||
#endif
|
||||
{"FlushScreenTextures"},&hwdriver.pfnFlushScreenTextures},
|
||||
{"StartScreenWipe", &hwdriver.pfnStartScreenWipe},
|
||||
{"EndScreenWipe", &hwdriver.pfnEndScreenWipe},
|
||||
{"DoScreenWipe", &hwdriver.pfnDoScreenWipe},
|
||||
|
|
|
|||
Loading…
Reference in New Issue