Merge branch 'Saturn-Next' into directionallight
This commit is contained in:
commit
a3b5c4dff8
109 files changed
+6361
-5262
No files matched your search
@@ -28,6 +28,10 @@ exist.
|
||||
Returns the values of the given HUD item's `xoffset`/`yoffset` cvars.
|
||||
Available for any HUD item with offset cvars.
|
||||
|
||||
## patch = v.cachePatchRotated(name, rollangle)
|
||||
Like v.cachePatch, it caches a new patch with the corresponding name. Unlike v.cachePatch, however,
|
||||
a rollangle can be supplied to the function so that it returns a rotated patch instead.
|
||||
|
||||
## x, y, flags = v.getDrawInfo(item)
|
||||
|
||||
Returns the X, Y and flags where the given HUD item will be drawn for the current displayplayer.
|
||||
|
||||
@@ -0,0 +1,8 @@
|
||||
ifdef SILENT
|
||||
MAKEFLAGS+=--no-print-directory
|
||||
endif
|
||||
|
||||
all :
|
||||
|
||||
% ::
|
||||
@$(MAKE) -C src $(MAKECMDGOALS)
|
||||
@@ -76,7 +76,7 @@ Crashlogs now contain alot more informations. and even more if your build has de
|
||||
Also allows 64bit Windows builds to produce Crashlogs!
|
||||
|
||||
## MISC
|
||||
- Bird's Camara Tilting feature is no longer turned on by default
|
||||
- Bird's Camera Tilting feature is no longer turned on by default
|
||||
- Bird's warning on the title screen has been removed
|
||||
|
||||
## Bugs
|
||||
|
||||
@@ -184,8 +184,6 @@ void I_OutputMsg(const char *fmt, ...)
|
||||
|
||||
void I_StartupMouse(void){}
|
||||
|
||||
void I_StartupMouse2(void){}
|
||||
|
||||
void I_StartupKeyboard(void){}
|
||||
|
||||
INT32 I_GetKey(void)
|
||||
@@ -242,8 +240,6 @@ void I_GetJoystickEvents(void){}
|
||||
|
||||
void I_GetJoystick2Events(void){}
|
||||
|
||||
void I_GetMouseEvents(void){}
|
||||
|
||||
char *I_GetEnv(const char *name)
|
||||
{
|
||||
LOGW("I_GetEnv() called?!");
|
||||
|
||||
+7
-1
@@ -608,7 +608,7 @@ static void CON_MoveConsole(void)
|
||||
}
|
||||
|
||||
// Not instant - Increment fracmovement fractionally
|
||||
fracmovement += FixedMul(cons_speed.value*vid.fdupy, renderdeltatics);
|
||||
fracmovement += FixedMul(cons_speed.value*vid.fdupy, (cv_uncappedhud.value ? renderdeltatics : FRACUNIT));
|
||||
|
||||
if (con_curlines < con_destlines) // Move the console downwards
|
||||
{
|
||||
@@ -1466,7 +1466,10 @@ static void CON_DrawHudlines(void)
|
||||
{
|
||||
charflags = (*p & 0x7f) << V_CHARCOLORSHIFT;
|
||||
p++;
|
||||
c++;
|
||||
}
|
||||
if (c >= con_width)
|
||||
break;
|
||||
if (*p < HU_FONTSTART)
|
||||
;//charwidth = 4 * con_scalefactor;
|
||||
else
|
||||
@@ -1546,7 +1549,10 @@ static void CON_DrawConsole(void)
|
||||
{
|
||||
charflags = (*p & 0x7f) << V_CHARCOLORSHIFT;
|
||||
p++;
|
||||
c++;
|
||||
}
|
||||
if (c >= con_width)
|
||||
break;
|
||||
V_DrawCharacter(x, y, (INT32)(*p) | charflags | cv_constextsize.value | V_NOSCALESTART, !cv_allcaps.value);
|
||||
}
|
||||
}
|
||||
|
||||
+251
-51
@@ -103,6 +103,30 @@ static tic_t freezetimeout[MAXNETNODES]; // Until when can this node freeze the
|
||||
UINT16 pingmeasurecount = 1;
|
||||
UINT32 realpingtable[MAXPLAYERS]; //the base table of ping where an average will be sent to everyone.
|
||||
UINT32 playerpingtable[MAXPLAYERS]; //table of player latency values.
|
||||
|
||||
#define GENTLEMANSMOOTHING (TICRATE)
|
||||
static tic_t reference_lag;
|
||||
static UINT8 spike_time;
|
||||
tic_t lowest_lag;
|
||||
tic_t simulated_lag;
|
||||
boolean server_lagless;
|
||||
|
||||
static void Lagless_OnChange(void)
|
||||
{
|
||||
/* don't back out of dishonesty, or go lagless after playing honestly */
|
||||
if (cv_lagless.value && gamestate == GS_LEVEL)
|
||||
server_lagless = true;
|
||||
|
||||
/*if (cv_lagless.value)
|
||||
HU_AddChatText(M_GetText("\x82*Gentlemans Delay has been disabled for Serverplayer."), false);
|
||||
else
|
||||
HU_AddChatText(M_GetText("\x82*Gentlemans Delay will be enabled for Serverplayer."), false);*/
|
||||
}
|
||||
|
||||
static CV_PossibleValue_t mindelay_cons_t[] = {{0, "MIN"}, {30, "MAX"}, {0, NULL}};
|
||||
consvar_t cv_mindelay = {"mindelay", "0", CV_SAVE, mindelay_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_lagless = {"serverlagless", "On", CV_SAVE|CV_CALL|CV_NOINIT, CV_OnOff, Lagless_OnChange, 0, NULL, NULL, 0, 0, NULL}; // this should be a netvar Zzz...
|
||||
|
||||
SINT8 nodetoplayer[MAXNETNODES];
|
||||
SINT8 nodetoplayer2[MAXNETNODES]; // say the numplayer for this node if any (splitscreen)
|
||||
SINT8 nodetoplayer3[MAXNETNODES]; // say the numplayer for this node if any (splitscreen == 2)
|
||||
@@ -140,7 +164,7 @@ static UINT8 gamestate_resend_counter[MAXNETNODES];
|
||||
boolean hu_stopped = false;
|
||||
|
||||
// Client specific
|
||||
static ticcmd_t localcmds[MAXSPLITSCREENPLAYERS];
|
||||
static ticcmd_t localcmds[MAXSPLITSCREENPLAYERS][MAXGENTLEMENDELAY];
|
||||
static boolean cl_packetmissed;
|
||||
// here it is for the secondary local player (splitscreen)
|
||||
static UINT8 mynode; // my address pointofview server
|
||||
@@ -187,6 +211,16 @@ typedef struct textcmdtic_s
|
||||
struct textcmdtic_s *next;
|
||||
} textcmdtic_t;
|
||||
|
||||
typedef struct textcmdbuf_s textcmdbuf_t;
|
||||
|
||||
struct textcmdbuf_s
|
||||
{
|
||||
textcmdbuf_t *next;
|
||||
UINT8 cmd[MAXTEXTCMD];
|
||||
};
|
||||
|
||||
static textcmdbuf_t *textcmdbuf[MAXSPLITSCREENPLAYERS] = {NULL};
|
||||
|
||||
ticcmd_t netcmds[TICQUEUE][MAXPLAYERS];
|
||||
static textcmdtic_t *textcmds[TEXTCMD_HASH_SIZE] = {NULL};
|
||||
|
||||
@@ -271,25 +305,59 @@ void RegisterNetXCmd(netxcmd_t id, void (*cmd_f)(UINT8 **p, INT32 playernum))
|
||||
listnetxcmd[id] = cmd_f;
|
||||
}
|
||||
|
||||
void SendNetXCmdForPlayer(UINT8 playerid, netxcmd_t id, const void *param, size_t nparam)
|
||||
static void WriteNetXCmd(UINT8 *cmd, netxcmd_t id, const void *param, size_t nparam)
|
||||
{
|
||||
if ((localtextcmd[playerid])[0]+2+nparam > MAXTEXTCMD)
|
||||
{
|
||||
// for future reference: if (cht_debug) != debug disabled.
|
||||
CONS_Alert(CONS_ERROR, M_GetText("NetXCmd buffer full, cannot add netcmd %d! (size: %d, needed: %s)\n"), id, localtextcmd[playerid][0], sizeu1(nparam));
|
||||
return;
|
||||
}
|
||||
|
||||
localtextcmd[playerid][0]++;
|
||||
localtextcmd[playerid][localtextcmd[playerid][0]] = (UINT8)id;
|
||||
|
||||
cmd[0]++;
|
||||
cmd[cmd[0]] = (UINT8)id;
|
||||
if (param && nparam)
|
||||
{
|
||||
M_Memcpy(&localtextcmd[playerid][localtextcmd[playerid][0] + 1], param, nparam);
|
||||
localtextcmd[playerid][0] = (UINT8)(localtextcmd[playerid][0] + (UINT8)nparam);
|
||||
M_Memcpy(&cmd[cmd[0]+1], param, nparam);
|
||||
cmd[0] = (UINT8)(cmd[0] + (UINT8)nparam);
|
||||
}
|
||||
}
|
||||
|
||||
void SendNetXCmdForPlayer(UINT8 playerid, netxcmd_t id, const void *param, size_t nparam)
|
||||
{
|
||||
if (localtextcmd[playerid][0]+2+nparam > MAXTEXTCMD)
|
||||
{
|
||||
textcmdbuf_t *buf = textcmdbuf[playerid];
|
||||
|
||||
if (2+nparam > MAXTEXTCMD)
|
||||
{
|
||||
CONS_Alert(CONS_ERROR, M_GetText("packet too large to fit NetXCmd, cannot add netcmd %d! (size: %s, max: %d)\n"), id, sizeu1(2+nparam), MAXTEXTCMD);
|
||||
return;
|
||||
}
|
||||
|
||||
// for future reference: if (cv_debug) != debug disabled.
|
||||
CONS_Alert(CONS_NOTICE, M_GetText("NetXCmd buffer full, delaying netcmd %d... (size: %d, needed: %s)\n"), id, localtextcmd[playerid][0], sizeu1(nparam));
|
||||
if (buf == NULL)
|
||||
{
|
||||
textcmdbuf[playerid] = Z_Malloc(sizeof(textcmdbuf_t), PU_STATIC, NULL);
|
||||
textcmdbuf[playerid]->cmd[0] = 0;
|
||||
textcmdbuf[playerid]->next = NULL;
|
||||
WriteNetXCmd(textcmdbuf[playerid]->cmd, id, param, nparam);
|
||||
return;
|
||||
}
|
||||
|
||||
while (buf->next != NULL)
|
||||
buf = buf->next;
|
||||
|
||||
if (buf->cmd[0]+2+nparam > MAXTEXTCMD)
|
||||
{
|
||||
buf->next = Z_Malloc(sizeof(textcmdbuf_t), PU_STATIC, NULL);
|
||||
buf->next->cmd[0] = 0;
|
||||
buf->next->next = NULL;
|
||||
WriteNetXCmd(buf->next->cmd, id, param, nparam);
|
||||
}
|
||||
else
|
||||
{
|
||||
WriteNetXCmd(buf->cmd, id, param, nparam);
|
||||
}
|
||||
return;
|
||||
}
|
||||
WriteNetXCmd(localtextcmd[playerid], id, param, nparam);
|
||||
}
|
||||
|
||||
/*UINT8 GetFreeXCmdSize(UINT8 playerid)
|
||||
{
|
||||
// -1 for the size and another -1 for the ID.
|
||||
@@ -456,10 +524,15 @@ static void D_Clearticcmd(tic_t tic)
|
||||
|
||||
void D_ResetTiccmds(void)
|
||||
{
|
||||
INT32 i;
|
||||
INT32 i, j;
|
||||
|
||||
for (i = 0; i < MAXSPLITSCREENPLAYERS; i++)
|
||||
memset(&localcmds[i], 0, sizeof(ticcmd_t));
|
||||
{
|
||||
for (j = 0; j < MAXGENTLEMENDELAY; j++)
|
||||
{
|
||||
memset(&localcmds[i][j], 0, sizeof(ticcmd_t));
|
||||
}
|
||||
}
|
||||
|
||||
// Reset the net command list
|
||||
for (i = 0; i < TEXTCMD_HASH_SIZE; i++)
|
||||
@@ -1159,7 +1232,8 @@ static inline void CL_DrawConnectionStatus(void)
|
||||
INT32 ccstime = I_GetTime();
|
||||
|
||||
// Draw background fade
|
||||
V_DrawFadeScreen(0xFF00, 16);
|
||||
if (!menuactive) // menu already draws its own fade
|
||||
V_DrawFadeScreen(0xFF00, 16); // force default
|
||||
|
||||
if (cl_mode != CL_DOWNLOADFILES && cl_mode != CL_LOADFILES && cl_mode != CL_CHECKFILES
|
||||
#ifdef HAVE_CURL
|
||||
@@ -1185,10 +1259,22 @@ static inline void CL_DrawConnectionStatus(void)
|
||||
case CL_DOWNLOADSAVEGAME:
|
||||
if (lastfilenum != -1)
|
||||
{
|
||||
UINT32 currentsize = fileneeded[lastfilenum].currentsize;
|
||||
UINT32 totalsize = fileneeded[lastfilenum].totalsize;
|
||||
INT32 dldlength;
|
||||
|
||||
cltext = M_GetText("Downloading game state...");
|
||||
Net_GetNetStat();
|
||||
|
||||
dldlength = (INT32)((currentsize/(double)totalsize) * 256);
|
||||
if (dldlength > 256)
|
||||
dldlength = 256;
|
||||
V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, 256, 8, 111);
|
||||
V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, dldlength, 8, 96);
|
||||
|
||||
V_DrawString(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE,
|
||||
va(" %4uK",fileneeded[lastfilenum].currentsize>>10));
|
||||
va(" %4uK/%4uK",currentsize>>10,totalsize>>10));
|
||||
|
||||
V_DrawRightAlignedString(BASEVIDWIDTH/2+128, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE,
|
||||
va("%3.1fK/s ", ((double)getbps)/1024));
|
||||
}
|
||||
@@ -2683,12 +2769,12 @@ static void CL_ConnectToServer(void)
|
||||
sprintf(tmpsave, "%s" PATHSEP TMPSAVENAME, srb2home);
|
||||
#endif
|
||||
|
||||
cl_mode = CL_SEARCHING;
|
||||
|
||||
#ifdef CLIENT_LOADINGSCREEN
|
||||
lastfilenum = -1;
|
||||
#endif
|
||||
|
||||
cl_mode = CL_SEARCHING;
|
||||
|
||||
#ifdef JOININGAME
|
||||
// Don't get a corrupt savegame error because tmpsave already exists
|
||||
if (FIL_FileExists(tmpsave) && unlink(tmpsave) == -1)
|
||||
@@ -5270,6 +5356,12 @@ static void HandlePacketFromPlayer(SINT8 node)
|
||||
/// \todo Use a separate cvar for that kind of timeout?
|
||||
freezetimeout[node] = I_GetTime() + connectiontimeout;
|
||||
|
||||
// If we've alredy received a ticcmd for this tic, just submit it for the next one.
|
||||
tic_t faketic = maketic;
|
||||
if ((!!(netcmds[maketic % TICQUEUE][netconsole].angleturn & TICCMD_RECEIVED))
|
||||
&& (maketic - firstticstosend < TICQUEUE - 1))
|
||||
faketic++;
|
||||
|
||||
// Don't do anything for packets of type NODEKEEPALIVE?
|
||||
// Sryder 2018/07/01: Update the freezetimeout still!
|
||||
if (netbuffer->packettype == PT_NODEKEEPALIVE
|
||||
@@ -5277,7 +5369,7 @@ static void HandlePacketFromPlayer(SINT8 node)
|
||||
break;
|
||||
|
||||
// Copy ticcmd
|
||||
G_MoveTiccmd(&netcmds[maketic%TICQUEUE][netconsole], &netbuffer->u.clientpak.cmd, 1);
|
||||
G_MoveTiccmd(&netcmds[faketic%TICQUEUE][netconsole], &netbuffer->u.clientpak.cmd, 1);
|
||||
|
||||
// Check ticcmd for "speed hacks"
|
||||
if (CheckForSpeedHacks((UINT8)netconsole))
|
||||
@@ -5289,7 +5381,7 @@ static void HandlePacketFromPlayer(SINT8 node)
|
||||
|| (netbuffer->packettype == PT_CLIENT4CMD || netbuffer->packettype == PT_CLIENT4MIS))
|
||||
&& (nodetoplayer2[node] >= 0))
|
||||
{
|
||||
G_MoveTiccmd(&netcmds[maketic%TICQUEUE][(UINT8)nodetoplayer2[node]],
|
||||
G_MoveTiccmd(&netcmds[faketic%TICQUEUE][(UINT8)nodetoplayer2[node]],
|
||||
&netbuffer->u.client2pak.cmd2, 1);
|
||||
|
||||
if (CheckForSpeedHacks((UINT8)nodetoplayer2[node]))
|
||||
@@ -5300,7 +5392,7 @@ static void HandlePacketFromPlayer(SINT8 node)
|
||||
|| (netbuffer->packettype == PT_CLIENT4CMD || netbuffer->packettype == PT_CLIENT4MIS))
|
||||
&& (nodetoplayer3[node] >= 0))
|
||||
{
|
||||
G_MoveTiccmd(&netcmds[maketic%TICQUEUE][(UINT8)nodetoplayer3[node]],
|
||||
G_MoveTiccmd(&netcmds[faketic%TICQUEUE][(UINT8)nodetoplayer3[node]],
|
||||
&netbuffer->u.client3pak.cmd3, 1);
|
||||
|
||||
if (CheckForSpeedHacks((UINT8)nodetoplayer3[node]))
|
||||
@@ -5310,7 +5402,7 @@ static void HandlePacketFromPlayer(SINT8 node)
|
||||
if ((netbuffer->packettype == PT_CLIENT4CMD || netbuffer->packettype == PT_CLIENT4MIS)
|
||||
&& (nodetoplayer4[node] >= 0))
|
||||
{
|
||||
G_MoveTiccmd(&netcmds[maketic%TICQUEUE][(UINT8)nodetoplayer4[node]],
|
||||
G_MoveTiccmd(&netcmds[faketic%TICQUEUE][(UINT8)nodetoplayer4[node]],
|
||||
&netbuffer->u.client4pak.cmd4, 1);
|
||||
|
||||
if (CheckForSpeedHacks((UINT8)nodetoplayer4[node]))
|
||||
@@ -6007,27 +6099,78 @@ static void CL_SendClientCmd(void)
|
||||
}
|
||||
else if (gamestate != GS_NULL)
|
||||
{
|
||||
UINT8 lagDelay = 0;
|
||||
|
||||
if (lowest_lag > 0)
|
||||
{
|
||||
// Gentlemens' ping.
|
||||
lagDelay = min(lowest_lag, MAXGENTLEMENDELAY);
|
||||
|
||||
// Is our connection worse than our current gentleman point?
|
||||
// Make sure it stays that way for a bit before increasing delay levels.
|
||||
if (lagDelay > reference_lag)
|
||||
{
|
||||
spike_time++;
|
||||
if (spike_time >= GENTLEMANSMOOTHING)
|
||||
{
|
||||
// Okay, this is genuinely the new baseline delay.
|
||||
reference_lag = lagDelay;
|
||||
spike_time = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Just a temporary fluctuation, ignore it.
|
||||
lagDelay = reference_lag;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
reference_lag = lagDelay; // Adjust quickly if the connection improves.
|
||||
spike_time = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
if (server) // Clients have to wait for the gamestate to make it back. Servers don't!
|
||||
lagDelay *= 2; // Simulate the HELLFUCK NIGHTMARE of a complete round trip.
|
||||
*/
|
||||
|
||||
// [deep breath in]
|
||||
// Plausible, elegant explanation that is WRONG AND SUPER HARMFUL.
|
||||
// Clients with stable connections were adding their mindelay to network delay,
|
||||
// even when their mindelay was as high or higher than network delay—which made
|
||||
// client delay APPEAR slower than host mindelay, by the exact value that made
|
||||
// "lmao just double it" make sense at the time.
|
||||
//
|
||||
// While this fix made client connections match server mindelay in our most common
|
||||
// test environment, it also masked an issue that seriously affected online handling
|
||||
// responsiveness, completely ruining our opportunity to further investigate it!
|
||||
//
|
||||
// See UpdatePingTable.
|
||||
// I am taking this shitty code to my grave as an example of "never trust your brain".
|
||||
// -Tyron 2024-05-15
|
||||
}
|
||||
|
||||
packetsize = sizeof (clientcmd_pak);
|
||||
G_MoveTiccmd(&netbuffer->u.clientpak.cmd, &localcmds[0], 1);
|
||||
netbuffer->u.clientpak.consistancy = SHORT(consistancy[gametic%TICQUEUE]);
|
||||
G_MoveTiccmd(&netbuffer->u.clientpak.cmd, &localcmds[0][lagDelay], 1);
|
||||
netbuffer->u.clientpak.consistancy = SHORT(consistancy[gametic % TICQUEUE]);
|
||||
|
||||
if (splitscreen || botingame) // Send a special packet with 2 cmd for splitscreen
|
||||
{
|
||||
netbuffer->packettype = (mis ? PT_CLIENT2MIS : PT_CLIENT2CMD);
|
||||
packetsize = sizeof (client2cmd_pak);
|
||||
G_MoveTiccmd(&netbuffer->u.client2pak.cmd2, &localcmds[1], 1);
|
||||
G_MoveTiccmd(&netbuffer->u.client2pak.cmd2, &localcmds[1][lagDelay], 1);
|
||||
|
||||
if (splitscreen > 1)
|
||||
{
|
||||
netbuffer->packettype = (mis ? PT_CLIENT3MIS : PT_CLIENT3CMD);
|
||||
packetsize = sizeof (client3cmd_pak);
|
||||
G_MoveTiccmd(&netbuffer->u.client3pak.cmd3, &localcmds[2], 1);
|
||||
G_MoveTiccmd(&netbuffer->u.client3pak.cmd3, &localcmds[2][lagDelay], 1);
|
||||
|
||||
if (splitscreen > 2)
|
||||
{
|
||||
netbuffer->packettype = (mis ? PT_CLIENT4MIS : PT_CLIENT4CMD);
|
||||
packetsize = sizeof (client4cmd_pak);
|
||||
G_MoveTiccmd(&netbuffer->u.client4pak.cmd4, &localcmds[3], 1);
|
||||
G_MoveTiccmd(&netbuffer->u.client4pak.cmd4, &localcmds[3][lagDelay], 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -6062,7 +6205,16 @@ static void CL_SendClientCmd(void)
|
||||
M_Memcpy(netbuffer->u.textcmd, localtextcmd[i], localtextcmd[i][0]+1);
|
||||
// All extra data have been sent
|
||||
if (HSendPacket(servernode, true, 0, localtextcmd[i][0]+1)) // Send can fail...
|
||||
{
|
||||
localtextcmd[i][0] = 0;
|
||||
if (textcmdbuf[i] != NULL)
|
||||
{
|
||||
textcmdbuf_t *buf = textcmdbuf[i];
|
||||
M_Memcpy(localtextcmd[i], textcmdbuf[i]->cmd, textcmdbuf[i]->cmd[0]+1);
|
||||
textcmdbuf[i] = textcmdbuf[i]->next;
|
||||
Z_Free(buf);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -6194,8 +6346,15 @@ static void SV_SendTics(void)
|
||||
//
|
||||
static inline void CreateNewLocalCMD(UINT8 p, INT32 realtics)
|
||||
{
|
||||
G_BuildTiccmd(&localcmds[p], realtics, p+1);
|
||||
localcmds[p].angleturn |= TICCMD_RECEIVED;
|
||||
INT32 i;
|
||||
|
||||
for (i = MAXGENTLEMENDELAY-1; i > 0; i--)
|
||||
{
|
||||
G_MoveTiccmd(&localcmds[p][i], &localcmds[p][i-1], 1);
|
||||
}
|
||||
|
||||
G_BuildTiccmd(&localcmds[p][0], realtics, p+1);
|
||||
localcmds[p][0].angleturn |= TICCMD_RECEIVED;
|
||||
}
|
||||
|
||||
static void Local_Maketic(INT32 realtics)
|
||||
@@ -6207,8 +6366,8 @@ static void Local_Maketic(INT32 realtics)
|
||||
// game responder calls HU_Responder, AM_Responder, F_Responder,
|
||||
// and G_MapEventsToControls
|
||||
if (!dedicated) rendergametic = gametic;
|
||||
// translate inputs (keyboard/mouse/joystick) into game controls
|
||||
|
||||
// translate inputs (keyboard/mouse/joystick) into game controls
|
||||
for (i = 0; i <= splitscreen; i++)
|
||||
{
|
||||
CreateNewLocalCMD(i, realtics);
|
||||
@@ -6328,21 +6487,19 @@ boolean TryRunTics(tic_t realtics)
|
||||
}
|
||||
#endif
|
||||
|
||||
ticking = neededtic > gametic;
|
||||
|
||||
if (ticking)
|
||||
if (neededtic > gametic)
|
||||
{
|
||||
if (realtics)
|
||||
hu_stopped = false;
|
||||
hu_stopped = false;
|
||||
}
|
||||
|
||||
if (player_joining)
|
||||
{
|
||||
if (realtics)
|
||||
hu_stopped = true;
|
||||
hu_stopped = true;
|
||||
return false;
|
||||
}
|
||||
|
||||
ticking = neededtic > gametic;
|
||||
|
||||
if (ticking)
|
||||
{
|
||||
// run the count * tics
|
||||
@@ -6497,17 +6654,62 @@ static tic_t gametime = 0;
|
||||
|
||||
static void UpdatePingTable(void)
|
||||
{
|
||||
tic_t fastest;
|
||||
tic_t lag;
|
||||
|
||||
INT32 i;
|
||||
|
||||
if (server)
|
||||
{
|
||||
if (netgame && !(gametime % 35)) // update once per second.
|
||||
if (Playing() && !(gametime % 8)) // Value chosen based on _my vibes man_
|
||||
PingUpdate();
|
||||
|
||||
fastest = 0;
|
||||
|
||||
// update node latency values so we can take an average later.
|
||||
for (i = 0; i < MAXPLAYERS; i++)
|
||||
if (playeringame[i] && playernode[i] != UINT8_MAX)
|
||||
{
|
||||
if (playeringame[i] && playernode[i] > 0 && playernode[i] != UINT8_MAX)
|
||||
{
|
||||
realpingtable[i] += GetLag(playernode[i]);
|
||||
|
||||
if (!server_lagless && !players[i].spectator)
|
||||
{
|
||||
lag = playerpingtable[i];
|
||||
if (! fastest || lag < fastest)
|
||||
fastest = lag;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (server_lagless)
|
||||
lowest_lag = 0;
|
||||
else
|
||||
lowest_lag = fastest;
|
||||
|
||||
// Don't gentleman below your mindelay
|
||||
if (lowest_lag < (tic_t)cv_mindelay.value)
|
||||
lowest_lag = (tic_t)cv_mindelay.value;
|
||||
|
||||
simulated_lag = lowest_lag;
|
||||
|
||||
pingmeasurecount++;
|
||||
}
|
||||
else // We're a client, handle mindelay on the way out.
|
||||
{
|
||||
// Previously (neededtic - gametic) - WRONG VALUE!
|
||||
// Pretty sure that's measuring jitter, not RTT.
|
||||
// Stable connections would be punished by adding their mindelay to network delay!
|
||||
tic_t mydelay = playerpingtable[consoleplayer];
|
||||
|
||||
if (mydelay < (tic_t)cv_mindelay.value)
|
||||
{
|
||||
lowest_lag = ((tic_t)cv_mindelay.value - mydelay);
|
||||
simulated_lag = (tic_t)cv_mindelay.value;
|
||||
}
|
||||
else
|
||||
lowest_lag = simulated_lag = 0;
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef HOLEPUNCH
|
||||
@@ -6602,14 +6804,6 @@ void NetUpdate(void)
|
||||
if (realtics <= 0) // nothing new to update
|
||||
return;
|
||||
|
||||
if (realtics > 5)
|
||||
{
|
||||
if (server)
|
||||
realtics = 1;
|
||||
else
|
||||
realtics = 5;
|
||||
}
|
||||
|
||||
#ifdef DEDICATEDIDLETIME
|
||||
if (server && dedicated && gamestate == GS_LEVEL)
|
||||
{
|
||||
@@ -6658,6 +6852,14 @@ void NetUpdate(void)
|
||||
}
|
||||
#endif
|
||||
|
||||
if (realtics > 5)
|
||||
{
|
||||
if (server)
|
||||
realtics = 1;
|
||||
else
|
||||
realtics = 5;
|
||||
}
|
||||
|
||||
gametime = nowtime;
|
||||
|
||||
UpdatePingTable();
|
||||
@@ -6751,8 +6953,6 @@ void NetUpdate(void)
|
||||
Net_AckTicker();
|
||||
HandleNodeTimeouts();
|
||||
|
||||
nowtime /= NEWTICRATERATIO;
|
||||
|
||||
if (nowtime > resptime)
|
||||
{
|
||||
resptime = nowtime;
|
||||
|
||||
@@ -41,6 +41,15 @@ applications may follow different packet versions.
|
||||
#define BACKUPTICS 32
|
||||
#define TICQUEUE 512 // more than enough for most timeouts....
|
||||
#define MAXTEXTCMD 256
|
||||
|
||||
// No. of tics your controls can be delayed by.
|
||||
|
||||
// TODO: Instead of storing a ton of extra cmds for gentlemens' delay,
|
||||
// keep them in a linked-list, with timestamps to discard everything that's older than already sent.
|
||||
// That will support any amount of lag, and be less wasteful for clients who don't use it.
|
||||
// This just works as a quick implementation.
|
||||
#define MAXGENTLEMENDELAY TICRATE
|
||||
|
||||
//
|
||||
// Packet structure
|
||||
//
|
||||
@@ -576,6 +585,11 @@ extern UINT32 realpingtable[MAXPLAYERS];
|
||||
extern UINT32 playerpingtable[MAXPLAYERS];
|
||||
extern tic_t servermaxping;
|
||||
|
||||
extern boolean server_lagless;
|
||||
extern tic_t simulated_lag;
|
||||
extern tic_t lowest_lag;
|
||||
extern consvar_t cv_mindelay, cv_lagless;
|
||||
|
||||
extern consvar_t
|
||||
#ifdef VANILLAJOINNEXTROUND
|
||||
cv_joinnextround,
|
||||
@@ -645,6 +659,7 @@ extern char motd[254], server_context[8];
|
||||
extern UINT8 playernode[MAXPLAYERS];
|
||||
|
||||
INT32 D_NumPlayers(void);
|
||||
|
||||
void D_ResetTiccmds(void);
|
||||
|
||||
tic_t GetLag(INT32 node);
|
||||
|
||||
@@ -25,7 +25,6 @@ typedef enum
|
||||
ev_console,
|
||||
ev_mouse,
|
||||
ev_joystick,
|
||||
ev_mouse2,
|
||||
ev_joystick2,
|
||||
ev_joystick3,
|
||||
ev_joystick4,
|
||||
|
||||
+57
-50
@@ -133,6 +133,7 @@ char srb2home[256] = ".";
|
||||
char srb2path[256] = ".";
|
||||
boolean usehome = true;
|
||||
const char *pandf = "%s" PATHSEP "%s";
|
||||
static char addonsdir[MAX_WADPATH];
|
||||
|
||||
//
|
||||
// EVENT HANDLING
|
||||
@@ -182,6 +183,9 @@ static void D_GamePadMenuScrollTicker(void)
|
||||
static SINT8 menuInputDelayTimer = 0;
|
||||
int key = 0; // butt-on output
|
||||
|
||||
if (dedicated)
|
||||
return;
|
||||
|
||||
// wish i had a switch ono
|
||||
if (DPADUPSCROLL)
|
||||
key = KEY_UPARROW;
|
||||
@@ -210,20 +214,17 @@ static void D_GamePadMenuScrollTicker(void)
|
||||
static void D_DeviceLEDTick(void)
|
||||
{
|
||||
UINT8 i;
|
||||
UINT16 color[MAXSPLITSCREENPLAYERS];
|
||||
UINT16 curcolor[MAXSPLITSCREENPLAYERS];
|
||||
static UINT16 color[MAXSPLITSCREENPLAYERS] = {0, 0, 0, 0};
|
||||
static UINT16 curcolor[MAXSPLITSCREENPLAYERS] = {0, 0, 0, 0};
|
||||
|
||||
if (I_NumJoys() == 0)
|
||||
if (dedicated || numcontrollers == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
for (i = 0; i <= splitscreen; i++)
|
||||
{
|
||||
if (!cv_usejoystick[i].value)
|
||||
continue;
|
||||
|
||||
if (!cv_gamepadled[i].value)
|
||||
if (!cv_usejoystick[i].value || !cv_gamepadled[i].value)
|
||||
continue;
|
||||
|
||||
color[i] = G_GetSkinColor(i);
|
||||
@@ -334,7 +335,7 @@ static boolean D_Display(void)
|
||||
|
||||
if (rendermode == render_soft && !splitscreen)
|
||||
{
|
||||
R_InterpolateViewRollAngle(rendertimefrac);
|
||||
R_InterpolateViewRollAngle(rendertimefrac_unpaused);
|
||||
R_CheckViewMorph();
|
||||
}
|
||||
|
||||
@@ -352,6 +353,7 @@ static boolean D_Display(void)
|
||||
|
||||
// save the current screen if about to wipe
|
||||
wipe = (gamestate != wipegamestate);
|
||||
|
||||
if (wipe)
|
||||
{
|
||||
// set for all later
|
||||
@@ -504,7 +506,7 @@ static boolean D_Display(void)
|
||||
|
||||
#ifdef HWRENDER
|
||||
if (rendermode == render_opengl)
|
||||
HWR_RenderPlayerView(i, &players[displayplayers[i]]);
|
||||
HWR_RenderPlayerView();
|
||||
else
|
||||
#endif
|
||||
if (rendermode != render_none)
|
||||
@@ -558,7 +560,7 @@ static boolean D_Display(void)
|
||||
|
||||
for (i = 0; i <= splitscreen; i++)
|
||||
{
|
||||
V_DoPostProcessor(i, &players[displayplayers[i]], postimgparam[i]);
|
||||
V_DoPostProcessor(i, postimgparam[i]);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -579,8 +581,6 @@ static boolean D_Display(void)
|
||||
PS_START_TIMING(ps_uitime);
|
||||
ST_Drawer();
|
||||
HU_Drawer();
|
||||
|
||||
NetUpdate(); // TEST: run this EVERY frame
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -741,11 +741,9 @@ void D_SRB2Loop(void)
|
||||
precise_t enterprecise = I_GetPreciseTime();
|
||||
precise_t finishprecise = enterprecise;
|
||||
|
||||
{
|
||||
// Casting the return value of a function is bad practice (apparently)
|
||||
double budget = ((R_GetFramerateCap() == 0) ? 0.0 : round((1.0 / R_GetFramerateCap()) * I_GetPrecisePrecision()));
|
||||
capbudget = (precise_t) budget;
|
||||
}
|
||||
// Casting the return value of a function is bad practice (apparently)
|
||||
double budget = ((R_GetFramerateCap() == 0) ? 0.0 : round((1.0 / R_GetFramerateCap()) * I_GetPrecisePrecision()));
|
||||
capbudget = (precise_t) budget;
|
||||
|
||||
boolean ranwipe = false;
|
||||
|
||||
@@ -774,15 +772,15 @@ void D_SRB2Loop(void)
|
||||
debugload--;
|
||||
#endif
|
||||
|
||||
interp = R_UsingFrameInterpolation() && !dedicated;
|
||||
interp = (R_UsingFrameInterpolation() && !dedicated);
|
||||
doDisplay = false;
|
||||
|
||||
renderisnewtic = (realtics > 0 || singletics);
|
||||
|
||||
refreshdirmenu = 0; // not sure where to put this, here as good as any?
|
||||
|
||||
if (renderisnewtic)
|
||||
{
|
||||
refreshdirmenu = 0; // not sure where to put this, here as good as any?
|
||||
|
||||
// don't skip more than 10 frames at a time
|
||||
// (fadein / fadeout cause massive frame skip!)
|
||||
if (realtics > 8)
|
||||
@@ -791,7 +789,7 @@ void D_SRB2Loop(void)
|
||||
// process tics (but maybe not if realtic == 0)
|
||||
TryRunTics(realtics);
|
||||
|
||||
if (lastdraw || singletics || gametic > rendergametic)
|
||||
if (lastdraw || singletics || (gametic > rendergametic))
|
||||
{
|
||||
rendergametic = gametic;
|
||||
rendertimeout = entertic + TICRATE/17;
|
||||
@@ -805,7 +803,7 @@ void D_SRB2Loop(void)
|
||||
{
|
||||
// Evaluate the chase cam once for every local realtic
|
||||
// This might actually be better suited inside G_Ticker or TryRunTics
|
||||
for (tic_t chasecamtics = 0; chasecamtics < realtics; chasecamtics++)
|
||||
for (tic_t chasecamtics = 0; (chasecamtics < realtics); chasecamtics++)
|
||||
{
|
||||
P_RunChaseCameras();
|
||||
}
|
||||
@@ -827,7 +825,7 @@ void D_SRB2Loop(void)
|
||||
{
|
||||
renderdeltatics = FLOAT_TO_FIXED(deltatics);
|
||||
|
||||
if (!(paused || P_AutoPause()) && !hu_stopped)
|
||||
if (!(paused || P_AutoPause()) && deltatics < 1.0 && !hu_stopped)
|
||||
{
|
||||
rendertimefrac = g_time.timefrac;
|
||||
}
|
||||
@@ -836,7 +834,14 @@ void D_SRB2Loop(void)
|
||||
rendertimefrac = FRACUNIT;
|
||||
}
|
||||
|
||||
rendertimefrac_unpaused = g_time.timefrac;
|
||||
if ((deltatics < 1.0) && !hu_stopped)
|
||||
{
|
||||
rendertimefrac_unpaused = g_time.timefrac;
|
||||
}
|
||||
else
|
||||
{
|
||||
rendertimefrac_unpaused = FRACUNIT;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -859,7 +864,6 @@ void D_SRB2Loop(void)
|
||||
// consoleplayer -> displayplayers (hear sounds from viewpoint)
|
||||
S_UpdateSounds(); // move positional sounds
|
||||
|
||||
|
||||
LUA_Step();
|
||||
|
||||
#ifdef HAVE_DISCORDRPC
|
||||
@@ -885,7 +889,7 @@ void D_SRB2Loop(void)
|
||||
//
|
||||
// Wipes run an inner loop and artificially increase
|
||||
// the measured time.
|
||||
if (!ranwipe && frameskip < 3 && deltatics > 1.0)
|
||||
if (!ranwipe && (frameskip < 3) && (deltatics > 1.0))
|
||||
{
|
||||
frameskip++;
|
||||
}
|
||||
@@ -901,7 +905,7 @@ void D_SRB2Loop(void)
|
||||
// in the case of "match refresh rate" + vsync, don't sleep at all
|
||||
const boolean vsync_with_match_refresh = cv_vidwait.value && cv_fpscap.value == 0;
|
||||
|
||||
if (elapsed > 0 && (INT64)capbudget > elapsed && !vsync_with_match_refresh)
|
||||
if ((elapsed > 0) && ((INT64)capbudget > elapsed) && !vsync_with_match_refresh)
|
||||
{
|
||||
I_SleepDuration(capbudget - (finishprecise - enterprecise));
|
||||
}
|
||||
@@ -976,10 +980,6 @@ void D_StartTitle(void)
|
||||
S_ResetKeepAndSpecialMus(); // just in case
|
||||
|
||||
F_StartTitleScreen();
|
||||
|
||||
// Reset the palette -- SRB2Kart: actually never mind let's do this in the middle of every fade
|
||||
/*if (rendermode != render_none)
|
||||
V_SetPaletteLump("PLAYPAL");*/
|
||||
}
|
||||
|
||||
//
|
||||
@@ -1197,19 +1197,22 @@ boolean found_extra_kart;
|
||||
boolean found_extra2_kart;
|
||||
boolean found_extra3_kart;
|
||||
|
||||
boolean xtra_speedo; // extra speedometer check
|
||||
boolean xtra_speedo_clr; // extra speedometer colour check
|
||||
boolean xtra_speedo3; // 80x 11 extra speedometer check
|
||||
boolean xtra_speedo_clr3; // 80x 11 extra speedometer colour check
|
||||
boolean achi_speedo; // achiiro speedometer check
|
||||
boolean achi_speedo_clr; // extra speedometer colour check
|
||||
boolean clr_hud; // colour hud check
|
||||
boolean big_lap; // bigger lap counter
|
||||
boolean big_lap_color; // bigger lap counter but colour
|
||||
boolean kartzspeedo; // kartZ speedo
|
||||
boolean statdp; // stat display for extended player setup
|
||||
boolean nametaggfx; // Nametag stuffs
|
||||
boolean driftgaugegfx;
|
||||
boolean xtra_speedo; // extra speedometer check
|
||||
boolean xtra_speedo_clr; // extra speedometer colour check
|
||||
boolean xtra_speedo3; // 80x 11 extra speedometer check
|
||||
boolean xtra_speedo_clr3; // 80x 11 extra speedometer colour check
|
||||
boolean achi_speedo; // achiiro speedometer check
|
||||
boolean achi_speedo_clr; // extra speedometer colour check
|
||||
boolean kartz_speedo; // kartZ speedo
|
||||
|
||||
boolean clr_hud; // colour hud check
|
||||
boolean big_lap; // bigger lap counter
|
||||
boolean big_lap_color; // bigger lap counter but colour
|
||||
boolean statdp; // stat display for extended player setup
|
||||
boolean nametaggfx; // Nametag stuffs
|
||||
boolean driftgaugegfx; // Driftgauge stuffs
|
||||
boolean multiitem_icon; // Extra icons for Sneakers, Banana and Jawz
|
||||
//
|
||||
|
||||
static void IdentifyVersion(void)
|
||||
{
|
||||
@@ -1435,8 +1438,6 @@ void D_SRB2Main(void)
|
||||
|
||||
// can't use sprintf since there is %u in savegamename
|
||||
strcatbf(savegamename, srb2home, PATHSEP);
|
||||
|
||||
I_mkdir(srb2home, 0700);
|
||||
#else
|
||||
snprintf(srb2home, sizeof srb2home, "%s", userhome);
|
||||
snprintf(downloaddir, sizeof downloaddir, "%s", userhome);
|
||||
@@ -1473,6 +1474,10 @@ void D_SRB2Main(void)
|
||||
}
|
||||
}
|
||||
|
||||
// Create addons dir
|
||||
snprintf(addonsdir, sizeof addonsdir, "%s%s%s", srb2home, PATHSEP, "addons");
|
||||
I_mkdir(addonsdir, 0755);
|
||||
|
||||
D_SetupProtocol();
|
||||
|
||||
// rand() needs seeded regardless of password
|
||||
@@ -1625,7 +1630,7 @@ void D_SRB2Main(void)
|
||||
"K_KZSP13", "K_KZSP14", "K_KZSP15", "K_KZSP16", "K_KZSP17", "K_KZSP18", "K_KZSP19", \
|
||||
"K_KZSP20", "K_KZSP21", "K_KZSP22", "K_KZSP23", "K_KZSP24", "K_KZSP25", NULL))
|
||||
{
|
||||
kartzspeedo = true;
|
||||
kartz_speedo = true;
|
||||
PUSHCONS(speedo_cons_temp, last_speedo_i, 4, "P-Meter");
|
||||
}
|
||||
|
||||
@@ -1639,9 +1644,11 @@ void D_SRB2Main(void)
|
||||
nametaggfx = true;
|
||||
|
||||
if (W_CheckMultipleLumps("K_DGAU","K_DCAU","K_DGSU","K_DCSU", NULL))
|
||||
{
|
||||
driftgaugegfx = true;
|
||||
}
|
||||
|
||||
// extra item icons
|
||||
if (W_CheckMultipleLumps("K_ITSHO2", "K_ITSHO3", "K_ITBAN2", "K_ITBAN3", "K_ITBAN4", "K_ITJAW2", NULL))
|
||||
multiitem_icon = true;
|
||||
|
||||
if (found_extra3_kart)
|
||||
{
|
||||
@@ -2070,7 +2077,7 @@ void D_SRB2Main(void)
|
||||
}
|
||||
|
||||
#ifdef HAVE_DISCORDRPC
|
||||
if (! dedicated)
|
||||
if (!dedicated)
|
||||
{
|
||||
DRPC_Init();
|
||||
}
|
||||
|
||||
+17
-13
@@ -27,23 +27,27 @@ extern boolean usehome; //Alam: which path?
|
||||
extern const char *pandf; //Alam: how to path?
|
||||
extern char srb2path[256]; //Alam: SRB2's Home
|
||||
|
||||
// extra graphic patches for saturn specific thingies
|
||||
extern boolean found_extra_kart; // for use in k_kart.c
|
||||
extern boolean found_extra2_kart; // for use in k_kart.c
|
||||
extern boolean found_extra3_kart; // for use in k_kart.c
|
||||
|
||||
extern boolean xtra_speedo; // extra speedometer check
|
||||
extern boolean xtra_speedo_clr; // extra speedometer colour check
|
||||
extern boolean xtra_speedo3; // 80x11 extra speedometer check
|
||||
extern boolean xtra_speedo_clr3; // 80x11 extra speedometer colour check
|
||||
extern boolean achi_speedo; // achiiro speedometer check
|
||||
extern boolean achi_speedo_clr; // extra speedometer colour check
|
||||
extern boolean clr_hud; // colour hud check
|
||||
extern boolean big_lap; // bigger lap counter
|
||||
extern boolean big_lap_color; // bigger lap counter but colour
|
||||
extern boolean kartzspeedo; // kartZ speedo
|
||||
extern boolean statdp; // stat display for extended player setup
|
||||
extern boolean nametaggfx; // Nametag stuffs
|
||||
extern boolean driftgaugegfx;
|
||||
extern boolean xtra_speedo; // extra speedometer check
|
||||
extern boolean xtra_speedo_clr; // extra speedometer colour check
|
||||
extern boolean xtra_speedo3; // 80x11 extra speedometer check
|
||||
extern boolean xtra_speedo_clr3; // 80x11 extra speedometer colour check
|
||||
extern boolean achi_speedo; // achiiro speedometer check
|
||||
extern boolean achi_speedo_clr; // extra speedometer colour check
|
||||
extern boolean kartz_speedo; // kartZ speedo
|
||||
|
||||
extern boolean clr_hud; // colour hud check
|
||||
extern boolean big_lap; // bigger lap counter
|
||||
extern boolean big_lap_color; // bigger lap counter but colour
|
||||
extern boolean statdp; // stat display for extended player setup
|
||||
extern boolean nametaggfx; // Nametag stuffs
|
||||
extern boolean driftgaugegfx; // Driftgauge stuffs
|
||||
extern boolean multiitem_icon; // Extra icons for Sneakers, Banana and Jawz
|
||||
//
|
||||
|
||||
// autoload stuff
|
||||
extern boolean autoloading;
|
||||
|
||||
+3
-2
@@ -638,6 +638,7 @@ void Net_WaitAllAckReceived(UINT32 timeout)
|
||||
static void InitNode(node_t *node)
|
||||
{
|
||||
node->acktosend_head = node->acktosend_tail = 0;
|
||||
memset(node->acktosend, 0, sizeof(node->acktosend));
|
||||
node->firstacktosend = 0;
|
||||
node->nextacknum = 1;
|
||||
node->remotefirstack = 0;
|
||||
@@ -1339,9 +1340,9 @@ boolean D_CheckNetGame(void)
|
||||
I_Error("Too many nodes (%d), max:%d", doomcom->numnodes, MAXNETNODES);
|
||||
|
||||
netbuffer = (doomdata_t *)(void *)&doomcom->data;
|
||||
#ifdef HOLEPUNCH
|
||||
#ifdef HOLEPUNCH
|
||||
holepunchpacket = (holepunch_t *)(void *)&doomcom->data;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef DEBUGFILE
|
||||
if (M_CheckParm("-debugfile"))
|
||||
|
||||
+27
-50
@@ -209,13 +209,6 @@ void SendWeaponPref3(void);
|
||||
void SendWeaponPref4(void);
|
||||
|
||||
static CV_PossibleValue_t usemouse_cons_t[] = {{0, "Off"}, {1, "On"}, {2, "Force"}, {0, NULL}};
|
||||
#if defined (__unix__) || defined (__APPLE__) || defined (UNIXCOMMON)
|
||||
static CV_PossibleValue_t mouse2port_cons_t[] = {{0, "/dev/gpmdata"}, {1, "/dev/ttyS0"},
|
||||
{2, "/dev/ttyS1"}, {3, "/dev/ttyS2"}, {4, "/dev/ttyS3"}, {0, NULL}};
|
||||
#else
|
||||
static CV_PossibleValue_t mouse2port_cons_t[] = {{1, "COM1"}, {2, "COM2"}, {3, "COM3"}, {4, "COM4"},
|
||||
{0, NULL}};
|
||||
#endif
|
||||
|
||||
#ifdef LJOYSTICK
|
||||
static CV_PossibleValue_t joyport_cons_t[] = {{1, "/dev/js0"}, {2, "/dev/js1"}, {3, "/dev/js2"},
|
||||
@@ -298,13 +291,15 @@ consvar_t cv_skipmapcheck = {"skipmapcheck", "Off", CV_SAVE, CV_OnOff, NULL, 0,
|
||||
INT32 cv_debug;
|
||||
|
||||
consvar_t cv_usemouse = {"use_mouse", "Off", CV_SAVE|CV_CALL,usemouse_cons_t, I_StartupMouse, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_usemouse2 = {"use_mouse2", "Off", CV_SAVE|CV_CALL,usemouse_cons_t, I_StartupMouse2, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
//WTF
|
||||
consvar_t cv_mouseturn = {"mouseturn", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
// Lagless camera! Yay!
|
||||
consvar_t cv_laglesscam = {"laglesscamera", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
consvar_t cv_verticallook = {"verticallook", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
#if defined(HAVE_SDL) || defined(_WINDOWS) //joystick 1 and 2
|
||||
consvar_t cv_usejoystick[MAXSPLITSCREENPLAYERS] = {
|
||||
{"use_joystick", "1", CV_SAVE|CV_CALL, usejoystick_cons_t, I_InitJoystick1, 0, NULL, NULL, 0, 0, NULL},
|
||||
@@ -331,12 +326,6 @@ consvar_t cv_joyscale[2] = { //Alam: Dummy for save
|
||||
{"joyscale", "1", CV_SAVE|CV_HIDEN, NULL, NULL, 0, NULL, NULL, 0, 0, NULL}
|
||||
};
|
||||
#endif
|
||||
#if defined (__unix__) || defined (__APPLE__) || defined (UNIXCOMMON)
|
||||
consvar_t cv_mouse2port = {"mouse2port", "/dev/gpmdata", CV_SAVE, mouse2port_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_mouse2opt = {"mouse2opt", "0", CV_SAVE, NULL, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
#else
|
||||
consvar_t cv_mouse2port = {"mouse2port", "COM2", CV_SAVE, mouse2port_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
#endif
|
||||
|
||||
consvar_t cv_matchboxes = {"matchboxes", "Normal", CV_NETVAR|CV_CHEAT|CV_NOSHOWHELP, matchboxes_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_specialrings = {"specialrings", "On", CV_NETVAR|CV_NOSHOWHELP, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
@@ -404,18 +393,18 @@ static CV_PossibleValue_t kartvoices_cons_t[] = {{0, "Never"}, {1, "Tasteful"},
|
||||
consvar_t cv_kartvoices = {"kartvoices", "Tasteful", CV_SAVE, kartvoices_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_karthitemdialog = {"karthitemdialog", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
consvar_t cv_karteliminatelast = {"karteliminatelast", "Yes", CV_NETVAR|CV_CHEAT|CV_CALL|CV_NOSHOWHELP, CV_YesNo, KartEliminateLast_OnChange, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_karteliminatelast = {"karteliminatelast", "Yes", CV_NETVAR|CV_CHEAT|CV_CALL, CV_YesNo, KartEliminateLast_OnChange, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
static CV_PossibleValue_t kartdebugitem_cons_t[] = {{-1, "MIN"}, {NUMKARTITEMS-1, "MAX"}, {0, NULL}};
|
||||
consvar_t cv_kartdebugitem = {"kartdebugitem", "0", CV_NETVAR|CV_CHEAT|CV_NOSHOWHELP, kartdebugitem_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_kartdebugitem = {"kartdebugitem", "0", CV_NETVAR|CV_CHEAT, kartdebugitem_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
static CV_PossibleValue_t kartdebugamount_cons_t[] = {{1, "MIN"}, {255, "MAX"}, {0, NULL}};
|
||||
consvar_t cv_kartdebugamount = {"kartdebugamount", "1", CV_NETVAR|CV_CHEAT|CV_NOSHOWHELP, kartdebugamount_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_kartdebugshrink = {"kartdebugshrink", "Off", CV_NETVAR|CV_CHEAT|CV_NOSHOWHELP, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_kartdebugdistribution = {"kartdebugdistribution", "Off", CV_NETVAR|CV_CHEAT|CV_NOSHOWHELP, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_kartdebughuddrop = {"kartdebughuddrop", "Off", CV_NETVAR|CV_CHEAT|CV_NOSHOWHELP, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_kartdebugamount = {"kartdebugamount", "1", CV_NETVAR|CV_CHEAT, kartdebugamount_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_kartdebugshrink = {"kartdebugshrink", "Off", CV_NETVAR|CV_CHEAT, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_kartdebugdistribution = {"kartdebugdistribution", "Off", CV_NETVAR|CV_CHEAT, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_kartdebughuddrop = {"kartdebughuddrop", "Off", CV_NETVAR|CV_CHEAT, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
consvar_t cv_kartdebugcheckpoint = {"kartdebugcheckpoint", "Off", CV_NOSHOWHELP, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_kartdebugnodes = {"kartdebugnodes", "Off", CV_NOSHOWHELP, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_kartdebugcheckpoint = {"kartdebugcheckpoint", "Off", 0, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_kartdebugnodes = {"kartdebugnodes", "Off", 0, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_kartdebugcolorize = {"kartdebugcolorize", "Off", CV_NOSHOWHELP, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
static CV_PossibleValue_t votetime_cons_t[] = {{1, "MIN"}, {3600, "MAX"}, {0, NULL}};
|
||||
@@ -527,7 +516,8 @@ static CV_PossibleValue_t ps_descriptor_cons_t[] = {
|
||||
{1, "Average"}, {2, "SD"}, {3, "Minimum"}, {4, "Maximum"}, {0, NULL}};
|
||||
consvar_t cv_ps_descriptor = {"ps_descriptor", "Average", 0, ps_descriptor_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
consvar_t cv_director = {"director", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
// only there to better keep track of it globally
|
||||
consvar_t cv_director = {"director", "Off", CV_HIDEN, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
consvar_t cv_kartdebugdirector = {"debugdirector", "Off", 0, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_showdirectorhud = {"showdirectorhud", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
@@ -868,6 +858,8 @@ void D_RegisterClientCommands(void)
|
||||
CV_RegisterVar(&cv_screenshot_option);
|
||||
CV_RegisterVar(&cv_screenshot_folder);
|
||||
CV_RegisterVar(&cv_moviemode);
|
||||
CV_RegisterVar(&cv_movie_option);
|
||||
CV_RegisterVar(&cv_movie_folder);
|
||||
// PNG variables
|
||||
CV_RegisterVar(&cv_zlib_level);
|
||||
CV_RegisterVar(&cv_zlib_memory);
|
||||
@@ -916,6 +908,8 @@ void D_RegisterClientCommands(void)
|
||||
CV_RegisterVar(&cv_rollingdemos);
|
||||
CV_RegisterVar(&cv_netstat);
|
||||
CV_RegisterVar(&cv_netticbuffer);
|
||||
CV_RegisterVar(&cv_mindelay);
|
||||
CV_RegisterVar(&cv_lagless);
|
||||
|
||||
#ifdef NETGAME_DEVMODE
|
||||
CV_RegisterVar(&cv_fishcake);
|
||||
@@ -970,14 +964,6 @@ void D_RegisterClientCommands(void)
|
||||
|
||||
CV_RegisterVar(&cv_showlocalskinmenus);
|
||||
|
||||
//CV_RegisterVar(&cv_crosshair);
|
||||
//CV_RegisterVar(&cv_crosshair2);
|
||||
//CV_RegisterVar(&cv_crosshair3);
|
||||
//CV_RegisterVar(&cv_crosshair4);
|
||||
//CV_RegisterVar(&cv_alwaysfreelook);
|
||||
//CV_RegisterVar(&cv_alwaysfreelook2);
|
||||
//CV_RegisterVar(&cv_chasefreelook);
|
||||
//CV_RegisterVar(&cv_chasefreelook2);
|
||||
CV_RegisterVar(&cv_replaysearchrate);
|
||||
CV_RegisterVar(&cv_showfocuslost);
|
||||
CV_RegisterVar(&cv_pauseifunfocused);
|
||||
@@ -987,6 +973,8 @@ void D_RegisterClientCommands(void)
|
||||
{
|
||||
CV_RegisterVar(&cv_turnaxis[i]);
|
||||
CV_RegisterVar(&cv_moveaxis[i]);
|
||||
CV_RegisterVar(&cv_camturnaxis[i]);
|
||||
CV_RegisterVar(&cv_camstrafeaxis[i]);
|
||||
CV_RegisterVar(&cv_brakeaxis[i]);
|
||||
CV_RegisterVar(&cv_aimaxis[i]);
|
||||
CV_RegisterVar(&cv_lookaxis[i]);
|
||||
@@ -1008,12 +996,6 @@ void D_RegisterClientCommands(void)
|
||||
CV_RegisterVar(&cv_addons_search_type);
|
||||
CV_RegisterVar(&cv_addons_search_case);
|
||||
|
||||
// WARNING: the order is important when initialising mouse2
|
||||
// we need the mouse2port
|
||||
CV_RegisterVar(&cv_mouse2port);
|
||||
#if defined (__unix__) || defined (__APPLE__) || defined (UNIXCOMMON)
|
||||
CV_RegisterVar(&cv_mouse2opt);
|
||||
#endif
|
||||
CV_RegisterVar(&cv_controlperkey);
|
||||
CV_RegisterVar(&cv_turnsmooth);
|
||||
|
||||
@@ -1025,15 +1007,10 @@ void D_RegisterClientCommands(void)
|
||||
}
|
||||
|
||||
CV_RegisterVar(&cv_usemouse);
|
||||
CV_RegisterVar(&cv_usemouse2);
|
||||
CV_RegisterVar(&cv_invertmouse);
|
||||
CV_RegisterVar(&cv_invertmouse2);
|
||||
CV_RegisterVar(&cv_mousesens);
|
||||
CV_RegisterVar(&cv_mousesens2);
|
||||
CV_RegisterVar(&cv_mouseysens);
|
||||
CV_RegisterVar(&cv_mouseysens2);
|
||||
//CV_RegisterVar(&cv_mousemove);
|
||||
//CV_RegisterVar(&cv_mousemove2);
|
||||
|
||||
for (i = 0; i < MAXSPLITSCREENPLAYERS; i++)
|
||||
{
|
||||
@@ -1091,6 +1068,8 @@ void D_RegisterClientCommands(void)
|
||||
|
||||
CV_RegisterVar(&cv_laglesscam);
|
||||
|
||||
CV_RegisterVar(&cv_verticallook);
|
||||
|
||||
// ingame object placing
|
||||
COM_AddCommand("objectplace", Command_ObjectPlace_f);
|
||||
COM_AddCommand("writethings", Command_Writethings_f);
|
||||
@@ -2237,7 +2216,7 @@ static void Command_View_f(void)
|
||||
return;
|
||||
}
|
||||
|
||||
if (demo.freecam)
|
||||
if (camera[viewnum-1].freecam)
|
||||
return;
|
||||
|
||||
displayplayerp = &displayplayers[viewnum-1];
|
||||
@@ -2455,8 +2434,6 @@ static void Command_StopMovie_f(void)
|
||||
|
||||
INT32 mapchangepending = 0;
|
||||
|
||||
tic_t driftsparkGrowTimer[MAXPLAYERS];
|
||||
|
||||
/** Runs a map change.
|
||||
* The supplied data are assumed to be good. If provided by a user, they will
|
||||
* have already been checked in Command_Map_f().
|
||||
@@ -2490,9 +2467,6 @@ void D_MapChange(INT32 mapnum, INT32 newgametype, boolean pencoremode, boolean r
|
||||
CONS_Debug(DBG_GAMELOGIC, "Map change: mapnum=%d gametype=%d encoremode=%d resetplayers=%d delay=%d skipprecutscene=%d\n",
|
||||
mapnum, newgametype, pencoremode, resetplayers, delay, skipprecutscene);
|
||||
|
||||
// just gonna hack in a timer reset here...
|
||||
memset(driftsparkGrowTimer, 0, sizeof(driftsparkGrowTimer));
|
||||
|
||||
if (netgame || multiplayer)
|
||||
FLS = false;
|
||||
|
||||
@@ -2702,6 +2676,8 @@ static void Command_Map_f(void)
|
||||
return;
|
||||
}
|
||||
|
||||
M_ClearMenus(true);
|
||||
|
||||
last_map_cmd = I_GetTime();
|
||||
|
||||
size_t first_option;
|
||||
@@ -2894,6 +2870,7 @@ static void Command_Map_f(void)
|
||||
}
|
||||
|
||||
fromlevelselect = false;
|
||||
|
||||
D_MapChange(newmapnum, newgametype, newencoremode, newresetplayers, 0, false, false);
|
||||
|
||||
Z_Free(realmapname);
|
||||
@@ -3177,7 +3154,7 @@ static void Got_Respawn(UINT8 **cp, INT32 playernum)
|
||||
return;
|
||||
|
||||
if (players[respawnplayer].mo)
|
||||
P_DamageMobj(players[respawnplayer].mo, NULL, NULL, 10000);
|
||||
P_DamageMobj(players[respawnplayer].mo, NULL, NULL, DMG_INSTAKILL);
|
||||
demo_extradata[playernum] |= DXD_RESPAWN;
|
||||
}
|
||||
|
||||
@@ -3879,7 +3856,7 @@ static void Got_Teamchange(UINT8 **cp, INT32 playernum)
|
||||
if (!players[playernum].spectator)
|
||||
{
|
||||
if (players[playernum].mo)
|
||||
P_DamageMobj(players[playernum].mo, NULL, NULL, 10000);
|
||||
P_DamageMobj(players[playernum].mo, NULL, NULL, DMG_INSTAKILL);
|
||||
else
|
||||
players[playernum].playerstate = PST_REBORN;
|
||||
}
|
||||
|
||||
+2
-11
@@ -50,13 +50,6 @@ extern consvar_t cv_joyport2;
|
||||
#endif
|
||||
extern consvar_t cv_joyscale[4]; //MAXSPLITSCREENPLAYERS
|
||||
|
||||
// splitscreen with second mouse
|
||||
extern consvar_t cv_mouse2port;
|
||||
extern consvar_t cv_usemouse2;
|
||||
#if defined (__unix__) || defined (__APPLE__) || defined (UNIXCOMMON)
|
||||
extern consvar_t cv_mouse2opt;
|
||||
#endif
|
||||
|
||||
// normally in p_mobj but the .h is not read
|
||||
extern consvar_t cv_itemrespawntime;
|
||||
extern consvar_t cv_itemrespawn;
|
||||
@@ -179,9 +172,7 @@ extern consvar_t cv_nametagdist;
|
||||
extern consvar_t cv_showownnametag;
|
||||
extern consvar_t cv_smallnametags;
|
||||
extern consvar_t cv_nametagrestat;
|
||||
extern consvar_t cv_nametaghop;
|
||||
extern consvar_t cv_nametagscore;
|
||||
extern consvar_t cv_shownametagfinish;
|
||||
extern consvar_t cv_shownametagspectator;
|
||||
|
||||
#define SKINSELECTSPIN_PAIN 25
|
||||
@@ -207,6 +198,8 @@ extern consvar_t cv_betainterscreen;
|
||||
|
||||
extern consvar_t cv_laglesscam;
|
||||
|
||||
extern consvar_t cv_verticallook;
|
||||
|
||||
typedef enum
|
||||
{
|
||||
SKINMENUTYPE_SCROLL = 0,
|
||||
@@ -304,8 +297,6 @@ typedef union {
|
||||
#pragma pack()
|
||||
#endif
|
||||
|
||||
extern tic_t driftsparkGrowTimer[16];
|
||||
|
||||
// add game commands, needs cleanup
|
||||
void D_RegisterServerCommands(void);
|
||||
void D_RegisterClientCommands(void);
|
||||
|
||||
@@ -233,6 +233,9 @@ void D_ParseFileneeded(INT32 fileneedednum_parm, UINT8 *fileneededstr, UINT16 fi
|
||||
|
||||
void CL_PrepareDownloadSaveGame(const char *tmpsave)
|
||||
{
|
||||
#ifdef CLIENT_LOADINGSCREEN
|
||||
lastfilenum = -1;
|
||||
#endif
|
||||
fileneedednum = 1;
|
||||
fileneeded[0].status = FS_REQUESTED;
|
||||
fileneeded[0].totalsize = UINT32_MAX;
|
||||
|
||||
+6
-4
@@ -351,6 +351,7 @@ typedef enum
|
||||
typedef enum
|
||||
{
|
||||
LAP_CUR,
|
||||
LAP_BEST,
|
||||
LAP_LAST,
|
||||
LAP__MAX
|
||||
} laptime_e;
|
||||
@@ -412,8 +413,6 @@ typedef struct player_s
|
||||
// See pflags_t, above.
|
||||
pflags_t pflags;
|
||||
|
||||
UINT16 postimgflags;
|
||||
|
||||
// playing animation.
|
||||
panim_t panim;
|
||||
|
||||
@@ -551,9 +550,12 @@ typedef struct player_s
|
||||
UINT8 hitemvictim;
|
||||
|
||||
UINT8 splitscreenindex;
|
||||
#ifdef HWRENDER
|
||||
|
||||
tic_t driftsparkGrowTimer;
|
||||
|
||||
fixed_t spinoutrot; // When a player spins out, this value increments modulus 360.
|
||||
|
||||
fixed_t fovadd; // adjust FOV for hw rendering
|
||||
#endif
|
||||
} player_t;
|
||||
|
||||
#endif
|
||||
+50
-4
@@ -7761,7 +7761,18 @@ struct {
|
||||
{"FF_HORIZONTALFLIP",FF_HORIZONTALFLIP},
|
||||
{"FF_PAPERSPRITE",FF_PAPERSPRITE},
|
||||
{"FF_ANIMATE",FF_ANIMATE},
|
||||
// brightness
|
||||
{"FF_BRIGHTMASK",FF_BRIGHTMASK},
|
||||
{"FF_FULLBRIGHT",FF_FULLBRIGHT},
|
||||
{"FF_SEMIBRIGHT",FF_SEMIBRIGHT},
|
||||
{"FF_FULLDARK",FF_FULLDARK},
|
||||
// blending
|
||||
{"FF_BLENDMASK",FF_BLENDMASK},
|
||||
{"FF_BLENDSHIFT",FF_BRIGHTMASK},
|
||||
{"FF_ADD",FF_ADD},
|
||||
{"FF_SUBTRACT",FF_SUBTRACT},
|
||||
{"FF_REVERSESUBTRACT",FF_REVERSESUBTRACT},
|
||||
{"FF_MODULATE",FF_MODULATE},
|
||||
{"FF_TRANSMASK",FF_TRANSMASK},
|
||||
{"FF_TRANSSHIFT",FF_TRANSSHIFT},
|
||||
// new preshifted translucency (used in source)
|
||||
@@ -7797,6 +7808,15 @@ struct {
|
||||
{"tr_trans90",tr_trans90},
|
||||
{"NUMTRANSMAPS",NUMTRANSMAPS},
|
||||
|
||||
// Alpha styles (blend modes)
|
||||
{"AST_COPY",AST_COPY},
|
||||
{"AST_TRANSLUCENT",AST_TRANSLUCENT},
|
||||
{"AST_ADD",AST_ADD},
|
||||
{"AST_SUBTRACT",AST_SUBTRACT},
|
||||
{"AST_REVERSESUBTRACT",AST_REVERSESUBTRACT},
|
||||
{"AST_MODULATE",AST_MODULATE},
|
||||
{"AST_OVERLAY",AST_OVERLAY},
|
||||
|
||||
// Type of levels
|
||||
{"TOL_SP",TOL_SP},
|
||||
{"TOL_COOP",TOL_COOP},
|
||||
@@ -8161,6 +8181,14 @@ struct {
|
||||
{"V_CHARCOLORSHIFT",V_CHARCOLORSHIFT},
|
||||
{"V_ALPHASHIFT",V_ALPHASHIFT},
|
||||
|
||||
// Blending
|
||||
{"V_BLENDSHIFT",V_BLENDSHIFT},
|
||||
{"V_BLENDMASK",V_BLENDMASK},
|
||||
{"B_ADD",B_ADD},
|
||||
{"B_SUBTRACT",B_SUBTRACT},
|
||||
{"B_REVERSESUBTRACT",B_REVERSESUBTRACT},
|
||||
{"B_MODULATE",B_MODULATE},
|
||||
|
||||
//Kick Reasons
|
||||
{"KR_KICK",KR_KICK},
|
||||
{"KR_PINGLIMIT",KR_PINGLIMIT},
|
||||
@@ -8585,6 +8613,16 @@ static int lua_enumlib_mariomode_get(lua_State *L)
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int lua_enumlib_replayfreecam_get(lua_State *L)
|
||||
{
|
||||
if (dedicated) // huh?
|
||||
lua_pushboolean(L, false);
|
||||
else
|
||||
lua_pushboolean(L, camera[R_GetViewNumber()].freecam);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int lua_enumlib_twodlevel_get(lua_State *L)
|
||||
{
|
||||
lua_pushboolean(L, twodlevel);
|
||||
@@ -9189,8 +9227,6 @@ int LUA_EnumLib(lua_State *L)
|
||||
PUSHGETTER(globalweather, u8);
|
||||
PUSHGETTER(levelskynum, i32);
|
||||
PUSHGETTER(globallevelskynum, i32);
|
||||
PUSHGETTER(mapmusflags, u16);
|
||||
PUSHGETTER(mapmusposition, u32);
|
||||
PUSHGETTER(gravity, fxp);
|
||||
PUSHGETTER(gamespeed, u8);
|
||||
PUSHGETTER(encoremode, bool);
|
||||
@@ -9205,9 +9241,19 @@ int LUA_EnumLib(lua_State *L)
|
||||
PUSHGETTER(racecountdown, u32);
|
||||
PUSHGETTER(exitcountdown, u32);
|
||||
|
||||
lua_pushcfunction(L, lua_glib_new_getter);
|
||||
lua_pushliteral(L, "mapmusflags");
|
||||
lua_glib_push_u16_getter(L, &mapmusic.flags);
|
||||
lua_call(L, 2, 0);
|
||||
|
||||
lua_pushcfunction(L, lua_glib_new_getter);
|
||||
lua_pushliteral(L, "mapmusposition");
|
||||
lua_glib_push_u32_getter(L, &mapmusic.position);
|
||||
lua_call(L, 2, 0);
|
||||
|
||||
lua_pushcfunction(L, lua_glib_new_getter);
|
||||
lua_pushliteral(L, "mapmusname");
|
||||
lua_glib_push_str_getter(L, mapmusname);
|
||||
lua_glib_push_str_getter(L, mapmusic.name);
|
||||
lua_call(L, 2, 0);
|
||||
|
||||
lua_pushcfunction(L, lua_glib_new_getter);
|
||||
@@ -9262,7 +9308,7 @@ int LUA_EnumLib(lua_State *L)
|
||||
|
||||
lua_pushcfunction(L, lua_glib_new_getter);
|
||||
lua_pushliteral(L, "replayfreecam");
|
||||
lua_glib_push_bool_getter(L, &demo.freecam);
|
||||
lua_pushcfunction(L, lua_enumlib_replayfreecam_get);
|
||||
lua_call(L, 2, 0);
|
||||
|
||||
if (!mathlib)
|
||||
|
||||
+1
-2
@@ -530,9 +530,8 @@ UINT32 quickncasehash (const char *p, size_t n)
|
||||
#ifndef max // Double-Check with WATTCP-32's cdefs.h
|
||||
#define max(x, y) (((x) > (y)) ? (x) : (y))
|
||||
#endif
|
||||
|
||||
#ifndef CLAMP
|
||||
#define CLAMP(x, min_val, max_val) ((x) < (min_val) ? (min_val) : ((x) > (max_val) ? (max_val) : (x)))
|
||||
#define CLAMP(x, y, z) ((x) < (y) ? (y) : ((x) > (z) ? (z) : (x)))
|
||||
#endif
|
||||
|
||||
#ifndef M_PIl
|
||||
|
||||
+15
-6
@@ -30,16 +30,26 @@
|
||||
// =============================
|
||||
|
||||
// Selected by user.
|
||||
extern INT16 gamemap;
|
||||
extern char mapmusname[7];
|
||||
extern UINT16 mapmusflags;
|
||||
extern UINT32 mapmusposition;
|
||||
extern UINT32 mapmusresume;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
char name[7]; // Music name, up to 6-character name
|
||||
void *data; // Music lump
|
||||
UINT16 flags; // Track and reset bit
|
||||
boolean looping; // Is this music looping?
|
||||
UINT32 position; // Position to jump to
|
||||
UINT32 resume; // Saved Position when music was stopped
|
||||
UINT32 fadeinms; // Fade in time in ms (used for queue)
|
||||
} music_t;
|
||||
|
||||
extern music_t mapmusic;
|
||||
|
||||
#define MUSIC_TRACKMASK 0x0FFF // ----************
|
||||
#define MUSIC_RELOADRESET 0x8000 // *---------------
|
||||
#define MUSIC_FORCERESET 0x4000 // -*--------------
|
||||
// Use other bits if necessary.
|
||||
|
||||
extern INT16 gamemap;
|
||||
extern INT16 maptol;
|
||||
extern UINT8 globalweather;
|
||||
extern INT32 curWeather;
|
||||
@@ -503,7 +513,6 @@ extern boolean startedInFreePlay;
|
||||
|
||||
extern boolean legitimateexit;
|
||||
extern boolean comebackshowninfo;
|
||||
extern tic_t curlap, bestlap;
|
||||
|
||||
extern INT16 votelevels[4][2];
|
||||
extern SINT8 votes[MAXPLAYERS];
|
||||
|
||||
+3
-9
@@ -342,15 +342,6 @@ union FColorRGBA
|
||||
} ATTRPACK;
|
||||
typedef union FColorRGBA RGBA_t;
|
||||
|
||||
typedef enum
|
||||
{
|
||||
POSTIMG_WATER = 1, // Underwater screen effect.
|
||||
POSTIMG_MOTION = 1<<1, // Unused motion blur effect.
|
||||
POSTIMG_FLIP = 1<<2, // Flipcam screen effect.
|
||||
POSTIMG_HEAT = 1<<3, // Heatwave screen effect.
|
||||
POSTIMG_MIRROR = 1<<4, // encore screen effect.
|
||||
} postimgflag_t;
|
||||
|
||||
typedef UINT32 lumpnum_t; // 16 : 16 unsigned long (wad num: lump num)
|
||||
#define LUMPERROR UINT32_MAX
|
||||
|
||||
@@ -389,6 +380,9 @@ unset_bit_array (bitarray_t * const array, const int value)
|
||||
array[value >> 3] &= ~(1<<(value & 7));
|
||||
}
|
||||
|
||||
#define intsign(n) \
|
||||
((n) < 0 ? -1 : (n) > 0 ? 1 : 0)
|
||||
|
||||
typedef UINT64 precise_t;
|
||||
|
||||
#endif //__DOOMTYPE__
|
||||
@@ -92,8 +92,6 @@ void I_OutputMsg(const char *error, ...)
|
||||
|
||||
void I_StartupMouse(void){}
|
||||
|
||||
void I_StartupMouse2(void){}
|
||||
|
||||
void I_StartupKeyboard(void){}
|
||||
|
||||
INT32 I_GetKey(void)
|
||||
@@ -146,8 +144,6 @@ void I_GetJoystickEvents(void){}
|
||||
|
||||
void I_GetJoystick2Events(void){}
|
||||
|
||||
void I_GetMouseEvents(void){}
|
||||
|
||||
char *I_GetEnv(const char *name)
|
||||
{
|
||||
(void)name;
|
||||
|
||||
+1
-1
@@ -273,7 +273,7 @@ static void F_DoWipe(fademask_t *fademask)
|
||||
else
|
||||
{
|
||||
// pointer to transtable that this mask would use
|
||||
transtbl = transtables + ((9 - *mask)<<FF_TRANSSHIFT);
|
||||
transtbl = R_GetTranslucencyTable((9 - *mask) + 1);
|
||||
|
||||
// DRAWING LOOP
|
||||
while (draw_linestogo--)
|
||||
|
||||
+1
-1
@@ -797,7 +797,7 @@ boolean preparefilemenu(boolean samedepth, boolean replayhut)
|
||||
}
|
||||
else if (ext == EXT_TXT)
|
||||
{
|
||||
if (!strcmp(dent->d_name, "log.txt") || !strcmp(dent->d_name, "errorlog.txt"))
|
||||
if (!strncmp(dent->d_name, "log-", 4) || !strcmp(dent->d_name, "errorlog.txt"))
|
||||
ext |= EXT_LOADED;
|
||||
}
|
||||
|
||||
|
||||
+234
-279
@@ -84,10 +84,7 @@ static void G_DoStartVote(void);
|
||||
|
||||
static void G_ResetDemoPlayback(char *pdemoname);
|
||||
|
||||
char mapmusname[7]; // Music name
|
||||
UINT16 mapmusflags; // Track and reset bit
|
||||
UINT32 mapmusposition; // Position to jump to
|
||||
UINT32 mapmusresume;
|
||||
music_t mapmusic;
|
||||
|
||||
INT16 gamemap = 1;
|
||||
INT16 maptol;
|
||||
@@ -281,8 +278,6 @@ boolean startedInFreePlay; // Map was started in free play
|
||||
// Client-sided, unsynched variables (NEVER use in anything that needs to be synced with other players)
|
||||
boolean legitimateexit; // Did this client actually finish the match?
|
||||
boolean comebackshowninfo; // Have you already seen the "ATTACK OR PROTECT" message?
|
||||
tic_t curlap; // Current lap time
|
||||
tic_t bestlap; // Best lap time
|
||||
static INT16 randmapbuffer[NUMMAPS+1]; // Buffer for maps RandMap is allowed to roll
|
||||
|
||||
tic_t hidetime;
|
||||
@@ -336,11 +331,6 @@ boolean precache = true; // if true, load all graphics at start
|
||||
|
||||
INT16 prevmap, nextmap;
|
||||
|
||||
// save if director is enabled
|
||||
// so demos can disable it by default and restore it after
|
||||
static int directorstate = 0;
|
||||
tic_t directortoggletimer = 0;
|
||||
|
||||
static CV_PossibleValue_t recordmultiplayerdemos_cons_t[] = {{0, "Disabled"}, {1, "Manual Save"}, {2, "Auto Save"}, {0, NULL}};
|
||||
consvar_t cv_recordmultiplayerdemos = {"netdemo_record", "Manual Save", CV_SAVE, recordmultiplayerdemos_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
@@ -360,8 +350,6 @@ void SendWeaponPref2(void);
|
||||
void SendWeaponPref3(void);
|
||||
void SendWeaponPref4(void);
|
||||
|
||||
static void G_FixCamera(UINT8 view);
|
||||
|
||||
// don't mind me putting these here, I was lazy to figure out where else I could put those without blowing up the compiler.
|
||||
|
||||
// chat timer thingy
|
||||
@@ -403,20 +391,9 @@ static CV_PossibleValue_t powermusic_cons_t[] = {{0, "Off"}, {1, "On"}, {2, "SFX
|
||||
consvar_t cv_growmusic = {"growmusic", "On", CV_SAVE, powermusic_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_supermusic = {"supermusic", "On", CV_SAVE, powermusic_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
/*consvar_t cv_crosshair = {"crosshair", "Off", CV_SAVE, crosshair_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_crosshair2 = {"crosshair2", "Off", CV_SAVE, crosshair_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_crosshair3 = {"crosshair3", "Off", CV_SAVE, crosshair_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_crosshair4 = {"crosshair4", "Off", CV_SAVE, crosshair_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};*/
|
||||
consvar_t cv_invertmouse = {"invertmouse", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_invertmouse2 = {"invertmouse2", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
/*consvar_t cv_alwaysfreelook = {"alwaysmlook", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_alwaysfreelook2 = {"alwaysmlook2", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_chasefreelook = {"chasemlook", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_chasefreelook2 = {"chasemlook2", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_mousemove = {"mousemove", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_mousemove2 = {"mousemove2", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};*/
|
||||
//consvar_t cv_mousemove = {"mousemove", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
//static CV_PossibleValue_t crosshair_cons_t[] = {{0, "Off"}, {1, "Cross"}, {2, "Angle"}, {3, "Point"}, {0, NULL}};
|
||||
static CV_PossibleValue_t joyaxis_cons_t[] = {{0, "None"},
|
||||
{1, "Left X"}, {2, "Left Y"}, {-1, "Left X-"}, {-2, "Left Y-"},
|
||||
#if JOYAXISSET > 1
|
||||
@@ -449,6 +426,20 @@ consvar_t cv_moveaxis[MAXSPLITSCREENPLAYERS] = {
|
||||
{"joyaxis4_move", "None", CV_SAVE, joyaxis_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}
|
||||
};
|
||||
|
||||
consvar_t cv_camstrafeaxis[MAXSPLITSCREENPLAYERS] = {
|
||||
{"joyaxis_camstrafe", "None", CV_SAVE, joyaxis_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL},
|
||||
{"joyaxis2_camstrafe", "None", CV_SAVE, joyaxis_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL},
|
||||
{"joyaxis3_camstrafe", "None", CV_SAVE, joyaxis_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL},
|
||||
{"joyaxis4_camstrafe", "None", CV_SAVE, joyaxis_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}
|
||||
};
|
||||
|
||||
consvar_t cv_camturnaxis[MAXSPLITSCREENPLAYERS] = {
|
||||
{"joyaxis_camturn", "Left X", CV_SAVE, joyaxis_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL},
|
||||
{"joyaxis2_camturn", "Left X", CV_SAVE, joyaxis_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL},
|
||||
{"joyaxis3_camturn", "Left X", CV_SAVE, joyaxis_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL},
|
||||
{"joyaxis4_camturn", "Left X", CV_SAVE, joyaxis_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}
|
||||
};
|
||||
|
||||
consvar_t cv_brakeaxis[MAXSPLITSCREENPLAYERS] = {
|
||||
{"joyaxis_brake", "None", CV_SAVE, joyaxis_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL},
|
||||
{"joyaxis2_brake", "None", CV_SAVE, joyaxis_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL},
|
||||
@@ -529,26 +520,6 @@ consvar_t cv_ydeadzone[MAXSPLITSCREENPLAYERS] = {
|
||||
static CV_PossibleValue_t driftsparkpulse_t[] = {{0, "MIN"}, {FRACUNIT*3, "MAX"}, {0, NULL}};
|
||||
consvar_t cv_driftsparkpulse = {"driftsparkpulse", "1.4", CV_FLOAT | CV_SAVE, driftsparkpulse_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
static CV_PossibleValue_t stretchfactor_t[] = {
|
||||
{0, "Off"}, {FRACUNIT/8, "0.125"}, {FRACUNIT/4, "0.250"},
|
||||
{3*FRACUNIT/8, "0.375"}, {FRACUNIT/2, "0.500"}, {5*FRACUNIT/8, "0.625"},
|
||||
{3*FRACUNIT/4, "0.750"}, {7*FRACUNIT/8, "0.875"}, {FRACUNIT, "Max"}, {0, NULL}};
|
||||
consvar_t cv_gravstretch = {"gravstretch", "0", CV_SAVE, stretchfactor_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
static CV_PossibleValue_t slamsound_t[] = {{0, "Off"}, {1, "On"}, {0, NULL}};
|
||||
consvar_t cv_slamsound = {"slamsound", "1", CV_SAVE, slamsound_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
static CV_PossibleValue_t sloperolldist_cons_t[] = {
|
||||
/*{256, "256"},*/ {512, "512"}, {768, "768"},
|
||||
{1024, "1024"}, {1536, "1536"}, {2048, "2048"},
|
||||
{3072, "3072"}, {4096, "4096"}, {6144, "6144"},
|
||||
{8192, "8192"}, {0, "Infinite"}, {0, NULL}};
|
||||
consvar_t cv_sloperolldist = {"sloperolldist", "Infinite", CV_SAVE, sloperolldist_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
static CV_PossibleValue_t sloperoll_cons_t[] = {{0, "Off"}, {1, "Players"}, {2, "Everything"}, {0, NULL}};
|
||||
consvar_t cv_sloperoll = {"sloperoll", "Off", CV_SAVE|CV_CALL, sloperoll_cons_t, PDistort_menu_Onchange, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_sparkroll = {"sparkroll", "Off", CV_SAVE|CV_CALL, CV_OnOff, PDistort_menu_Onchange, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_sliptideroll = {"sliptideroll", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
consvar_t cv_cechotoggle = {"show_cecho", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
#if MAXPLAYERS > 16
|
||||
@@ -741,6 +712,12 @@ INT32 JoyAxis(axis_input_e axissel, UINT8 player)
|
||||
case AXISMOVE:
|
||||
axisval = cv_moveaxis[player-1].value;
|
||||
break;
|
||||
case AXISCAMTURN:
|
||||
axisval = cv_camturnaxis[player-1].value;
|
||||
break;
|
||||
case AXISCAMSTRAFE:
|
||||
axisval = cv_camstrafeaxis[player-1].value;
|
||||
break;
|
||||
case AXISBRAKE:
|
||||
axisval = cv_brakeaxis[player-1].value;
|
||||
break;
|
||||
@@ -834,14 +811,6 @@ boolean InputDown(INT32 gc, UINT8 p)
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// G_BuildTiccmd
|
||||
// Builds a ticcmd from all of the available inputs
|
||||
// or reads it from the demo buffer.
|
||||
// If recording a demo, write it out
|
||||
//
|
||||
// set secondaryplayer true to build player 2's ticcmd in splitscreen mode
|
||||
//
|
||||
INT32 localaiming[MAXSPLITSCREENPLAYERS];
|
||||
angle_t localangle[MAXSPLITSCREENPLAYERS];
|
||||
boolean camspin[MAXSPLITSCREENPLAYERS];
|
||||
@@ -850,42 +819,94 @@ static fixed_t forwardmove[2] = {25<<FRACBITS>>16, 50<<FRACBITS>>16};
|
||||
static fixed_t sidemove[2] = {2<<FRACBITS>>16, 4<<FRACBITS>>16};
|
||||
static fixed_t angleturn[3] = {KART_FULLTURN/2, KART_FULLTURN, KART_FULLTURN/4}; // + slow turn
|
||||
|
||||
//
|
||||
// G_BuildLocalTiccmd
|
||||
// extremely basic cut down ticcmd builder
|
||||
// for spectator and freecam
|
||||
// this does not make the player move at all but keeps important things working
|
||||
//
|
||||
static void G_BuildLocalTiccmd(ticcmd_t *cmd, UINT8 ssplayer, boolean freecam)
|
||||
{
|
||||
boolean moveinput = false;
|
||||
INT32 axis = 0;
|
||||
const boolean usejoystick = (cv_usejoystick[(ssplayer-1)].value);
|
||||
|
||||
// check for inputs and return button commands
|
||||
// for stuff like joining with item button, saltyhop, honking, etc.
|
||||
#define CHECKINPUT(button, AXIS, buttflag) \
|
||||
axis = JoyAxis(AXIS, ssplayer); \
|
||||
if (InputDown(button, ssplayer) || (usejoystick && axis > 0)) cmd->buttons |= buttflag;
|
||||
|
||||
CHECKINPUT(gc_fire, AXISFIRE, BT_ATTACK);
|
||||
CHECKINPUT(gc_drift, AXISDRIFT, BT_DRIFT);
|
||||
CHECKINPUT(gc_custom1, AXISCUSTOM1, BT_CUSTOM1);
|
||||
CHECKINPUT(gc_custom2, AXISCUSTOM2, BT_CUSTOM2);
|
||||
CHECKINPUT(gc_custom3, AXISCUSTOM3, BT_CUSTOM3);
|
||||
|
||||
// we dont need the rest of this if were in freecam state
|
||||
if (freecam)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
CHECKINPUT(gc_accelerate, AXISMOVE, BT_ACCELERATE);
|
||||
CHECKINPUT(gc_brake, AXISBRAKE, BT_BRAKE);
|
||||
|
||||
#undef CHECKINPUT
|
||||
|
||||
moveinput = (InputDown(gc_turnleft, ssplayer) || InputDown(gc_turnright, ssplayer)
|
||||
|| InputDown(gc_aimforward, ssplayer) || InputDown(gc_aimbackward, ssplayer) ||
|
||||
(usejoystick && JoyAxis(AXISAIM, ssplayer) != 0) || (usejoystick && JoyAxis(AXISTURN, ssplayer) != 0));
|
||||
|
||||
axis = JoyAxis(AXISLOOKBACK, ssplayer);
|
||||
camspin[ssplayer-1] = (InputDown(gc_lookback, ssplayer) || (usejoystick && axis > 0));
|
||||
|
||||
// Reset to our spec player if we watch someone else.
|
||||
if ((moveinput || cmd->buttons)
|
||||
&& displayplayers[0] != consoleplayer && ssplayer == 1)
|
||||
{
|
||||
if (cv_director.value)
|
||||
CV_SetValue(&cv_director, 0);
|
||||
|
||||
displayplayers[0] = consoleplayer;
|
||||
R_ResetViewInterpolation(0);
|
||||
camera[0].reset_aiming = true;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// G_BuildTiccmd
|
||||
// Builds a ticcmd from all of the available inputs
|
||||
// or reads it from the demo buffer.
|
||||
// If recording a demo, write it out
|
||||
//
|
||||
void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
|
||||
{
|
||||
const UINT8 forplayer = ssplayer-1;
|
||||
INT32 laim, th, tspeed, forward, side, axis; //i
|
||||
const INT32 speed = 1;
|
||||
INT32 laim, th, tspeed, forward, side, axis;
|
||||
|
||||
// these ones used for multiple conditions
|
||||
boolean turnleft, turnright, mouseaiming;
|
||||
boolean invertmouse, usejoystick, kbl, rd;
|
||||
player_t *player;
|
||||
camera_t *thiscam;
|
||||
boolean turnleft, turnright;
|
||||
boolean usejoystick, rd;
|
||||
angle_t lang;
|
||||
|
||||
static INT32 turnheld[MAXSPLITSCREENPLAYERS]; // for accelerative turning
|
||||
static boolean keyboard_look[MAXSPLITSCREENPLAYERS]; // true if lookup/down using keyboard
|
||||
static boolean resetdown[MAXSPLITSCREENPLAYERS]; // don't cam reset every frame
|
||||
|
||||
const boolean lookaxis = cv_lookaxis[forplayer].value;
|
||||
if (demo.playback)
|
||||
return;
|
||||
|
||||
const UINT8 forplayer = (ssplayer-1);
|
||||
player_t *player = ((ssplayer == 1) ? &players[consoleplayer] : &players[displayplayers[forplayer]]);
|
||||
|
||||
camera_t *thiscam = &camera[forplayer];
|
||||
const boolean freecam = camera[forplayer].freecam;
|
||||
|
||||
const boolean analogjoystickmove = cv_usejoystick[forplayer].value && !Joystick[forplayer].bGamepadStyle;
|
||||
const boolean gamepadjoystickmove = cv_usejoystick[forplayer].value && Joystick[forplayer].bGamepadStyle;
|
||||
|
||||
if (demo.playback) return;
|
||||
|
||||
if (ssplayer == 1)
|
||||
player = &players[consoleplayer];
|
||||
else
|
||||
player = &players[displayplayers[forplayer]];
|
||||
|
||||
if (ssplayer == 2)
|
||||
thiscam = (player->bot == 2 ? &camera[0] : &camera[forplayer]);
|
||||
else
|
||||
thiscam = &camera[forplayer];
|
||||
|
||||
lang = localangle[forplayer];
|
||||
laim = localaiming[forplayer];
|
||||
th = turnheld[forplayer];
|
||||
kbl = keyboard_look[forplayer];
|
||||
rd = resetdown[forplayer];
|
||||
|
||||
switch (ssplayer)
|
||||
@@ -915,25 +936,17 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
|
||||
return;
|
||||
}
|
||||
|
||||
switch (ssplayer)
|
||||
// dumbass thing so we can use a few buttons but dont accidentally drive away
|
||||
if (player->spectator || freecam)
|
||||
{
|
||||
case 2:
|
||||
mouseaiming = player->spectator; //(PLAYER2INPUTDOWN(gc_mouseaiming)) ^ cv_alwaysfreelook2.value;
|
||||
invertmouse = cv_invertmouse2.value;
|
||||
break;
|
||||
case 3:
|
||||
mouseaiming = false;
|
||||
invertmouse = false;
|
||||
break;
|
||||
case 4:
|
||||
mouseaiming = false;
|
||||
invertmouse = false;
|
||||
break;
|
||||
case 1:
|
||||
default:
|
||||
mouseaiming = player->spectator; //(PLAYER1INPUTDOWN(gc_mouseaiming)) ^ cv_alwaysfreelook.value;
|
||||
invertmouse = cv_invertmouse.value;
|
||||
break;
|
||||
cmd->angleturn = (INT16)(lang >> 16);
|
||||
G_BuildLocalTiccmd(cmd, ssplayer, freecam);
|
||||
|
||||
// let lua override everything
|
||||
if (gamestate == GS_LEVEL)
|
||||
LUA_HookTiccmd(player, cmd, HOOK(PlayerCmd));
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
usejoystick = (analogjoystickmove || gamepadjoystickmove);
|
||||
@@ -967,7 +980,7 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
|
||||
if (th < SLOWTURNTICS)
|
||||
tspeed = cv_turnsmooth.value == 2 ? 2 : 0; // slow turn
|
||||
else
|
||||
tspeed = speed;
|
||||
tspeed = 1;
|
||||
|
||||
cmd->driftturn = 0;
|
||||
|
||||
@@ -993,14 +1006,14 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
|
||||
side += ((axis * sidemove[0]) >> 10);
|
||||
}
|
||||
|
||||
if (player->spectator || cv_mouseturn.value)
|
||||
if (cv_mouseturn.value)
|
||||
{
|
||||
//THIS WORKS WTF????????
|
||||
cmd->angleturn = (INT16)(cmd->angleturn - ((mousex*(encoremode ? -1 : 1)*8)));
|
||||
cmd->driftturn = (INT16)(cmd->driftturn - ((mousex*(encoremode ? -1 : 1)*8)));
|
||||
}
|
||||
|
||||
if (player->spectator || objectplacing) // SRB2Kart: spectators need special controls
|
||||
if (objectplacing) // SRB2Kart: spectators need special controls // not anymore huehuehue
|
||||
{
|
||||
axis = JoyAxis(AXISMOVE, ssplayer);
|
||||
if (InputDown(gc_accelerate, ssplayer) || (usejoystick && axis > 0))
|
||||
@@ -1082,54 +1095,7 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
|
||||
else
|
||||
rd = false;
|
||||
|
||||
// spectator aiming shit, ahhhh...
|
||||
{
|
||||
INT32 player_invert = invertmouse ? -1 : 1;
|
||||
INT32 screen_invert =
|
||||
(player->mo && (player->mo->eflags & MFE_VERTICALFLIP)
|
||||
&& (!thiscam->chase || player->pflags & PF_FLIPCAM)) //because chasecam's not inverted
|
||||
? -1 : 1; // set to -1 or 1 to multiply
|
||||
|
||||
// mouse look stuff (mouse look is not the same as mouse aim)
|
||||
if (mouseaiming && player->spectator)
|
||||
{
|
||||
kbl = false;
|
||||
|
||||
// looking up/down
|
||||
laim += (mlooky<<19)*player_invert*screen_invert;
|
||||
}
|
||||
|
||||
axis = JoyAxis(AXISLOOK, ssplayer);
|
||||
if (analogjoystickmove && axis != 0 && lookaxis && player->spectator)
|
||||
laim += (axis<<16) * screen_invert;
|
||||
|
||||
// spring back if not using keyboard neither mouselookin'
|
||||
if (!kbl && !lookaxis && !mouseaiming)
|
||||
laim = 0;
|
||||
|
||||
if (player->spectator)
|
||||
{
|
||||
if (InputDown(gc_lookup, ssplayer) || (gamepadjoystickmove && axis < 0))
|
||||
{
|
||||
laim += KB_LOOKSPEED * screen_invert;
|
||||
kbl = true;
|
||||
}
|
||||
else if (InputDown(gc_lookdown, ssplayer) || (gamepadjoystickmove && axis > 0))
|
||||
{
|
||||
laim -= KB_LOOKSPEED * screen_invert;
|
||||
kbl = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (InputDown(gc_centerview, ssplayer)) // No need to put a spectator limit on this one though :V
|
||||
laim = 0;
|
||||
|
||||
// accept no mlook for network games
|
||||
if (!cv_allowmlook.value)
|
||||
laim = 0;
|
||||
|
||||
cmd->aiming = G_ClipAimingPitch(&laim);
|
||||
}
|
||||
cmd->aiming = G_ClipAimingPitch(&laim);
|
||||
|
||||
mousex = mousey = mlooky = 0;
|
||||
|
||||
@@ -1181,7 +1147,6 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
|
||||
{
|
||||
localangle[forplayer] = lang;
|
||||
localaiming[forplayer] = laim;
|
||||
keyboard_look[forplayer] = kbl;
|
||||
turnheld[forplayer] = th;
|
||||
resetdown[forplayer] = rd;
|
||||
axis = JoyAxis(AXISLOOKBACK, ssplayer);
|
||||
@@ -1202,8 +1167,8 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
|
||||
LUA_HookTiccmd(player, cmd, HOOK(PlayerCmd));
|
||||
|
||||
//Reset away view if a command is given.
|
||||
if ((cmd->forwardmove || cmd->sidemove || cmd->buttons)
|
||||
&& displayplayers[0] != consoleplayer && ssplayer == 1)
|
||||
if (displayplayers[0] != consoleplayer && ssplayer == 1
|
||||
&& (cmd->forwardmove || cmd->sidemove || cmd->buttons))
|
||||
{
|
||||
displayplayers[0] = consoleplayer;
|
||||
G_FixCamera(1);
|
||||
@@ -1219,7 +1184,7 @@ static void G_DoLoadLevel(boolean resetplayer)
|
||||
|
||||
// Saturn Music Feature stuffs
|
||||
S_ResetKeepAndSpecialMus();
|
||||
S_CheckMap();
|
||||
S_KeepMusic();
|
||||
|
||||
// Make sure objectplace is OFF when you first start the level!
|
||||
OP_ResetObjectplace();
|
||||
@@ -1282,17 +1247,18 @@ static void G_DoLoadLevel(boolean resetplayer)
|
||||
joy4xmove[i] = joy4ymove[i] = 0;
|
||||
}
|
||||
mousex = mousey = 0;
|
||||
mouse2x = mouse2y = 0;
|
||||
|
||||
// clear hud messages remains (usually from game startup)
|
||||
CON_ClearHUD();
|
||||
|
||||
server_lagless = cv_lagless.value;
|
||||
|
||||
G_ResetAllDeviceRumbles();
|
||||
}
|
||||
|
||||
static INT32 pausedelay = 0;
|
||||
static INT32 camtoggledelay, camtoggledelay2, camtoggledelay3, camtoggledelay4 = 0;
|
||||
static INT32 spectatedelay, spectatedelay2, spectatedelay3, spectatedelay4 = 0;
|
||||
static INT32 camtoggledelay[MAXSPLITSCREENPLAYERS] = {0,0,0,0};
|
||||
static INT32 spectatedelay[MAXSPLITSCREENPLAYERS] = {0,0,0,0};
|
||||
|
||||
//
|
||||
// G_Responder
|
||||
@@ -1395,7 +1361,7 @@ boolean G_Responder(event_t *ev)
|
||||
}
|
||||
}
|
||||
|
||||
if (gamestate == GS_LEVEL && ev->type == ev_keydown && multiplayer && demo.playback && !demo.freecam)
|
||||
if (gamestate == GS_LEVEL && ev->type == ev_keydown && multiplayer && demo.playback)
|
||||
{
|
||||
if (ev->data1 == gamecontrolbis[gc_viewpoint][0] || ev->data1 == gamecontrolbis[gc_viewpoint][1])
|
||||
{
|
||||
@@ -1473,72 +1439,72 @@ boolean G_Responder(event_t *ev)
|
||||
if (ev->data1 == gamecontrol[gc_camtoggle][0]
|
||||
|| ev->data1 == gamecontrol[gc_camtoggle][1])
|
||||
{
|
||||
if (!camtoggledelay)
|
||||
if (!camtoggledelay[0])
|
||||
{
|
||||
camtoggledelay = NEWTICRATE / 7;
|
||||
camtoggledelay[0] = NEWTICRATE / 7;
|
||||
CV_SetValue(&cv_chasecam[0], cv_chasecam[0].value ? 0 : 1);
|
||||
}
|
||||
}
|
||||
if (ev->data1 == gamecontrolbis[gc_camtoggle][0]
|
||||
|| ev->data1 == gamecontrolbis[gc_camtoggle][1])
|
||||
{
|
||||
if (!camtoggledelay2)
|
||||
if (!camtoggledelay[1])
|
||||
{
|
||||
camtoggledelay2 = NEWTICRATE / 7;
|
||||
camtoggledelay[1] = NEWTICRATE / 7;
|
||||
CV_SetValue(&cv_chasecam[1], cv_chasecam[1].value ? 0 : 1);
|
||||
}
|
||||
}
|
||||
if (ev->data1 == gamecontrol3[gc_camtoggle][0]
|
||||
|| ev->data1 == gamecontrol3[gc_camtoggle][1])
|
||||
{
|
||||
if (!camtoggledelay3)
|
||||
if (!camtoggledelay[2])
|
||||
{
|
||||
camtoggledelay3 = NEWTICRATE / 7;
|
||||
camtoggledelay[2] = NEWTICRATE / 7;
|
||||
CV_SetValue(&cv_chasecam[2], cv_chasecam[2].value ? 0 : 1);
|
||||
}
|
||||
}
|
||||
if (ev->data1 == gamecontrol4[gc_camtoggle][0]
|
||||
|| ev->data1 == gamecontrol4[gc_camtoggle][1])
|
||||
{
|
||||
if (!camtoggledelay4)
|
||||
if (!camtoggledelay[3])
|
||||
{
|
||||
camtoggledelay4 = NEWTICRATE / 7;
|
||||
camtoggledelay[3] = NEWTICRATE / 7;
|
||||
CV_SetValue(&cv_chasecam[3], cv_chasecam[3].value ? 0 : 1);
|
||||
}
|
||||
}
|
||||
if (ev->data1 == gamecontrol[gc_spectate][0]
|
||||
|| ev->data1 == gamecontrol[gc_spectate][1])
|
||||
{
|
||||
if (!spectatedelay)
|
||||
if (!spectatedelay[0])
|
||||
{
|
||||
spectatedelay = NEWTICRATE / 7;
|
||||
spectatedelay[0] = NEWTICRATE / 7;
|
||||
COM_ImmedExecute("changeteam spectator");
|
||||
}
|
||||
}
|
||||
if (ev->data1 == gamecontrolbis[gc_spectate][0]
|
||||
|| ev->data1 == gamecontrolbis[gc_spectate][1])
|
||||
{
|
||||
if (!spectatedelay2)
|
||||
if (!spectatedelay[1])
|
||||
{
|
||||
spectatedelay2 = NEWTICRATE / 7;
|
||||
spectatedelay[1] = NEWTICRATE / 7;
|
||||
COM_ImmedExecute("changeteam2 spectator");
|
||||
}
|
||||
}
|
||||
if (ev->data1 == gamecontrol3[gc_spectate][0]
|
||||
|| ev->data1 == gamecontrol3[gc_spectate][1])
|
||||
{
|
||||
if (!spectatedelay3)
|
||||
if (!spectatedelay[2])
|
||||
{
|
||||
spectatedelay3 = NEWTICRATE / 7;
|
||||
spectatedelay[2] = NEWTICRATE / 7;
|
||||
COM_ImmedExecute("changeteam3 spectator");
|
||||
}
|
||||
}
|
||||
if (ev->data1 == gamecontrol4[gc_spectate][0]
|
||||
|| ev->data1 == gamecontrol4[gc_spectate][1])
|
||||
{
|
||||
if (!spectatedelay4)
|
||||
if (!spectatedelay[3])
|
||||
{
|
||||
spectatedelay4 = NEWTICRATE / 7;
|
||||
spectatedelay[3] = NEWTICRATE / 7;
|
||||
COM_ImmedExecute("changeteam4 spectator");
|
||||
}
|
||||
}
|
||||
@@ -1548,6 +1514,23 @@ boolean G_Responder(event_t *ev)
|
||||
K_ToggleDirector();
|
||||
}
|
||||
|
||||
if (ev->data1 == gamecontrol[gc_freecam][0] || ev->data1 == gamecontrol[gc_freecam][1])
|
||||
{
|
||||
P_ToggleDemoCamera(0);
|
||||
}
|
||||
else if (ev->data1 == gamecontrolbis[gc_freecam][0] || ev->data1 == gamecontrolbis[gc_freecam][1])
|
||||
{
|
||||
P_ToggleDemoCamera(1);
|
||||
}
|
||||
else if (ev->data1 == gamecontrol3[gc_freecam][0] || ev->data1 == gamecontrol3[gc_freecam][1])
|
||||
{
|
||||
P_ToggleDemoCamera(2);
|
||||
}
|
||||
else if (ev->data1 == gamecontrol4[gc_freecam][0] || ev->data1 == gamecontrol4[gc_freecam][1])
|
||||
{
|
||||
P_ToggleDemoCamera(3);
|
||||
}
|
||||
|
||||
return true;
|
||||
|
||||
case ev_keyup:
|
||||
@@ -1682,13 +1665,14 @@ INT32 G_CountPlayersPotentiallyViewable(boolean active)
|
||||
// Reset camera position, angle and interpolation on a view
|
||||
// after changing state.
|
||||
//
|
||||
static void G_FixCamera(UINT8 view)
|
||||
void G_FixCamera(UINT8 view)
|
||||
{
|
||||
player_t *player = &players[displayplayers[view - 1]];
|
||||
|
||||
// The order of displayplayers can change, which would
|
||||
// invalidate localangle.
|
||||
localangle[view - 1] = (angle_t)(player->cmd.angleturn << 16);
|
||||
if (!P_MobjWasRemoved(player->mo))
|
||||
localangle[view - 1] = player->mo->angle;
|
||||
|
||||
P_ResetCamera(player, &camera[view - 1]);
|
||||
|
||||
@@ -1728,13 +1712,6 @@ void G_ResetView(UINT8 viewnum, INT32 playernum, boolean onlyactive)
|
||||
viewnum = playersviewable;
|
||||
splitscreen = viewnum-1;
|
||||
|
||||
/* Prepare extra views for G_FindView to pass. */
|
||||
for (viewd = splits+1; viewd < viewnum; ++viewd)
|
||||
{
|
||||
displayplayerp = (&displayplayers[viewd-1]);
|
||||
(*displayplayerp) = INT32_MAX;
|
||||
}
|
||||
|
||||
R_ExecuteSetViewSize();
|
||||
}
|
||||
|
||||
@@ -1752,10 +1729,17 @@ void G_ResetView(UINT8 viewnum, INT32 playernum, boolean onlyactive)
|
||||
(*displayplayerp) = playernumd;
|
||||
|
||||
/* If a viewpoint changes, reset the camera to clear uninitialized memory. */
|
||||
G_FixCamera(viewd);
|
||||
if (viewnum > splits)
|
||||
{
|
||||
G_FixCamera(viewd);
|
||||
}
|
||||
else if ((*displayplayerp) != olddisplayplayer)
|
||||
{
|
||||
G_FixCamera(viewnum);
|
||||
}
|
||||
}
|
||||
|
||||
if (viewnum == 1 && demo.playback)
|
||||
if (demo.playback && viewnum == 1)
|
||||
consoleplayer = displayplayers[0];
|
||||
}
|
||||
|
||||
@@ -1769,6 +1753,10 @@ void G_AdjustView(UINT8 viewnum, INT32 offset, boolean onlyactive)
|
||||
INT32 *displayplayerp, oldview;
|
||||
displayplayerp = &displayplayers[viewnum-1];
|
||||
oldview = (*displayplayerp);
|
||||
|
||||
// turn off the freecam
|
||||
camera[viewnum-1].freecam = false;
|
||||
|
||||
G_ResetView(viewnum, ( (*displayplayerp) + offset ), onlyactive);
|
||||
|
||||
// If no other view could be found, go back to what we had.
|
||||
@@ -1975,23 +1963,14 @@ void G_Ticker(boolean run)
|
||||
if (pausedelay)
|
||||
pausedelay--;
|
||||
|
||||
if (camtoggledelay)
|
||||
camtoggledelay--;
|
||||
if (camtoggledelay2)
|
||||
camtoggledelay2--;
|
||||
if (camtoggledelay3)
|
||||
camtoggledelay3--;
|
||||
if (camtoggledelay4)
|
||||
camtoggledelay4--;
|
||||
for (UINT8 j = 0; j < MAXSPLITSCREENPLAYERS;j++)
|
||||
{
|
||||
if (camtoggledelay[j])
|
||||
camtoggledelay[j]--;
|
||||
|
||||
if (spectatedelay)
|
||||
spectatedelay--;
|
||||
if (spectatedelay2)
|
||||
spectatedelay2--;
|
||||
if (spectatedelay3)
|
||||
spectatedelay3--;
|
||||
if (spectatedelay4)
|
||||
spectatedelay4--;
|
||||
if (spectatedelay[j])
|
||||
spectatedelay[j]--;
|
||||
}
|
||||
|
||||
if (gametic % NAMECHANGERATE == 0)
|
||||
{
|
||||
@@ -2288,13 +2267,9 @@ void G_PlayerReborn(INT32 player)
|
||||
|
||||
if (p-players == consoleplayer)
|
||||
{
|
||||
if (mapmusflags & MUSIC_RELOADRESET)
|
||||
if (mapmusic.flags & MUSIC_RELOADRESET)
|
||||
{
|
||||
strncpy(mapmusname, mapheaderinfo[gamemap-1]->musname, 7);
|
||||
mapmusname[6] = 0;
|
||||
mapmusflags = (mapheaderinfo[gamemap-1]->mustrack & MUSIC_TRACKMASK);
|
||||
mapmusposition = mapheaderinfo[gamemap-1]->muspos;
|
||||
mapmusresume = 0;
|
||||
S_HandleReloadResetMusic();
|
||||
songcredit = true;
|
||||
}
|
||||
}
|
||||
@@ -4052,7 +4027,7 @@ void G_InitNew(UINT8 pencoremode, const char *mapname, boolean resetplayer, bool
|
||||
globalweather = mapheaderinfo[gamemap-1]->weather;
|
||||
|
||||
// Don't carry over custom music change to another map.
|
||||
mapmusflags |= MUSIC_RELOADRESET;
|
||||
mapmusic.flags |= MUSIC_RELOADRESET;
|
||||
|
||||
automapactive = false;
|
||||
imcontinuing = false;
|
||||
@@ -4532,7 +4507,7 @@ void G_ReadDemoExtraData(void)
|
||||
if (extradata & DXD_RESPAWN)
|
||||
{
|
||||
if (players[p].mo)
|
||||
P_DamageMobj(players[p].mo, NULL, NULL, 10000); // Is this how this should work..?
|
||||
P_DamageMobj(players[p].mo, NULL, NULL, DMG_INSTAKILL); // Is this how this should work..?
|
||||
}
|
||||
if (extradata & DXD_SKIN)
|
||||
{
|
||||
@@ -4598,7 +4573,7 @@ void G_ReadDemoExtraData(void)
|
||||
{
|
||||
players[p].spectator = true;
|
||||
if (players[p].mo)
|
||||
P_DamageMobj(players[p].mo, NULL, NULL, 10000);
|
||||
P_DamageMobj(players[p].mo, NULL, NULL, DMG_INSTAKILL);
|
||||
else
|
||||
players[p].playerstate = PST_REBORN;
|
||||
}
|
||||
@@ -4625,18 +4600,23 @@ void G_ReadDemoExtraData(void)
|
||||
while (p != DW_END)
|
||||
{
|
||||
UINT32 rng;
|
||||
UINT32 checkrng;
|
||||
|
||||
switch (p)
|
||||
{
|
||||
case DW_RNG:
|
||||
rng = READUINT32(demobuf.p);
|
||||
if (P_GetRandSeed() != rng)
|
||||
checkrng = P_GetRandSeed();
|
||||
if (checkrng != rng)
|
||||
{
|
||||
P_SetRandSeed(rng);
|
||||
|
||||
if (demosynced)
|
||||
CONS_Alert(CONS_WARNING, M_GetText("Demo playback has desynced!\n"));
|
||||
{
|
||||
CONS_Alert(CONS_WARNING, M_GetText("Demo playback has desynced (RNG)!\n"));
|
||||
CONS_Printf("expected rng %d got %d\n", rng, checkrng);
|
||||
}
|
||||
demosynced = false;
|
||||
|
||||
P_SetRandSeed(rng);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4902,7 +4882,7 @@ void G_GhostAddHit(INT32 playernum, mobj_t *victim)
|
||||
ghostext[playernum].flags |= EZT_HIT;
|
||||
ghostext[playernum].hits++;
|
||||
ghostext[playernum].hitlist = Z_Realloc(ghostext[playernum].hitlist, ghostext[playernum].hits * sizeof(mobj_t *), PU_LEVEL, NULL);
|
||||
ghostext[playernum].hitlist[ghostext[playernum].hits-1] = victim;
|
||||
P_SetTarget(ghostext[playernum].hitlist + (ghostext[playernum].hits-1), victim);
|
||||
}
|
||||
|
||||
void G_WriteAllGhostTics(void)
|
||||
@@ -4913,6 +4893,7 @@ void G_WriteAllGhostTics(void)
|
||||
UINT8 *save_demo_p = demobuf.p;
|
||||
#define CHECKSPACE(num) if (demobuf.p+(num) > demoend) { demobuf.p = save_demo_p; G_CheckDemoStatus(); return; }
|
||||
|
||||
boolean toobig = false;
|
||||
INT32 i, counter = leveltime;
|
||||
|
||||
for (i = 0; i < MAXPLAYERS; i++)
|
||||
@@ -4925,18 +4906,32 @@ void G_WriteAllGhostTics(void)
|
||||
|
||||
counter++;
|
||||
|
||||
if (counter % cv_netdemosyncquality.value != 0) // Only write 1 in this many ghost datas per tic to cut down on multiplayer replay size.
|
||||
if (multiplayer && ((counter % cv_netdemosyncquality.value) != 0)) // Only write 1 in this many ghost datas per tic to cut down on multiplayer replay size.
|
||||
continue;
|
||||
|
||||
CHECKSPACE(1);
|
||||
|
||||
WRITEUINT8(demobuf.p, i);
|
||||
G_WriteGhostTic(players[i].mo, i);
|
||||
|
||||
// attention here for the ticcmd size!
|
||||
// latest demos with mouse aiming byte in ticcmd
|
||||
if (demobuf.p >= demoend - (13 + 9 + 9))
|
||||
{
|
||||
toobig = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
CHECKSPACE(1);
|
||||
WRITEUINT8(demobuf.p, 0xFF);
|
||||
|
||||
if (toobig)
|
||||
{
|
||||
G_CheckDemoStatus(); // no more space
|
||||
return;
|
||||
}
|
||||
|
||||
#undef CHECKSPACE
|
||||
}
|
||||
|
||||
@@ -5111,6 +5106,7 @@ void G_WriteGhostTic(mobj_t *ghost, INT32 playernum)
|
||||
WRITEFIXED(demobuf.p,mo->y);
|
||||
WRITEFIXED(demobuf.p,mo->z);
|
||||
WRITEANGLE(demobuf.p,mo->angle);
|
||||
P_SetTarget(ghostext[playernum].hitlist+i, NULL);
|
||||
}
|
||||
Z_Free(ghostext[playernum].hitlist);
|
||||
ghostext[playernum].hits = 0;
|
||||
@@ -5133,23 +5129,17 @@ void G_WriteGhostTic(mobj_t *ghost, INT32 playernum)
|
||||
}
|
||||
|
||||
*ziptic_p = ziptic;
|
||||
|
||||
// attention here for the ticcmd size!
|
||||
// latest demos with mouse aiming byte in ticcmd
|
||||
if (demobuf.p >= demoend - (13 + 9))
|
||||
{
|
||||
G_CheckDemoStatus(); // no more space
|
||||
return;
|
||||
}
|
||||
#undef CHECKSPACE
|
||||
}
|
||||
|
||||
void G_ConsAllGhostTics(void)
|
||||
{
|
||||
if (!demobuf.p)
|
||||
UINT8 p;
|
||||
|
||||
if (!demobuf.p || !demo.deferstart)
|
||||
return;
|
||||
|
||||
UINT8 p = READUINT8(demobuf.p);
|
||||
p = READUINT8(demobuf.p);
|
||||
|
||||
while (p != 0xFF)
|
||||
{
|
||||
@@ -5175,8 +5165,6 @@ void G_ConsGhostTic(INT32 playernum)
|
||||
fixed_t syncleeway;
|
||||
boolean nightsfail = false;
|
||||
|
||||
if (!demobuf.p || !demo.deferstart)
|
||||
return;
|
||||
if (!(demoflags & DF_GHOST))
|
||||
return; // No ghost data to use.
|
||||
|
||||
@@ -5259,7 +5247,10 @@ void G_ConsGhostTic(INT32 playernum)
|
||||
if (mobj && mobj->health != health) // Wasn't damaged?! This is desync! Fix it!
|
||||
{
|
||||
if (demosynced)
|
||||
CONS_Alert(CONS_WARNING, M_GetText("Demo playback has desynced!\n"));
|
||||
{
|
||||
CONS_Alert(CONS_WARNING, M_GetText("Demo playback has desynced (health)!\n"));
|
||||
CONS_Printf("expected health %d got %d\n", health, mobj->health);
|
||||
}
|
||||
demosynced = false;
|
||||
P_DamageMobj(mobj, players[0].mo, players[0].mo, 1);
|
||||
}
|
||||
@@ -5292,7 +5283,7 @@ void G_ConsGhostTic(INT32 playernum)
|
||||
if (ghostext[playernum].desyncframes >= 2)
|
||||
{
|
||||
if (demosynced)
|
||||
CONS_Alert(CONS_WARNING, M_GetText("Demo playback has desynced!\n"));
|
||||
CONS_Alert(CONS_WARNING, "Demo playback has desynced (player %s)!\n", player_names[playernum]);
|
||||
demosynced = false;
|
||||
|
||||
P_UnsetThingPosition(testmo);
|
||||
@@ -5322,7 +5313,11 @@ void G_ConsGhostTic(INT32 playernum)
|
||||
)
|
||||
{
|
||||
if (demosynced)
|
||||
CONS_Alert(CONS_WARNING, M_GetText("Demo playback has desynced!\n"));
|
||||
{
|
||||
CONS_Alert(CONS_WARNING, "Demo playback has desynced (item/bumpers)!(player %s)!\n", player_names[playernum]);
|
||||
CONS_Printf("expected item type %d got %d\n", ghostext[playernum].kartitem, players[playernum].kartstuff[k_itemtype]);
|
||||
CONS_Printf("expected item amount %d got %d\n", ghostext[playernum].kartamount, players[playernum].kartstuff[k_itemamount]);
|
||||
}
|
||||
demosynced = false;
|
||||
|
||||
players[playernum].kartstuff[k_itemtype] = ghostext[playernum].kartitem;
|
||||
@@ -5769,9 +5764,6 @@ void G_ConfirmRewind(tic_t rewindtime)
|
||||
|
||||
COM_BufInsertText("renderview on\n");
|
||||
|
||||
if (demo.freecam)
|
||||
return; // don't touch from there
|
||||
|
||||
splitscreen = oldss;
|
||||
displayplayers[0] = olddp1;
|
||||
displayplayers[1] = olddp2;
|
||||
@@ -6014,7 +6006,7 @@ void G_RecordDemo(const char *name)
|
||||
|
||||
maxsize = cv_maxdemosize.value*1024*1024;
|
||||
|
||||
demobuf.buffer = Z_Malloc(maxsize, PU_STATIC, NULL);
|
||||
demobuf.buffer = Z_Malloc(maxsize + 100*1024, PU_STATIC, NULL);
|
||||
demoend = demobuf.buffer + maxsize;
|
||||
|
||||
if (demobuf.buffer)
|
||||
@@ -6032,7 +6024,7 @@ void G_RecordMetal(void)
|
||||
Z_Free(demobuf.buffer);
|
||||
demobuf.p = NULL;
|
||||
metalrecording = false;
|
||||
demobuf.buffer = Z_Malloc(maxsize, PU_STATIC, NULL);
|
||||
demobuf.buffer = Z_Malloc(maxsize + 100*1024, PU_STATIC, NULL);
|
||||
demoend = demobuf.buffer + maxsize;
|
||||
|
||||
if (demobuf.buffer)
|
||||
@@ -7186,15 +7178,14 @@ void G_DoPlayDemo(char *defdemoname)
|
||||
|
||||
//LUA_HookInt(gamemap, HOOK(MapChange));
|
||||
|
||||
displayplayers[0] = consoleplayer = 0;
|
||||
consoleplayer = 0;
|
||||
memset(playeringame,0,sizeof(playeringame));
|
||||
memset(displayplayers,0,sizeof(displayplayers));
|
||||
memset(camera,0,sizeof(camera)); // reset freecam
|
||||
|
||||
// Load players that were in-game when the map started
|
||||
p = READUINT8(demobuf.p);
|
||||
|
||||
for (i = 1; i < MAXSPLITSCREENPLAYERS; i++)
|
||||
displayplayers[i] = INT32_MAX;
|
||||
|
||||
while (p != 0xFF)
|
||||
{
|
||||
spectator = false;
|
||||
@@ -7310,8 +7301,8 @@ post_compat:
|
||||
players[i].kartweight = kartweight[i];
|
||||
}
|
||||
|
||||
directorstate = cv_director.value;
|
||||
CV_SetValue(&cv_director, 0);
|
||||
if (cv_director.value)
|
||||
CV_SetValue(&cv_director, 0);
|
||||
|
||||
demo.deferstart = true;
|
||||
}
|
||||
@@ -7836,7 +7827,6 @@ void G_DoneLevelLoad(void)
|
||||
// Stops metal sonic's demo. Separate from other functions because metal + replays can coexist
|
||||
void G_StopMetalDemo(void)
|
||||
{
|
||||
|
||||
// Metal Sonic finishing doesn't end the game, dammit.
|
||||
Z_Free(metalbuffer);
|
||||
metalbuffer = NULL;
|
||||
@@ -7876,11 +7866,6 @@ void G_StopDemo(void)
|
||||
{
|
||||
Z_Free(demobuf.buffer);
|
||||
demobuf.buffer = NULL;
|
||||
if (demo.playback)
|
||||
{
|
||||
CV_SetValue(&cv_director, directorstate);
|
||||
directorstate = 0;
|
||||
}
|
||||
demo.playback = false;
|
||||
if (demo.title)
|
||||
modeattacking = false;
|
||||
@@ -7888,14 +7873,13 @@ void G_StopDemo(void)
|
||||
demo.timing = false;
|
||||
singletics = false;
|
||||
|
||||
demo.freecam = false;
|
||||
// reset democam shit too:
|
||||
democam.cam = NULL;
|
||||
democam.soundmobj = NULL;
|
||||
democam.localangle = 0;
|
||||
democam.localaiming = 0;
|
||||
democam.turnheld = false;
|
||||
democam.keyboardlook = false;
|
||||
UINT8 i;
|
||||
for (i = 0; i < MAXSPLITSCREENPLAYERS; ++i)
|
||||
{
|
||||
camera[i].freecam = false;
|
||||
camera[i].localangle = 0;
|
||||
camera[i].localaiming = 0;
|
||||
}
|
||||
|
||||
CV_SetValue(&cv_playbackspeed, 1);
|
||||
demo.rewinding = false;
|
||||
@@ -8177,32 +8161,3 @@ boolean G_GetRetryFlag(void)
|
||||
{
|
||||
return retrying;
|
||||
}
|
||||
|
||||
// Time utility functions
|
||||
INT32 G_TicsToHours(tic_t tics)
|
||||
{
|
||||
return tics/(3600*TICRATE);
|
||||
}
|
||||
|
||||
INT32 G_TicsToMinutes(tic_t tics, boolean full)
|
||||
{
|
||||
if (full)
|
||||
return tics/(60*TICRATE);
|
||||
else
|
||||
return tics/(60*TICRATE)%60;
|
||||
}
|
||||
|
||||
INT32 G_TicsToSeconds(tic_t tics)
|
||||
{
|
||||
return (tics/TICRATE)%60;
|
||||
}
|
||||
|
||||
INT32 G_TicsToCentiseconds(tic_t tics)
|
||||
{
|
||||
return (INT32)((tics%TICRATE) * (100.00f/TICRATE));
|
||||
}
|
||||
|
||||
INT32 G_TicsToMilliseconds(tic_t tics)
|
||||
{
|
||||
return (INT32)((tics%TICRATE) * (1000.00f/TICRATE));
|
||||
}
|
||||
+46
-24
@@ -66,9 +66,6 @@ struct demovars_s {
|
||||
DSM_WILLSAVE,
|
||||
DSM_SAVED
|
||||
} savemode;
|
||||
|
||||
boolean freecam;
|
||||
|
||||
};
|
||||
|
||||
extern struct demovars_s demo;
|
||||
@@ -118,12 +115,12 @@ extern consvar_t cv_songcredits;
|
||||
extern consvar_t cv_showfreeplay;
|
||||
extern consvar_t cv_growmusic, cv_supermusic;
|
||||
extern consvar_t cv_pauseifunfocused;
|
||||
//extern consvar_t cv_crosshair, cv_crosshair2, cv_crosshair3, cv_crosshair4;
|
||||
extern consvar_t cv_invertmouse/*, cv_alwaysfreelook, cv_chasefreelook, cv_mousemove*/;
|
||||
extern consvar_t cv_invertmouse2/*, cv_alwaysfreelook2, cv_chasefreelook2, cv_mousemove2*/;
|
||||
extern consvar_t cv_invertmouse;
|
||||
|
||||
extern consvar_t cv_turnaxis[MAXSPLITSCREENPLAYERS];
|
||||
extern consvar_t cv_moveaxis[MAXSPLITSCREENPLAYERS];
|
||||
extern consvar_t cv_camturnaxis[MAXSPLITSCREENPLAYERS];
|
||||
extern consvar_t cv_camstrafeaxis[MAXSPLITSCREENPLAYERS];
|
||||
extern consvar_t cv_brakeaxis[MAXSPLITSCREENPLAYERS];
|
||||
extern consvar_t cv_aimaxis[MAXSPLITSCREENPLAYERS];
|
||||
extern consvar_t cv_lookaxis[MAXSPLITSCREENPLAYERS];
|
||||
@@ -149,18 +146,19 @@ extern consvar_t cv_##name##_yoffset;
|
||||
DECL_HUD_OFFSET_X(name)\
|
||||
DECL_HUD_OFFSET_Y(name)
|
||||
|
||||
DECL_HUD_OFFSET(item); // Item box
|
||||
DECL_HUD_OFFSET(time); // Time
|
||||
DECL_HUD_OFFSET(laps); // Number of laps
|
||||
DECL_HUD_OFFSET(dnft); // Countdown (did not finish timer)
|
||||
DECL_HUD_OFFSET(speed); // Speedometer
|
||||
DECL_HUD_OFFSET(posi); // Position in race
|
||||
DECL_HUD_OFFSET(face); // Mini rankings
|
||||
DECL_HUD_OFFSET(stcd); // Starting countdown
|
||||
DECL_HUD_OFFSET(item); // Item box
|
||||
DECL_HUD_OFFSET(time); // Time
|
||||
DECL_HUD_OFFSET(laps); // Number of laps
|
||||
DECL_HUD_OFFSET(dnft); // Countdown (did not finish timer)
|
||||
DECL_HUD_OFFSET(speed); // Speedometer
|
||||
DECL_HUD_OFFSET(posi); // Position in race
|
||||
DECL_HUD_OFFSET(wheel); // RA Wheel
|
||||
DECL_HUD_OFFSET(face); // Mini rankings
|
||||
DECL_HUD_OFFSET(stcd); // Starting countdown
|
||||
DECL_HUD_OFFSET_Y(chek); // Check gfx
|
||||
DECL_HUD_OFFSET(mini); // Minimap
|
||||
DECL_HUD_OFFSET(want); // Wanted
|
||||
DECL_HUD_OFFSET(stat); // Stats
|
||||
DECL_HUD_OFFSET(mini); // Minimap
|
||||
DECL_HUD_OFFSET(want); // Wanted
|
||||
DECL_HUD_OFFSET(stat); // Stats
|
||||
|
||||
#undef DECL_HUD_OFFSET
|
||||
#undef DECL_HUD_OFFSET_X
|
||||
@@ -182,6 +180,7 @@ extern consvar_t cv_sliptideroll;
|
||||
extern consvar_t cv_slamsound;
|
||||
extern consvar_t cv_sloperolldist;
|
||||
extern consvar_t cv_sparkroll;
|
||||
extern consvar_t cv_spinoutroll;
|
||||
|
||||
extern consvar_t cv_cechotoggle;
|
||||
|
||||
@@ -194,6 +193,8 @@ typedef enum
|
||||
AXISNONE = 0,
|
||||
AXISTURN,
|
||||
AXISMOVE,
|
||||
AXISCAMTURN,
|
||||
AXISCAMSTRAFE,
|
||||
AXISBRAKE,
|
||||
AXISAIM,
|
||||
AXISLOOK,
|
||||
@@ -231,8 +232,6 @@ extern angle_t localangle[MAXSPLITSCREENPLAYERS];
|
||||
extern INT32 localaiming[MAXSPLITSCREENPLAYERS]; // should be an angle_t but signed
|
||||
extern boolean camspin[MAXSPLITSCREENPLAYERS]; // SRB2Kart
|
||||
|
||||
extern tic_t directortoggletimer;
|
||||
|
||||
//
|
||||
// GAME
|
||||
//
|
||||
@@ -434,11 +433,32 @@ void G_ClearRecords(void);
|
||||
|
||||
tic_t G_GetBestTime(INT16 map);
|
||||
|
||||
FUNCMATH INT32 G_TicsToHours(tic_t tics);
|
||||
FUNCMATH INT32 G_TicsToMinutes(tic_t tics, boolean full);
|
||||
FUNCMATH INT32 G_TicsToSeconds(tic_t tics);
|
||||
FUNCMATH INT32 G_TicsToCentiseconds(tic_t tics);
|
||||
FUNCMATH INT32 G_TicsToMilliseconds(tic_t tics);
|
||||
// Time utility functions
|
||||
|
||||
FUNCINLINE static ATTRINLINE FUNCMATH INT32 G_TicsToHours(tic_t tics)
|
||||
{
|
||||
return tics/(3600*TICRATE);
|
||||
}
|
||||
|
||||
FUNCINLINE static ATTRINLINE FUNCMATH INT32 G_TicsToMinutes(tic_t tics, boolean full)
|
||||
{
|
||||
return full ? (tics/(60*TICRATE)) : (tics/(60*TICRATE)%60);
|
||||
}
|
||||
|
||||
FUNCINLINE static ATTRINLINE FUNCMATH INT32 G_TicsToSeconds(tic_t tics)
|
||||
{
|
||||
return (tics/TICRATE)%60;
|
||||
}
|
||||
|
||||
FUNCINLINE static ATTRINLINE FUNCMATH INT32 G_TicsToCentiseconds(tic_t tics)
|
||||
{
|
||||
return (INT32)((tics%TICRATE) * (100.00f/TICRATE));
|
||||
}
|
||||
|
||||
FUNCINLINE static ATTRINLINE FUNCMATH INT32 G_TicsToMilliseconds(tic_t tics)
|
||||
{
|
||||
return (INT32)((tics%TICRATE) * (1000.00f/TICRATE));
|
||||
}
|
||||
|
||||
// Don't split up TOL handling
|
||||
INT16 G_TOLFlag(INT32 pgametype);
|
||||
@@ -446,4 +466,6 @@ INT16 G_TOLFlag(INT32 pgametype);
|
||||
INT16 G_RandMap(INT16 tolflags, INT16 pprevmap, boolean ignorebuffer, UINT8 maphell, boolean callagainsoon, INT16 *extbuffer);
|
||||
void G_AddMapToBuffer(INT16 map);
|
||||
|
||||
void G_FixCamera(UINT8 view);
|
||||
|
||||
#endif
|
||||
+14
-79
@@ -33,9 +33,7 @@ static CV_PossibleValue_t turnsmooth_cons_t[] = {{2, "Slow"}, {1, "Fast"}, {0, "
|
||||
|
||||
// mouse values are used once
|
||||
consvar_t cv_mousesens = {"mousesens", "20", CV_SAVE, mousesens_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_mousesens2 = {"mousesens2", "20", CV_SAVE, mousesens_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_mouseysens = {"mouseysens", "20", CV_SAVE, mousesens_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_mouseysens2 = {"mouseysens2", "20", CV_SAVE, mousesens_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_controlperkey = {"controlperkey", "One", CV_SAVE, onecontrolperkey_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_turnsmooth = {"turnsmoothing", "Slow", CV_SAVE, turnsmooth_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
@@ -125,8 +123,6 @@ static void led_off_handle4(void)
|
||||
INT32 mousex, mousey;
|
||||
INT32 mlooky; // like mousey but with a custom sensitivity for mlook
|
||||
|
||||
INT32 mouse2x, mouse2y, mlook2y;
|
||||
|
||||
// joystick values are repeated
|
||||
INT32 joyxmove[JOYAXISSET], joyymove[JOYAXISSET], joy2xmove[JOYAXISSET], joy2ymove[JOYAXISSET],
|
||||
joy3xmove[JOYAXISSET], joy3ymove[JOYAXISSET], joy4xmove[JOYAXISSET], joy4ymove[JOYAXISSET];
|
||||
@@ -148,7 +144,6 @@ typedef struct
|
||||
} dclick_t;
|
||||
static dclick_t mousedclicks[MOUSEBUTTONS];
|
||||
static dclick_t joydclicks[JOYBUTTONS + JOYHATS*4];
|
||||
static dclick_t mouse2dclicks[MOUSEBUTTONS];
|
||||
static dclick_t joy2dclicks[JOYBUTTONS + JOYHATS*4];
|
||||
static dclick_t joy3dclicks[JOYBUTTONS + JOYHATS*4];
|
||||
static dclick_t joy4dclicks[JOYBUTTONS + JOYHATS*4];
|
||||
@@ -233,14 +228,6 @@ void G_MapEventsToControls(event_t *ev)
|
||||
if (ev->data3 != INT32_MAX) joy4ymove[i] = ev->data3;
|
||||
break;
|
||||
|
||||
case ev_mouse2: // buttons are virtual keys
|
||||
if (menuactive || CON_Ready() || chat_on)
|
||||
break;
|
||||
mouse2x = (INT32)(ev->data2*((cv_mousesens2.value*cv_mousesens2.value)/110.0f + 0.1f));
|
||||
mouse2y = (INT32)(ev->data3*((cv_mousesens2.value*cv_mousesens2.value)/110.0f + 0.1f));
|
||||
mlook2y = (INT32)(ev->data3*((cv_mouseysens2.value*cv_mousesens2.value)/110.0f + 0.1f));
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@@ -258,12 +245,6 @@ void G_MapEventsToControls(event_t *ev)
|
||||
gamekeydown[KEY_DBLJOY1+i] = flag;
|
||||
}
|
||||
|
||||
for (i = 0; i < MOUSEBUTTONS; i++)
|
||||
{
|
||||
flag = G_CheckDoubleClick(gamekeydown[KEY_2MOUSE1+i], &mouse2dclicks[i]);
|
||||
gamekeydown[KEY_DBL2MOUSE1+i] = flag;
|
||||
}
|
||||
|
||||
for (i = 0; i < JOYBUTTONS + JOYHATS*4; i++)
|
||||
{
|
||||
flag = G_CheckDoubleClick(gamekeydown[KEY_2JOY1+i], &joy2dclicks[i]);
|
||||
@@ -401,18 +382,8 @@ static keyname_t keynames[] =
|
||||
{KEY_MOUSE1+5,"MOUSE6"},
|
||||
{KEY_MOUSE1+6,"MOUSE7"},
|
||||
{KEY_MOUSE1+7,"MOUSE8"},
|
||||
{KEY_2MOUSE1+0,"SEC_MOUSE2"}, // BP: sorry my mouse handler swap button 1 and 2
|
||||
{KEY_2MOUSE1+1,"SEC_MOUSE1"},
|
||||
{KEY_2MOUSE1+2,"SEC_MOUSE3"},
|
||||
{KEY_2MOUSE1+3,"SEC_MOUSE4"},
|
||||
{KEY_2MOUSE1+4,"SEC_MOUSE5"},
|
||||
{KEY_2MOUSE1+5,"SEC_MOUSE6"},
|
||||
{KEY_2MOUSE1+6,"SEC_MOUSE7"},
|
||||
{KEY_2MOUSE1+7,"SEC_MOUSE8"},
|
||||
{KEY_MOUSEWHEELUP, "Wheel 1 UP"},
|
||||
{KEY_MOUSEWHEELDOWN, "Wheel 1 Down"},
|
||||
{KEY_2MOUSEWHEELUP, "Wheel 2 UP"},
|
||||
{KEY_2MOUSEWHEELDOWN, "Wheel 2 Down"},
|
||||
|
||||
{KEY_JOY1+0, "JOY1"},
|
||||
{KEY_JOY1+1, "JOY2"},
|
||||
@@ -423,7 +394,7 @@ static keyname_t keynames[] =
|
||||
{KEY_JOY1+6, "JOY7"},
|
||||
{KEY_JOY1+7, "JOY8"},
|
||||
{KEY_JOY1+8, "JOY9"},
|
||||
|
||||
|
||||
#if !defined (NOMOREJOYBTN_1S)
|
||||
// we use up to 32 buttons in DirectInput
|
||||
{KEY_JOY1+9, "JOY10"},
|
||||
@@ -476,14 +447,6 @@ static keyname_t keynames[] =
|
||||
{KEY_DBLMOUSE1+5, "DBLMOUSE6"},
|
||||
{KEY_DBLMOUSE1+6, "DBLMOUSE7"},
|
||||
{KEY_DBLMOUSE1+7, "DBLMOUSE8"},
|
||||
{KEY_DBL2MOUSE1+0, "DBLSEC_MOUSE2"}, // BP: sorry my mouse handler swap button 1 and 2
|
||||
{KEY_DBL2MOUSE1+1, "DBLSEC_MOUSE1"},
|
||||
{KEY_DBL2MOUSE1+2, "DBLSEC_MOUSE3"},
|
||||
{KEY_DBL2MOUSE1+3, "DBLSEC_MOUSE4"},
|
||||
{KEY_DBL2MOUSE1+4, "DBLSEC_MOUSE5"},
|
||||
{KEY_DBL2MOUSE1+5, "DBLSEC_MOUSE6"},
|
||||
{KEY_DBL2MOUSE1+6, "DBLSEC_MOUSE7"},
|
||||
{KEY_DBL2MOUSE1+7, "DBLSEC_MOUSE8"},
|
||||
|
||||
{KEY_DBLJOY1+0, "DBLJOY1"},
|
||||
{KEY_DBLJOY1+1, "DBLJOY2"},
|
||||
@@ -868,7 +831,6 @@ static keyname_t keynames[] =
|
||||
{KEY_DBL4HAT1+13, "DBLFOR_HATDOWN4"},
|
||||
{KEY_DBL4HAT1+14, "DBLFOR_HATLEFT4"},
|
||||
{KEY_DBL4HAT1+15, "DBLFOR_HATRIGHT4"},
|
||||
|
||||
};
|
||||
|
||||
static const char *gamecontrolname[num_gamecontrols] =
|
||||
@@ -902,6 +864,11 @@ static const char *gamecontrolname[num_gamecontrols] =
|
||||
"custom2",
|
||||
"custom3",
|
||||
"director",
|
||||
"freecam",
|
||||
"camfloat",
|
||||
"camsink",
|
||||
"strafeleft",
|
||||
"straferight",
|
||||
};
|
||||
|
||||
#define NUMKEYNAMES (sizeof (keynames)/sizeof (keyname_t))
|
||||
@@ -928,36 +895,27 @@ UINT16 G_GetSkinColor(INT32 playernum)
|
||||
{
|
||||
case 0:
|
||||
return cv_playercolor.value;
|
||||
break;
|
||||
case 1:
|
||||
return cv_playercolor2.value;
|
||||
break;
|
||||
case 2:
|
||||
return cv_playercolor3.value;
|
||||
break;
|
||||
case 3:
|
||||
return cv_playercolor4.value;
|
||||
break;
|
||||
default:
|
||||
return 0;
|
||||
break;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void G_SetPlayerGamepadIndicatorColor(INT32 playernum, UINT16 color)
|
||||
{
|
||||
INT32 device;
|
||||
UINT16 skincolor;
|
||||
byteColor_t byte_color;
|
||||
|
||||
I_Assert(playernum >= 0 && playernum < MAXSPLITSCREENPLAYERS);
|
||||
|
||||
if (cv_gamepadled[playernum].value == 0)
|
||||
return;
|
||||
|
||||
device = cv_usejoystick[playernum].value;
|
||||
|
||||
if (device <= 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
@@ -965,19 +923,14 @@ void G_SetPlayerGamepadIndicatorColor(INT32 playernum, UINT16 color)
|
||||
skincolor = color ? color : G_GetSkinColor(playernum);
|
||||
byte_color = V_GetColor(colortranslations[skincolor][8]).s;
|
||||
|
||||
I_SetGamepadIndicatorColor(device, byte_color.red, byte_color.green, byte_color.blue);
|
||||
I_SetGamepadIndicatorColor(playernum, byte_color.red, byte_color.green, byte_color.blue);
|
||||
}
|
||||
|
||||
static void G_ResetPlayerGamepadIndicatorColor(INT32 playernum)
|
||||
{
|
||||
if (cv_gamepadled[playernum].value == 0)
|
||||
{
|
||||
INT32 device = cv_usejoystick[playernum].value;
|
||||
|
||||
if (device <= 0)
|
||||
return;
|
||||
|
||||
I_SetGamepadIndicatorColor(device, 0, 0, 255);
|
||||
I_SetGamepadIndicatorColor(playernum, 0, 0, 255);
|
||||
}
|
||||
else
|
||||
G_SetPlayerGamepadIndicatorColor(playernum, 0);
|
||||
@@ -985,16 +938,7 @@ static void G_ResetPlayerGamepadIndicatorColor(INT32 playernum)
|
||||
|
||||
static void G_ResetPlayerDeviceRumble(INT32 playernum)
|
||||
{
|
||||
INT32 device_id;
|
||||
|
||||
device_id = cv_usejoystick[playernum].value;
|
||||
|
||||
if (device_id < 1)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
I_GamepadRumble(device_id, 0, 0, 0);
|
||||
I_GamepadRumble(playernum, 0, 0, 0);
|
||||
}
|
||||
|
||||
void G_ResetAllDeviceRumbles(void)
|
||||
@@ -1006,29 +950,20 @@ void G_ResetAllDeviceRumbles(void)
|
||||
|
||||
for (i = 0; i < devices; i++)
|
||||
{
|
||||
INT32 device_id = cv_usejoystick[i].value;
|
||||
|
||||
I_GamepadRumble(device_id, 0, 0, 0);
|
||||
I_GamepadRumble(devices, 0, 0, 0);
|
||||
}
|
||||
}
|
||||
|
||||
void G_PlayerDeviceRumble(INT32 playernum, UINT16 low_strength, UINT16 high_strength, UINT32 duration)
|
||||
{
|
||||
INT32 device_id;
|
||||
I_Assert(playernum >= 0 && playernum < MAXSPLITSCREENPLAYERS);
|
||||
|
||||
if (cv_rumble[playernum].value == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
device_id = cv_usejoystick[playernum].value;
|
||||
|
||||
if (device_id < 1)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
I_GamepadRumble(device_id, low_strength, high_strength, duration);
|
||||
I_GamepadRumble(playernum, low_strength, high_strength, duration);
|
||||
}
|
||||
|
||||
//
|
||||
|
||||
+8
-9
@@ -41,12 +41,10 @@ typedef enum
|
||||
KEY_DBLJOY1 = KEY_DBLMOUSE1 + MOUSEBUTTONS,
|
||||
KEY_DBLHAT1 = KEY_DBLJOY1 + JOYBUTTONS,
|
||||
|
||||
KEY_2MOUSE1 = KEY_DBLHAT1 + JOYHATS*4,
|
||||
KEY_2JOY1 = KEY_2MOUSE1 + MOUSEBUTTONS,
|
||||
KEY_2JOY1 = KEY_DBLHAT1 + MOUSEBUTTONS,
|
||||
KEY_2HAT1 = KEY_2JOY1 + JOYBUTTONS,
|
||||
|
||||
KEY_DBL2MOUSE1 = KEY_2HAT1 + JOYHATS*4,
|
||||
KEY_DBL2JOY1 = KEY_DBL2MOUSE1 + MOUSEBUTTONS,
|
||||
KEY_DBL2JOY1 = KEY_2HAT1 + MOUSEBUTTONS,
|
||||
KEY_DBL2HAT1 = KEY_DBL2JOY1 + JOYBUTTONS,
|
||||
|
||||
KEY_3JOY1 = KEY_DBL2HAT1 + JOYHATS*4,
|
||||
@@ -63,10 +61,8 @@ typedef enum
|
||||
|
||||
KEY_MOUSEWHEELUP = KEY_DBL4HAT1 + JOYHATS*4,
|
||||
KEY_MOUSEWHEELDOWN = KEY_MOUSEWHEELUP + 1,
|
||||
KEY_2MOUSEWHEELUP = KEY_MOUSEWHEELDOWN + 1,
|
||||
KEY_2MOUSEWHEELDOWN = KEY_2MOUSEWHEELUP + 1,
|
||||
|
||||
NUMINPUTS = KEY_2MOUSEWHEELDOWN + 1,
|
||||
NUMINPUTS = KEY_MOUSEWHEELDOWN + 1,
|
||||
} key_input_e;
|
||||
|
||||
typedef enum
|
||||
@@ -100,12 +96,16 @@ typedef enum
|
||||
gc_custom2, // Lua scriptable
|
||||
gc_custom3, // Lua scriptable
|
||||
gc_director,
|
||||
gc_freecam, // Toggle for freecam while ingame
|
||||
gc_camfloat, // alternative button for raising cam
|
||||
gc_camsink, // alternative button for sinking
|
||||
gc_strafeleft,
|
||||
gc_straferight,
|
||||
num_gamecontrols
|
||||
} gamecontrols_e;
|
||||
|
||||
// mouse values are used once
|
||||
extern consvar_t cv_mousesens, cv_mouseysens;
|
||||
extern consvar_t cv_mousesens2, cv_mouseysens2;
|
||||
extern consvar_t cv_controlperkey, cv_turnsmooth;
|
||||
extern consvar_t cv_rumble[MAXSPLITSCREENPLAYERS];
|
||||
extern consvar_t cv_gamepadled[MAXSPLITSCREENPLAYERS];
|
||||
@@ -113,7 +113,6 @@ extern consvar_t cv_ledpowerup[MAXSPLITSCREENPLAYERS];
|
||||
|
||||
extern INT32 mousex, mousey;
|
||||
extern INT32 mlooky; //mousey with mlookSensitivity
|
||||
extern INT32 mouse2x, mouse2y, mlook2y;
|
||||
|
||||
extern INT32 joyxmove[JOYAXISSET], joyymove[JOYAXISSET], joy2xmove[JOYAXISSET], joy2ymove[JOYAXISSET],
|
||||
joy3xmove[JOYAXISSET], joy3ymove[JOYAXISSET], joy4xmove[JOYAXISSET], joy4ymove[JOYAXISSET];
|
||||
|
||||
+13
-27
@@ -141,27 +141,19 @@ static int comparePolygons(const void *p1, const void *p2)
|
||||
PolygonArrayEntry *poly2 = *(PolygonArrayEntry *const *)p2;
|
||||
int diff;
|
||||
INT64 diff64;
|
||||
UINT32 downloaded1 = 0;
|
||||
UINT32 downloaded2 = 0;
|
||||
|
||||
int shader1 = poly1->shader;
|
||||
int shader2 = poly2->shader;
|
||||
// make skywalls and horizon lines first in order
|
||||
if (poly1->polyFlags & PF_NoTexture || poly1->horizonSpecial)
|
||||
shader1 = -1;
|
||||
if (poly2->polyFlags & PF_NoTexture || poly2->horizonSpecial)
|
||||
shader2 = -1;
|
||||
diff = shader1 - shader2;
|
||||
if (diff != 0) return diff;
|
||||
int shader1 = (poly1->polyFlags & PF_NoTexture || poly1->horizonSpecial) ? -1 : poly1->shader;
|
||||
int shader2 = (poly2->polyFlags & PF_NoTexture || poly2->horizonSpecial) ? -1 : poly2->shader;
|
||||
|
||||
// skywalls and horizon lines must retain their order for horizon lines to work
|
||||
if (shader1 == -1 && shader2 == -1)
|
||||
return poly1 - poly2;
|
||||
|
||||
if (poly1->texture)
|
||||
downloaded1 = poly1->texture->downloaded; // there should be a opengl texture name here, usable for comparisons
|
||||
if (poly2->texture)
|
||||
downloaded2 = poly2->texture->downloaded;
|
||||
diff = shader1 - shader2;
|
||||
if (diff != 0) return diff;
|
||||
|
||||
UINT32 downloaded1 = poly1->texture ? poly1->texture->downloaded : 0; // there should be a opengl texture name here, usable for comparisons
|
||||
UINT32 downloaded2 = poly2->texture ? poly2->texture->downloaded : 0;
|
||||
diff64 = downloaded1 - downloaded2;
|
||||
if (diff64 != 0) return diff64;
|
||||
|
||||
@@ -194,21 +186,15 @@ static int comparePolygonsNoShaders(const void *p1, const void *p2)
|
||||
int diff;
|
||||
INT64 diff64;
|
||||
|
||||
GLMipmap_t *texture1 = poly1->texture;
|
||||
GLMipmap_t *texture2 = poly2->texture;
|
||||
UINT32 downloaded1 = 0;
|
||||
UINT32 downloaded2 = 0;
|
||||
if (poly1->polyFlags & PF_NoTexture || poly1->horizonSpecial)
|
||||
texture1 = NULL;
|
||||
if (poly2->polyFlags & PF_NoTexture || poly2->horizonSpecial)
|
||||
texture2 = NULL;
|
||||
if (texture1)
|
||||
downloaded1 = texture1->downloaded; // there should be a opengl texture name here, usable for comparisons
|
||||
if (texture2)
|
||||
downloaded2 = texture2->downloaded;
|
||||
GLMipmap_t *texture1 = (poly1->polyFlags & PF_NoTexture || poly1->horizonSpecial) ? NULL : poly1->texture;
|
||||
GLMipmap_t *texture2 = (poly2->polyFlags & PF_NoTexture || poly2->horizonSpecial) ? NULL : poly2->texture;
|
||||
|
||||
// skywalls and horizon lines must retain their order for horizon lines to work
|
||||
if (!texture1 && !texture2)
|
||||
return poly1 - poly2;
|
||||
|
||||
UINT32 downloaded1 = texture1 ? texture1->downloaded : 0; // there should be a opengl texture name here, usable for comparisons
|
||||
UINT32 downloaded2 = texture2 ? texture2->downloaded : 0;
|
||||
diff64 = downloaded1 - downloaded2;
|
||||
if (diff64 != 0) return diff64;
|
||||
|
||||
|
||||
+10
-9
@@ -319,7 +319,7 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *gltex, boolean noe
|
||||
patch_t *realpatch;
|
||||
INT32 blockwidth, blockheight, blocksize;
|
||||
|
||||
INT32 i;
|
||||
INT32 i, idx;
|
||||
boolean skyspecial = false; //poor hack for Legacy large skies..
|
||||
|
||||
RGBA_t *palette;
|
||||
@@ -368,12 +368,10 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *gltex, boolean noe
|
||||
|
||||
col = palette[HWR_CHROMAKEY_EQUIVALENTCOLORINDEX];
|
||||
|
||||
for (j = 0; j < blockheight; j++)
|
||||
for (idx = 0, j = 0; j < blockheight; j++)
|
||||
{
|
||||
for (i = 0; i < blockwidth; i++)
|
||||
for (i = 0; i < blockwidth; i++, idx++)
|
||||
{
|
||||
int idx = (j*blockwidth+i);
|
||||
|
||||
block[4*idx+0] = col.s.red;
|
||||
block[4*idx+1] = col.s.green;
|
||||
block[4*idx+2] = col.s.blue;
|
||||
@@ -386,8 +384,11 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *gltex, boolean noe
|
||||
for (i = 0, patch = texture->patches; i < texture->patchcount; i++, patch++)
|
||||
{
|
||||
realpatch = W_CacheLumpNumPwad(patch->wad, patch->lump, PU_CACHE);
|
||||
HWR_DrawTexturePatchInCache(&gltex->mipmap, blockwidth, blockheight, texture, patch, realpatch);
|
||||
Z_ChangeTag(realpatch, PU_HWRCACHE_UNLOCKED);
|
||||
if (realpatch != NULL)
|
||||
{
|
||||
HWR_DrawTexturePatchInCache(&gltex->mipmap, blockwidth, blockheight, texture, patch, realpatch);
|
||||
Z_ChangeTag(realpatch, PU_HWRCACHE_UNLOCKED);
|
||||
}
|
||||
}
|
||||
|
||||
//Hurdler: not efficient at all but I don't remember exactly how HWR_DrawPatchInCache works :(
|
||||
@@ -639,8 +640,7 @@ static void HWR_CacheFlat(GLMipmap_t *glMipmap, lumpnum_t flatlumpnum)
|
||||
glMipmap->height = (UINT16)pflatsize;
|
||||
|
||||
// the flat raw data needn't be converted with palettized textures
|
||||
W_ReadLump(flatlumpnum, Z_Malloc(W_LumpLength(flatlumpnum),
|
||||
PU_HWRCACHE, &glMipmap->data));
|
||||
W_ReadLump(flatlumpnum, Z_Malloc(size, PU_HWRCACHE, &glMipmap->data));
|
||||
|
||||
#ifdef GLENCORE
|
||||
flat = glMipmap->data;
|
||||
@@ -835,6 +835,7 @@ static void HWR_DrawFadeMaskInCache(GLMipmap_t *mipmap, INT32 pblockwidth, INT32
|
||||
stepy = ((INT32)SHORT(fmheight)<<FRACBITS)/pblockheight;
|
||||
stepx = ((INT32)SHORT(fmwidth)<<FRACBITS)/pblockwidth;
|
||||
posy = 0;
|
||||
|
||||
for (j = 0; j < pblockheight; j++)
|
||||
{
|
||||
posx = 0;
|
||||
|
||||
@@ -333,7 +333,7 @@ angle_t gld_FrustumAngle(angle_t tiltangle)
|
||||
|
||||
// ok, this is a gross hack that barely works...
|
||||
// but at least it doesn't overestimate too much...
|
||||
clipfov = atan(1 / projMatrix[0]) * 360 / M_PIl;
|
||||
clipfov = atan(1 / projMatrix[0]) * 360.0f / M_PIl;
|
||||
floatangle = 2.0f + (45.0f + (tilt / 1.9f)) * clipfov / 90.0f;
|
||||
if (floatangle >= 180.0)
|
||||
return 0xffffffff;
|
||||
|
||||
+15
-29
@@ -121,38 +121,24 @@ typedef struct
|
||||
poly_t *planepoly; // the generated convex polygon
|
||||
} extrasubsector_t;
|
||||
|
||||
// Kart features
|
||||
#define USE_FTRANSFORM_ANGLEZ
|
||||
#define USE_FTRANSFORM_MIRROR
|
||||
|
||||
// Vanilla features
|
||||
//#define USE_MODEL_NEXTFRAME
|
||||
|
||||
typedef struct
|
||||
{
|
||||
FLOAT x,y,z; // position
|
||||
#ifdef USE_FTRANSFORM_ANGLEZ
|
||||
FLOAT anglex, angley, anglez; // aimingangle / viewangle
|
||||
FLOAT anglex2, anglez2; // secondaries
|
||||
#else
|
||||
FLOAT anglex, angley; // aimingangle / viewangle
|
||||
FLOAT anglex2; // secondaries
|
||||
#endif
|
||||
FLOAT scalex, scaley, scalez;
|
||||
FLOAT spritexscale, spriteyscale;
|
||||
FLOAT fovxangle, fovyangle;
|
||||
FLOAT fovangle;
|
||||
UINT8 splitscreen;
|
||||
boolean flip; // screenflip
|
||||
boolean roll;
|
||||
boolean rollmodel;
|
||||
SINT8 rollflip;
|
||||
FLOAT rollangle;
|
||||
UINT8 rotaxis;
|
||||
FLOAT centerx, centery;
|
||||
#ifdef USE_FTRANSFORM_MIRROR
|
||||
FLOAT rollx, rollz;
|
||||
boolean mirror; // SRB2Kart: Encore Mode
|
||||
boolean mirrorflip; // Encore Mode with Flipcam
|
||||
#endif
|
||||
boolean shearing; // 14042019
|
||||
float viewaiming; // 17052019
|
||||
} FTransform;
|
||||
@@ -246,22 +232,22 @@ enum EPolyFlags
|
||||
{
|
||||
// the first 5 are mutually exclusive
|
||||
|
||||
PF_Masked = 0x00000001, // Poly is alpha scaled and 0 alpha pels are discarded (holes in texture)
|
||||
PF_Masked = 0x00000001, // Poly is alpha scaled and 0 alpha pixels are discarded (holes in texture)
|
||||
PF_Translucent = 0x00000002, // Poly is transparent, alpha = level of transparency
|
||||
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_Fog = 0x00000040, // Fog blocks
|
||||
PF_Blending = (PF_Environment|PF_Additive|PF_Translucent|PF_Masked|PF_Substractive|PF_Fog)&~PF_NoAlphaTest,
|
||||
PF_Environment = 0x00000004, // Poly should be drawn environment mapped. (Hurdler: used for text drawing)
|
||||
PF_Additive = 0x00000008, // Source blending factor is additive.
|
||||
PF_Subtractive = 0x00000010, // Subtractive color blending
|
||||
PF_ReverseSubtract = 0x00000020, // Reverse subtract, used in wall splats (decals)
|
||||
PF_Multiplicative = 0x00000040, // Multiplicative color blending
|
||||
PF_Fog = 0x20000000, // Fog blocks
|
||||
PF_NoAlphaTest = 0x40000000, // Disables alpha testing
|
||||
PF_Blending = (PF_Masked|PF_Translucent|PF_Environment|PF_Additive|PF_Subtractive|PF_ReverseSubtract|PF_Multiplicative|PF_Fog) & ~PF_NoAlphaTest,
|
||||
|
||||
// other flag bits
|
||||
|
||||
PF_Occlude = 0x00000100, // Update the depth buffer
|
||||
PF_NoDepthTest = 0x00000200, // Disable the depth test mode
|
||||
PF_Invisible = 0x00000400, // Disable write to color buffer
|
||||
PF_Decal = 0x00000800, // Enable polygon offset
|
||||
PF_Occlude = 0x00000100, // Updates the depth buffer
|
||||
PF_NoDepthTest = 0x00000200, // Disables the depth test mode
|
||||
PF_Invisible = 0x00000400, // Disables write to color buffer
|
||||
PF_Decal = 0x00000800, // Enables polygon offset
|
||||
PF_Modulated = 0x00001000, // Modulation (multiply output with constant RGBA)
|
||||
// When set, pass the color constant into the FSurfaceInfo -> FlatColor
|
||||
PF_NoTexture = 0x00002000, // Disable texture
|
||||
|
||||
+94
-67
@@ -62,6 +62,9 @@ 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};
|
||||
|
||||
static const float FLOATBASEVIDWIDTH = (float)BASEVIDWIDTH;
|
||||
static const float FLOATBASEVIDHEIGHT = (float)BASEVIDHEIGHT;
|
||||
|
||||
//
|
||||
// -----------------+
|
||||
// HWR_DrawPatch : Draw a 'tile' graphic
|
||||
@@ -126,13 +129,14 @@ void HWR_DrawPatch(GLPatch_t *gpatch, INT32 x, INT32 y, INT32 option)
|
||||
GL_DrawPolygon(NULL, v, 4, flags);
|
||||
}
|
||||
|
||||
void HWR_DrawStretchyFixedPatch(GLPatch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale, fixed_t vscale, INT32 option, const UINT8 *colormap)
|
||||
void HWR_DrawStretchyFixedPatch(GLPatch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale, fixed_t vscale, INT32 option, const UINT8 *colormap, INT32 bflags)
|
||||
{
|
||||
FOutVector v[4];
|
||||
FBITFIELD flags;
|
||||
float cx = FIXED_TO_FLOAT(x);
|
||||
float cy = FIXED_TO_FLOAT(y);
|
||||
UINT8 alphalevel = ((option & V_ALPHAMASK) >> V_ALPHASHIFT);
|
||||
UINT8 blendmode = ((bflags & V_BLENDMASK) >> V_BLENDSHIFT);
|
||||
|
||||
// 3--2
|
||||
// | /|
|
||||
@@ -143,6 +147,9 @@ void HWR_DrawStretchyFixedPatch(GLPatch_t *gpatch, fixed_t x, fixed_t y, fixed_t
|
||||
if (alphalevel >= 10 && alphalevel < 13)
|
||||
return;
|
||||
|
||||
const float fvw = (float)vid.width;
|
||||
const float fvh = (float)vid.height;
|
||||
|
||||
// make patch ready in hardware cache
|
||||
if (!colormap)
|
||||
HWR_GetPatch(gpatch);
|
||||
@@ -226,21 +233,21 @@ void HWR_DrawStretchyFixedPatch(GLPatch_t *gpatch, fixed_t x, fixed_t y, fixed_t
|
||||
Z_Free(realpatch);
|
||||
}
|
||||
// centre screen
|
||||
if (fabsf((float)vid.width - (float)BASEVIDWIDTH * dupx) > 1.0E-36f)
|
||||
if (fabsf(fvw - FLOATBASEVIDWIDTH * dupx) > 1.0E-36f)
|
||||
{
|
||||
if (option & V_SNAPTORIGHT)
|
||||
cx += ((float)vid.width - ((float)BASEVIDWIDTH * dupx));
|
||||
cx += (fvw - (FLOATBASEVIDWIDTH * dupx));
|
||||
else if (!(option & V_SNAPTOLEFT))
|
||||
cx += ((float)vid.width - ((float)BASEVIDWIDTH * dupx))/2;
|
||||
cx += (fvw - (FLOATBASEVIDWIDTH * dupx))/2;
|
||||
}
|
||||
if (fabsf((float)vid.height - (float)BASEVIDHEIGHT * dupy) > 1.0E-36f)
|
||||
if (fabsf(fvh - FLOATBASEVIDHEIGHT * dupy) > 1.0E-36f)
|
||||
{
|
||||
if ((option & (V_SPLITSCREEN|V_SNAPTOTOP)) == (V_SPLITSCREEN|V_SNAPTOTOP))
|
||||
cy += ((float)vid.height/2 - ((float)BASEVIDHEIGHT/2 * dupy));
|
||||
cy += (fvh/2 - (FLOATBASEVIDHEIGHT/2 * dupy));
|
||||
else if (option & V_SNAPTOBOTTOM)
|
||||
cy += ((float)vid.height - ((float)BASEVIDHEIGHT * dupy));
|
||||
cy += (fvh - (FLOATBASEVIDHEIGHT * dupy));
|
||||
else if (!(option & V_SNAPTOTOP))
|
||||
cy += ((float)vid.height - ((float)BASEVIDHEIGHT * dupy))/2;
|
||||
cy += (fvh - (FLOATBASEVIDHEIGHT * dupy))/2;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -257,12 +264,12 @@ void HWR_DrawStretchyFixedPatch(GLPatch_t *gpatch, fixed_t x, fixed_t y, fixed_t
|
||||
}
|
||||
|
||||
// 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));
|
||||
cx = -1.0f + (cx / (vid.width / 2.0f));
|
||||
cy = 1.0f - (cy / (vid.height / 2.0f));
|
||||
|
||||
// fwidth and fheight are similar
|
||||
fwidth /= vid.width / 2;
|
||||
fheight /= vid.height / 2;
|
||||
fwidth /= fvw / 2.0f;
|
||||
fheight /= fvh / 2.0f;
|
||||
|
||||
// set the polygon vertices to the right positions
|
||||
v[0].x = v[3].x = cx;
|
||||
@@ -287,7 +294,11 @@ void HWR_DrawStretchyFixedPatch(GLPatch_t *gpatch, fixed_t x, fixed_t y, fixed_t
|
||||
v[0].t = v[1].t = 0.0f;
|
||||
v[2].t = v[3].t = gpatch->max_t;
|
||||
|
||||
flags = PF_Translucent|PF_NoDepthTest;
|
||||
// whoops
|
||||
if (blendmode)
|
||||
flags = HWR_GetBlendModeFlag(blendmode+1)|PF_NoDepthTest;
|
||||
else
|
||||
flags = PF_Translucent|PF_NoDepthTest;
|
||||
|
||||
if (option & V_WRAPX)
|
||||
flags |= PF_ForceWrapX;
|
||||
@@ -295,14 +306,17 @@ void HWR_DrawStretchyFixedPatch(GLPatch_t *gpatch, fixed_t x, fixed_t y, fixed_t
|
||||
flags |= PF_ForceWrapY;
|
||||
|
||||
// clip it since it is used for bunny scroll in doom I
|
||||
|
||||
if (alphalevel)
|
||||
{
|
||||
FSurfaceInfo Surf;
|
||||
Surf.PolyColor.s.red = Surf.PolyColor.s.green = Surf.PolyColor.s.blue = 0xff;
|
||||
|
||||
if (alphalevel == 13) Surf.PolyColor.s.alpha = softwaretranstogl_lo[hudtrans];
|
||||
else if (alphalevel == 14) Surf.PolyColor.s.alpha = softwaretranstogl[hudtrans];
|
||||
else if (alphalevel == 15) Surf.PolyColor.s.alpha = softwaretranstogl_hi[hudtrans];
|
||||
else Surf.PolyColor.s.alpha = softwaretranstogl[10-alphalevel];
|
||||
|
||||
flags |= PF_Modulated;
|
||||
GL_DrawPolygon(&Surf, v, 4, flags);
|
||||
}
|
||||
@@ -327,6 +341,9 @@ void HWR_DrawCroppedPatch(GLPatch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscal
|
||||
if (alphalevel >= 10 && alphalevel < 13)
|
||||
return;
|
||||
|
||||
const float fvw = (float)vid.width;
|
||||
const float fvh = (float)vid.height;
|
||||
|
||||
// make patch ready in hardware cache
|
||||
HWR_GetPatch(gpatch);
|
||||
|
||||
@@ -377,21 +394,21 @@ void HWR_DrawCroppedPatch(GLPatch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscal
|
||||
Z_Free(realpatch);
|
||||
}
|
||||
// centre screen
|
||||
if (fabsf((float)vid.width - (float)BASEVIDWIDTH * dupx) > 1.0E-36f)
|
||||
if (fabsf(fvw - FLOATBASEVIDWIDTH * dupx) > 1.0E-36f)
|
||||
{
|
||||
if (option & V_SNAPTORIGHT)
|
||||
cx += ((float)vid.width - ((float)BASEVIDWIDTH * dupx));
|
||||
cx += (fvw - (FLOATBASEVIDWIDTH * dupx));
|
||||
else if (!(option & V_SNAPTOLEFT))
|
||||
cx += ((float)vid.width - ((float)BASEVIDWIDTH * dupx))/2;
|
||||
cx += (fvw - (FLOATBASEVIDWIDTH * dupx))/2;
|
||||
}
|
||||
if (fabsf((float)vid.height - (float)BASEVIDHEIGHT * dupy) > 1.0E-36f)
|
||||
if (fabsf(fvh - FLOATBASEVIDHEIGHT * dupy) > 1.0E-36f)
|
||||
{
|
||||
if ((option & (V_SPLITSCREEN|V_SNAPTOTOP)) == (V_SPLITSCREEN|V_SNAPTOTOP))
|
||||
cy += ((float)vid.height/2 - ((float)BASEVIDHEIGHT/2 * dupy));
|
||||
cy += (fvh/2 - (FLOATBASEVIDHEIGHT/2 * dupy));
|
||||
else if (option & V_SNAPTOBOTTOM)
|
||||
cy += ((float)vid.height - ((float)BASEVIDHEIGHT * dupy));
|
||||
cy += (fvh - (FLOATBASEVIDHEIGHT * dupy));
|
||||
else if (!(option & V_SNAPTOTOP))
|
||||
cy += ((float)vid.height - ((float)BASEVIDHEIGHT * dupy))/2;
|
||||
cy += (fvh - (FLOATBASEVIDHEIGHT * dupy))/2;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -423,12 +440,12 @@ void HWR_DrawCroppedPatch(GLPatch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscal
|
||||
}
|
||||
|
||||
// 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));
|
||||
cx = -1.0f + (cx / (vid.width / 2.0f));
|
||||
cy = 1.0f - (cy / (vid.height / 2.0f));
|
||||
|
||||
// fwidth and fheight are similar
|
||||
fwidth /= vid.width / 2;
|
||||
fheight /= vid.height / 2;
|
||||
fwidth /= fvw / 2.0f;
|
||||
fheight /= fvh / 2.0f;
|
||||
|
||||
// set the polygon vertices to the right positions
|
||||
v[0].x = v[3].x = cx;
|
||||
@@ -456,10 +473,12 @@ void HWR_DrawCroppedPatch(GLPatch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscal
|
||||
{
|
||||
FSurfaceInfo Surf;
|
||||
Surf.PolyColor.s.red = Surf.PolyColor.s.green = Surf.PolyColor.s.blue = 0xff;
|
||||
|
||||
if (alphalevel == 13) Surf.PolyColor.s.alpha = softwaretranstogl_lo[cv_translucenthud.value];
|
||||
else if (alphalevel == 14) Surf.PolyColor.s.alpha = softwaretranstogl[cv_translucenthud.value];
|
||||
else if (alphalevel == 15) Surf.PolyColor.s.alpha = softwaretranstogl_hi[cv_translucenthud.value];
|
||||
else Surf.PolyColor.s.alpha = softwaretranstogl[10-alphalevel];
|
||||
|
||||
flags |= PF_Modulated;
|
||||
GL_DrawPolygon(&Surf, v, 4, flags);
|
||||
}
|
||||
@@ -811,6 +830,9 @@ void HWR_DrawDiag(INT32 x, INT32 y, INT32 wh, INT32 color)
|
||||
fy = (float)y;
|
||||
fw = fh = (float)wh;
|
||||
|
||||
const float fvw = (float)vid.width;
|
||||
const float fvh = (float)vid.height;
|
||||
|
||||
if (!(color & V_NOSCALESTART))
|
||||
{
|
||||
float dupx = (float)vid.dupx, dupy = (float)vid.dupy;
|
||||
@@ -820,20 +842,20 @@ void HWR_DrawDiag(INT32 x, INT32 y, INT32 wh, INT32 color)
|
||||
fw *= dupx;
|
||||
fh *= dupy;
|
||||
|
||||
if (fabsf((float)vid.width - ((float)BASEVIDWIDTH * dupx)) > 1.0E-36f)
|
||||
if (fabsf(fvw - (FLOATBASEVIDWIDTH * dupx)) > 1.0E-36f)
|
||||
{
|
||||
if (color & V_SNAPTORIGHT)
|
||||
fx += ((float)vid.width - ((float)BASEVIDWIDTH * dupx));
|
||||
fx += (fvw - (FLOATBASEVIDWIDTH * dupx));
|
||||
else if (!(color & V_SNAPTOLEFT))
|
||||
fx += ((float)vid.width - ((float)BASEVIDWIDTH * dupx)) / 2;
|
||||
fx += (fvw - (FLOATBASEVIDWIDTH * dupx)) / 2;
|
||||
}
|
||||
if (fabsf((float)vid.height - ((float)BASEVIDHEIGHT * dupy)) > 1.0E-36f)
|
||||
if (fabsf(fvh - (FLOATBASEVIDHEIGHT * dupy)) > 1.0E-36f)
|
||||
{
|
||||
// same thing here
|
||||
if (color & V_SNAPTOBOTTOM)
|
||||
fy += ((float)vid.height - ((float)BASEVIDHEIGHT * dupy));
|
||||
fy += (fvh - (FLOATBASEVIDHEIGHT * dupy));
|
||||
else if (!(color & V_SNAPTOTOP))
|
||||
fy += ((float)vid.height - ((float)BASEVIDHEIGHT * dupy)) / 2;
|
||||
fy += (fvh - (FLOATBASEVIDHEIGHT * dupy)) / 2;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -854,16 +876,16 @@ void HWR_DrawDiag(INT32 x, INT32 y, INT32 wh, INT32 color)
|
||||
return;
|
||||
if (fx + fw > vid.width)
|
||||
{
|
||||
fwait = fw - ((float)vid.width - fx);
|
||||
fw = (float)vid.width - fx;
|
||||
fwait = fw - (fvw- fx);
|
||||
fw = fvw - fx;
|
||||
}
|
||||
if (fy + fh > vid.height)
|
||||
fh = (float)vid.height - fy;
|
||||
fh = fvh - fy;
|
||||
|
||||
fx = -1 + fx / (vid.width / 2);
|
||||
fy = 1 - fy / (vid.height / 2);
|
||||
fw = fw / (vid.width / 2);
|
||||
fh = fh / (vid.height / 2);
|
||||
fx = -1.0f + fx / (vid.width / 2.0f);
|
||||
fy = 1.0f - fy / (vid.height / 2.0f);
|
||||
fw = fw / (fvw / 2.0f);
|
||||
fh = fh / (fvh / 2.0f);
|
||||
|
||||
v[0].x = v[3].x = fx;
|
||||
v[2].x = v[1].x = fx + fw;
|
||||
@@ -907,6 +929,9 @@ void HWR_DrawConsoleFill(INT32 x, INT32 y, INT32 w, INT32 h, UINT32 color, INT32
|
||||
fw = (float)w;
|
||||
fh = (float)h;
|
||||
|
||||
const float fvw = (float)vid.width;
|
||||
const float fvh = (float)vid.height;
|
||||
|
||||
if (!(options & V_NOSCALESTART))
|
||||
{
|
||||
float dupx = (float)vid.dupx, dupy = (float)vid.dupy;
|
||||
@@ -928,25 +953,25 @@ void HWR_DrawConsoleFill(INT32 x, INT32 y, INT32 w, INT32 h, UINT32 color, INT32
|
||||
fw *= dupx;
|
||||
fh *= dupy;
|
||||
|
||||
if (fabsf((float)vid.width - ((float)BASEVIDWIDTH * dupx)) > 1.0E-36f)
|
||||
if (fabsf(fvw - (FLOATBASEVIDWIDTH * dupx)) > 1.0E-36f)
|
||||
{
|
||||
if (options & V_SNAPTORIGHT)
|
||||
fx += ((float)vid.width - ((float)BASEVIDWIDTH * dupx));
|
||||
fx += (fvw - (FLOATBASEVIDWIDTH * dupx));
|
||||
else if (!(options & V_SNAPTOLEFT))
|
||||
fx += ((float)vid.width - ((float)BASEVIDWIDTH * dupx)) / 2;
|
||||
fx += (fvw - (FLOATBASEVIDWIDTH * dupx)) / 2;
|
||||
}
|
||||
if (fabsf((float)vid.height - ((float)BASEVIDHEIGHT * dupy)) > 1.0E-36f)
|
||||
if (fabsf(fvh - (FLOATBASEVIDHEIGHT * dupy)) > 1.0E-36f)
|
||||
{
|
||||
// same thing here
|
||||
if (options & V_SNAPTOBOTTOM)
|
||||
fy += ((float)vid.height - ((float)BASEVIDHEIGHT * dupy));
|
||||
fy += (fvh - (FLOATBASEVIDHEIGHT * dupy));
|
||||
else if (!(options & V_SNAPTOTOP))
|
||||
fy += ((float)vid.height - ((float)BASEVIDHEIGHT * dupy)) / 2;
|
||||
fy += (fvh - (FLOATBASEVIDHEIGHT * dupy)) / 2;
|
||||
}
|
||||
if (options & V_SPLITSCREEN)
|
||||
fy += ((float)BASEVIDHEIGHT * dupy)/2;
|
||||
fy += (FLOATBASEVIDHEIGHT * dupy)/2;
|
||||
if (options & V_HORZSCREEN)
|
||||
fx += ((float)BASEVIDWIDTH * dupx)/2;
|
||||
fx += (FLOATBASEVIDWIDTH * dupx)/2;
|
||||
|
||||
}
|
||||
|
||||
@@ -966,14 +991,14 @@ void HWR_DrawConsoleFill(INT32 x, INT32 y, INT32 w, INT32 h, UINT32 color, INT32
|
||||
if (fw <= 0 || fh <= 0)
|
||||
return;
|
||||
if (fx + fw > vid.width)
|
||||
fw = (float)vid.width - fx;
|
||||
fw = fvw - fx;
|
||||
if (fy + fh > vid.height)
|
||||
fh = (float)vid.height - fy;
|
||||
fh = fvh - fy;
|
||||
|
||||
fx = -1 + fx / (vid.width / 2);
|
||||
fy = 1 - fy / (vid.height / 2);
|
||||
fw = fw / (vid.width / 2);
|
||||
fh = fh / (vid.height / 2);
|
||||
fx = -1.0f + fx / (vid.width / 2.0f);
|
||||
fy = 1.0f - fy / (vid.height / 2.0f);
|
||||
fw = fw / (fvw / 2.0f);
|
||||
fh = fh / (fvh / 2.0f);
|
||||
|
||||
v[0].x = v[3].x = fx;
|
||||
v[2].x = v[1].x = fx + fw;
|
||||
@@ -1018,6 +1043,9 @@ void HWR_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 color)
|
||||
fw = (float)w;
|
||||
fh = (float)h;
|
||||
|
||||
const float fvw = (float)vid.width;
|
||||
const float fvh = (float)vid.height;
|
||||
|
||||
if (!(color & V_NOSCALESTART))
|
||||
{
|
||||
float dupx = (float)vid.dupx, dupy = (float)vid.dupy;
|
||||
@@ -1039,26 +1067,25 @@ void HWR_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 color)
|
||||
fw *= dupx;
|
||||
fh *= dupy;
|
||||
|
||||
if (fabsf((float)vid.width - (float)BASEVIDWIDTH * dupx) > 1.0E-36f)
|
||||
if (fabsf(fvw - FLOATBASEVIDWIDTH * dupx) > 1.0E-36f)
|
||||
{
|
||||
if (color & V_SNAPTORIGHT)
|
||||
fx += ((float)vid.width - ((float)BASEVIDWIDTH * dupx));
|
||||
fx += (fvw - (FLOATBASEVIDWIDTH * dupx));
|
||||
else if (!(color & V_SNAPTOLEFT))
|
||||
fx += ((float)vid.width - ((float)BASEVIDWIDTH * dupx)) / 2;
|
||||
fx += (fvw - (FLOATBASEVIDWIDTH * dupx)) / 2;
|
||||
}
|
||||
if (fabsf((float)vid.height - (float)BASEVIDHEIGHT * dupy) > 1.0E-36f)
|
||||
if (fabsf(fvh - FLOATBASEVIDHEIGHT * dupy) > 1.0E-36f)
|
||||
{
|
||||
// same thing here
|
||||
if (color & V_SNAPTOBOTTOM)
|
||||
fy += ((float)vid.height - ((float)BASEVIDHEIGHT * dupy));
|
||||
fy += (fvh - (FLOATBASEVIDHEIGHT * dupy));
|
||||
else if (!(color & V_SNAPTOTOP))
|
||||
fy += ((float)vid.height - ((float)BASEVIDHEIGHT * dupy)) / 2;
|
||||
fy += (fvh - (FLOATBASEVIDHEIGHT * dupy)) / 2;
|
||||
}
|
||||
if (color & V_SPLITSCREEN)
|
||||
fy += ((float)BASEVIDHEIGHT * dupy)/2;
|
||||
fy += (FLOATBASEVIDHEIGHT * dupy)/2;
|
||||
if (color & V_HORZSCREEN)
|
||||
fx += ((float)BASEVIDWIDTH * dupx)/2;
|
||||
|
||||
fx += (FLOATBASEVIDWIDTH * dupx)/2;
|
||||
}
|
||||
|
||||
if (fx >= vid.width || fy >= vid.height)
|
||||
@@ -1077,14 +1104,14 @@ void HWR_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 color)
|
||||
if (fw <= 0 || fh <= 0)
|
||||
return;
|
||||
if (fx + fw > vid.width)
|
||||
fw = (float)vid.width - fx;
|
||||
fw = fvw - fx;
|
||||
if (fy + fh > vid.height)
|
||||
fh = (float)vid.height - fy;
|
||||
fh = fvh - fy;
|
||||
|
||||
fx = -1 + fx / (vid.width / 2);
|
||||
fy = 1 - fy / (vid.height / 2);
|
||||
fw = fw / (vid.width / 2);
|
||||
fh = fh / (vid.height / 2);
|
||||
fx = -1.0f + fx / (vid.width / 2.0f);
|
||||
fy = 1.0f - fy / (vid.height / 2.0f);
|
||||
fw = fw / (fvw / 2.0f);
|
||||
fh = fh / (fvh / 2.0f);
|
||||
|
||||
v[0].x = v[3].x = fx;
|
||||
v[2].x = v[1].x = fx + fw;
|
||||
@@ -1127,7 +1154,7 @@ void HWR_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 color)
|
||||
#define _FILE_OFFSET_BITS 0
|
||||
#endif
|
||||
|
||||
#include "png.h"
|
||||
#include "png.h"
|
||||
#ifdef PNG_WRITE_SUPPORTED
|
||||
#define USE_PNG // PNG is only used if write is supported (see ../m_misc.c)
|
||||
#endif
|
||||
|
||||
+320
-250
File diff suppressed because it is too large.
Load diff
+63
-22
@@ -20,6 +20,7 @@
|
||||
#ifndef __HWR_MAIN_H__
|
||||
#define __HWR_MAIN_H__
|
||||
|
||||
#include "hw_gl.h"
|
||||
#include "hw_glob.h"
|
||||
#include "hw_data.h"
|
||||
#include "hw_defs.h"
|
||||
@@ -29,6 +30,7 @@
|
||||
#include "../d_player.h"
|
||||
#include "../r_defs.h"
|
||||
#include "../m_perfstats.h"
|
||||
#include "../v_video.h"
|
||||
|
||||
#define GLENCORE
|
||||
|
||||
@@ -56,11 +58,11 @@ extern sector_t *gl_backsector;
|
||||
|
||||
enum
|
||||
{
|
||||
HWR_STENCIL_NORMAL,
|
||||
HWR_STENCIL_BEGIN,
|
||||
HWR_STENCIL_REVERSE,
|
||||
HWR_STENCIL_DEPTH,
|
||||
HWR_STENCIL_SKY
|
||||
HWR_STENCIL_NORMAL,
|
||||
HWR_STENCIL_BEGIN,
|
||||
HWR_STENCIL_REVERSE,
|
||||
HWR_STENCIL_DEPTH,
|
||||
HWR_STENCIL_SKY
|
||||
};
|
||||
|
||||
// Performance stats
|
||||
@@ -84,7 +86,7 @@ extern boolean gl_shadersavailable;
|
||||
|
||||
// hw_draw.c
|
||||
void HWR_DrawPatch(GLPatch_t *gpatch, INT32 x, INT32 y, INT32 option);
|
||||
void HWR_DrawStretchyFixedPatch(GLPatch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale, fixed_t vscale, INT32 option, const UINT8 *colormap);
|
||||
void HWR_DrawStretchyFixedPatch(GLPatch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale, fixed_t vscale, INT32 option, const UINT8 *colormap, INT32 bflags);
|
||||
void HWR_DrawCroppedPatch(GLPatch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale, INT32 option, fixed_t sx, fixed_t sy, fixed_t w, fixed_t h);
|
||||
void HWR_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 color);
|
||||
void HWR_DrawConsoleFill(INT32 x, INT32 y, INT32 w, INT32 h, UINT32 color, INT32 options); // Lat: separate flags from color since color needs to be an uint to work right.
|
||||
@@ -102,39 +104,65 @@ boolean HWR_Screenshot(const char *lbmname);
|
||||
void HWR_SetViewSize(void);
|
||||
void HWR_AddCommands(void);
|
||||
|
||||
void HWR_RenderPlayerView(INT32 viewnumber, player_t *player);
|
||||
void HWR_RenderPlayerView(void);
|
||||
void HWR_RenderViewpoint(gl_portal_t *rootportal, const float fpov, player_t *player, int stencil_level, boolean allow_portals);
|
||||
|
||||
void HWR_ClearSkyDome(void);
|
||||
void HWR_BuildSkyDome(void);
|
||||
|
||||
void HWR_SetTransform(float fpov, player_t *player);
|
||||
void HWR_SetTransform(float fpov);
|
||||
void HWR_ClearClipper(void);
|
||||
void HWR_SetStencilState(int state, int level);
|
||||
|
||||
boolean HWR_UseShader(void);
|
||||
boolean HWR_ShouldUsePaletteRendering(void);
|
||||
boolean HWR_PalRenderFlashpal(void);
|
||||
|
||||
// My original intention was to split hw_main.c
|
||||
// into files like hw_bsp.c, hw_sprites.c...
|
||||
|
||||
// hw_main.c: Lighting and fog
|
||||
void HWR_Lighting(FSurfaceInfo *Surface, INT32 light_level, extracolormap_t *colormap, const boolean directional);
|
||||
|
||||
UINT8 HWR_GetTranstableAlpha(INT32 transtablenum);
|
||||
FBITFIELD HWR_GetBlendModeFlag(INT32 ast);
|
||||
FBITFIELD HWR_SurfaceBlend(INT32 style, INT32 transtablenum, FSurfaceInfo *pSurf);
|
||||
FBITFIELD HWR_TranstableToAlpha(INT32 transtablenum, FSurfaceInfo *pSurf);
|
||||
|
||||
// Get amount of memory used by gpu textures in bytes
|
||||
INT32 HWR_GetTextureUsed(void);
|
||||
// Get amount of memory used by gpu textures in bytes;
|
||||
FUNCINLINE static ATTRINLINE INT32 HWR_GetTextureUsed(void)
|
||||
{
|
||||
return GL_GetTextureUsed();
|
||||
}
|
||||
|
||||
// hw_main.c: Post-rendering
|
||||
void HWR_StartScreenWipe(void);
|
||||
void HWR_EndScreenWipe(void);
|
||||
void HWR_DrawIntermissionBG(void);
|
||||
void HWR_DoWipe(UINT8 wipenum, UINT8 scrnnum);
|
||||
void HWR_RenderVhsEffect(fixed_t upbary, fixed_t downbary, UINT8 updistort, UINT8 downdistort, UINT8 barsize);
|
||||
void HWR_MakeScreenFinalTexture(void);
|
||||
void HWR_DrawScreenFinalTexture(INT32 width, INT32 height, boolean useshader);
|
||||
|
||||
FUNCINLINE static ATTRINLINE void HWR_StartScreenWipe(void)
|
||||
{
|
||||
GL_MakeScreenTexture(HWD_SCREENTEXTURE_WIPE_START);
|
||||
}
|
||||
|
||||
FUNCINLINE static ATTRINLINE void HWR_EndScreenWipe(void)
|
||||
{
|
||||
GL_MakeScreenTexture(HWD_SCREENTEXTURE_WIPE_END);
|
||||
}
|
||||
|
||||
FUNCINLINE static ATTRINLINE void HWR_DrawIntermissionBG(void)
|
||||
{
|
||||
GL_DrawScreenTexture(HWD_SCREENTEXTURE_GENERIC1, NULL, 0);
|
||||
}
|
||||
|
||||
FUNCINLINE static ATTRINLINE void HWR_RenderVhsEffect(fixed_t upbary, fixed_t downbary, UINT8 updistort, UINT8 downdistort, UINT8 barsize)
|
||||
{
|
||||
GL_RenderVhsEffect(upbary, downbary, updistort, downdistort, barsize);
|
||||
}
|
||||
|
||||
FUNCINLINE static ATTRINLINE void HWR_MakeScreenFinalTexture(void)
|
||||
{
|
||||
GL_MakeScreenTexture(HWD_SCREENTEXTURE_GENERIC2);
|
||||
}
|
||||
|
||||
FUNCINLINE static ATTRINLINE void HWR_DrawScreenFinalTexture(INT32 width, INT32 height, boolean useshader)
|
||||
{
|
||||
GL_DrawScreenFinalTexture(HWD_SCREENTEXTURE_GENERIC2, width, height, useshader);
|
||||
}
|
||||
|
||||
// hw_main.c: Segs
|
||||
void HWR_ProcessSeg(void); // Sort of like GLWall::Process in GZDoom
|
||||
@@ -181,10 +209,23 @@ extern consvar_t cv_glrenderdistance;
|
||||
extern consvar_t cv_glhorizonlines;
|
||||
extern consvar_t cv_glportals;
|
||||
|
||||
extern consvar_t cv_glfovchange;
|
||||
|
||||
extern consvar_t cv_glpaletterendering;
|
||||
extern consvar_t cv_glpalettedepth;
|
||||
extern consvar_t cv_glflashpal;
|
||||
|
||||
FUNCINLINE static ATTRINLINE boolean HWR_UseShader(void)
|
||||
{
|
||||
return (cv_glshaders.value && gl_shadersavailable);
|
||||
}
|
||||
|
||||
FUNCINLINE static ATTRINLINE boolean HWR_ShouldUsePaletteRendering(void)
|
||||
{
|
||||
return (cv_glpaletterendering.value && (pLocalPalette != NULL) && HWR_UseShader());
|
||||
}
|
||||
|
||||
FUNCINLINE static ATTRINLINE boolean HWR_PalRenderFlashpal(void)
|
||||
{
|
||||
return (HWR_ShouldUsePaletteRendering() && cv_glflashpal.value);
|
||||
}
|
||||
|
||||
#endif
|
||||
+53
-88
@@ -1163,8 +1163,6 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
|
||||
spritedef_t *sprdef;
|
||||
spriteframe_t *sprframe;
|
||||
spriteinfo_t *sprinfo;
|
||||
INT32 rollfactor = 0;
|
||||
angle_t ang;
|
||||
interpmobjstate_t interp;
|
||||
|
||||
if (R_UsingFrameInterpolation() && !paused && (!cv_maxinterpdist.value || R_QuickCamDist(spr->mobj->x, spr->mobj->y) < cv_maxinterpdist.value))
|
||||
@@ -1181,13 +1179,31 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
|
||||
// Apparently people don't like jump frames like that, so back it goes
|
||||
//if (tics > durs)
|
||||
//durs = tics;
|
||||
|
||||
INT32 blendmode;
|
||||
if (spr->mobj->frame & FF_BLENDMASK)
|
||||
blendmode = ((spr->mobj->frame & FF_BLENDMASK) >> FF_BLENDSHIFT) + 1;
|
||||
else
|
||||
blendmode = spr->mobj->blendmode;
|
||||
|
||||
blendmode = min(AST_MODULATE, blendmode);
|
||||
|
||||
if (spr->mobj->flags2 & MF2_SHADOW)
|
||||
{
|
||||
Surf.PolyColor.s.alpha = 0x40;
|
||||
Surf.PolyFlags = HWR_GetBlendModeFlag(blendmode);
|
||||
}
|
||||
else if (spr->mobj->frame & FF_TRANSMASK)
|
||||
{
|
||||
HWR_TranstableToAlpha((spr->mobj->frame & FF_TRANSMASK)>>FF_TRANSSHIFT, &Surf);
|
||||
Surf.PolyFlags = HWR_SurfaceBlend(blendmode, (spr->mobj->frame & FF_TRANSMASK)>>FF_TRANSSHIFT, &Surf);
|
||||
}
|
||||
else
|
||||
Surf.PolyColor.s.alpha = 0xFF;
|
||||
{
|
||||
// this hack is dumb, but the blendmodes refuse to work otherwise
|
||||
Surf.PolyColor.s.alpha = (blendmode == AST_TRANSLUCENT) ? 0xFF : 0xFE;
|
||||
Surf.PolyFlags = HWR_GetBlendModeFlag(blendmode);
|
||||
}
|
||||
|
||||
// dont forget to enabled the depth test because we can't do this like
|
||||
// before: polygons models are not sorted
|
||||
@@ -1343,7 +1359,7 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
|
||||
p.x = FIXED_TO_FLOAT(interp.x);
|
||||
p.y = FIXED_TO_FLOAT(interp.y)+md2->offset;
|
||||
|
||||
if (spr->mobj->eflags & MFE_VERTICALFLIP)
|
||||
if (flip)
|
||||
p.z = FIXED_TO_FLOAT(interp.z + spr->mobj->height);
|
||||
else
|
||||
p.z = FIXED_TO_FLOAT(interp.z);
|
||||
@@ -1366,109 +1382,58 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
|
||||
const fixed_t anglef = AngleFixed((R_PointToAngle(interp.x, interp.y))-ANGLE_180);
|
||||
p.angley = FIXED_TO_FLOAT(anglef);
|
||||
}
|
||||
|
||||
p.rollangle = 0.0f;
|
||||
p.rollflip = 1;
|
||||
p.rotaxis = 0;
|
||||
|
||||
p.spritexscale = FIXED_TO_FLOAT(spr->mobj->spritexscale);
|
||||
p.spriteyscale = FIXED_TO_FLOAT(spr->mobj->spriteyscale);
|
||||
|
||||
angle_t sliptideroll = ((cv_sloperoll.value && cv_sliptideroll.value && spr->mobj->player) ? spr->mobj->player->sliproll : 0);
|
||||
const angle_t sliptideroll = ((cv_sliptideroll.value && spr->mobj->player) ? spr->mobj->player->sliproll : 0);
|
||||
const SINT8 flipfactor = flip ? -1 : 1;
|
||||
|
||||
if (spr->mobj->rollangle || sliptideroll)
|
||||
{
|
||||
angle_t rollang = 0;
|
||||
rollfactor = ((spr->mobj->rollmodel == true) ? 1 : 0);
|
||||
angle_t rollang = sliptideroll
|
||||
? (spr->mobj->rollangle) + (sliptideroll * spr->mobj->player->kartstuff[k_aizdriftstrat])
|
||||
: (spr->mobj->rollangle);
|
||||
|
||||
rollang = sliptideroll
|
||||
? (spr->mobj->rollangle * rollfactor) + (sliptideroll * spr->mobj->player->kartstuff[k_aizdriftstrat])
|
||||
: (spr->mobj->rollangle * rollfactor);
|
||||
|
||||
fixed_t anglef = AngleFixed(rollang);
|
||||
p.rollangle = FIXED_TO_FLOAT(anglef);
|
||||
p.rollmodel = (spr->mobj->rollmodel);
|
||||
p.roll = true;
|
||||
|
||||
// rotation pivot
|
||||
p.centerx = FIXED_TO_FLOAT(spr->mobj->radius/2)*(p.spritexscale);
|
||||
p.centery = FIXED_TO_FLOAT(spr->mobj->height/2)*(p.spriteyscale);
|
||||
p.rollangle = 0.0f;
|
||||
|
||||
// rotation axis
|
||||
if (sprinfo->available)
|
||||
p.rotaxis = (UINT8)(sprinfo->pivot[(spr->mobj->frame & FF_FRAMEMASK)].rotaxis);
|
||||
if (anglef)
|
||||
{
|
||||
fixed_t camAngleDiff = AngleFixed(viewangle) - FLOAT_TO_FIXED(p.angley); // dumb reconversion back, I know
|
||||
|
||||
// for NiGHTS specifically but should work everywhere else
|
||||
ang = R_PointToAngle (spr->mobj->x, spr->mobj->y) - (spr->mobj->player ? spr->mobj->player->frameangle : spr->mobj->angle);
|
||||
if ((sprframe->rotate & SRF_RIGHT) && (ang < ANGLE_180)) // See from right
|
||||
p.rollflip = 1;
|
||||
else if ((sprframe->rotate & SRF_LEFT) && (ang >= ANGLE_180)) // See from left
|
||||
p.rollflip = -1;
|
||||
p.rollangle = FIXED_TO_FLOAT(anglef);
|
||||
p.roll = true;
|
||||
|
||||
// rotation pivot
|
||||
if (sprinfo->available)
|
||||
{
|
||||
p.centerx = FIXED_TO_FLOAT(sprinfo->pivot[frame].x);
|
||||
p.centery = FIXED_TO_FLOAT(sprinfo->pivot[frame].y);
|
||||
}
|
||||
else
|
||||
{
|
||||
p.centerx = FIXED_TO_FLOAT(spr->mobj->radius/2);
|
||||
p.centery = FIXED_TO_FLOAT(spr->mobj->height/2);
|
||||
}
|
||||
|
||||
// rotation axes relative to camera
|
||||
p.rollx = FIXED_TO_FLOAT(FINECOSINE(FixedAngle(camAngleDiff) >> ANGLETOFINESHIFT));
|
||||
p.rollz = FIXED_TO_FLOAT(FINESINE(FixedAngle(camAngleDiff) >> ANGLETOFINESHIFT));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
p.anglex = 0.0f;
|
||||
p.anglex2 = 0.0f;
|
||||
#ifdef USE_FTRANSFORM_ANGLEZ
|
||||
// Slope rotation from Kart
|
||||
p.anglez = 0.0f;
|
||||
p.anglez2 = 0.0f;
|
||||
|
||||
// use secondary angles for the slope rotation
|
||||
if (spr->mobj->standingslope)
|
||||
{
|
||||
fixed_t tempz = spr->mobj->standingslope->normal.z;
|
||||
fixed_t tempy = spr->mobj->standingslope->normal.y;
|
||||
fixed_t tempx = spr->mobj->standingslope->normal.x;
|
||||
fixed_t tempangle = AngleFixed(R_PointToAngle2(0, 0, FixedSqrt(FixedMul(tempy, tempy) + FixedMul(tempz, tempz)), tempx));
|
||||
p.anglez2 = FIXED_TO_FLOAT(tempangle);
|
||||
tempangle = -AngleFixed(R_PointToAngle2(0, 0, tempz, tempy));
|
||||
p.anglex2 = FIXED_TO_FLOAT(tempangle);
|
||||
}
|
||||
else if ((spr->mobj->sloperoll || spr->mobj->slopepitch) && (!P_IsObjectOnGround(spr->mobj)) && (!paused))
|
||||
{
|
||||
SINT8 flipfactor = flip ? -1 : 1;
|
||||
|
||||
angle_t camang = R_PointToAngle(interp.x, interp.y);
|
||||
angle_t mobjang;
|
||||
|
||||
if (spr->mobj->flags & (MF_NOTHINK|MF_SCENERY))
|
||||
mobjang = spr->mobj->angle;
|
||||
else
|
||||
mobjang = interp.angle;
|
||||
|
||||
angle_t fmoang;
|
||||
fmoang = camang - mobjang;
|
||||
|
||||
// slopepitch
|
||||
p.anglex += flipfactor*FIXED_TO_FLOAT( AngleFixed(FixedMul(FINESINE((camang-fmoang) >> ANGLETOFINESHIFT), interp.slopepitch)) );
|
||||
p.anglez -= flipfactor*FIXED_TO_FLOAT( AngleFixed(FixedMul(FINECOSINE((camang-fmoang) >> ANGLETOFINESHIFT), interp.slopepitch)) );
|
||||
|
||||
// sloperoll
|
||||
p.anglex += flipfactor*FIXED_TO_FLOAT( AngleFixed(FixedMul(FINECOSINE((camang-fmoang) >> ANGLETOFINESHIFT), interp.sloperoll)) );
|
||||
p.anglez += flipfactor*FIXED_TO_FLOAT( AngleFixed(FixedMul(FINESINE((camang-fmoang) >> ANGLETOFINESHIFT), interp.sloperoll)) );
|
||||
p.roll = true;
|
||||
}
|
||||
// slope pitch and roll
|
||||
p.anglex += flipfactor*FIXED_TO_FLOAT(AngleFixed(interp.sloperoll));
|
||||
p.anglez -= flipfactor*FIXED_TO_FLOAT(AngleFixed(interp.slopepitch));
|
||||
|
||||
// pitch and roll
|
||||
if (interp.roll || interp.pitch)
|
||||
{
|
||||
SINT8 flipfactor = flip ? -1 : 1;
|
||||
p.anglex += flipfactor*FIXED_TO_FLOAT(AngleFixed(interp.roll));
|
||||
p.anglez -= flipfactor*FIXED_TO_FLOAT(AngleFixed(interp.pitch));
|
||||
p.roll = true;
|
||||
}
|
||||
#endif
|
||||
p.anglex += flipfactor*FIXED_TO_FLOAT(AngleFixed(interp.roll));
|
||||
p.anglez -= flipfactor*FIXED_TO_FLOAT(AngleFixed(interp.pitch));
|
||||
|
||||
p.flip = atransform.flip;
|
||||
#ifdef USE_FTRANSFORM_MIRROR
|
||||
p.mirror = atransform.mirror; // from Kart
|
||||
#endif
|
||||
|
||||
GL_SetShader(SHADER_MODEL); // model shader
|
||||
{
|
||||
SINT8 flipfactor = flip ? -1 : 1;
|
||||
|
||||
float this_scale = FIXED_TO_FLOAT(interp.scale);
|
||||
|
||||
float xs = this_scale * FIXED_TO_FLOAT(interp.spritexscale);
|
||||
|
||||
@@ -160,7 +160,7 @@ static void HWR_RenderPortalSeg(gl_portal_t* portal, SINT8 state)
|
||||
void HWR_RenderPortal(gl_portal_t* portal, gl_portal_t* rootportal, const float fpov, player_t *player, int stencil_level)
|
||||
{
|
||||
// draw portal seg to stencil buffer with increment
|
||||
HWR_SetTransform(fpov, player);
|
||||
HWR_SetTransform(fpov);
|
||||
HWR_ClearClipper();
|
||||
|
||||
HWR_SetStencilState(HWR_STENCIL_BEGIN, stencil_level);
|
||||
@@ -180,7 +180,7 @@ void HWR_RenderPortal(gl_portal_t* portal, gl_portal_t* rootportal, const float
|
||||
}
|
||||
|
||||
// remove portal seg from stencil buffer
|
||||
HWR_SetTransform(fpov, player);
|
||||
HWR_SetTransform(fpov);
|
||||
HWR_ClearClipper();
|
||||
|
||||
HWR_SetStencilState(HWR_STENCIL_REVERSE, stencil_level);
|
||||
|
||||
+12
-11
@@ -400,17 +400,18 @@ void HWR_CompileShaders(void)
|
||||
|
||||
int HWR_GetShaderFromTarget(int shader_target)
|
||||
{
|
||||
int custom_shader = gl_shadertargets[shader_target].custom_shader;
|
||||
// use custom shader if following are true
|
||||
// - custom shader exists
|
||||
// - custom shader has been compiled successfully
|
||||
// - custom shaders are enabled
|
||||
// - custom shaders are allowed by the server
|
||||
if (custom_shader != -1 && gl_shaders[custom_shader].compiled &&
|
||||
cv_glshaders.value == 1)
|
||||
return custom_shader;
|
||||
else
|
||||
return gl_shadertargets[shader_target].base_shader;
|
||||
if (cv_glshaders.value == 1)
|
||||
{
|
||||
int custom_shader = gl_shadertargets[shader_target].custom_shader;
|
||||
// use custom shader if following are true
|
||||
// - custom shader exists
|
||||
// - custom shader has been compiled successfully
|
||||
// - custom shaders are enabled
|
||||
if (custom_shader != -1 && gl_shaders[custom_shader].compiled)
|
||||
return custom_shader;
|
||||
}
|
||||
|
||||
return gl_shadertargets[shader_target].base_shader;
|
||||
}
|
||||
|
||||
static inline UINT16 HWR_FindShaderDefs(UINT16 wadnum)
|
||||
|
||||
+244
-221
@@ -109,7 +109,6 @@ static GLint min_filter = GL_LINEAR;
|
||||
static GLint mag_filter = GL_LINEAR;
|
||||
static GLint anisotropic_filter = 0;
|
||||
boolean supportMipMap = false;
|
||||
static FTransform md2_transform;
|
||||
|
||||
const GLubyte *gl_version = NULL;
|
||||
const GLubyte *gl_renderer = NULL;
|
||||
@@ -495,6 +494,10 @@ static PFNglDeleteBuffers pglDeleteBuffers;
|
||||
typedef void (APIENTRY *PFNglColorPointer) (GLint, GLenum, GLsizei, const GLvoid*);
|
||||
static PFNglColorPointer pglColorPointer;
|
||||
|
||||
/* 2.0 functions */
|
||||
typedef void (APIENTRY * PFNglBlendEquation) (GLenum mode);
|
||||
static PFNglBlendEquation pglBlendEquation;
|
||||
|
||||
/* 1.2 Parms */
|
||||
/* GL_CLAMP_TO_EDGE_EXT */
|
||||
#ifndef GL_CLAMP_TO_EDGE
|
||||
@@ -747,6 +750,9 @@ void SetupGLFunc4(void)
|
||||
pglBufferData = GetGLFunc("glBufferData");
|
||||
pglDeleteBuffers = GetGLFunc("glDeleteBuffers");
|
||||
pglColorPointer = GetGLFunc("glColorPointer");
|
||||
|
||||
/* 2.0 funcs */
|
||||
pglBlendEquation = GetGLFunc("glBlendEquation");
|
||||
|
||||
pglStencilFuncSeparate = GetGLFunc("glStencilFuncSeparate");
|
||||
pglStencilOpSeparate = GetGLFunc("glStencilOpSeparate");
|
||||
@@ -1164,7 +1170,7 @@ static void GL_Framebuffer_Delete(void)
|
||||
FramebufferObject = 0;
|
||||
}
|
||||
|
||||
inline void GL_Framebuffer_Unbind(void)
|
||||
void GL_Framebuffer_Unbind(void)
|
||||
{
|
||||
if (!supportFBO || fboinit == false)
|
||||
return;
|
||||
@@ -1176,7 +1182,7 @@ inline void GL_Framebuffer_Unbind(void)
|
||||
pglBindRenderbuffer(GL_RENDERBUFFER, 0);
|
||||
}
|
||||
|
||||
inline void GL_Framebuffer_Enable(void)
|
||||
void GL_Framebuffer_Enable(void)
|
||||
{
|
||||
if (!supportFBO || !UseScreenFBO())
|
||||
return;
|
||||
@@ -1426,7 +1432,11 @@ void GL_Draw2DLine(F2DCoord * v1, F2DCoord * v2, RGBA_t Color)
|
||||
pglEnableClientState(GL_TEXTURE_COORD_ARRAY);
|
||||
pglEnable(GL_TEXTURE_2D);
|
||||
}
|
||||
|
||||
// -----------------+
|
||||
// SetBlend : Set render mode
|
||||
// -----------------+
|
||||
// PF_Masked - we could use an ALPHA_TEST of GL_EQUAL, and alpha ref of 0,
|
||||
// is it faster when pixels are discarded ?
|
||||
static void Clamp2D(GLenum pname)
|
||||
{
|
||||
pglTexParameteri(GL_TEXTURE_2D, pname, GL_CLAMP); // fallback clamp
|
||||
@@ -1435,148 +1445,185 @@ static void Clamp2D(GLenum pname)
|
||||
#endif
|
||||
}
|
||||
|
||||
// -----------------+
|
||||
// SetBlend : Set render mode
|
||||
// -----------------+
|
||||
// PF_Masked - we could use an ALPHA_TEST of GL_EQUAL, and alpha ref of 0,
|
||||
// is it faster when pixels are discarded ?
|
||||
static void GL_SetBlendEquation(GLenum mode)
|
||||
{
|
||||
if (pglBlendEquation)
|
||||
pglBlendEquation(mode);
|
||||
}
|
||||
|
||||
static void GL_SetBlendMode(FBITFIELD flags)
|
||||
{
|
||||
// Set blending function
|
||||
switch (flags)
|
||||
{
|
||||
case PF_Translucent & PF_Blending:
|
||||
pglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // alpha = level of transparency
|
||||
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
|
||||
break;
|
||||
case PF_Additive & PF_Blending:
|
||||
case PF_Subtractive & PF_Blending:
|
||||
case PF_ReverseSubtract & PF_Blending:
|
||||
pglBlendFunc(GL_SRC_ALPHA, GL_ONE); // src * alpha + dest
|
||||
break;
|
||||
case PF_Environment & PF_Blending:
|
||||
pglBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
|
||||
break;
|
||||
case PF_Multiplicative & PF_Blending:
|
||||
pglBlendFunc(GL_DST_COLOR, GL_ZERO);
|
||||
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);
|
||||
break;
|
||||
default: // must be 0, otherwise it's an error
|
||||
// No blending
|
||||
pglBlendFunc(GL_ONE, GL_ZERO); // the same as no blending
|
||||
break;
|
||||
}
|
||||
|
||||
// Set blending equation
|
||||
switch (flags)
|
||||
{
|
||||
case PF_Subtractive & PF_Blending:
|
||||
GL_SetBlendEquation(GL_FUNC_SUBTRACT);
|
||||
break;
|
||||
case PF_ReverseSubtract & PF_Blending:
|
||||
// good for shadow
|
||||
// not really but what else ?
|
||||
GL_SetBlendEquation(GL_FUNC_REVERSE_SUBTRACT);
|
||||
break;
|
||||
default:
|
||||
GL_SetBlendEquation(GL_FUNC_ADD);
|
||||
break;
|
||||
}
|
||||
|
||||
// Alpha test
|
||||
switch (flags)
|
||||
{
|
||||
case PF_Masked & PF_Blending:
|
||||
pglAlphaFunc(GL_GREATER, 0.5f);
|
||||
break;
|
||||
case PF_Translucent & PF_Blending:
|
||||
case PF_Additive & PF_Blending:
|
||||
case PF_Subtractive & PF_Blending:
|
||||
case PF_ReverseSubtract & PF_Blending:
|
||||
case PF_Environment & PF_Blending:
|
||||
case PF_Multiplicative & PF_Blending:
|
||||
pglAlphaFunc(GL_NOTEQUAL, 0.0f);
|
||||
break;
|
||||
case PF_Fog & PF_Fog:
|
||||
pglAlphaFunc(GL_ALWAYS, 0.0f); // Don't discard zero alpha fragments
|
||||
break;
|
||||
default:
|
||||
pglAlphaFunc(GL_GREATER, 0.5f);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void GL_SetBlend(FBITFIELD PolyFlags)
|
||||
{
|
||||
const FBITFIELD Xor = (CurrentPolyFlags ^ PolyFlags);
|
||||
const FBITFIELD Xor = CurrentPolyFlags^PolyFlags;;
|
||||
|
||||
if (!(Xor & (PF_Blending|PF_RemoveYWrap|PF_ForceWrapX|PF_ForceWrapY|PF_Occlude|PF_NoTexture|PF_Modulated|PF_NoDepthTest|PF_Decal|PF_Invisible|PF_NoAlphaTest)))
|
||||
if (Xor & (PF_Blending|PF_RemoveYWrap|PF_ForceWrapX|PF_ForceWrapY|PF_Occlude|PF_NoTexture|PF_Modulated|PF_NoDepthTest|PF_Decal|PF_Invisible))
|
||||
{
|
||||
CurrentPolyFlags = PolyFlags;
|
||||
return;
|
||||
}
|
||||
if (Xor & PF_Blending) // if blending mode must be changed
|
||||
GL_SetBlendMode(PolyFlags & PF_Blending);
|
||||
|
||||
if (Xor & PF_Blending) // if blending mode must be changed
|
||||
{
|
||||
switch (PolyFlags & PF_Blending)
|
||||
if (Xor & PF_NoAlphaTest)
|
||||
{
|
||||
case (PF_Translucent & PF_Blending):
|
||||
pglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // alpha = level of transparency
|
||||
pglAlphaFunc(GL_NOTEQUAL, 0.0f);
|
||||
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
|
||||
pglAlphaFunc(GL_GREATER, 0.5f);
|
||||
break;
|
||||
case (PF_Additive & PF_Blending):
|
||||
pglBlendFunc(GL_SRC_ALPHA, GL_ONE); // src * alpha + dest
|
||||
pglAlphaFunc(GL_NOTEQUAL, 0.0f);
|
||||
break;
|
||||
case (PF_Environment & PF_Blending):
|
||||
pglBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
|
||||
pglAlphaFunc(GL_NOTEQUAL, 0.0f);
|
||||
break;
|
||||
case (PF_Substractive & PF_Blending):
|
||||
// good for shadow
|
||||
// not really but what else ?
|
||||
pglBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
|
||||
pglAlphaFunc(GL_NOTEQUAL, 0.0f);
|
||||
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);
|
||||
pglAlphaFunc(GL_ALWAYS, 0.0f); // Don't discard zero alpha fragments
|
||||
break;
|
||||
default : // must be 0, otherwise it's an error
|
||||
// No blending
|
||||
pglBlendFunc(GL_ONE, GL_ZERO); // the same as no blending
|
||||
pglAlphaFunc(GL_GREATER, 0.5f);
|
||||
break;
|
||||
if (PolyFlags & PF_NoAlphaTest)
|
||||
pglDisable(GL_ALPHA_TEST);
|
||||
else
|
||||
pglEnable(GL_ALPHA_TEST); // discard 0 alpha pixels (holes in texture)
|
||||
}
|
||||
}
|
||||
|
||||
if (Xor & PF_NoAlphaTest)
|
||||
{
|
||||
if (PolyFlags & PF_NoAlphaTest)
|
||||
pglDisable(GL_ALPHA_TEST);
|
||||
else
|
||||
pglEnable(GL_ALPHA_TEST); // discard 0 alpha pixels (holes in texture)
|
||||
}
|
||||
if (Xor & PF_Decal)
|
||||
{
|
||||
if (PolyFlags & PF_Decal)
|
||||
pglEnable(GL_POLYGON_OFFSET_FILL);
|
||||
else
|
||||
pglDisable(GL_POLYGON_OFFSET_FILL);
|
||||
}
|
||||
|
||||
if (Xor & PF_Decal)
|
||||
{
|
||||
if (PolyFlags & PF_Decal)
|
||||
pglEnable(GL_POLYGON_OFFSET_FILL);
|
||||
else
|
||||
pglDisable(GL_POLYGON_OFFSET_FILL);
|
||||
}
|
||||
if (Xor & PF_NoDepthTest)
|
||||
{
|
||||
if (PolyFlags & PF_NoDepthTest)
|
||||
pglDepthFunc(GL_ALWAYS); //pglDisable(GL_DEPTH_TEST);
|
||||
else
|
||||
pglDepthFunc(GL_LEQUAL); //pglEnable(GL_DEPTH_TEST);
|
||||
}
|
||||
if (Xor & PF_NoDepthTest)
|
||||
{
|
||||
if (PolyFlags & PF_NoDepthTest)
|
||||
pglDepthFunc(GL_ALWAYS); //pglDisable(GL_DEPTH_TEST);
|
||||
else
|
||||
pglDepthFunc(GL_LEQUAL); //pglEnable(GL_DEPTH_TEST);
|
||||
}
|
||||
|
||||
if (Xor & PF_RemoveYWrap)
|
||||
{
|
||||
if (PolyFlags & PF_RemoveYWrap)
|
||||
Clamp2D(GL_TEXTURE_WRAP_T);
|
||||
}
|
||||
if (Xor & PF_RemoveYWrap)
|
||||
{
|
||||
if (PolyFlags & PF_RemoveYWrap)
|
||||
Clamp2D(GL_TEXTURE_WRAP_T);
|
||||
}
|
||||
|
||||
if (Xor & PF_ForceWrapX)
|
||||
{
|
||||
if (PolyFlags & PF_ForceWrapX)
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
|
||||
}
|
||||
if (Xor & PF_ForceWrapX)
|
||||
{
|
||||
if (PolyFlags & PF_ForceWrapX)
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
|
||||
}
|
||||
|
||||
if (Xor & PF_ForceWrapY)
|
||||
{
|
||||
if (PolyFlags & PF_ForceWrapY)
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
|
||||
}
|
||||
if (Xor & PF_ForceWrapY)
|
||||
{
|
||||
if (PolyFlags & PF_ForceWrapY)
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
|
||||
}
|
||||
|
||||
if (Xor & PF_Modulated)
|
||||
{
|
||||
if (Xor & PF_Modulated)
|
||||
{
|
||||
#if defined (__unix__) || defined (UNIXCOMMON)
|
||||
if (oglflags & GLF_NOTEXENV)
|
||||
{
|
||||
if (!(PolyFlags & PF_Modulated))
|
||||
pglColor4ubv(white);
|
||||
}
|
||||
else
|
||||
if (oglflags & GLF_NOTEXENV)
|
||||
{
|
||||
if (!(PolyFlags & PF_Modulated))
|
||||
pglColor4ubv(white);
|
||||
}
|
||||
else
|
||||
#endif
|
||||
if (PolyFlags & PF_Modulated)
|
||||
{ // mix texture colour with Surface->PolyColor
|
||||
pglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
|
||||
}
|
||||
else
|
||||
{ // colour from texture is unchanged before blending
|
||||
pglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
|
||||
}
|
||||
}
|
||||
|
||||
// mix texture colour with Surface->PolyColor
|
||||
if (PolyFlags & PF_Modulated)
|
||||
pglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
|
||||
// colour from texture is unchanged before blending
|
||||
else
|
||||
pglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
|
||||
}
|
||||
|
||||
if (Xor & PF_Occlude) // depth test but (no) depth write
|
||||
{
|
||||
if (PolyFlags & PF_Occlude)
|
||||
pglDepthMask(1);
|
||||
else
|
||||
pglDepthMask(0);
|
||||
}
|
||||
|
||||
////Hurdler: not used if we don't define POLYSKY
|
||||
if (Xor & PF_Invisible)
|
||||
{
|
||||
if (PolyFlags&PF_Invisible)
|
||||
pglBlendFunc(GL_ZERO, GL_ONE); // transparent blending
|
||||
else
|
||||
{ // big hack: (TODO: manage that better)
|
||||
// we test only for PF_Masked because PF_Invisible is only used
|
||||
// (for now) with it (yeah, that's crappy, sorry)
|
||||
if ((PolyFlags & PF_Blending) == PF_Masked)
|
||||
pglBlendFunc(GL_SRC_ALPHA, GL_ZERO);
|
||||
if (Xor & PF_Occlude) // depth test but (no) depth write
|
||||
{
|
||||
if (PolyFlags&PF_Occlude)
|
||||
{
|
||||
pglDepthMask(1);
|
||||
}
|
||||
else
|
||||
pglDepthMask(0);
|
||||
}
|
||||
////Hurdler: not used if we don't define POLYSKY
|
||||
if (Xor & PF_Invisible)
|
||||
{
|
||||
if (PolyFlags&PF_Invisible)
|
||||
pglBlendFunc(GL_ZERO, GL_ONE); // transparent blending
|
||||
else
|
||||
{ // big hack: (TODO: manage that better)
|
||||
// we test only for PF_Masked because PF_Invisible is only used
|
||||
// (for now) with it (yeah, that's crappy, sorry)
|
||||
if ((PolyFlags&PF_Blending)==PF_Masked)
|
||||
pglBlendFunc(GL_SRC_ALPHA, GL_ZERO);
|
||||
}
|
||||
}
|
||||
if (PolyFlags & PF_NoTexture)
|
||||
{
|
||||
GL_SetNoTexture();
|
||||
}
|
||||
}
|
||||
|
||||
if (PolyFlags & PF_NoTexture)
|
||||
GL_SetNoTexture();
|
||||
|
||||
CurrentPolyFlags = PolyFlags;
|
||||
}
|
||||
|
||||
@@ -1604,6 +1651,7 @@ static void GL_UpdateTexture(GLMipmap_t *pTexInfo)
|
||||
|
||||
INT32 w = pTexInfo->width, h = pTexInfo->height;
|
||||
INT32 i, j;
|
||||
INT32 idx;
|
||||
|
||||
const GLubyte *pImgData = (const GLubyte *)pTexInfo->data;
|
||||
const GLvoid *ptex = NULL;
|
||||
@@ -1632,18 +1680,13 @@ static void GL_UpdateTexture(GLMipmap_t *pTexInfo)
|
||||
|
||||
const int chromakeyed = (pTexInfo->flags & TF_CHROMAKEYED);
|
||||
|
||||
for (j = 0; j < h; j++)
|
||||
for (idx = 0, j = 0; j < h; j++)
|
||||
{
|
||||
for (i = 0; i < w; i++)
|
||||
for (i = 0; i < w; i++, idx++)
|
||||
{
|
||||
int idx = (w*j+i);
|
||||
|
||||
if (chromakeyed && (*pImgData == HWR_PATCHES_CHROMAKEY_COLORINDEX))
|
||||
{
|
||||
tex[idx].s.red = 0;
|
||||
tex[idx].s.green = 0;
|
||||
tex[idx].s.blue = 0;
|
||||
tex[idx].s.alpha = 0;
|
||||
tex[idx].s = (byteColor_t){0, 0, 0, 0};
|
||||
pTexInfo->flags |= TF_TRANSPARENT; // there is a hole in it
|
||||
}
|
||||
else
|
||||
@@ -1672,12 +1715,10 @@ static void GL_UpdateTexture(GLMipmap_t *pTexInfo)
|
||||
ptex = tex = textureBuffer;
|
||||
texformat = GL_LUMINANCE_ALPHA;
|
||||
|
||||
for (j = 0; j < h; j++)
|
||||
for (idx = 0, j = 0; j < h; j++)
|
||||
{
|
||||
for (i = 0; i < w; i++)
|
||||
for (i = 0; i < w; i++, idx++)
|
||||
{
|
||||
int idx = (w*j+i);
|
||||
|
||||
tex[idx].s.red = *pImgData;
|
||||
tex[idx].s.green = *pImgData;
|
||||
tex[idx].s.blue = *pImgData;
|
||||
@@ -1692,17 +1733,13 @@ static void GL_UpdateTexture(GLMipmap_t *pTexInfo)
|
||||
ptex = tex = textureBuffer;
|
||||
texformat = GL_ALPHA;
|
||||
|
||||
for (j = 0; j < h; j++)
|
||||
{
|
||||
for (i = 0; i < w; i++)
|
||||
{
|
||||
int idx = (w*j+i);
|
||||
memset(&tex->s, 255, sizeof(byteColor_t)*w*h); // 255 because the fade mask is modulated with the screen texture, so alpha affects it while the colours don't
|
||||
|
||||
tex[idx].s.red = 255; // 255 because the fade mask is modulated with the screen texture, so alpha affects it while the colours don't
|
||||
tex[idx].s.green = 255;
|
||||
tex[idx].s.blue = 255;
|
||||
tex[idx].s.alpha = *pImgData;
|
||||
pImgData++;
|
||||
for (idx = 0, j = 0; j < h; j++)
|
||||
{
|
||||
for (i = 0; i < w; i++, idx++)
|
||||
{
|
||||
tex[idx].s.alpha = *pImgData++;
|
||||
}
|
||||
}
|
||||
break;
|
||||
@@ -2596,14 +2633,11 @@ void GL_DrawModelEx(model_t *model, INT32 frameIndex, float duration, float tics
|
||||
poly.green = byte2float[Surface->PolyColor.s.green];
|
||||
poly.blue = byte2float[Surface->PolyColor.s.blue];
|
||||
poly.alpha = byte2float[Surface->PolyColor.s.alpha];
|
||||
|
||||
if (poly.alpha < 1)
|
||||
GL_SetBlend(PF_Translucent|PF_Modulated);
|
||||
else
|
||||
GL_SetBlend(PF_Masked|PF_Modulated|PF_Occlude);
|
||||
|
||||
|
||||
pglColor4ubv((GLubyte*)&Surface->PolyColor.s);
|
||||
|
||||
GL_SetBlend((poly.alpha < 1 ? Surface->PolyFlags : (PF_Masked|PF_Occlude))|PF_Modulated);
|
||||
|
||||
tint.red = byte2float[Surface->TintColor.s.red];
|
||||
tint.green = byte2float[Surface->TintColor.s.green];
|
||||
tint.blue = byte2float[Surface->TintColor.s.blue];
|
||||
@@ -2627,7 +2661,6 @@ void GL_DrawModelEx(model_t *model, INT32 frameIndex, float duration, float tics
|
||||
pglEnable(GL_CULL_FACE);
|
||||
pglEnable(GL_NORMALIZE);
|
||||
|
||||
#ifdef USE_FTRANSFORM_MIRROR
|
||||
// flipped is if the object is vertically flipped
|
||||
// hflipped is if the object is horizontally flipped
|
||||
// pos->flip is if the screen is flipped vertically
|
||||
@@ -2640,13 +2673,6 @@ void GL_DrawModelEx(model_t *model, INT32 frameIndex, float duration, float tics
|
||||
else
|
||||
pglCullFace(GL_BACK);
|
||||
}
|
||||
#else
|
||||
// pos->flip is if the screen is flipped too
|
||||
if (flipped ^ hflipped ^ pos->flip) // If one or three of these are active, but not two, invert the model's culling
|
||||
pglCullFace(GL_FRONT);
|
||||
else
|
||||
pglCullFace(GL_BACK);
|
||||
#endif
|
||||
|
||||
pglPushMatrix(); // should be the same as glLoadIdentity
|
||||
pglTranslatef(pos->x, pos->z, pos->y);
|
||||
@@ -2654,30 +2680,15 @@ void GL_DrawModelEx(model_t *model, INT32 frameIndex, float duration, float tics
|
||||
scaley = -scaley;
|
||||
if (hflipped)
|
||||
scalez = -scalez;
|
||||
#ifdef USE_FTRANSFORM_ANGLEZ
|
||||
pglRotatef(pos->anglez2, 0.0f, 0.0f, -1.0f); // rotate by slope from Kart
|
||||
#endif
|
||||
pglRotatef(pos->anglex2, -1.0f, 0.0f, 0.0f);
|
||||
|
||||
pglRotatef(pos->anglez, 0.0f, 0.0f, -1.0f);
|
||||
pglRotatef(pos->anglex, 1.0f, 0.0f, 0.0f);
|
||||
pglRotatef(pos->angley, 0.0f, -1.0f, 0.0f);
|
||||
|
||||
if (pos->roll)
|
||||
{
|
||||
float roll = (1.0f * pos->rollflip);
|
||||
pglTranslatef(pos->centerx, pos->centery, 0);
|
||||
|
||||
// rotate model for pitch and roll
|
||||
pglRotatef(pos->anglex, 1.0f, 0.0f, 0.0f);
|
||||
#ifdef USE_FTRANSFORM_ANGLEZ
|
||||
pglRotatef(pos->anglez, 0.0f, 0.0f, -1.0f);
|
||||
#endif
|
||||
|
||||
if (pos->rotaxis == 2) // Z
|
||||
pglRotatef(pos->rollangle, 0.0f, 0.0f, roll);
|
||||
else if (pos->rotaxis == 1) // Y
|
||||
pglRotatef(pos->rollangle, 0.0f, roll, 0.0f);
|
||||
else // X
|
||||
pglRotatef(pos->rollangle, roll, 0.0f, 0.0f);
|
||||
|
||||
pglRotatef(pos->rollangle, pos->rollx, 0.0f, pos->rollz);
|
||||
pglTranslatef(-pos->centerx, -pos->centery, 0);
|
||||
}
|
||||
|
||||
@@ -2800,20 +2811,14 @@ void GL_SetTransform(FTransform *stransform)
|
||||
|
||||
if (stransform)
|
||||
{
|
||||
used_fov = stransform->fovxangle;
|
||||
used_fov = stransform->fovangle;
|
||||
shearing = stransform->shearing;
|
||||
// keep a trace of the transformation for md2
|
||||
memcpy(&md2_transform, stransform, sizeof (md2_transform));
|
||||
|
||||
#ifdef USE_FTRANSFORM_MIRROR
|
||||
// mirroring from Kart
|
||||
if (stransform->mirror)
|
||||
pglScalef(-stransform->scalex, stransform->scaley, -stransform->scalez);
|
||||
else if (stransform->mirrorflip)
|
||||
pglScalef(-stransform->scalex, -stransform->scaley, -stransform->scalez);
|
||||
else
|
||||
#endif
|
||||
if (stransform->flip)
|
||||
else if (stransform->flip)
|
||||
pglScalef(stransform->scalex, -stransform->scaley, -stransform->scalez);
|
||||
else
|
||||
pglScalef(stransform->scalex, stransform->scaley, -stransform->scalez);
|
||||
@@ -2891,7 +2896,7 @@ void GL_PostImgRedraw(float points[SCREENVERTS][SCREENVERTS][2])
|
||||
INT32 x, y;
|
||||
float float_x, float_y, float_nextx, float_nexty;
|
||||
float xfix, yfix;
|
||||
INT32 texsize = 512;
|
||||
INT32 texsizew = 512, texsizey = 512;
|
||||
|
||||
const float blackBack[16] =
|
||||
{
|
||||
@@ -2905,12 +2910,15 @@ void GL_PostImgRedraw(float points[SCREENVERTS][SCREENVERTS][2])
|
||||
return;
|
||||
|
||||
// look for power of two that is large enough for the screen
|
||||
while (texsize < screen_width || texsize < screen_height)
|
||||
texsize <<= 1;
|
||||
while (texsizew < screen_width)
|
||||
texsizew <<= 1;
|
||||
|
||||
while (texsizey < screen_height)
|
||||
texsizey <<= 1;
|
||||
|
||||
// X/Y stretch fix for all resolutions(!)
|
||||
xfix = (float)(texsize)/((float)((screen_width)/(float)(SCREENVERTS-1)));
|
||||
yfix = (float)(texsize)/((float)((screen_height)/(float)(SCREENVERTS-1)));
|
||||
xfix = (float)(texsizew)/((float)((screen_width)/(float)(SCREENVERTS-1)));
|
||||
yfix = (float)(texsizey)/((float)((screen_height)/(float)(SCREENVERTS-1)));
|
||||
|
||||
pglDisable(GL_DEPTH_TEST);
|
||||
pglDisable(GL_BLEND);
|
||||
@@ -2983,7 +2991,7 @@ void GL_FlushScreenTextures(void)
|
||||
void GL_DrawScreenTexture(int tex, FSurfaceInfo *surf, FBITFIELD polyflags)
|
||||
{
|
||||
float xfix, yfix;
|
||||
INT32 texsize = 512;
|
||||
INT32 texsizew = 512, texsizey = 512;
|
||||
|
||||
const float screenVerts[12] =
|
||||
{
|
||||
@@ -2999,11 +3007,14 @@ void GL_DrawScreenTexture(int tex, FSurfaceInfo *surf, FBITFIELD polyflags)
|
||||
return;
|
||||
|
||||
// look for power of two that is large enough for the screen
|
||||
while (texsize < screen_width || texsize < screen_height)
|
||||
texsize <<= 1;
|
||||
while (texsizew < screen_width)
|
||||
texsizew <<= 1;
|
||||
|
||||
xfix = 1/((float)(texsize)/((float)((screen_width))));
|
||||
yfix = 1/((float)(texsize)/((float)((screen_height))));
|
||||
while (texsizey < screen_height)
|
||||
texsizey <<= 1;
|
||||
|
||||
xfix = 1/((float)(texsizew)/((float)((screen_width))));
|
||||
yfix = 1/((float)(texsizey)/((float)((screen_height))));
|
||||
|
||||
// const float screenVerts[12]
|
||||
|
||||
@@ -3036,7 +3047,7 @@ void GL_DrawScreenTexture(int tex, FSurfaceInfo *surf, FBITFIELD polyflags)
|
||||
// Do screen fades!
|
||||
void GL_DoScreenWipe(int wipeStart, int wipeEnd)
|
||||
{
|
||||
INT32 texsize = 512;
|
||||
INT32 texsizew = 512, texsizey = 512;
|
||||
float xfix, yfix;
|
||||
|
||||
INT32 fademaskdownloaded = tex_downloaded; // the fade mask that has been set
|
||||
@@ -3063,11 +3074,14 @@ void GL_DoScreenWipe(int wipeStart, int wipeEnd)
|
||||
return;
|
||||
|
||||
// look for power of two that is large enough for the screen
|
||||
while (texsize < screen_width || texsize < screen_height)
|
||||
texsize <<= 1;
|
||||
while (texsizew < screen_width)
|
||||
texsizew <<= 1;
|
||||
|
||||
xfix = 1/((float)(texsize)/((float)((screen_width))));
|
||||
yfix = 1/((float)(texsize)/((float)((screen_height))));
|
||||
while (texsizey < screen_height)
|
||||
texsizey <<= 1;
|
||||
|
||||
xfix = 1/((float)(texsizew)/((float)((screen_width))));
|
||||
yfix = 1/((float)(texsizey)/((float)((screen_height))));
|
||||
|
||||
// const float screenVerts[12]
|
||||
|
||||
@@ -3127,7 +3141,7 @@ void GL_DoScreenWipe(int wipeStart, int wipeEnd)
|
||||
|
||||
void GL_RenderVhsEffect(fixed_t upbary, fixed_t downbary, UINT8 updistort, UINT8 downdistort, UINT8 barsize)
|
||||
{
|
||||
INT32 texsize = 512;
|
||||
INT32 texsizew = 512, texsizey = 512;
|
||||
int tex = HWD_SCREENTEXTURE_VHS;
|
||||
float xfix, yfix;
|
||||
float fix[8];
|
||||
@@ -3146,11 +3160,14 @@ void GL_RenderVhsEffect(fixed_t upbary, fixed_t downbary, UINT8 updistort, UINT8
|
||||
return;
|
||||
|
||||
// look for power of two that is large enough for the screen
|
||||
while (texsize < screen_width || texsize < screen_height)
|
||||
texsize <<= 1;
|
||||
while (texsizew < screen_width)
|
||||
texsizew <<= 1;
|
||||
|
||||
xfix = 1/((float)(texsize)/((float)((screen_width))));
|
||||
yfix = 1/((float)(texsize)/((float)((screen_height))));
|
||||
while (texsizey < screen_height)
|
||||
texsizey <<= 1;
|
||||
|
||||
xfix = 1/((float)(texsizew)/((float)((screen_width))));
|
||||
yfix = 1/((float)(texsizey)/((float)((screen_height))));
|
||||
|
||||
// Slight fuzziness
|
||||
GL_MakeScreenTexture(tex);
|
||||
@@ -3234,15 +3251,18 @@ void GL_RenderVhsEffect(fixed_t upbary, fixed_t downbary, UINT8 updistort, UINT8
|
||||
// Create a texture from the screen.
|
||||
void GL_MakeScreenTexture(int tex)
|
||||
{
|
||||
INT32 texsize = 512;
|
||||
INT32 texsizew = 512, texsizey = 512;
|
||||
boolean firstTime = (screenTextures[tex] == 0);
|
||||
|
||||
if (!gl_enable_screen_textures)
|
||||
return;
|
||||
|
||||
// look for power of two that is large enough for the screen
|
||||
while (texsize < screen_width || texsize < screen_height)
|
||||
texsize <<= 1;
|
||||
while (texsizew < screen_width)
|
||||
texsizew <<= 1;
|
||||
|
||||
while (texsizey < screen_height)
|
||||
texsizey <<= 1;
|
||||
|
||||
// Create screen texture
|
||||
if (firstTime)
|
||||
@@ -3255,10 +3275,10 @@ void GL_MakeScreenTexture(int tex)
|
||||
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||||
Clamp2D(GL_TEXTURE_WRAP_S);
|
||||
Clamp2D(GL_TEXTURE_WRAP_T);
|
||||
pglCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, texsize, texsize, 0);
|
||||
pglCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, texsizew, texsizey, 0);
|
||||
}
|
||||
else
|
||||
pglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, texsize, texsize);
|
||||
pglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, texsizew, texsizey);
|
||||
|
||||
tex_downloaded = screenTextures[tex];
|
||||
}
|
||||
@@ -3269,7 +3289,7 @@ void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height, boolean usesh
|
||||
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 = 512;
|
||||
INT32 texsizew = 512, texsizey = 512;
|
||||
|
||||
float off[12];
|
||||
float fix[8];
|
||||
@@ -3278,11 +3298,14 @@ void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height, boolean usesh
|
||||
return;
|
||||
|
||||
// look for power of two that is large enough for the screen
|
||||
while (texsize < screen_width || texsize < screen_height)
|
||||
texsize <<= 1;
|
||||
while (texsizew < screen_width)
|
||||
texsizew <<= 1;
|
||||
|
||||
xfix = 1/((float)(texsize)/((float)((screen_width))));
|
||||
yfix = 1/((float)(texsize)/((float)((screen_height))));
|
||||
while (texsizey < screen_height)
|
||||
texsizey <<= 1;
|
||||
|
||||
xfix = 1/((float)(texsizew)/((float)((screen_width))));
|
||||
yfix = 1/((float)(texsizey)/((float)((screen_height))));
|
||||
|
||||
origaspect = (float)screen_width / screen_height;
|
||||
newaspect = (float)width / height;
|
||||
@@ -3339,7 +3362,7 @@ void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height, boolean usesh
|
||||
pglVertexPointer(3, GL_FLOAT, 0, off);
|
||||
|
||||
pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
|
||||
|
||||
|
||||
if (useshader)
|
||||
pglUseProgram(0);
|
||||
|
||||
|
||||
+104
-116
@@ -26,6 +26,7 @@
|
||||
#include "i_video.h"
|
||||
#include "i_system.h"
|
||||
|
||||
#include "r_fps.h"
|
||||
#include "st_stuff.h" // ST_HEIGHT
|
||||
#include "r_local.h"
|
||||
|
||||
@@ -69,7 +70,6 @@ patch_t *hu_font[HU_FONTSIZE];
|
||||
patch_t *kart_font[KART_FONTSIZE]; // SRB2kart
|
||||
patch_t *tny_font[HU_FONTSIZE];
|
||||
patch_t *tallnum[10]; // 0-9
|
||||
patch_t *nightsnum[10]; // 0-9
|
||||
|
||||
// Level title and credits fonts
|
||||
patch_t *lt_font[LT_FONTSIZE];
|
||||
@@ -100,24 +100,8 @@ patch_t *rflagico;
|
||||
patch_t *bflagico;
|
||||
patch_t *rmatcico;
|
||||
patch_t *bmatcico;
|
||||
patch_t *tagico;
|
||||
patch_t *tallminus;
|
||||
|
||||
//-------------------------------------------
|
||||
// coop hud
|
||||
//-------------------------------------------
|
||||
|
||||
patch_t *emeraldpics[7];
|
||||
patch_t *tinyemeraldpics[7];
|
||||
static patch_t *emblemicon;
|
||||
static patch_t *tokenicon;
|
||||
|
||||
//-------------------------------------------
|
||||
// misc vars
|
||||
//-------------------------------------------
|
||||
|
||||
// crosshair 0 = off, 1 = cross, 2 = angle, 3 = point, see m_menu.c
|
||||
static patch_t *crosshair[HU_CROSSHAIRS]; // 3 precached crosshair graphics
|
||||
// song credits
|
||||
static patch_t *songcreditbg;
|
||||
|
||||
@@ -381,8 +365,6 @@ void HU_LoadGraphics(void)
|
||||
{
|
||||
sprintf(buffer, "STTNUM%d", i);
|
||||
tallnum[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX);
|
||||
sprintf(buffer, "NGTNUM%d", i);
|
||||
nightsnum[i] = (patch_t *) W_CachePatchName(buffer, PU_HUDGFX);
|
||||
sprintf(buffer, "PINGN%d", i);
|
||||
pingnum[i] = (patch_t *) W_CachePatchName(buffer, PU_HUDGFX);
|
||||
sprintf(buffer, "OPPRNK0%d", i);
|
||||
@@ -392,32 +374,6 @@ void HU_LoadGraphics(void)
|
||||
// minus for negative tallnums
|
||||
tallminus = (patch_t *)W_CachePatchName("STTMINUS", PU_HUDGFX);
|
||||
|
||||
// cache the crosshairs, don't bother to know which one is being used,
|
||||
// just cache all 3, they're so small anyway.
|
||||
for (i = 0; i < HU_CROSSHAIRS; i++)
|
||||
{
|
||||
sprintf(buffer, "CROSHAI%c", '1'+i);
|
||||
crosshair[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX);
|
||||
}
|
||||
|
||||
emblemicon = W_CachePatchName("EMBLICON", PU_HUDGFX);
|
||||
tokenicon = W_CachePatchName("TOKNICON", PU_HUDGFX);
|
||||
|
||||
emeraldpics[0] = W_CachePatchName("CHAOS1", PU_HUDGFX);
|
||||
emeraldpics[1] = W_CachePatchName("CHAOS2", PU_HUDGFX);
|
||||
emeraldpics[2] = W_CachePatchName("CHAOS3", PU_HUDGFX);
|
||||
emeraldpics[3] = W_CachePatchName("CHAOS4", PU_HUDGFX);
|
||||
emeraldpics[4] = W_CachePatchName("CHAOS5", PU_HUDGFX);
|
||||
emeraldpics[5] = W_CachePatchName("CHAOS6", PU_HUDGFX);
|
||||
emeraldpics[6] = W_CachePatchName("CHAOS7", PU_HUDGFX);
|
||||
tinyemeraldpics[0] = W_CachePatchName("TEMER1", PU_HUDGFX);
|
||||
tinyemeraldpics[1] = W_CachePatchName("TEMER2", PU_HUDGFX);
|
||||
tinyemeraldpics[2] = W_CachePatchName("TEMER3", PU_HUDGFX);
|
||||
tinyemeraldpics[3] = W_CachePatchName("TEMER4", PU_HUDGFX);
|
||||
tinyemeraldpics[4] = W_CachePatchName("TEMER5", PU_HUDGFX);
|
||||
tinyemeraldpics[5] = W_CachePatchName("TEMER6", PU_HUDGFX);
|
||||
tinyemeraldpics[6] = W_CachePatchName("TEMER7", PU_HUDGFX);
|
||||
|
||||
songcreditbg = W_CachePatchName("K_SONGCR", PU_HUDGFX);
|
||||
|
||||
// cache ping gfx:
|
||||
@@ -1198,7 +1154,7 @@ void HU_Ticker(void)
|
||||
|| hu_redownloadinggamestate
|
||||
#endif
|
||||
)
|
||||
resynch_ticker++; //tic tic tic tic tic
|
||||
resynch_ticker++; //tic tic tic tic tic
|
||||
|
||||
HU_TickSongCredits();
|
||||
}
|
||||
@@ -2231,7 +2187,7 @@ void HU_DrawSongCredits(void)
|
||||
//
|
||||
void HU_Drawer(void)
|
||||
{
|
||||
if (cv_vhseffect.value && (paused || (demo.playback && cv_playbackspeed.value > 1)))
|
||||
if (cv_vhseffect.value && ((paused && !camera[R_GetViewNumber()].freecam) || (demo.playback && cv_playbackspeed.value > 1)))
|
||||
V_DrawVhsEffect(demo.rewinding);
|
||||
|
||||
#ifndef NONET
|
||||
@@ -2289,22 +2245,6 @@ void HU_Drawer(void)
|
||||
if (gamestate != GS_LEVEL)
|
||||
return;
|
||||
|
||||
// draw the crosshair, not when viewing demos nor with chasecam
|
||||
/*if (!automapactive && !demo.playback)
|
||||
{
|
||||
if (cv_crosshair.value && !camera[0].chase && !players[displayplayers[0]].spectator)
|
||||
HU_DrawCrosshair();
|
||||
|
||||
if (cv_crosshair2.value && !camera[1].chase && !players[displayplayers[1]].spectator)
|
||||
HU_DrawCrosshair2();
|
||||
|
||||
if (cv_crosshair3.value && !camera[2].chase && !players[displayplayers[2]].spectator)
|
||||
HU_DrawCrosshair3();
|
||||
|
||||
if (cv_crosshair4.value && !camera[3].chase && !players[displayplayers[3]].spectator)
|
||||
HU_DrawCrosshair4();
|
||||
}*/
|
||||
|
||||
// draw song credits
|
||||
if (cv_songcredits.value)
|
||||
HU_DrawSongCredits();
|
||||
@@ -2416,92 +2356,138 @@ Ping_gfx_num (int lag)
|
||||
return 4;
|
||||
}
|
||||
|
||||
static int
|
||||
Ping_gfx_color (int lag)
|
||||
{
|
||||
if (lag < 2)
|
||||
return SKINCOLOR_JAWZ;
|
||||
else if (lag < 4)
|
||||
return SKINCOLOR_MINT;
|
||||
else if (lag < 7)
|
||||
return SKINCOLOR_GOLD;
|
||||
else if (lag < 10)
|
||||
return SKINCOLOR_RED;
|
||||
else
|
||||
return SKINCOLOR_WHITE; // SKINCOLOR_MAGENTA
|
||||
}
|
||||
|
||||
static const UINT8 *
|
||||
Ping_gfx_colormap (UINT32 lag, boolean gentleman)
|
||||
{
|
||||
const UINT8 *colormap = NULL;
|
||||
|
||||
if (K_UseColorHud())
|
||||
colormap = R_GetTranslationColormap(TC_RAINBOW, Ping_gfx_color(lag), GTC_CACHE);
|
||||
|
||||
if (servermaxping && lag > servermaxping && hu_tick < 4)
|
||||
{
|
||||
// flash ping red if too high
|
||||
colormap = R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_RASPBERRY, GTC_CACHE);
|
||||
}
|
||||
else if (gentleman)
|
||||
{
|
||||
colormap = R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_PASTEL, GTC_CACHE);
|
||||
}
|
||||
|
||||
return colormap;
|
||||
}
|
||||
|
||||
static UINT32
|
||||
Ping_conversion (UINT32 lag)
|
||||
{
|
||||
if (cv_pingmeasurement.value)
|
||||
{
|
||||
lag = (INT32)(lag * (1000.00f / TICRATE));
|
||||
}
|
||||
|
||||
return lag;
|
||||
}
|
||||
|
||||
//
|
||||
// HU_drawPing
|
||||
//
|
||||
|
||||
void HU_drawPing(INT32 x, INT32 y, UINT32 lag, INT32 flags)
|
||||
void HU_drawPlayerPing(INT32 x, INT32 y, INT32 pnum, INT32 flags)
|
||||
{
|
||||
UINT8 *colormap = NULL;
|
||||
INT32 measureid = cv_pingmeasurement.value ? 1 : 0;
|
||||
INT32 gfxnum; // gfx to draw
|
||||
|
||||
|
||||
//SRB2/Kart v1.0 style
|
||||
UINT8 numbars = 0; // how many ping bars do we draw?
|
||||
UINT8 barcolor = 31; // color we use for the bars (green, yellow, red or black)
|
||||
SINT8 i = 0;
|
||||
SINT8 yoffset = 6;
|
||||
//INT32 dx;
|
||||
|
||||
gfxnum = Ping_gfx_num(lag);
|
||||
|
||||
if (!cv_pingstyle.value)
|
||||
UINT32 lag = playerpingtable[pnum];
|
||||
const boolean gentleman = (cv_mindelay.value && (lag < (tic_t)simulated_lag));
|
||||
|
||||
if (gentleman)
|
||||
{
|
||||
lag = simulated_lag;
|
||||
}
|
||||
|
||||
if (cv_pingstyle.value == 0) // kart
|
||||
{
|
||||
gfxnum = Ping_gfx_num(lag);
|
||||
|
||||
if (measureid == 1)
|
||||
V_DrawScaledPatch(x+11 - pingmeasure[measureid]->width, y+9, flags, pingmeasure[measureid]);
|
||||
|
||||
if (cv_pingicon.value)
|
||||
V_DrawScaledPatch(x+2, y, flags, pinggfx[gfxnum]);
|
||||
|
||||
if (servermaxping && lag > servermaxping && hu_tick < 4)
|
||||
colormap = R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_RASPBERRY, GTC_CACHE); // flash ping red if too high
|
||||
|
||||
if (cv_pingmeasurement.value)
|
||||
lag = (INT32)(lag * (1000.00f / TICRATE));
|
||||
|
||||
x = V_DrawPingNum(x + (measureid == 1 ? 11 - pingmeasure[measureid]->width : 10), y+9, flags, lag, colormap);
|
||||
x = V_DrawPingNum(x + (measureid == 1 ? 11 - pingmeasure[measureid]->width : 10), y+9, flags, Ping_conversion(lag), Ping_gfx_colormap(lag, gentleman));
|
||||
|
||||
if (measureid == 0)
|
||||
V_DrawScaledPatch(x+1 - pingmeasure[measureid]->width, y+9, flags, pingmeasure[measureid]);
|
||||
V_DrawScaledPatch(x+1 - pingmeasure[measureid]->width, y+9, flags, pingmeasure[measureid]);
|
||||
}
|
||||
else if (cv_pingstyle.value) // old style ping
|
||||
else if (cv_pingstyle.value == 1) // old style ping
|
||||
{
|
||||
if (cv_pingicon.value)
|
||||
{
|
||||
if (lag < 4)
|
||||
{
|
||||
numbars = 3;
|
||||
barcolor = 184;
|
||||
}
|
||||
else if (lag < 7)
|
||||
{
|
||||
numbars = 2; // Apparently ternaries w/ multiple statements don't look good in C so I decided against it.
|
||||
barcolor = 103;
|
||||
}
|
||||
else if (lag < 10)
|
||||
{
|
||||
numbars = 1;
|
||||
barcolor = 155; // need a better red
|
||||
}
|
||||
else // brazil
|
||||
{
|
||||
numbars = 0;
|
||||
barcolor = 31;
|
||||
}
|
||||
}
|
||||
|
||||
if (cv_pingmeasurement.value)
|
||||
lag = (INT32)(lag * (1000.00f / TICRATE));
|
||||
|
||||
if (vid.width >= 640) // how sad, we're using a shit resolution.
|
||||
{
|
||||
if (measureid == 1)
|
||||
{
|
||||
//dx = x+1 - (V_SmallStringWidth(va("%dms", lag), V_ALLOWLOWERCASE|flags)/2);
|
||||
//V_DrawSmallString(dx, y+4, V_ALLOWLOWERCASE|flags, va("%dms", lag));
|
||||
V_DrawRightAlignedSmallString(x+12, y+13, V_ALLOWLOWERCASE|flags, va("%dms", lag));
|
||||
V_DrawRightAlignedSmallString(x+12, y+13, V_ALLOWLOWERCASE|flags, va("%dms", Ping_conversion(lag)));
|
||||
}
|
||||
else if (measureid == 0)
|
||||
{
|
||||
//dx = x+1 - (V_SmallStringWidth(va("d%d", lag), flags)/2);
|
||||
//V_DrawSmallString(dx, y+4, flags, va("d%d", lag));
|
||||
V_DrawRightAlignedSmallString(x+12, y+13, flags, va("d%d", lag));
|
||||
V_DrawRightAlignedSmallString(x+12, y+13, flags, va("d%d", Ping_conversion(lag)));
|
||||
}
|
||||
}
|
||||
|
||||
if (cv_pingicon.value)
|
||||
{
|
||||
for (i=0; (i<3); i++) // Draw the ping bar
|
||||
{
|
||||
switch (lag)
|
||||
{
|
||||
case 0 ... 1:
|
||||
numbars = 3;
|
||||
barcolor = 215; // Blue
|
||||
break;
|
||||
case 2 ... 3:
|
||||
numbars = 3;
|
||||
barcolor = 184; // Green
|
||||
break;
|
||||
case 4 ... 6:
|
||||
numbars = 2; // Apparently ternaries w/ multiple statements don't look good in C so I decided against it.
|
||||
barcolor = 103; // Yellow
|
||||
break;
|
||||
case 7 ... 9:
|
||||
numbars = 1;
|
||||
barcolor = 155; // Red
|
||||
break;
|
||||
default: // Brazil
|
||||
numbars = 0;
|
||||
barcolor = 31; // black
|
||||
break;
|
||||
}
|
||||
|
||||
if (gentleman)
|
||||
{
|
||||
barcolor = 194; // make it purplish
|
||||
// bars get indirectly set earlier
|
||||
}
|
||||
|
||||
for (i = 0; (i < 3); i++) // Draw the ping bar
|
||||
{
|
||||
V_DrawFill(x+2 *(i-1)+7, y+8+yoffset-4, 2, 8-yoffset, 31|flags);
|
||||
if (i < numbars)
|
||||
@@ -2595,8 +2581,10 @@ static inline void HU_DrawSpectatorTicker(void)
|
||||
}
|
||||
}
|
||||
|
||||
if (netgame && i != serverplayer)
|
||||
HU_drawPing((templength - duptweak)+8, height-20, playerpingtable[i], V_TRANSLUCENT);
|
||||
if ((netgame && i != serverplayer) || (cv_mindelay.value && P_IsLocalPlayer(&players[i])))
|
||||
{
|
||||
HU_drawPlayerPing((templength - duptweak)+8, height-20, i, V_TRANSLUCENT);
|
||||
}
|
||||
}
|
||||
|
||||
if ((length += len) >= dupadjust+8)
|
||||
|
||||
+1
-7
@@ -42,8 +42,6 @@
|
||||
#define CRED_FONTEND 'Z' // the last font character
|
||||
#define CRED_FONTSIZE (CRED_FONTEND - CRED_FONTSTART + 1)
|
||||
|
||||
#define HU_CROSSHAIRS 3 // maximum of 9 - see HU_Init();
|
||||
|
||||
extern char *shiftxform; // english translation shift table
|
||||
extern char english_shiftxform[];
|
||||
|
||||
@@ -90,18 +88,14 @@ extern patch_t *tallnum[10];
|
||||
extern patch_t *pingnum[10];
|
||||
extern patch_t *pinggfx[5];
|
||||
extern patch_t *ranknum[10];
|
||||
extern patch_t *nightsnum[10];
|
||||
extern patch_t *framecounter;
|
||||
extern patch_t *frameslash;
|
||||
extern patch_t *lt_font[LT_FONTSIZE];
|
||||
extern patch_t *cred_font[CRED_FONTSIZE];
|
||||
extern patch_t *emeraldpics[7];
|
||||
extern patch_t *tinyemeraldpics[7];
|
||||
extern patch_t *rflagico;
|
||||
extern patch_t *bflagico;
|
||||
extern patch_t *rmatcico;
|
||||
extern patch_t *bmatcico;
|
||||
extern patch_t *tagico;
|
||||
extern patch_t *tallminus;
|
||||
|
||||
// set true whenever the tab rankings are being shown for any reason
|
||||
@@ -125,7 +119,7 @@ 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, INT32 flags); // Lat': Ping drawer for scoreboard.
|
||||
void HU_drawPlayerPing(INT32 x, INT32 y, INT32 pnum, INT32 flags); // Lat': Ping drawer for scoreboard.
|
||||
//void HU_DrawTeamTabRankings(playersort_t *tab, INT32 whiteplayer);
|
||||
//void HU_DrawDualTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scorelines, INT32 whiteplayer);
|
||||
void HU_DrawTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scorelines, INT32 whiteplayer, INT32 hilicol);
|
||||
|
||||
+4
-10
@@ -226,6 +226,8 @@ void I_InitJoystick4(void);
|
||||
*/
|
||||
INT32 I_NumJoys(void);
|
||||
|
||||
extern INT32 numcontrollers;
|
||||
|
||||
/** \brief The *I_GetJoyName function
|
||||
|
||||
\param joyindex which joystick
|
||||
@@ -234,8 +236,8 @@ INT32 I_NumJoys(void);
|
||||
*/
|
||||
const char *I_GetJoyName(INT32 joyindex);
|
||||
|
||||
void I_GamepadRumble(INT32 device_id, UINT16 low_strength, UINT16 high_strength, UINT32 duration);
|
||||
void I_SetGamepadIndicatorColor(INT32 device_id, UINT8 red, UINT8 green, UINT8 blue);
|
||||
void I_GamepadRumble(INT32 playernum, UINT16 low_strength, UINT16 high_strength, UINT32 duration);
|
||||
void I_SetGamepadIndicatorColor(INT32 playernum, UINT8 red, UINT8 green, UINT8 blue);
|
||||
|
||||
#ifndef NOMUMBLE
|
||||
#include "p_mobj.h" // mobj_t
|
||||
@@ -249,10 +251,6 @@ void I_UpdateMumble(const mobj_t *mobj, const listener_t listener);
|
||||
*/
|
||||
void I_StartupMouse(void);
|
||||
|
||||
/** \brief Startup the second mouse
|
||||
*/
|
||||
void I_StartupMouse2(void);
|
||||
|
||||
/** \brief setup timer irq and user timer routine.
|
||||
*/
|
||||
void I_StartupTimer(void);
|
||||
@@ -315,10 +313,6 @@ const char *I_LocateWad(void);
|
||||
*/
|
||||
void I_GetJoystickEvents(UINT8 index);
|
||||
|
||||
/** \brief Mouses events
|
||||
*/
|
||||
void I_GetMouseEvents(void);
|
||||
|
||||
char *I_GetEnv(const char *name);
|
||||
|
||||
INT32 I_PutEnv(char *variable);
|
||||
|
||||
+1
-1
@@ -61,7 +61,7 @@ void I_UpdateTime(fixed_t timescale)
|
||||
ticratescaled = (double)TICRATE * FIXED_TO_FLOAT(timescale);
|
||||
|
||||
enterprecise = I_GetPreciseTime();
|
||||
elapsedseconds = (double)(enterprecise - oldenterprecise) / I_GetPrecisePrecision();
|
||||
elapsedseconds = (double)((INT64)enterprecise - oldenterprecise) / I_GetPrecisePrecision();
|
||||
tictimer += elapsedseconds;
|
||||
while (tictimer > 1.0/ticratescaled)
|
||||
{
|
||||
|
||||
+3
-23
@@ -40,25 +40,6 @@ struct directorinfo
|
||||
INT32 boredom[MAXPLAYERS]; // how long has a given position had no credible attackers?
|
||||
} directorinfo;
|
||||
|
||||
static boolean K_DirectorIsPlayerAlone(void)
|
||||
{
|
||||
UINT8 pingame = 0;
|
||||
|
||||
// Gotta check how many players are active at this moment.
|
||||
for (UINT8 i = 0; i < MAXPLAYERS; i++)
|
||||
{
|
||||
if (!playeringame[i] || players[i].spectator)
|
||||
continue;
|
||||
|
||||
pingame++;
|
||||
|
||||
if (pingame >= 2) // we dont need to check further
|
||||
break;
|
||||
}
|
||||
|
||||
return (pingame <= 1);
|
||||
}
|
||||
|
||||
static inline boolean race_rules(void)
|
||||
{
|
||||
return gametype == GT_RACE;
|
||||
@@ -71,9 +52,9 @@ static fixed_t ScaleFromMap(fixed_t n, fixed_t scale)
|
||||
|
||||
boolean K_DirectorIsAvailable(void)
|
||||
{
|
||||
if ((demo.playback && demo.title) || modeattacking)
|
||||
if (splitscreen || (demo.playback && demo.title) || modeattacking)
|
||||
return false;
|
||||
return ((gamestate == GS_LEVEL) && (demo.playback || (players[consoleplayer].spectator && !K_DirectorIsPlayerAlone())));
|
||||
return ((gamestate == GS_LEVEL) && ((demo.playback && !camera[0].freecam) || (players[consoleplayer].spectator && (D_NumPlayers() > 1))));
|
||||
}
|
||||
|
||||
static boolean K_DirectorIsEnabled(void)
|
||||
@@ -422,10 +403,9 @@ void K_ToggleDirector(void)
|
||||
if (!K_DirectorIsAvailable())
|
||||
return;
|
||||
|
||||
G_AdjustView(1, 1, true);
|
||||
|
||||
if (!K_DirectorIsEnabled())
|
||||
{
|
||||
G_AdjustView(1, 1, true);
|
||||
directorinfo.cooldown = 0; // switch immediately
|
||||
}
|
||||
|
||||
|
||||
+956
-451
File diff suppressed because it is too large.
Load diff
+11
-6
@@ -11,6 +11,7 @@
|
||||
|
||||
#define KART_FULLTURN 800
|
||||
|
||||
|
||||
extern UINT8 colortranslations[MAXTRANSLATIONS][16];
|
||||
extern const char *KartColor_Names[MAXSKINCOLORS];
|
||||
extern const UINT8 KartColor_Opposite[MAXSKINCOLORS*2];
|
||||
@@ -22,17 +23,21 @@ boolean K_UseColorHud(void);
|
||||
|
||||
void K_RegisterKartStuff(void);
|
||||
|
||||
extern consvar_t cv_colorizedhud;
|
||||
extern consvar_t cv_colorizeditembox;
|
||||
extern consvar_t cv_colorizedhudcolor;
|
||||
extern consvar_t cv_coloredspeedlines, cv_coloredsneakertrail;
|
||||
extern consvar_t cv_bananajitter;
|
||||
extern consvar_t cv_bananthrowroll;
|
||||
extern consvar_t cv_airsparks;
|
||||
extern consvar_t cv_colorizedhud, cv_colorizeditembox, cv_colorizedhudcolor;
|
||||
extern consvar_t cv_darkitembox;
|
||||
extern consvar_t cv_biglaps;
|
||||
extern consvar_t cv_highresportrait;
|
||||
extern consvar_t cv_stat_xoffset;
|
||||
extern consvar_t cv_stat_yoffset;
|
||||
extern consvar_t cv_stat_xoffset, cv_stat_yoffset;
|
||||
extern consvar_t cv_showstats;
|
||||
extern consvar_t cv_fancyroulette;
|
||||
extern consvar_t cv_showlaptimes;
|
||||
extern consvar_t cv_battlespeedo;
|
||||
extern consvar_t cv_multiitemicon;
|
||||
extern consvar_t cv_huditemamount;
|
||||
|
||||
#define NUMSPEEDOSTUFF 6
|
||||
extern CV_PossibleValue_t speedo_cons_t[NUMSPEEDOSTUFF];
|
||||
@@ -56,7 +61,7 @@ void K_ExplodePlayer(player_t *player, mobj_t *source, mobj_t *inflictor);
|
||||
void K_StealBumper(player_t *player, player_t *victim, boolean force);
|
||||
void K_SpawnKartExplosion(fixed_t x, fixed_t y, fixed_t z, fixed_t radius, INT32 number, mobjtype_t type, angle_t rotangle, boolean spawncenter, boolean ghostit, mobj_t *source);
|
||||
void K_SpawnMineExplosion(mobj_t *source, UINT8 color);
|
||||
void K_RollMobjBySlopes(mobj_t *mo, boolean usedistance);
|
||||
void K_RollMobjBySlopes(mobj_t *mo, pslope_t *slope);
|
||||
void K_SpawnBoostTrail(player_t *player);
|
||||
void K_SpawnSparkleTrail(mobj_t *mo);
|
||||
void K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent);
|
||||
|
||||
+29
-28
@@ -64,7 +64,7 @@ static UINT8 * hooksErrored;
|
||||
|
||||
static int errorRef;
|
||||
|
||||
static boolean mobj_hook_available(int hook_type, mobjtype_t mobj_type)
|
||||
FUNCINLINE static ATTRINLINE boolean mobj_hook_available(int hook_type, mobjtype_t mobj_type)
|
||||
{
|
||||
return
|
||||
(
|
||||
@@ -73,7 +73,7 @@ static boolean mobj_hook_available(int hook_type, mobjtype_t mobj_type)
|
||||
);
|
||||
}
|
||||
|
||||
static unsigned hook_in_list
|
||||
FUNCINLINE static ATTRINLINE unsigned hook_in_list
|
||||
(
|
||||
const char * const name,
|
||||
const char * const * const list
|
||||
@@ -106,7 +106,7 @@ static void get_table(lua_State *L)
|
||||
lua_remove(L, -2);
|
||||
}
|
||||
|
||||
static void add_hook_to_table(lua_State *L, int n)
|
||||
FUNCINLINE static ATTRINLINE void add_hook_to_table(lua_State *L, int n)
|
||||
{
|
||||
lua_pushnumber(L, nextid);
|
||||
lua_rawseti(L, -2, n);
|
||||
@@ -175,14 +175,14 @@ static void add_string_hook(lua_State *L, int type)
|
||||
add_hook_to_table(L, ++hook->numGeneric);
|
||||
}
|
||||
|
||||
static void add_hook(hook_t *map)
|
||||
FUNCINLINE static ATTRINLINE void add_hook(hook_t *map)
|
||||
{
|
||||
Z_Realloc(map->ids, (map->numHooks + 1) * sizeof *map->ids,
|
||||
PU_STATIC, &map->ids);
|
||||
map->ids[map->numHooks++] = nextid;
|
||||
}
|
||||
|
||||
static void add_mobj_hook(lua_State *L, int hook_type)
|
||||
FUNCINLINE static ATTRINLINE void add_mobj_hook(lua_State *L, int hook_type)
|
||||
{
|
||||
mobjtype_t mobj_type = luaL_optnumber(L, 3, MT_NULL);
|
||||
|
||||
@@ -191,7 +191,7 @@ static void add_mobj_hook(lua_State *L, int hook_type)
|
||||
add_hook(&mobjHookIds[mobj_type][hook_type]);
|
||||
}
|
||||
|
||||
static void add_hud_hook(lua_State *L, int idx)
|
||||
FUNCINLINE static ATTRINLINE void add_hud_hook(lua_State *L, int idx)
|
||||
{
|
||||
add_hook(&hudHookIds[luaL_checkoption(L,
|
||||
idx, "game", hudHookNames)]);
|
||||
@@ -263,7 +263,6 @@ int LUA_HookLib(lua_State *L)
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int lib_hudadd(lua_State *L);/* yeah compiler */
|
||||
int lib_hudadd(lua_State *L)
|
||||
{
|
||||
@@ -297,24 +296,24 @@ enum {
|
||||
SINDEX = 2,/* string itself is pushed in case of string hook */
|
||||
};
|
||||
|
||||
static void push_error_handler(void)
|
||||
FUNCINLINE static ATTRINLINE void push_error_handler(void)
|
||||
{
|
||||
lua_getref(gL, errorRef);
|
||||
}
|
||||
|
||||
/* repush hook string */
|
||||
static void push_string(void)
|
||||
FUNCINLINE static ATTRINLINE void push_string(void)
|
||||
{
|
||||
lua_pushvalue(gL, SINDEX);
|
||||
}
|
||||
|
||||
static boolean begin_hook_values(Hook_State *hook)
|
||||
FUNCINLINE static ATTRINLINE boolean begin_hook_values(Hook_State *hook)
|
||||
{
|
||||
hook->top = lua_gettop(gL);
|
||||
return true;
|
||||
}
|
||||
|
||||
static void start_hook_stack(void)
|
||||
FUNCINLINE static ATTRINLINE void start_hook_stack(void)
|
||||
{
|
||||
lua_settop(gL, 0);
|
||||
push_error_handler();
|
||||
@@ -343,7 +342,7 @@ static boolean init_hook_type
|
||||
return false;
|
||||
}
|
||||
|
||||
static boolean prepare_hook
|
||||
FUNCINLINE static ATTRINLINE boolean prepare_hook
|
||||
(
|
||||
Hook_State * hook,
|
||||
int default_status,
|
||||
@@ -356,7 +355,7 @@ static boolean prepare_hook
|
||||
hookIds[hook_type].numHooks);
|
||||
}
|
||||
|
||||
static boolean prepare_mobj_hook
|
||||
FUNCINLINE static ATTRINLINE boolean prepare_mobj_hook
|
||||
(
|
||||
Hook_State * hook,
|
||||
int default_status,
|
||||
@@ -373,7 +372,7 @@ static boolean prepare_mobj_hook
|
||||
mobj_hook_available(hook_type, mobj_type));
|
||||
}
|
||||
|
||||
static boolean prepare_string_hook
|
||||
FUNCINLINE static ATTRINLINE boolean prepare_string_hook
|
||||
(
|
||||
Hook_State * hook,
|
||||
int default_status,
|
||||
@@ -393,7 +392,7 @@ static boolean prepare_string_hook
|
||||
return false;
|
||||
}
|
||||
|
||||
static void init_hook_call
|
||||
FUNCINLINE static ATTRINLINE void init_hook_call
|
||||
(
|
||||
Hook_State * hook,
|
||||
int results,
|
||||
@@ -406,13 +405,13 @@ static void init_hook_call
|
||||
hook->results_handler = results_handler;
|
||||
}
|
||||
|
||||
static void get_hook(Hook_State *hook, const int *ids, int n)
|
||||
FUNCINLINE static ATTRINLINE void get_hook(Hook_State *hook, const int *ids, int n)
|
||||
{
|
||||
hook->id = ids[n];
|
||||
lua_getref(gL, hookRefs[hook->id]);
|
||||
}
|
||||
|
||||
static void get_hook_from_table(Hook_State *hook, int n)
|
||||
FUNCINLINE static ATTRINLINE void get_hook_from_table(Hook_State *hook, int n)
|
||||
{
|
||||
lua_rawgeti(gL, -1, n);
|
||||
hook->id = lua_tonumber(gL, -1);
|
||||
@@ -444,7 +443,7 @@ static int call_single_hook_no_copy(Hook_State *hook)
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int call_single_hook(Hook_State *hook)
|
||||
FUNCINLINE static ATTRINLINE int call_single_hook(Hook_State *hook)
|
||||
{
|
||||
int i;
|
||||
|
||||
@@ -454,7 +453,7 @@ static int call_single_hook(Hook_State *hook)
|
||||
return call_single_hook_no_copy(hook);
|
||||
}
|
||||
|
||||
static int call_hook_table_for(Hook_State *hook, int n)
|
||||
FUNCINLINE static ATTRINLINE int call_hook_table_for(Hook_State *hook, int n)
|
||||
{
|
||||
int k;
|
||||
|
||||
@@ -467,12 +466,12 @@ static int call_hook_table_for(Hook_State *hook, int n)
|
||||
return n;
|
||||
}
|
||||
|
||||
static int call_hook_table(Hook_State *hook)
|
||||
FUNCINLINE static ATTRINLINE int call_hook_table(Hook_State *hook)
|
||||
{
|
||||
return call_hook_table_for(hook, lua_objlen(gL, -1));
|
||||
}
|
||||
|
||||
static int call_mapped(Hook_State *hook, const hook_t *map)
|
||||
FUNCINLINE static ATTRINLINE int call_mapped(Hook_State *hook, const hook_t *map)
|
||||
{
|
||||
int k;
|
||||
|
||||
@@ -503,7 +502,7 @@ static int call_string_hooks(Hook_State *hook)
|
||||
return calls;
|
||||
}
|
||||
|
||||
static int call_mobj_type_hooks(Hook_State *hook, mobjtype_t mobj_type)
|
||||
FUNCINLINE static ATTRINLINE int call_mobj_type_hooks(Hook_State *hook, mobjtype_t mobj_type)
|
||||
{
|
||||
return call_mapped(hook, &mobjHookIds[mobj_type][hook->hook_type]);
|
||||
}
|
||||
@@ -546,7 +545,7 @@ static int call_hooks
|
||||
|
||||
#define res_none NULL
|
||||
|
||||
static void res_true(Hook_State *hook)
|
||||
FUNCINLINE static ATTRINLINE void res_true(Hook_State *hook)
|
||||
{
|
||||
if (lua_toboolean(gL, -1))
|
||||
hook->status = true;
|
||||
@@ -558,7 +557,7 @@ static void res_true(Hook_State *hook)
|
||||
hook->status = false;
|
||||
}*/
|
||||
|
||||
static void res_force(Hook_State *hook)
|
||||
FUNCINLINE static ATTRINLINE void res_force(Hook_State *hook)
|
||||
{
|
||||
if (!lua_isnil(gL, -1))
|
||||
{
|
||||
@@ -569,7 +568,7 @@ static void res_force(Hook_State *hook)
|
||||
}
|
||||
}
|
||||
|
||||
static void res_hud(Hook_State *hook)
|
||||
FUNCINLINE static ATTRINLINE void res_hud(Hook_State *hook)
|
||||
{
|
||||
(void)hook;
|
||||
|
||||
@@ -700,6 +699,8 @@ static void hook_think_frame(int type)
|
||||
const hook_t * map = &hookIds[type];
|
||||
int k;
|
||||
|
||||
const boolean perfstats = (cv_perfstats.value >= 3);
|
||||
|
||||
if (prepare_hook(&hook, 0, type))
|
||||
{
|
||||
init_hook_call(&hook, 0, res_none);
|
||||
@@ -708,7 +709,7 @@ static void hook_think_frame(int type)
|
||||
{
|
||||
get_hook(&hook, map->ids, k);
|
||||
|
||||
if (cv_perfstats.value >= 3)
|
||||
if (perfstats)
|
||||
{
|
||||
lua_pushvalue(gL, -1);/* need the function again */
|
||||
time_taken = I_GetPreciseTime();
|
||||
@@ -716,7 +717,7 @@ static void hook_think_frame(int type)
|
||||
|
||||
call_single_hook(&hook);
|
||||
|
||||
if (cv_perfstats.value >= 3)
|
||||
if (perfstats)
|
||||
{
|
||||
lua_Debug ar;
|
||||
time_taken = I_GetPreciseTime() - time_taken;
|
||||
@@ -808,7 +809,7 @@ typedef struct {
|
||||
ticcmd_t * cmd;
|
||||
} BotAI_State;
|
||||
|
||||
static boolean checkbotkey(const char *field)
|
||||
FUNCINLINE static ATTRINLINE boolean checkbotkey(const char *field)
|
||||
{
|
||||
return lua_toboolean(gL, -1) && strcmp(lua_tostring(gL, -2), field) == 0;
|
||||
}
|
||||
|
||||
+39
-13
@@ -397,6 +397,18 @@ static int libd_cachePatch(lua_State *L)
|
||||
return 1;
|
||||
}
|
||||
|
||||
#ifdef ROTSPRITE
|
||||
static int libd_cachePatchRotated(lua_State *L)
|
||||
{
|
||||
HUDONLY
|
||||
angle_t rollangle = luaL_checkangle(L, 2);
|
||||
INT32 rot = R_GetRollAngle(rollangle);
|
||||
LUA_PushUserdata(L, W_CachePatchNameRotated(luaL_checkstring(L, 1), rot, PU_STATIC), META_PATCH);
|
||||
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
|
||||
// this is structured like getSprite2Patch in vanilla 2.2
|
||||
// v.getSpritePatch(skin, sprite, [frame, [angle, [rollangle]]])
|
||||
static int libd_getSpritePatch(lua_State *L)
|
||||
@@ -462,12 +474,16 @@ static int libd_getSpritePatch(lua_State *L)
|
||||
if (skn < 0) // standard sprite
|
||||
{
|
||||
sprdef = &sprites[i];
|
||||
#ifdef ROTSPRITE
|
||||
sprinfo = &spriteinfo[i];
|
||||
#endif
|
||||
}
|
||||
else // player skin
|
||||
{
|
||||
sprdef = &skins[skn].spritedef;
|
||||
#ifdef ROTSPRITE
|
||||
sprinfo = &skins[skn].sprinfo;
|
||||
#endif
|
||||
}
|
||||
|
||||
// set frame number
|
||||
@@ -488,13 +504,15 @@ static int libd_getSpritePatch(lua_State *L)
|
||||
if (angle >= 8) // out of range?
|
||||
angle = (angle & 7); // modulus angle by 8
|
||||
|
||||
#ifdef ROTSPRITE
|
||||
// rotsprite?????
|
||||
if (lua_isnumber(L, 4) && cv_sloperoll.value)
|
||||
if (lua_isnumber(L, 4))
|
||||
{
|
||||
angle_t rollangle = luaL_checkangle(L, 4);
|
||||
INT32 rot = R_GetRollAngle(rollangle);
|
||||
|
||||
if (rot) {
|
||||
if (rot)
|
||||
{
|
||||
patch_t *rotsprite = Patch_GetRotatedSprite(sprframe, frame, angle, sprframe->flip & (1<<angle), false, sprinfo, rot);
|
||||
LUA_PushUserdata(L, rotsprite, META_PATCH);
|
||||
lua_pushboolean(L, false);
|
||||
@@ -502,6 +520,7 @@ static int libd_getSpritePatch(lua_State *L)
|
||||
return 3;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
// push both the patch and its "flip" value
|
||||
LUA_PushUserdata(L, W_CachePatchNum(sprframe->lumppat[angle], PU_STATIC), META_PATCH);
|
||||
@@ -511,7 +530,7 @@ static int libd_getSpritePatch(lua_State *L)
|
||||
|
||||
static int libd_draw(lua_State *L)
|
||||
{
|
||||
INT32 x, y, flags;
|
||||
INT32 x, y, flags, blend;
|
||||
patch_t *patch;
|
||||
UINT8 *colormap = NULL;
|
||||
huddrawlist_h list;
|
||||
@@ -523,6 +542,7 @@ static int libd_draw(lua_State *L)
|
||||
flags = luaL_optinteger(L, 4, 0);
|
||||
if (!lua_isnoneornil(L, 5))
|
||||
colormap = *((UINT8 **)luaL_checkudata(L, 5, META_COLORMAP));
|
||||
blend = luaL_optinteger(L, 6, 0);
|
||||
|
||||
flags &= ~V_PARAMMASK; // Don't let crashes happen.
|
||||
|
||||
@@ -531,16 +551,16 @@ static int libd_draw(lua_State *L)
|
||||
lua_pop(L, 1);
|
||||
|
||||
if (LUA_HUD_IsDrawListValid(list))
|
||||
LUA_HUD_AddDraw(list, x, y, patch, flags, colormap);
|
||||
LUA_HUD_AddDraw(list, x, y, patch, flags, colormap, blend);
|
||||
else
|
||||
V_DrawFixedPatch(x<<FRACBITS, y<<FRACBITS, FRACUNIT, flags, patch, colormap);
|
||||
V_DrawBlendingFixedPatch(x<<FRACBITS, y<<FRACBITS, FRACUNIT, flags, patch, colormap, blend);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int libd_drawScaled(lua_State *L)
|
||||
{
|
||||
fixed_t x, y, scale;
|
||||
INT32 flags;
|
||||
INT32 flags, blend;
|
||||
patch_t *patch;
|
||||
UINT8 *colormap = NULL;
|
||||
huddrawlist_h list;
|
||||
@@ -555,6 +575,7 @@ static int libd_drawScaled(lua_State *L)
|
||||
flags = luaL_optinteger(L, 5, 0);
|
||||
if (!lua_isnoneornil(L, 6))
|
||||
colormap = *((UINT8 **)luaL_checkudata(L, 6, META_COLORMAP));
|
||||
blend = luaL_optinteger(L, 7, 0);
|
||||
|
||||
flags &= ~V_PARAMMASK; // Don't let crashes happen.
|
||||
|
||||
@@ -563,9 +584,9 @@ static int libd_drawScaled(lua_State *L)
|
||||
lua_pop(L, 1);
|
||||
|
||||
if (LUA_HUD_IsDrawListValid(list))
|
||||
LUA_HUD_AddDrawScaled(list, x, y, scale, patch, flags, colormap);
|
||||
LUA_HUD_AddDrawScaled(list, x, y, scale, patch, flags, colormap, blend);
|
||||
else
|
||||
V_DrawFixedPatch(x, y, scale, flags, patch, colormap);
|
||||
V_DrawBlendingFixedPatch(x, y, scale, flags, patch, colormap, blend);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -649,7 +670,7 @@ static int libd_drawOnMinimap(lua_State *L)
|
||||
if (gamestate != GS_LEVEL)
|
||||
return 0;
|
||||
|
||||
if (stplyr != &players[displayplayers[0]])
|
||||
if (stplyrnum != 0)
|
||||
return 0;
|
||||
|
||||
AutomapPic = minimapinfo.minimap_pic;
|
||||
@@ -709,7 +730,7 @@ static int libd_drawOnMinimap(lua_State *L)
|
||||
|
||||
if (LUA_HUD_IsDrawListValid(list))
|
||||
{
|
||||
LUA_HUD_AddDrawScaled(list, amxpos, amypos, scale, patch, splitflags, colormap);
|
||||
LUA_HUD_AddDrawScaled(list, amxpos, amypos, scale, patch, splitflags, colormap, 0);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -722,7 +743,7 @@ static int libd_drawOnMinimap(lua_State *L)
|
||||
static int libd_drawStretched(lua_State *L)
|
||||
{
|
||||
fixed_t x, y, hscale, vscale;
|
||||
INT32 flags;
|
||||
INT32 flags, blend;
|
||||
patch_t *patch;
|
||||
UINT8 *colormap = NULL;
|
||||
huddrawlist_h list;
|
||||
@@ -740,6 +761,7 @@ static int libd_drawStretched(lua_State *L)
|
||||
flags = luaL_optinteger(L, 6, 0);
|
||||
if (!lua_isnoneornil(L, 7))
|
||||
colormap = *((UINT8 **)luaL_checkudata(L, 7, META_COLORMAP));
|
||||
blend = luaL_optinteger(L, 8, 0);
|
||||
|
||||
flags &= ~V_PARAMMASK; // Don't let crashes happen.
|
||||
|
||||
@@ -748,9 +770,9 @@ static int libd_drawStretched(lua_State *L)
|
||||
lua_pop(L, 1);
|
||||
|
||||
if (LUA_HUD_IsDrawListValid(list))
|
||||
LUA_HUD_AddDrawStretched(list, x, y, hscale, vscale, patch, flags, colormap);
|
||||
LUA_HUD_AddDrawStretched(list, x, y, hscale, vscale, patch, flags, colormap, blend);
|
||||
else
|
||||
V_DrawStretchyFixedPatch(x, y, hscale, vscale, flags, patch, colormap);
|
||||
V_DrawStretchyFixedPatch(x, y, hscale, vscale, flags, patch, colormap, blend);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -1172,6 +1194,10 @@ static int libd_interpLatch(lua_State *L)
|
||||
static luaL_Reg lib_draw[] = {
|
||||
{"patchExists", libd_patchExists},
|
||||
{"cachePatch", libd_cachePatch},
|
||||
#ifdef ROTSPRITE
|
||||
// Is this ifdef nonsense? Yes.
|
||||
{"cachePatchRotated", libd_cachePatchRotated},
|
||||
#endif
|
||||
{"draw", libd_draw},
|
||||
{"drawScaled", libd_drawScaled},
|
||||
{"drawStretched", libd_drawStretched},
|
||||
|
||||
@@ -69,6 +69,7 @@ typedef struct drawitem_s {
|
||||
size_t stroffset; // offset into strbuf to get str
|
||||
};
|
||||
const UINT8 *colormap;
|
||||
INT32 blend;
|
||||
} drawitem_t;
|
||||
|
||||
// The internal structure of a drawlist.
|
||||
@@ -345,7 +346,8 @@ void LUA_HUD_AddDraw(
|
||||
INT32 y,
|
||||
patch_t *patch,
|
||||
INT32 flags,
|
||||
UINT8 *colormap
|
||||
UINT8 *colormap,
|
||||
INT32 blend
|
||||
)
|
||||
{
|
||||
size_t i = AllocateDrawItem(list);
|
||||
@@ -357,6 +359,7 @@ void LUA_HUD_AddDraw(
|
||||
item->patch = patch;
|
||||
item->flags = flags;
|
||||
item->colormap = colormap;
|
||||
item->blend = blend;
|
||||
}
|
||||
|
||||
void LUA_HUD_AddDrawScaled(
|
||||
@@ -366,7 +369,8 @@ void LUA_HUD_AddDrawScaled(
|
||||
fixed_t scale,
|
||||
patch_t *patch,
|
||||
INT32 flags,
|
||||
UINT8 *colormap
|
||||
UINT8 *colormap,
|
||||
INT32 blend
|
||||
)
|
||||
{
|
||||
size_t i = AllocateDrawItem(list);
|
||||
@@ -379,6 +383,7 @@ void LUA_HUD_AddDrawScaled(
|
||||
item->patch = patch;
|
||||
item->flags = flags;
|
||||
item->colormap = colormap;
|
||||
item->blend = blend;
|
||||
}
|
||||
|
||||
void LUA_HUD_AddDrawStretched(
|
||||
@@ -389,7 +394,8 @@ void LUA_HUD_AddDrawStretched(
|
||||
fixed_t vscale,
|
||||
patch_t *patch,
|
||||
INT32 flags,
|
||||
UINT8 *colormap
|
||||
UINT8 *colormap,
|
||||
INT32 blend
|
||||
)
|
||||
{
|
||||
size_t i = AllocateDrawItem(list);
|
||||
@@ -403,6 +409,7 @@ void LUA_HUD_AddDrawStretched(
|
||||
item->patch = patch;
|
||||
item->flags = flags;
|
||||
item->colormap = colormap;
|
||||
item->blend = blend;
|
||||
}
|
||||
|
||||
void LUA_HUD_AddDrawNum(
|
||||
@@ -634,17 +641,17 @@ void LUA_HUD_DrawList(huddrawlist_h list)
|
||||
case DI_Draw:
|
||||
if (!item->patch || item->patch == NULL)
|
||||
return;
|
||||
V_DrawFixedPatch(LERPS(x), LERPS(y), FRACUNIT, item->flags, item->patch, item->colormap);
|
||||
V_DrawBlendingFixedPatch(LERPS(x), LERPS(y), FRACUNIT, item->flags, item->patch, item->colormap, item->blend);
|
||||
break;
|
||||
case DI_DrawScaled:
|
||||
if (!item->patch || item->patch == NULL)
|
||||
return;
|
||||
V_DrawFixedPatch(LERPS(x), LERPS(y), LERP(scale), item->flags, item->patch, item->colormap);
|
||||
V_DrawBlendingFixedPatch(LERPS(x), LERPS(y), LERP(scale), item->flags, item->patch, item->colormap, item->blend);
|
||||
break;
|
||||
case DI_DrawStretched:
|
||||
if (!item->patch || item->patch == NULL)
|
||||
return;
|
||||
V_DrawStretchyFixedPatch(LERPS(x), LERPS(y), LERP(hscale), LERP(vscale), item->flags, item->patch, item->colormap);
|
||||
V_DrawStretchyFixedPatch(LERPS(x), LERPS(y), LERP(hscale), LERP(vscale), item->flags, item->patch, item->colormap, item->blend);
|
||||
break;
|
||||
case DI_DrawNum:
|
||||
V_DrawTallNum(LERPS(x), LERPS(y), item->flags, item->num);
|
||||
|
||||
@@ -40,7 +40,8 @@ void LUA_HUD_AddDraw(
|
||||
INT32 y,
|
||||
patch_t *patch,
|
||||
INT32 flags,
|
||||
UINT8 *colormap
|
||||
UINT8 *colormap,
|
||||
INT32 blend
|
||||
);
|
||||
void LUA_HUD_AddDrawStretched(
|
||||
huddrawlist_h list,
|
||||
@@ -50,7 +51,8 @@ void LUA_HUD_AddDrawStretched(
|
||||
fixed_t vscale,
|
||||
patch_t *patch,
|
||||
INT32 flags,
|
||||
UINT8 *colormap
|
||||
UINT8 *colormap,
|
||||
INT32 blend
|
||||
);
|
||||
void LUA_HUD_AddDrawScaled(
|
||||
huddrawlist_h list,
|
||||
@@ -59,7 +61,8 @@ void LUA_HUD_AddDrawScaled(
|
||||
fixed_t scale,
|
||||
patch_t *patch,
|
||||
INT32 flags,
|
||||
UINT8 *colormap
|
||||
UINT8 *colormap,
|
||||
INT32 blend
|
||||
);
|
||||
void LUA_HUD_AddDrawNum(
|
||||
huddrawlist_h list,
|
||||
|
||||
@@ -94,6 +94,7 @@ enum line_e {
|
||||
line_sidenum,
|
||||
line_frontside,
|
||||
line_backside,
|
||||
line_alpha,
|
||||
line_slopetype,
|
||||
line_frontsector,
|
||||
line_backsector,
|
||||
@@ -115,6 +116,7 @@ static const char *const line_opt[] = {
|
||||
"sidenum",
|
||||
"frontside",
|
||||
"backside",
|
||||
"alpha",
|
||||
"slopetype",
|
||||
"frontsector",
|
||||
"backsector",
|
||||
@@ -186,6 +188,7 @@ enum ffloor_e {
|
||||
ffloor_next,
|
||||
ffloor_prev,
|
||||
ffloor_alpha,
|
||||
ffloor_blend,
|
||||
};
|
||||
|
||||
static const char *const ffloor_opt[] = {
|
||||
@@ -204,6 +207,7 @@ static const char *const ffloor_opt[] = {
|
||||
"next",
|
||||
"prev",
|
||||
"alpha",
|
||||
"blend",
|
||||
NULL};
|
||||
|
||||
static int ffloor_fields_ref = LUA_NOREF;
|
||||
@@ -652,6 +656,9 @@ static int line_get(lua_State *L)
|
||||
return 0;
|
||||
LUA_PushUserdata(L, &sides[line->sidenum[1]], META_SIDE);
|
||||
return 1;
|
||||
case line_alpha:
|
||||
lua_pushfixed(L, line->alpha);
|
||||
return 1;
|
||||
case line_slopetype:
|
||||
switch(line->slopetype)
|
||||
{
|
||||
@@ -1168,6 +1175,9 @@ static int ffloor_get(lua_State *L)
|
||||
case ffloor_alpha:
|
||||
lua_pushinteger(L, ffloor->alpha);
|
||||
return 1;
|
||||
case ffloor_blend:
|
||||
lua_pushinteger(L, ffloor->blend);
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@@ -1246,6 +1256,9 @@ static int ffloor_set(lua_State *L)
|
||||
case ffloor_alpha:
|
||||
ffloor->alpha = (INT32)luaL_checkinteger(L, 3);
|
||||
break;
|
||||
case ffloor_blend:
|
||||
ffloor->blend = (INT32)luaL_checkinteger(L, 3);
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
+37
-3
@@ -40,6 +40,7 @@ int mobj_sprev_unimplemented(lua_State *L);
|
||||
int mobj_angle_setter(lua_State *L);
|
||||
int mobj_sloperoll_noop(lua_State *L);
|
||||
int mobj_spritescale_setter(lua_State *L);
|
||||
int mobj_spriteoffset_setter(lua_State *L);
|
||||
int mobj_touching_sectorlist_unimplemented(lua_State *L);
|
||||
int mobj_radius_setter(lua_State *L);
|
||||
int mobj_height_setter(lua_State *L);
|
||||
@@ -52,6 +53,7 @@ int mobj_skin_setter(lua_State *L);
|
||||
int mobj_localskin_getter(lua_State *L);
|
||||
int mobj_localskin_setter(lua_State *L);
|
||||
int mobj_color_setter(lua_State *L);
|
||||
int mobj_blendmode_setter(lua_State *L);
|
||||
int mobj_bnext_noset(lua_State *L);
|
||||
int mobj_bprev_unimplemented(lua_State *L);
|
||||
int mobj_hnext_setter(lua_State *L);
|
||||
@@ -94,8 +96,8 @@ static const udata_field_t mobj_fields[] = {
|
||||
FIELD(mobj_t, anim_duration, udatalib_getter_uint16, udatalib_setter_uint16),
|
||||
FIELD(mobj_t, spritexscale, udatalib_getter_fixed, mobj_spritescale_setter),
|
||||
FIELD(mobj_t, spriteyscale, udatalib_getter_fixed, mobj_spritescale_setter),
|
||||
FIELD(mobj_t, spritexoffset, udatalib_getter_fixed, udatalib_setter_fixed),
|
||||
FIELD(mobj_t, spriteyoffset, udatalib_getter_fixed, udatalib_setter_fixed),
|
||||
FIELD(mobj_t, spritexoffset, udatalib_getter_fixed, mobj_spriteoffset_setter),
|
||||
FIELD(mobj_t, spriteyoffset, udatalib_getter_fixed, mobj_spriteoffset_setter),
|
||||
FIELD(mobj_t, touching_sectorlist, mobj_touching_sectorlist_unimplemented, mobj_touching_sectorlist_unimplemented),
|
||||
FIELD(mobj_t, lightlevel, udatalib_getter_int16, udatalib_setter_int16),
|
||||
FIELD(mobj_t, subsector, udatalib_getter_subsector, mobj_nosetpos_subsector),
|
||||
@@ -115,6 +117,7 @@ static const udata_field_t mobj_fields[] = {
|
||||
FIELD(mobj_t, skin, mobj_skin_getter, mobj_skin_setter),
|
||||
FIELD(mobj_t, localskin, mobj_localskin_getter, mobj_localskin_setter),
|
||||
FIELD(mobj_t, color, udatalib_getter_uint8, mobj_color_setter),
|
||||
FIELD(mobj_t, blendmode, udatalib_getter_int32, mobj_blendmode_setter),
|
||||
FIELD(mobj_t, bnext, udatalib_getter_mobj, mobj_bnext_noset),
|
||||
FIELD(mobj_t, bprev, mobj_bprev_unimplemented, mobj_bprev_unimplemented),
|
||||
FIELD(mobj_t, hnext, udatalib_getter_mobj, mobj_hnext_setter),
|
||||
@@ -147,7 +150,6 @@ static const udata_field_t mobj_fields[] = {
|
||||
FIELD(mobj_t, standingslope, udatalib_getter_slope, mobj_standingslope_noset),
|
||||
FIELD(mobj_t, colorized, udatalib_getter_boolean, udatalib_setter_boolean),
|
||||
FIELD(mobj_t, mirrored, udatalib_getter_boolean, udatalib_setter_boolean),
|
||||
FIELD(mobj_t, rollmodel, udatalib_getter_boolean, udatalib_setter_boolean),
|
||||
{ NULL, 0, NULL, NULL },
|
||||
};
|
||||
#undef FIELD
|
||||
@@ -278,6 +280,26 @@ int mobj_spritescale_setter(lua_State *L)
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mobj_spriteoffset_setter(lua_State *L)
|
||||
{
|
||||
mobj_t *mo = GETMO();
|
||||
|
||||
fixed_t *spriteoffset;
|
||||
UDATALIB_GETFIELD(fixed_t, spriteoffset);
|
||||
|
||||
if (!mo->player)
|
||||
*spriteoffset = luaL_checkfixed(L, 2);
|
||||
else
|
||||
{
|
||||
// Mmm yea
|
||||
if (spriteoffset == &mo->spritexoffset)
|
||||
mo->realxoffset = luaL_checkfixed(L, 2);
|
||||
else
|
||||
mo->realyoffset = luaL_checkfixed(L, 2);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mobj_radius_setter(lua_State *L)
|
||||
{
|
||||
mobj_t *mo = GETMO();
|
||||
@@ -477,6 +499,18 @@ int mobj_color_setter(lua_State *L)
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mobj_blendmode_setter(lua_State *L)
|
||||
{
|
||||
mobj_t *mo = GETMO();
|
||||
|
||||
INT32 blendmode = (INT32)luaL_checkinteger(L, 2);
|
||||
if (blendmode < 0 || blendmode > AST_OVERLAY)
|
||||
return luaL_error(L, "mobj.blendmode %d out of range (0 - %d).", blendmode, AST_OVERLAY);
|
||||
mo->blendmode = blendmode;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mobj_hnext_setter(lua_State *L)
|
||||
{
|
||||
mobj_t *mo = GETMO();
|
||||
|
||||
+2
-3
@@ -157,9 +157,8 @@ static const udata_field_t player_fields[] = {
|
||||
FIELD(player_t, grieftime, udatalib_getter_tic, udatalib_setter_tic),
|
||||
FIELD(player_t, griefstrikes, udatalib_getter_uint8, udatalib_setter_uint8),
|
||||
FIELD(player_t, splitscreenindex, udatalib_getter_uint8, player_splitscreenindex_noset),
|
||||
#ifdef HWRENDER
|
||||
FIELD(player_t, fovadd, udatalib_getter_fixed, udatalib_setter_fixed), // Mmm yeah thats definitely synch safe
|
||||
#endif
|
||||
|
||||
// Same as player.name
|
||||
{ "sliproll", 0, player_sliproll_getter, player_sliproll_noset },
|
||||
{ "viewrollangle", 0, player_viewrollangle_getter, player_viewrollangle_noset },
|
||||
@@ -882,4 +881,4 @@ int LUA_PlayerLib(lua_State *L)
|
||||
lua_setglobal(L, "displayplayers");
|
||||
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
+67
-146
@@ -504,6 +504,8 @@ void LUA_InvalidateLevel(void)
|
||||
{
|
||||
thinker_t *th;
|
||||
size_t i;
|
||||
ffloor_t *rover = NULL;
|
||||
|
||||
if (!gL)
|
||||
return;
|
||||
|
||||
@@ -515,32 +517,55 @@ void LUA_InvalidateLevel(void)
|
||||
for (i = 0; i < numsubsectors; i++)
|
||||
LUA_InvalidateUserdata(&subsectors[i]);
|
||||
for (i = 0; i < numsectors; i++)
|
||||
{
|
||||
LUA_InvalidateUserdata(§ors[i]);
|
||||
LUA_InvalidateUserdata(§ors[i].lines);
|
||||
|
||||
if (sectors[i].ffloors)
|
||||
{
|
||||
for (rover = sectors[i].ffloors; rover; rover = rover->next)
|
||||
LUA_InvalidateUserdata(rover);
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < numlines; i++)
|
||||
{
|
||||
LUA_InvalidateUserdata(&lines[i]);
|
||||
LUA_InvalidateUserdata(lines[i].sidenum);
|
||||
}
|
||||
|
||||
for (i = 0; i < numsides; i++)
|
||||
LUA_InvalidateUserdata(&sides[i]);
|
||||
for (i = 0; i < numvertexes; i++)
|
||||
LUA_InvalidateUserdata(&vertexes[i]);
|
||||
|
||||
for (pslope_t *slope = slopelist; slope; slope = slope->next)
|
||||
{
|
||||
LUA_InvalidateUserdata(slope);
|
||||
LUA_InvalidateUserdata(&slope->normal);
|
||||
LUA_InvalidateUserdata(&slope->o);
|
||||
LUA_InvalidateUserdata(&slope->d);
|
||||
}
|
||||
}
|
||||
|
||||
void LUA_InvalidateMapthings(void)
|
||||
{
|
||||
size_t i;
|
||||
|
||||
if (!gL)
|
||||
return;
|
||||
|
||||
for (i = 0; i < nummapthings; i++)
|
||||
{
|
||||
LUA_InvalidateUserdata(&mapthings[i]);
|
||||
}
|
||||
}
|
||||
|
||||
void LUA_InvalidatePlayer(player_t *player)
|
||||
{
|
||||
if (!gL)
|
||||
return;
|
||||
|
||||
LUA_InvalidateUserdata(player);
|
||||
LUA_InvalidateUserdata(player->powers);
|
||||
LUA_InvalidateUserdata(player->kartstuff);
|
||||
@@ -586,7 +611,7 @@ static const struct {
|
||||
{META_SUBSECTOR,ARCH_SUBSECTOR},
|
||||
{META_SECTOR, ARCH_SECTOR},
|
||||
{META_SLOPE, ARCH_SLOPE},
|
||||
{META_MAPHEADER, ARCH_MAPHEADER},
|
||||
{META_MAPHEADER,ARCH_MAPHEADER},
|
||||
{NULL, ARCH_NULL}
|
||||
};
|
||||
|
||||
@@ -940,7 +965,7 @@ static void ArchiveTables(UINT8 **p)
|
||||
}
|
||||
}
|
||||
|
||||
static UINT8 UnArchiveValue(UINT8 **p, int TABLESINDEX)
|
||||
static UINT8 UnArchiveValue(UINT8 **p, int TABLESINDEX, boolean network)
|
||||
{
|
||||
UINT8 type = READUINT8(*p);
|
||||
switch (type)
|
||||
@@ -992,6 +1017,12 @@ static UINT8 UnArchiveValue(UINT8 **p, int TABLESINDEX)
|
||||
LUA_PushUserdata(gL, &states[READUINT16(*p)], META_STATE);
|
||||
break;
|
||||
case ARCH_MOBJ:
|
||||
if (network == false) // for replays :chaosleep:
|
||||
{
|
||||
*p += sizeof(UINT32); // Skip this data, we can't read a mobj here, it'd point to garbage and crash the game.
|
||||
return 3; // Don't set the field
|
||||
}
|
||||
|
||||
LUA_PushUserdata(gL, P_FindNewPosition(READUINT32(*p)), META_MOBJ);
|
||||
break;
|
||||
case ARCH_PLAYER:
|
||||
@@ -1033,106 +1064,6 @@ static UINT8 UnArchiveValue(UINT8 **p, int TABLESINDEX)
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
// Unarchives from demo_p:
|
||||
// Return values:
|
||||
// 0: Normal
|
||||
// 1: Read table key
|
||||
// 2: Read table value
|
||||
// 3: Don't use setfield
|
||||
|
||||
static UINT8 UnArchiveValueDemo(UINT8 **p, int TABLESINDEX, char field[1024])
|
||||
{
|
||||
UINT8 type = READUINT8(*p);
|
||||
switch (type)
|
||||
{
|
||||
case ARCH_NULL:
|
||||
lua_pushnil(gL);
|
||||
break;
|
||||
case ARCH_BOOLEAN:
|
||||
lua_pushboolean(gL, READUINT8(*p));
|
||||
break;
|
||||
case ARCH_SIGNED:
|
||||
lua_pushinteger(gL, READFIXED(*p));
|
||||
break;
|
||||
case ARCH_STRING:
|
||||
{
|
||||
UINT16 len = READUINT16(*p); // length of string, including embedded zeros
|
||||
char *value;
|
||||
UINT16 i = 0;
|
||||
// See my comments in the ArchiveValue function;
|
||||
// it's much the same for reading strings as writing them!
|
||||
// (i.e. we can't use READSTRING either)
|
||||
// -- Monster Iestyn 05/08/18
|
||||
value = malloc(len); // make temp buffer of size len
|
||||
// now read the actual string
|
||||
while (i < len)
|
||||
value[i++] = READCHAR(*p); // read chars individually, including the embedded zeros
|
||||
lua_pushlstring(gL, value, len); // push the string (note: this function supports embedded zeros)
|
||||
free(value); // free the buffer
|
||||
break;
|
||||
}
|
||||
case ARCH_TABLE:
|
||||
{
|
||||
UINT16 tid = READUINT16(*p);
|
||||
lua_rawgeti(gL, TABLESINDEX, tid);
|
||||
if (lua_isnil(gL, -1))
|
||||
{
|
||||
lua_pop(gL, 1);
|
||||
lua_newtable(gL);
|
||||
lua_pushvalue(gL, -1);
|
||||
lua_rawseti(gL, TABLESINDEX, tid);
|
||||
return 2;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case ARCH_MOBJINFO:
|
||||
LUA_PushUserdata(gL, &mobjinfo[READUINT16(*p)], META_MOBJINFO);
|
||||
break;
|
||||
case ARCH_STATE:
|
||||
LUA_PushUserdata(gL, &states[READUINT16(*p)], META_STATE);
|
||||
break;
|
||||
case ARCH_MOBJ:
|
||||
*p += sizeof(UINT32); // Skip this data, we can't read a mobj here, it'd point to garbage and crash the game.
|
||||
if (field)
|
||||
CONS_Alert(CONS_WARNING,"Cannot read mobj_t stored in player variable \'%s\'. Desyncs may occur.\n", field);
|
||||
else
|
||||
CONS_Alert(CONS_WARNING,"Couldn't read mobj_t\n");
|
||||
return 3; // Don't set the field
|
||||
|
||||
case ARCH_PLAYER:
|
||||
LUA_PushUserdata(gL, &players[READUINT8(*p)], META_PLAYER);
|
||||
break;
|
||||
case ARCH_MAPTHING:
|
||||
LUA_PushUserdata(gL, &mapthings[READUINT16(*p)], META_MAPTHING);
|
||||
break;
|
||||
case ARCH_VERTEX:
|
||||
LUA_PushUserdata(gL, &vertexes[READUINT16(*p)], META_VERTEX);
|
||||
break;
|
||||
case ARCH_LINE:
|
||||
LUA_PushUserdata(gL, &lines[READUINT16(*p)], META_LINE);
|
||||
break;
|
||||
case ARCH_SIDE:
|
||||
LUA_PushUserdata(gL, &sides[READUINT16(*p)], META_SIDE);
|
||||
break;
|
||||
case ARCH_SUBSECTOR:
|
||||
LUA_PushUserdata(gL, &subsectors[READUINT16(*p)], META_SUBSECTOR);
|
||||
break;
|
||||
case ARCH_SECTOR:
|
||||
LUA_PushUserdata(gL, §ors[READUINT16(*p)], META_SECTOR);
|
||||
break;
|
||||
case ARCH_SLOPE:
|
||||
LUA_PushUserdata(gL, P_SlopeById(READUINT16(*p)), META_SLOPE);
|
||||
break;
|
||||
case ARCH_MAPHEADER:
|
||||
LUA_PushUserdata(gL, mapheaderinfo[READUINT16(*p)], META_MAPHEADER);
|
||||
break;
|
||||
case ARCH_TEND:
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void UnArchiveExtVars(UINT8 **p, void *pointer, boolean network)
|
||||
{
|
||||
int TABLESINDEX;
|
||||
@@ -1152,29 +1083,25 @@ static void UnArchiveExtVars(UINT8 **p, void *pointer, boolean network)
|
||||
TABLESINDEX = lua_gettop(gL);
|
||||
lua_createtable(gL, 0, field_count); // pointer's ext vars subtable
|
||||
|
||||
if (network)
|
||||
for (i = 0; i < field_count; i++)
|
||||
{
|
||||
for (i = 0; i < field_count; i++)
|
||||
{
|
||||
READSTRING(*p, field);
|
||||
UINT8 ret;
|
||||
READSTRING(*p, field);
|
||||
|
||||
if (UnArchiveValue(p, TABLESINDEX) == 1)
|
||||
{
|
||||
CONS_Alert(CONS_ERROR, "Unexpected end marker when reading ExtVars (field '%s')\n", field);
|
||||
break;
|
||||
}
|
||||
ret = UnArchiveValue(p, TABLESINDEX, network);
|
||||
|
||||
lua_setfield(gL, -2, field);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (i = 0; i < field_count; i++)
|
||||
if (ret == 1)
|
||||
{
|
||||
READSTRING(*p, field);
|
||||
if (UnArchiveValueDemo(p, TABLESINDEX, field) != 3) // This will return 3 if we shouldn't set this field.
|
||||
lua_setfield(gL, -2, field);
|
||||
CONS_Alert(CONS_ERROR, "Unexpected end marker when reading ExtVars (field '%s')\n", field);
|
||||
break;
|
||||
}
|
||||
else if (ret == 3) // This will return 3 if we shouldn't set this field.
|
||||
{
|
||||
CONS_Alert(CONS_WARNING,"Cannot read mobj_t stored in player variable \'%s\'. Desyncs may occur.\n", field);
|
||||
continue;
|
||||
}
|
||||
|
||||
lua_setfield(gL, -2, field);
|
||||
}
|
||||
|
||||
lua_getfield(gL, LUA_REGISTRYINDEX, LREG_EXTVARS);
|
||||
@@ -1191,7 +1118,7 @@ static int NetUnArchive(lua_State *L)
|
||||
savebuffer_t *save = lua_touserdata(L, lua_upvalueindex(2));
|
||||
int i, n = lua_gettop(L);
|
||||
for (i = 1; i <= n; i++)
|
||||
UnArchiveValue(&save->p, TABLESINDEX);
|
||||
UnArchiveValue(&save->p, TABLESINDEX, true);
|
||||
return n;
|
||||
}
|
||||
|
||||
@@ -1221,35 +1148,29 @@ static void UnArchiveTables(UINT8 **p, boolean network)
|
||||
{
|
||||
UINT8 ret;
|
||||
|
||||
if (network)
|
||||
ret = UnArchiveValue(p, TABLESINDEX, network);
|
||||
if (ret == 3)
|
||||
{
|
||||
if (UnArchiveValue(p, TABLESINDEX) == 1) // read key
|
||||
break;
|
||||
|
||||
ret = UnArchiveValue(p, TABLESINDEX);
|
||||
if (ret == 1)
|
||||
{
|
||||
CONS_Alert(CONS_ERROR, "Unexpected end of save reached (Corrupted save?)\n");
|
||||
lua_pop(gL, 1); // Pop key
|
||||
break;
|
||||
}
|
||||
else if (ret == 2) // read value
|
||||
n++;
|
||||
CONS_Alert(CONS_WARNING,"Couldn't read mobj_t\n");
|
||||
lua_pushnil(gL);
|
||||
}
|
||||
else
|
||||
else if (ret == 1) // read key
|
||||
break;
|
||||
|
||||
ret = UnArchiveValue(p, TABLESINDEX, network);
|
||||
if (ret == 1)
|
||||
{
|
||||
ret = UnArchiveValueDemo(p, TABLESINDEX, NULL);
|
||||
if (ret == 3)
|
||||
lua_pushnil(gL);
|
||||
else if (ret == 1) // read key
|
||||
break;
|
||||
|
||||
ret = UnArchiveValueDemo(p, TABLESINDEX, NULL);
|
||||
if (ret == 3)
|
||||
lua_pushnil(gL);
|
||||
else if (ret == 2) // read value
|
||||
n++;
|
||||
CONS_Alert(CONS_ERROR, "Unexpected end of save reached (Corrupted save?)\n");
|
||||
lua_pop(gL, 1); // Pop key
|
||||
break;
|
||||
}
|
||||
else if (ret == 3)
|
||||
{
|
||||
CONS_Alert(CONS_WARNING,"Couldn't read mobj_t\n");
|
||||
lua_pushnil(gL);
|
||||
}
|
||||
else if (ret == 2) // read value
|
||||
n++;
|
||||
|
||||
if (lua_isnil(gL, -2)) // if key is nil (if a function etc was accidentally saved)
|
||||
{
|
||||
|
||||
+9
-2
@@ -32,6 +32,7 @@ consvar_t cv_gif_downscale = {"gif_downscale", "On", CV_SAVE, CV_OnOff, NULL, 0
|
||||
#ifdef HAVE_ANIGIF
|
||||
static boolean gif_optimize = false; // So nobody can do something dumb
|
||||
static boolean gif_downscale = false; // like changing cvars mid output
|
||||
static RGBA_t *gif_palette = NULL;
|
||||
|
||||
static FILE *gif_out = NULL;
|
||||
static INT32 gif_frames = 0;
|
||||
@@ -461,13 +462,15 @@ static size_t gifframe_size = 8192;
|
||||
// converts an RGB frame to a frame with a palette.
|
||||
//
|
||||
#ifdef HWRENDER
|
||||
static colorlookup_t gif_colorlookup;
|
||||
|
||||
static void GIF_rgbconvert(UINT8 *linear, UINT8 *scr)
|
||||
{
|
||||
UINT8 r, g, b;
|
||||
size_t src, dest;
|
||||
int x, y;
|
||||
|
||||
InitColorLUT();
|
||||
InitColorLUT(&gif_colorlookup, gif_palette, true);
|
||||
|
||||
for (x = 0; x < vid.width; x += scrbuf_downscaleamt)
|
||||
{
|
||||
@@ -479,7 +482,7 @@ static void GIF_rgbconvert(UINT8 *linear, UINT8 *scr)
|
||||
r = (UINT8)linear[src];
|
||||
g = (UINT8)linear[src + 1];
|
||||
b = (UINT8)linear[src + 2];
|
||||
scr[dest] = colorlookup[r >> SHIFTCOLORBITS][g >> SHIFTCOLORBITS][b >> SHIFTCOLORBITS];
|
||||
scr[dest] = GetColorLUTDirect(&gif_colorlookup, r, g, b);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -636,6 +639,10 @@ INT32 GIF_open(const char *filename)
|
||||
|
||||
gif_optimize = (!!cv_gif_optimize.value);
|
||||
gif_downscale = (!!cv_gif_downscale.value);
|
||||
|
||||
// no master palettes in SRB2Kart land
|
||||
gif_palette = pLocalPalette;
|
||||
|
||||
GIF_headwrite();
|
||||
gif_frames = 0;
|
||||
return 1;
|
||||
|
||||
+410
-386
File diff suppressed because it is too large.
Load diff
@@ -286,6 +286,9 @@ void Screenshot_option_Onchange(void);
|
||||
// Addons menu updating
|
||||
void Addons_option_Onchange(void);
|
||||
|
||||
// Moviemode menu updating
|
||||
void Moviemode_option_Onchange(void);
|
||||
|
||||
// Player distortion menu updating
|
||||
void PDistort_menu_Onchange(void);
|
||||
|
||||
|
||||
+121
-14
@@ -110,6 +110,9 @@ consvar_t cv_screenshot_folder = {"screenshot_folder", "", CV_SAVE, NULL, NULL,
|
||||
static CV_PossibleValue_t moviemode_cons_t[] = {{MM_GIF, "GIF"}, {MM_APNG, "aPNG"}, {MM_SCREENSHOT, "Screenshots"}, {0, NULL}};
|
||||
consvar_t cv_moviemode = {"moviemode_mode", "GIF", CV_SAVE|CV_CALL, moviemode_cons_t, Moviemode_mode_Onchange, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
consvar_t cv_movie_option = {"movie_option", "Default", CV_SAVE|CV_CALL, screenshot_cons_t, Moviemode_option_Onchange, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_movie_folder = {"movie_folder", "", CV_SAVE, NULL, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
static CV_PossibleValue_t zlib_mem_level_t[] = {
|
||||
{1, "(Min Memory) 1"},
|
||||
{2, "2"}, {3, "3"}, {4, "4"}, {5, "5"}, {6, "6"}, {7, "7"},
|
||||
@@ -1144,19 +1147,25 @@ static inline moviemode_t M_StartMovieGIF(const char *pathname)
|
||||
void M_StartMovie(void)
|
||||
{
|
||||
#if NUMSCREENS > 2
|
||||
const char *pathname = ".";
|
||||
char pathname[MAX_WADPATH];
|
||||
|
||||
if (moviemode)
|
||||
return;
|
||||
|
||||
if (cv_screenshot_option.value == 0)
|
||||
pathname = usehome ? srb2home : srb2path;
|
||||
else if (cv_screenshot_option.value == 1)
|
||||
pathname = srb2home;
|
||||
else if (cv_screenshot_option.value == 2)
|
||||
pathname = srb2path;
|
||||
else if (cv_screenshot_option.value == 3 && *cv_screenshot_folder.string != '\0')
|
||||
pathname = cv_screenshot_folder.string;
|
||||
if (cv_movie_option.value == 0)
|
||||
strcpy(pathname, usehome ? srb2home : srb2path);
|
||||
else if (cv_movie_option.value == 1)
|
||||
strcpy(pathname, srb2home);
|
||||
else if (cv_movie_option.value == 2)
|
||||
strcpy(pathname, srb2path);
|
||||
else if (cv_movie_option.value == 3 && *cv_movie_folder.string != '\0')
|
||||
strcpy(pathname, cv_movie_folder.string);
|
||||
|
||||
if (cv_movie_option.value != 3)
|
||||
{
|
||||
strcat(pathname, PATHSEP"gifs"PATHSEP);
|
||||
I_mkdir(pathname, 0755);
|
||||
}
|
||||
|
||||
if (rendermode == render_none)
|
||||
I_Error("Can't make a movie without a render system\n");
|
||||
@@ -1482,7 +1491,8 @@ void M_ScreenShot(void)
|
||||
void M_DoScreenShot(void)
|
||||
{
|
||||
#if NUMSCREENS > 2
|
||||
const char *freename = NULL, *pathname = ".";
|
||||
const char *freename = NULL;
|
||||
char pathname[MAX_WADPATH];
|
||||
boolean ret = false;
|
||||
UINT8 *linear = NULL;
|
||||
|
||||
@@ -1494,13 +1504,19 @@ void M_DoScreenShot(void)
|
||||
return;
|
||||
|
||||
if (cv_screenshot_option.value == 0)
|
||||
pathname = usehome ? srb2home : srb2path;
|
||||
strcpy(pathname, usehome ? srb2home : srb2path);
|
||||
else if (cv_screenshot_option.value == 1)
|
||||
pathname = srb2home;
|
||||
strcpy(pathname, srb2home);
|
||||
else if (cv_screenshot_option.value == 2)
|
||||
pathname = srb2path;
|
||||
strcpy(pathname, srb2path);
|
||||
else if (cv_screenshot_option.value == 3 && *cv_screenshot_folder.string != '\0')
|
||||
pathname = cv_screenshot_folder.string;
|
||||
strcpy(pathname, cv_screenshot_folder.string);
|
||||
|
||||
if (cv_screenshot_option.value != 3)
|
||||
{
|
||||
strcat(pathname, PATHSEP"screenshots"PATHSEP);
|
||||
I_mkdir(pathname, 0755);
|
||||
}
|
||||
|
||||
#ifdef USE_PNG
|
||||
freename = Newsnapshotfile(pathname,"png");
|
||||
@@ -2076,3 +2092,94 @@ const char *M_FileError(FILE *fp)
|
||||
else
|
||||
return "end-of-file";
|
||||
}
|
||||
|
||||
/** Return the number of parts of this path.
|
||||
*/
|
||||
int M_PathParts(const char *path)
|
||||
{
|
||||
int n;
|
||||
const char *p;
|
||||
const char *t;
|
||||
if (path == NULL)
|
||||
return 0;
|
||||
for (n = 0, p = path ;; ++n)
|
||||
{
|
||||
t = p;
|
||||
if (( p = strchr(p, PATHSEP[0]) ))
|
||||
p += strspn(p, PATHSEP);
|
||||
else
|
||||
{
|
||||
if (*t)/* there is something after the final delimiter */
|
||||
n++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
||||
/** Check whether a path is an absolute path.
|
||||
*/
|
||||
boolean M_IsPathAbsolute(const char *path)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
return ( strncmp(&path[1], ":\\", 2) == 0 );
|
||||
#else
|
||||
return ( path[0] == '/' );
|
||||
#endif
|
||||
}
|
||||
|
||||
/** I_mkdir for each part of the path.
|
||||
*/
|
||||
void M_MkdirEachUntil(const char *cpath, int start, int end, int mode)
|
||||
{
|
||||
char path[MAX_WADPATH];
|
||||
char *p;
|
||||
char *t;
|
||||
|
||||
if (end > 0 && end <= start)
|
||||
return;
|
||||
|
||||
strlcpy(path, cpath, sizeof path);
|
||||
#ifdef _WIN32
|
||||
if (strncmp(&path[1], ":\\", 2) == 0)
|
||||
p = &path[3];
|
||||
else
|
||||
#endif
|
||||
p = path;
|
||||
|
||||
if (end > 0)
|
||||
end -= start;
|
||||
|
||||
for (; start > 0; --start)
|
||||
{
|
||||
p += strspn(p, PATHSEP);
|
||||
if (!( p = strchr(p, PATHSEP[0]) ))
|
||||
return;
|
||||
}
|
||||
p += strspn(p, PATHSEP);
|
||||
for (;;)
|
||||
{
|
||||
if (end > 0 && !--end)
|
||||
break;
|
||||
|
||||
t = p;
|
||||
if (( p = strchr(p, PATHSEP[0]) ))
|
||||
{
|
||||
*p = '\0';
|
||||
I_mkdir(path, mode);
|
||||
*p = PATHSEP[0];
|
||||
p += strspn(p, PATHSEP);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (*t)
|
||||
I_mkdir(path, mode);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void M_MkdirEach(const char *path, int start, int mode)
|
||||
{
|
||||
M_MkdirEachUntil(path, start, -1, mode);
|
||||
}
|
||||
+6
-1
@@ -30,7 +30,7 @@ typedef enum {
|
||||
extern moviemode_t moviemode;
|
||||
|
||||
extern consvar_t cv_screenshot_option, cv_screenshot_folder;
|
||||
extern consvar_t cv_moviemode;
|
||||
extern consvar_t cv_moviemode, cv_movie_folder, cv_movie_option;
|
||||
extern consvar_t cv_zlib_memory, cv_zlib_level, cv_zlib_strategy, cv_zlib_window_bits;
|
||||
extern consvar_t cv_zlib_memorya, cv_zlib_levela, cv_zlib_strategya, cv_zlib_window_bitsa;
|
||||
extern consvar_t cv_apng_delay;
|
||||
@@ -99,6 +99,11 @@ void strcatbf(char *s1, const char *s2, const char *s3);
|
||||
|
||||
const char *M_FileError(FILE *handle);
|
||||
|
||||
int M_PathParts (const char *path);
|
||||
boolean M_IsPathAbsolute (const char *path);
|
||||
void M_MkdirEach (const char *path, int start, int mode);
|
||||
void M_MkdirEachUntil (const char *path, int start, int end, int mode);
|
||||
|
||||
// counting bits, for weapon ammo code, usually
|
||||
FUNCMATH UINT8 M_CountBits(UINT32 num, UINT8 size);
|
||||
|
||||
|
||||
+10
-4
@@ -577,8 +577,7 @@ static void PS_CountThinkers(void)
|
||||
ps_removecount.value.i = 0;
|
||||
for (thinker = thinkercap.next; thinker != &thinkercap; thinker = thinker->next)
|
||||
{
|
||||
if (thinker->function.acp1 != (actionf_p1)P_NullPrecipThinker)
|
||||
ps_thinkercount.value.i++;
|
||||
ps_thinkercount.value.i++;
|
||||
|
||||
if (thinker->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
|
||||
ps_removecount.value.i++;
|
||||
@@ -593,11 +592,18 @@ static void PS_CountThinkers(void)
|
||||
else
|
||||
ps_regularcount.value.i++;
|
||||
}
|
||||
else if (thinker->function.acp1 == (actionf_p1)P_NullPrecipThinker)
|
||||
ps_precipcount.value.i++;
|
||||
else
|
||||
ps_otherthcount.value.i++;
|
||||
}
|
||||
|
||||
for (thinker = precipcap.next; thinker != &precipcap; thinker = thinker->next)
|
||||
{
|
||||
if (thinker->function.acp1 != (actionf_p1)P_NullPrecipThinker)
|
||||
continue; // not a precipmobj thinker
|
||||
|
||||
ps_precipcount.value.i++;
|
||||
}
|
||||
|
||||
/*for (i = 0; i < NUM_THINKERLISTS; i++)
|
||||
{
|
||||
for (thinker = thlist[i].next; thinker != &thlist[i]; thinker = thinker->next)
|
||||
|
||||
+6
-4
@@ -3920,10 +3920,12 @@ void A_MineExplode(mobj_t *actor)
|
||||
for (d = 0; d < 16; d++)
|
||||
K_SpawnKartExplosion(actor->x, actor->y, actor->z, explodedist + 32*mapobjectscale, 32, type, d*(ANGLE_45/4), true, false, actor->target); // 32 <-> 64
|
||||
|
||||
skincolors_t color = SKINCOLOR_KETCHUP;
|
||||
|
||||
if (actor->target && actor->target->player)
|
||||
K_SpawnMineExplosion(actor, actor->target->player->skincolor);
|
||||
else
|
||||
K_SpawnMineExplosion(actor, SKINCOLOR_KETCHUP);
|
||||
color = actor->target->player->skincolor;
|
||||
|
||||
K_SpawnMineExplosion(actor, color);
|
||||
|
||||
P_SpawnMobj(actor->x, actor->y, actor->z, MT_MINEEXPLOSIONSOUND);
|
||||
|
||||
@@ -10137,7 +10139,7 @@ void A_RemoteDamage(mobj_t *actor)
|
||||
if (locvar2 == 1) // Kill mobj!
|
||||
{
|
||||
if (target->player) // players die using P_DamageMobj instead for some reason
|
||||
P_DamageMobj(target, source, source, 10000);
|
||||
P_DamageMobj(target, source, source, DMG_INSTAKILL);
|
||||
else
|
||||
P_KillMobj(target, source, source);
|
||||
}
|
||||
|
||||
+20
-26
@@ -327,7 +327,7 @@ void T_MoveFloor(floormove_t *movefloor)
|
||||
movefloor->direction = (movefloor->floordestheight < movefloor->sector->floorheight) ? -1 : 1;
|
||||
movefloor->sector->floorspeed = movefloor->speed * movefloor->direction;
|
||||
movefloor->delaytimer = movefloor->delay;
|
||||
P_RecalcPrecipInSector(movefloor->sector);
|
||||
movefloor->sector->moved = true;
|
||||
return; // not break, why did this work? Graue 04-03-2004
|
||||
case bounceFloorCrush: // Graue 03-27-2004
|
||||
if (movefloor->floordestheight == lines[movefloor->texture].frontsector->floorheight)
|
||||
@@ -343,14 +343,14 @@ void T_MoveFloor(floormove_t *movefloor)
|
||||
movefloor->direction = (movefloor->floordestheight < movefloor->sector->floorheight) ? -1 : 1;
|
||||
movefloor->sector->floorspeed = movefloor->speed * movefloor->direction;
|
||||
movefloor->delaytimer = movefloor->delay;
|
||||
P_RecalcPrecipInSector(movefloor->sector);
|
||||
movefloor->sector->moved = true;
|
||||
return; // not break, why did this work? Graue 04-03-2004
|
||||
case crushFloorOnce:
|
||||
movefloor->floordestheight = lines[movefloor->texture].frontsector->floorheight;
|
||||
movefloor->direction = -1;
|
||||
movefloor->sector->soundorg.z = movefloor->sector->floorheight;
|
||||
S_StartSound(&movefloor->sector->soundorg,sfx_pstop);
|
||||
P_RecalcPrecipInSector(movefloor->sector);
|
||||
movefloor->sector->moved = true;
|
||||
return;
|
||||
default:
|
||||
break;
|
||||
@@ -376,7 +376,7 @@ void T_MoveFloor(floormove_t *movefloor)
|
||||
movefloor->direction = (movefloor->floordestheight < movefloor->sector->floorheight) ? -1 : 1;
|
||||
movefloor->sector->floorspeed = movefloor->speed * movefloor->direction;
|
||||
movefloor->delaytimer = movefloor->delay;
|
||||
P_RecalcPrecipInSector(movefloor->sector);
|
||||
movefloor->sector->moved = true;
|
||||
return; // not break, why did this work? Graue 04-03-2004
|
||||
case bounceFloorCrush: // Graue 03-27-2004
|
||||
if (movefloor->floordestheight == lines[movefloor->texture].frontsector->floorheight)
|
||||
@@ -392,13 +392,13 @@ void T_MoveFloor(floormove_t *movefloor)
|
||||
movefloor->direction = (movefloor->floordestheight < movefloor->sector->floorheight) ? -1 : 1;
|
||||
movefloor->sector->floorspeed = movefloor->speed * movefloor->direction;
|
||||
movefloor->delaytimer = movefloor->delay;
|
||||
P_RecalcPrecipInSector(movefloor->sector);
|
||||
movefloor->sector->moved = true;
|
||||
return; // not break, why did this work? Graue 04-03-2004
|
||||
case crushFloorOnce:
|
||||
movefloor->sector->floordata = NULL; // Clear up the thinker so others can use it
|
||||
P_RemoveThinker(&movefloor->thinker);
|
||||
movefloor->sector->floorspeed = 0;
|
||||
P_RecalcPrecipInSector(movefloor->sector);
|
||||
movefloor->sector->moved = true;
|
||||
return;
|
||||
default:
|
||||
break;
|
||||
@@ -415,7 +415,7 @@ void T_MoveFloor(floormove_t *movefloor)
|
||||
else
|
||||
movefloor->sector->floorspeed = 0;
|
||||
|
||||
P_RecalcPrecipInSector(movefloor->sector);
|
||||
movefloor->sector->moved = true;
|
||||
}
|
||||
|
||||
//
|
||||
@@ -817,7 +817,6 @@ void T_BounceCheese(levelspecthink_t *bouncer)
|
||||
bouncer->sector->floorheight = bouncer->sector->ceilingheight - (halfheight*2);
|
||||
T_MovePlane(bouncer->sector, 0, bouncer->sector->ceilingheight, 0, 1, -1); // update things on ceiling
|
||||
T_MovePlane(bouncer->sector, 0, bouncer->sector->floorheight, 0, 0, -1); // update things on floor
|
||||
P_RecalcPrecipInSector(actionsector);
|
||||
bouncer->sector->ceilingdata = NULL;
|
||||
bouncer->sector->floordata = NULL;
|
||||
bouncer->sector->floorspeed = 0;
|
||||
@@ -833,7 +832,6 @@ void T_BounceCheese(levelspecthink_t *bouncer)
|
||||
bouncer->sector->floorheight = floorheight;
|
||||
T_MovePlane(bouncer->sector, 0, bouncer->sector->ceilingheight, 0, 1, -1); // update things on ceiling
|
||||
T_MovePlane(bouncer->sector, 0, bouncer->sector->floorheight, 0, 0, -1); // update things on floor
|
||||
P_RecalcPrecipInSector(actionsector);
|
||||
bouncer->sector->ceilingdata = NULL;
|
||||
bouncer->sector->floordata = NULL;
|
||||
bouncer->sector->floorspeed = 0;
|
||||
@@ -913,9 +911,6 @@ void T_BounceCheese(levelspecthink_t *bouncer)
|
||||
|
||||
if (bouncer->distance > 0)
|
||||
bouncer->distance--;
|
||||
|
||||
if (actionsector)
|
||||
P_RecalcPrecipInSector(actionsector);
|
||||
}
|
||||
#undef speed
|
||||
#undef distance
|
||||
@@ -1102,7 +1097,6 @@ void T_StartCrumble(elevator_t *elevator)
|
||||
{
|
||||
sector = §ors[i];
|
||||
sector->moved = true;
|
||||
P_RecalcPrecipInSector(sector);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1156,7 +1150,7 @@ void T_MarioBlock(levelspecthink_t *block)
|
||||
}
|
||||
|
||||
for (i = -1; (i = P_FindSectorFromTag((INT16)block->vars[0], i)) >= 0 ;)
|
||||
P_RecalcPrecipInSector(§ors[i]);
|
||||
sectors[i].moved = true;
|
||||
|
||||
#undef speed
|
||||
#undef direction
|
||||
@@ -1272,7 +1266,7 @@ void T_FloatSector(levelspecthink_t *floater)
|
||||
else if (floater->sector->crumblestate == 0 || floater->sector->crumblestate >= 3/* || floatanyway*/)
|
||||
EV_BounceSector(floater->sector, FRACUNIT, floater->sourceline);
|
||||
|
||||
P_RecalcPrecipInSector(actionsector);
|
||||
actionsector->moved = true;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1974,7 +1968,7 @@ void T_ThwompSector(levelspecthink_t *thwomp)
|
||||
thwomp->sector->floorspeed = 0;
|
||||
}
|
||||
|
||||
P_RecalcPrecipInSector(actionsector);
|
||||
actionsector->moved = true;
|
||||
#undef speed
|
||||
#undef direction
|
||||
#undef distance
|
||||
@@ -2119,11 +2113,11 @@ void T_EachTimeThinker(levelspecthink_t *eachtime)
|
||||
sec = §ors[secnum];
|
||||
|
||||
FOFsector = false;
|
||||
INT32 special = GETSECSPECIAL(sec->special, 2);
|
||||
const INT32 secspecial = GETSECSPECIAL(sec->special, 2);
|
||||
|
||||
if (special == 3 || special == 5)
|
||||
if (secspecial == 3 || secspecial == 5)
|
||||
floortouch = true;
|
||||
else if (special >= 1 && special <= 8)
|
||||
else if (secspecial >= 1 && secspecial <= 8)
|
||||
floortouch = false;
|
||||
else
|
||||
continue;
|
||||
@@ -2255,7 +2249,7 @@ void T_EachTimeThinker(levelspecthink_t *eachtime)
|
||||
continue;
|
||||
|
||||
if (!(players[i].mo->subsector->sector == sec
|
||||
|| P_PlayerTouchingSectorSpecial(&players[i], 2, special) == sec))
|
||||
|| P_PlayerTouchingSectorSpecial(&players[i], 2, GETSECSPECIAL(sec->special, 2)) == sec))
|
||||
continue;
|
||||
|
||||
if (floortouch == true && P_IsObjectOnRealGround(players[i].mo, sec))
|
||||
@@ -2299,9 +2293,9 @@ void T_EachTimeThinker(levelspecthink_t *eachtime)
|
||||
|
||||
while ((affectPlayer = P_HavePlayersEnteredArea(playersArea, oldPlayersArea, inAndOut)) != -1)
|
||||
{
|
||||
INT32 special = GETSECSPECIAL(sec->special, 2);
|
||||
const INT32 secspecial = GETSECSPECIAL(sec->special, 2);
|
||||
|
||||
if (special == 2 || special == 3)
|
||||
if (secspecial == 2 || secspecial == 3)
|
||||
{
|
||||
for (i = 0; i < MAXPLAYERS; i++)
|
||||
{
|
||||
@@ -2503,7 +2497,7 @@ void T_RaiseSector(levelspecthink_t *raise)
|
||||
raise->sector->floorspeed = raise->vars[3]*raise->vars[8];
|
||||
|
||||
for (i = -1; (i = P_FindSectorFromTag(raise->sourceline->tag, i)) >= 0 ;)
|
||||
P_RecalcPrecipInSector(§ors[i]);
|
||||
sectors[i].moved = true;
|
||||
}
|
||||
|
||||
void T_CameraScanner(elevator_t *elevator)
|
||||
@@ -2920,12 +2914,12 @@ void EV_CrumbleChain(sector_t *sec, ffloor_t *rover)
|
||||
fixed_t a, b, c;
|
||||
mobjtype_t type = MT_ROCKCRUMBLE1;
|
||||
const fixed_t spacing = 48*mapobjectscale;
|
||||
INT32 special = GETSECSPECIAL(rover->master->frontsector->special, 3);
|
||||
const INT32 secspecial = GETSECSPECIAL(rover->master->frontsector->special, 3);
|
||||
|
||||
// If the control sector has a special
|
||||
// of Section3:7-15, use the custom debris.
|
||||
if (special >= 8)
|
||||
type = MT_ROCKCRUMBLE1+(special-7);
|
||||
if (secspecial >= 8)
|
||||
type = MT_ROCKCRUMBLE1+(secspecial-7);
|
||||
|
||||
// soundorg z height never gets set normally, so MEH.
|
||||
sec->soundorg.z = sec->floorheight;
|
||||
|
||||
+11
-7
@@ -2364,10 +2364,9 @@ static void P_RingDamage(player_t *player, mobj_t *inflictor, mobj_t *source, IN
|
||||
* player is hit by a ring, the player who shot it. In some
|
||||
* cases, the target will go after this object after
|
||||
* receiving damage. This can be NULL.
|
||||
* \param damage Amount of damage to be dealt. 10000 is instant death.
|
||||
* \param damage Amount of damage to be dealt. DMG_INSTAKILL is instant death.
|
||||
* \return True if the target sustained damage, otherwise false.
|
||||
* \todo Clean up this mess, split into multiple functions.
|
||||
* \todo Get rid of the magic number 10000.
|
||||
* \sa P_KillMobj
|
||||
*/
|
||||
boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 damage)
|
||||
@@ -2378,14 +2377,18 @@ boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 da
|
||||
if (objectplacing)
|
||||
return false;
|
||||
|
||||
// well no clue but this may happen ig
|
||||
if (!target)
|
||||
return false;
|
||||
|
||||
if (target->health <= 0)
|
||||
return false;
|
||||
|
||||
// Spectator handling
|
||||
if (netgame)
|
||||
{
|
||||
if (damage == 42000 && target->player && target->player->spectator)
|
||||
damage = 10000;
|
||||
if (damage == DMG_SPECTATOR && target->player && target->player->spectator)
|
||||
damage = DMG_INSTAKILL;
|
||||
else if (target->player && target->player->spectator)
|
||||
return false;
|
||||
|
||||
@@ -2397,6 +2400,7 @@ boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 da
|
||||
if (!metalrecording)
|
||||
{
|
||||
UINT8 shouldForce = LUA_HookShouldDamage(target, inflictor, source, damage);
|
||||
|
||||
if (P_MobjWasRemoved(target))
|
||||
return (shouldForce == 1); // mobj was removed
|
||||
if (shouldForce == 1)
|
||||
@@ -2524,7 +2528,7 @@ boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 da
|
||||
{
|
||||
if ((G_BattleGametype()) && cv_suddendeath.value
|
||||
&& !player->powers[pw_flashing] && !player->powers[pw_invulnerability])
|
||||
damage = 10000;
|
||||
damage = DMG_INSTAKILL;
|
||||
}
|
||||
|
||||
// Player hits another player
|
||||
@@ -2538,7 +2542,7 @@ boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 da
|
||||
return false;
|
||||
|
||||
// Instant-Death
|
||||
if (damage == 10000)
|
||||
if (damage == DMG_INSTAKILL)
|
||||
P_KillPlayer(player, source, damage);
|
||||
else if (player->kartstuff[k_invincibilitytimer] > 0 || player->kartstuff[k_growshrinktimer] > 0 || player->powers[pw_flashing])
|
||||
{
|
||||
@@ -2591,7 +2595,7 @@ boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 da
|
||||
else
|
||||
{
|
||||
player->health -= damage; // mirror mobj health here
|
||||
if (damage < 10000)
|
||||
if (damage < DMG_INSTAKILL)
|
||||
{
|
||||
target->player->powers[pw_flashing] = K_GetKartFlashing(target->player);
|
||||
if (damage > 0) // don't spill emeralds/ammo/panels for shield damage
|
||||
|
||||
+39
-21
@@ -66,21 +66,38 @@
|
||||
|
||||
// both the head and tail of the thinker list
|
||||
extern thinker_t thinkercap;
|
||||
extern thinker_t precipcap;
|
||||
extern mobj_t *mobjcache;
|
||||
|
||||
void P_InitThinkers(void);
|
||||
void P_AddThinker(thinker_t *thinker);
|
||||
void P_AddPrecipThinker(thinker_t *thinker);
|
||||
void P_RemoveThinker(thinker_t *thinker);
|
||||
void P_UnlinkThinker(thinker_t *thinker);
|
||||
|
||||
//
|
||||
// P_USER
|
||||
//
|
||||
|
||||
typedef struct camera_s
|
||||
{
|
||||
boolean chase;
|
||||
boolean freecam;
|
||||
|
||||
angle_t localangle;
|
||||
INT32 localaiming;
|
||||
|
||||
angle_t aiming;
|
||||
|
||||
// Freecam: A button was held since entering from menu, so don't move camera
|
||||
UINT8 button_a_held;
|
||||
|
||||
// Freecam: aiming needs to be reset after switching from chasecam
|
||||
boolean reset_aiming;
|
||||
|
||||
// Hold up/down to pan the camera vertically
|
||||
SINT8 dpad_y_held;
|
||||
|
||||
// Things used by FS cameras.
|
||||
fixed_t viewheight;
|
||||
angle_t startangle;
|
||||
@@ -110,29 +127,30 @@ typedef struct camera_s
|
||||
|
||||
// SRB2Kart: camera pans while drifting
|
||||
fixed_t pan;
|
||||
|
||||
// postproccess effects
|
||||
UINT8 postimg;
|
||||
} camera_t;
|
||||
|
||||
// demo freecam or something before i commit die
|
||||
struct demofreecam_s {
|
||||
|
||||
camera_t *cam; // this is useful when the game is paused, notably
|
||||
mobj_t *soundmobj; // mobj to play sound from, used in s_sound
|
||||
|
||||
angle_t localangle; // keeps track of the cam angle for cmds
|
||||
angle_t localaiming; // ditto with aiming
|
||||
boolean turnheld; // holding turn button for gradual turn speed
|
||||
boolean keyboardlook; // keyboard look
|
||||
// post process types
|
||||
enum
|
||||
{
|
||||
POSTIMG_WATER = 1, // Underwater screen effect.
|
||||
POSTIMG_MOTION = 1<<1, // Unused motion blur effect.
|
||||
POSTIMG_FLIP = 1<<2, // Flipcam screen effect.
|
||||
POSTIMG_HEAT = 1<<3, // Heatwave screen effect.
|
||||
POSTIMG_MIRROR = 1<<4, // encore screen effect.
|
||||
};
|
||||
|
||||
extern struct demofreecam_s democam;
|
||||
|
||||
extern camera_t camera[MAXSPLITSCREENPLAYERS];
|
||||
extern consvar_t cv_cam_dist[MAXSPLITSCREENPLAYERS];
|
||||
extern consvar_t cv_cam_still[MAXSPLITSCREENPLAYERS];
|
||||
extern consvar_t cv_cam_height[MAXSPLITSCREENPLAYERS];
|
||||
extern consvar_t cv_cam_speed[MAXSPLITSCREENPLAYERS];
|
||||
extern consvar_t cv_cam_rotate[MAXSPLITSCREENPLAYERS];
|
||||
extern consvar_t cv_cam_rotspeed[MAXSPLITSCREENPLAYERS];
|
||||
extern consvar_t cv_cam_timeover[MAXSPLITSCREENPLAYERS];
|
||||
|
||||
extern consvar_t cv_freecam_speed[MAXSPLITSCREENPLAYERS];
|
||||
|
||||
extern consvar_t cv_tilting;
|
||||
extern consvar_t cv_quaketilt;
|
||||
@@ -150,10 +168,11 @@ void P_AddPlayerScore(player_t *player, UINT32 amount);
|
||||
void P_ResetCamera(player_t *player, camera_t *thiscam);
|
||||
boolean P_TryCameraMove(fixed_t x, fixed_t y, camera_t *thiscam);
|
||||
void P_SlideCameraMove(camera_t *thiscam);
|
||||
void P_DemoCameraMovement(camera_t *cam);
|
||||
//void P_DemoCameraMovement(camera_t *cam, UINT8 num);
|
||||
boolean P_MoveChaseCamera(player_t *player, camera_t *thiscam, boolean resetcalled);
|
||||
void P_ResetLocalCamAiming(player_t *player);
|
||||
void P_InitCameraCmd(void);
|
||||
void P_ToggleDemoCamera(UINT8 viewnum);
|
||||
void P_CalcChasePostImg(player_t *player, camera_t *thiscam);
|
||||
boolean P_PlayerInPain(player_t *player);
|
||||
void P_DoPlayerPain(player_t *player, mobj_t *source, mobj_t *inflictor);
|
||||
void P_ResetPlayer(player_t *player);
|
||||
@@ -238,7 +257,6 @@ mobj_t *P_SpawnMobj(fixed_t x, fixed_t y, fixed_t z, mobjtype_t type);
|
||||
|
||||
mobj_t *P_SpawnShadowMobj(mobj_t * caster);
|
||||
|
||||
void P_RecalcPrecipInSector(sector_t *sector);
|
||||
void P_PrecipitationEffects(void);
|
||||
|
||||
void P_RemoveMobj(mobj_t *th);
|
||||
@@ -296,7 +314,7 @@ void P_ColorTeamMissile(mobj_t *missile, player_t *source);
|
||||
// Special utility to return +1 or -1 depending on mobj's gravity
|
||||
FUNCINLINE static ATTRINLINE SINT8 P_MobjFlip(const mobj_t *mobj)
|
||||
{
|
||||
return (mobj && mobj->eflags & MFE_VERTICALFLIP) ? -1 : 1;
|
||||
return (mobj && (mobj->eflags & MFE_VERTICALFLIP)) ? -1 : 1;
|
||||
}
|
||||
|
||||
fixed_t P_GetMobjGravity(mobj_t *mo);
|
||||
@@ -353,8 +371,6 @@ extern line_t *ceilingline;
|
||||
extern line_t *blockingline;
|
||||
extern msecnode_t *sector_list;
|
||||
|
||||
extern mprecipsecnode_t *precipsector_list;
|
||||
|
||||
void P_UnsetThingPosition(mobj_t *thing);
|
||||
void P_SetThingPosition(mobj_t *thing);
|
||||
void P_SetUnderlayPosition(mobj_t *thing);
|
||||
@@ -378,7 +394,6 @@ void P_CheckHoopPosition(mobj_t *hoopthing, fixed_t x, fixed_t y, fixed_t z, fix
|
||||
boolean P_CheckSector(sector_t *sector, boolean crunch);
|
||||
|
||||
void P_DelSeclist(msecnode_t *node);
|
||||
void P_DelPrecipSeclist(mprecipsecnode_t *node);
|
||||
|
||||
void P_CreateSecNodeList(mobj_t *thing, fixed_t x, fixed_t y);
|
||||
void P_Initsecnode(void);
|
||||
@@ -406,7 +421,6 @@ extern precipmobj_t **precipblocklinks; // special blockmap for precip rendering
|
||||
extern struct minimapinfo
|
||||
{
|
||||
patch_t *minimap_pic;
|
||||
UINT8 mapthingcount;
|
||||
INT32 min_x, min_y;
|
||||
INT32 max_x, max_y;
|
||||
INT32 map_w, map_h;
|
||||
@@ -430,6 +444,10 @@ typedef struct BasicFF_s
|
||||
INT32 Magnitude; ///< Magnitude of the effect, in the range from 0 through 10,000.
|
||||
} BasicFF_t;
|
||||
|
||||
// replace damage magic numbers with smth readable
|
||||
#define DMG_INSTAKILL 10000
|
||||
#define DMG_SPECTATOR 42000
|
||||
|
||||
void P_ForceFeed(const player_t *player, INT32 attack, INT32 fade, tic_t duration, INT32 period);
|
||||
void P_ForceConstant(const BasicFF_t *FFInfo);
|
||||
void P_RampConstant(const BasicFF_t *FFInfo, INT32 Start, INT32 End);
|
||||
|
||||
+61
-266
@@ -46,9 +46,6 @@ static INT32 tmflags;
|
||||
fixed_t tmx;
|
||||
fixed_t tmy;
|
||||
|
||||
static precipmobj_t *tmprecipthing;
|
||||
static fixed_t preciptmbbox[4];
|
||||
|
||||
// If "floatok" true, move would be ok
|
||||
// if within "tmfloorz - tmceilingz".
|
||||
boolean floatok;
|
||||
@@ -68,7 +65,6 @@ line_t *ceilingline;
|
||||
line_t *blockingline;
|
||||
|
||||
msecnode_t *sector_list = NULL;
|
||||
mprecipsecnode_t *precipsector_list = NULL;
|
||||
camera_t *mapcampointer;
|
||||
|
||||
//
|
||||
@@ -76,9 +72,9 @@ camera_t *mapcampointer;
|
||||
//
|
||||
|
||||
//
|
||||
// P_TeleportMove
|
||||
// P_MoveOrigin - P_TeleportMove which KEEPS interpolation values.
|
||||
//
|
||||
static boolean P_TeleportMove(mobj_t *thing, fixed_t x, fixed_t y, fixed_t z)
|
||||
boolean P_MoveOrigin(mobj_t *thing, fixed_t x, fixed_t y, fixed_t z)
|
||||
{
|
||||
// the move is ok,
|
||||
// so link the thing into its new position
|
||||
@@ -108,28 +104,19 @@ static boolean P_TeleportMove(mobj_t *thing, fixed_t x, fixed_t y, fixed_t z)
|
||||
return true;
|
||||
}
|
||||
|
||||
//
|
||||
// P_SetOrigin - P_TeleportMove which RESETS interpolation values.
|
||||
//
|
||||
boolean P_SetOrigin(mobj_t *thing, fixed_t x, fixed_t y, fixed_t z)
|
||||
{
|
||||
boolean result = P_TeleportMove(thing, x, y, z);
|
||||
|
||||
if (result == true)
|
||||
if (P_MoveOrigin(thing, x, y, z))
|
||||
{
|
||||
thing->old_x = thing->x;
|
||||
thing->old_y = thing->y;
|
||||
thing->old_z = thing->z;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
//
|
||||
// P_MoveOrigin - P_TeleportMove which KEEPS interpolation values.
|
||||
//
|
||||
boolean P_MoveOrigin(mobj_t *thing, fixed_t x, fixed_t y, fixed_t z)
|
||||
{
|
||||
return P_TeleportMove(thing, x, y, z);
|
||||
return true;
|
||||
}
|
||||
|
||||
// =========================================================================
|
||||
@@ -235,14 +222,15 @@ boolean P_DoSpring(mobj_t *spring, mobj_t *object)
|
||||
|
||||
if (!demo.playback || P_AnalogMove(object->player))
|
||||
{
|
||||
if (object->player == &players[consoleplayer])
|
||||
localangle[0] = spring->angle;
|
||||
else if (object->player == &players[displayplayers[1]])
|
||||
localangle[1] = spring->angle;
|
||||
else if (object->player == &players[displayplayers[2]])
|
||||
localangle[2] = spring->angle;
|
||||
else if (object->player == &players[displayplayers[3]])
|
||||
localangle[3] = spring->angle;
|
||||
for (UINT8 j = 0; j <= splitscreen; ++j)
|
||||
{
|
||||
INT32 id = (j == 0 ? consoleplayer : displayplayers[j]);
|
||||
if (object->player == &players[id])
|
||||
{
|
||||
localangle[j] = spring->angle;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -724,7 +712,7 @@ static boolean PIT_CheckThing(mobj_t *thing)
|
||||
HU_SetCEchoDuration(5);
|
||||
HU_DoCEcho(va("%s\\was hit by a kitchen sink.\\\\\\\\", player_names[thing->player-players]));
|
||||
I_OutputMsg("%s was hit by a kitchen sink.\n", player_names[thing->player-players]);
|
||||
P_DamageMobj(thing, tmthing, tmthing->target, 10000);
|
||||
P_DamageMobj(thing, tmthing, tmthing->target, DMG_INSTAKILL);
|
||||
P_KillMobj(tmthing, thing, thing);
|
||||
}
|
||||
|
||||
@@ -991,7 +979,7 @@ static boolean PIT_CheckThing(mobj_t *thing)
|
||||
HU_SetCEchoDuration(5);
|
||||
HU_DoCEcho(va("%s\\was hit by a kitchen sink.\\\\\\\\", player_names[tmthing->player-players]));
|
||||
I_OutputMsg("%s was hit by a kitchen sink.\n", player_names[tmthing->player-players]);
|
||||
P_DamageMobj(tmthing, thing, thing->target, 10000);
|
||||
P_DamageMobj(tmthing, thing, thing->target, DMG_INSTAKILL);
|
||||
P_KillMobj(thing, tmthing, tmthing);
|
||||
}
|
||||
|
||||
@@ -1726,7 +1714,10 @@ boolean P_CheckPosition(mobj_t *thing, fixed_t x, fixed_t y)
|
||||
tmbbox[BOXRIGHT] = x + tmthing->radius;
|
||||
tmbbox[BOXLEFT] = x - tmthing->radius;
|
||||
|
||||
newsubsec = R_PointInSubsector(x, y);
|
||||
if (thing->x != x || thing->y != y || thing->subsector == NULL)
|
||||
newsubsec = R_PointInSubsector(x, y);
|
||||
else
|
||||
newsubsec = thing->subsector;
|
||||
|
||||
ceilingline = blockingline = NULL;
|
||||
|
||||
@@ -1748,7 +1739,7 @@ boolean P_CheckPosition(mobj_t *thing, fixed_t x, fixed_t y)
|
||||
|
||||
for (rover = newsubsec->sector->ffloors; rover; rover = rover->next)
|
||||
{
|
||||
fixed_t topheight, bottomheight;
|
||||
fixed_t topheight, bottomheight, midheight;
|
||||
|
||||
if (!(rover->flags & FF_EXISTS))
|
||||
continue;
|
||||
@@ -1813,10 +1804,10 @@ boolean P_CheckPosition(mobj_t *thing, fixed_t x, fixed_t y)
|
||||
continue;
|
||||
}
|
||||
|
||||
delta1 = thing->z - (bottomheight
|
||||
+ ((topheight - bottomheight)/2));
|
||||
delta2 = thingtop - (bottomheight
|
||||
+ ((topheight - bottomheight)/2));
|
||||
midheight = (bottomheight + ((topheight - bottomheight)/2));
|
||||
|
||||
delta1 = thing->z - midheight;
|
||||
delta2 = thingtop - midheight;
|
||||
|
||||
if (topheight > tmfloorz && abs(delta1) < abs(delta2)
|
||||
&& !(rover->flags & FF_REVERSEPLATFORM))
|
||||
@@ -1847,10 +1838,13 @@ boolean P_CheckPosition(mobj_t *thing, fixed_t x, fixed_t y)
|
||||
BMBOUNDFIX(xl, xh, yl, yh);
|
||||
|
||||
// Check polyobjects and see if tmfloorz/tmceilingz need to be altered
|
||||
// do we really have to iterate through the complete blockmap for polyobjects if there are no polyobjects on the map?
|
||||
if (numPolyObjects)
|
||||
{
|
||||
validcount++;
|
||||
|
||||
for (by = yl; by <= yh; by++)
|
||||
{
|
||||
for (bx = xl; bx <= xh; bx++)
|
||||
{
|
||||
INT32 offset;
|
||||
@@ -1901,12 +1895,14 @@ boolean P_CheckPosition(mobj_t *thing, fixed_t x, fixed_t y)
|
||||
delta1 = thing->z - (polybottom + ((polytop - polybottom)/2));
|
||||
delta2 = thingtop - (polybottom + ((polytop - polybottom)/2));
|
||||
|
||||
if (polytop > tmfloorz && abs(delta1) < abs(delta2)) {
|
||||
if (polytop > tmfloorz && abs(delta1) < abs(delta2))
|
||||
{
|
||||
tmfloorz = tmdropoffz = polytop;
|
||||
tmfloorslope = NULL;
|
||||
}
|
||||
|
||||
if (polybottom < tmceilingz && abs(delta1) >= abs(delta2)) {
|
||||
if (polybottom < tmceilingz && abs(delta1) >= abs(delta2))
|
||||
{
|
||||
tmceilingz = tmdrpoffceilz = polybottom;
|
||||
tmceilingslope = NULL;
|
||||
}
|
||||
@@ -1914,6 +1910,7 @@ boolean P_CheckPosition(mobj_t *thing, fixed_t x, fixed_t y)
|
||||
plink = (polymaplink_t *)(plink->link.next);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// tmfloorthing is set when tmfloorz comes from a thing's top
|
||||
@@ -1994,7 +1991,11 @@ boolean P_CheckCameraPosition(fixed_t x, fixed_t y, camera_t *thiscam)
|
||||
tmbbox[BOXRIGHT] = x + thiscam->radius;
|
||||
tmbbox[BOXLEFT] = x - thiscam->radius;
|
||||
|
||||
newsubsec = R_PointInSubsector(x, y);
|
||||
if (thiscam->x != x || thiscam->y != y || thiscam->subsector == NULL)
|
||||
newsubsec = R_PointInSubsector(x, y);
|
||||
else
|
||||
newsubsec = thiscam->subsector;
|
||||
|
||||
ceilingline = blockingline = NULL;
|
||||
|
||||
mapcampointer = thiscam;
|
||||
@@ -2073,6 +2074,8 @@ boolean P_CheckCameraPosition(fixed_t x, fixed_t y, camera_t *thiscam)
|
||||
BMBOUNDFIX(xl, xh, yl, yh);
|
||||
|
||||
// Check polyobjects and see if tmfloorz/tmceilingz need to be altered
|
||||
// do we really have to iterate through the complete blockmap for polyobjects if there are no polyobjects on the map?
|
||||
if (numPolyObjects)
|
||||
{
|
||||
validcount++;
|
||||
|
||||
@@ -2164,7 +2167,8 @@ boolean P_CheckCameraPosition(fixed_t x, fixed_t y, camera_t *thiscam)
|
||||
//
|
||||
boolean P_TryCameraMove(fixed_t x, fixed_t y, camera_t *thiscam)
|
||||
{
|
||||
subsector_t *s = R_PointInSubsector(x, y);
|
||||
subsector_t *s;
|
||||
|
||||
boolean retval = true;
|
||||
boolean itsatwodlevel = false;
|
||||
UINT8 i;
|
||||
@@ -2174,6 +2178,11 @@ boolean P_TryCameraMove(fixed_t x, fixed_t y, camera_t *thiscam)
|
||||
if (dedicated) // this crashes so don't even try it
|
||||
return false;
|
||||
|
||||
if (thiscam->x != x || thiscam->y != y || thiscam->subsector == NULL)
|
||||
s = R_PointInSubsector(x, y);
|
||||
else
|
||||
s = thiscam->subsector;
|
||||
|
||||
if (twodlevel)
|
||||
itsatwodlevel = true;
|
||||
else
|
||||
@@ -2367,10 +2376,13 @@ boolean P_TryMove(mobj_t *thing, fixed_t x, fixed_t y, boolean allowdropoff)
|
||||
radius = MAXRADIUS/2;
|
||||
|
||||
do {
|
||||
if (thing->flags & MF_NOCLIP) {
|
||||
if (thing->flags & MF_NOCLIP)
|
||||
{
|
||||
tryx = x;
|
||||
tryy = y;
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
if (x-tryx > radius)
|
||||
tryx += radius;
|
||||
else if (x-tryx < -radius)
|
||||
@@ -2392,19 +2404,16 @@ boolean P_TryMove(mobj_t *thing, fixed_t x, fixed_t y, boolean allowdropoff)
|
||||
{
|
||||
//All things are affected by their scale.
|
||||
fixed_t maxstep = FixedMul(MAXSTEPMOVE, mapobjectscale);
|
||||
INT32 special = 0;
|
||||
|
||||
if (thing->player)
|
||||
{
|
||||
special = GETSECSPECIAL(R_PointInSubsector(x, y)->sector->special, 1);
|
||||
|
||||
// If using type Section1:13, double the maxstep.
|
||||
if (P_PlayerTouchingSectorSpecial(thing->player, 1, 13)
|
||||
|| special == 13)
|
||||
|| GETSECSPECIAL(R_PointInSubsector(x, y)->sector->special, 1) == 13)
|
||||
maxstep <<= 1;
|
||||
// If using type Section1:12, no maxstep. For ledges you don't want the player to climb! (see: Egg Zeppelin & SMK port walls)
|
||||
else if (P_PlayerTouchingSectorSpecial(thing->player, 1, 12)
|
||||
|| special == 12)
|
||||
|| GETSECSPECIAL(R_PointInSubsector(x, y)->sector->special, 1) == 12)
|
||||
maxstep = 0;
|
||||
}
|
||||
|
||||
@@ -2450,7 +2459,7 @@ boolean P_TryMove(mobj_t *thing, fixed_t x, fixed_t y, boolean allowdropoff)
|
||||
else if (maxstep > 0 && !(
|
||||
thing->player && (
|
||||
P_PlayerTouchingSectorSpecial(thing->player, 1, 14)
|
||||
|| special == 14)
|
||||
|| GETSECSPECIAL(R_PointInSubsector(x, y)->sector->special, 1) == 14)
|
||||
)) // Step down
|
||||
{
|
||||
// If the floor difference is MAXSTEPMOVE or less, and the sector isn't Section1:14, ALWAYS
|
||||
@@ -2514,14 +2523,16 @@ boolean P_TryMove(mobj_t *thing, fixed_t x, fixed_t y, boolean allowdropoff)
|
||||
if (!(thing->flags & MF_NOCLIPHEIGHT))
|
||||
{
|
||||
// Assign thing's standingslope if needed
|
||||
if (thing->z <= tmfloorz && !(thing->eflags & MFE_VERTICALFLIP)) {
|
||||
if (thing->z <= tmfloorz && !(thing->eflags & MFE_VERTICALFLIP))
|
||||
{
|
||||
if (!startingonground && tmfloorslope)
|
||||
P_HandleSlopeLanding(thing, tmfloorslope);
|
||||
|
||||
if (thing->momz <= 0)
|
||||
thing->standingslope = tmfloorslope;
|
||||
}
|
||||
else if (thing->z+thing->height >= tmceilingz && (thing->eflags & MFE_VERTICALFLIP)) {
|
||||
else if (thing->z+thing->height >= tmceilingz && (thing->eflags & MFE_VERTICALFLIP))
|
||||
{
|
||||
if (!startingonground && tmceilingslope)
|
||||
P_HandleSlopeLanding(thing, tmceilingslope);
|
||||
|
||||
@@ -3650,7 +3661,7 @@ static boolean PIT_ChangeSector(mobj_t *thing, boolean realcrush)
|
||||
{
|
||||
// Crush the object
|
||||
if (netgame && thing->player && thing->player->spectator)
|
||||
P_DamageMobj(thing, NULL, NULL, 42000); // Respawn crushed spectators
|
||||
P_DamageMobj(thing, NULL, NULL, DMG_SPECTATOR); // Respawn crushed spectators
|
||||
else
|
||||
{
|
||||
if (!killer)
|
||||
@@ -3660,7 +3671,7 @@ static boolean PIT_ChangeSector(mobj_t *thing, boolean realcrush)
|
||||
killer->threshold = 44; // Special flag for crushing
|
||||
}
|
||||
if (!thing->player)
|
||||
P_DamageMobj(thing, killer, killer, 10000);
|
||||
P_DamageMobj(thing, killer, killer, DMG_INSTAKILL);
|
||||
else
|
||||
K_SquishPlayer(thing->player, killer, killer); // SRB2kart - Squish instead of kill
|
||||
}
|
||||
@@ -3706,8 +3717,6 @@ boolean P_CheckSector(sector_t *sector, boolean crunch)
|
||||
|
||||
sec->moved = true;
|
||||
|
||||
P_RecalcPrecipInSector(sec);
|
||||
|
||||
if (!sector->attachedsolid[i])
|
||||
continue;
|
||||
|
||||
@@ -3768,8 +3777,6 @@ boolean P_CheckSector(sector_t *sector, boolean crunch)
|
||||
|
||||
sec->moved = true;
|
||||
|
||||
P_RecalcPrecipInSector(sec);
|
||||
|
||||
if (!sector->attachedsolid[i])
|
||||
continue;
|
||||
|
||||
@@ -3820,12 +3827,10 @@ boolean P_CheckSector(sector_t *sector, boolean crunch)
|
||||
*/
|
||||
|
||||
static msecnode_t *headsecnode = NULL;
|
||||
static mprecipsecnode_t *headprecipsecnode = NULL;
|
||||
|
||||
void P_Initsecnode(void)
|
||||
{
|
||||
headsecnode = NULL;
|
||||
headprecipsecnode = NULL;
|
||||
}
|
||||
|
||||
// P_GetSecnode() retrieves a node from the freelist. The calling routine
|
||||
@@ -3845,20 +3850,6 @@ static msecnode_t *P_GetSecnode(void)
|
||||
return node;
|
||||
}
|
||||
|
||||
static mprecipsecnode_t *P_GetPrecipSecnode(void)
|
||||
{
|
||||
mprecipsecnode_t *node;
|
||||
|
||||
if (headprecipsecnode)
|
||||
{
|
||||
node = headprecipsecnode;
|
||||
headprecipsecnode = headprecipsecnode->m_thinglist_next;
|
||||
}
|
||||
else
|
||||
node = Z_Calloc(sizeof (*node), PU_LEVEL, NULL);
|
||||
return node;
|
||||
}
|
||||
|
||||
// P_PutSecnode() returns a node to the freelist.
|
||||
|
||||
static inline void P_PutSecnode(msecnode_t *node)
|
||||
@@ -3867,13 +3858,6 @@ static inline void P_PutSecnode(msecnode_t *node)
|
||||
headsecnode = node;
|
||||
}
|
||||
|
||||
// Tails 08-25-2002
|
||||
static inline void P_PutPrecipSecnode(mprecipsecnode_t *node)
|
||||
{
|
||||
node->m_thinglist_next = headprecipsecnode;
|
||||
headprecipsecnode = node;
|
||||
}
|
||||
|
||||
// P_AddSecnode() searches the current list to see if this sector is
|
||||
// already there. If not, it adds a sector node at the head of the list of
|
||||
// sectors this object appears in. This is called when creating a list of
|
||||
@@ -3919,47 +3903,6 @@ static msecnode_t *P_AddSecnode(sector_t *s, mobj_t *thing, msecnode_t *nextnode
|
||||
return node;
|
||||
}
|
||||
|
||||
// More crazy crap Tails 08-25-2002
|
||||
static mprecipsecnode_t *P_AddPrecipSecnode(sector_t *s, precipmobj_t *thing, mprecipsecnode_t *nextnode)
|
||||
{
|
||||
mprecipsecnode_t *node;
|
||||
|
||||
node = nextnode;
|
||||
while (node)
|
||||
{
|
||||
if (node->m_sector == s) // Already have a node for this sector?
|
||||
{
|
||||
node->m_thing = thing; // Yes. Setting m_thing says 'keep it'.
|
||||
return nextnode;
|
||||
}
|
||||
node = node->m_sectorlist_next;
|
||||
}
|
||||
|
||||
// Couldn't find an existing node for this sector. Add one at the head
|
||||
// of the list.
|
||||
|
||||
node = P_GetPrecipSecnode();
|
||||
|
||||
// mark new nodes unvisited.
|
||||
node->visited = 0;
|
||||
|
||||
node->m_sector = s; // sector
|
||||
node->m_thing = thing; // mobj
|
||||
node->m_sectorlist_prev = NULL; // prev node on Thing thread
|
||||
node->m_sectorlist_next = nextnode; // next node on Thing thread
|
||||
if (nextnode)
|
||||
nextnode->m_sectorlist_prev = node; // set back link on Thing
|
||||
|
||||
// Add new node at head of sector thread starting at s->touching_thinglist
|
||||
|
||||
node->m_thinglist_prev = NULL; // prev node on sector thread
|
||||
node->m_thinglist_next = s->touching_preciplist; // next node on sector thread
|
||||
if (s->touching_preciplist)
|
||||
node->m_thinglist_next->m_thinglist_prev = node;
|
||||
s->touching_preciplist = node;
|
||||
return node;
|
||||
}
|
||||
|
||||
// P_DelSecnode() deletes a sector node from the list of
|
||||
// sectors this object appears in. Returns a pointer to the next node
|
||||
// on the linked list, or NULL.
|
||||
@@ -4002,45 +3945,6 @@ static msecnode_t *P_DelSecnode(msecnode_t *node)
|
||||
return tn;
|
||||
}
|
||||
|
||||
// Tails 08-25-2002
|
||||
static mprecipsecnode_t *P_DelPrecipSecnode(mprecipsecnode_t *node)
|
||||
{
|
||||
mprecipsecnode_t *tp; // prev node on thing thread
|
||||
mprecipsecnode_t *tn; // next node on thing thread
|
||||
mprecipsecnode_t *sp; // prev node on sector thread
|
||||
mprecipsecnode_t *sn; // next node on sector thread
|
||||
|
||||
if (!node)
|
||||
return NULL;
|
||||
|
||||
// Unlink from the Thing thread. The Thing thread begins at
|
||||
// sector_list and not from mobj_t->touching_sectorlist.
|
||||
|
||||
tp = node->m_sectorlist_prev;
|
||||
tn = node->m_sectorlist_next;
|
||||
if (tp)
|
||||
tp->m_sectorlist_next = tn;
|
||||
if (tn)
|
||||
tn->m_sectorlist_prev = tp;
|
||||
|
||||
// Unlink from the sector thread. This thread begins at
|
||||
// sector_t->touching_thinglist.
|
||||
|
||||
sp = node->m_thinglist_prev;
|
||||
sn = node->m_thinglist_next;
|
||||
if (sp)
|
||||
sp->m_thinglist_next = sn;
|
||||
else
|
||||
node->m_sector->touching_preciplist = sn;
|
||||
if (sn)
|
||||
sn->m_thinglist_prev = sp;
|
||||
|
||||
// Return this node to the freelist
|
||||
|
||||
P_PutPrecipSecnode(node);
|
||||
return tn;
|
||||
}
|
||||
|
||||
// Delete an entire sector list
|
||||
void P_DelSeclist(msecnode_t *node)
|
||||
{
|
||||
@@ -4048,13 +3952,6 @@ void P_DelSeclist(msecnode_t *node)
|
||||
node = P_DelSecnode(node);
|
||||
}
|
||||
|
||||
// Tails 08-25-2002
|
||||
void P_DelPrecipSeclist(mprecipsecnode_t *node)
|
||||
{
|
||||
while (node)
|
||||
node = P_DelPrecipSecnode(node);
|
||||
}
|
||||
|
||||
// PIT_GetSectors
|
||||
// Locates all the sectors the object is in by looking at the lines that
|
||||
// cross through it. You have already decided that the object is allowed
|
||||
@@ -4095,41 +3992,6 @@ static inline boolean PIT_GetSectors(line_t *ld)
|
||||
return true;
|
||||
}
|
||||
|
||||
// Tails 08-25-2002
|
||||
static inline boolean PIT_GetPrecipSectors(line_t *ld)
|
||||
{
|
||||
if (preciptmbbox[BOXRIGHT] <= ld->bbox[BOXLEFT] ||
|
||||
preciptmbbox[BOXLEFT] >= ld->bbox[BOXRIGHT] ||
|
||||
preciptmbbox[BOXTOP] <= ld->bbox[BOXBOTTOM] ||
|
||||
preciptmbbox[BOXBOTTOM] >= ld->bbox[BOXTOP])
|
||||
return true;
|
||||
|
||||
if (P_BoxOnLineSide(preciptmbbox, ld) != -1)
|
||||
return true;
|
||||
|
||||
if (ld->polyobj) // line belongs to a polyobject, don't add it
|
||||
return true;
|
||||
|
||||
// This line crosses through the object.
|
||||
|
||||
// Collect the sector(s) from the line and add to the
|
||||
// sector_list you're examining. If the Thing ends up being
|
||||
// allowed to move to this position, then the sector_list
|
||||
// will be attached to the Thing's mobj_t at touching_sectorlist.
|
||||
|
||||
precipsector_list = P_AddPrecipSecnode(ld->frontsector, tmprecipthing, precipsector_list);
|
||||
|
||||
// Don't assume all lines are 2-sided, since some Things
|
||||
// like MT_TFOG are allowed regardless of whether their radius takes
|
||||
// them beyond an impassable linedef.
|
||||
|
||||
// Use sidedefs instead of 2s flag to determine two-sidedness.
|
||||
if (ld->backsector)
|
||||
precipsector_list = P_AddPrecipSecnode(ld->backsector, tmprecipthing, precipsector_list);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// P_CreateSecNodeList alters/creates the sector_list that shows what sectors
|
||||
// the object resides in.
|
||||
|
||||
@@ -4216,73 +4078,6 @@ void P_CreateSecNodeList(mobj_t *thing, fixed_t x, fixed_t y)
|
||||
}
|
||||
}
|
||||
|
||||
// More crazy crap Tails 08-25-2002
|
||||
void P_CreatePrecipSecNodeList(precipmobj_t *thing,fixed_t x,fixed_t y)
|
||||
{
|
||||
INT32 xl, xh, yl, yh, bx, by;
|
||||
mprecipsecnode_t *node = precipsector_list;
|
||||
precipmobj_t *saved_tmthing = tmprecipthing; /* cph - see comment at func end */
|
||||
|
||||
// First, clear out the existing m_thing fields. As each node is
|
||||
// added or verified as needed, m_thing will be set properly. When
|
||||
// finished, delete all nodes where m_thing is still NULL. These
|
||||
// represent the sectors the Thing has vacated.
|
||||
|
||||
while (node)
|
||||
{
|
||||
node->m_thing = NULL;
|
||||
node = node->m_sectorlist_next;
|
||||
}
|
||||
|
||||
tmprecipthing = thing;
|
||||
|
||||
preciptmbbox[BOXTOP] = y + 2*FRACUNIT;
|
||||
preciptmbbox[BOXBOTTOM] = y - 2*FRACUNIT;
|
||||
preciptmbbox[BOXRIGHT] = x + 2*FRACUNIT;
|
||||
preciptmbbox[BOXLEFT] = x - 2*FRACUNIT;
|
||||
|
||||
validcount++; // used to make sure we only process a line once
|
||||
|
||||
xl = (unsigned)(preciptmbbox[BOXLEFT] - bmaporgx)>>MAPBLOCKSHIFT;
|
||||
xh = (unsigned)(preciptmbbox[BOXRIGHT] - bmaporgx)>>MAPBLOCKSHIFT;
|
||||
yl = (unsigned)(preciptmbbox[BOXBOTTOM] - bmaporgy)>>MAPBLOCKSHIFT;
|
||||
yh = (unsigned)(preciptmbbox[BOXTOP] - bmaporgy)>>MAPBLOCKSHIFT;
|
||||
|
||||
BMBOUNDFIX(xl, xh, yl, yh);
|
||||
|
||||
for (bx = xl; bx <= xh; bx++)
|
||||
for (by = yl; by <= yh; by++)
|
||||
P_BlockLinesIterator(bx, by, PIT_GetPrecipSectors);
|
||||
|
||||
// Add the sector of the (x, y) point to sector_list.
|
||||
precipsector_list = P_AddPrecipSecnode(thing->subsector->sector, thing, precipsector_list);
|
||||
|
||||
// Now delete any nodes that won't be used. These are the ones where
|
||||
// m_thing is still NULL.
|
||||
node = precipsector_list;
|
||||
while (node)
|
||||
{
|
||||
if (!node->m_thing)
|
||||
{
|
||||
if (node == precipsector_list)
|
||||
precipsector_list = node->m_sectorlist_next;
|
||||
node = P_DelPrecipSecnode(node);
|
||||
}
|
||||
else
|
||||
node = node->m_sectorlist_next;
|
||||
}
|
||||
|
||||
/* cph -
|
||||
* This is the strife we get into for using global variables. tmthing
|
||||
* is being used by several different functions calling
|
||||
* P_BlockThingIterator, including functions that can be called *from*
|
||||
* P_BlockThingIterator. Using a global tmthing is not reentrant.
|
||||
* OTOH for Boom/MBF demos we have to preserve the buggy behavior.
|
||||
* Fun. We restore its previous value unless we're in a Boom/MBF demo.
|
||||
*/
|
||||
tmprecipthing = saved_tmthing;
|
||||
}
|
||||
|
||||
/* cphipps 2004/08/30 -
|
||||
* Must clear tmthing at tic end, as it might contain a pointer to a removed thinker, or the level might have ended/been ended and we clear the objects it was pointing too. Hopefully we don't need to carry this between tics for sync. */
|
||||
void P_MapStart(void)
|
||||
|
||||
+179
-163
@@ -296,7 +296,7 @@ void P_CameraLineOpening(line_t *linedef)
|
||||
{
|
||||
frontfloor = sectors[front->camsec].floorheight;
|
||||
frontceiling = sectors[front->camsec].ceilingheight;
|
||||
if (sectors[front->camsec].f_slope) // SRB2CBTODO: ESLOPE (sectors[front->heightsec].f_slope)
|
||||
if (sectors[front->camsec].f_slope)
|
||||
frontfloor = P_GetZAt(sectors[front->camsec].f_slope, camera[0].x, camera[0].y);
|
||||
if (sectors[front->camsec].c_slope)
|
||||
frontceiling = P_GetZAt(sectors[front->camsec].c_slope, camera[0].x, camera[0].y);
|
||||
@@ -306,7 +306,7 @@ void P_CameraLineOpening(line_t *linedef)
|
||||
{
|
||||
frontfloor = sectors[front->heightsec].floorheight;
|
||||
frontceiling = sectors[front->heightsec].ceilingheight;
|
||||
if (sectors[front->heightsec].f_slope) // SRB2CBTODO: ESLOPE (sectors[front->heightsec].f_slope)
|
||||
if (sectors[front->heightsec].f_slope)
|
||||
frontfloor = P_GetZAt(sectors[front->heightsec].f_slope, camera[0].x, camera[0].y);
|
||||
if (sectors[front->heightsec].c_slope)
|
||||
frontceiling = P_GetZAt(sectors[front->heightsec].c_slope, camera[0].x, camera[0].y);
|
||||
@@ -316,11 +316,12 @@ void P_CameraLineOpening(line_t *linedef)
|
||||
frontfloor = P_CameraGetFloorZ(mapcampointer, front, tmx, tmy, linedef);
|
||||
frontceiling = P_CameraGetCeilingZ(mapcampointer, front, tmx, tmy, linedef);
|
||||
}
|
||||
|
||||
if (back->camsec >= 0)
|
||||
{
|
||||
backfloor = sectors[back->camsec].floorheight;
|
||||
backceiling = sectors[back->camsec].ceilingheight;
|
||||
if (sectors[back->camsec].f_slope) // SRB2CBTODO: ESLOPE (sectors[front->heightsec].f_slope)
|
||||
if (sectors[back->camsec].f_slope)
|
||||
frontfloor = P_GetZAt(sectors[back->camsec].f_slope, camera[0].x, camera[0].y);
|
||||
if (sectors[back->camsec].c_slope)
|
||||
frontceiling = P_GetZAt(sectors[back->camsec].c_slope, camera[0].x, camera[0].y);
|
||||
@@ -329,7 +330,7 @@ void P_CameraLineOpening(line_t *linedef)
|
||||
{
|
||||
backfloor = sectors[back->heightsec].floorheight;
|
||||
backceiling = sectors[back->heightsec].ceilingheight;
|
||||
if (sectors[back->heightsec].f_slope) // SRB2CBTODO: ESLOPE (sectors[front->heightsec].f_slope)
|
||||
if (sectors[back->heightsec].f_slope)
|
||||
frontfloor = P_GetZAt(sectors[back->heightsec].f_slope, camera[0].x, camera[0].y);
|
||||
if (sectors[back->heightsec].c_slope)
|
||||
frontceiling = P_GetZAt(sectors[back->heightsec].c_slope, camera[0].x, camera[0].y);
|
||||
@@ -340,104 +341,111 @@ void P_CameraLineOpening(line_t *linedef)
|
||||
backceiling = P_CameraGetCeilingZ(mapcampointer, back, tmx, tmy, linedef);
|
||||
}
|
||||
|
||||
fixed_t thingtop = mapcampointer->z + mapcampointer->height;
|
||||
|
||||
if (frontceiling < backceiling)
|
||||
{
|
||||
fixed_t thingtop = mapcampointer->z + mapcampointer->height;
|
||||
|
||||
if (frontceiling < backceiling)
|
||||
{
|
||||
opentop = frontceiling;
|
||||
highceiling = backceiling;
|
||||
}
|
||||
else
|
||||
{
|
||||
opentop = backceiling;
|
||||
highceiling = frontceiling;
|
||||
}
|
||||
|
||||
if (frontfloor > backfloor)
|
||||
{
|
||||
openbottom = frontfloor;
|
||||
lowfloor = backfloor;
|
||||
}
|
||||
else
|
||||
{
|
||||
openbottom = backfloor;
|
||||
lowfloor = frontfloor;
|
||||
}
|
||||
|
||||
// Check for fake floors in the sector.
|
||||
if (front->ffloors || back->ffloors)
|
||||
{
|
||||
ffloor_t *rover;
|
||||
fixed_t highestceiling = highceiling;
|
||||
fixed_t lowestceiling = opentop;
|
||||
fixed_t highestfloor = openbottom;
|
||||
fixed_t lowestfloor = lowfloor;
|
||||
fixed_t delta1, delta2;
|
||||
|
||||
// Check for frontsector's fake floors
|
||||
if (front->ffloors)
|
||||
for (rover = front->ffloors; rover; rover = rover->next)
|
||||
{
|
||||
fixed_t topheight, bottomheight;
|
||||
if (!(rover->flags & FF_BLOCKOTHERS) || !(rover->flags & FF_RENDERALL) || !(rover->flags & FF_EXISTS) || GETSECSPECIAL(rover->master->frontsector->special, 4) == 12)
|
||||
continue;
|
||||
|
||||
topheight = P_CameraGetFOFTopZ(mapcampointer, front, rover, tmx, tmy, linedef);
|
||||
bottomheight = P_CameraGetFOFBottomZ(mapcampointer, front, rover, tmx, tmy, linedef);
|
||||
|
||||
delta1 = abs(mapcampointer->z - (bottomheight + ((topheight - bottomheight)/2)));
|
||||
delta2 = abs(thingtop - (bottomheight + ((topheight - bottomheight)/2)));
|
||||
if (bottomheight < lowestceiling && delta1 >= delta2)
|
||||
lowestceiling = bottomheight;
|
||||
else if (bottomheight < highestceiling && delta1 >= delta2)
|
||||
highestceiling = bottomheight;
|
||||
|
||||
if (topheight > highestfloor && delta1 < delta2)
|
||||
highestfloor = topheight;
|
||||
else if (topheight > lowestfloor && delta1 < delta2)
|
||||
lowestfloor = topheight;
|
||||
}
|
||||
|
||||
// Check for backsectors fake floors
|
||||
if (back->ffloors)
|
||||
for (rover = back->ffloors; rover; rover = rover->next)
|
||||
{
|
||||
fixed_t topheight, bottomheight;
|
||||
if (!(rover->flags & FF_BLOCKOTHERS) || !(rover->flags & FF_RENDERALL) || !(rover->flags & FF_EXISTS) || GETSECSPECIAL(rover->master->frontsector->special, 4) == 12)
|
||||
continue;
|
||||
|
||||
topheight = P_CameraGetFOFTopZ(mapcampointer, back, rover, tmx, tmy, linedef);
|
||||
bottomheight = P_CameraGetFOFBottomZ(mapcampointer, back, rover, tmx, tmy, linedef);
|
||||
|
||||
delta1 = abs(mapcampointer->z - (bottomheight + ((topheight - bottomheight)/2)));
|
||||
delta2 = abs(thingtop - (bottomheight + ((topheight - bottomheight)/2)));
|
||||
if (bottomheight < lowestceiling && delta1 >= delta2)
|
||||
lowestceiling = bottomheight;
|
||||
else if (bottomheight < highestceiling && delta1 >= delta2)
|
||||
highestceiling = bottomheight;
|
||||
|
||||
if (topheight > highestfloor && delta1 < delta2)
|
||||
highestfloor = topheight;
|
||||
else if (topheight > lowestfloor && delta1 < delta2)
|
||||
lowestfloor = topheight;
|
||||
}
|
||||
|
||||
if (highestceiling < highceiling)
|
||||
highceiling = highestceiling;
|
||||
|
||||
if (highestfloor > openbottom)
|
||||
openbottom = highestfloor;
|
||||
|
||||
if (lowestceiling < opentop)
|
||||
opentop = lowestceiling;
|
||||
|
||||
if (lowestfloor > lowfloor)
|
||||
lowfloor = lowestfloor;
|
||||
}
|
||||
openrange = opentop - openbottom;
|
||||
return;
|
||||
opentop = frontceiling;
|
||||
highceiling = backceiling;
|
||||
}
|
||||
else
|
||||
{
|
||||
opentop = backceiling;
|
||||
highceiling = frontceiling;
|
||||
}
|
||||
|
||||
if (frontfloor > backfloor)
|
||||
{
|
||||
openbottom = frontfloor;
|
||||
lowfloor = backfloor;
|
||||
}
|
||||
else
|
||||
{
|
||||
openbottom = backfloor;
|
||||
lowfloor = frontfloor;
|
||||
}
|
||||
|
||||
// Check for fake floors in the sector.
|
||||
if (front->ffloors || back->ffloors)
|
||||
{
|
||||
ffloor_t *rover;
|
||||
fixed_t highestceiling = highceiling;
|
||||
fixed_t lowestceiling = opentop;
|
||||
fixed_t highestfloor = openbottom;
|
||||
fixed_t lowestfloor = lowfloor;
|
||||
fixed_t delta1, delta2;
|
||||
|
||||
// Check for frontsector's fake floors
|
||||
if (front->ffloors)
|
||||
{
|
||||
for (rover = front->ffloors; rover; rover = rover->next)
|
||||
{
|
||||
fixed_t topheight, bottomheight;
|
||||
|
||||
if (!(rover->flags & FF_BLOCKOTHERS) || !(rover->flags & FF_RENDERALL) || !(rover->flags & FF_EXISTS) || GETSECSPECIAL(rover->master->frontsector->special, 4) == 12)
|
||||
continue;
|
||||
|
||||
topheight = P_CameraGetFOFTopZ(mapcampointer, front, rover, tmx, tmy, linedef);
|
||||
bottomheight = P_CameraGetFOFBottomZ(mapcampointer, front, rover, tmx, tmy, linedef);
|
||||
|
||||
delta1 = abs(mapcampointer->z - (bottomheight + ((topheight - bottomheight)/2)));
|
||||
delta2 = abs(thingtop - (bottomheight + ((topheight - bottomheight)/2)));
|
||||
|
||||
if (bottomheight < lowestceiling && delta1 >= delta2)
|
||||
lowestceiling = bottomheight;
|
||||
else if (bottomheight < highestceiling && delta1 >= delta2)
|
||||
highestceiling = bottomheight;
|
||||
|
||||
if (topheight > highestfloor && delta1 < delta2)
|
||||
highestfloor = topheight;
|
||||
else if (topheight > lowestfloor && delta1 < delta2)
|
||||
lowestfloor = topheight;
|
||||
}
|
||||
}
|
||||
|
||||
// Check for backsectors fake floors
|
||||
if (back->ffloors)
|
||||
{
|
||||
for (rover = back->ffloors; rover; rover = rover->next)
|
||||
{
|
||||
fixed_t topheight, bottomheight;
|
||||
|
||||
if (!(rover->flags & FF_BLOCKOTHERS) || !(rover->flags & FF_RENDERALL) || !(rover->flags & FF_EXISTS) || GETSECSPECIAL(rover->master->frontsector->special, 4) == 12)
|
||||
continue;
|
||||
|
||||
topheight = P_CameraGetFOFTopZ(mapcampointer, back, rover, tmx, tmy, linedef);
|
||||
bottomheight = P_CameraGetFOFBottomZ(mapcampointer, back, rover, tmx, tmy, linedef);
|
||||
|
||||
delta1 = abs(mapcampointer->z - (bottomheight + ((topheight - bottomheight)/2)));
|
||||
delta2 = abs(thingtop - (bottomheight + ((topheight - bottomheight)/2)));
|
||||
|
||||
if (bottomheight < lowestceiling && delta1 >= delta2)
|
||||
lowestceiling = bottomheight;
|
||||
else if (bottomheight < highestceiling && delta1 >= delta2)
|
||||
highestceiling = bottomheight;
|
||||
|
||||
if (topheight > highestfloor && delta1 < delta2)
|
||||
highestfloor = topheight;
|
||||
else if (topheight > lowestfloor && delta1 < delta2)
|
||||
lowestfloor = topheight;
|
||||
}
|
||||
}
|
||||
|
||||
if (highestceiling < highceiling)
|
||||
highceiling = highestceiling;
|
||||
|
||||
if (highestfloor > openbottom)
|
||||
openbottom = highestfloor;
|
||||
|
||||
if (lowestceiling < opentop)
|
||||
opentop = lowestceiling;
|
||||
|
||||
if (lowestfloor > lowfloor)
|
||||
lowfloor = lowestfloor;
|
||||
}
|
||||
|
||||
openrange = opentop - openbottom;
|
||||
return;
|
||||
}
|
||||
|
||||
void P_LineOpening(line_t *linedef, mobj_t *mobj)
|
||||
@@ -466,40 +474,39 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj)
|
||||
I_Assert(front != NULL);
|
||||
I_Assert(back != NULL);
|
||||
|
||||
{ // Set open and high/low values here
|
||||
fixed_t frontheight, backheight;
|
||||
// Set open and high/low values here
|
||||
fixed_t frontheight, backheight;
|
||||
|
||||
frontheight = P_GetCeilingZ(mobj, front, tmx, tmy, linedef);
|
||||
backheight = P_GetCeilingZ(mobj, back, tmx, tmy, linedef);
|
||||
frontheight = P_GetCeilingZ(mobj, front, tmx, tmy, linedef);
|
||||
backheight = P_GetCeilingZ(mobj, back, tmx, tmy, linedef);
|
||||
|
||||
if (frontheight < backheight)
|
||||
{
|
||||
opentop = frontheight;
|
||||
highceiling = backheight;
|
||||
opentopslope = front->c_slope;
|
||||
}
|
||||
else
|
||||
{
|
||||
opentop = backheight;
|
||||
highceiling = frontheight;
|
||||
opentopslope = back->c_slope;
|
||||
}
|
||||
if (frontheight < backheight)
|
||||
{
|
||||
opentop = frontheight;
|
||||
highceiling = backheight;
|
||||
opentopslope = front->c_slope;
|
||||
}
|
||||
else
|
||||
{
|
||||
opentop = backheight;
|
||||
highceiling = frontheight;
|
||||
opentopslope = back->c_slope;
|
||||
}
|
||||
|
||||
frontheight = P_GetFloorZ(mobj, front, tmx, tmy, linedef);
|
||||
backheight = P_GetFloorZ(mobj, back, tmx, tmy, linedef);
|
||||
frontheight = P_GetFloorZ(mobj, front, tmx, tmy, linedef);
|
||||
backheight = P_GetFloorZ(mobj, back, tmx, tmy, linedef);
|
||||
|
||||
if (frontheight > backheight)
|
||||
{
|
||||
openbottom = frontheight;
|
||||
lowfloor = backheight;
|
||||
openbottomslope = front->f_slope;
|
||||
}
|
||||
else
|
||||
{
|
||||
openbottom = backheight;
|
||||
lowfloor = frontheight;
|
||||
openbottomslope = back->f_slope;
|
||||
}
|
||||
if (frontheight > backheight)
|
||||
{
|
||||
openbottom = frontheight;
|
||||
lowfloor = backheight;
|
||||
openbottomslope = front->f_slope;
|
||||
}
|
||||
else
|
||||
{
|
||||
openbottom = backheight;
|
||||
lowfloor = frontheight;
|
||||
openbottomslope = back->f_slope;
|
||||
}
|
||||
|
||||
if (mobj)
|
||||
@@ -508,29 +515,33 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj)
|
||||
|
||||
// Check for collision with front side's midtexture if Effect 4 is set
|
||||
if (linedef->flags & ML_EFFECT4
|
||||
&& !linedef->polyobj // don't do anything for polyobjects! ...for now
|
||||
) {
|
||||
&& !linedef->polyobj) // don't do anything for polyobjects! ...for now
|
||||
{
|
||||
side_t *side = &sides[linedef->sidenum[0]];
|
||||
fixed_t textop, texbottom, texheight;
|
||||
fixed_t texmid, delta1, delta2;
|
||||
INT32 texnum = R_GetTextureNum(side->midtexture); // make sure the texture is actually valid
|
||||
|
||||
if (texnum) {
|
||||
if (texnum)
|
||||
{
|
||||
// Get the midtexture's height
|
||||
texheight = textures[texnum]->height << FRACBITS;
|
||||
|
||||
// Set texbottom and textop to the Z coordinates of the texture's boundaries
|
||||
if (linedef->flags & ML_EFFECT5 && !side->repeatcnt) // "infinite" repeat
|
||||
{
|
||||
if (linedef->flags & ML_EFFECT5 && !side->repeatcnt) { // "infinite" repeat
|
||||
texbottom = openbottom + side->rowoffset;
|
||||
textop = opentop + side->rowoffset;
|
||||
} else if (!!(linedef->flags & ML_DONTPEGBOTTOM) ^ !!(linedef->flags & ML_EFFECT3)) {
|
||||
texbottom = openbottom + side->rowoffset;
|
||||
textop = texbottom + texheight*(side->repeatcnt+1);
|
||||
} else {
|
||||
textop = opentop + side->rowoffset;
|
||||
texbottom = textop - texheight*(side->repeatcnt+1);
|
||||
}
|
||||
texbottom = openbottom + side->rowoffset;
|
||||
textop = opentop + side->rowoffset;
|
||||
}
|
||||
else if (!!(linedef->flags & ML_DONTPEGBOTTOM) ^ !!(linedef->flags & ML_EFFECT3))
|
||||
{
|
||||
texbottom = openbottom + side->rowoffset;
|
||||
textop = texbottom + texheight*(side->repeatcnt+1);
|
||||
}
|
||||
else
|
||||
{
|
||||
textop = opentop + side->rowoffset;
|
||||
texbottom = textop - texheight*(side->repeatcnt+1);
|
||||
}
|
||||
|
||||
texmid = texbottom+(textop-texbottom)/2;
|
||||
@@ -538,10 +549,13 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj)
|
||||
delta1 = abs(mobj->z - texmid);
|
||||
delta2 = abs(thingtop - texmid);
|
||||
|
||||
if (delta1 > delta2) { // Below
|
||||
if (delta1 > delta2) // Below
|
||||
{
|
||||
if (opentop > texbottom)
|
||||
opentop = texbottom;
|
||||
} else { // Above
|
||||
}
|
||||
else // Above
|
||||
{
|
||||
if (openbottom < textop)
|
||||
openbottom = textop;
|
||||
}
|
||||
@@ -549,9 +563,7 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj)
|
||||
}
|
||||
|
||||
// Check for fake floors in the sector.
|
||||
if (front->ffloors || back->ffloors
|
||||
|| linedef->polyobj
|
||||
)
|
||||
if (front->ffloors || back->ffloors || linedef->polyobj)
|
||||
{
|
||||
ffloor_t *rover;
|
||||
|
||||
@@ -567,6 +579,7 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj)
|
||||
for (rover = front->ffloors; rover; rover = rover->next)
|
||||
{
|
||||
fixed_t topheight, bottomheight;
|
||||
|
||||
if (!(rover->flags & FF_EXISTS))
|
||||
continue;
|
||||
|
||||
@@ -584,7 +597,8 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj)
|
||||
|
||||
if (delta1 >= delta2 && !(rover->flags & FF_PLATFORM)) // thing is below FOF
|
||||
{
|
||||
if (bottomheight < lowestceiling) {
|
||||
if (bottomheight < lowestceiling)
|
||||
{
|
||||
lowestceiling = bottomheight;
|
||||
ceilingslope = *rover->b_slope;
|
||||
}
|
||||
@@ -594,7 +608,8 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj)
|
||||
|
||||
if (delta1 < delta2 && !(rover->flags & FF_REVERSEPLATFORM)) // thing is above FOF
|
||||
{
|
||||
if (topheight > highestfloor) {
|
||||
if (topheight > highestfloor)
|
||||
{
|
||||
highestfloor = topheight;
|
||||
floorslope = *rover->t_slope;
|
||||
}
|
||||
@@ -624,7 +639,8 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj)
|
||||
|
||||
if (delta1 >= delta2 && !(rover->flags & FF_PLATFORM)) // thing is below FOF
|
||||
{
|
||||
if (bottomheight < lowestceiling) {
|
||||
if (bottomheight < lowestceiling)
|
||||
{
|
||||
lowestceiling = bottomheight;
|
||||
ceilingslope = *rover->b_slope;
|
||||
}
|
||||
@@ -634,7 +650,8 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj)
|
||||
|
||||
if (delta1 < delta2 && !(rover->flags & FF_REVERSEPLATFORM)) // thing is above FOF
|
||||
{
|
||||
if (topheight > highestfloor) {
|
||||
if (topheight > highestfloor)
|
||||
{
|
||||
highestfloor = topheight;
|
||||
floorslope = *rover->t_slope;
|
||||
}
|
||||
@@ -650,29 +667,35 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj)
|
||||
|
||||
delta1 = abs(mobj->z - (polysec->floorheight + ((polysec->ceilingheight - polysec->floorheight)/2)));
|
||||
delta2 = abs(thingtop - (polysec->floorheight + ((polysec->ceilingheight - polysec->floorheight)/2)));
|
||||
if (polysec->floorheight < lowestceiling && delta1 >= delta2) {
|
||||
|
||||
if (polysec->floorheight < lowestceiling && delta1 >= delta2)
|
||||
{
|
||||
lowestceiling = polysec->floorheight;
|
||||
ceilingslope = NULL;
|
||||
}
|
||||
else if (polysec->floorheight < highestceiling && delta1 >= delta2)
|
||||
highestceiling = polysec->floorheight;
|
||||
|
||||
if (polysec->ceilingheight > highestfloor && delta1 < delta2) {
|
||||
if (polysec->ceilingheight > highestfloor && delta1 < delta2)
|
||||
{
|
||||
highestfloor = polysec->ceilingheight;
|
||||
floorslope = NULL;
|
||||
}
|
||||
else if (polysec->ceilingheight > lowestfloor && delta1 < delta2)
|
||||
lowestfloor = polysec->ceilingheight;
|
||||
}
|
||||
|
||||
if (highestceiling < highceiling)
|
||||
highceiling = highestceiling;
|
||||
|
||||
if (highestfloor > openbottom) {
|
||||
if (highestfloor > openbottom)
|
||||
{
|
||||
openbottom = highestfloor;
|
||||
openbottomslope = floorslope;
|
||||
}
|
||||
|
||||
if (lowestceiling < opentop) {
|
||||
if (lowestceiling < opentop)
|
||||
{
|
||||
opentop = lowestceiling;
|
||||
opentopslope = ceilingslope;
|
||||
}
|
||||
@@ -759,9 +782,6 @@ void P_UnsetPrecipThingPosition(precipmobj_t *thing)
|
||||
|
||||
if (bprev && (*bprev = bnext) != NULL) // unlink from block map
|
||||
bnext->bprev = bprev;
|
||||
|
||||
precipsector_list = thing->touching_sectorlist;
|
||||
thing->touching_sectorlist = NULL; //to be restored by P_SetPrecipThingPosition
|
||||
}
|
||||
|
||||
static void P_LinkToBlockMap(mobj_t *thing, mobj_t **bmap)
|
||||
@@ -906,10 +926,6 @@ void P_SetPrecipitationThingPosition(precipmobj_t *thing)
|
||||
{
|
||||
thing->subsector = R_PointInSubsector(thing->x, thing->y);
|
||||
|
||||
P_CreatePrecipSecNodeList(thing, thing->x, thing->y);
|
||||
thing->touching_sectorlist = precipsector_list; // Attach to Thing's precipmobj_t
|
||||
precipsector_list = NULL; // clear for next time
|
||||
|
||||
// NOTE: this works because bnext/bprev are at the same
|
||||
// offsets in precipmobj_t and mobj_t
|
||||
P_LinkToBlockMap((mobj_t*)thing, (mobj_t**)precipblocklinks);
|
||||
|
||||
+180
-136
@@ -435,7 +435,7 @@ void P_ExplodeMissile(mobj_t *mo)
|
||||
}
|
||||
|
||||
// Hack: Release an animal.
|
||||
P_DamageMobj(mo, NULL, NULL, 10000);
|
||||
P_DamageMobj(mo, NULL, NULL, DMG_INSTAKILL);
|
||||
}
|
||||
|
||||
mo->flags &= ~MF_MISSILE;
|
||||
@@ -1357,12 +1357,16 @@ void P_XYMovement(mobj_t *mo)
|
||||
oldy = mo->y;
|
||||
|
||||
// adjust various things based on slope
|
||||
if (mo->standingslope && abs(mo->standingslope->zdelta) > FRACUNIT>>8) {
|
||||
if (!P_IsObjectOnGround(mo)) { // We fell off at some point? Do the twisty thing!
|
||||
if (mo->standingslope && abs(mo->standingslope->zdelta) > FRACUNIT>>8)
|
||||
{
|
||||
if (!P_IsObjectOnGround(mo)) // We fell off at some point? Do the twisty thing!
|
||||
{
|
||||
P_SlopeLaunch(mo);
|
||||
xmove = mo->momx;
|
||||
ymove = mo->momy;
|
||||
} else { // Still on the ground.
|
||||
}
|
||||
else // Still on the ground.
|
||||
{
|
||||
slopemom.x = xmove;
|
||||
slopemom.y = ymove;
|
||||
slopemom.z = 0;
|
||||
@@ -1375,7 +1379,8 @@ void P_XYMovement(mobj_t *mo)
|
||||
|
||||
oldslope = mo->standingslope;
|
||||
}
|
||||
} else if (P_IsObjectOnGround(mo) && !mo->momz)
|
||||
}
|
||||
else if (P_IsObjectOnGround(mo) && !mo->momz)
|
||||
predictedz = mo->z;
|
||||
|
||||
// Pushables can break some blocks
|
||||
@@ -1882,13 +1887,13 @@ boolean P_CheckDeathPitCollide(mobj_t *mo)
|
||||
I_Assert(mo != NULL);
|
||||
I_Assert(!P_MobjWasRemoved(mo));
|
||||
|
||||
INT32 special = GETSECSPECIAL(mo->subsector->sector->special, 1);
|
||||
const INT32 secspecial = GETSECSPECIAL(mo->subsector->sector->special, 1);
|
||||
|
||||
if (((mo->z <= mo->subsector->sector->floorheight
|
||||
&& !(mo->eflags & MFE_VERTICALFLIP) && (mo->subsector->sector->flags & SF_FLIPSPECIAL_FLOOR))
|
||||
|| (mo->z + mo->height >= mo->subsector->sector->ceilingheight
|
||||
&& (mo->eflags & MFE_VERTICALFLIP) && (mo->subsector->sector->flags & SF_FLIPSPECIAL_CEILING)))
|
||||
&& (special == 6 || special == 7))
|
||||
&& (secspecial == 6 || secspecial == 7))
|
||||
return true;
|
||||
|
||||
return false;
|
||||
@@ -2480,55 +2485,58 @@ static void P_PlayerZMovement(mobj_t *mo)
|
||||
msecnode_t *node;
|
||||
boolean stopmovecut = false;
|
||||
|
||||
for (node = mo->touching_sectorlist; node; node = node->m_sectorlist_next)
|
||||
if (numPolyObjects)
|
||||
{
|
||||
sector_t *sec = node->m_sector;
|
||||
subsector_t *newsubsec;
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < numsubsectors; i++)
|
||||
for (node = mo->touching_sectorlist; node; node = node->m_sectorlist_next)
|
||||
{
|
||||
newsubsec = &subsectors[i];
|
||||
sector_t *sec = node->m_sector;
|
||||
subsector_t *newsubsec;
|
||||
size_t i;
|
||||
|
||||
if (newsubsec->sector != sec)
|
||||
continue;
|
||||
|
||||
if (!newsubsec->polyList)
|
||||
continue;
|
||||
|
||||
polyobj_t *po = newsubsec->polyList;
|
||||
sector_t *polysec;
|
||||
|
||||
while(po)
|
||||
for (i = 0; i < numsubsectors; i++)
|
||||
{
|
||||
if (!P_MobjInsidePolyobj(po, mo) || !(po->flags & POF_SOLID))
|
||||
{
|
||||
po = (polyobj_t *)(po->link.next);
|
||||
newsubsec = &subsectors[i];
|
||||
|
||||
if (newsubsec->sector != sec)
|
||||
continue;
|
||||
}
|
||||
|
||||
// We're inside it! Yess...
|
||||
polysec = po->lines[0]->backsector;
|
||||
|
||||
// Moving polyobjects should act like conveyors if the player lands on one. (I.E. none of the momentum cut thing below) -Red
|
||||
if ((mo->z == polysec->ceilingheight || mo->z+mo->height == polysec->floorheight) && po->thinker)
|
||||
stopmovecut = true;
|
||||
|
||||
if (!(po->flags & POF_LDEXEC))
|
||||
{
|
||||
po = (polyobj_t *)(po->link.next);
|
||||
if (!newsubsec->polyList)
|
||||
continue;
|
||||
}
|
||||
|
||||
if (mo->z == polysec->ceilingheight)
|
||||
polyobj_t *po = newsubsec->polyList;
|
||||
sector_t *polysec;
|
||||
|
||||
while(po)
|
||||
{
|
||||
// We're landing on a PO, so check for
|
||||
// a linedef executor.
|
||||
// Trigger tags are 32000 + the PO's ID number.
|
||||
P_LinedefExecute((INT16)(32000 + po->id), mo, NULL);
|
||||
}
|
||||
if (!P_MobjInsidePolyobj(po, mo) || !(po->flags & POF_SOLID))
|
||||
{
|
||||
po = (polyobj_t *)(po->link.next);
|
||||
continue;
|
||||
}
|
||||
|
||||
po = (polyobj_t *)(po->link.next);
|
||||
// We're inside it! Yess...
|
||||
polysec = po->lines[0]->backsector;
|
||||
|
||||
// Moving polyobjects should act like conveyors if the player lands on one. (I.E. none of the momentum cut thing below) -Red
|
||||
if ((mo->z == polysec->ceilingheight || mo->z+mo->height == polysec->floorheight) && po->thinker)
|
||||
stopmovecut = true;
|
||||
|
||||
if (!(po->flags & POF_LDEXEC))
|
||||
{
|
||||
po = (polyobj_t *)(po->link.next);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (mo->z == polysec->ceilingheight)
|
||||
{
|
||||
// We're landing on a PO, so check for
|
||||
// a linedef executor.
|
||||
// Trigger tags are 32000 + the PO's ID number.
|
||||
P_LinedefExecute((INT16)(32000 + po->id), mo, NULL);
|
||||
}
|
||||
|
||||
po = (polyobj_t *)(po->link.next);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -2999,11 +3007,6 @@ void P_MobjCheckWater(mobj_t *mobj)
|
||||
else if (mobj->eflags & MFE_VERTICALFLIP && mobj->momz > FixedMul(-min, mobj->scale))
|
||||
mobj->momz = FixedMul(-min, mobj->scale);
|
||||
|
||||
/*if (!(mobj->eflags & MFE_VERTICALFLIP) && mobj->momz > FixedMul(max, mobj->scale))
|
||||
mobj->momz = FixedMul(max, mobj->scale);
|
||||
else if (mobj->eflags & MFE_VERTICALFLIP && mobj->momz < FixedMul(-max, mobj->scale))
|
||||
mobj->momz = FixedMul(-max, mobj->scale);*/
|
||||
|
||||
p->kartstuff[k_waterskip]++;
|
||||
}
|
||||
|
||||
@@ -3141,7 +3144,7 @@ static boolean P_CameraCheckHeat(camera_t *thiscam)
|
||||
sector_t *sector;
|
||||
fixed_t halfheight;
|
||||
|
||||
if (!thiscam)
|
||||
if (!thiscam || !thiscam->subsector)
|
||||
return false;
|
||||
|
||||
halfheight = thiscam->z + (thiscam->height >> 1);
|
||||
@@ -3179,7 +3182,7 @@ static boolean P_CameraCheckWater(camera_t *thiscam)
|
||||
sector_t *sector;
|
||||
fixed_t halfheight;
|
||||
|
||||
if (!thiscam)
|
||||
if (!thiscam || !thiscam->subsector)
|
||||
return false;
|
||||
|
||||
halfheight = thiscam->z + (thiscam->height >> 1);
|
||||
@@ -3232,16 +3235,23 @@ void P_DestroyRobots(void)
|
||||
}
|
||||
|
||||
// the below is chasecam only, if you're curious. check out P_CalcPostImg in p_user.c for first person
|
||||
static void P_CalcChasePostImg(player_t *player, camera_t *thiscam)
|
||||
void P_CalcChasePostImg(player_t *player, camera_t *thiscam)
|
||||
{
|
||||
const boolean flipcam = (player->pflags & PF_FLIPCAM && !(player->pflags & PF_NIGHTSMODE) && player->mo->eflags & MFE_VERTICALFLIP);
|
||||
UINT16 postimgflags = 0;
|
||||
UINT8 i;
|
||||
UINT8 postimgtype = 0;
|
||||
|
||||
if (encoremode)
|
||||
postimgflags |= POSTIMG_MIRROR;
|
||||
postimgtype |= POSTIMG_MIRROR;
|
||||
if (flipcam)
|
||||
postimgflags |= POSTIMG_FLIP;
|
||||
postimgtype |= POSTIMG_FLIP;
|
||||
|
||||
#ifdef HWRENDER
|
||||
if (rendermode == render_opengl && splitscreen)
|
||||
{
|
||||
thiscam->postimg = postimgtype;
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (player->awayviewtics && player->awayviewmobj && !P_MobjWasRemoved(player->awayviewmobj)) // Camera must obviously exist
|
||||
{
|
||||
@@ -3256,27 +3266,20 @@ static void P_CalcChasePostImg(player_t *player, camera_t *thiscam)
|
||||
|
||||
// Are we in water?
|
||||
if (P_CameraCheckWater(&dummycam))
|
||||
postimgflags |= POSTIMG_WATER;
|
||||
if (P_CameraCheckHeat(&dummycam))
|
||||
postimgflags |= POSTIMG_HEAT;
|
||||
postimgtype |= POSTIMG_WATER;
|
||||
else if (P_CameraCheckHeat(&dummycam))
|
||||
postimgtype |= POSTIMG_HEAT;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Are we in water?
|
||||
if (P_CameraCheckWater(thiscam))
|
||||
postimgflags |= POSTIMG_WATER;
|
||||
if (P_CameraCheckHeat(thiscam))
|
||||
postimgflags |= POSTIMG_HEAT;
|
||||
postimgtype |= POSTIMG_WATER;
|
||||
else if (P_CameraCheckHeat(thiscam))
|
||||
postimgtype |= POSTIMG_HEAT;
|
||||
}
|
||||
|
||||
for (i = 0; i <= splitscreen; i++)
|
||||
{
|
||||
if (player != &players[displayplayers[i]])
|
||||
continue;
|
||||
|
||||
players[displayplayers[i]].postimgflags = postimgflags;
|
||||
break;
|
||||
}
|
||||
thiscam->postimg = postimgtype;
|
||||
}
|
||||
|
||||
// P_CameraThinker
|
||||
@@ -3564,7 +3567,7 @@ animonly:
|
||||
}
|
||||
}
|
||||
|
||||
static void CalculatePrecipFloor(precipmobj_t *mobj)
|
||||
static void P_CalculatePrecipFloor(precipmobj_t *mobj, boolean spawn)
|
||||
{
|
||||
// recalculate floorz each time
|
||||
const sector_t *mobjsecsubsec;
|
||||
@@ -3574,6 +3577,10 @@ static void CalculatePrecipFloor(precipmobj_t *mobj)
|
||||
else
|
||||
return;
|
||||
|
||||
// no need to recalc anything if not moved
|
||||
if (!spawn && !mobjsecsubsec->moved)
|
||||
return;
|
||||
|
||||
mobj->floorz = P_GetSectorFloorZAt(mobjsecsubsec, mobj->x, mobj->y);
|
||||
|
||||
if (mobjsecsubsec->ffloors)
|
||||
@@ -3598,19 +3605,6 @@ static void CalculatePrecipFloor(precipmobj_t *mobj)
|
||||
}
|
||||
}
|
||||
|
||||
void P_RecalcPrecipInSector(sector_t *sector)
|
||||
{
|
||||
mprecipsecnode_t *psecnode;
|
||||
|
||||
if (!sector)
|
||||
return;
|
||||
|
||||
sector->moved = true; // Recalc lighting and things too, maybe
|
||||
|
||||
for (psecnode = sector->touching_preciplist; psecnode; psecnode = psecnode->m_thinglist_next)
|
||||
CalculatePrecipFloor(psecnode->m_thing);
|
||||
}
|
||||
|
||||
//
|
||||
// P_NullPrecipThinker
|
||||
//
|
||||
@@ -3677,6 +3671,9 @@ boolean P_PrecipThinker(precipmobj_t *mobj)
|
||||
if (mobj->precipflags & PCF_SPLASH)
|
||||
return true;
|
||||
|
||||
if (renderisnewtic)
|
||||
P_CalculatePrecipFloor(mobj, false);
|
||||
|
||||
// adjust height
|
||||
if ((mobj->z += mobj->momz) <= mobj->floorz)
|
||||
{
|
||||
@@ -4847,7 +4844,13 @@ static void P_Boss7Thinker(mobj_t *mobj)
|
||||
continue;
|
||||
|
||||
mo2 = (mobj_t *)th;
|
||||
if (mo2->type == MT_BOSS3WAYPOINT && mo2->spawnpoint && (mo2->spawnpoint->options & 7) == waypointNum)
|
||||
|
||||
if (mo2->type != MT_BOSS3WAYPOINT)
|
||||
continue;
|
||||
if (!mo2->spawnpoint)
|
||||
continue;
|
||||
|
||||
if ((mo2->spawnpoint->options & 7) == waypointNum)
|
||||
{
|
||||
hitspot = mo2;
|
||||
break;
|
||||
@@ -5690,9 +5693,6 @@ void P_Attract(mobj_t *source, mobj_t *dest, boolean nightsgrab) // Home in on y
|
||||
if (!dest || dest->health <= 0 || !dest->player || !source->tracer)
|
||||
return;
|
||||
|
||||
// change angle
|
||||
//source->angle = R_PointToAngle2(source->x, source->y, tx, ty);
|
||||
|
||||
// change slope
|
||||
dist = P_AproxDistance(P_AproxDistance(tx - source->x, ty - source->y), tz - source->z);
|
||||
|
||||
@@ -6033,17 +6033,21 @@ static void P_KoopaThinker(mobj_t *koopa)
|
||||
//
|
||||
void P_RollPitchMobj(mobj_t* mobj)
|
||||
{
|
||||
// we dont need this in dedi do we?
|
||||
if (rendermode == render_none)
|
||||
return;
|
||||
|
||||
if (P_MobjWasRemoved(mobj))
|
||||
return;
|
||||
|
||||
if (cv_sloperoll.value != 2)
|
||||
{
|
||||
mobj->sloperoll = FixedAngle(0);
|
||||
mobj->slopepitch = FixedAngle(0);
|
||||
mobj->sloperoll = 0;
|
||||
mobj->slopepitch = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
K_RollMobjBySlopes(mobj, cv_sloperolldist.value && !splitscreen);
|
||||
K_RollMobjBySlopes(mobj, mobj->standingslope);
|
||||
}
|
||||
|
||||
angle_t P_MobjPitchAndRoll(mobj_t *mobj)
|
||||
@@ -7054,8 +7058,21 @@ void P_MobjThinker(mobj_t *mobj)
|
||||
}
|
||||
break;
|
||||
//{ SRB2kart Items - Death States
|
||||
case MT_ORBINAUT:
|
||||
case MT_BANANA:
|
||||
if (cv_sloperoll.value == 2 && cv_bananthrowroll.value)
|
||||
{
|
||||
angle_t spin = FixedMul(FixedDiv(abs(mobj->momz), 8 * mobj->scale), ANGLE_67h);
|
||||
//mobj->angle -= spin;
|
||||
|
||||
if (cv_bananthrowroll.value == 1)
|
||||
mobj->sloperoll += spin; // im lazy but this makes sure the banan goes back to upright when it lands lmao
|
||||
else if (cv_bananthrowroll.value == 2)
|
||||
mobj->rollangle += spin;
|
||||
|
||||
//if (P_IsObjectOnGround(mobj) && mobj->momz * P_MobjFlip(mobj) <= 0)
|
||||
}
|
||||
/* FALLTHRU */
|
||||
case MT_ORBINAUT:
|
||||
case MT_EGGMANITEM:
|
||||
case MT_SPB:
|
||||
if (P_IsObjectOnGround(mobj))
|
||||
@@ -7797,6 +7814,18 @@ void P_MobjThinker(mobj_t *mobj)
|
||||
}
|
||||
case MT_BANANA:
|
||||
case MT_EGGMANITEM:
|
||||
if (cv_sloperoll.value == 2 && cv_bananthrowroll.value && !P_IsObjectOnGround(mobj))
|
||||
{
|
||||
// tilt n tumble
|
||||
angle_t spin = FixedMul(FixedDiv(mobj->momz, 8 * mobj->scale), ANGLE_67h);
|
||||
//mobj->angle += spin;
|
||||
|
||||
if (cv_bananthrowroll.value == 1)
|
||||
mobj->sloperoll -= spin; // im lazy but this makes sure the banan goes back to upright when it lands lmao
|
||||
else if (cv_bananthrowroll.value == 2)
|
||||
mobj->rollangle -= spin;
|
||||
}
|
||||
|
||||
mobj->friction = ORIG_FRICTION/4;
|
||||
if (mobj->momx || mobj->momy)
|
||||
P_SpawnGhostMobj(mobj);
|
||||
@@ -9443,10 +9472,13 @@ mobj_t *P_SpawnMobj(fixed_t x, fixed_t y, fixed_t z, mobjtype_t type)
|
||||
}
|
||||
|
||||
// Sprite rendering
|
||||
mobj->blendmode = AST_TRANSLUCENT;
|
||||
mobj->realxscale = mobj->realyscale = mobj->scale;
|
||||
mobj->spritexscale = mobj->realxscale;
|
||||
mobj->spriteyscale = mobj->realyscale;
|
||||
mobj->spritexoffset = mobj->spriteyoffset = 0;
|
||||
mobj->realxoffset = mobj->realyoffset = 0;
|
||||
mobj->spritexoffset = mobj->realxoffset;
|
||||
mobj->spriteyoffset = mobj->realyoffset;
|
||||
|
||||
// Funni slam sound when landing
|
||||
mobj->slamsoundtimer = 0;
|
||||
@@ -9877,6 +9909,7 @@ mobj_t *P_SpawnShadowMobj(mobj_t * caster)
|
||||
mobj->radius = info->radius;
|
||||
mobj->height = info->height;
|
||||
mobj->flags = info->flags;
|
||||
mobj->blendmode = AST_TRANSLUCENT;
|
||||
|
||||
mobj->health = info->spawnhealth;
|
||||
|
||||
@@ -10006,9 +10039,9 @@ static precipmobj_t *P_SpawnPrecipMobj(fixed_t x, fixed_t y, fixed_t z, mobjtype
|
||||
mobj->momz = cv_mobjscaleprecip.value ? FixedMul(info->speed, mapobjectscale) : info->speed;
|
||||
|
||||
mobj->thinker.function.acp1 = (actionf_p1)P_NullPrecipThinker;
|
||||
P_AddThinker(&mobj->thinker);
|
||||
P_AddPrecipThinker(&mobj->thinker);
|
||||
|
||||
CalculatePrecipFloor(mobj);
|
||||
P_CalculatePrecipFloor(mobj, true);
|
||||
|
||||
if (mobj->floorz != starting_floorz)
|
||||
mobj->precipflags |= PCF_FOF;
|
||||
@@ -10168,12 +10201,6 @@ void P_FreePrecipMobj(precipmobj_t *mobj)
|
||||
// unlink from sector and block lists
|
||||
P_UnsetPrecipThingPosition(mobj);
|
||||
|
||||
if (precipsector_list)
|
||||
{
|
||||
P_DelPrecipSeclist(precipsector_list);
|
||||
precipsector_list = NULL;
|
||||
}
|
||||
|
||||
// free block
|
||||
// Precipmobjs don't actually think using their thinker,
|
||||
// so the free cannot be delayed.
|
||||
@@ -10187,12 +10214,6 @@ void P_RemoveSavegameMobj(mobj_t *mobj)
|
||||
if (((thinker_t *)mobj)->function.acp1 == (actionf_p1)P_NullPrecipThinker)
|
||||
{
|
||||
P_UnsetPrecipThingPosition((precipmobj_t *)mobj);
|
||||
|
||||
if (precipsector_list)
|
||||
{
|
||||
P_DelPrecipSeclist(precipsector_list);
|
||||
precipsector_list = NULL;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -10225,28 +10246,26 @@ consvar_t cv_suddendeath = {"suddendeath", "Off", CV_NETVAR|CV_CHEAT|CV_NOSHOWHE
|
||||
|
||||
void P_SpawnPrecipitation(void)
|
||||
{
|
||||
INT32 i, mrand;
|
||||
fixed_t basex, basey, j, x, y, z;
|
||||
INT32 i, j, mrand;
|
||||
fixed_t basex, basey, x, y, z;
|
||||
subsector_t *precipsector = NULL;
|
||||
precipmobj_t *rainmo = NULL;
|
||||
|
||||
if (dedicated || !cv_drawdist_precip.value || curWeather == PRECIP_NONE) // SRB2Kart
|
||||
if (dedicated || !cv_drawdist_precip.value || curWeather == PRECIP_NONE || curWeather == PRECIP_STORM_NORAIN)
|
||||
return;
|
||||
|
||||
fixed_t density = (cv_mobjscaleprecip.value ? mapobjectscale : FRACUNIT);
|
||||
|
||||
if (cv_lessprecip.value)
|
||||
density *= 2; // just spawn half the precip
|
||||
const fixed_t precipmoscale = (cv_mobjscaleprecip.value ? mapobjectscale : FRACUNIT);
|
||||
const INT32 density = (cv_lessprecip.value ? 2 : 1); // only spawn half as much
|
||||
|
||||
// Use the blockmap to narrow down our placing patterns
|
||||
for (i = 0; i < bmapwidth*bmapheight; ++i)
|
||||
for (i = 0; i < bmapwidth*bmapheight; i += density)
|
||||
{
|
||||
basex = bmaporgx + (i % bmapwidth) * MAPBLOCKSIZE;
|
||||
basey = bmaporgy + (i / bmapwidth) * MAPBLOCKSIZE;
|
||||
|
||||
// If mobjscale < FRACUNIT, each blockmap cell covers
|
||||
// more area so spawn more precipitation in that area.
|
||||
for (j = 0; j < FRACUNIT; j += density)
|
||||
for (j = 0; j < FRACUNIT; j += precipmoscale)
|
||||
{
|
||||
INT32 floorz;
|
||||
INT32 ceilingz;
|
||||
@@ -10284,6 +10303,9 @@ void P_SpawnPrecipitation(void)
|
||||
else // everything else.
|
||||
rainmo = P_SpawnPrecipMobj(x, y, z, MT_RAIN);
|
||||
|
||||
if (curWeather == PRECIP_BLANK)
|
||||
rainmo->precipflags |= PCF_INVISIBLE;
|
||||
|
||||
floorz = rainmo->floorz >> FRACBITS;
|
||||
ceilingz = rainmo->ceilingz >> FRACBITS;
|
||||
|
||||
@@ -10299,17 +10321,6 @@ void P_SpawnPrecipitation(void)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (curWeather == PRECIP_BLANK)
|
||||
{
|
||||
curWeather = PRECIP_RAIN;
|
||||
P_SwitchWeather(PRECIP_BLANK);
|
||||
}
|
||||
else if (curWeather == PRECIP_STORM_NORAIN)
|
||||
{
|
||||
curWeather = PRECIP_RAIN;
|
||||
P_SwitchWeather(PRECIP_STORM_NORAIN);
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
@@ -10621,7 +10632,9 @@ void P_SpawnPlayer(INT32 playernum)
|
||||
if (multiplayer && demo.playback)
|
||||
; // Don't mess with spectator values since the demo setup handles them already.
|
||||
else if (!G_GametypeHasSpectators())
|
||||
{
|
||||
p->spectator = false;
|
||||
}
|
||||
else if (netgame && p->jointime <= 1 && pcount)
|
||||
{
|
||||
p->spectator = true;
|
||||
@@ -10653,7 +10666,9 @@ void P_SpawnPlayer(INT32 playernum)
|
||||
SendNetXCmd(XD_TEAMCHANGE, &usvalue, sizeof(usvalue));
|
||||
}
|
||||
else // Otherwise, never spectator.
|
||||
{
|
||||
p->spectator = false;
|
||||
}
|
||||
}
|
||||
|
||||
if (G_GametypeHasTeams())
|
||||
@@ -10713,6 +10728,8 @@ void P_SpawnPlayer(INT32 playernum)
|
||||
p->hitemtimer = 0;
|
||||
p->hitemvictim = 255;
|
||||
|
||||
p->spinoutrot = 0;
|
||||
|
||||
if (G_BattleGametype()) // SRB2kart
|
||||
{
|
||||
mobj_t *overheadarrow = P_SpawnMobj(mobj->x, mobj->y, mobj->z + P_GetPlayerHeight(p)+16*FRACUNIT, MT_PLAYERARROW);
|
||||
@@ -10758,6 +10775,30 @@ void P_SpawnPlayer(INT32 playernum)
|
||||
P_SetScale(karmahitbox, mobj->scale);
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: handle splitscreen
|
||||
// Spectators can switch to freecam. This should be
|
||||
// disabled when they enter the race, or when the level
|
||||
// changes.
|
||||
if (!demo.playback)
|
||||
{
|
||||
if (!p->spectator)
|
||||
{
|
||||
if (playernum == consoleplayer)
|
||||
camera[0].freecam = false;
|
||||
else if (splitscreen)
|
||||
{
|
||||
for (i = 1; i <= splitscreen; i++)
|
||||
{
|
||||
if (playernum == displayplayers[i])
|
||||
{
|
||||
camera[i].freecam = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void P_AfterPlayerSpawn(INT32 playernum)
|
||||
@@ -10800,15 +10841,18 @@ void P_AfterPlayerSpawn(INT32 playernum)
|
||||
|
||||
SV_SpawnPlayer(playernum, mobj->x, mobj->y, mobj->angle);
|
||||
|
||||
for (i = 0; i <= splitscreen; i++)
|
||||
if (p->spectator == false)
|
||||
{
|
||||
if (!camera[i].chase)
|
||||
continue;
|
||||
for (i = 0; i <= splitscreen; i++)
|
||||
{
|
||||
if (!camera[i].chase)
|
||||
continue;
|
||||
|
||||
if (displayplayers[i] != playernum)
|
||||
continue;
|
||||
if (displayplayers[i] != playernum)
|
||||
continue;
|
||||
|
||||
P_ResetCamera(p, &camera[i]);
|
||||
P_ResetCamera(p, &camera[i]);
|
||||
}
|
||||
}
|
||||
|
||||
if (CheckForReverseGravity)
|
||||
@@ -11607,7 +11651,7 @@ ML_NOCLIMB : Direction not controllable
|
||||
mobj_t *elecmobj;
|
||||
elecmobj = P_SpawnMobj(x, y, z, MT_CYBRAKDEMON_ELECTRIC_BARRIER);
|
||||
P_SetTarget(&elecmobj->target, mobj);
|
||||
elecmobj->angle = FixedAngle(mthing->angle*FRACUNIT);;
|
||||
elecmobj->angle = FixedAngle(mthing->angle*FRACUNIT);
|
||||
elecmobj->destscale = mobj->scale*2;
|
||||
P_SetScale(elecmobj, elecmobj->destscale);
|
||||
}
|
||||
|
||||
+4
-1
@@ -289,6 +289,7 @@ typedef struct mobj_s
|
||||
UINT32 frame; // frame number, plus bits see p_pspr.h
|
||||
UINT16 anim_duration; // for FF_ANIMATE states
|
||||
|
||||
INT32 blendmode; // blend mode
|
||||
fixed_t spritexscale, spriteyscale;
|
||||
fixed_t spritexoffset, spriteyoffset;
|
||||
fixed_t old_spritexscale, old_spriteyscale;
|
||||
@@ -296,6 +297,7 @@ typedef struct mobj_s
|
||||
INT16 lightlevel; // Add to sector lightlevel, -255 - 255
|
||||
|
||||
fixed_t realxscale, realyscale; // funn-E streeetch
|
||||
fixed_t realxoffset, realyoffset;
|
||||
|
||||
fixed_t stretchslam; // "squish" effect when you land
|
||||
|
||||
@@ -394,7 +396,6 @@ typedef struct mobj_s
|
||||
boolean resetinterp; // if true, some fields should not be interpolated (see R_InterpolateMobjState implementation)
|
||||
boolean colorized; // Whether the mobj uses the rainbow colormap
|
||||
boolean mirrored; // The object's rotations will be mirrored left to right, e.g., see frame AL from the right and AR from the left
|
||||
boolean rollmodel; // OpenGL: Should this model rotate?
|
||||
|
||||
tic_t slamsoundtimer;
|
||||
|
||||
@@ -442,6 +443,7 @@ typedef struct precipmobj_s
|
||||
UINT32 frame; // frame number, plus bits see p_pspr.h
|
||||
UINT16 anim_duration; // for FF_ANIMATE states
|
||||
|
||||
INT32 blendmode; // blend mode
|
||||
fixed_t spritexscale, spriteyscale;
|
||||
fixed_t spritexoffset, spriteyoffset;
|
||||
fixed_t old_spritexscale, old_spriteyscale;
|
||||
@@ -449,6 +451,7 @@ typedef struct precipmobj_s
|
||||
INT16 lightlevel; // Add to sector lightlevel, -255 - 255
|
||||
|
||||
fixed_t realxscale, realyscale; // funn-E streeetch
|
||||
fixed_t realxoffset, realyoffset;
|
||||
|
||||
fixed_t stretchslam; // "squish" effect when you land
|
||||
|
||||
|
||||
+24
-6
@@ -41,12 +41,18 @@
|
||||
#define FF_HORIZONTALFLIP 0x400
|
||||
/// \brief Frame flags: Thin, paper-like sprite (for collision equivalent, see MF_PAPERCOLLISION)
|
||||
#define FF_PAPERSPRITE 0x800
|
||||
/// \brief mobj_t.lightlevel is absolute instead of relative
|
||||
#define FF_ABSOLUTELIGHTLEVEL 0x2000
|
||||
/// \brief Frame flags: Simple stateless animation
|
||||
#define FF_ANIMATE 0x4000
|
||||
/// \brief Frame flags: frame always appears full bright
|
||||
#define FF_FULLBRIGHT 0x8000
|
||||
|
||||
/// \brief Frame flags: blend types
|
||||
#define FF_BLENDMASK 0x7000
|
||||
/// \brief shift for FF_BLENDMASK
|
||||
#define FF_BLENDSHIFT 12
|
||||
/// \brief preshifted blend flags minus 1 as effects don't distinguish between AST_COPY and AST_TRANSLUCENT
|
||||
#define FF_ADD ((AST_ADD-1)<<FF_BLENDSHIFT)
|
||||
#define FF_SUBTRACT ((AST_SUBTRACT-1)<<FF_BLENDSHIFT)
|
||||
#define FF_REVERSESUBTRACT ((AST_REVERSESUBTRACT-1)<<FF_BLENDSHIFT)
|
||||
#define FF_MODULATE ((AST_MODULATE-1)<<FF_BLENDSHIFT)
|
||||
#define FF_OVERLAY ((AST_OVERLAY-1)<<FF_BLENDSHIFT)
|
||||
|
||||
/// \brief Frame flags: 0 = no trans(opaque), 1-15 = transl. table
|
||||
#define FF_TRANSMASK 0xf0000
|
||||
/// \brief shift for FF_TRANSMASK
|
||||
@@ -62,6 +68,18 @@
|
||||
#define FF_TRANS80 (tr_trans80<<FF_TRANSSHIFT)
|
||||
#define FF_TRANS90 (tr_trans90<<FF_TRANSSHIFT)
|
||||
|
||||
/// \brief Frame flags: brightness mask
|
||||
#define FF_BRIGHTMASK 0x00300000
|
||||
/// \brief Frame flags: frame always appears full bright
|
||||
#define FF_FULLBRIGHT 0x00100000
|
||||
/// \brief Frame flags: frame always appears full darkness
|
||||
#define FF_FULLDARK 0x00200000
|
||||
/// \brief Frame flags: frame appears between sector bright and full bright
|
||||
#define FF_SEMIBRIGHT (FF_FULLBRIGHT|FF_FULLDARK)
|
||||
|
||||
/// \brief Frame flags: Simple stateless animation
|
||||
#define FF_ANIMATE 0x10000000
|
||||
|
||||
/** \brief translucency tables
|
||||
|
||||
\todo add another asm routine which use the fg and bg indexes in the
|
||||
|
||||
+28
-13
@@ -1680,8 +1680,7 @@ static void P_NetArchiveThinkers(savebuffer_t *save)
|
||||
// save off the current thinkers
|
||||
for (th = thinkercap.next; th != &thinkercap; th = th->next)
|
||||
{
|
||||
if (!(th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed
|
||||
|| th->function.acp1 == (actionf_p1)P_NullPrecipThinker))
|
||||
if (th->function.acp1 != (actionf_p1)P_RemoveThinkerDelayed)
|
||||
numsaved++;
|
||||
|
||||
if (th->function.acp1 == (actionf_p1)P_MobjThinker)
|
||||
@@ -1689,9 +1688,6 @@ static void P_NetArchiveThinkers(savebuffer_t *save)
|
||||
SaveMobjThinker(save, th, tc_mobj);
|
||||
continue;
|
||||
}
|
||||
#ifdef PARANOIA
|
||||
else if (th->function.acp1 == (actionf_p1)P_NullPrecipThinker);
|
||||
#endif
|
||||
else if (th->function.acp1 == (actionf_p1)T_MoveCeiling)
|
||||
{
|
||||
SaveCeilingThinker(save, th, tc_ceiling);
|
||||
@@ -2151,12 +2147,11 @@ static void LoadMobjThinker(savebuffer_t *save, actionf_p1 thinker)
|
||||
mobj->mirrored = 0;
|
||||
|
||||
// Sprite Rendering stuff
|
||||
mobj->spritexoffset = 0;
|
||||
mobj->spriteyoffset = 0;
|
||||
mobj->spritexscale = FRACUNIT;
|
||||
mobj->spriteyscale = FRACUNIT;
|
||||
mobj->realxscale = FRACUNIT;
|
||||
mobj->realyscale = FRACUNIT;
|
||||
mobj->blendmode = AST_TRANSLUCENT;
|
||||
mobj->spritexoffset = mobj->realxoffset = 0;
|
||||
mobj->spriteyoffset = mobj->realxoffset = 0;
|
||||
mobj->spritexscale = mobj->realxscale = FRACUNIT;
|
||||
mobj->spriteyscale = mobj->realyscale = FRACUNIT;
|
||||
mobj->stretchslam = 0;
|
||||
|
||||
// Timer for slam sound effect
|
||||
@@ -2674,6 +2669,8 @@ static void P_NetUnArchiveThinkers(savebuffer_t *save)
|
||||
{
|
||||
thinker_t *currentthinker;
|
||||
thinker_t *next;
|
||||
thinker_t *currentprecipthinker;
|
||||
thinker_t *nextprecip;
|
||||
UINT8 tclass;
|
||||
UINT8 restoreNum = false;
|
||||
UINT32 i;
|
||||
@@ -2688,7 +2685,7 @@ static void P_NetUnArchiveThinkers(savebuffer_t *save)
|
||||
{
|
||||
next = currentthinker->next;
|
||||
|
||||
if (currentthinker->function.acp1 == (actionf_p1)P_MobjThinker || currentthinker->function.acp1 == (actionf_p1)P_NullPrecipThinker)
|
||||
if (currentthinker->function.acp1 == (actionf_p1)P_MobjThinker)
|
||||
P_RemoveSavegameMobj((mobj_t *)currentthinker); // item isn't saved, don't remove it
|
||||
else
|
||||
{
|
||||
@@ -2698,6 +2695,24 @@ static void P_NetUnArchiveThinkers(savebuffer_t *save)
|
||||
}
|
||||
}
|
||||
|
||||
// remove all the current precip thinkers
|
||||
currentprecipthinker = precipcap.next;
|
||||
for (currentprecipthinker = precipcap.next; currentprecipthinker != &precipcap; currentprecipthinker = nextprecip)
|
||||
{
|
||||
nextprecip = currentprecipthinker->next;
|
||||
|
||||
#ifdef PARANOIA
|
||||
if (currentprecipthinker->function.acp1 != (actionf_p1)P_NullPrecipThinker)
|
||||
{
|
||||
(next->prev = currentprecipthinker->prev)->next = nextprecip;
|
||||
R_DestroyLevelInterpolators(currentprecipthinker);
|
||||
Z_Free(currentprecipthinker);
|
||||
}
|
||||
else
|
||||
#endif
|
||||
P_RemoveSavegameMobj((mobj_t *)currentprecipthinker); // item isn't saved, don't remove it
|
||||
}
|
||||
|
||||
// we don't want the removed mobjs to come back
|
||||
iquetail = iquehead = 0;
|
||||
P_InitThinkers();
|
||||
@@ -3336,7 +3351,7 @@ FUNCINLINE static ATTRINLINE boolean P_NetUnArchiveMisc(savebuffer_t *save, bool
|
||||
// tell the sound code to reset the music since we're skipping what
|
||||
// normally sets this flag
|
||||
if (!reloading)
|
||||
mapmusflags |= MUSIC_RELOADRESET;
|
||||
mapmusic.flags |= MUSIC_RELOADRESET;
|
||||
|
||||
G_SetGamestate(READINT16(save->p));
|
||||
|
||||
|
||||
+318
-247
@@ -91,6 +91,9 @@
|
||||
//
|
||||
unsigned char mapmd5[16];
|
||||
|
||||
// true when level was loaded from netsave
|
||||
boolean midgamejoin = false;
|
||||
|
||||
//
|
||||
// MAP related Lookup tables.
|
||||
// Store VERTEXES, LINEDEFS, SIDEDEFS, etc.
|
||||
@@ -247,8 +250,6 @@ static SINT8 partadd_stage = -1;
|
||||
static boolean partadd_replacescurrentmap = false;
|
||||
static boolean partadd_important = false;
|
||||
|
||||
SINT8 midgamejoin = 0;
|
||||
|
||||
/** Logs an error about a map being corrupt, then terminate.
|
||||
* This allows reporting highly technical errors for usefulness, without
|
||||
* confusing a novice map designer who simply needs to run ZenNode.
|
||||
@@ -872,8 +873,6 @@ static void P_LoadRawSectors(UINT8 *data)
|
||||
ss->thinglist = NULL;
|
||||
ss->touching_thinglist = NULL;
|
||||
|
||||
ss->touching_preciplist = NULL;
|
||||
|
||||
ss->floordata = NULL;
|
||||
ss->ceilingdata = NULL;
|
||||
ss->lightingdata = NULL;
|
||||
@@ -1207,6 +1206,9 @@ static void P_SetupLines(void)
|
||||
ld->dx = v2->x - v1->x;
|
||||
ld->dy = v2->y - v1->y;
|
||||
|
||||
ld->alpha = FRACUNIT;
|
||||
ld->blendmode = 0;
|
||||
|
||||
if (!ld->dx)
|
||||
ld->slopetype = ST_VERTICAL;
|
||||
else if (!ld->dy)
|
||||
@@ -1314,6 +1316,26 @@ static void P_LoadLineDefs2(void)
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
// Set alpha for translucent walls
|
||||
if (ld->special >= 900 && ld->special < 909)
|
||||
ld->alpha = ((909 - ld->special) << FRACBITS)/10;
|
||||
|
||||
// Set alpha for additive/subtractive/reverse subtractive walls
|
||||
if (ld->special >= 910 && ld->special <= 939)
|
||||
ld->alpha = ((10 - ld->special % 10) << FRACBITS)/10;
|
||||
|
||||
if (ld->special >= 910 && ld->special <= 919) // additive
|
||||
ld->blendmode = AST_ADD;
|
||||
|
||||
if (ld->special >= 920 && ld->special <= 929) // subtractive
|
||||
ld->blendmode = AST_SUBTRACT;
|
||||
|
||||
if (ld->special >= 930 && ld->special <= 939) // reverse subtractive
|
||||
ld->blendmode = AST_REVERSESUBTRACT;
|
||||
|
||||
if (ld->special == 940) // modulate
|
||||
ld->blendmode = AST_MODULATE;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1592,8 +1614,10 @@ static void P_LoadRawSideDefs2(void *data)
|
||||
if (msd->toptexture[0] == '#')
|
||||
{
|
||||
char *col = msd->toptexture;
|
||||
sd->toptexture = sd->bottomtexture =
|
||||
((col[1]-'0')*100 + (col[2]-'0')*10 + col[3]-'0') + 1;
|
||||
sd->toptexture =
|
||||
((col[1]-'0')*100 + (col[2]-'0')*10 + col[3]-'0')+1;
|
||||
if (col[4]) // extra num for blendmode
|
||||
sd->toptexture += (col[4]-'0')*1000;
|
||||
sd->midtexture = R_TextureNumForName(msd->midtexture);
|
||||
}
|
||||
else
|
||||
@@ -2223,7 +2247,13 @@ static void P_LevelInitStuff(boolean reloadinggamestate)
|
||||
players[i].lives = 1; // SRB2Kart
|
||||
|
||||
players[i].realtime = racecountdown = exitcountdown = 0;
|
||||
curlap = bestlap = 0; // SRB2Kart
|
||||
|
||||
for (INT32 j = 0; j < LAP__MAX; j++)
|
||||
{
|
||||
players[i].laptime[j] = 0;
|
||||
}
|
||||
|
||||
players[i].driftsparkGrowTimer = 0;
|
||||
|
||||
players[i].gotcontinue = false;
|
||||
|
||||
@@ -2596,27 +2626,33 @@ static void P_SetupCamera(UINT8 pnum, camera_t *cam)
|
||||
cam->angle = FixedAngle((fixed_t)thing->angle << FRACBITS);
|
||||
cam->subsector = R_PointInSubsector(cam->x, cam->y); // make sure camera has a subsector set -- Monster Iestyn (12/11/18)
|
||||
}
|
||||
|
||||
cam->chase = false; // tell camera to reset its position next tic
|
||||
}
|
||||
|
||||
static void P_InitCamera(void)
|
||||
{
|
||||
INT32 i;
|
||||
|
||||
if (!dedicated)
|
||||
if (dedicated)
|
||||
return;
|
||||
|
||||
for (i = 0; i <= splitscreen; i++)
|
||||
{
|
||||
if (!demo.freecam)
|
||||
for (i = 0; i <= splitscreen; i++)
|
||||
P_SetupCamera(displayplayers[i], &camera[i]);
|
||||
if (camera[i].freecam)
|
||||
continue;
|
||||
|
||||
// Though, I don't think anyone would care about cam_rotate being reset back to the only value that makes sense :P
|
||||
for (i = 0; i < MAXSPLITSCREENPLAYERS; i++)
|
||||
{
|
||||
if (!cv_cam_rotate[i].changed)
|
||||
CV_Set(&cv_cam_rotate[i], cv_cam_rotate[i].defaultvalue);
|
||||
}
|
||||
|
||||
displayplayers[0] = consoleplayer; // Start with your OWN view, please!
|
||||
P_SetupCamera(displayplayers[i], &camera[i]);
|
||||
}
|
||||
|
||||
// Though, I don't think anyone would care about cam_rotate being reset back to the only value that makes sense :P
|
||||
for (i = 0; i < MAXSPLITSCREENPLAYERS; i++)
|
||||
{
|
||||
if (!cv_cam_rotate[i].changed)
|
||||
CV_Set(&cv_cam_rotate[i], cv_cam_rotate[i].defaultvalue);
|
||||
}
|
||||
|
||||
displayplayers[0] = consoleplayer; // Start with your OWN view, please!
|
||||
}
|
||||
|
||||
static boolean P_CanSave(void)
|
||||
@@ -2627,7 +2663,7 @@ static boolean P_CanSave(void)
|
||||
struct minimapinfo minimapinfo;
|
||||
static void P_InitMinimapInfo(void)
|
||||
{
|
||||
INT32 lumpnum;
|
||||
lumpnum_t lumpnum;
|
||||
fixed_t a;
|
||||
fixed_t b;
|
||||
node_t *bsp = &nodes[numnodes-1];
|
||||
@@ -2636,11 +2672,9 @@ static void P_InitMinimapInfo(void)
|
||||
|
||||
lumpnum = W_CheckNumForName(va("%sR", G_BuildMapName(gamemap)));
|
||||
|
||||
if (lumpnum != -1)
|
||||
if (lumpnum != LUMPERROR)
|
||||
minimapinfo.minimap_pic = W_CachePatchName(va("%sR", G_BuildMapName(gamemap)), PU_HUDGFX);
|
||||
|
||||
minimapinfo.mapthingcount = 0;
|
||||
// TODO iterate over mapthings to look for possible user-defined bounds
|
||||
minimapinfo.min_x = bsp->bbox[0][BOXLEFT];
|
||||
minimapinfo.max_x = bsp->bbox[0][BOXRIGHT];
|
||||
minimapinfo.min_y = bsp->bbox[0][BOXBOTTOM];
|
||||
@@ -2689,72 +2723,8 @@ static void P_InitMinimapInfo(void)
|
||||
minimapinfo.offs_y = FixedMul((minimapinfo.min_y + minimapinfo.map_h/2) << FRACBITS, minimapinfo.zoom);
|
||||
}
|
||||
|
||||
/** Loads a level from a lump or external wad.
|
||||
*
|
||||
* \param skipprecip If true, don't spawn precipitation.
|
||||
* \todo Clean up, refactor, split up; get rid of the bloat.
|
||||
*/
|
||||
boolean P_SetupLevel(boolean skipprecip, boolean reloadinggamestate)
|
||||
static boolean P_RunSpecialWipe(boolean reloadinggamestate)
|
||||
{
|
||||
// use gamemap to get map number.
|
||||
// 99% of the things already did, so.
|
||||
// Map header should always be in place at this point
|
||||
INT32 i, loadprecip = 1, ranspecialwipe = 0;
|
||||
INT32 loademblems = 1;
|
||||
INT32 fromnetsave = 0;
|
||||
midgamejoin = 0;
|
||||
sector_t *ss;
|
||||
boolean chase;
|
||||
|
||||
levelloading = true;
|
||||
|
||||
// This is needed. Don't touch.
|
||||
maptol = mapheaderinfo[gamemap-1]->typeoflevel;
|
||||
|
||||
CON_Drawer(); // let the user know what we are going to do
|
||||
I_FinishUpdate(); // page flip or blit buffer
|
||||
|
||||
// Initialize sector node list.
|
||||
P_Initsecnode();
|
||||
|
||||
if (netgame || multiplayer)
|
||||
cv_debug = botskin = 0;
|
||||
|
||||
if (metalplayback)
|
||||
G_StopMetalDemo();
|
||||
|
||||
// Clear CECHO messages
|
||||
HU_ClearCEcho();
|
||||
|
||||
if (mapheaderinfo[gamemap-1]->runsoc[0] != '#')
|
||||
P_RunSOC(mapheaderinfo[gamemap-1]->runsoc);
|
||||
|
||||
if (cv_runscripts.value && mapheaderinfo[gamemap-1]->scriptname[0] != '#')
|
||||
P_RunLevelScript(mapheaderinfo[gamemap-1]->scriptname);
|
||||
|
||||
P_LevelInitStuff(reloadinggamestate);
|
||||
|
||||
if (mapheaderinfo[gamemap-1]->forcecharacter[0] != '\0'
|
||||
&& atoi(mapheaderinfo[gamemap-1]->forcecharacter) != 255)
|
||||
P_ForceCharacter(mapheaderinfo[gamemap-1]->forcecharacter);
|
||||
|
||||
// chasecam on in chaos, race, coop
|
||||
// chasecam off in match, tag, capture the flag
|
||||
chase = true; // srb2kart: always on
|
||||
|
||||
if (!dedicated)
|
||||
{
|
||||
for (i = 0; i < MAXSPLITSCREENPLAYERS; i++)
|
||||
{
|
||||
if (!cv_chasecam[i].changed)
|
||||
CV_SetValue(&cv_chasecam[i], chase);
|
||||
}
|
||||
}
|
||||
|
||||
// Initial height of PointOfView
|
||||
// will be set by player think.
|
||||
players[consoleplayer].viewz = 1;
|
||||
|
||||
// Cancel all d_main.c fadeouts (keep fade in though).
|
||||
if (reloadinggamestate)
|
||||
wipegamestate = gamestate; // Don't fade if reloading the gamestate
|
||||
@@ -2787,7 +2757,7 @@ boolean P_SetupLevel(boolean skipprecip, boolean reloadinggamestate)
|
||||
F_RunWipe(wipedefs[wipe_speclevel_towhite], false);
|
||||
F_RunWipe(wipedefs[wipe_level_final], false);
|
||||
}
|
||||
|
||||
|
||||
locstarttime = nowtime = lastwipetic;
|
||||
endtime = locstarttime + (3*TICRATE)/2;
|
||||
|
||||
@@ -2808,162 +2778,15 @@ boolean P_SetupLevel(boolean skipprecip, boolean reloadinggamestate)
|
||||
NetKeepAlive();
|
||||
}
|
||||
|
||||
ranspecialwipe = 1;
|
||||
return true;
|
||||
}
|
||||
|
||||
// Make sure all sounds are stopped before Z_FreeTags.
|
||||
S_StopSounds();
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!S_PrecacheSound())
|
||||
S_ClearSfx();
|
||||
|
||||
// As oddly named as this is, this handles music only.
|
||||
// We should be fine starting it here.
|
||||
if (!reloadinggamestate)
|
||||
S_InitMapMusic();
|
||||
|
||||
levelfadecol = (encoremode && !ranspecialwipe ? 122 : 120);
|
||||
|
||||
// Let's fade to white here
|
||||
// But only if we didn't do the encore startup wipe
|
||||
if (!ranspecialwipe && !demo.rewinding && !reloadinggamestate)
|
||||
{
|
||||
if (rendermode != render_none)
|
||||
{
|
||||
F_WipeStartScreen();
|
||||
V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, levelfadecol);
|
||||
|
||||
F_WipeEndScreen();
|
||||
F_RunWipe(wipedefs[(encoremode ? wipe_level_final : wipe_level_toblack)], false);
|
||||
}
|
||||
else //dedicated servers
|
||||
{
|
||||
F_RunWipe(wipedefs[(encoremode ? wipe_level_final : wipe_level_toblack)], false);
|
||||
}
|
||||
}
|
||||
|
||||
// Reset the palette now all fades have been done
|
||||
if (rendermode != render_none)
|
||||
V_SetPaletteLump(GetPalette()); // Set the level palette
|
||||
|
||||
// Print "SPEEDING OFF TO [ZONE] [ACT 1]..."
|
||||
/*if (rendermode != render_none)
|
||||
{
|
||||
// Don't include these in the fade!
|
||||
char tx[64];
|
||||
V_DrawSmallString(1, 191, V_ALLOWLOWERCASE, M_GetText("Speeding off to..."));
|
||||
snprintf(tx, 63, "%s%s%s",
|
||||
mapheaderinfo[gamemap-1]->lvlttl,
|
||||
(strlen(mapheaderinfo[gamemap-1]->zonttl) > 0) ? va(" %s",mapheaderinfo[gamemap-1]->zonttl) : // SRB2kart
|
||||
((mapheaderinfo[gamemap-1]->levelflags & LF_NOZONE) ? "" : " Zone"),
|
||||
(strlen(mapheaderinfo[gamemap-1]->actnum) > 0) ? va(", Act %s",mapheaderinfo[gamemap-1]->actnum) : "");
|
||||
V_DrawSmallString(1, 195, V_ALLOWLOWERCASE, tx);
|
||||
I_UpdateNoVsync();
|
||||
}*/
|
||||
|
||||
LUA_InvalidateLevel();
|
||||
|
||||
for (ss = sectors; sectors+numsectors != ss; ss++)
|
||||
{
|
||||
Z_Free(ss->attached);
|
||||
Z_Free(ss->attachedsolid);
|
||||
}
|
||||
|
||||
// Clear pointers that would be left dangling by the purge
|
||||
R_FlushTranslationColormapCache();
|
||||
|
||||
Z_FreeTags(PU_LEVEL, PU_PURGELEVEL - 1);
|
||||
|
||||
#if defined (WALLSPLATS) || defined (FLOORSPLATS)
|
||||
// clear the splats from previous level
|
||||
R_ClearLevelSplats();
|
||||
#endif
|
||||
|
||||
mobjcache = NULL;
|
||||
|
||||
R_InitializeLevelInterpolators();
|
||||
|
||||
P_InitThinkers();
|
||||
R_InitMobjInterpolators();
|
||||
P_InitCachedActions();
|
||||
|
||||
/// \note for not spawning precipitation, etc. when loading netgame snapshots
|
||||
if (skipprecip)
|
||||
{
|
||||
fromnetsave = 1;
|
||||
loadprecip = 0;
|
||||
loademblems = 0;
|
||||
midgamejoin = 1;
|
||||
}
|
||||
|
||||
// internal game map
|
||||
maplumpname = G_BuildMapName(gamemap);
|
||||
lastloadedmaplumpnum = W_CheckNumForName(maplumpname);
|
||||
if (lastloadedmaplumpnum == INT16_MAX)
|
||||
I_Error("Map %s not found.\n", maplumpname);
|
||||
|
||||
curmapvirt = vres_GetMap(lastloadedmaplumpnum);
|
||||
|
||||
R_ReInitColormaps(mapheaderinfo[gamemap-1]->palette,
|
||||
(encoremode ? W_CheckNumForName(va("%sE", maplumpname)) : LUMPERROR));
|
||||
CON_SetupBackColormap();
|
||||
|
||||
// SRB2 determines the sky texture to be used depending on the map header.
|
||||
P_SetupLevelSky(mapheaderinfo[gamemap-1]->skynum, true);
|
||||
|
||||
numdmstarts = numredctfstarts = numbluectfstarts = 0;
|
||||
|
||||
// reset the player starts
|
||||
for (i = 0; i < MAXPLAYERS; i++)
|
||||
playerstarts[i] = NULL;
|
||||
for (i = 0; i < 2; i++)
|
||||
skyboxmo[i] = NULL;
|
||||
|
||||
P_ResetWaypoints();
|
||||
|
||||
P_MapStart();
|
||||
|
||||
if (lastloadedmaplumpnum)
|
||||
P_LoadMapFromFile();
|
||||
|
||||
P_ResetDynamicSlopes();
|
||||
|
||||
P_LoadThings();
|
||||
|
||||
P_SpawnSecretItems(loademblems);
|
||||
|
||||
P_InitMinimapInfo();
|
||||
|
||||
for (numcoopstarts = 0; numcoopstarts < MAXPLAYERS; numcoopstarts++)
|
||||
if (!playerstarts[numcoopstarts])
|
||||
break;
|
||||
|
||||
globalweather = mapheaderinfo[gamemap-1]->weather;
|
||||
|
||||
// set up world state
|
||||
P_SpawnSpecials(fromnetsave, reloadinggamestate);
|
||||
|
||||
if (loadprecip) // ugly hack for P_NetUnArchiveMisc (and P_LoadNetGame)
|
||||
P_SpawnPrecipitation();
|
||||
|
||||
#ifdef HWRENDER // not win32 only 19990829 by Kin
|
||||
if (rendermode == render_opengl)
|
||||
{
|
||||
HWR_FreeExtraSubsectors();
|
||||
|
||||
// stuff like HWR_CreatePlanePolygons is called there
|
||||
HWR_LoadLevel();
|
||||
}
|
||||
#endif
|
||||
|
||||
// oh god I hope this helps
|
||||
// (addendum: apparently it does!
|
||||
// none of this needs to be done because it's not the beginning of the map when
|
||||
// a netgame save is being loaded, and could actively be harmful by messing with
|
||||
// the client's view of the data.)
|
||||
if (fromnetsave)
|
||||
goto netgameskip;
|
||||
// ==========
|
||||
static void P_SetupPlayer(void)
|
||||
{
|
||||
INT32 i;
|
||||
|
||||
for (i = 0; i < MAXPLAYERS; i++)
|
||||
if (playeringame[i])
|
||||
@@ -3014,7 +2837,7 @@ boolean P_SetupLevel(boolean skipprecip, boolean reloadinggamestate)
|
||||
}
|
||||
}
|
||||
|
||||
if (realnumplayers) //this should also fix the dedicated crash bug. You only pick a player if one exists to be picked.
|
||||
if (realnumplayers) // this should also fix the dedicated crash bug. You only pick a player if one exists to be picked.
|
||||
{
|
||||
i = P_RandomKey(realnumplayers);
|
||||
players[playersactive[i]].pflags |= PF_TAGIT; //choose our initial tagger before map starts.
|
||||
@@ -3083,10 +2906,213 @@ boolean P_SetupLevel(boolean skipprecip, boolean reloadinggamestate)
|
||||
startedInFreePlay = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ===========
|
||||
// landing point for netgames.
|
||||
netgameskip:
|
||||
/** Loads a level from a lump or external wad.
|
||||
*
|
||||
* \param fromnetsave If true, skip some stuff because we're loading a netgame snapshot.
|
||||
* \todo Clean up, refactor, split up; get rid of the bloat.
|
||||
*/
|
||||
boolean P_SetupLevel(boolean fromnetsave, boolean reloadinggamestate)
|
||||
{
|
||||
// use gamemap to get map number.
|
||||
// 99% of the things already did, so.
|
||||
// Map header should always be in place at this point
|
||||
INT32 i;
|
||||
boolean ranspecialwipe = false;
|
||||
sector_t *ss;
|
||||
|
||||
midgamejoin = fromnetsave; // makes dynslopes run in P_Ticker/P_PreTicker to avoid synch issues and other stuff
|
||||
|
||||
levelloading = true;
|
||||
|
||||
// This is needed. Don't touch.
|
||||
maptol = mapheaderinfo[gamemap-1]->typeoflevel;
|
||||
|
||||
CON_Drawer(); // let the user know what we are going to do
|
||||
I_FinishUpdate(); // page flip or blit buffer
|
||||
|
||||
// Initialize sector node list.
|
||||
P_Initsecnode();
|
||||
|
||||
if (netgame || multiplayer)
|
||||
cv_debug = botskin = 0;
|
||||
|
||||
if (metalplayback)
|
||||
G_StopMetalDemo();
|
||||
|
||||
// Clear CECHO messages
|
||||
HU_ClearCEcho();
|
||||
|
||||
if (mapheaderinfo[gamemap-1]->runsoc[0] != '#')
|
||||
P_RunSOC(mapheaderinfo[gamemap-1]->runsoc);
|
||||
|
||||
if (cv_runscripts.value && mapheaderinfo[gamemap-1]->scriptname[0] != '#')
|
||||
P_RunLevelScript(mapheaderinfo[gamemap-1]->scriptname);
|
||||
|
||||
P_LevelInitStuff(reloadinggamestate);
|
||||
|
||||
if (mapheaderinfo[gamemap-1]->forcecharacter[0] != '\0'
|
||||
&& atoi(mapheaderinfo[gamemap-1]->forcecharacter) != 255)
|
||||
P_ForceCharacter(mapheaderinfo[gamemap-1]->forcecharacter);
|
||||
|
||||
if (!dedicated)
|
||||
{
|
||||
for (i = 0; i < MAXSPLITSCREENPLAYERS; i++)
|
||||
{
|
||||
if (!cv_chasecam[i].changed)
|
||||
CV_SetValue(&cv_chasecam[i], true); // srb2kart: always on
|
||||
}
|
||||
}
|
||||
|
||||
// Initial height of PointOfView
|
||||
// will be set by player think.
|
||||
players[consoleplayer].viewz = 1;
|
||||
|
||||
ranspecialwipe = P_RunSpecialWipe(reloadinggamestate);
|
||||
|
||||
// Make sure all sounds are stopped before Z_FreeTags.
|
||||
S_StopSounds();
|
||||
|
||||
if (!S_PrecacheSound())
|
||||
S_ClearSfx();
|
||||
|
||||
// As oddly named as this is, this handles music only.
|
||||
// We should be fine starting it here.
|
||||
if (!reloadinggamestate)
|
||||
S_InitMapMusic();
|
||||
|
||||
levelfadecol = (encoremode && !ranspecialwipe ? 122 : 120);
|
||||
|
||||
// Let's fade to white here
|
||||
// But only if we didn't do the encore startup wipe
|
||||
if (!ranspecialwipe && !demo.rewinding && !reloadinggamestate)
|
||||
{
|
||||
if (rendermode != render_none)
|
||||
{
|
||||
F_WipeStartScreen();
|
||||
V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, levelfadecol);
|
||||
F_WipeEndScreen();
|
||||
F_RunWipe(wipedefs[(encoremode ? wipe_level_final : wipe_level_toblack)], false);
|
||||
}
|
||||
else //dedicated servers
|
||||
{
|
||||
F_RunWipe(wipedefs[(encoremode ? wipe_level_final : wipe_level_toblack)], false);
|
||||
}
|
||||
}
|
||||
|
||||
// Reset the palette now all fades have been done
|
||||
if (rendermode != render_none)
|
||||
V_SetPaletteLump(GetPalette()); // Set the level palette
|
||||
|
||||
// Print "SPEEDING OFF TO [ZONE] [ACT 1]..."
|
||||
/*if (rendermode != render_none)
|
||||
{
|
||||
// Don't include these in the fade!
|
||||
char tx[64];
|
||||
V_DrawSmallString(1, 191, V_ALLOWLOWERCASE, M_GetText("Speeding off to..."));
|
||||
snprintf(tx, 63, "%s%s%s",
|
||||
mapheaderinfo[gamemap-1]->lvlttl,
|
||||
(strlen(mapheaderinfo[gamemap-1]->zonttl) > 0) ? va(" %s",mapheaderinfo[gamemap-1]->zonttl) : // SRB2kart
|
||||
((mapheaderinfo[gamemap-1]->levelflags & LF_NOZONE) ? "" : " Zone"),
|
||||
(strlen(mapheaderinfo[gamemap-1]->actnum) > 0) ? va(", Act %s",mapheaderinfo[gamemap-1]->actnum) : "");
|
||||
V_DrawSmallString(1, 195, V_ALLOWLOWERCASE, tx);
|
||||
I_UpdateNoVsync();
|
||||
}*/
|
||||
|
||||
LUA_InvalidateLevel();
|
||||
|
||||
for (ss = sectors; sectors+numsectors != ss; ss++)
|
||||
{
|
||||
Z_Free(ss->attached);
|
||||
Z_Free(ss->attachedsolid);
|
||||
}
|
||||
|
||||
// Clear pointers that would be left dangling by the purge
|
||||
R_FlushTranslationColormapCache();
|
||||
|
||||
Z_FreeTags(PU_LEVEL, PU_PURGELEVEL - 1);
|
||||
|
||||
#if defined (WALLSPLATS) || defined (FLOORSPLATS)
|
||||
// clear the splats from previous level
|
||||
R_ClearLevelSplats();
|
||||
#endif
|
||||
|
||||
mobjcache = NULL;
|
||||
|
||||
R_InitializeLevelInterpolators();
|
||||
|
||||
P_InitThinkers();
|
||||
R_InitMobjInterpolators();
|
||||
P_InitCachedActions();
|
||||
|
||||
// internal game map
|
||||
maplumpname = G_BuildMapName(gamemap);
|
||||
lastloadedmaplumpnum = W_CheckNumForName(maplumpname);
|
||||
if (lastloadedmaplumpnum == INT16_MAX)
|
||||
I_Error("Map %s not found.\n", maplumpname);
|
||||
|
||||
curmapvirt = vres_GetMap(lastloadedmaplumpnum);
|
||||
|
||||
R_ReInitColormaps(mapheaderinfo[gamemap-1]->palette,
|
||||
(encoremode ? W_CheckNumForName(va("%sE", maplumpname)) : LUMPERROR));
|
||||
CON_SetupBackColormap();
|
||||
|
||||
// SRB2 determines the sky texture to be used depending on the map header.
|
||||
P_SetupLevelSky(mapheaderinfo[gamemap-1]->skynum, true);
|
||||
|
||||
numdmstarts = numredctfstarts = numbluectfstarts = 0;
|
||||
|
||||
// reset the player starts
|
||||
for (i = 0; i < MAXPLAYERS; i++)
|
||||
playerstarts[i] = NULL;
|
||||
for (i = 0; i < 2; i++)
|
||||
skyboxmo[i] = NULL;
|
||||
|
||||
P_ResetWaypoints();
|
||||
|
||||
P_MapStart();
|
||||
|
||||
if (lastloadedmaplumpnum)
|
||||
P_LoadMapFromFile();
|
||||
|
||||
P_ResetDynamicSlopes();
|
||||
|
||||
P_LoadThings();
|
||||
|
||||
P_SpawnSecretItems(!fromnetsave);
|
||||
|
||||
P_InitMinimapInfo();
|
||||
|
||||
for (numcoopstarts = 0; numcoopstarts < MAXPLAYERS; numcoopstarts++)
|
||||
if (!playerstarts[numcoopstarts])
|
||||
break;
|
||||
|
||||
globalweather = mapheaderinfo[gamemap-1]->weather;
|
||||
|
||||
// set up world state
|
||||
P_SpawnSpecials(fromnetsave, reloadinggamestate);
|
||||
|
||||
if (!fromnetsave) // ugly hack for P_NetUnArchiveMisc (and P_LoadNetGame)
|
||||
P_SpawnPrecipitation();
|
||||
|
||||
#ifdef HWRENDER // not win32 only 19990829 by Kin
|
||||
if (rendermode == render_opengl)
|
||||
{
|
||||
HWR_FreeExtraSubsectors();
|
||||
|
||||
// stuff like HWR_CreatePlanePolygons is called there
|
||||
HWR_LoadLevel();
|
||||
}
|
||||
#endif
|
||||
|
||||
// oh god I hope this helps
|
||||
// (addendum: apparently it does!
|
||||
// none of this needs to be done because it's not the beginning of the map when
|
||||
// a netgame save is being loaded, and could actively be harmful by messing with
|
||||
// the client's view of the data.)
|
||||
if (!fromnetsave)
|
||||
P_SetupPlayer();
|
||||
|
||||
if (!reloadinggamestate)
|
||||
{
|
||||
@@ -3136,7 +3162,7 @@ boolean P_SetupLevel(boolean skipprecip, boolean reloadinggamestate)
|
||||
skyVisible = true;
|
||||
memset(skyVisiblePerPlayer, true, sizeof(skyVisiblePerPlayer));
|
||||
|
||||
if (loadprecip) // uglier hack
|
||||
if (!fromnetsave) // uglier hack
|
||||
{ // to make a newly loaded level start on the second frame.
|
||||
INT32 buf = gametic % TICQUEUE;
|
||||
for (i = 0; i < MAXPLAYERS; i++)
|
||||
@@ -3208,6 +3234,12 @@ boolean P_AddWadFileLocal(const char *wadfilename)
|
||||
return true;
|
||||
}
|
||||
|
||||
// check for replacement votescreen backgrounds
|
||||
boolean wideracereplaced = false;
|
||||
boolean racereplaced = false;
|
||||
boolean widebattlereplaced = false;
|
||||
boolean battlereplaced = false;
|
||||
|
||||
//
|
||||
// Add a WAD file and do the per-WAD setup stages.
|
||||
// Call P_MultiSetupWadFiles as soon as possible after any number of these.
|
||||
@@ -3332,6 +3364,41 @@ UINT16 P_PartialAddWadFile(const char *wadfilename, boolean local)
|
||||
// TODO: Experimental SPRTINFO support, test first
|
||||
R_LoadSpriteInfoLumps(wadnum, wadfiles[wadnum]->numlumps);
|
||||
|
||||
//
|
||||
// check for votescreen replacements
|
||||
//
|
||||
lumpinfo = wadfiles[wadnum]->lumpinfo;
|
||||
for (i = 0; i < numlumps; i++, lumpinfo++)
|
||||
{
|
||||
name = lumpinfo->name;
|
||||
|
||||
// widescreen patch Race
|
||||
if (!wideracereplaced && !strncmp(name, "INTERSCW", 8))
|
||||
{
|
||||
wideracereplaced = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!racereplaced && !strncmp(name, "INTERSCR", 8))
|
||||
{
|
||||
racereplaced = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
// widescreen patch Battle
|
||||
if (!widebattlereplaced && !strncmp(name, "BATTLSCW", 8))
|
||||
{
|
||||
widebattlereplaced = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!battlereplaced && !strncmp(name, "BATTLSCR", 8))
|
||||
{
|
||||
battlereplaced = true;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
refreshdirmenu &= ~REFRESHDIR_GAMEDATA; // Under usual circumstances we'd wait for REFRESHDIR_GAMEDATA to disappear the next frame, but it's a bit too dangerous for that...
|
||||
partadd_stage = 0;
|
||||
return wadnum;
|
||||
@@ -3361,6 +3428,10 @@ boolean P_MultiSetupWadFiles(boolean fullsetup)
|
||||
ST_LoadGraphics();
|
||||
ST_ReloadSkinFaceGraphics();
|
||||
|
||||
// reload minimap stuff while were in the map since it may get replaced otherwise
|
||||
if (gamestate == GS_LEVEL)
|
||||
P_InitMinimapInfo();
|
||||
|
||||
if (!partadd_important)
|
||||
partadd_stage = -1; // everything done
|
||||
else if (fullsetup)
|
||||
|
||||
+9
-3
@@ -19,11 +19,12 @@
|
||||
#include "r_defs.h"
|
||||
#include "w_wad.h"
|
||||
|
||||
extern SINT8 midgamejoin;
|
||||
|
||||
// map md5, sent to players via PT_SERVERINFO
|
||||
extern unsigned char mapmd5[16];
|
||||
|
||||
// true when level was loaded from netsave
|
||||
extern boolean midgamejoin;
|
||||
|
||||
// Player spawn spots for deathmatch.
|
||||
#define MAX_DM_STARTS 64
|
||||
extern mapthing_t *deathmatchstarts[MAX_DM_STARTS];
|
||||
@@ -60,13 +61,18 @@ extern mapthing_t *mapthings;
|
||||
|
||||
void P_SetupLevelSky(INT32 skynum, boolean global);
|
||||
void P_LoadThingsOnly(void);
|
||||
boolean P_SetupLevel(boolean skipprecip, boolean reloadinggamestate);
|
||||
boolean P_SetupLevel(boolean fromnetsave, boolean reloadinggamestate);
|
||||
#ifdef HWRENDER
|
||||
void HWR_LoadLevel(void);
|
||||
#endif
|
||||
boolean P_AddWadFile(const char *wadfilename, boolean local);
|
||||
boolean P_AddWadFileLocal(const char *wadfilename);
|
||||
|
||||
extern boolean wideracereplaced;
|
||||
extern boolean racereplaced;
|
||||
extern boolean widebattlereplaced;
|
||||
extern boolean battlereplaced;
|
||||
|
||||
// WARNING: The following functions should be grouped as follows:
|
||||
// any amount of PartialAdds followed by MultiSetups until returned true,
|
||||
// as soon as possible.
|
||||
|
||||
+8
-22
@@ -42,15 +42,16 @@ static INT32 sightcounts[2];
|
||||
static INT32 P_DivlineSide(fixed_t x, fixed_t y, const divline_t *node)
|
||||
{
|
||||
fixed_t left, right;
|
||||
return
|
||||
|
||||
return(
|
||||
!node->dx ? x == node->x ? 2 : x <= node->x ? node->dy > 0 : node->dy < 0 :
|
||||
!node->dy ? y == node->y ? 2 : y <= node->y ? node->dx < 0 : node->dx > 0 :
|
||||
(right = ((y - node->y) >> FRACBITS) * (node->dx >> FRACBITS)) <
|
||||
(left = ((x - node->x) >> FRACBITS) * (node->dy >> FRACBITS)) ? 0 :
|
||||
right == left ? 2 : 1;
|
||||
right == left ? 2 : 1);
|
||||
}
|
||||
|
||||
static INT32 P_DivlineCrossed(fixed_t x1, fixed_t y1, fixed_t x2, fixed_t y2, const divline_t *node)
|
||||
static inline INT32 P_DivlineCrossed(fixed_t x1, fixed_t y1, fixed_t x2, fixed_t y2, const divline_t *node)
|
||||
{
|
||||
return (P_DivlineSide(x1, y1, node) == P_DivlineSide(x2, y2, node));
|
||||
}
|
||||
@@ -100,10 +101,6 @@ static boolean P_CrossSubsecPolyObj(polyobj_t *po, register los_t *los)
|
||||
if (P_DivlineCrossed(los->strace.x, los->strace.y, los->t2x, los->t2y, &divl))
|
||||
continue;
|
||||
|
||||
// stop because it is not two sided
|
||||
//if (!(po->flags & POF_TESTHEIGHT))
|
||||
//return false;
|
||||
|
||||
frac = P_InterceptVector(&los->strace, &divl);
|
||||
|
||||
// get slopes of top and bottom of this polyobject line
|
||||
@@ -112,17 +109,11 @@ static boolean P_CrossSubsecPolyObj(polyobj_t *po, register los_t *los)
|
||||
|
||||
if (topslope >= los->topslope && bottomslope <= los->bottomslope)
|
||||
return false; // view completely blocked
|
||||
|
||||
// TODO: figure out if it's worth considering partially blocked cases or not?
|
||||
// maybe to adjust los's top/bottom slopes if needed
|
||||
//if (los->topslope <= los->bottomslope)
|
||||
//return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_CrossSubsector
|
||||
//
|
||||
@@ -305,24 +296,19 @@ static boolean P_CrossBSPNode(INT32 bspnum, register los_t *los, boolean fast)
|
||||
{
|
||||
register node_t *bsp = nodes + bspnum;
|
||||
|
||||
INT32 side = (fast ? R_PointOnSideFast(los->strace.x, los->strace.y, bsp) : (P_DivlineSide(los->strace.x,los->strace.y, (divline_t *)bsp) & 1));
|
||||
INT32 side = (fast ? R_PointOnSideFast(los->strace.x, los->strace.y, bsp) : (P_DivlineSide(los->strace.x, los->strace.y, (divline_t *)bsp) & 1));
|
||||
INT32 side2 = (fast ? R_PointOnSideFast(los->t2x, los->t2y, bsp) : P_DivlineSide(los->t2x, los->t2y, (divline_t *) bsp));
|
||||
|
||||
if (side == side2)
|
||||
{
|
||||
bspnum = bsp->children[side]; // doesn't touch the other side
|
||||
}
|
||||
else
|
||||
else // the partition plane is crossed here
|
||||
{
|
||||
// the partition plane is crossed here
|
||||
if (!P_CrossBSPNode(bsp->children[side], los, fast))
|
||||
{
|
||||
return false; // cross the starting side
|
||||
}
|
||||
else
|
||||
{
|
||||
bspnum = bsp->children[side^1]; // cross the ending side
|
||||
}
|
||||
|
||||
bspnum = bsp->children[side^1]; // cross the ending side
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+1
-1
@@ -24,7 +24,7 @@
|
||||
#include "w_wad.h"
|
||||
|
||||
|
||||
static pslope_t *slopelist = NULL;
|
||||
pslope_t *slopelist = NULL;
|
||||
static UINT16 slopecount = 0;
|
||||
|
||||
// Calculate light
|
||||
|
||||
@@ -33,6 +33,8 @@ void P_CopySectorSlope(line_t *line);
|
||||
|
||||
pslope_t *P_SlopeById(UINT16 id);
|
||||
|
||||
extern pslope_t *slopelist;
|
||||
|
||||
//
|
||||
// P_GetZAt
|
||||
//
|
||||
|
||||
+104
-141
@@ -1427,14 +1427,14 @@ boolean P_RunTriggerLinedef(line_t *triggerline, mobj_t *actor, sector_t *caller
|
||||
}
|
||||
else if (caller)
|
||||
{
|
||||
INT32 special = GETSECSPECIAL(caller->special, 2);
|
||||
const INT32 secspecial = GETSECSPECIAL(caller->special, 2);
|
||||
|
||||
if (special == 6)
|
||||
if (secspecial == 6)
|
||||
{
|
||||
if (!(ALL7EMERALDS(emeralds)))
|
||||
return false;
|
||||
}
|
||||
else if (special == 7) // SRB2Kart: reusing for Race Lap executor
|
||||
else if (secspecial == 7) // SRB2Kart: reusing for Race Lap executor
|
||||
{
|
||||
UINT8 lap;
|
||||
|
||||
@@ -1468,7 +1468,7 @@ boolean P_RunTriggerLinedef(line_t *triggerline, mobj_t *actor, sector_t *caller
|
||||
// If we were not triggered by a sector type especially for the purpose,
|
||||
// a Linedef Executor linedef trigger is not handling sector triggers properly, return.
|
||||
|
||||
else if ((!special || special > 7) && (specialtype > 322))
|
||||
else if ((!secspecial || secspecial > 7) && (specialtype > 322))
|
||||
{
|
||||
CONS_Alert(CONS_WARNING,
|
||||
M_GetText("Linedef executor trigger isn't handling sector triggers properly!\nspecialtype = %d, if you are not a dev, report this warning instance\nalong with the wad that caused it!\n"),
|
||||
@@ -1718,6 +1718,22 @@ void P_LinedefExecute(INT16 tag, mobj_t *actor, sector_t *caller)
|
||||
}
|
||||
}
|
||||
|
||||
static boolean is_rain_type (INT32 weathernum)
|
||||
{
|
||||
switch (weathernum)
|
||||
{
|
||||
case PRECIP_SNOW:
|
||||
case PRECIP_RAIN:
|
||||
case PRECIP_STORM:
|
||||
case PRECIP_STORM_NOSTRIKES:
|
||||
case PRECIP_BLANK:
|
||||
return true;
|
||||
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// P_SwitchWeather
|
||||
//
|
||||
@@ -1725,53 +1741,14 @@ void P_LinedefExecute(INT16 tag, mobj_t *actor, sector_t *caller)
|
||||
//
|
||||
void P_SwitchWeather(INT32 weathernum)
|
||||
{
|
||||
boolean purge = false;
|
||||
INT32 swap = 0;
|
||||
boolean purge = true;
|
||||
|
||||
switch (weathernum)
|
||||
{
|
||||
case PRECIP_NONE: // None
|
||||
if (curWeather == PRECIP_NONE)
|
||||
return; // Nothing to do.
|
||||
purge = true;
|
||||
break;
|
||||
case PRECIP_STORM: // Storm
|
||||
case PRECIP_STORM_NOSTRIKES: // Storm w/ no lightning
|
||||
case PRECIP_RAIN: // Rain
|
||||
if (curWeather == PRECIP_SNOW || curWeather == PRECIP_BLANK || curWeather == PRECIP_STORM_NORAIN)
|
||||
swap = PRECIP_RAIN;
|
||||
break;
|
||||
case PRECIP_SNOW: // Snow
|
||||
if (curWeather == PRECIP_SNOW)
|
||||
return; // Nothing to do.
|
||||
if (curWeather == PRECIP_RAIN || curWeather == PRECIP_STORM || curWeather == PRECIP_STORM_NOSTRIKES || curWeather == PRECIP_BLANK || curWeather == PRECIP_STORM_NORAIN)
|
||||
swap = PRECIP_SNOW; // Need to delete the other precips.
|
||||
break;
|
||||
case PRECIP_STORM_NORAIN: // Storm w/o rain
|
||||
if (curWeather == PRECIP_SNOW
|
||||
|| curWeather == PRECIP_STORM
|
||||
|| curWeather == PRECIP_STORM_NOSTRIKES
|
||||
|| curWeather == PRECIP_RAIN
|
||||
|| curWeather == PRECIP_BLANK)
|
||||
swap = PRECIP_STORM_NORAIN;
|
||||
else if (curWeather == PRECIP_STORM_NORAIN)
|
||||
return;
|
||||
break;
|
||||
case PRECIP_BLANK:
|
||||
if (curWeather == PRECIP_SNOW
|
||||
|| curWeather == PRECIP_STORM
|
||||
|| curWeather == PRECIP_STORM_NOSTRIKES
|
||||
|| curWeather == PRECIP_RAIN)
|
||||
swap = PRECIP_BLANK;
|
||||
else if (curWeather == PRECIP_STORM_NORAIN)
|
||||
swap = PRECIP_BLANK;
|
||||
else if (curWeather == PRECIP_BLANK)
|
||||
return;
|
||||
break;
|
||||
default:
|
||||
CONS_Debug(DBG_GAMELOGIC, "P_SwitchWeather: Unknown weather type %d.\n", weathernum);
|
||||
break;
|
||||
}
|
||||
if (weathernum == curWeather)
|
||||
return;
|
||||
|
||||
if (is_rain_type(weathernum) &&
|
||||
is_rain_type(curWeather))
|
||||
purge = false;
|
||||
|
||||
if (purge)
|
||||
{
|
||||
@@ -1779,44 +1756,47 @@ void P_SwitchWeather(INT32 weathernum)
|
||||
thinker_t *next;
|
||||
precipmobj_t *precipmobj;
|
||||
|
||||
for (think = thinkercap.next; think != &thinkercap; think = next)
|
||||
for (think = precipcap.next; think != &precipcap; think = next)
|
||||
{
|
||||
next = think->next;
|
||||
|
||||
#ifdef PARANOIA
|
||||
if (think->function.acp1 != (actionf_p1)P_NullPrecipThinker)
|
||||
continue; // not a precipmobj thinker
|
||||
#endif
|
||||
|
||||
precipmobj = (precipmobj_t *)think;
|
||||
P_FreePrecipMobj(precipmobj);
|
||||
}
|
||||
}
|
||||
else if (swap && !((swap == PRECIP_BLANK && curWeather == PRECIP_STORM_NORAIN) || (swap == PRECIP_STORM_NORAIN && curWeather == PRECIP_BLANK))) // Rather than respawn all that crap, reuse it!
|
||||
else // Rather than respawn all that crap, reuse it!
|
||||
{
|
||||
thinker_t *think;
|
||||
precipmobj_t *precipmobj;
|
||||
state_t *st;
|
||||
|
||||
for (think = thinkercap.next; think != &thinkercap; think = think->next)
|
||||
for (think = precipcap.next; think != &precipcap; think = think->next)
|
||||
{
|
||||
#ifdef PARANOIA
|
||||
if (think->function.acp1 != (actionf_p1)P_NullPrecipThinker)
|
||||
continue; // not a precipmobj thinker
|
||||
#endif
|
||||
|
||||
precipmobj = (precipmobj_t *)think;
|
||||
|
||||
mobjtype_t type = 0;
|
||||
INT32 z = 0;
|
||||
mobjtype_t type = MT_NULL;
|
||||
|
||||
if (swap == PRECIP_BLANK || swap == PRECIP_STORM_NORAIN) // Remove precip, but keep it around for reuse.
|
||||
if (weathernum == PRECIP_NONE || weathernum == PRECIP_BLANK || weathernum == PRECIP_STORM_NORAIN) // Remove precip, but keep it around for reuse.
|
||||
{
|
||||
precipmobj->precipflags |= PCF_INVISIBLE;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (swap == PRECIP_RAIN) // Snow To Rain
|
||||
else if (weathernum == PRECIP_RAIN || weathernum == PRECIP_STORM || weathernum == PRECIP_STORM_NOSTRIKES) // Snow To Rain
|
||||
{
|
||||
type = MT_RAIN;
|
||||
}
|
||||
else if (swap == PRECIP_SNOW) // Rain To Snow
|
||||
else if (weathernum == PRECIP_SNOW) // Rain To Snow
|
||||
{
|
||||
type = MT_SNOWFLAKE;
|
||||
|
||||
@@ -1846,50 +1826,45 @@ void P_SwitchWeather(INT32 weathernum)
|
||||
}
|
||||
}
|
||||
|
||||
boolean dontspawn = false;
|
||||
boolean spawnprecip = false;
|
||||
|
||||
switch (weathernum)
|
||||
{
|
||||
case PRECIP_SNOW: // snow
|
||||
curWeather = PRECIP_SNOW;
|
||||
break;
|
||||
spawnprecip = true;
|
||||
break;
|
||||
case PRECIP_RAIN: // rain
|
||||
{
|
||||
if (curWeather == PRECIP_RAIN || curWeather == PRECIP_STORM || curWeather == PRECIP_STORM_NOSTRIKES)
|
||||
dontspawn = true;
|
||||
|
||||
curWeather = PRECIP_RAIN;
|
||||
spawnprecip = true;
|
||||
break;
|
||||
}
|
||||
case PRECIP_STORM: // storm
|
||||
{
|
||||
if (curWeather == PRECIP_RAIN || curWeather == PRECIP_STORM || curWeather == PRECIP_STORM_NOSTRIKES)
|
||||
dontspawn = true;
|
||||
|
||||
curWeather = PRECIP_STORM;
|
||||
spawnprecip = true;
|
||||
break;
|
||||
}
|
||||
case PRECIP_STORM_NOSTRIKES: // storm w/o lightning
|
||||
{
|
||||
if (curWeather == PRECIP_RAIN || curWeather == PRECIP_STORM || curWeather == PRECIP_STORM_NOSTRIKES)
|
||||
dontspawn = true;
|
||||
|
||||
curWeather = PRECIP_STORM_NOSTRIKES;
|
||||
spawnprecip = true;
|
||||
break;
|
||||
}
|
||||
case PRECIP_STORM_NORAIN: // storm w/o rain
|
||||
curWeather = PRECIP_STORM_NORAIN;
|
||||
break;
|
||||
case PRECIP_BLANK:
|
||||
case PRECIP_BLANK: //preloaded
|
||||
curWeather = PRECIP_BLANK;
|
||||
break;
|
||||
spawnprecip = true;
|
||||
break;
|
||||
default:
|
||||
dontspawn = true;
|
||||
curWeather = PRECIP_NONE;
|
||||
break;
|
||||
}
|
||||
|
||||
if (!dontspawn && !swap)
|
||||
if (spawnprecip && purge)
|
||||
P_SpawnPrecipitation();
|
||||
}
|
||||
|
||||
@@ -2105,7 +2080,7 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
|
||||
break;
|
||||
|
||||
case 413: // Change music
|
||||
if (keepmusic && (leveltime <= MUSICSTARTTIME)) //why check for starttime? cause encore music Zzz...
|
||||
if (keepmapmusic && (leveltime <= MUSICSTARTTIME)) // why check for starttime? cause encore music Zzz...
|
||||
return;
|
||||
|
||||
//if (cv_ignoremusicchanges.value && (leveltime >= MUSICSTARTTIME) && !fromlapexec) // keep lap music intanct tho
|
||||
@@ -2153,19 +2128,19 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
|
||||
// Change the music and apply position/fade operations
|
||||
else
|
||||
{
|
||||
strncpy(mapmusname, sides[line->sidenum[0]].text, 7);
|
||||
mapmusname[6] = 0;
|
||||
strncpy(mapmusic.name, sides[line->sidenum[0]].text, 7);
|
||||
mapmusic.name[6] = 0;
|
||||
|
||||
mapmusflags = tracknum & MUSIC_TRACKMASK;
|
||||
mapmusic.flags = tracknum & MUSIC_TRACKMASK;
|
||||
if (!(line->flags & ML_BLOCKMONSTERS))
|
||||
mapmusflags |= MUSIC_RELOADRESET;
|
||||
mapmusic.flags |= MUSIC_RELOADRESET;
|
||||
if (line->flags & ML_BOUNCY)
|
||||
mapmusflags |= MUSIC_FORCERESET;
|
||||
mapmusic.flags |= MUSIC_FORCERESET;
|
||||
|
||||
mapmusposition = position;
|
||||
mapmusresume = 0;
|
||||
mapmusic.position = position;
|
||||
mapmusic.resume = 0;
|
||||
|
||||
S_ChangeMusicEx(mapmusname, mapmusflags, !(line->flags & ML_EFFECT4), position,
|
||||
S_ChangeMusicEx(mapmusic.name, mapmusic.flags, !(line->flags & ML_EFFECT4), position,
|
||||
!(line->flags & ML_EFFECT2) ? prefadems : 0,
|
||||
!(line->flags & ML_EFFECT2) ? postfadems : 0);
|
||||
|
||||
@@ -2192,7 +2167,7 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
|
||||
INT32 sfxnum;
|
||||
|
||||
//dont play any funky sound intros that may interfere with the music
|
||||
if (skipintromus && (leveltime < MUSICSTARTTIME))
|
||||
if ((skipintromus || keepmapmusic) && (leveltime < MUSICSTARTTIME))
|
||||
return;
|
||||
|
||||
sfxnum = sides[line->sidenum[0]].toptexture; //P_AproxDistance(line->dx, line->dy)>>FRACBITS;
|
||||
@@ -3335,10 +3310,10 @@ void P_ProcessSpecialSector(player_t *player, sector_t *sector, sector_t *rovers
|
||||
case 6: // Death Pit (Camera Tilt)
|
||||
case 7: // Death Pit (No Camera Tilt)
|
||||
if (roversector || P_MobjReadyToTrigger(player->mo, sector))
|
||||
P_DamageMobj(player->mo, NULL, NULL, 10000);
|
||||
P_DamageMobj(player->mo, NULL, NULL, DMG_INSTAKILL);
|
||||
break;
|
||||
case 8: // Instant Kill
|
||||
P_DamageMobj(player->mo, NULL, NULL, 10000);
|
||||
P_DamageMobj(player->mo, NULL, NULL, DMG_INSTAKILL);
|
||||
break;
|
||||
case 9: // Ring Drainer (Floor Touch)
|
||||
case 10: // Ring Drainer (No Floor Touch)
|
||||
@@ -3586,14 +3561,15 @@ DoneSection2:
|
||||
|
||||
if (!demo.playback || P_AnalogMove(player))
|
||||
{
|
||||
if (player == &players[consoleplayer])
|
||||
localangle[0] = player->mo->angle;
|
||||
else if (player == &players[displayplayers[1]])
|
||||
localangle[1] = player->mo->angle;
|
||||
else if (player == &players[displayplayers[2]])
|
||||
localangle[2] = player->mo->angle;
|
||||
else if (player == &players[displayplayers[3]])
|
||||
localangle[3] = player->mo->angle;
|
||||
for (UINT8 j = 0; j <= splitscreen; ++j)
|
||||
{
|
||||
INT32 id = (j == 0 ? consoleplayer : displayplayers[j]);
|
||||
if (player == &players[id])
|
||||
{
|
||||
localangle[j] = player->mo->angle;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!(lines[i].flags & ML_EFFECT4))
|
||||
@@ -3937,17 +3913,13 @@ DoneSection2:
|
||||
CON_LogMessage(va(M_GetText("%s has finished the race.\n"), player_names[player-players]));
|
||||
|
||||
// SRB2Kart: save best lap for record attack
|
||||
if (player == &players[consoleplayer])
|
||||
if (player->laptime[LAP_CUR] < player->laptime[LAP_BEST] || player->laptime[LAP_BEST] == 0)
|
||||
{
|
||||
if (curlap < bestlap || bestlap == 0)
|
||||
bestlap = curlap;
|
||||
curlap = 0;
|
||||
player->laptime[LAP_BEST] = player->laptime[LAP_CUR];
|
||||
}
|
||||
|
||||
// ONLY FOR HUD
|
||||
player->laptime[LAP_LAST] = player->laptime[LAP_CUR];
|
||||
player->laptime[LAP_CUR] = 0;
|
||||
//
|
||||
|
||||
player->starposttime = player->realtime;
|
||||
player->starpostnum = 0;
|
||||
@@ -4779,16 +4751,34 @@ static ffloor_t *P_AddFakeFloor(sector_t *sec, sector_t *sec2, line_t *master, f
|
||||
else th = th->next;
|
||||
}
|
||||
|
||||
|
||||
if (flags & FF_TRANSLUCENT)
|
||||
{
|
||||
if (sides[master->sidenum[0]].toptexture > 0)
|
||||
ffloor->alpha = sides[master->sidenum[0]].toptexture; // for future reference, "#0" is 1, and "#255" is 256. Be warned
|
||||
{
|
||||
// for future reference, "#0" is 1, and "#255" is 256. Be warned
|
||||
ffloor->alpha = sides[master->sidenum[0]].toptexture;
|
||||
|
||||
if (ffloor->alpha >= 1001) // fourth digit
|
||||
{
|
||||
ffloor->blend = (ffloor->alpha/1000)+1; // becomes an AST
|
||||
ffloor->alpha %= 1000;
|
||||
}
|
||||
else
|
||||
{
|
||||
ffloor->blend = 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ffloor->alpha = 0x80;
|
||||
ffloor->blend = 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ffloor->alpha = 0xff;
|
||||
ffloor->blend = 0;
|
||||
}
|
||||
|
||||
ffloor->spawnalpha = ffloor->alpha; // save for netgames
|
||||
|
||||
@@ -5298,20 +5288,8 @@ void P_SpawnSpecials(INT32 fromnetsave, boolean reloadinggamestate)
|
||||
}
|
||||
}
|
||||
|
||||
if (mapheaderinfo[gamemap-1]->weather == 2) // snow
|
||||
curWeather = PRECIP_SNOW;
|
||||
else if (mapheaderinfo[gamemap-1]->weather == 3) // rain
|
||||
curWeather = PRECIP_RAIN;
|
||||
else if (mapheaderinfo[gamemap-1]->weather == 1) // storm
|
||||
curWeather = PRECIP_STORM;
|
||||
else if (mapheaderinfo[gamemap-1]->weather == 5) // storm w/o rain
|
||||
curWeather = PRECIP_STORM_NORAIN;
|
||||
else if (mapheaderinfo[gamemap-1]->weather == 6) // storm w/o lightning
|
||||
curWeather = PRECIP_STORM_NOSTRIKES;
|
||||
else if (mapheaderinfo[gamemap-1]->weather == 4) // blank
|
||||
curWeather = PRECIP_BLANK;
|
||||
else
|
||||
curWeather = PRECIP_NONE;
|
||||
// set current weather
|
||||
curWeather = mapheaderinfo[gamemap-1]->weather;
|
||||
|
||||
P_InitTagLists(); // Create xref tables for tags
|
||||
P_SearchForDisableLinedefs(); // Disable linedefs are now allowed to disable *any* line
|
||||
@@ -7429,33 +7407,18 @@ void T_Pusher(pusher_t *p)
|
||||
|
||||
if (!demo.playback || P_AnalogMove(thing->player))
|
||||
{
|
||||
if (thing->player == &players[consoleplayer])
|
||||
for (UINT8 i = 0; i <= splitscreen; ++i)
|
||||
{
|
||||
if (thing->angle - localangle[0] > ANGLE_180)
|
||||
localangle[0] -= (localangle[0] - thing->angle) / 8;
|
||||
else
|
||||
localangle[0] += (thing->angle - localangle[0]) / 8;
|
||||
}
|
||||
else if (thing->player == &players[displayplayers[1]])
|
||||
{
|
||||
if (thing->angle - localangle[1] > ANGLE_180)
|
||||
localangle[1] -= (localangle[1] - thing->angle) / 8;
|
||||
else
|
||||
localangle[1] += (thing->angle - localangle[1]) / 8;
|
||||
}
|
||||
else if (thing->player == &players[displayplayers[2]])
|
||||
{
|
||||
if (thing->angle - localangle[2] > ANGLE_180)
|
||||
localangle[2] -= (localangle[2] - thing->angle) / 8;
|
||||
else
|
||||
localangle[2] += (thing->angle - localangle[2]) / 8;
|
||||
}
|
||||
else if (thing->player == &players[displayplayers[3]])
|
||||
{
|
||||
if (thing->angle - localangle[3] > ANGLE_180)
|
||||
localangle[3] -= (localangle[3] - thing->angle) / 8;
|
||||
else
|
||||
localangle[3] += (thing->angle - localangle[3]) / 8;
|
||||
INT32 id = (i == 0 ? consoleplayer : displayplayers[i]);
|
||||
if (thing->player == &players[id])
|
||||
{
|
||||
if (thing->angle - localangle[i] > ANGLE_180)
|
||||
localangle[i] -= (localangle[i] - thing->angle) / 8;
|
||||
else
|
||||
localangle[i] += (thing->angle - localangle[i]) / 8;
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+83
-24
@@ -49,6 +49,7 @@ tic_t leveltime;
|
||||
|
||||
// Both the head and tail of the thinker list.
|
||||
thinker_t thinkercap;
|
||||
thinker_t precipcap;
|
||||
|
||||
void Command_Numthinkers_f(void)
|
||||
{
|
||||
@@ -56,6 +57,7 @@ void Command_Numthinkers_f(void)
|
||||
INT32 count = 0;
|
||||
actionf_p1 action;
|
||||
thinker_t *think;
|
||||
thinker_t *listtype;
|
||||
|
||||
if (gamestate != GS_LEVEL)
|
||||
{
|
||||
@@ -104,7 +106,9 @@ void Command_Numthinkers_f(void)
|
||||
return;
|
||||
}
|
||||
|
||||
for (think = thinkercap.next; think != &thinkercap; think = think->next)
|
||||
listtype = (num == 2) ? &precipcap : &thinkercap;
|
||||
|
||||
for (think = listtype->next; think != listtype; think = think->next)
|
||||
{
|
||||
if (think->function.acp1 != action)
|
||||
continue;
|
||||
@@ -181,6 +185,7 @@ void Command_CountMobjs_f(void)
|
||||
void P_InitThinkers(void)
|
||||
{
|
||||
thinkercap.prev = thinkercap.next = &thinkercap;
|
||||
precipcap.prev = precipcap.next = &precipcap;
|
||||
waypointcap = NULL;
|
||||
}
|
||||
|
||||
@@ -200,6 +205,22 @@ void P_AddThinker(thinker_t *thinker)
|
||||
thinker->cachable = (thinker->function.acp1 == (actionf_p1)P_MobjThinker);
|
||||
}
|
||||
|
||||
//
|
||||
// P_AddPrecipThinker
|
||||
// Adds a new precip thinker at the end of the list.
|
||||
//
|
||||
void P_AddPrecipThinker(thinker_t *thinker)
|
||||
{
|
||||
precipcap.prev->next = thinker;
|
||||
thinker->next = &precipcap;
|
||||
thinker->prev = precipcap.prev;
|
||||
precipcap.prev = thinker;
|
||||
|
||||
thinker->references = 0; // killough 11/98: init reference counter to 0
|
||||
|
||||
thinker->cachable = false;
|
||||
}
|
||||
|
||||
//
|
||||
// killough 11/98:
|
||||
//
|
||||
@@ -341,8 +362,6 @@ static inline void P_RunThinkers(void)
|
||||
{
|
||||
for (currentthinker = thinkercap.next; currentthinker != &thinkercap; currentthinker = currentthinker->next)
|
||||
{
|
||||
if (currentthinker->function.acp1 == (actionf_p1)P_NullPrecipThinker)
|
||||
continue;
|
||||
#ifdef PARANOIA
|
||||
I_Assert(currentthinker->function.acp1 != NULL)
|
||||
#endif
|
||||
@@ -354,7 +373,7 @@ static void P_DeviceRumbleTick(void)
|
||||
{
|
||||
UINT8 i;
|
||||
|
||||
if (I_NumJoys() == 0 || gamestate != GS_LEVEL)
|
||||
if (dedicated || numcontrollers == 0 || gamestate != GS_LEVEL)
|
||||
{
|
||||
return;
|
||||
}
|
||||
@@ -364,24 +383,19 @@ static void P_DeviceRumbleTick(void)
|
||||
UINT16 low = 0;
|
||||
UINT16 high = 0;
|
||||
|
||||
if (!cv_usejoystick[i].value || !cv_rumble[i].value)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
player_t *player = ((i == 0) ? &players[consoleplayer] : &players[displayplayers[i]]);
|
||||
|
||||
if (!cv_usejoystick[i].value)
|
||||
if (player->spectator || !player->mo)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!cv_rumble[i].value)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if (player->spectator)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if (player->mo == NULL)
|
||||
if (camera[i].freecam)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
@@ -394,7 +408,8 @@ static void P_DeviceRumbleTick(void)
|
||||
|
||||
if (player->kartstuff[k_spinouttimer])
|
||||
{
|
||||
low = high = FRACUNIT / 4;
|
||||
//low = high = FRACUNIT / 6;
|
||||
low = high = FixedMul((FRACUNIT / 4), (FixedDiv(player->kartstuff[k_spinouttimer], (3*TICRATE / 2))));
|
||||
}
|
||||
else if (player->kartstuff[k_sneakertimer] > (sneakertime-(TICRATE/2)))
|
||||
{
|
||||
@@ -416,6 +431,12 @@ static void P_DeviceRumbleTick(void)
|
||||
low = high = FRACUNIT / 64;
|
||||
}
|
||||
}
|
||||
else if ((player->kartstuff[k_bananadrag] > TICRATE)
|
||||
&& P_IsObjectOnGround(player->mo) && player->speed != 0)
|
||||
{
|
||||
if (leveltime & 1) // this is actually funny lel
|
||||
high = FRACUNIT / 64;
|
||||
}
|
||||
|
||||
if (player->kartstuff[k_brakedrift])
|
||||
{
|
||||
@@ -439,7 +460,20 @@ void P_RunChaseCameras(void)
|
||||
for (i = 0; i <= splitscreen; i++)
|
||||
{
|
||||
if (camera[i].chase)
|
||||
P_MoveChaseCamera(&players[displayplayers[i]], &camera[i], false);
|
||||
{
|
||||
player_t *p = &players[displayplayers[i]];
|
||||
camera_t *cam = &camera[i];
|
||||
|
||||
if (cv_verticallook.value && leveltime > starttime && p->mo && p->kartstuff[k_respawn] == 0 && p->kartstuff[k_throwdir] != 0)
|
||||
{
|
||||
if (p->speed < 6 * p->mo->scale && abs(cam->dpad_y_held) < 2*TICRATE)
|
||||
cam->dpad_y_held += intsign(p->kartstuff[k_throwdir]);
|
||||
}
|
||||
else
|
||||
cam->dpad_y_held = 0;
|
||||
|
||||
P_MoveChaseCamera(p, cam, false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -473,6 +507,32 @@ static void P_RunQuakes(void)
|
||||
--quake.time;
|
||||
}
|
||||
|
||||
static inline void P_ResetSpriteStuff(void)
|
||||
{
|
||||
thinker_t *th;
|
||||
|
||||
if (rendermode == render_none)
|
||||
return;
|
||||
|
||||
for (th = thinkercap.next; th != &thinkercap; th = th->next)
|
||||
{
|
||||
mobj_t *mo;
|
||||
|
||||
if (th->function.acp1 != (actionf_p1)P_MobjThinker) // not a mobj
|
||||
continue;
|
||||
|
||||
mo = (mobj_t *)th;
|
||||
|
||||
if (mo->sprite == SPR_NULL || mo->flags2 & MF2_DONTDRAW || mo->type == MT_SHADOW)
|
||||
continue;
|
||||
|
||||
mo->spritexscale = mo->realxscale;
|
||||
mo->spriteyscale = mo->realyscale;
|
||||
mo->spritexoffset = mo->realxoffset;
|
||||
mo->spriteyoffset = mo->realyoffset;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// P_Ticker
|
||||
//
|
||||
@@ -520,8 +580,8 @@ void P_Ticker(boolean run)
|
||||
timeinmap = (timeinmap-1) & ~3;
|
||||
G_PreviewRewind(leveltime);
|
||||
}
|
||||
else if (demo.freecam && democam.cam) // special case: allow freecam to MOVE during pause!
|
||||
P_DemoCameraMovement(democam.cam);
|
||||
else
|
||||
P_RunChaseCameras(); // special case: allow freecam to MOVE during pause!
|
||||
|
||||
return;
|
||||
}
|
||||
@@ -573,6 +633,8 @@ void P_Ticker(boolean run)
|
||||
ps_lua_mobjhooks.value.i = 0;
|
||||
ps_checkposition_calls.value.i = 0;
|
||||
|
||||
P_ResetSpriteStuff();
|
||||
|
||||
PS_START_TIMING(ps_lua_prethinkframe_time);
|
||||
LUA_HookPreThinkFrame();
|
||||
PS_STOP_TIMING(ps_lua_prethinkframe_time);
|
||||
@@ -614,10 +676,7 @@ void P_Ticker(boolean run)
|
||||
PS_STOP_TIMING(ps_lua_thinkframe_time);
|
||||
}
|
||||
|
||||
// Run shield positioning
|
||||
//P_RunShields();
|
||||
P_RunOverlays();
|
||||
|
||||
P_RunShadows();
|
||||
|
||||
P_UpdateSpecials();
|
||||
@@ -647,7 +706,7 @@ void P_Ticker(boolean run)
|
||||
if (!players[i].mo)
|
||||
continue;
|
||||
|
||||
P_DamageMobj(players[i].mo, NULL, NULL, 10000);
|
||||
P_DamageMobj(players[i].mo, NULL, NULL, DMG_INSTAKILL);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+470
-325
File diff suppressed because it is too large.
Load diff
@@ -16,6 +16,7 @@
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include "qs22j.h"
|
||||
|
||||
#define INSORTTHRESH 5 // if n < this use insertion sort
|
||||
|
||||
+40
-59
@@ -263,21 +263,11 @@ sector_t *R_FakeFlat(sector_t *sec, sector_t *tempsec, INT32 *floorlightlevel,
|
||||
mobj_t *pviewmobj = viewplayer->mo;
|
||||
INT32 heightsec;
|
||||
boolean underwater;
|
||||
UINT8 i;
|
||||
|
||||
for (i = 0; i <= splitscreen; i++)
|
||||
{
|
||||
if (viewplayer != &players[displayplayers[i]])
|
||||
continue;
|
||||
|
||||
if (!camera[i].chase)
|
||||
continue;
|
||||
UINT8 i = R_GetViewNumber();
|
||||
|
||||
if (viewplayer == &players[displayplayers[i]] && camera[i].chase)
|
||||
heightsec = R_PointInSubsector(camera[i].x, camera[i].y)->sector->heightsec;
|
||||
break;
|
||||
}
|
||||
|
||||
if (i > splitscreen && pviewmobj)
|
||||
else if (i > splitscreen && viewmobj)
|
||||
heightsec = R_PointInSubsector(pviewmobj->x, pviewmobj->y)->sector->heightsec;
|
||||
else
|
||||
return sec;
|
||||
@@ -433,7 +423,7 @@ static void R_AddLine(seg_t *line)
|
||||
span = angle1 - angle2;
|
||||
|
||||
// Back side? i.e. backface culling?
|
||||
if (span >= ANGLE_180)
|
||||
if (span >= ANGLE_180 || !line->linedef)
|
||||
return;
|
||||
|
||||
// Global angle needed by segcalc.
|
||||
@@ -504,11 +494,12 @@ static void R_AddLine(seg_t *line)
|
||||
|
||||
doorclosed = 0;
|
||||
|
||||
fixed_t frontf1,frontf2, frontc1, frontc2; // front floor/ceiling ends
|
||||
fixed_t backf1, backf2, backc1, backc2; // back floor ceiling ends
|
||||
|
||||
// Closed door.
|
||||
if (frontsector->f_slope || frontsector->c_slope || backsector->f_slope || backsector->c_slope)
|
||||
{
|
||||
fixed_t frontf1,frontf2, frontc1, frontc2; // front floor/ceiling ends
|
||||
fixed_t backf1, backf2, backc1, backc2; // back floor ceiling ends
|
||||
#define SLOPEPARAMS(slope, end1, end2, normalheight) \
|
||||
if (slope) { \
|
||||
end1 = P_GetZAt(slope, line->v1->x, line->v1->y); \
|
||||
@@ -521,57 +512,44 @@ static void R_AddLine(seg_t *line)
|
||||
SLOPEPARAMS( backsector->f_slope, backf1, backf2, backsector->floorheight)
|
||||
SLOPEPARAMS( backsector->c_slope, backc1, backc2, backsector->ceilingheight)
|
||||
#undef SLOPEPARAMS
|
||||
if (viewsector != backsector && viewsector != frontsector)
|
||||
{
|
||||
if ((backc1 <= frontf1 && backc2 <= frontf2)
|
||||
|| (backf1 >= frontc1 && backf2 >= frontc2))
|
||||
{
|
||||
goto clipsolid;
|
||||
}
|
||||
|
||||
// Check for automap fix. Store in doorclosed for r_segs.c
|
||||
doorclosed = (backc1 <= backf1 && backc2 <= backf2
|
||||
&& ((backc1 >= frontc1 && backc2 >= frontc2) || curline->sidedef->toptexture)
|
||||
&& ((backf1 <= frontf1 && backf2 >= frontf2) || curline->sidedef->bottomtexture)
|
||||
&& (backsector->ceilingpic != skyflatnum || frontsector->ceilingpic != skyflatnum));
|
||||
|
||||
if (doorclosed)
|
||||
goto clipsolid;
|
||||
}
|
||||
|
||||
// Window.
|
||||
if (backc1 != frontc1 || backc2 != frontc2
|
||||
|| backf1 != frontf1 || backf2 != frontf2)
|
||||
{
|
||||
goto clippass;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (viewsector != backsector && viewsector != frontsector)
|
||||
frontf1 = frontf2 = frontsector->floorheight;
|
||||
frontc1 = frontc2 = frontsector->ceilingheight;
|
||||
backf1 = backf2 = backsector->floorheight;
|
||||
backc1 = backc2 = backsector->ceilingheight;
|
||||
}
|
||||
|
||||
if (viewsector != backsector && viewsector != frontsector)
|
||||
{
|
||||
// here we're talking about a CEILING lower than a floor. ...yeah we don't even need to bother.
|
||||
if (backc1 <= frontf1 && backc2 <= frontf2)
|
||||
{
|
||||
if (backsector->ceilingheight <= frontsector->floorheight
|
||||
|| backsector->floorheight >= frontsector->ceilingheight)
|
||||
{
|
||||
goto clipsolid;
|
||||
}
|
||||
|
||||
// Check for automap fix. Store in doorclosed for r_segs.c
|
||||
doorclosed = (backsector->ceilingheight <= backsector->floorheight
|
||||
&& (backsector->ceilingheight >= frontsector->ceilingheight || curline->sidedef->toptexture)
|
||||
&& (backsector->floorheight <= frontsector->floorheight || curline->sidedef->bottomtexture)
|
||||
&& (backsector->ceilingpic != skyflatnum || frontsector->ceilingpic != skyflatnum));
|
||||
|
||||
if (doorclosed)
|
||||
goto clipsolid;
|
||||
goto clipsolid;
|
||||
}
|
||||
|
||||
// Window.
|
||||
if (backsector->ceilingheight != frontsector->ceilingheight
|
||||
|| backsector->floorheight != frontsector->floorheight)
|
||||
// here we're talking about floors higher than ceilings, don't even bother either.
|
||||
if (backf1 >= frontc1 && backf2 >= frontc2)
|
||||
{
|
||||
goto clippass;
|
||||
goto clipsolid;
|
||||
}
|
||||
|
||||
// Check for automap fix. Store in doorclosed for r_segs.c
|
||||
doorclosed = (backc1 <= backf1 && backc2 <= backf2
|
||||
&& ((backc1 >= frontc1 && backc2 >= frontc2) || curline->sidedef->toptexture)
|
||||
&& ((backf1 <= frontf1 && backf2 >= frontf2) || curline->sidedef->bottomtexture)
|
||||
&& (backsector->ceilingpic != skyflatnum || frontsector->ceilingpic != skyflatnum));
|
||||
|
||||
if (doorclosed)
|
||||
goto clipsolid;
|
||||
}
|
||||
|
||||
// Window.
|
||||
if (backc1 != frontc1 || backc2 != frontc2
|
||||
|| backf1 != frontf1 || backf2 != frontf2)
|
||||
{
|
||||
goto clippass;
|
||||
}
|
||||
|
||||
// Reject empty lines used for triggers and special events.
|
||||
@@ -907,6 +885,9 @@ static void R_Subsector(size_t num)
|
||||
{
|
||||
for (rover = frontsector->ffloors; rover; rover = rover->next)
|
||||
{
|
||||
if (!(rover->flags & FF_EXISTS) || !(rover->flags & FF_RENDERPLANES))
|
||||
continue;
|
||||
|
||||
sector_t *controlSec = §ors[rover->secnum];
|
||||
|
||||
if (controlSec->moved != true)
|
||||
|
||||
+112
@@ -126,6 +126,113 @@ size_t flatmemory, spritememory, texturememory; // gotta play by 2.2 rules to ge
|
||||
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)
|
||||
{
|
||||
RGBA_t output;
|
||||
INT16 fullalpha = (alpha - (0xFF - foreground.s.alpha));
|
||||
if (style == AST_TRANSLUCENT)
|
||||
{
|
||||
if (fullalpha <= 0)
|
||||
output.rgba = background.rgba;
|
||||
else
|
||||
{
|
||||
// don't go too high
|
||||
if (fullalpha >= 0xFF)
|
||||
fullalpha = 0xFF;
|
||||
alpha = (UINT8)fullalpha;
|
||||
|
||||
// if the background pixel is empty,
|
||||
// match software and don't blend anything
|
||||
if (!background.s.alpha)
|
||||
{
|
||||
// ...unless the foreground pixel ISN'T actually translucent.
|
||||
if (alpha == 0xFF)
|
||||
output.rgba = foreground.rgba;
|
||||
else
|
||||
output.rgba = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
UINT8 beta = (0xFF - alpha);
|
||||
output.s.red = ((background.s.red * beta) + (foreground.s.red * alpha)) / 0xFF;
|
||||
output.s.green = ((background.s.green * beta) + (foreground.s.green * alpha)) / 0xFF;
|
||||
output.s.blue = ((background.s.blue * beta) + (foreground.s.blue * alpha)) / 0xFF;
|
||||
output.s.alpha = 0xFF;
|
||||
}
|
||||
}
|
||||
return output.rgba;
|
||||
}
|
||||
#define clamp(c) max(min(c, 0xFF), 0x00);
|
||||
else
|
||||
{
|
||||
float falpha = ((float)alpha / 256.0f);
|
||||
float fr = ((float)foreground.s.red * falpha);
|
||||
float fg = ((float)foreground.s.green * falpha);
|
||||
float fb = ((float)foreground.s.blue * falpha);
|
||||
if (style == AST_ADD)
|
||||
{
|
||||
output.s.red = clamp((int)(background.s.red + fr));
|
||||
output.s.green = clamp((int)(background.s.green + fg));
|
||||
output.s.blue = clamp((int)(background.s.blue + fb));
|
||||
}
|
||||
else if (style == AST_SUBTRACT)
|
||||
{
|
||||
output.s.red = clamp((int)(background.s.red - fr));
|
||||
output.s.green = clamp((int)(background.s.green - fg));
|
||||
output.s.blue = clamp((int)(background.s.blue - fb));
|
||||
}
|
||||
else if (style == AST_REVERSESUBTRACT)
|
||||
{
|
||||
output.s.red = clamp((int)((-background.s.red) + fr));
|
||||
output.s.green = clamp((int)((-background.s.green) + fg));
|
||||
output.s.blue = clamp((int)((-background.s.blue) + fb));
|
||||
}
|
||||
else if (style == AST_MODULATE)
|
||||
{
|
||||
fr = ((float)foreground.s.red / 256.0f);
|
||||
fg = ((float)foreground.s.green / 256.0f);
|
||||
fb = ((float)foreground.s.blue / 256.0f);
|
||||
output.s.red = clamp((int)(background.s.red * fr));
|
||||
output.s.green = clamp((int)(background.s.green * fg));
|
||||
output.s.blue = clamp((int)(background.s.blue * fb));
|
||||
}
|
||||
// just copy the pixel
|
||||
else if (style == AST_COPY)
|
||||
output.rgba = foreground.rgba;
|
||||
|
||||
output.s.alpha = 0xFF;
|
||||
return output.rgba;
|
||||
}
|
||||
#undef clamp
|
||||
return 0;
|
||||
}
|
||||
|
||||
INT32 ASTTextureBlendingThreshold[2] = {255/11, (10*255/11)};
|
||||
|
||||
// Blends a pixel for a texture patch.
|
||||
UINT32 ASTBlendTexturePixel(RGBA_t background, RGBA_t foreground, int style, UINT8 alpha)
|
||||
{
|
||||
// Alpha style set to translucent?
|
||||
if (style == AST_TRANSLUCENT)
|
||||
{
|
||||
// Is the alpha small enough for translucency?
|
||||
if (alpha <= ASTTextureBlendingThreshold[1])
|
||||
{
|
||||
// Is the patch way too translucent? Don't blend then.
|
||||
if (alpha < ASTTextureBlendingThreshold[0])
|
||||
return background.rgba;
|
||||
|
||||
return ASTBlendPixel(background, foreground, style, alpha);
|
||||
}
|
||||
else // just copy the pixel
|
||||
return foreground.rgba;
|
||||
}
|
||||
else
|
||||
return ASTBlendPixel(background, foreground, style, alpha);
|
||||
}
|
||||
|
||||
// Painfully simple texture id cacheing to make maps load faster. :3
|
||||
static struct {
|
||||
char name[9];
|
||||
@@ -282,6 +389,11 @@ static UINT8 *R_GenerateTexture(size_t texnum)
|
||||
for (i = 0, patch = texture->patches; i < texture->patchcount; i++, patch++)
|
||||
{
|
||||
realpatch = W_CacheLumpNumPwad(patch->wad, patch->lump, PU_CACHE);
|
||||
|
||||
// Well, it's not valid...
|
||||
if (realpatch == NULL)
|
||||
continue;
|
||||
|
||||
x1 = patch->originx;
|
||||
x2 = x1 + SHORT(realpatch->width);
|
||||
|
||||
|
||||
@@ -56,6 +56,9 @@ extern INT32 *texturewidthmask;
|
||||
|
||||
extern fixed_t *textureheight; // needed for texture pegging
|
||||
|
||||
UINT32 ASTBlendPixel(RGBA_t background, RGBA_t foreground, int style, UINT8 alpha);
|
||||
UINT32 ASTBlendTexturePixel(RGBA_t background, RGBA_t foreground, int style, UINT8 alpha);
|
||||
|
||||
extern INT16 color8to16[256]; // remap color index to highcolor
|
||||
extern INT16 *hicolormaps; // remap high colors to high colors..
|
||||
|
||||
|
||||
+6
-14
@@ -172,6 +172,7 @@ typedef struct ffloor_s
|
||||
|
||||
INT32 lastlight;
|
||||
INT32 alpha;
|
||||
UINT8 blend; // blendmode
|
||||
tic_t norender; // for culling
|
||||
|
||||
// these are saved for netgames, so do not let Lua touch these!
|
||||
@@ -354,9 +355,6 @@ typedef struct sector_s
|
||||
// Current speed of ceiling/floor. For Knuckles to hold onto stuff.
|
||||
fixed_t floorspeed, ceilspeed;
|
||||
|
||||
// list of precipitation mobjs in sector
|
||||
struct mprecipsecnode_s *touching_preciplist;
|
||||
|
||||
// Eternity engine slope
|
||||
pslope_t *f_slope; // floor slope
|
||||
pslope_t *c_slope; // ceiling slope
|
||||
@@ -402,6 +400,8 @@ typedef struct line_s
|
||||
|
||||
// Visual appearance: sidedefs.
|
||||
UINT16 sidenum[2]; // sidenum[1] will be 0xffff if one-sided
|
||||
fixed_t alpha; // translucency
|
||||
UINT8 blendmode; // blendmode
|
||||
|
||||
fixed_t bbox[4]; // bounding box for the extent of the linedef
|
||||
|
||||
@@ -492,17 +492,6 @@ typedef struct msecnode_s
|
||||
boolean visited; // used in search algorithms
|
||||
} msecnode_t;
|
||||
|
||||
typedef struct mprecipsecnode_s
|
||||
{
|
||||
sector_t *m_sector; // a sector containing this object
|
||||
struct precipmobj_s *m_thing; // this object
|
||||
struct mprecipsecnode_s *m_sectorlist_prev; // prev msecnode_t for this thing
|
||||
struct mprecipsecnode_s *m_sectorlist_next; // next msecnode_t for this thing
|
||||
struct mprecipsecnode_s *m_thinglist_prev; // prev msecnode_t for this sector
|
||||
struct mprecipsecnode_s *m_thinglist_next; // next msecnode_t for this sector
|
||||
boolean visited; // used in search algorithms
|
||||
} mprecipsecnode_t;
|
||||
|
||||
//
|
||||
// The lineseg.
|
||||
//
|
||||
@@ -687,6 +676,9 @@ typedef struct
|
||||
#pragma pack()
|
||||
#endif
|
||||
|
||||
// Possible alpha types for a patch.
|
||||
enum patchalphastyle {AST_COPY, AST_TRANSLUCENT, AST_ADD, AST_SUBTRACT, AST_REVERSESUBTRACT, AST_MODULATE, AST_OVERLAY};
|
||||
|
||||
typedef enum
|
||||
{
|
||||
SRF_SINGLE = 0, // 0-angle for all rotations
|
||||
|
||||
+187
-3
@@ -86,6 +86,7 @@ INT32 dc_sourcelength;
|
||||
#define NUMTRANSTABLES 9 // how many translucency tables are used
|
||||
|
||||
UINT8 *transtables; // translucency tables
|
||||
UINT8 *blendtables[NUMBLENDMAPS];
|
||||
|
||||
/** \brief R_DrawTransColumn uses this
|
||||
*/
|
||||
@@ -213,11 +214,11 @@ const UINT8 Color_Opposite[MAXSKINCOLORS*2] =
|
||||
|
||||
CV_PossibleValue_t Color_cons_t[MAXSKINCOLORS+1];
|
||||
|
||||
/** \brief The R_InitTranslationTables
|
||||
#define TRANSTAB_AMTMUL10 (256.0f / 10.0f)
|
||||
|
||||
load in color translation tables
|
||||
/** \brief Initializes the translucency tables used by the Software renderer.
|
||||
*/
|
||||
void R_InitTranslationTables(void)
|
||||
void R_InitTranslucencyTables(void)
|
||||
{
|
||||
// Load here the transparency lookup tables 'TINTTAB'
|
||||
// NOTE: the TINTTAB resource MUST BE aligned on 64k for the asm
|
||||
@@ -234,6 +235,189 @@ void R_InitTranslationTables(void)
|
||||
W_ReadLump(W_GetNumForName("TRANS70"), transtables+0x60000);
|
||||
W_ReadLump(W_GetNumForName("TRANS80"), transtables+0x70000);
|
||||
W_ReadLump(W_GetNumForName("TRANS90"), transtables+0x80000);
|
||||
|
||||
R_GenerateBlendTables();
|
||||
}
|
||||
|
||||
static colorlookup_t transtab_lut;
|
||||
|
||||
static void BlendTab_Translucent(UINT8 *table, int style, UINT8 blendamt)
|
||||
{
|
||||
INT16 bg, fg;
|
||||
|
||||
if (table == NULL)
|
||||
I_Error("BlendTab_Translucent: input table was NULL!");
|
||||
|
||||
for (bg = 0; bg < 0x100; bg++)
|
||||
{
|
||||
for (fg = 0; fg < 0x100; fg++)
|
||||
{
|
||||
RGBA_t backrgba = V_GetColor(bg);
|
||||
RGBA_t frontrgba = V_GetColor(fg);
|
||||
RGBA_t result;
|
||||
|
||||
result.rgba = ASTBlendPixel(backrgba, frontrgba, style, 0xFF);
|
||||
result.rgba = ASTBlendPixel(result, frontrgba, AST_TRANSLUCENT, blendamt);
|
||||
|
||||
table[((bg * 0x100) + fg)] = GetColorLUT(&transtab_lut, result.s.red, result.s.green, result.s.blue);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void BlendTab_Subtractive(UINT8 *table, int style, UINT8 blendamt)
|
||||
{
|
||||
INT16 bg, fg;
|
||||
|
||||
if (table == NULL)
|
||||
I_Error("BlendTab_Subtractive: input table was NULL!");
|
||||
|
||||
if (blendamt == 0xFF)
|
||||
{
|
||||
memset(table, GetColorLUT(&transtab_lut, 0, 0, 0), 0x10000);
|
||||
return;
|
||||
}
|
||||
|
||||
for (bg = 0; bg < 0x100; bg++)
|
||||
{
|
||||
for (fg = 0; fg < 0x100; fg++)
|
||||
{
|
||||
RGBA_t backrgba = V_GetColor(bg);
|
||||
RGBA_t frontrgba = V_GetColor(fg);
|
||||
RGBA_t result;
|
||||
|
||||
result.rgba = ASTBlendPixel(backrgba, frontrgba, style, 0xFF);
|
||||
result.s.red = max(0, result.s.red - blendamt);
|
||||
result.s.green = max(0, result.s.green - blendamt);
|
||||
result.s.blue = max(0, result.s.blue - blendamt);
|
||||
|
||||
table[((bg * 0x100) + fg)] = GetColorLUT(&transtab_lut, result.s.red, result.s.green, result.s.blue);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void BlendTab_Modulative(UINT8 *table)
|
||||
{
|
||||
INT16 bg, fg;
|
||||
|
||||
if (table == NULL)
|
||||
I_Error("BlendTab_Modulative: input table was NULL!");
|
||||
|
||||
for (bg = 0; bg < 0x100; bg++)
|
||||
{
|
||||
for (fg = 0; fg < 0x100; fg++)
|
||||
{
|
||||
RGBA_t backrgba = V_GetColor(bg);
|
||||
RGBA_t frontrgba = V_GetColor(fg);
|
||||
RGBA_t result;
|
||||
result.rgba = ASTBlendPixel(backrgba, frontrgba, AST_MODULATE, 0);
|
||||
table[((bg * 0x100) + fg)] = GetColorLUT(&transtab_lut, result.s.red, result.s.green, result.s.blue);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static INT32 BlendTab_Count[NUMBLENDMAPS] =
|
||||
{
|
||||
NUMTRANSTABLES, // blendtab_add
|
||||
NUMTRANSTABLES+1, // blendtab_subtract
|
||||
NUMTRANSTABLES+1, // blendtab_reversesubtract
|
||||
1 // blendtab_modulate
|
||||
};
|
||||
|
||||
static INT32 BlendTab_FromStyle[] =
|
||||
{
|
||||
0, // AST_COPY
|
||||
0, // AST_TRANSLUCENT
|
||||
blendtab_add, // AST_ADD
|
||||
blendtab_subtract, // AST_SUBTRACT
|
||||
blendtab_reversesubtract, // AST_REVERSESUBTRACT
|
||||
blendtab_modulate, // AST_MODULATE
|
||||
0 // AST_OVERLAY
|
||||
};
|
||||
|
||||
static void BlendTab_GenerateMaps(INT32 tab, INT32 style, void (*genfunc)(UINT8 *, int, UINT8))
|
||||
{
|
||||
INT32 i = 0, num = BlendTab_Count[tab];
|
||||
const float amtmul = (256.0f / (float)(NUMTRANSTABLES));
|
||||
for (; i < num; i++)
|
||||
{
|
||||
const size_t offs = (0x10000 * i);
|
||||
const UINT16 alpha = min(amtmul * i, 0xFF);
|
||||
genfunc(blendtables[tab] + offs, style, alpha);
|
||||
}
|
||||
}
|
||||
|
||||
void R_GenerateBlendTables(void)
|
||||
{
|
||||
INT32 i;
|
||||
|
||||
for (i = 0; i < NUMBLENDMAPS; i++)
|
||||
blendtables[i] = Z_MallocAlign(BlendTab_Count[i] * 0x10000, PU_STATIC, NULL, 16);
|
||||
|
||||
InitColorLUT(&transtab_lut, pLocalPalette, false);
|
||||
|
||||
// Additive
|
||||
BlendTab_GenerateMaps(blendtab_add, AST_ADD, BlendTab_Translucent);
|
||||
|
||||
// Subtractive
|
||||
#if 1
|
||||
BlendTab_GenerateMaps(blendtab_subtract, AST_SUBTRACT, BlendTab_Subtractive);
|
||||
#else
|
||||
BlendTab_GenerateMaps(blendtab_subtract, AST_SUBTRACT, BlendTab_Translucent);
|
||||
#endif
|
||||
|
||||
// Reverse subtractive
|
||||
BlendTab_GenerateMaps(blendtab_reversesubtract, AST_REVERSESUBTRACT, BlendTab_Translucent);
|
||||
|
||||
// Modulative blending only requires a single table
|
||||
BlendTab_Modulative(blendtables[blendtab_modulate]);
|
||||
}
|
||||
|
||||
#define ClipBlendLevel(style, trans) max(min((trans), BlendTab_Count[BlendTab_FromStyle[style]]-1), 0)
|
||||
#define ClipTransLevel(trans) max(min((trans), NUMTRANSMAPS-2), 0)
|
||||
|
||||
UINT8 *R_GetTranslucencyTable(INT32 alphalevel)
|
||||
{
|
||||
return transtables + (ClipTransLevel(alphalevel-1) << FF_TRANSSHIFT);
|
||||
}
|
||||
|
||||
UINT8 *R_GetBlendTable(int style, INT32 alphalevel)
|
||||
{
|
||||
size_t offs;
|
||||
|
||||
if (style == AST_COPY || style == AST_OVERLAY)
|
||||
return NULL;
|
||||
|
||||
offs = (ClipBlendLevel(style, alphalevel) << FF_TRANSSHIFT);
|
||||
|
||||
// Lactozilla: Returns the equivalent to AST_TRANSLUCENT
|
||||
// if no alpha style matches any of the blend tables.
|
||||
switch (style)
|
||||
{
|
||||
case AST_ADD:
|
||||
return blendtables[blendtab_add] + offs;
|
||||
case AST_SUBTRACT:
|
||||
return blendtables[blendtab_subtract] + offs;
|
||||
case AST_REVERSESUBTRACT:
|
||||
return blendtables[blendtab_reversesubtract] + offs;
|
||||
case AST_MODULATE:
|
||||
return blendtables[blendtab_modulate];
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
// Return a normal translucency table
|
||||
if (--alphalevel >= 0)
|
||||
return transtables + (ClipTransLevel(alphalevel) << FF_TRANSSHIFT);
|
||||
else
|
||||
return NULL;
|
||||
}
|
||||
|
||||
boolean R_BlendLevelVisible(INT32 blendmode, INT32 alphalevel)
|
||||
{
|
||||
if (blendmode == AST_COPY || blendmode == AST_SUBTRACT || blendmode == AST_MODULATE || blendmode == AST_OVERLAY)
|
||||
return true;
|
||||
|
||||
return (alphalevel < BlendTab_Count[BlendTab_FromStyle[blendmode]]);
|
||||
}
|
||||
|
||||
/** \brief Retrieves a translation colormap from the cache.
|
||||
|
||||
+21
-2
@@ -40,7 +40,6 @@ extern UINT8 dc_hires;
|
||||
extern UINT8 *dc_source; // first pixel in a column
|
||||
|
||||
// translucency stuff here
|
||||
extern UINT8 *transtables; // translucency tables, should be (*transtables)[5][256][256]
|
||||
extern UINT8 *dc_transmap;
|
||||
|
||||
// translation stuff here
|
||||
@@ -117,7 +116,6 @@ extern lumpnum_t viewborderlump[8];
|
||||
#define TC_BLINK -6 // For item blinking
|
||||
|
||||
// Initialize color translation tables, for player rendering etc.
|
||||
void R_InitTranslationTables(void);
|
||||
UINT8* R_GetTranslationColormap(INT32 skinnum, skincolors_t color, UINT8 flags);
|
||||
UINT8* R_GetLocalTranslationColormap(skin_t *skin, skin_t *localskin, skincolors_t color, UINT8 flags, boolean local);
|
||||
patch_t* R_GetSkinFaceRank(player_t* ply);
|
||||
@@ -126,6 +124,27 @@ patch_t* R_GetSkinFaceMini(player_t* ply);
|
||||
void R_FlushTranslationColormapCache(void);
|
||||
UINT8 R_GetColorByName(const char *name);
|
||||
|
||||
extern UINT8 *transtables; // translucency tables, should be (*transtables)[5][256][256]
|
||||
|
||||
enum
|
||||
{
|
||||
blendtab_add,
|
||||
blendtab_subtract,
|
||||
blendtab_reversesubtract,
|
||||
blendtab_modulate,
|
||||
NUMBLENDMAPS
|
||||
};
|
||||
|
||||
extern UINT8 *blendtables[NUMBLENDMAPS];
|
||||
|
||||
void R_InitTranslucencyTables(void);
|
||||
void R_GenerateBlendTables(void);
|
||||
|
||||
UINT8 *R_GetTranslucencyTable(INT32 alphalevel);
|
||||
UINT8 *R_GetBlendTable(int style, INT32 alphalevel);
|
||||
|
||||
boolean R_BlendLevelVisible(INT32 blendmode, INT32 alphalevel);
|
||||
|
||||
// Custom player skin translation
|
||||
void R_InitViewBuffer(INT32 width, INT32 height);
|
||||
void R_InitViewBorder(void);
|
||||
|
||||
+41
-129
@@ -60,25 +60,13 @@ void R_DrawColumn_8(void)
|
||||
register const UINT8 *source = dc_source;
|
||||
register const lighttable_t *colormap = dc_colormap;
|
||||
|
||||
register INT32 heightmask = dc_texheight-1;
|
||||
register INT32 heightmask = dc_sourcelength-1;
|
||||
npow2min = -1;
|
||||
npow2max = dc_sourcelength-1;
|
||||
|
||||
if (dc_texheight & heightmask) // not a power of 2 -- killough
|
||||
if (dc_sourcelength & heightmask) // not a power of 2 -- killough
|
||||
{
|
||||
heightmask++;
|
||||
heightmask <<= FRACBITS;
|
||||
|
||||
if (dc_sourcelength <= 0)
|
||||
{
|
||||
// Note: we need to unconditionally clamp in npow2 draw loop to avoid a CPU branch
|
||||
// This is to just render it effectively the identity function.
|
||||
npow2min = INT32_MIN;
|
||||
npow2max = INT32_MAX;
|
||||
}
|
||||
else
|
||||
{
|
||||
npow2min = -1;
|
||||
npow2max = dc_sourcelength;
|
||||
}
|
||||
heightmask = dc_texheight << FRACBITS;
|
||||
|
||||
if (frac < 0)
|
||||
{
|
||||
@@ -192,26 +180,14 @@ void R_Draw2sMultiPatchColumn_8(void)
|
||||
// This is as fast as it gets.
|
||||
register const UINT8 *source = dc_source;
|
||||
register const lighttable_t *colormap = dc_colormap;
|
||||
register INT32 heightmask = dc_texheight-1;
|
||||
register INT32 heightmask = dc_sourcelength-1;
|
||||
register UINT8 val;
|
||||
npow2min = -1;
|
||||
npow2max = dc_sourcelength-1;
|
||||
|
||||
if (dc_texheight & heightmask) // not a power of 2 -- killough
|
||||
if (dc_sourcelength & heightmask) // not a power of 2 -- killough
|
||||
{
|
||||
heightmask++;
|
||||
heightmask <<= FRACBITS;
|
||||
|
||||
if (dc_sourcelength <= 0)
|
||||
{
|
||||
// Note: we need to unconditionally clamp in npow2 draw loop to avoid a CPU branch
|
||||
// This is to just render it effectively the identity function.
|
||||
npow2min = INT32_MIN;
|
||||
npow2max = INT32_MAX;
|
||||
}
|
||||
else
|
||||
{
|
||||
npow2min = -1;
|
||||
npow2max = dc_sourcelength;
|
||||
}
|
||||
heightmask = dc_texheight << FRACBITS;
|
||||
|
||||
if (frac < 0)
|
||||
{
|
||||
@@ -343,26 +319,14 @@ void R_Draw2sMultiPatchTranslucentColumn_8(void)
|
||||
register const UINT8 *source = dc_source;
|
||||
register const UINT8 *transmap = dc_transmap;
|
||||
register const lighttable_t *colormap = dc_colormap;
|
||||
register INT32 heightmask = dc_texheight-1;
|
||||
register INT32 heightmask = dc_sourcelength-1;
|
||||
register UINT8 val;
|
||||
npow2min = -1;
|
||||
npow2max = dc_sourcelength-1;
|
||||
|
||||
if (dc_texheight & heightmask) // not a power of 2 -- killough
|
||||
if (dc_sourcelength & heightmask) // not a power of 2 -- killough
|
||||
{
|
||||
heightmask++;
|
||||
heightmask <<= FRACBITS;
|
||||
|
||||
if (dc_sourcelength <= 0)
|
||||
{
|
||||
// Note: we need to unconditionally clamp in npow2 draw loop to avoid a CPU branch
|
||||
// This is to just render it effectively the identity function.
|
||||
npow2min = INT32_MIN;
|
||||
npow2max = INT32_MAX;
|
||||
}
|
||||
else
|
||||
{
|
||||
npow2min = -1;
|
||||
npow2max = dc_sourcelength;
|
||||
}
|
||||
heightmask = dc_texheight << FRACBITS;
|
||||
|
||||
if (frac < 0)
|
||||
{
|
||||
@@ -535,25 +499,13 @@ void R_DrawTranslucentColumn_8(void)
|
||||
register const UINT8 *source = dc_source;
|
||||
register const UINT8 *transmap = dc_transmap;
|
||||
register const lighttable_t *colormap = dc_colormap;
|
||||
register INT32 heightmask = dc_texheight - 1;
|
||||
register INT32 heightmask = dc_sourcelength-1;
|
||||
npow2min = -1;
|
||||
npow2max = dc_sourcelength-1;
|
||||
|
||||
if (dc_texheight & heightmask)
|
||||
if (dc_sourcelength & heightmask)
|
||||
{
|
||||
heightmask++;
|
||||
heightmask <<= FRACBITS;
|
||||
|
||||
if (dc_sourcelength <= 0)
|
||||
{
|
||||
// Note: we need to unconditionally clamp in npow2 draw loop to avoid a CPU branch
|
||||
// This is to just render it effectively the identity function.
|
||||
npow2min = INT32_MIN;
|
||||
npow2max = INT32_MAX;
|
||||
}
|
||||
else
|
||||
{
|
||||
npow2min = -1;
|
||||
npow2max = dc_sourcelength;
|
||||
}
|
||||
heightmask = dc_texheight << FRACBITS;
|
||||
|
||||
if (frac < 0)
|
||||
{
|
||||
@@ -653,25 +605,13 @@ void R_DrawTranslatedTranslucentColumn_8(void)
|
||||
|
||||
// Inner loop that does the actual texture mapping, e.g. a DDA-like scaling.
|
||||
// This is as fast as it gets.
|
||||
register INT32 heightmask = dc_texheight - 1;
|
||||
register INT32 heightmask = dc_sourcelength-1;
|
||||
npow2min = -1;
|
||||
npow2max = dc_sourcelength-1;
|
||||
|
||||
if (dc_texheight & heightmask)
|
||||
if (dc_sourcelength & heightmask)
|
||||
{
|
||||
heightmask++;
|
||||
heightmask <<= FRACBITS;
|
||||
|
||||
if (dc_sourcelength <= 0)
|
||||
{
|
||||
// Note: we need to unconditionally clamp in npow2 draw loop to avoid a CPU branch
|
||||
// This is to just render it effectively the identity function.
|
||||
npow2min = INT32_MIN;
|
||||
npow2max = INT32_MAX;
|
||||
}
|
||||
else
|
||||
{
|
||||
npow2min = -1;
|
||||
npow2max = dc_sourcelength;
|
||||
}
|
||||
heightmask = dc_texheight << FRACBITS;
|
||||
|
||||
if (frac < 0)
|
||||
{
|
||||
@@ -804,17 +744,14 @@ void R_DrawSpan_8 (void)
|
||||
fixed_t xstep, ystep;
|
||||
register UINT32 bit;
|
||||
|
||||
UINT8 *source;
|
||||
UINT8 *colormap;
|
||||
register UINT8 *dest;
|
||||
const UINT8 *source = ds_source;
|
||||
const UINT8 *colormap = ds_colormap;
|
||||
register UINT8 *dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
const UINT8 *deststop = screens[0] + vid.rowbytes * vid.height;
|
||||
|
||||
register size_t count = (ds_x2 - ds_x1 + 1);
|
||||
size_t i;
|
||||
|
||||
xposition = ds_xfrac; yposition = ds_yfrac;
|
||||
xstep = ds_xstep; ystep = ds_ystep;
|
||||
|
||||
// SoM: we only need 6 bits for the integer part (0 thru 63) so the rest
|
||||
// can be used for the fraction part. This allows calculation of the memory address in the
|
||||
// texture with two shifts, an OR and one AND. (see below)
|
||||
@@ -822,12 +759,8 @@ void R_DrawSpan_8 (void)
|
||||
// bit per power of two (obviously)
|
||||
// Ok, because I was able to eliminate the variable spot below, this function is now FASTER
|
||||
// than the original span renderer. Whodathunkit?
|
||||
xposition <<= nflatshiftup; yposition <<= nflatshiftup;
|
||||
xstep <<= nflatshiftup; ystep <<= nflatshiftup;
|
||||
|
||||
source = ds_source;
|
||||
colormap = ds_colormap;
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
xposition = ds_xfrac << nflatshiftup; yposition = ds_yfrac << nflatshiftup;
|
||||
xstep = ds_xstep << nflatshiftup; ystep = ds_ystep << nflatshiftup;
|
||||
|
||||
if (dest+8 > deststop)
|
||||
{
|
||||
@@ -868,14 +801,13 @@ void R_CalcTiltedLighting(fixed_t start, fixed_t end)
|
||||
{
|
||||
// ZDoom uses a different lighting setup to us, and I couldn't figure out how to adapt their version
|
||||
// of this function. Here's my own.
|
||||
INT32 left = ds_x1, right = ds_x2;
|
||||
fixed_t step = (end-start)/(ds_x2-ds_x1+1);
|
||||
INT32 i;
|
||||
fixed_t step = (end-start)/(ds_x2-ds_x1+1);
|
||||
|
||||
// I wanna do some optimizing by checking for out-of-range segments on either side to fill in all at once,
|
||||
// but I'm too bad at coding to not crash the game trying to do that. I guess this is fast enough for now...
|
||||
|
||||
for (i = left; i <= right; i++)
|
||||
for (i = ds_x1; i <= ds_x2; i++)
|
||||
{
|
||||
tiltlighting[i] = (start += step) >> FRACBITS;
|
||||
|
||||
@@ -897,7 +829,6 @@ void R_CalcTiltedLighting(fixed_t start, fixed_t end)
|
||||
*/
|
||||
void R_DrawTiltedSpan_8(void)
|
||||
{
|
||||
// x1, x2 = ds_x1, ds_x2
|
||||
int width = ds_x2 - ds_x1;
|
||||
double iz, uz, vz;
|
||||
UINT32 u, v;
|
||||
@@ -933,7 +864,6 @@ void R_DrawTiltedSpan_8(void)
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
|
||||
source = ds_source;
|
||||
//colormap = ds_colormap;
|
||||
|
||||
#if 0 // The "perfect" reference version of this routine. Pretty slow.
|
||||
// Use it only to see how things are supposed to look.
|
||||
@@ -961,7 +891,6 @@ void R_DrawTiltedSpan_8(void)
|
||||
izstep = ds_szp->x * SPANSIZE;
|
||||
uzstep = ds_sup->x * SPANSIZE;
|
||||
vzstep = ds_svp->x * SPANSIZE;
|
||||
//x1 = 0;
|
||||
width++;
|
||||
|
||||
while (width >= SPANSIZE)
|
||||
@@ -1038,7 +967,6 @@ void R_DrawTiltedSpan_8(void)
|
||||
*/
|
||||
void R_DrawTiltedTranslucentSpan_8(void)
|
||||
{
|
||||
// x1, x2 = ds_x1, ds_x2
|
||||
int width = ds_x2 - ds_x1;
|
||||
double iz, uz, vz;
|
||||
UINT32 u, v;
|
||||
@@ -1074,7 +1002,6 @@ void R_DrawTiltedTranslucentSpan_8(void)
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
|
||||
source = ds_source;
|
||||
//colormap = ds_colormap;
|
||||
|
||||
#if 0 // The "perfect" reference version of this routine. Pretty slow.
|
||||
// Use it only to see how things are supposed to look.
|
||||
@@ -1102,7 +1029,6 @@ void R_DrawTiltedTranslucentSpan_8(void)
|
||||
izstep = ds_szp->x * SPANSIZE;
|
||||
uzstep = ds_sup->x * SPANSIZE;
|
||||
vzstep = ds_svp->x * SPANSIZE;
|
||||
//x1 = 0;
|
||||
width++;
|
||||
|
||||
while (width >= SPANSIZE)
|
||||
@@ -1180,7 +1106,6 @@ void R_DrawTiltedTranslucentSpan_8(void)
|
||||
*/
|
||||
void R_DrawTiltedTranslucentWaterSpan_8(void)
|
||||
{
|
||||
// x1, x2 = ds_x1, ds_x2
|
||||
int width = ds_x2 - ds_x1;
|
||||
double iz, uz, vz;
|
||||
UINT32 u, v;
|
||||
@@ -1218,7 +1143,6 @@ void R_DrawTiltedTranslucentWaterSpan_8(void)
|
||||
dsrc = screens[1] + (ds_y+ds_bgofs)*vid.width + ds_x1;
|
||||
|
||||
source = ds_source;
|
||||
//colormap = ds_colormap;
|
||||
|
||||
#if 0 // The "perfect" reference version of this routine. Pretty slow.
|
||||
// Use it only to see how things are supposed to look.
|
||||
@@ -1246,7 +1170,6 @@ void R_DrawTiltedTranslucentWaterSpan_8(void)
|
||||
izstep = ds_szp->x * SPANSIZE;
|
||||
uzstep = ds_sup->x * SPANSIZE;
|
||||
vzstep = ds_svp->x * SPANSIZE;
|
||||
//x1 = 0;
|
||||
width++;
|
||||
|
||||
while (width >= SPANSIZE)
|
||||
@@ -1618,17 +1541,14 @@ void R_DrawTranslucentSpan_8 (void)
|
||||
fixed_t xstep, ystep;
|
||||
register UINT32 bit;
|
||||
|
||||
UINT8 *source;
|
||||
UINT8 *colormap;
|
||||
register UINT8 *dest;
|
||||
const UINT8 *source = ds_source;
|
||||
const UINT8 *colormap = ds_colormap;
|
||||
register UINT8 *dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
const UINT8 *deststop = screens[0] + vid.rowbytes * vid.height;
|
||||
|
||||
register size_t count = (ds_x2 - ds_x1 + 1);
|
||||
size_t i;
|
||||
|
||||
xposition = ds_xfrac; yposition = ds_yfrac;
|
||||
xstep = ds_xstep; ystep = ds_ystep;
|
||||
|
||||
// SoM: we only need 6 bits for the integer part (0 thru 63) so the rest
|
||||
// can be used for the fraction part. This allows calculation of the memory address in the
|
||||
// texture with two shifts, an OR and one AND. (see below)
|
||||
@@ -1636,12 +1556,8 @@ void R_DrawTranslucentSpan_8 (void)
|
||||
// bit per power of two (obviously)
|
||||
// Ok, because I was able to eliminate the variable spot below, this function is now FASTER
|
||||
// than the original span renderer. Whodathunkit?
|
||||
xposition <<= nflatshiftup; yposition <<= nflatshiftup;
|
||||
xstep <<= nflatshiftup; ystep <<= nflatshiftup;
|
||||
|
||||
source = ds_source;
|
||||
colormap = ds_colormap;
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
xposition = ds_xfrac << nflatshiftup; yposition = ds_yfrac << nflatshiftup;
|
||||
xstep = ds_xstep << nflatshiftup; ystep = ds_ystep << nflatshiftup;
|
||||
|
||||
while (count >= 8)
|
||||
{
|
||||
@@ -1677,10 +1593,10 @@ void R_DrawTranslucentWaterSpan_8(void)
|
||||
UINT32 xstep, ystep;
|
||||
register UINT32 bit;
|
||||
|
||||
UINT8 *source;
|
||||
UINT8 *colormap;
|
||||
register UINT8 *dest;
|
||||
UINT8 *dsrc;
|
||||
const UINT8 *source = ds_source;
|
||||
const UINT8 *colormap = ds_colormap;
|
||||
register UINT8 *dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
register UINT8 *dsrc;
|
||||
|
||||
register size_t count;
|
||||
size_t i;
|
||||
@@ -1695,9 +1611,6 @@ void R_DrawTranslucentWaterSpan_8(void)
|
||||
xposition = ds_xfrac << nflatshiftup; yposition = (ds_yfrac + ds_waterofs) << nflatshiftup;
|
||||
xstep = ds_xstep << nflatshiftup; ystep = ds_ystep << nflatshiftup;
|
||||
|
||||
source = ds_source;
|
||||
colormap = ds_colormap;
|
||||
dest = ylookup[ds_y] + columnofs[ds_x1];
|
||||
dsrc = screens[1] + (ds_y+ds_bgofs)*vid.width + ds_x1;
|
||||
count = ds_x2 - ds_x1 + 1;
|
||||
|
||||
@@ -1739,7 +1652,6 @@ void R_DrawFogSpan_8(void)
|
||||
register 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;
|
||||
|
||||
@@ -37,6 +37,10 @@ enum viewcontext_e
|
||||
VIEWCONTEXT_SKY4
|
||||
};
|
||||
|
||||
extern enum viewcontext_e viewcontext;
|
||||
|
||||
#define R_GetViewNumber() ((viewcontext - VIEWCONTEXT_PLAYER1) & 3)
|
||||
|
||||
typedef struct {
|
||||
fixed_t x;
|
||||
fixed_t y;
|
||||
|
||||
+88
-54
@@ -143,12 +143,14 @@ static CV_PossibleValue_t maxinterpdist_cons_t[] = {
|
||||
{3072, "3072"}, {4096, "4096"}, {6144, "6144"},
|
||||
{8192, "8192"}, {0, "Infinite"}, {0, NULL}};
|
||||
|
||||
static CV_PossibleValue_t fov_cons_t[] = {{5*FRACUNIT, "MIN"}, {178*FRACUNIT, "MAX"}, {0, NULL}};
|
||||
static CV_PossibleValue_t fov_cons_t[] = {{MINFOV*FRACUNIT, "MIN"}, {MAXFOV*FRACUNIT, "MAX"}, {0, NULL}};
|
||||
|
||||
static CV_PossibleValue_t translucenthud_cons_t[] = {{0, "MIN"}, {10, "MAX"}, {0, NULL}};
|
||||
static CV_PossibleValue_t maxportals_cons_t[] = {{0, "MIN"}, {12, "MAX"}, {0, NULL}}; // lmao rendering 32 portals, you're a card
|
||||
static CV_PossibleValue_t homremoval_cons_t[] = {{0, "No"}, {1, "Yes"}, {2, "Flash"}, {0, NULL}};
|
||||
|
||||
static void R_SetFov(fixed_t playerfov);
|
||||
|
||||
static void Fov_OnChange(void);
|
||||
static void FlipCam_OnChange(void);
|
||||
static void FlipCam2_OnChange(void);
|
||||
@@ -202,6 +204,7 @@ consvar_t cv_ripplewater = {"waterripples", "On", CV_SAVE, CV_OnOff, NULL, 0, NU
|
||||
|
||||
// cap fov, fov too high tears software apart.
|
||||
consvar_t cv_fov = {"fov", "90", CV_FLOAT|CV_CALL|CV_SAVE, fov_cons_t, Fov_OnChange, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_fovchange = {"fovchange", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
// Okay, whoever said homremoval causes a performance hit should be shot.
|
||||
consvar_t cv_homremoval = {"homremoval", "Yes", CV_SAVE, homremoval_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
@@ -296,12 +299,14 @@ static void Precipstuff_OnChange(void)
|
||||
thinker_t *next;
|
||||
precipmobj_t *precipmobj;
|
||||
|
||||
for (think = thinkercap.next; think != &thinkercap; think = next)
|
||||
for (think = precipcap.next; think != &precipcap; think = next)
|
||||
{
|
||||
next = think->next;
|
||||
|
||||
#ifdef PARANOIA
|
||||
if (think->function.acp1 != (actionf_p1)P_NullPrecipThinker)
|
||||
continue; // not a precipmobj thinker
|
||||
#endif
|
||||
|
||||
precipmobj = (precipmobj_t *)think;
|
||||
P_FreePrecipMobj(precipmobj);
|
||||
@@ -379,7 +384,7 @@ angle_t R_PlayerSliptideAngle(player_t *player)
|
||||
spriteframe_t *sprframe;
|
||||
angle_t ang = 0;
|
||||
|
||||
if (!cv_sloperoll.value || !cv_sliptideroll.value || !player || P_MobjWasRemoved(player->mo))
|
||||
if (!cv_sliptideroll.value || !player || P_MobjWasRemoved(player->mo))
|
||||
return 0;
|
||||
|
||||
mo = player->mo;
|
||||
@@ -846,13 +851,10 @@ void R_ApplyViewMorph(void)
|
||||
vid.width*vid.bpp, vid.height, vid.width*vid.bpp, vid.width);
|
||||
}
|
||||
|
||||
static inline int intsign(int n) {
|
||||
return n < 0 ? -1 : n > 0 ? 1 : 0;
|
||||
}
|
||||
|
||||
angle_t R_ViewRollAngle(const player_t *player)
|
||||
{
|
||||
angle_t roll = 0;
|
||||
const UINT8 viewnum = R_GetViewNumber();
|
||||
|
||||
if (gamestate != GS_LEVEL)
|
||||
{
|
||||
@@ -871,7 +873,7 @@ angle_t R_ViewRollAngle(const player_t *player)
|
||||
|
||||
if (cv_tilting.value)
|
||||
{
|
||||
if (!player->spectator && !demo.freecam)
|
||||
if (!player->spectator && !camera[viewnum].freecam)
|
||||
roll += player->tilt;
|
||||
|
||||
if (cv_actionmovie.value)
|
||||
@@ -904,12 +906,10 @@ void R_SetViewSize(void)
|
||||
//
|
||||
void R_ExecuteSetViewSize(void)
|
||||
{
|
||||
fixed_t dy;
|
||||
INT32 i;
|
||||
INT32 j;
|
||||
INT32 level;
|
||||
INT32 startmapl;
|
||||
angle_t fov;
|
||||
|
||||
setsizeneeded = false;
|
||||
|
||||
@@ -938,17 +938,10 @@ void R_ExecuteSetViewSize(void)
|
||||
centerxfrac = centerx<<FRACBITS;
|
||||
centeryfrac = centery<<FRACBITS;
|
||||
|
||||
fov = FixedAngle(cv_fov.value/2) + ANGLE_90;
|
||||
fovtan = FixedMul(FINETANGENT(fov >> ANGLETOFINESHIFT), viewmorph.zoomneeded);
|
||||
if (splitscreen == 1) // Splitscreen FOV should be adjusted to maintain expected vertical view
|
||||
fovtan = 17*fovtan/10;
|
||||
|
||||
projection = projectiony = FixedDiv(centerxfrac, fovtan);
|
||||
R_SetFov(cv_fov.value);
|
||||
|
||||
R_InitViewBuffer(scaledviewwidth, viewheight);
|
||||
|
||||
R_InitTextureMapping();
|
||||
|
||||
// why did we calc all the software crap?
|
||||
#ifdef HWRENDER
|
||||
if (rendermode == render_opengl)
|
||||
@@ -963,19 +956,6 @@ void R_ExecuteSetViewSize(void)
|
||||
for (i = 0; i < viewwidth; i++)
|
||||
screenheightarray[i] = (INT16)viewheight;
|
||||
|
||||
// setup sky scaling
|
||||
R_SetSkyScale();
|
||||
|
||||
// planes
|
||||
// this is only used for planes rendering in software mode
|
||||
j = viewheight*16;
|
||||
for (i = 0; i < j; i++)
|
||||
{
|
||||
dy = (i - viewheight*8)<<FRACBITS;
|
||||
dy = FixedMul(abs(dy), fovtan);
|
||||
yslopetab[i] = FixedDiv(centerx*FRACUNIT, dy);
|
||||
}
|
||||
|
||||
if (ds_su)
|
||||
Z_Free(ds_su);
|
||||
if (ds_sv)
|
||||
@@ -1009,6 +989,37 @@ void R_ExecuteSetViewSize(void)
|
||||
am_recalc = true;
|
||||
}
|
||||
|
||||
fixed_t R_GetPlayerFov(player_t *player)
|
||||
{
|
||||
fixed_t fov = cv_fov.value + player->fovadd;
|
||||
return max(MINFOV*FRACUNIT, min(fov, MAXFOV*FRACUNIT));
|
||||
}
|
||||
|
||||
static void R_SetFov(fixed_t playerfov)
|
||||
{
|
||||
angle_t fov = FixedAngle(playerfov/2) + ANGLE_90;
|
||||
fovtan = FixedMul(FINETANGENT(fov >> ANGLETOFINESHIFT), viewmorph.zoomneeded);
|
||||
if (splitscreen == 1) // Splitscreen FOV should be adjusted to maintain expected vertical view
|
||||
fovtan = 17*fovtan/10;
|
||||
|
||||
// this is only used for planes rendering in software mode
|
||||
INT32 j = viewheight*16;
|
||||
for (INT32 i = 0; i < j; i++)
|
||||
{
|
||||
fixed_t dy = (i - viewheight*8)<<FRACBITS;
|
||||
dy = FixedMul(abs(dy), fovtan);
|
||||
yslopetab[i] = FixedDiv(centerx*FRACUNIT, dy);
|
||||
}
|
||||
|
||||
projection = projectiony = FixedDiv(centerxfrac, fovtan);
|
||||
|
||||
R_InitTextureMapping();
|
||||
|
||||
// setup sky scaling
|
||||
R_SetSkyScale();
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// R_Init
|
||||
//
|
||||
@@ -1030,8 +1041,8 @@ void R_Init(void)
|
||||
//I_OutputMsg("\nR_InitLightTables");
|
||||
R_InitLightTables();
|
||||
|
||||
//I_OutputMsg("\nR_InitTranslationTables\n");
|
||||
R_InitTranslationTables();
|
||||
//I_OutputMsg("\nR_InitTranslucencyTables\n");
|
||||
R_InitTranslucencyTables();
|
||||
|
||||
R_InitDrawNodes();
|
||||
|
||||
@@ -1072,7 +1083,7 @@ subsector_t *R_IsPointInSubsector(fixed_t x, fixed_t y)
|
||||
|
||||
mobj_t *viewmobj;
|
||||
|
||||
static void R_SetupCommonFrame(player_t * player, subsector_t * subsector)
|
||||
static void R_SetupCommonFrame(player_t * player, sector_t * sector)
|
||||
{
|
||||
newview->player = player;
|
||||
|
||||
@@ -1082,12 +1093,12 @@ static void R_SetupCommonFrame(player_t * player, subsector_t * subsector)
|
||||
|
||||
newview->roll = R_ViewRollAngle(player);
|
||||
|
||||
if (subsector && subsector->sector)
|
||||
newview->sector = subsector->sector;
|
||||
if (sector != NULL)
|
||||
newview->sector = sector;
|
||||
else
|
||||
newview->sector = R_PointInSubsector(newview->x, newview->y)->sector;
|
||||
|
||||
R_InterpolateView(R_UsingFrameInterpolation() ? (demo.playback && demo.freecam) ? rendertimefrac_unpaused : rendertimefrac : FRACUNIT, false);
|
||||
R_InterpolateView(R_UsingFrameInterpolation() ? rendertimefrac_unpaused : FRACUNIT, false);
|
||||
}
|
||||
|
||||
static void R_SetupAimingFrame(player_t *player, camera_t *thiscam)
|
||||
@@ -1213,10 +1224,10 @@ void R_SkyboxFrame(int s)
|
||||
}
|
||||
#undef SETUPSKYVIEW
|
||||
|
||||
if (!P_MobjWasRemoved(viewmobj))
|
||||
if (!P_MobjWasRemoved(viewmobj) && viewmobj->subsector && viewmobj->subsector->sector)
|
||||
subsector = viewmobj->subsector;
|
||||
|
||||
R_SetupCommonFrame(player, subsector);
|
||||
R_SetupCommonFrame(player, subsector->sector);
|
||||
}
|
||||
|
||||
void R_SetupFrame(int s, boolean skybox)
|
||||
@@ -1224,7 +1235,7 @@ void R_SetupFrame(int s, boolean skybox)
|
||||
player_t *player = &players[displayplayers[s]];
|
||||
camera_t *thiscam = &camera[s];
|
||||
boolean chasecam = (cv_chasecam[s].value);
|
||||
subsector_t * subsector = NULL;
|
||||
sector_t * sector = NULL;
|
||||
|
||||
R_SetViewContext(VIEWCONTEXT_PLAYER1 + s);
|
||||
if (thiscam->reset)
|
||||
@@ -1233,9 +1244,14 @@ void R_SetupFrame(int s, boolean skybox)
|
||||
thiscam->reset = false;
|
||||
}
|
||||
|
||||
if (player->spectator) // no spectator chasecam
|
||||
chasecam = false; // force chasecam off
|
||||
else if (player->playerstate == PST_DEAD || player->exiting)
|
||||
if (player->spectator)
|
||||
{
|
||||
// Free flying spectator uses demo freecam. This
|
||||
// requires chasecam to be enabled.
|
||||
chasecam = true;
|
||||
}
|
||||
|
||||
if (player->playerstate == PST_DEAD || player->exiting)
|
||||
chasecam = true; // force chasecam on
|
||||
|
||||
if (chasecam && (thiscam && !thiscam->chase))
|
||||
@@ -1259,12 +1275,12 @@ void R_SetupFrame(int s, boolean skybox)
|
||||
newview->y = viewmobj->y;
|
||||
newview->z = viewmobj->z + 20*FRACUNIT;
|
||||
|
||||
if (!P_MobjWasRemoved(viewmobj))
|
||||
subsector = viewmobj->subsector;
|
||||
if (!P_MobjWasRemoved(viewmobj) && viewmobj->subsector && viewmobj->subsector->sector)
|
||||
sector = viewmobj->subsector->sector;
|
||||
|
||||
R_SetupCommonFrame(player, subsector);
|
||||
R_SetupCommonFrame(player, sector);
|
||||
}
|
||||
else if (!player->spectator && (thiscam && chasecam)) // use outside cam view
|
||||
else if (thiscam && chasecam) // use outside cam view
|
||||
{
|
||||
viewmobj = NULL;
|
||||
|
||||
@@ -1272,10 +1288,10 @@ void R_SetupFrame(int s, boolean skybox)
|
||||
newview->y = thiscam->y;
|
||||
newview->z = thiscam->z + (thiscam->height>>1);
|
||||
|
||||
if (thiscam != NULL)
|
||||
subsector = thiscam->subsector;
|
||||
if (thiscam != NULL && thiscam->subsector && thiscam->subsector->sector)
|
||||
sector = thiscam->subsector->sector;
|
||||
|
||||
R_SetupCommonFrame(player, subsector);
|
||||
R_SetupCommonFrame(player, sector);
|
||||
}
|
||||
else // use the player's eyes view
|
||||
{
|
||||
@@ -1286,10 +1302,10 @@ void R_SetupFrame(int s, boolean skybox)
|
||||
newview->y = viewmobj->y;
|
||||
newview->z = player->viewz;
|
||||
|
||||
if (!P_MobjWasRemoved(viewmobj))
|
||||
subsector = viewmobj->subsector;
|
||||
if (!P_MobjWasRemoved(viewmobj) && viewmobj->subsector && viewmobj->subsector->sector)
|
||||
sector = viewmobj->subsector->sector;
|
||||
|
||||
R_SetupCommonFrame(player, subsector);
|
||||
R_SetupCommonFrame(player, sector);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1330,6 +1346,8 @@ static void R_PortalFrame(portal_t *portal)
|
||||
// I mean, there is a win16lock() or something that lasts all the rendering,
|
||||
// so maybe we should release screen lock before each netupdate below..?
|
||||
|
||||
static fixed_t viewfov[MAXSPLITSCREENPLAYERS];
|
||||
|
||||
void R_RenderPlayerView(player_t *player)
|
||||
{
|
||||
const boolean skybox = (skyboxmo[0] && cv_skybox.value);
|
||||
@@ -1368,6 +1386,18 @@ void R_RenderPlayerView(player_t *player)
|
||||
break;
|
||||
}
|
||||
|
||||
fixed_t fov = R_GetPlayerFov(player);
|
||||
|
||||
for (UINT8 j = 0; j <= splitscreen; j++)
|
||||
{
|
||||
if (player == &players[displayplayers[i]]
|
||||
&& viewfov[i] != fov)
|
||||
{
|
||||
viewfov[i] = fov;
|
||||
R_SetFov(fov);
|
||||
}
|
||||
}
|
||||
|
||||
Portal_InitList();
|
||||
|
||||
PS_START_TIMING(ps_skyboxtime);
|
||||
@@ -1521,6 +1551,8 @@ void R_RegisterEngineStuff(void)
|
||||
CV_RegisterVar(&cv_drawdist_precip);
|
||||
CV_RegisterVar(&cv_lessprecip);
|
||||
CV_RegisterVar(&cv_mobjscaleprecip);
|
||||
|
||||
CV_RegisterVar(&cv_fovchange);
|
||||
CV_RegisterVar(&cv_fov);
|
||||
|
||||
for (i = 0; i < MAXSPLITSCREENPLAYERS; i++)
|
||||
@@ -1540,7 +1572,8 @@ void R_RegisterEngineStuff(void)
|
||||
CV_RegisterVar(&cv_cam_height[i]);
|
||||
CV_RegisterVar(&cv_cam_speed[i]);
|
||||
CV_RegisterVar(&cv_cam_rotate[i]);
|
||||
CV_RegisterVar(&cv_cam_rotspeed[i]);
|
||||
CV_RegisterVar(&cv_cam_timeover[i]);
|
||||
CV_RegisterVar(&cv_freecam_speed[i]);
|
||||
}
|
||||
|
||||
CV_RegisterVar(&cv_tilting);
|
||||
@@ -1556,6 +1589,7 @@ void R_RegisterEngineStuff(void)
|
||||
CV_RegisterVar(&cv_sliptideroll);
|
||||
CV_RegisterVar(&cv_sloperolldist);
|
||||
CV_RegisterVar(&cv_sparkroll);
|
||||
CV_RegisterVar(&cv_spinoutroll);
|
||||
|
||||
CV_RegisterVar(&cv_showhud);
|
||||
CV_RegisterVar(&cv_translucenthud);
|
||||
|
||||
+5
-1
@@ -29,6 +29,9 @@ extern fixed_t centerxfrac, centeryfrac;
|
||||
extern fixed_t projection, projectiony;
|
||||
extern fixed_t fovtan; // field of view
|
||||
|
||||
#define MINFOV 5
|
||||
#define MAXFOV 179
|
||||
|
||||
extern size_t validcount, linecount, loopcount, framecount;
|
||||
|
||||
// The fraction of a tic being drawn (for interpolation between two tics)
|
||||
@@ -179,7 +182,7 @@ extern consvar_t cv_shadow, cv_shadowoffs;
|
||||
extern consvar_t cv_ffloorclip, cv_spriteclip;
|
||||
extern consvar_t cv_translucency;
|
||||
extern consvar_t cv_drawdist, cv_drawdist_precip, cv_lessprecip, cv_mobjscaleprecip;
|
||||
extern consvar_t cv_fov;
|
||||
extern consvar_t cv_fov, cv_fovchange;
|
||||
extern consvar_t cv_skybox;
|
||||
extern consvar_t cv_tailspickup;
|
||||
extern consvar_t cv_maxinterpdist;
|
||||
@@ -201,6 +204,7 @@ void R_SetViewSize(void);
|
||||
// do it (sometimes explicitly called)
|
||||
void R_ExecuteSetViewSize(void);
|
||||
|
||||
fixed_t R_GetPlayerFov(player_t *player);
|
||||
void R_SkyboxFrame(int s);
|
||||
void R_SetupFrame(int s, boolean skybox);
|
||||
|
||||
|
||||
+14
-24
@@ -662,6 +662,7 @@ static void R_DrawSkyPlane(visplane_t *pl)
|
||||
|
||||
dc_texturemid = skytexturemid;
|
||||
dc_texheight = textureheight[skytexture] >>FRACBITS;
|
||||
dc_sourcelength = dc_texheight;
|
||||
|
||||
for (x = pl->minx; x <= pl->maxx; x++)
|
||||
{
|
||||
@@ -804,7 +805,7 @@ void R_DrawSinglePlane(visplane_t *pl)
|
||||
if (pl->polyobj->translucency >= 10)
|
||||
return; // Don't even draw it
|
||||
else if (pl->polyobj->translucency > 0)
|
||||
ds_transmap = transtables + ((pl->polyobj->translucency-1)<<FF_TRANSSHIFT);
|
||||
ds_transmap = R_GetTranslucencyTable(pl->polyobj->translucency);
|
||||
else // Opaque, but allow transparent flat pixels
|
||||
spanfunc = splatfunc;
|
||||
|
||||
@@ -841,28 +842,17 @@ void R_DrawSinglePlane(visplane_t *pl)
|
||||
spanfunc = R_DrawTranslucentSpan_8;
|
||||
|
||||
// Hacked up support for alpha value in software mode Tails 09-24-2002
|
||||
if (pl->ffloor->alpha < 12)
|
||||
return; // Don't even draw it
|
||||
else if (pl->ffloor->alpha < 38)
|
||||
ds_transmap = transtables + ((tr_trans90-1)<<FF_TRANSSHIFT);
|
||||
else if (pl->ffloor->alpha < 64)
|
||||
ds_transmap = transtables + ((tr_trans80-1)<<FF_TRANSSHIFT);
|
||||
else if (pl->ffloor->alpha < 89)
|
||||
ds_transmap = transtables + ((tr_trans70-1)<<FF_TRANSSHIFT);
|
||||
else if (pl->ffloor->alpha < 115)
|
||||
ds_transmap = transtables + ((tr_trans60-1)<<FF_TRANSSHIFT);
|
||||
else if (pl->ffloor->alpha < 140)
|
||||
ds_transmap = transtables + ((tr_trans50-1)<<FF_TRANSSHIFT);
|
||||
else if (pl->ffloor->alpha < 166)
|
||||
ds_transmap = transtables + ((tr_trans40-1)<<FF_TRANSSHIFT);
|
||||
else if (pl->ffloor->alpha < 192)
|
||||
ds_transmap = transtables + ((tr_trans30-1)<<FF_TRANSSHIFT);
|
||||
else if (pl->ffloor->alpha < 217)
|
||||
ds_transmap = transtables + ((tr_trans20-1)<<FF_TRANSSHIFT);
|
||||
else if (pl->ffloor->alpha < 243)
|
||||
ds_transmap = transtables + ((tr_trans10-1)<<FF_TRANSSHIFT);
|
||||
else // Opaque, but allow transparent flat pixels
|
||||
spanfunc = splatfunc;
|
||||
// ...unhacked by toaster 04-01-2021, re-hacked a little by sphere 19-11-2021
|
||||
// and mercilessly shoved into saturn by chearii 02-02-2025
|
||||
{
|
||||
INT32 trans = (10*((256+12) - pl->ffloor->alpha))/255;
|
||||
if (trans >= 10)
|
||||
return; // Don't even draw it
|
||||
if (pl->ffloor->blend) // additive, (reverse) subtractive, modulative
|
||||
ds_transmap = R_GetBlendTable(pl->ffloor->blend, trans);
|
||||
else if (!(ds_transmap = R_GetTranslucencyTable(trans)) || trans == 0)
|
||||
spanfunc = splatfunc; // Opaque, but allow transparent flat pixels
|
||||
}
|
||||
|
||||
#ifdef SHITPLANESPARENCY
|
||||
if (spanfunc == splatfunc || (pl->extra_colormap && pl->extra_colormap->fog))
|
||||
@@ -1137,7 +1127,7 @@ using the palette colors.
|
||||
if (spanfunc == R_DrawSpan_8)
|
||||
{
|
||||
INT32 i;
|
||||
ds_transmap = transtables + ((tr_trans50-1)<<FF_TRANSSHIFT);
|
||||
ds_transmap = R_GetTranslucencyTable(tr_trans50);
|
||||
spanfunc = R_DrawTranslucentSpan_8;
|
||||
for (i=0; i<4; i++)
|
||||
{
|
||||
|
||||
+69
-60
@@ -190,7 +190,7 @@ static void R_DrawWallSplats(void)
|
||||
colfunc = basecolfunc;
|
||||
else
|
||||
{
|
||||
dc_transmap = transtables + ((tr_trans50 - 1)<<FF_TRANSSHIFT);
|
||||
dc_transmap = R_GetTranslucencyTable(tr_trans50);
|
||||
colfunc = fuzzcolfunc;
|
||||
}
|
||||
|
||||
@@ -277,7 +277,7 @@ static void R_Render2sidedMultiPatchColumn(column_t *column)
|
||||
if (dc_yl <= dc_yh && dc_yh < vid.height && dc_yh > 0)
|
||||
{
|
||||
dc_source = (UINT8 *)column + 3;
|
||||
dc_sourcelength = 0;
|
||||
dc_sourcelength = column2s_length;
|
||||
|
||||
if (colfunc == wallcolfunc)
|
||||
twosmultipatchfunc();
|
||||
@@ -288,6 +288,28 @@ static void R_Render2sidedMultiPatchColumn(column_t *column)
|
||||
}
|
||||
}
|
||||
|
||||
transnum_t R_GetLinedefTransTable(fixed_t alpha)
|
||||
{
|
||||
if (alpha < 9830)
|
||||
return tr_trans90;
|
||||
else if (alpha < 16384)
|
||||
return tr_trans80;
|
||||
else if (alpha < 22937)
|
||||
return tr_trans70;
|
||||
else if (alpha < 29491)
|
||||
return tr_trans60;
|
||||
else if (alpha < 36044)
|
||||
return tr_trans50;
|
||||
else if (alpha < 42598)
|
||||
return tr_trans40;
|
||||
else if (alpha < 49152)
|
||||
return tr_trans30;
|
||||
else if (alpha < 55705)
|
||||
return tr_trans20;
|
||||
else
|
||||
return tr_trans10;
|
||||
}
|
||||
|
||||
void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2)
|
||||
{
|
||||
size_t pindex;
|
||||
@@ -315,28 +337,32 @@ void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2)
|
||||
|
||||
// hack translucent linedef types (900-909 for transtables 1-9)
|
||||
ldef = curline->linedef;
|
||||
switch (ldef->special)
|
||||
|
||||
if (!ldef->alpha)
|
||||
return;
|
||||
|
||||
if (ldef->blendmode)
|
||||
{
|
||||
case 900:
|
||||
case 901:
|
||||
case 902:
|
||||
case 903:
|
||||
case 904:
|
||||
case 905:
|
||||
case 906:
|
||||
case 907:
|
||||
case 908:
|
||||
dc_transmap = transtables + ((ldef->special-900)<<FF_TRANSSHIFT);
|
||||
colfunc = fuzzcolfunc;
|
||||
break;
|
||||
case 909:
|
||||
colfunc = R_DrawFogColumn_8;
|
||||
windowtop = frontsector->ceilingheight;
|
||||
windowbottom = frontsector->floorheight;
|
||||
break;
|
||||
default:
|
||||
colfunc = wallcolfunc;
|
||||
break;
|
||||
if (ldef->alpha == NUMTRANSMAPS || ldef->blendmode == AST_MODULATE)
|
||||
dc_transmap = R_GetBlendTable(ldef->blendmode, 0);
|
||||
else
|
||||
dc_transmap = R_GetBlendTable(ldef->blendmode, R_GetLinedefTransTable(ldef->alpha));
|
||||
colfunc = fuzzcolfunc;
|
||||
}
|
||||
else if (ldef->alpha > 0 && ldef->alpha < FRACUNIT)
|
||||
{
|
||||
dc_transmap = transtables + ((R_GetLinedefTransTable(ldef->alpha) - 1) << FF_TRANSSHIFT);
|
||||
colfunc = fuzzcolfunc;
|
||||
}
|
||||
else if (ldef->special == 909)
|
||||
{
|
||||
colfunc = R_DrawFogColumn_8;
|
||||
windowtop = frontsector->ceilingheight;
|
||||
windowbottom = frontsector->floorheight;
|
||||
}
|
||||
else
|
||||
{
|
||||
colfunc = wallcolfunc;
|
||||
}
|
||||
|
||||
if (curline->polyseg && curline->polyseg->translucency > 0)
|
||||
@@ -344,7 +370,7 @@ void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2)
|
||||
if (curline->polyseg->translucency >= NUMTRANSMAPS)
|
||||
return;
|
||||
|
||||
dc_transmap = transtables + ((curline->polyseg->translucency-1)<<FF_TRANSSHIFT);
|
||||
dc_transmap = R_GetTranslucencyTable(curline->polyseg->translucency);
|
||||
colfunc = fuzzcolfunc;
|
||||
}
|
||||
|
||||
@@ -712,28 +738,17 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
|
||||
boolean fuzzy = true;
|
||||
|
||||
// Hacked up support for alpha value in software mode Tails 09-24-2002
|
||||
if (pfloor->alpha < 12)
|
||||
return; // Don't even draw it
|
||||
else if (pfloor->alpha < 38)
|
||||
dc_transmap = transtables + ((tr_trans90-1)<<FF_TRANSSHIFT);
|
||||
else if (pfloor->alpha < 64)
|
||||
dc_transmap = transtables + ((tr_trans80-1)<<FF_TRANSSHIFT);
|
||||
else if (pfloor->alpha < 89)
|
||||
dc_transmap = transtables + ((tr_trans70-1)<<FF_TRANSSHIFT);
|
||||
else if (pfloor->alpha < 115)
|
||||
dc_transmap = transtables + ((tr_trans60-1)<<FF_TRANSSHIFT);
|
||||
else if (pfloor->alpha < 140)
|
||||
dc_transmap = transtables + ((tr_trans50-1)<<FF_TRANSSHIFT);
|
||||
else if (pfloor->alpha < 166)
|
||||
dc_transmap = transtables + ((tr_trans40-1)<<FF_TRANSSHIFT);
|
||||
else if (pfloor->alpha < 192)
|
||||
dc_transmap = transtables + ((tr_trans30-1)<<FF_TRANSSHIFT);
|
||||
else if (pfloor->alpha < 217)
|
||||
dc_transmap = transtables + ((tr_trans20-1)<<FF_TRANSSHIFT);
|
||||
else if (pfloor->alpha < 243)
|
||||
dc_transmap = transtables + ((tr_trans10-1)<<FF_TRANSSHIFT);
|
||||
else
|
||||
fuzzy = false; // Opaque
|
||||
// ...unhacked by toaster 04-01-2021, re-hacked a little by sphere 19-11-2021
|
||||
// and mercilessly shoved into saturn by chearii 02-02-2025
|
||||
{
|
||||
INT32 trans = (10*((256+12) - pfloor->alpha))/255;
|
||||
if (trans >= 10)
|
||||
return; // Don't even draw it
|
||||
if (pfloor->blend) // additive, (reverse) subtractive, modulative
|
||||
dc_transmap = R_GetBlendTable(pfloor->blend, trans);
|
||||
else if (!(dc_transmap = R_GetTranslucencyTable(trans)) || trans == 0)
|
||||
fuzzy = false; // Opaque
|
||||
}
|
||||
|
||||
if (fuzzy)
|
||||
colfunc = fuzzcolfunc;
|
||||
@@ -1450,7 +1465,7 @@ static void R_RenderSegLoop (void)
|
||||
dc_texturemid = rw_midtexturemid;
|
||||
dc_source = R_GetColumn(midtexture,texturecolumn);
|
||||
dc_texheight = textureheight[midtexture]>>FRACBITS;
|
||||
dc_sourcelength = 0;
|
||||
dc_sourcelength = dc_texheight;
|
||||
colfunc();
|
||||
|
||||
// dont draw anything more for this column, since
|
||||
@@ -1498,7 +1513,7 @@ static void R_RenderSegLoop (void)
|
||||
dc_texturemid = rw_toptexturemid;
|
||||
dc_source = R_GetColumn(toptexture,texturecolumn);
|
||||
dc_texheight = textureheight[toptexture]>>FRACBITS;
|
||||
dc_sourcelength = 0;
|
||||
dc_sourcelength = dc_texheight;
|
||||
colfunc();
|
||||
ceilingclip[rw_x] = (INT16)mid;
|
||||
}
|
||||
@@ -1536,7 +1551,7 @@ static void R_RenderSegLoop (void)
|
||||
dc_source = R_GetColumn(bottomtexture,
|
||||
texturecolumn);
|
||||
dc_texheight = textureheight[bottomtexture]>>FRACBITS;
|
||||
dc_sourcelength = 0;
|
||||
dc_sourcelength = dc_texheight;
|
||||
colfunc();
|
||||
floorclip[rw_x] = (INT16)mid;
|
||||
}
|
||||
@@ -1614,12 +1629,6 @@ static INT64 R_CalcSegDist(seg_t* seg, INT64 x2, INT64 y2)
|
||||
}
|
||||
}
|
||||
|
||||
static inline INT32 get_flat_tex (INT32 texnum)
|
||||
{
|
||||
texnum = R_GetTextureNum(texnum);
|
||||
return textures[texnum]->holes ? 0 : texnum; // R_DrawWallColumn cannot render holey textures
|
||||
}
|
||||
|
||||
//
|
||||
// R_StoreWallRange
|
||||
// A wall segment will be drawn
|
||||
@@ -1875,7 +1884,7 @@ void R_StoreWallRange(INT32 start, INT32 stop)
|
||||
{
|
||||
fixed_t texheight;
|
||||
// single sided line
|
||||
midtexture = get_flat_tex(sidedef->midtexture);
|
||||
midtexture = R_GetTextureNum(sidedef->midtexture);
|
||||
texheight = textureheight[midtexture];
|
||||
// a single sided line is terminal, so it must mark ends
|
||||
markfloor = markceiling = true;
|
||||
@@ -2052,15 +2061,15 @@ void R_StoreWallRange(INT32 start, INT32 stop)
|
||||
{
|
||||
// Special case... use offsets from 2nd side but only if it has a texture.
|
||||
side_t *def = &sides[linedef->sidenum[1]];
|
||||
toptexture = get_flat_tex(def->toptexture);
|
||||
toptexture = R_GetTextureNum(def->toptexture);
|
||||
|
||||
if (!toptexture) //Second side has no texture, use the first side's instead.
|
||||
toptexture = get_flat_tex(sidedef->toptexture);
|
||||
toptexture = R_GetTextureNum(sidedef->toptexture);
|
||||
texheight = textureheight[toptexture];
|
||||
}
|
||||
else
|
||||
{
|
||||
toptexture = get_flat_tex(sidedef->toptexture);
|
||||
toptexture = R_GetTextureNum(sidedef->toptexture);
|
||||
texheight = textureheight[toptexture];
|
||||
}
|
||||
if (!(linedef->flags & ML_EFFECT1)) { // Ignore slopes for lower/upper textures unless flag is checked
|
||||
@@ -2085,7 +2094,7 @@ void R_StoreWallRange(INT32 start, INT32 stop)
|
||||
if (worldlow > worldbottom || worldlowslope > worldbottomslope) // Only if VISIBLE!!!
|
||||
{
|
||||
// bottom texture
|
||||
bottomtexture = get_flat_tex(sidedef->bottomtexture);
|
||||
bottomtexture = R_GetTextureNum(sidedef->bottomtexture);
|
||||
|
||||
if (!(linedef->flags & ML_EFFECT1)) { // Ignore slopes for lower/upper textures unless flag is checked
|
||||
if (linedef->flags & ML_DONTPEGBOTTOM)
|
||||
|
||||
@@ -18,6 +18,7 @@
|
||||
#pragma interface
|
||||
#endif
|
||||
|
||||
transnum_t R_GetLinedefTransTable(fixed_t alpha);
|
||||
void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2);
|
||||
void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pffloor);
|
||||
void R_StoreWallRange(INT32 start, INT32 stop);
|
||||
|
||||
+1
-2
@@ -79,6 +79,5 @@ void R_SetupSkyDraw(void)
|
||||
*/
|
||||
void R_SetSkyScale(void)
|
||||
{
|
||||
fixed_t difference = vid.fdupx-(vid.dupx<<FRACBITS);
|
||||
skyscale = FixedDiv(fovtan, vid.fdupx+difference);
|
||||
skyscale = FixedDiv(fovtan, FixedDiv(vid.width*FRACUNIT, BASEVIDWIDTH*FRACUNIT));
|
||||
}
|
||||
+94
-53
@@ -592,7 +592,7 @@ void R_DrawMaskedColumn(column_t *column)
|
||||
|
||||
basetexturemid = dc_texturemid;
|
||||
|
||||
if (!column || column == 0)
|
||||
if (column == NULL)
|
||||
return;
|
||||
|
||||
for (; column->topdelta != 0xff ;)
|
||||
@@ -976,7 +976,7 @@ static void R_DrawPrecipitationVisSprite(vissprite_t *vis)
|
||||
// R_SplitSprite
|
||||
// runs through a sector's lightlist and splits the sprite according to the heights
|
||||
//
|
||||
static void R_SplitSprite(vissprite_t *sprite, mobj_t *thing)
|
||||
static void R_SplitSprite(vissprite_t *sprite)
|
||||
{
|
||||
INT32 i, lightnum, lindex;
|
||||
INT16 cutfrac;
|
||||
@@ -1042,7 +1042,7 @@ static void R_SplitSprite(vissprite_t *sprite, mobj_t *thing)
|
||||
|
||||
newsprite->extra_colormap = sector->lightlist[i].extra_colormap;
|
||||
|
||||
if (!((thing->frame & (FF_FULLBRIGHT|FF_TRANSMASK) || thing->flags2 & MF2_SHADOW)
|
||||
if (!((newsprite->cut & SC_FULLBRIGHT)
|
||||
&& (!newsprite->extra_colormap || !(newsprite->extra_colormap->fog & 1))))
|
||||
{
|
||||
lindex = FixedMul(sprite->xscale, LIGHTRESOLUTIONFIX)>>(LIGHTSCALESHIFT);
|
||||
@@ -1050,6 +1050,9 @@ static void R_SplitSprite(vissprite_t *sprite, mobj_t *thing)
|
||||
// Mitigate against negative xscale and arithmetic overflow
|
||||
lindex = CLAMP(lindex, 0, MAXLIGHTSCALE - 1);
|
||||
|
||||
if (newsprite->cut & SC_SEMIBRIGHT)
|
||||
lindex = (MAXLIGHTSCALE/2) + (lindex >>1);
|
||||
|
||||
newsprite->colormap = spritelights[lindex];
|
||||
}
|
||||
}
|
||||
@@ -1163,6 +1166,7 @@ static void R_ProjectSprite(mobj_t *thing)
|
||||
UINT8 flip;
|
||||
|
||||
INT32 lindex;
|
||||
INT32 trans;
|
||||
|
||||
vissprite_t *vis;
|
||||
|
||||
@@ -1260,8 +1264,8 @@ static void R_ProjectSprite(mobj_t *thing)
|
||||
|
||||
#ifdef ROTSPRITE
|
||||
// determine here if sprite should rotate for optimization
|
||||
const boolean sliprollrotate = (cv_sloperoll.value && cv_sliptideroll.value && (thing->player && thing->player->sliproll));
|
||||
const boolean shouldrotate = (cv_sloperoll.value && (interp.roll || interp.pitch || interp.sloperoll || interp.slopepitch || thing->rollangle || sliprollrotate));
|
||||
const boolean sliprollrotate = (cv_sliptideroll.value && (thing->player && thing->player->sliproll));
|
||||
const boolean shouldrotate = (interp.roll || interp.pitch || interp.sloperoll || interp.slopepitch || thing->rollangle || sliprollrotate);
|
||||
#endif
|
||||
|
||||
//Fab : 02-08-98: 'skin' override spritedef currently used for skin
|
||||
@@ -1308,9 +1312,9 @@ static void R_ProjectSprite(mobj_t *thing)
|
||||
I_Error("R_ProjectSprite: sprframes NULL for sprite %d\n", thing->sprite);
|
||||
#endif
|
||||
|
||||
if (sprframe->rotate != SRF_SINGLE || papersprite ||
|
||||
if (sprframe->rotate != SRF_SINGLE || papersprite
|
||||
#ifdef ROTSPRITE
|
||||
(shouldrotate)
|
||||
|| (shouldrotate)
|
||||
#endif
|
||||
)
|
||||
{
|
||||
@@ -1575,6 +1579,24 @@ static void R_ProjectSprite(mobj_t *thing)
|
||||
return;
|
||||
}
|
||||
|
||||
INT32 blendmode;
|
||||
if (oldthing->frame & FF_BLENDMASK)
|
||||
blendmode = ((oldthing->frame & FF_BLENDMASK) >> FF_BLENDSHIFT) + 1;
|
||||
else
|
||||
blendmode = oldthing->blendmode;
|
||||
|
||||
// Determine the translucency value.
|
||||
if (oldthing->flags2 & MF2_SHADOW || thing->flags2 & MF2_SHADOW) // actually only the player should use this (temporary invisibility)
|
||||
trans = tr_trans80; // because now the translucency is set through FF_TRANSMASK
|
||||
else if (oldthing->frame & FF_TRANSMASK)
|
||||
{
|
||||
trans = (oldthing->frame & FF_TRANSMASK) >> FF_TRANSSHIFT;
|
||||
if (!R_BlendLevelVisible(blendmode, trans))
|
||||
return;
|
||||
}
|
||||
else
|
||||
trans = 0;
|
||||
|
||||
//SoM: 3/17/2000: Disregard sprites that are out of view..
|
||||
if (vflip)
|
||||
{
|
||||
@@ -1752,6 +1774,18 @@ static void R_ProjectSprite(mobj_t *thing)
|
||||
vis->scale += FixedMul(scalestep, spriteyscale) * (vis->x1 - x1);
|
||||
}
|
||||
|
||||
if ((blendmode != AST_COPY) && cv_translucency.value)
|
||||
vis->transmap = R_GetBlendTable(blendmode, trans);
|
||||
else
|
||||
vis->transmap = NULL;
|
||||
|
||||
if (R_ThingIsFullBright(oldthing) || oldthing->flags2 & MF2_SHADOW || thing->flags2 & MF2_SHADOW)
|
||||
vis->cut |= SC_FULLBRIGHT;
|
||||
else if (R_ThingIsSemiBright(oldthing))
|
||||
vis->cut |= SC_SEMIBRIGHT;
|
||||
else if (R_ThingIsFullDark(oldthing))
|
||||
vis->cut |= SC_FULLDARK;
|
||||
|
||||
//Fab: lumppat is the lump number of the patch to use, this is different
|
||||
// than lumpid for sprites-in-pwad : the graphics are patched
|
||||
#ifdef ROTSPRITE
|
||||
@@ -1761,25 +1795,18 @@ static void R_ProjectSprite(mobj_t *thing)
|
||||
#endif
|
||||
vis->patch = W_CachePatchNum(sprframe->lumppat[rot], PU_CACHE);
|
||||
|
||||
//
|
||||
// determine the colormap (lightlevel & special effects)
|
||||
//
|
||||
vis->transmap = NULL;
|
||||
//
|
||||
// determine the colormap (lightlevel & special effects)
|
||||
//
|
||||
|
||||
// specific translucency
|
||||
if (!cv_translucency.value)
|
||||
; // no translucency
|
||||
else if (thing->flags2 & MF2_SHADOW) // actually only the player should use this (temporary invisibility)
|
||||
vis->transmap = transtables + ((tr_trans80-1)<<FF_TRANSSHIFT); // because now the translucency is set through FF_TRANSMASK
|
||||
else if (thing->frame & FF_TRANSMASK)
|
||||
vis->transmap = transtables + (thing->frame & FF_TRANSMASK) - 0x10000;
|
||||
|
||||
if (((thing->frame & FF_FULLBRIGHT) || (thing->flags2 & MF2_SHADOW))
|
||||
if ((vis->cut & SC_FULLBRIGHT)
|
||||
&& (!vis->extra_colormap || !(vis->extra_colormap->fog & 1)))
|
||||
{
|
||||
// full bright: goggles
|
||||
vis->colormap = colormaps;
|
||||
}
|
||||
else if (vis->cut & SC_FULLDARK)
|
||||
vis->colormap = scalelight[0][0];
|
||||
else
|
||||
{
|
||||
// diminished light
|
||||
@@ -1788,7 +1815,10 @@ static void R_ProjectSprite(mobj_t *thing)
|
||||
// Mitigate against negative xscale and arithmetic overflow
|
||||
lindex = CLAMP(lindex, 0, MAXLIGHTSCALE - 1);
|
||||
|
||||
vis->colormap = lights_array[lindex];
|
||||
if (vis->cut & SC_SEMIBRIGHT)
|
||||
lindex = (MAXLIGHTSCALE/2) + (lindex >> 1);
|
||||
|
||||
vis->colormap = spritelights[lindex];
|
||||
}
|
||||
|
||||
vis->precip = false;
|
||||
@@ -1798,7 +1828,7 @@ static void R_ProjectSprite(mobj_t *thing)
|
||||
vis->isScaled = false;
|
||||
|
||||
if (thing->subsector->sector->numlights)
|
||||
R_SplitSprite(vis, thing);
|
||||
R_SplitSprite(vis);
|
||||
|
||||
// Debug
|
||||
++objectsdrawn;
|
||||
@@ -1977,8 +2007,8 @@ static void R_ProjectPrecipitationSprite(precipmobj_t *thing)
|
||||
vis->patch = W_CachePatchNum(sprframe->lumppat[0], PU_CACHE);
|
||||
|
||||
// specific translucency
|
||||
if (thing->frame & FF_TRANSMASK)
|
||||
vis->transmap = (thing->frame & FF_TRANSMASK) - 0x10000 + transtables;
|
||||
if ((thing->blendmode != AST_COPY) && cv_translucency.value)
|
||||
vis->transmap = R_GetTranslucencyTable((thing->frame & FF_TRANSMASK) >> FF_TRANSSHIFT);
|
||||
else
|
||||
vis->transmap = NULL;
|
||||
|
||||
@@ -2858,9 +2888,6 @@ boolean R_ThingVisible (mobj_t *thing)
|
||||
if (thing->sprite == SPR_NULL || thing->flags2 & MF2_DONTDRAW)
|
||||
return false;
|
||||
|
||||
if (!P_MobjWasRemoved(viewmobj) && (thing == viewmobj))
|
||||
return false;
|
||||
|
||||
if (splitscreen)
|
||||
{
|
||||
if ((viewssnum == 0 && (thing->eflags & MFE_DRAWONLYFORP1))
|
||||
@@ -2873,12 +2900,11 @@ boolean R_ThingVisible (mobj_t *thing)
|
||||
return true;
|
||||
}
|
||||
|
||||
boolean R_ThingWithinDist (mobj_t *thing, fixed_t limit_dist)
|
||||
boolean R_ThingWithinDist(mobj_t *thing, fixed_t limit_dist)
|
||||
{
|
||||
if (limit_dist)
|
||||
{
|
||||
const fixed_t dist = P_AproxDistance(viewx-thing->x, viewy-thing->y);
|
||||
if (dist > limit_dist)
|
||||
if (P_AproxDistance(viewx-thing->x, viewy-thing->y) > limit_dist)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
@@ -2887,6 +2913,21 @@ boolean R_ThingWithinDist (mobj_t *thing, fixed_t limit_dist)
|
||||
return true;
|
||||
}
|
||||
|
||||
boolean R_ThingIsFullBright(mobj_t *thing)
|
||||
{
|
||||
return ((thing->frame & FF_BRIGHTMASK) == FF_FULLBRIGHT);
|
||||
}
|
||||
|
||||
boolean R_ThingIsSemiBright(mobj_t *thing)
|
||||
{
|
||||
return ((thing->frame & FF_BRIGHTMASK) == FF_SEMIBRIGHT);
|
||||
}
|
||||
|
||||
boolean R_ThingIsFullDark(mobj_t *thing)
|
||||
{
|
||||
return ((thing->frame & FF_BRIGHTMASK) == FF_FULLDARK);
|
||||
}
|
||||
|
||||
//
|
||||
// R_DrawMasked
|
||||
//
|
||||
@@ -2979,7 +3020,7 @@ static void Sk_SetDefaultValue(skin_t *skin, boolean local)
|
||||
//
|
||||
memset(skin, 0, sizeof (skin_t));
|
||||
snprintf(skin->name,
|
||||
sizeof skin->name, "skin %u", (UINT32)(skin-( (local) ? localskins : skins )));
|
||||
sizeof skin->name, "skin %u", (UINT32)(skin-(local ? localskins : skins)));
|
||||
skin->name[sizeof skin->name - 1] = '\0';
|
||||
skin->wadnum = INT16_MAX;
|
||||
strcpy(skin->sprite, "");
|
||||
@@ -3149,8 +3190,8 @@ boolean SetPlayerSkin(INT32 playernum, const char *skinname)
|
||||
|
||||
void SetLocalPlayerSkin(INT32 playernum, const char *skinname, consvar_t *cvar)
|
||||
{
|
||||
player_t *player = &players[playernum];
|
||||
INT32 i;
|
||||
player_t *player = &players[playernum];
|
||||
|
||||
if (strcasecmp(skinname, "none"))
|
||||
{
|
||||
@@ -3200,8 +3241,8 @@ void SetLocalPlayerSkin(INT32 playernum, const char *skinname, consvar_t *cvar)
|
||||
{
|
||||
if (player->localskin > 0)
|
||||
{
|
||||
CV_StealthSet(&cv_fakelocalskin, ( (player->skinlocal) ? localskins : skins )[player->localskin - 1].name);
|
||||
CV_StealthSet(cvar, ( (player->skinlocal) ? localskins : skins )[player->localskin - 1].name);
|
||||
CV_StealthSet(&cv_fakelocalskin, (player->skinlocal ? localskins : skins)[player->localskin-1].name);
|
||||
CV_StealthSet(cvar, (player->skinlocal ? localskins : skins)[player->localskin-1].name);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -3390,6 +3431,9 @@ void R_AddSkins(UINT16 wadnum, boolean local)
|
||||
skin_t *skin;
|
||||
boolean hudname, realname;
|
||||
|
||||
#define lskin (local ? localskins : skins)
|
||||
#define lnumskins (local ? numlocalskins : numskins)
|
||||
|
||||
//
|
||||
// search for all skin markers in pwad
|
||||
//
|
||||
@@ -3421,7 +3465,7 @@ void R_AddSkins(UINT16 wadnum, boolean local)
|
||||
buf2[size] = '\0';
|
||||
|
||||
// set defaults
|
||||
skin = &( (local) ? localskins : skins )[( (local) ? numlocalskins : numskins )];
|
||||
skin = &lskin[lnumskins];
|
||||
Sk_SetDefaultValue(skin, local);
|
||||
skin->wadnum = wadnum;
|
||||
hudname = realname = false;
|
||||
@@ -3647,34 +3691,29 @@ next_token:
|
||||
|
||||
CONS_Printf(M_GetText("Added skin '%s'\n"), skin->name);
|
||||
#ifdef SKINVALUES
|
||||
(local ? localskin_cons_t : skin_cons_t)[(local ? numlocalskins : numskins)].value = (local ? numlocalskins : numskins);
|
||||
(local ? localskin_cons_t : skin_cons_t)[(local ? numlocalskins : numskins)].strvalue = skin->name;
|
||||
(local ? localskin_cons_t : skin_cons_t)[lnumskins].value = lnumskins;
|
||||
(local ? localskin_cons_t : skin_cons_t)[lnumskins].strvalue = skin->name;
|
||||
#endif
|
||||
|
||||
// Update the forceskin possiblevalues
|
||||
if (!local)
|
||||
{
|
||||
// Update the forceskin possiblevalues
|
||||
Forceskin_cons_t[numskins+1].value = numskins;
|
||||
Forceskin_cons_t[numskins+1].strvalue = skins[numskins].name;
|
||||
}
|
||||
|
||||
skin->localskin = local;
|
||||
|
||||
// so we dont have to guess
|
||||
if (local)
|
||||
skin->localnum = numlocalskins;
|
||||
else
|
||||
skin->localskin = false;
|
||||
skin->localnum = numskins;
|
||||
|
||||
// add face graphics
|
||||
if (local)
|
||||
ST_LoadLocalFaceGraphics(skin->facerank, skin->facewant, skin->facemmap, numlocalskins);
|
||||
else
|
||||
ST_LoadFaceGraphics(skin->facerank, skin->facewant, skin->facemmap, numskins);
|
||||
}
|
||||
else
|
||||
{
|
||||
skin->localskin = true;
|
||||
skin->localnum = numlocalskins;
|
||||
ST_LoadLocalFaceGraphics(skin->facerank, skin->facewant, skin->facemmap, numlocalskins);
|
||||
}
|
||||
|
||||
#ifdef HWRENDER
|
||||
if (rendermode == render_opengl)
|
||||
HWR_AddPlayerMD2(((local) ? numlocalskins : numskins), local);
|
||||
HWR_AddPlayerMD2(lnumskins, local);
|
||||
#endif
|
||||
if (!local)
|
||||
{
|
||||
@@ -3685,12 +3724,14 @@ next_token:
|
||||
skinsorted[numskins] = numskins;
|
||||
}
|
||||
|
||||
allskins[numallskins] = ( (local) ? localskins : skins )[( (local) ? numlocalskins : numskins )];
|
||||
allskins[numallskins] = lskin[lnumskins];
|
||||
|
||||
local ? numlocalskins++ : numskins++;
|
||||
numallskins++;
|
||||
}
|
||||
|
||||
#undef lskin
|
||||
#undef lnumskins
|
||||
//sortSkinGrid();
|
||||
|
||||
return;
|
||||
|
||||
@@ -79,6 +79,10 @@ void R_DrawMasked(void);
|
||||
boolean R_ThingVisible (mobj_t *thing);
|
||||
boolean R_ThingWithinDist (mobj_t *thing, fixed_t limit_dist);
|
||||
|
||||
boolean R_ThingIsFullBright (mobj_t *thing);
|
||||
boolean R_ThingIsSemiBright (mobj_t *thing);
|
||||
boolean R_ThingIsFullDark (mobj_t *thing);
|
||||
|
||||
// -----------
|
||||
// SKINS STUFF
|
||||
// -----------
|
||||
@@ -131,6 +135,9 @@ typedef enum
|
||||
SC_BOTTOM = 2,
|
||||
SC_VFLIP = 3,
|
||||
SC_NOTVISIBLE = 4,
|
||||
SC_FULLBRIGHT = 8,
|
||||
SC_SEMIBRIGHT = 16,
|
||||
SC_FULLDARK = 32,
|
||||
SC_CUTMASK = SC_TOP|SC_BOTTOM|SC_NOTVISIBLE,
|
||||
SC_FLAGMASK = ~SC_CUTMASK
|
||||
} spritecut_e;
|
||||
|
||||
+163
-137
@@ -113,13 +113,15 @@ consvar_t cv_resume = {"resume", "No", CV_SAVE, CV_YesNo, NULL, 0, NULL, NULL, 0
|
||||
consvar_t cv_fading = {"fading", "Off", CV_SAVE|CV_CALL, CV_OnOff, Bird_menu_Onchange, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_birdmusic = {"birdmusicstuff", "No", CV_SAVE|CV_CALL, CV_YesNo, Bird_menu_Onchange, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
|
||||
consvar_t cv_keepmusic = {"keepmusic", "No", CV_SAVE, CV_YesNo, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
consvar_t cv_skipintromusic = {"skipintromusic", "No", CV_SAVE, CV_YesNo, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
//consvar_t cv_ignoremusicchanges = {"ignoremusicchanges", "No", CV_SAVE, CV_YesNo, NULL, 0, NULL, NULL, 0, 0, NULL};
|
||||
|
||||
boolean keepmusic = false;
|
||||
static void S_CheckEventMus(const char *newmus);
|
||||
boolean keepmapmusic = false; // keep the current music on map restart
|
||||
boolean skipintromus = false; // skip the intro fanfare
|
||||
static boolean resumekeepmusic = false;
|
||||
static music_t keepmusic;
|
||||
static void S_SetKeepMusResume(void);
|
||||
|
||||
#ifdef HAVE_OPENMPT
|
||||
openmpt_module *openmpt_mhandle = NULL;
|
||||
@@ -342,7 +344,7 @@ lumpnum_t S_GetSfxLumpNum(sfxinfo_t *sfx)
|
||||
if (sfxlump != LUMPERROR)
|
||||
return sfxlump;
|
||||
|
||||
strlcpy(namebuf, sfx->name, sizeof namebuf);
|
||||
strlcpy(namebuf, sfx->name, sizeof(namebuf));
|
||||
|
||||
sfxlump = W_CheckNumForName(namebuf);
|
||||
if (sfxlump != LUMPERROR)
|
||||
@@ -456,11 +458,7 @@ void S_StartSoundAtVolume(const void *origin_p, sfxenum_t sfx_id, INT32 volume)
|
||||
memset(&listener[i], 0, sizeof (listener[i]));
|
||||
listenmobj[i] = NULL;
|
||||
|
||||
if (i == 0 && democam.soundmobj)
|
||||
{
|
||||
listenmobj[i] = democam.soundmobj;
|
||||
}
|
||||
else if (player->awayviewtics)
|
||||
if (player->awayviewtics)
|
||||
{
|
||||
listenmobj[i] = player->awayviewmobj;
|
||||
}
|
||||
@@ -469,7 +467,7 @@ void S_StartSoundAtVolume(const void *origin_p, sfxenum_t sfx_id, INT32 volume)
|
||||
listenmobj[i] = player->mo;
|
||||
}
|
||||
|
||||
if (origin && origin == listenmobj[i])
|
||||
if (origin && origin == listenmobj[i] && !camera[i].freecam)
|
||||
{
|
||||
itsUs = true;
|
||||
}
|
||||
@@ -719,12 +717,6 @@ void S_UpdateSounds(void)
|
||||
memset(&listener[i], 0, sizeof (listener[i]));
|
||||
listenmobj[i] = NULL;
|
||||
|
||||
if (i == 0 && democam.soundmobj)
|
||||
{
|
||||
listenmobj[i] = democam.soundmobj;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (player->awayviewtics)
|
||||
{
|
||||
listenmobj[i] = player->awayviewmobj;
|
||||
@@ -780,6 +772,9 @@ void S_UpdateSounds(void)
|
||||
|
||||
for (i = splitscreen; i >= 0; i--)
|
||||
{
|
||||
if (camera[i].freecam)
|
||||
continue;
|
||||
|
||||
if (c->origin != listenmobj[i])
|
||||
continue;
|
||||
|
||||
@@ -1199,17 +1194,10 @@ const char *compat_special_music_slots[16] =
|
||||
};
|
||||
#endif
|
||||
|
||||
static char music_name[7]; // up to 6-character name
|
||||
static void *music_data;
|
||||
static UINT16 music_flags;
|
||||
static boolean music_looping;
|
||||
static consvar_t *music_refade_cv;
|
||||
static music_t music;
|
||||
static music_t queue;
|
||||
|
||||
static char queue_name[7];
|
||||
static UINT16 queue_flags;
|
||||
static boolean queue_looping;
|
||||
static UINT32 queue_position;
|
||||
static UINT32 queue_fadeinms;
|
||||
static consvar_t *music_refade_cv;
|
||||
|
||||
/// ------------------------
|
||||
/// Music Definitions
|
||||
@@ -1481,7 +1469,7 @@ void S_ShowSpecifiedMusicCredit(const char *musname)
|
||||
//
|
||||
void S_ShowMusicCredit(void)
|
||||
{
|
||||
S_ShowSpecifiedMusicCredit(music_name);
|
||||
S_ShowSpecifiedMusicCredit(music.name);
|
||||
}
|
||||
|
||||
musicdef_t **soundtestdefs = NULL;
|
||||
@@ -1560,7 +1548,7 @@ musictype_t S_MusicType(void)
|
||||
|
||||
const char *S_MusicName(void)
|
||||
{
|
||||
return music_name;
|
||||
return music.name;
|
||||
}
|
||||
|
||||
boolean S_MusicInfo(char *mname, UINT16 *mflags, boolean *looping)
|
||||
@@ -1568,10 +1556,10 @@ boolean S_MusicInfo(char *mname, UINT16 *mflags, boolean *looping)
|
||||
if (!I_SongPlaying())
|
||||
return false;
|
||||
|
||||
strncpy(mname, music_name, 7);
|
||||
strncpy(mname, music.name, 7);
|
||||
mname[6] = 0;
|
||||
*mflags = music_flags;
|
||||
*looping = music_looping;
|
||||
*mflags = music.flags;
|
||||
*looping = music.looping;
|
||||
|
||||
return (boolean)mname[0];
|
||||
}
|
||||
@@ -1661,9 +1649,9 @@ static boolean S_LoadMusic(const char *mname)
|
||||
|
||||
if (I_LoadSong(mdata, W_LumpLength(mlumpnum)))
|
||||
{
|
||||
strncpy(music_name, mname, 7);
|
||||
music_name[6] = 0;
|
||||
music_data = mdata;
|
||||
strncpy(music.name, mname, 7);
|
||||
music.name[6] = 0;
|
||||
music.data = mdata;
|
||||
return true;
|
||||
}
|
||||
else
|
||||
@@ -1675,13 +1663,13 @@ static void S_UnloadMusic(void)
|
||||
I_UnloadSong();
|
||||
|
||||
#ifndef HAVE_SDL //SDL uses RWOPS
|
||||
Z_ChangeTag(music_data, PU_CACHE);
|
||||
Z_ChangeTag(music.data, PU_CACHE);
|
||||
#endif
|
||||
music_data = NULL;
|
||||
music.data = NULL;
|
||||
|
||||
music_name[0] = 0;
|
||||
music_flags = 0;
|
||||
music_looping = false;
|
||||
music.name[0] = 0;
|
||||
music.flags = 0;
|
||||
music.looping = false;
|
||||
|
||||
music_refade_cv = 0;
|
||||
}
|
||||
@@ -1710,24 +1698,28 @@ static boolean S_PlayMusic(boolean looping, UINT32 fadeinms)
|
||||
|
||||
static void S_QueueMusic(const char *mmusic, UINT16 mflags, boolean looping, UINT32 position, UINT32 fadeinms)
|
||||
{
|
||||
strncpy(queue_name, mmusic, 7);
|
||||
queue_flags = mflags;
|
||||
queue_looping = looping;
|
||||
queue_position = position;
|
||||
queue_fadeinms = fadeinms;
|
||||
strncpy(queue.name, mmusic, 7);
|
||||
queue.flags = mflags;
|
||||
queue.looping = looping;
|
||||
queue.position = position;
|
||||
queue.fadeinms = fadeinms;
|
||||
}
|
||||
|
||||
static void S_ClearQueue(void)
|
||||
{
|
||||
queue_name[0] = queue_flags = queue_looping = queue_position = queue_fadeinms = 0;
|
||||
queue.name[0] = queue.flags = queue.looping = queue.position = queue.fadeinms = 0;
|
||||
}
|
||||
|
||||
static void S_ChangeMusicToQueue(void)
|
||||
{
|
||||
S_ChangeMusicEx(queue_name, queue_flags, queue_looping, queue_position, 0, queue_fadeinms);
|
||||
S_ChangeMusicEx(queue.name, queue.flags, queue.looping, queue.position, 0, queue.fadeinms);
|
||||
S_ClearQueue();
|
||||
}
|
||||
|
||||
// keep copy of music name before lua hook change
|
||||
// for custom vote music etc
|
||||
static char checkmusic[7] = {0};
|
||||
|
||||
void S_ChangeMusicEx(const char *mmusic, UINT16 mflags, boolean looping, UINT32 position, UINT32 prefadems, UINT32 fadeinms)
|
||||
{
|
||||
char newmusic[7] = {0};
|
||||
@@ -1747,10 +1739,9 @@ void S_ChangeMusicEx(const char *mmusic, UINT16 mflags, boolean looping, UINT32
|
||||
return;
|
||||
|
||||
strncpy(newmusic, mmusic, 6);
|
||||
strncpy(checkmusic, mmusic, 6);
|
||||
|
||||
S_CheckEventMus(newmusic);
|
||||
|
||||
if (LUA_HookMusicChange(music_name, &hook_param))
|
||||
if (LUA_HookMusicChange(music.name, &hook_param))
|
||||
return;
|
||||
|
||||
// No Music (empty string)
|
||||
@@ -1765,12 +1756,12 @@ void S_ChangeMusicEx(const char *mmusic, UINT16 mflags, boolean looping, UINT32
|
||||
|
||||
if (prefadems && S_MusicPlaying()) // queue music change for after fade // allow even if the music is the same
|
||||
{
|
||||
CONS_Debug(DBG_DETAILED, "Now fading out song %s\n", music_name);
|
||||
CONS_Debug(DBG_DETAILED, "Now fading out song %s\n", music.name);
|
||||
S_QueueMusic(newmusic, mflags, looping, position, fadeinms);
|
||||
I_FadeSong(0, prefadems, S_ChangeMusicToQueue);
|
||||
return;
|
||||
}
|
||||
else if (strnicmp(music_name, newmusic, 6) || (mflags & MUSIC_FORCERESET))
|
||||
else if (strnicmp(music.name, newmusic, 6) || (mflags & MUSIC_FORCERESET))
|
||||
{
|
||||
CONS_Debug(DBG_DETAILED, "Now playing song %s\n", newmusic);
|
||||
|
||||
@@ -1782,8 +1773,8 @@ void S_ChangeMusicEx(const char *mmusic, UINT16 mflags, boolean looping, UINT32
|
||||
return;
|
||||
}
|
||||
|
||||
music_flags = mflags;
|
||||
music_looping = looping;
|
||||
music.flags = mflags;
|
||||
music.looping = looping;
|
||||
|
||||
if (!S_PlayMusic(looping, fadeinms))
|
||||
{
|
||||
@@ -1823,7 +1814,9 @@ void S_StopMusic(void)
|
||||
|| demo.title) // SRB2Kart: Demos don't interrupt title screen music
|
||||
return;
|
||||
|
||||
mapmusresume = (cv_birdmusic.value && (strcasecmp(music_name, mapmusname) == 0)) ? I_GetSongPosition() : 0;
|
||||
mapmusic.resume = (cv_birdmusic.value && (strcasecmp(music.name, mapmusic.name) == 0)) ? I_GetSongPosition() : 0;
|
||||
|
||||
S_SetKeepMusResume();
|
||||
|
||||
if (I_SongPaused())
|
||||
I_ResumeSong();
|
||||
@@ -1938,83 +1931,123 @@ boolean S_FadeOutStopMusic(UINT32 ms)
|
||||
/// Init & Others
|
||||
/// ------------------------
|
||||
|
||||
/*static boolean S_KeepMusic(void)
|
||||
{
|
||||
//if (!cv_keepmusic.value)
|
||||
//return false;
|
||||
|
||||
// should i compare songs or maps?
|
||||
static char oldmusname[7] = "";
|
||||
|
||||
if (strcmp(music_name, mapmusname) != 0)
|
||||
return false;
|
||||
|
||||
if (strcmp(oldmusname, mapmusname) == 0)
|
||||
return true;
|
||||
|
||||
strncpy(oldmusname, mapmusname, 7);
|
||||
oldmusname[6] = '\0';
|
||||
|
||||
return false;
|
||||
}*/
|
||||
|
||||
static boolean skipmusic = false;
|
||||
boolean skipintromus = false;
|
||||
|
||||
static const char *musicexception_list[17] = {
|
||||
static const char *musicexception_list[] = {
|
||||
"vote", "voteea", "voteeb", "racent", "krwin",
|
||||
"krok", "krlose", "krfail", "kbwin", "kbok",
|
||||
"kblose", "kstart", "estart", "wait2j", "titles",
|
||||
"CHRSHF", "CHRSHP" // no clue what those are tbh
|
||||
"kinvnc", "kgrow", // grow and invinc
|
||||
"SPBA_W", "SPBA_L", // SPB Attack music
|
||||
"CHRSHF", "CHRSHP" // no clue what those are tbh
|
||||
};
|
||||
|
||||
// check if the current music is smth we dont want to keep (vote music, etc)
|
||||
static boolean S_CheckMusicException(void)
|
||||
{
|
||||
if (stricmp(music.name, mapmusic.name))
|
||||
return true;
|
||||
|
||||
// in case somehow the mapmusic was replaced with smth we dont want to keep
|
||||
for (size_t i = 0; i < sizeof(musicexception_list)/sizeof(musicexception_list[0]); i++)
|
||||
{
|
||||
if (!stricmp(music.name, musicexception_list[i]) || !stricmp(checkmusic, musicexception_list[i]))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
void S_ResetKeepAndSpecialMus(void)
|
||||
{
|
||||
keepmusic = skipintromus = false;
|
||||
keepmapmusic = skipintromus = false;
|
||||
}
|
||||
|
||||
//checks for any kind of event music like intermission, vote etc.
|
||||
//always runs when musicchange gets invoked
|
||||
static void S_CheckEventMus(const char *newmus)
|
||||
// saves the current song position everytime a song stops
|
||||
// so we can resume it in some cases
|
||||
static void S_SetKeepMusResume(void)
|
||||
{
|
||||
skipmusic = false;
|
||||
keepmusic.resume = 0;
|
||||
|
||||
if (!cv_keepmusic.value)
|
||||
return;
|
||||
|
||||
for (int i = 0; i < 17; i++)
|
||||
if (stricmp(music_name, musicexception_list[i]) == 0 || stricmp(newmus, musicexception_list[i]) == 0) // weird? sure! but were lucky enough newmus reflects whats being replaced
|
||||
{
|
||||
skipmusic = true;
|
||||
break;
|
||||
}
|
||||
|
||||
//CONS_Printf("music_name = %s\n", music_name);
|
||||
//CONS_Printf("newmus = %s\n", newmus);
|
||||
//CONS_Printf("skipmusic = %d\n", skipmusic);
|
||||
if (strcasecmp(music.name, mapmusic.name) == 0)
|
||||
{
|
||||
keepmusic.resume = I_GetSongPosition();
|
||||
}
|
||||
}
|
||||
|
||||
//this one compares map and encoremode instead of the music itself
|
||||
//makes tunes work and stuff
|
||||
void S_CheckMap(void)
|
||||
// determine if we should keep the music on a map restart
|
||||
// this gets called BEFORE the level gets loaded in G_DoLoadLevel
|
||||
void S_KeepMusic(void)
|
||||
{
|
||||
static INT16 oldmap = 0;
|
||||
static INT16 oldmap = -1;
|
||||
static boolean oldencore = false;
|
||||
|
||||
keepmapmusic = resumekeepmusic = false;
|
||||
|
||||
if (!cv_keepmusic.value)
|
||||
{
|
||||
keepmusic = false;
|
||||
return;
|
||||
}
|
||||
|
||||
keepmusic = (!skipmusic && gamestate == GS_LEVEL && oldmap == gamemap && oldencore == encoremode);
|
||||
// copy over mapmusicname stuff into temporary var
|
||||
memset(keepmusic.name, 0, sizeof(keepmusic.name));
|
||||
strlcpy(keepmusic.name, mapmusic.name, sizeof(keepmusic.name));
|
||||
keepmusic.name[6] = 0;
|
||||
|
||||
//CONS_Printf("keepmusic = %s\n", keepmusic);
|
||||
if (oldmap == gamemap && oldencore == encoremode)
|
||||
{
|
||||
const boolean musicchanged = S_CheckMusicException();
|
||||
|
||||
resumekeepmusic = (musicchanged && keepmusic.resume);
|
||||
keepmapmusic = (!musicchanged || resumekeepmusic);
|
||||
}
|
||||
|
||||
oldencore = encoremode;
|
||||
oldmap = gamemap;
|
||||
}
|
||||
|
||||
// Sets up the map music in case it should be reloaded
|
||||
// Special case for keep music
|
||||
void S_HandleReloadResetMusic(void)
|
||||
{
|
||||
if (!(mapmusic.flags & MUSIC_RELOADRESET))
|
||||
return;
|
||||
|
||||
// replace mapmusic with our saved keepmusic stuff
|
||||
if (keepmapmusic)
|
||||
{
|
||||
// this is horrible, but oh well
|
||||
strlcpy(mapmusic.name, keepmusic.name, sizeof(mapmusic.name));
|
||||
}
|
||||
else
|
||||
{
|
||||
strlcpy(mapmusic.name, mapheaderinfo[gamemap-1]->musname, sizeof(mapmusic.name));
|
||||
}
|
||||
|
||||
mapmusic.name[6] = 0;
|
||||
mapmusic.flags = (mapheaderinfo[gamemap-1]->mustrack & MUSIC_TRACKMASK);
|
||||
mapmusic.position = mapheaderinfo[gamemap-1]->muspos;
|
||||
mapmusic.resume = 0;
|
||||
}
|
||||
|
||||
static boolean S_SkipIntroMusic(void)
|
||||
{
|
||||
boolean skip = cv_skipintromusic.value;
|
||||
|
||||
if (!skip)
|
||||
return false;
|
||||
|
||||
char *maptitle = G_BuildMapTitle(gamemap); // Zzz...
|
||||
|
||||
// check if menu music is playing, otherwise it may continue playing
|
||||
if (!stricmp(music.name, "titles") || (maptitle && (!stricmp(maptitle, "Wandering Falls")))) // wandering balls changes its song when the race starts Zzz...
|
||||
skip = false;
|
||||
|
||||
Z_Free(maptitle);
|
||||
|
||||
return skip;
|
||||
}
|
||||
|
||||
//
|
||||
// Per level startup code.
|
||||
// Kills playing sounds at start of level,
|
||||
@@ -2022,56 +2055,49 @@ void S_CheckMap(void)
|
||||
//
|
||||
void S_InitMapMusic(void)
|
||||
{
|
||||
skipintromus = false;
|
||||
S_HandleReloadResetMusic();
|
||||
|
||||
if (mapmusflags & MUSIC_RELOADRESET)
|
||||
if (keepmapmusic)
|
||||
{
|
||||
strncpy(mapmusname, mapheaderinfo[gamemap-1]->musname, 7);
|
||||
mapmusname[6] = 0;
|
||||
mapmusflags = (mapheaderinfo[gamemap-1]->mustrack & MUSIC_TRACKMASK);
|
||||
mapmusposition = mapheaderinfo[gamemap-1]->muspos;
|
||||
mapmusresume = 0;
|
||||
}
|
||||
|
||||
if (keepmusic)
|
||||
// this is kinda silly, but we can use it to fade back into the map song at the saved point, should the current music be different from the map music
|
||||
if (resumekeepmusic)
|
||||
{
|
||||
S_ChangeMusicEx(mapmusic.name, mapmusic.flags, true, keepmusic.resume, 0, 500);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// Starting ambience should always be restarted
|
||||
// lug: but not when we keep the map music lol
|
||||
S_StopMusic();
|
||||
|
||||
if (cv_skipintromusic.value)
|
||||
{
|
||||
char *maptitle = G_BuildMapTitle(gamemap);
|
||||
// for some reason, occasionally the title screen music doesent seem to be reset in time, so skipping the intro may make it just continue playing it instead, weird..
|
||||
skipintromus = (stricmp(music_name, "titles") != 0) && (maptitle && (stricmp(maptitle, "Wandering Falls") != 0)); // thanks diggle!
|
||||
if (maptitle)
|
||||
Z_Free(maptitle);
|
||||
}
|
||||
skipintromus = S_SkipIntroMusic();
|
||||
|
||||
if (skipintromus)
|
||||
return;
|
||||
|
||||
if (leveltime < MUSICSTARTTIME) // SRB2Kart
|
||||
S_ChangeMusicInternal((encoremode ? "estart" : "kstart"), false); //S_StopMusic();
|
||||
//S_ChangeMusicEx((encoremode ? "estart" : "kstart"), 0, false, mapmusposition, 0, 0);
|
||||
}
|
||||
|
||||
void S_StartMapMusic(void)
|
||||
{
|
||||
//no need to constantly run this after race has started
|
||||
// no need to constantly run this after race has started
|
||||
if (leveltime > MUSICSTARTTIME)
|
||||
return;
|
||||
|
||||
if (keepmusic)
|
||||
if (keepmapmusic)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (skipintromus)
|
||||
{
|
||||
if (leveltime < starttime)
|
||||
S_ChangeMusicEx(mapmusname, mapmusflags, true, mapmusposition, 0, 0);
|
||||
if (leveltime == MUSICSTARTTIME)
|
||||
S_ChangeMusicEx(mapmusic.name, mapmusic.flags, true, mapmusic.position, 0, 0);
|
||||
else if (leveltime == MUSICSTARTTIME)
|
||||
S_ShowMusicCredit();
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -2081,7 +2107,7 @@ void S_StartMapMusic(void)
|
||||
S_StopMusic();
|
||||
else if (leveltime == MUSICSTARTTIME) // Plays the music after the starting countdown.
|
||||
{
|
||||
S_ChangeMusicEx(mapmusname, mapmusflags, true, mapmusposition, 0, 0);
|
||||
S_ChangeMusicEx(mapmusic.name, mapmusic.flags, true, mapmusic.position, 0, 0);
|
||||
S_ShowMusicCredit();
|
||||
}
|
||||
}
|
||||
@@ -2131,7 +2157,7 @@ static void Command_Tunes_f(void)
|
||||
if (!strcasecmp(tunearg, "-show"))
|
||||
{
|
||||
CONS_Printf(M_GetText("The current tune is: %s [track %d]\n"),
|
||||
mapmusname, (mapmusflags & MUSIC_TRACKMASK));
|
||||
mapmusic.name, (mapmusic.flags & MUSIC_TRACKMASK));
|
||||
return;
|
||||
}
|
||||
if (!strcasecmp(tunearg, "-none"))
|
||||
@@ -2159,19 +2185,19 @@ static void Command_Tunes_f(void)
|
||||
track = (UINT16)atoi(COM_Argv(2))-1;
|
||||
|
||||
if (tunenum)
|
||||
snprintf(mapmusname, 7, "%sM", G_BuildMapName(tunenum));
|
||||
snprintf(mapmusic.name, 7, "%sM", G_BuildMapName(tunenum));
|
||||
else
|
||||
strncpy(mapmusname, tunearg, 7);
|
||||
strncpy(mapmusic.name, tunearg, 7);
|
||||
|
||||
if (argc > 4)
|
||||
position = (UINT32)atoi(COM_Argv(4));
|
||||
|
||||
mapmusname[6] = 0;
|
||||
mapmusflags = (track & MUSIC_TRACKMASK);
|
||||
mapmusposition = position;
|
||||
mapmusresume = 0;
|
||||
mapmusic.name[6] = 0;
|
||||
mapmusic.flags = (track & MUSIC_TRACKMASK);
|
||||
mapmusic.position = position;
|
||||
mapmusic.resume = 0;
|
||||
|
||||
S_ChangeMusicEx(mapmusname, mapmusflags, true, mapmusposition, 0, 0);
|
||||
S_ChangeMusicEx(mapmusic.name, mapmusic.flags, true, mapmusic.position, 0, 0);
|
||||
|
||||
if (argc > 3)
|
||||
{
|
||||
@@ -2219,7 +2245,7 @@ static void Command_RestartMusic_f(void) //same as RestartAudio but only music g
|
||||
|
||||
static void Command_ShowMusicCredit_f(void)
|
||||
{
|
||||
const char *musname = music_name;
|
||||
const char *musname = music.name;
|
||||
|
||||
if (COM_Argc() > 1)
|
||||
{
|
||||
|
||||
+3
-2
@@ -71,7 +71,7 @@ extern consvar_t cv_birdmusic;
|
||||
extern consvar_t cv_keepmusic;
|
||||
extern consvar_t cv_skipintromusic;
|
||||
//extern consvar_t cv_ignoremusicchanges;
|
||||
extern boolean keepmusic;
|
||||
extern boolean keepmapmusic;
|
||||
extern boolean skipintromus;
|
||||
#define MUSICSTARTTIME (starttime + (TICRATE/2))
|
||||
|
||||
@@ -113,8 +113,9 @@ void S_ResetKeepAndSpecialMus(void);
|
||||
|
||||
void S_InitMapMusic(void);
|
||||
void S_StartMapMusic(void);
|
||||
void S_HandleReloadResetMusic(void);
|
||||
|
||||
void S_CheckMap(void);
|
||||
void S_KeepMusic(void);
|
||||
|
||||
// Stops music and restarts it from same position. Used for instant applying changes to amiga filters.
|
||||
void S_RestartMusic(void);
|
||||
|
||||
+13
-11
@@ -443,22 +443,20 @@ void SCR_CalculateFPS(void)
|
||||
|
||||
void SCR_DisplayTicRate(void)
|
||||
{
|
||||
const UINT8 *ticcntcolor = NULL;
|
||||
UINT32 cap = R_GetFramerateCap();
|
||||
UINT32 benchmark = (cap == 0) ? I_GetRefreshRate() : cap;
|
||||
INT32 x = 318;
|
||||
double fps = round(averageFPS);
|
||||
INT32 fpsflags = V_LocalTransFlag()|V_SNAPTOBOTTOM|V_SNAPTORIGHT;
|
||||
const char *fps_string;
|
||||
|
||||
INT32 ticcntcolor2 = 0;
|
||||
|
||||
|
||||
if (gamestate == GS_NULL)
|
||||
return;
|
||||
|
||||
// new kart counter
|
||||
if (cv_ticrate.value == 1 || cv_ticrate.value == 2)
|
||||
{
|
||||
const UINT8 *ticcntcolor = NULL;
|
||||
INT32 x = 318;
|
||||
|
||||
// draw "FPS"
|
||||
if (cv_ticrate.value == 1)
|
||||
V_DrawFixedPatch(306<<FRACBITS, 183<<FRACBITS, FRACUNIT, fpsflags, framecounter, R_GetTranslationColormap(TC_RAINBOW, SKINCOLOR_YELLOW, GTC_CACHE));
|
||||
@@ -493,6 +491,9 @@ void SCR_DisplayTicRate(void)
|
||||
}
|
||||
else if (cv_ticrate.value == 3 || cv_ticrate.value == 4) // kart v1.0/srb2 counter
|
||||
{
|
||||
const char *fps_string;
|
||||
INT32 ticcntcolor2 = 0;
|
||||
|
||||
if (fps > (benchmark - 5))
|
||||
ticcntcolor2 = V_GREENMAP;
|
||||
else if (fps < 20)
|
||||
@@ -502,7 +503,8 @@ void SCR_DisplayTicRate(void)
|
||||
fps_string = va("%d/%d\x82", (INT32)fps, cap);
|
||||
else
|
||||
fps_string = va("%d\x82", (INT32)fps);
|
||||
|
||||
|
||||
// draw "FPS"
|
||||
if (cv_ticrate.value == 3)
|
||||
V_DrawRightAlignedString(319, 181, V_YELLOWMAP|fpsflags, "FPS");
|
||||
|
||||
@@ -515,13 +517,13 @@ void SCR_DisplayTicRate(void)
|
||||
|
||||
void SCR_DisplayLocalPing(void)
|
||||
{
|
||||
UINT32 ping = playerpingtable[consoleplayer]; // consoleplayer's ping is everyone's ping in a splitnetgame :P
|
||||
UINT32 ping = playerpingtable[consoleplayer];
|
||||
INT32 pingflags = V_LocalTransFlag()|V_SNAPTOBOTTOM|V_SNAPTORIGHT;
|
||||
|
||||
if (cv_showping.value == 1 || (cv_showping.value == 2 && ping > servermaxping)) // only show 2 (warning) if our ping is at a bad level
|
||||
if (cv_showping.value == 1 || (cv_showping.value == 2 && ping > servermaxping)) // only show 2 (warning) if our ping is at a bad level
|
||||
{
|
||||
INT32 dispy = (cv_ticrate.value == 1) ? 165 : ((cv_ticrate.value == 2 || cv_ticrate.value == 4) ? 172 : ((cv_ticrate.value == 3) ? 163 : 181)); // absolute buttpain
|
||||
|
||||
HU_drawPing(308, dispy, ping, pingflags);
|
||||
|
||||
HU_drawPlayerPing(308, dispy, consoleplayer, pingflags); // consoleplayer's ping is everyone's ping in a splitnetgame :P
|
||||
}
|
||||
}
|
||||
+2
-1
@@ -44,7 +44,7 @@
|
||||
#define BASEVIDWIDTH 320 // NEVER CHANGE THIS! This is the original
|
||||
#define BASEVIDHEIGHT 200 // resolution of the graphics.
|
||||
|
||||
// max res for png capture; just here to prevent some crashes on very high resoltions; tho you should never go this high cause ogl allocs certain things with MAXVIDWIDTH and MAXVIDHEIGHT too Zzz...
|
||||
// max res for png capture; just here to prevent some crashes on very high resolutions; tho you should never go this high cause ogl allocs certain things with MAXVIDWIDTH and MAXVIDHEIGHT too Zzz...
|
||||
#define MAXPNGWIDTH 7680
|
||||
#define MAXPNGHEIGHT 4320
|
||||
|
||||
@@ -94,6 +94,7 @@ 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
|
||||
|
||||
+99
-24
@@ -20,12 +20,19 @@
|
||||
#include "../doomdef.h"
|
||||
#include "../m_argv.h"
|
||||
#include "../d_main.h"
|
||||
#include "../m_misc.h"/* path shit */
|
||||
#include "../i_system.h"
|
||||
|
||||
#ifdef __GNUC__
|
||||
#if defined (__GNUC__) || defined (__unix__)
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
#ifdef __unix__
|
||||
#include <errno.h>
|
||||
#endif
|
||||
|
||||
#include "time.h" // For log timestamps
|
||||
|
||||
#ifdef HAVE_SDL
|
||||
|
||||
#ifdef HAVE_TTF
|
||||
@@ -89,6 +96,93 @@ ChDirToExe (void)
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef LOGMESSAGES
|
||||
static void InitLogging(void)
|
||||
{
|
||||
const char *logdir = NULL;
|
||||
time_t my_time;
|
||||
struct tm * timeinfo;
|
||||
const char *format;
|
||||
const char *reldir;
|
||||
int left;
|
||||
boolean fileabs;
|
||||
#if defined (__unix__) || defined(__APPLE__) || defined (UNIXCOMMON)
|
||||
const char *link;
|
||||
#endif
|
||||
|
||||
logdir = D_Home();
|
||||
|
||||
my_time = time(NULL);
|
||||
timeinfo = localtime(&my_time);
|
||||
|
||||
if (M_CheckParm("-logfile") && M_IsNextParm())
|
||||
{
|
||||
format = M_GetNextParm();
|
||||
fileabs = M_IsPathAbsolute(format);
|
||||
}
|
||||
else
|
||||
{
|
||||
format = "log-%Y-%m-%d_%H-%M-%S.txt";
|
||||
fileabs = false;
|
||||
}
|
||||
|
||||
if (fileabs)
|
||||
{
|
||||
strftime(logfilename, sizeof logfilename, format, timeinfo);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (M_CheckParm("-logdir") && M_IsNextParm())
|
||||
reldir = M_GetNextParm();
|
||||
else
|
||||
reldir = "logs";
|
||||
|
||||
if (M_IsPathAbsolute(reldir))
|
||||
{
|
||||
left = snprintf(logfilename, sizeof logfilename,
|
||||
"%s"PATHSEP, reldir);
|
||||
}
|
||||
else
|
||||
#ifdef DEFAULTDIR
|
||||
if (logdir)
|
||||
{
|
||||
left = snprintf(logfilename, sizeof logfilename,
|
||||
"%s"PATHSEP DEFAULTDIR PATHSEP"%s"PATHSEP, logdir, reldir);
|
||||
}
|
||||
else
|
||||
#endif/*DEFAULTDIR*/
|
||||
{
|
||||
left = snprintf(logfilename, sizeof logfilename,
|
||||
"."PATHSEP"%s"PATHSEP, reldir);
|
||||
}
|
||||
|
||||
strftime(&logfilename[left], sizeof logfilename - left,
|
||||
format, timeinfo);
|
||||
}
|
||||
|
||||
M_MkdirEachUntil(logfilename,
|
||||
M_PathParts(logdir) - 1,
|
||||
M_PathParts(logfilename) - 1, 0755);
|
||||
|
||||
#if defined (__unix__) || defined(__APPLE__) || defined (UNIXCOMMON)
|
||||
logstream = fopen(logfilename, "w");
|
||||
#ifdef DEFAULTDIR
|
||||
if (logdir)
|
||||
link = va("%s/"DEFAULTDIR"/latest-log.txt", logdir);
|
||||
else
|
||||
#endif/*DEFAULTDIR*/
|
||||
link = "latest-log.txt";
|
||||
unlink(link);
|
||||
if (symlink(logfilename, link) == -1)
|
||||
{
|
||||
I_OutputMsg("Error symlinking latest-log.txt: %s\n", strerror(errno));
|
||||
}
|
||||
#else/*defined (__unix__) || defined(__APPLE__) || defined (UNIXCOMMON)*/
|
||||
logstream = fopen("latest-log.txt", "wt+");
|
||||
#endif/*defined (__unix__) || defined(__APPLE__) || defined (UNIXCOMMON)*/
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/** \brief The main function
|
||||
|
||||
@@ -107,7 +201,6 @@ int SDL_main(int argc, char **argv)
|
||||
int main(int argc, char **argv)
|
||||
#endif
|
||||
{
|
||||
const char *logdir = NULL;
|
||||
myargc = argc;
|
||||
myargv = argv; /// \todo pull out path to exe from this string
|
||||
|
||||
@@ -136,36 +229,18 @@ int main(int argc, char **argv)
|
||||
ChDirToExe();
|
||||
#endif
|
||||
|
||||
logdir = D_Home();
|
||||
|
||||
#ifdef LOGMESSAGES
|
||||
#ifdef DEFAULTDIR
|
||||
if (logdir)
|
||||
strcpy(logfilename, va("%s/"DEFAULTDIR"/log.txt",logdir));
|
||||
else
|
||||
#endif
|
||||
strcpy(logfilename, "./log.txt");
|
||||
|
||||
logstream = fopen(logfilename, "wt");
|
||||
#endif
|
||||
if (!M_CheckParm("-nolog"))
|
||||
InitLogging();
|
||||
#endif/*LOGMESSAGES*/
|
||||
|
||||
//I_OutputMsg("I_StartupSystem() ...\n");
|
||||
I_StartupSystem();
|
||||
#if defined (_WIN32)
|
||||
{
|
||||
#if 0 // just load the DLL
|
||||
p_IsDebuggerPresent pfnIsDebuggerPresent = (p_IsDebuggerPresent)GetProcAddress(GetModuleHandleA("kernel32.dll"), "IsDebuggerPresent");
|
||||
if ((!pfnIsDebuggerPresent || !pfnIsDebuggerPresent())
|
||||
#ifdef BUGTRAP
|
||||
&& !InitBugTrap()
|
||||
#endif
|
||||
)
|
||||
#endif
|
||||
{
|
||||
#ifdef DRMINGW
|
||||
ExcHndlInit();
|
||||
ExcHndlInit();
|
||||
#endif
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
+58
-352
@@ -201,6 +201,8 @@ static char returnWadPath[256];
|
||||
#include "../byteptr.h"
|
||||
#endif
|
||||
|
||||
INT32 numcontrollers = 0;
|
||||
|
||||
#ifdef HAVE_LIBBACKTRACE
|
||||
#include <backtrace.h>
|
||||
// TODO - move this to some header file instead
|
||||
@@ -420,12 +422,6 @@ static INT32 joystick_started[MAXSPLITSCREENPLAYERS] = {0, 0, 0, 0};
|
||||
*/
|
||||
SDLJoyInfo_t JoyInfo[MAXSPLITSCREENPLAYERS];
|
||||
|
||||
|
||||
#ifdef HAVE_TERMIOS
|
||||
static INT32 fdmouse2 = -1;
|
||||
static INT32 mouse2_started = 0;
|
||||
#endif
|
||||
|
||||
SDL_bool consolevent = SDL_FALSE;
|
||||
SDL_bool framebuffer = SDL_FALSE;
|
||||
|
||||
@@ -1170,21 +1166,21 @@ void I_ShutdownJoystick(UINT8 index)
|
||||
{
|
||||
INT32 i;
|
||||
event_t event;
|
||||
event.type=ev_keyup;
|
||||
event.type = ev_keyup;
|
||||
event.data2 = 0;
|
||||
event.data3 = 0;
|
||||
|
||||
lastjoybuttons[index] = lastjoyhats[index] = 0;
|
||||
|
||||
// emulate the up of all joystick buttons
|
||||
for (i=0;i<JOYBUTTONS;i++)
|
||||
for (i = 0; i < JOYBUTTONS; i++)
|
||||
{
|
||||
event.data1=KEY_JOY1+i;
|
||||
event.data1=KEY_JOY1 + i;
|
||||
D_PostEvent(&event);
|
||||
}
|
||||
|
||||
// emulate the up of all joystick hats
|
||||
for (i=0;i<JOYHATS*4;i++)
|
||||
for (i = 0; i < JOYHATS*4; i++)
|
||||
{
|
||||
event.data1=KEY_HAT1+i;
|
||||
D_PostEvent(&event);
|
||||
@@ -1192,7 +1188,7 @@ void I_ShutdownJoystick(UINT8 index)
|
||||
|
||||
// reset joystick position
|
||||
event.type = ev_joystick;
|
||||
for (i=0;i<JOYAXISSET; i++)
|
||||
for (i = 0; i < JOYAXISSET; i++)
|
||||
{
|
||||
event.data1 = i;
|
||||
D_PostEvent(&event);
|
||||
@@ -1483,17 +1479,15 @@ const char *I_GetJoyName(INT32 joyindex)
|
||||
return joyname;
|
||||
}
|
||||
|
||||
void I_GamepadRumble(INT32 device_id, UINT16 low_strength, UINT16 high_strength, UINT32 duration)
|
||||
void I_GamepadRumble(INT32 playernum, UINT16 low_strength, UINT16 high_strength, UINT32 duration)
|
||||
{
|
||||
#if !(SDL_VERSION_ATLEAST(2,0,14))
|
||||
(void)device_id;
|
||||
(void)playernum;
|
||||
(void)low_strength;
|
||||
(void)high_strength;
|
||||
(void)duration;
|
||||
#else
|
||||
I_Assert(device_id > 0); // Gamepad devices are always ID 1 or higher
|
||||
|
||||
SDL_GameController *controller = SDL_GameControllerFromInstanceID(device_id - 1);
|
||||
SDL_GameController *controller = JoyInfo[playernum].dev;
|
||||
if (controller == NULL)
|
||||
{
|
||||
return;
|
||||
@@ -1503,17 +1497,15 @@ void I_GamepadRumble(INT32 device_id, UINT16 low_strength, UINT16 high_strength,
|
||||
#endif
|
||||
}
|
||||
|
||||
void I_SetGamepadIndicatorColor(INT32 device_id, UINT8 red, UINT8 green, UINT8 blue)
|
||||
void I_SetGamepadIndicatorColor(INT32 playernum, UINT8 red, UINT8 green, UINT8 blue)
|
||||
{
|
||||
#if !(SDL_VERSION_ATLEAST(2,0,14))
|
||||
(void)device_id;
|
||||
(void)playernum;
|
||||
(void)red;
|
||||
(void)green;
|
||||
(void)blue;
|
||||
#else
|
||||
I_Assert(device_id > 0); // Gamepad devices are always ID 1 or higher
|
||||
|
||||
SDL_GameController *controller = SDL_GameControllerFromInstanceID(device_id - 1);
|
||||
SDL_GameController *controller = JoyInfo[playernum].dev;
|
||||
if (controller == NULL)
|
||||
{
|
||||
return;
|
||||
@@ -1651,337 +1643,6 @@ void I_UpdateMumble(const mobj_t *mobj, const listener_t listener)
|
||||
#undef WINMUMBLE
|
||||
#endif // NOMUMBLE
|
||||
|
||||
#ifdef HAVE_TERMIOS
|
||||
|
||||
void I_GetMouseEvents(void)
|
||||
{
|
||||
static UINT8 mdata[5];
|
||||
static INT32 i = 0,om2b = 0;
|
||||
INT32 di, j, mlp, button;
|
||||
event_t event;
|
||||
const INT32 mswap[8] = {0, 4, 1, 5, 2, 6, 3, 7};
|
||||
|
||||
if (!mouse2_started) return;
|
||||
for (mlp = 0; mlp < 20; mlp++)
|
||||
{
|
||||
for (; i < 5; i++)
|
||||
{
|
||||
di = read(fdmouse2, mdata+i, 1);
|
||||
if (di == -1) return;
|
||||
}
|
||||
if ((mdata[0] & 0xf8) != 0x80)
|
||||
{
|
||||
for (j = 1; j < 5; j++)
|
||||
if ((mdata[j] & 0xf8) == 0x80)
|
||||
for (i = 0; i < 5-j; i++) // shift
|
||||
mdata[i] = mdata[i+j];
|
||||
if (i < 5) continue;
|
||||
}
|
||||
else
|
||||
{
|
||||
button = mswap[~mdata[0] & 0x07];
|
||||
for (j = 0; j < MOUSEBUTTONS; j++)
|
||||
{
|
||||
if (om2b & (1<<j))
|
||||
{
|
||||
if (!(button & (1<<j))) //keyup
|
||||
{
|
||||
event.type = ev_keyup;
|
||||
event.data1 = KEY_2MOUSE1+j;
|
||||
D_PostEvent(&event);
|
||||
om2b ^= 1 << j;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (button & (1<<j))
|
||||
{
|
||||
event.type = ev_keydown;
|
||||
event.data1 = KEY_2MOUSE1+j;
|
||||
D_PostEvent(&event);
|
||||
om2b ^= 1 << j;
|
||||
}
|
||||
}
|
||||
}
|
||||
event.data2 = ((SINT8)mdata[1])+((SINT8)mdata[3]);
|
||||
event.data3 = ((SINT8)mdata[2])+((SINT8)mdata[4]);
|
||||
if (event.data2 && event.data3)
|
||||
{
|
||||
event.type = ev_mouse2;
|
||||
event.data1 = 0;
|
||||
D_PostEvent(&event);
|
||||
}
|
||||
}
|
||||
i = 0;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// I_ShutdownMouse2
|
||||
//
|
||||
static void I_ShutdownMouse2(void)
|
||||
{
|
||||
if (fdmouse2 != -1) close(fdmouse2);
|
||||
mouse2_started = 0;
|
||||
}
|
||||
#elif defined (_WIN32)
|
||||
|
||||
static HANDLE mouse2filehandle = INVALID_HANDLE_VALUE;
|
||||
|
||||
static void I_ShutdownMouse2(void)
|
||||
{
|
||||
event_t event;
|
||||
INT32 i;
|
||||
|
||||
if (mouse2filehandle == INVALID_HANDLE_VALUE)
|
||||
return;
|
||||
|
||||
SetCommMask(mouse2filehandle, 0);
|
||||
|
||||
EscapeCommFunction(mouse2filehandle, CLRDTR);
|
||||
EscapeCommFunction(mouse2filehandle, CLRRTS);
|
||||
|
||||
PurgeComm(mouse2filehandle, PURGE_TXABORT | PURGE_RXABORT |
|
||||
PURGE_TXCLEAR | PURGE_RXCLEAR);
|
||||
|
||||
CloseHandle(mouse2filehandle);
|
||||
|
||||
// emulate the up of all mouse buttons
|
||||
for (i = 0; i < MOUSEBUTTONS; i++)
|
||||
{
|
||||
event.type = ev_keyup;
|
||||
event.data1 = KEY_2MOUSE1+i;
|
||||
D_PostEvent(&event);
|
||||
}
|
||||
|
||||
mouse2filehandle = INVALID_HANDLE_VALUE;
|
||||
}
|
||||
|
||||
#define MOUSECOMBUFFERSIZE 256
|
||||
static INT32 handlermouse2x,handlermouse2y,handlermouse2buttons;
|
||||
|
||||
static void I_PoolMouse2(void)
|
||||
{
|
||||
UINT8 buffer[MOUSECOMBUFFERSIZE];
|
||||
COMSTAT ComStat;
|
||||
DWORD dwErrorFlags;
|
||||
DWORD dwLength;
|
||||
char dx,dy;
|
||||
|
||||
static INT32 bytenum;
|
||||
static UINT8 combytes[4];
|
||||
DWORD i;
|
||||
|
||||
ClearCommError(mouse2filehandle, &dwErrorFlags, &ComStat);
|
||||
dwLength = min(MOUSECOMBUFFERSIZE, ComStat.cbInQue);
|
||||
|
||||
if (dwLength <= 0)
|
||||
return;
|
||||
|
||||
if (!ReadFile(mouse2filehandle, buffer, dwLength, &dwLength, NULL))
|
||||
{
|
||||
CONS_Alert(CONS_WARNING, "%s", M_GetText("Read Error on secondary mouse port\n"));
|
||||
return;
|
||||
}
|
||||
|
||||
// parse the mouse packets
|
||||
for (i = 0; i < dwLength; i++)
|
||||
{
|
||||
if ((buffer[i] & 64)== 64)
|
||||
bytenum = 0;
|
||||
|
||||
if (bytenum < 4)
|
||||
combytes[bytenum] = buffer[i];
|
||||
bytenum++;
|
||||
|
||||
if (bytenum == 1)
|
||||
{
|
||||
handlermouse2buttons &= ~3;
|
||||
handlermouse2buttons |= ((combytes[0] & (32+16)) >> 4);
|
||||
}
|
||||
else if (bytenum == 3)
|
||||
{
|
||||
dx = (char)((combytes[0] & 3) << 6);
|
||||
dy = (char)((combytes[0] & 12) << 4);
|
||||
dx = (char)(dx + combytes[1]);
|
||||
dy = (char)(dy + combytes[2]);
|
||||
handlermouse2x+= dx;
|
||||
handlermouse2y+= dy;
|
||||
}
|
||||
else if (bytenum == 4) // fourth UINT8 (logitech mouses)
|
||||
{
|
||||
if (buffer[i] & 32)
|
||||
handlermouse2buttons |= 4;
|
||||
else
|
||||
handlermouse2buttons &= ~4;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void I_GetMouseEvents(void)
|
||||
{
|
||||
static UINT8 lastbuttons2 = 0; //mouse movement
|
||||
event_t event;
|
||||
|
||||
if (mouse2filehandle == INVALID_HANDLE_VALUE)
|
||||
return;
|
||||
|
||||
I_PoolMouse2();
|
||||
// post key event for buttons
|
||||
if (handlermouse2buttons != lastbuttons2)
|
||||
{
|
||||
INT32 i, j = 1, k;
|
||||
k = (handlermouse2buttons ^ lastbuttons2); // only changed bit to 1
|
||||
lastbuttons2 = (UINT8)handlermouse2buttons;
|
||||
|
||||
for (i = 0; i < MOUSEBUTTONS; i++, j <<= 1)
|
||||
if (k & j)
|
||||
{
|
||||
if (handlermouse2buttons & j)
|
||||
event.type = ev_keydown;
|
||||
else
|
||||
event.type = ev_keyup;
|
||||
event.data1 = KEY_2MOUSE1+i;
|
||||
D_PostEvent(&event);
|
||||
}
|
||||
}
|
||||
|
||||
if (handlermouse2x != 0 || handlermouse2y != 0)
|
||||
{
|
||||
event.type = ev_mouse2;
|
||||
event.data1 = 0;
|
||||
// event.data1 = buttons; // not needed
|
||||
event.data2 = handlermouse2x << 1;
|
||||
event.data3 = -handlermouse2y << 1;
|
||||
handlermouse2x = 0;
|
||||
handlermouse2y = 0;
|
||||
|
||||
D_PostEvent(&event);
|
||||
}
|
||||
}
|
||||
#else
|
||||
void I_GetMouseEvents(void){};
|
||||
#endif
|
||||
|
||||
//
|
||||
// I_StartupMouse2
|
||||
//
|
||||
void I_StartupMouse2(void)
|
||||
{
|
||||
#ifdef HAVE_TERMIOS
|
||||
struct termios m2tio;
|
||||
size_t i;
|
||||
INT32 dtr = -1, rts = -1;;
|
||||
I_ShutdownMouse2();
|
||||
if (cv_usemouse2.value == 0) return;
|
||||
if ((fdmouse2 = open(cv_mouse2port.string, O_RDONLY|O_NONBLOCK|O_NOCTTY)) == -1)
|
||||
{
|
||||
CONS_Printf(M_GetText("Error opening %s!\n"), cv_mouse2port.string);
|
||||
return;
|
||||
}
|
||||
tcflush(fdmouse2, TCIOFLUSH);
|
||||
m2tio.c_iflag = IGNBRK;
|
||||
m2tio.c_oflag = 0;
|
||||
m2tio.c_cflag = CREAD|CLOCAL|HUPCL|CS8|CSTOPB|B1200;
|
||||
m2tio.c_lflag = 0;
|
||||
m2tio.c_cc[VTIME] = 0;
|
||||
m2tio.c_cc[VMIN] = 1;
|
||||
tcsetattr(fdmouse2, TCSANOW, &m2tio);
|
||||
for (i = 0; i < strlen(cv_mouse2opt.string); i++)
|
||||
{
|
||||
if (toupper(cv_mouse2opt.string[i]) == 'D')
|
||||
{
|
||||
if (cv_mouse2opt.string[i+1] == '-')
|
||||
dtr = 0;
|
||||
else
|
||||
dtr = 1;
|
||||
}
|
||||
if (toupper(cv_mouse2opt.string[i]) == 'R')
|
||||
{
|
||||
if (cv_mouse2opt.string[i+1] == '-')
|
||||
rts = 0;
|
||||
else
|
||||
rts = 1;
|
||||
}
|
||||
if (dtr != -1 || rts != -1)
|
||||
{
|
||||
INT32 c;
|
||||
if (!ioctl(fdmouse2, TIOCMGET, &c))
|
||||
{
|
||||
if (!dtr)
|
||||
c &= ~TIOCM_DTR;
|
||||
else if (dtr > 0)
|
||||
c |= TIOCM_DTR;
|
||||
}
|
||||
if (!rts)
|
||||
c &= ~TIOCM_RTS;
|
||||
else if (rts > 0)
|
||||
c |= TIOCM_RTS;
|
||||
ioctl(fdmouse2, TIOCMSET, &c);
|
||||
}
|
||||
}
|
||||
mouse2_started = 1;
|
||||
I_AddExitFunc(I_ShutdownMouse2);
|
||||
#elif defined (_WIN32)
|
||||
DCB dcb;
|
||||
|
||||
if (mouse2filehandle != INVALID_HANDLE_VALUE)
|
||||
I_ShutdownMouse2();
|
||||
|
||||
if (cv_usemouse2.value == 0)
|
||||
return;
|
||||
|
||||
if (mouse2filehandle == INVALID_HANDLE_VALUE)
|
||||
{
|
||||
// COM file handle
|
||||
mouse2filehandle = CreateFileA(cv_mouse2port.string, GENERIC_READ | GENERIC_WRITE,
|
||||
0, // exclusive access
|
||||
NULL, // no security attrs
|
||||
OPEN_EXISTING,
|
||||
FILE_ATTRIBUTE_NORMAL,
|
||||
NULL);
|
||||
if (mouse2filehandle == INVALID_HANDLE_VALUE)
|
||||
{
|
||||
INT32 e = GetLastError();
|
||||
if (e == 5)
|
||||
CONS_Alert(CONS_ERROR, M_GetText("Can't open %s: Access denied\n"), cv_mouse2port.string);
|
||||
else
|
||||
CONS_Alert(CONS_ERROR, M_GetText("Can't open %s: error %d\n"), cv_mouse2port.string, e);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// getevent when somthing happens
|
||||
//SetCommMask(mouse2filehandle, EV_RXCHAR);
|
||||
|
||||
// buffers
|
||||
SetupComm(mouse2filehandle, MOUSECOMBUFFERSIZE, MOUSECOMBUFFERSIZE);
|
||||
|
||||
// purge buffers
|
||||
PurgeComm(mouse2filehandle, PURGE_TXABORT | PURGE_RXABORT
|
||||
| PURGE_TXCLEAR | PURGE_RXCLEAR);
|
||||
|
||||
// setup port to 1200 7N1
|
||||
dcb.DCBlength = sizeof (DCB);
|
||||
|
||||
GetCommState(mouse2filehandle, &dcb);
|
||||
|
||||
dcb.BaudRate = CBR_1200;
|
||||
dcb.ByteSize = 7;
|
||||
dcb.Parity = NOPARITY;
|
||||
dcb.StopBits = ONESTOPBIT;
|
||||
|
||||
dcb.fDtrControl = DTR_CONTROL_ENABLE;
|
||||
dcb.fRtsControl = RTS_CONTROL_ENABLE;
|
||||
|
||||
dcb.fBinary = TRUE;
|
||||
dcb.fParity = TRUE;
|
||||
|
||||
SetCommState(mouse2filehandle, &dcb);
|
||||
I_AddExitFunc(I_ShutdownMouse2);
|
||||
#endif
|
||||
}
|
||||
|
||||
//
|
||||
// I_Tactile
|
||||
//
|
||||
@@ -2502,6 +2163,48 @@ void I_RemoveExitFunc(void (*func)())
|
||||
}
|
||||
}
|
||||
|
||||
#if !(defined (__unix__) || defined(__APPLE__) || defined (UNIXCOMMON))
|
||||
static void Shittycopyerror(const char *name)
|
||||
{
|
||||
I_OutputMsg(
|
||||
"Error copying log file: %s: %s\n",
|
||||
name,
|
||||
strerror(errno)
|
||||
);
|
||||
}
|
||||
|
||||
static void Shittylogcopy(void)
|
||||
{
|
||||
char buf[8192];
|
||||
FILE *fp;
|
||||
size_t r;
|
||||
if (fseek(logstream, 0, SEEK_SET) == -1)
|
||||
{
|
||||
Shittycopyerror("fseek");
|
||||
}
|
||||
else if (( fp = fopen(logfilename, "wt") ))
|
||||
{
|
||||
while (( r = fread(buf, 1, sizeof buf, logstream) ))
|
||||
{
|
||||
if (fwrite(buf, 1, r, fp) < r)
|
||||
{
|
||||
Shittycopyerror("fwrite");
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (ferror(logstream))
|
||||
{
|
||||
Shittycopyerror("fread");
|
||||
}
|
||||
fclose(fp);
|
||||
}
|
||||
else
|
||||
{
|
||||
Shittycopyerror(logfilename);
|
||||
}
|
||||
}
|
||||
#endif/*!(defined (__unix__) || defined(__APPLE__) || defined (UNIXCOMMON))*/
|
||||
|
||||
//
|
||||
// Closes down everything. This includes restoring the initial
|
||||
// palette and video mode, and removing whatever mouse, keyboard, and
|
||||
@@ -2524,6 +2227,9 @@ void I_ShutdownSystem(void)
|
||||
if (logstream)
|
||||
{
|
||||
I_OutputMsg("I_ShutdownSystem(): end of logstream.\n");
|
||||
#if !(defined (__unix__) || defined(__APPLE__) || defined (UNIXCOMMON))
|
||||
Shittylogcopy();
|
||||
#endif
|
||||
fclose(logstream);
|
||||
logstream = NULL;
|
||||
}
|
||||
|
||||
+65
-83
@@ -417,13 +417,15 @@ static INT32 Impl_SDL_Scancode_To_Keycode(SDL_Scancode code)
|
||||
}
|
||||
|
||||
// Get the equivalent ASCII (Unicode?) character for a keypress.
|
||||
static INT32 GetTypedChar(SDL_Scancode code, SDL_Keysym *sym)
|
||||
static INT32 GetTypedChar(SDL_Keysym keysym)
|
||||
{
|
||||
SDL_Event next_event;
|
||||
boolean Text_Input_Only = (chat_on || CON_Ready() || (menu_text_input && menuactive)); //only use this this if on chat or console or the current menu wants inputs from us (except if its the control setup menu ig)
|
||||
SDL_Keycode keycode = keysym.sym;
|
||||
SDL_Scancode scancode = keysym.scancode;
|
||||
const boolean Text_Input_Only = (chat_on || CON_Ready() || (menu_text_input && menuactive)); // only use this this if on chat or console or the current menu wants inputs from us (except if its the control setup menu ig)
|
||||
|
||||
// Special cases, where we always return a fixed value.
|
||||
switch (sym->sym)
|
||||
switch (keycode)
|
||||
{
|
||||
case SDLK_BACKSPACE: return KEY_BACKSPACE;
|
||||
case SDLK_RETURN: return KEY_ENTER;
|
||||
@@ -440,13 +442,13 @@ static INT32 GetTypedChar(SDL_Scancode code, SDL_Keysym *sym)
|
||||
}
|
||||
}
|
||||
|
||||
return Impl_SDL_Scancode_To_Keycode(code); //fallback
|
||||
return Impl_SDL_Scancode_To_Keycode(scancode); // fallback
|
||||
}
|
||||
|
||||
static INT32 Impl_SDL_Keysym_To_Keycode(SDL_Keysym keysym)
|
||||
{
|
||||
SDL_Keycode keycode= keysym.sym;
|
||||
SDL_Scancode scancode= keysym.scancode;
|
||||
SDL_Keycode keycode = keysym.sym;
|
||||
SDL_Scancode scancode = keysym.scancode;
|
||||
|
||||
if (keycode >= SDLK_a && keycode <= SDLK_z)
|
||||
{
|
||||
@@ -457,15 +459,14 @@ static INT32 Impl_SDL_Keysym_To_Keycode(SDL_Keysym keysym)
|
||||
{
|
||||
return KEY_F1 + (keycode - SDLK_F1);
|
||||
}
|
||||
if(scancode == SDL_SCANCODE_APOSTROPHE)
|
||||
|
||||
switch (scancode)
|
||||
{
|
||||
return KEY_FR_U_GRAVE;
|
||||
}
|
||||
switch(scancode){
|
||||
case SDL_SCANCODE_APOSTROPHE: return KEY_FR_U_GRAVE;
|
||||
case SDL_SCANCODE_LEFTBRACKET: return '^';
|
||||
default: break;
|
||||
}
|
||||
|
||||
switch (keycode)
|
||||
{
|
||||
// F11 and F12 are separated from the rest of the function keys
|
||||
@@ -658,11 +659,6 @@ static void VID_Command_Mode_f (void)
|
||||
setmodeneeded = modenum+1; // request vid mode change
|
||||
}
|
||||
|
||||
static inline void SDLJoyRemap(event_t *event)
|
||||
{
|
||||
(void)event;
|
||||
}
|
||||
|
||||
static INT32 SDLJoyAxis(const Sint16 axis, evtype_t which)
|
||||
{
|
||||
// -32768 to 32767
|
||||
@@ -858,6 +854,7 @@ static void Impl_HandleWindowEvent(SDL_WindowEvent evt)
|
||||
static void Impl_HandleKeyboardEvent(SDL_KeyboardEvent evt, Uint32 type)
|
||||
{
|
||||
event_t event;
|
||||
|
||||
if (type == SDL_KEYUP)
|
||||
{
|
||||
event.type = ev_keyup;
|
||||
@@ -871,12 +868,18 @@ static void Impl_HandleKeyboardEvent(SDL_KeyboardEvent evt, Uint32 type)
|
||||
return;
|
||||
}
|
||||
|
||||
if (cv_keyboardlayout.value == 2)
|
||||
event.data1 = GetTypedChar(evt.keysym.scancode, &evt.keysym);
|
||||
else if (cv_keyboardlayout.value == 3)
|
||||
event.data1 = Impl_SDL_Keysym_To_Keycode(evt.keysym);
|
||||
else
|
||||
event.data1 = Impl_SDL_Scancode_To_Keycode(evt.keysym.scancode);
|
||||
switch (cv_keyboardlayout.value)
|
||||
{
|
||||
case 2: // "native"
|
||||
event.data1 = GetTypedChar(evt.keysym);
|
||||
break;
|
||||
case 3: // AZERTY
|
||||
event.data1 = Impl_SDL_Keysym_To_Keycode(evt.keysym);
|
||||
break;
|
||||
default:
|
||||
event.data1 = Impl_SDL_Scancode_To_Keycode(evt.keysym.scancode);
|
||||
break;
|
||||
}
|
||||
|
||||
if (event.data1) D_PostEvent(&event);
|
||||
}
|
||||
@@ -926,8 +929,6 @@ static void Impl_HandleMouseButtonEvent(SDL_MouseButtonEvent evt, Uint32 type)
|
||||
{
|
||||
event_t event;
|
||||
|
||||
SDL_memset(&event, 0, sizeof(event_t));
|
||||
|
||||
// Ignore the event if the mouse is not actually focused on the window.
|
||||
// This can happen if you used the mouse to restore keyboard focus;
|
||||
// this apparently makes a mouse button down event but not a mouse button up event,
|
||||
@@ -939,6 +940,8 @@ static void Impl_HandleMouseButtonEvent(SDL_MouseButtonEvent evt, Uint32 type)
|
||||
/// \todo inputEvent.button.which
|
||||
if (USE_MOUSEINPUT)
|
||||
{
|
||||
SDL_memset(&event, 0, sizeof(event_t));
|
||||
|
||||
if (type == SDL_MOUSEBUTTONUP)
|
||||
{
|
||||
event.type = ev_keyup;
|
||||
@@ -969,26 +972,29 @@ static void Impl_HandleMouseWheelEvent(SDL_MouseWheelEvent evt)
|
||||
{
|
||||
event_t event;
|
||||
|
||||
SDL_memset(&event, 0, sizeof(event_t));
|
||||
if (USE_MOUSEINPUT)
|
||||
{
|
||||
SDL_memset(&event, 0, sizeof(event_t));
|
||||
|
||||
if (evt.y > 0)
|
||||
{
|
||||
event.data1 = KEY_MOUSEWHEELUP;
|
||||
event.type = ev_keydown;
|
||||
}
|
||||
if (evt.y < 0)
|
||||
{
|
||||
event.data1 = KEY_MOUSEWHEELDOWN;
|
||||
event.type = ev_keydown;
|
||||
}
|
||||
if (evt.y == 0)
|
||||
{
|
||||
event.data1 = 0;
|
||||
event.type = ev_keyup;
|
||||
}
|
||||
if (event.type == ev_keyup || event.type == ev_keydown)
|
||||
{
|
||||
D_PostEvent(&event);
|
||||
if (evt.y > 0)
|
||||
{
|
||||
event.data1 = KEY_MOUSEWHEELUP;
|
||||
event.type = ev_keydown;
|
||||
}
|
||||
if (evt.y < 0)
|
||||
{
|
||||
event.data1 = KEY_MOUSEWHEELDOWN;
|
||||
event.type = ev_keydown;
|
||||
}
|
||||
if (evt.y == 0)
|
||||
{
|
||||
event.data1 = 0;
|
||||
event.type = ev_keyup;
|
||||
}
|
||||
if (event.type == ev_keyup || event.type == ev_keydown)
|
||||
{
|
||||
D_PostEvent(&event);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1101,6 +1107,7 @@ static void Impl_HandleControllerButtonEvent(SDL_ControllerButtonEvent evt, Uint
|
||||
event.data1 = KEY_4JOY1;
|
||||
}
|
||||
else return;
|
||||
|
||||
if (type == SDL_CONTROLLERBUTTONUP)
|
||||
{
|
||||
event.type = ev_keyup;
|
||||
@@ -1110,13 +1117,13 @@ static void Impl_HandleControllerButtonEvent(SDL_ControllerButtonEvent evt, Uint
|
||||
event.type = ev_keydown;
|
||||
}
|
||||
else return;
|
||||
|
||||
if (evt.button < JOYBUTTONS)
|
||||
{
|
||||
event.data1 += evt.button;
|
||||
}
|
||||
else return;
|
||||
|
||||
SDLJoyRemap(&event);
|
||||
if (event.type != ev_console) D_PostEvent(&event);
|
||||
}
|
||||
|
||||
@@ -1238,7 +1245,10 @@ void I_GetEvent(void)
|
||||
////////////////////////////////////////////////////////////
|
||||
|
||||
for (i = 0; i < MAXSPLITSCREENPLAYERS; i++)
|
||||
{
|
||||
I_InitJoystick(i);
|
||||
G_SetPlayerGamepadIndicatorColor(i, G_GetSkinColor(i)); // gotta update the controller led again on reconnect
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////
|
||||
|
||||
@@ -1249,6 +1259,8 @@ void I_GetEvent(void)
|
||||
if (currentMenu == &OP_JoystickSetDef)
|
||||
M_SetupJoystickMenu(0);
|
||||
|
||||
numcontrollers = I_NumJoys();
|
||||
|
||||
for (i = 0; i < MAXSPLITSCREENPLAYERS; i++)
|
||||
{
|
||||
if (JoyInfo[i].dev == newcontroller)
|
||||
@@ -1308,6 +1320,9 @@ void I_GetEvent(void)
|
||||
// update the menu
|
||||
if (currentMenu == &OP_JoystickSetDef)
|
||||
M_SetupJoystickMenu(0);
|
||||
|
||||
numcontrollers = I_NumJoys();
|
||||
|
||||
break;
|
||||
case SDL_DROPFILE:
|
||||
dropped_filedir = evt.drop.file;
|
||||
@@ -1376,8 +1391,6 @@ void I_OsPolling(void)
|
||||
I_GetJoystickEvents(i);
|
||||
}
|
||||
|
||||
I_GetMouseEvents();
|
||||
|
||||
I_GetEvent();
|
||||
|
||||
mod = SDL_GetModState();
|
||||
@@ -1418,37 +1431,6 @@ void I_UpdateNoBlit(void)
|
||||
exposevideo = SDL_FALSE;
|
||||
}
|
||||
|
||||
// I_SkipFrame
|
||||
//
|
||||
// Returns true if it thinks we can afford to skip this frame
|
||||
// from PrBoom's src/SDL/i_video.c
|
||||
static inline boolean I_SkipFrame(void)
|
||||
{
|
||||
#if 1
|
||||
// While I fixed the FPS counter bugging out with this,
|
||||
// I actually really like being able to pause and
|
||||
// use perfstats to measure rendering performance
|
||||
// without game logic changes.
|
||||
return false;
|
||||
#else
|
||||
static boolean skip = false;
|
||||
|
||||
skip = !skip;
|
||||
|
||||
switch (gamestate)
|
||||
{
|
||||
case GS_LEVEL:
|
||||
if (!paused)
|
||||
return false;
|
||||
/* FALLTHRU */
|
||||
case GS_WAITINGPLAYERS:
|
||||
return skip; // Skip odd frames
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
//
|
||||
// I_FinishUpdate
|
||||
//
|
||||
@@ -1461,14 +1443,14 @@ void I_FinishUpdate(void)
|
||||
|
||||
SCR_CalculateFPS();
|
||||
|
||||
if (I_SkipFrame())
|
||||
return;
|
||||
if (st_overlay)
|
||||
{
|
||||
if (cv_ticrate.value)
|
||||
SCR_DisplayTicRate();
|
||||
|
||||
if (cv_ticrate.value && st_overlay)
|
||||
SCR_DisplayTicRate();
|
||||
|
||||
if (cv_showping.value && netgame && consoleplayer != serverplayer && st_overlay)
|
||||
SCR_DisplayLocalPing();
|
||||
if (cv_showping.value && ((netgame && consoleplayer != serverplayer) || (simulated_lag != 0 && consoleplayer == serverplayer && Playing())))
|
||||
SCR_DisplayLocalPing();
|
||||
}
|
||||
|
||||
#ifdef HAVE_DISCORDRPC
|
||||
if (discordRequestList != NULL)
|
||||
|
||||
Loaded 100 of 109 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user