stjr/SRB2
0
0
Fork 0
mirror of https://git.do.srb2.org/STJr/SRB2.git synced 2024-11-15 01:01:33 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge branch 'next' into raise-skin-limit

Browse source
This commit is contained in:
Logan Aerl Arias 2024-01-01 16:43:28 -05:00
commit 8009b945f7
96 changed files with 4700 additions and 2987 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
.gitattributes vendored
View file

@ -10,6 +10,7 @@
/src/Make*.cfg text=auto
/src/CMakeLists.txt text=auto
*.mk -whitespace text=auto
/comptime.sh text eol=lf
# Windows EOL
*.cs -crlf -whitespace
*.bat -crlf -whitespace

157
.gitlab-ci.yml
View file

@ -3,7 +3,7 @@ variables:
GIT_CLONE_PATH: $CI_BUILDS_DIR/$CI_CONCURRENT_ID/$CI_PROJECT_PATH
default:
image: debian:stable-slim
image: git.do.srb2.org:5050/stjr/srb2ci/srb2ci:stable
cache:
- key: ccache-$CI_PROJECT_PATH_SLUG-$CI_JOB_NAME_SLUG
@ -19,6 +19,11 @@ default:
- apt-cache
unprotect: true
- key: apk-$CI_JOB_IMAGE
paths:
- apk-cache
unprotect: true
before_script:
- - |
# debconf
@ -167,6 +172,10 @@ Debian testing GCC:
allow_failure: true
artifacts:
paths:
- "bin/"
- "src/comptime.h"
expose_as: "testing-gcc"
name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-testing-gcc"
variables:
@ -401,6 +410,10 @@ Debian stable Clang:
allow_failure: true
artifacts:
paths:
- "bin/"
- "src/comptime.h"
expose_as: "clang"
name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-clang"
variables:
@ -442,6 +455,10 @@ Debian stable musl:
allow_failure: true
artifacts:
paths:
- "bin/"
- "src/comptime.h"
expose_as: "musl"
name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-musl"
variables:
@ -481,6 +498,10 @@ Debian testing Clang:
image: debian:testing-slim
artifacts:
paths:
- "bin/"
- "src/comptime.h"
expose_as: "testing-clang"
name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-testing-clang"
variables:
@ -497,9 +518,143 @@ Debian testing musl:
image: debian:testing-slim
artifacts:
paths:
- "bin/"
- "src/comptime.h"
expose_as: "testing-musl"
name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-testing-musl"
variables:
CC: musl-gcc
LDD: musl-ldd
LDFLAGS: -Wl,-fuse-ld=gold
Alpine 3 GCC:
stage: build
when: on_success
image: alpine:3
allow_failure: true
artifacts:
paths:
- "bin/"
- "src/comptime.h"
expose_as: "Apline-3"
name: "$CI_PROJECT_PATH_SLUG-$CI_COMMIT_REF_SLUG-$CI_COMMIT_SHORT_SHA-Apline-3"
before_script:
- - |
# apk_cache
echo -e "\e[0Ksection_start:`date +%s`:apk_cache[collapsed=true]\r\e[0KUpdating APK listing"
- export APK_CACHE_DIR=`pwd`/apk-cache
- mkdir --parents --verbose $APK_CACHE_DIR/
- ln -sf /etc/apk/cache $APK_CACHE_DIR
- |
# apk_cache
echo -e "\e[0Ksection_end:`date +%s`:apk_cache\r\e[0K"
- - |
# apk_update
echo -e "\e[0Ksection_start:`date +%s`:apk_update[collapsed=true]\r\e[0KUpdating APK listing"
- apk update
- |
# apk_update
echo -e "\e[0Ksection_end:`date +%s`:apk_update\r\e[0K"
- - |
# apk_upgrade
echo -e "\e[0Ksection_start:`date +%s`:apk_upgrade[collapsed=true]\r\e[0KUpdating existing packages"
- apk upgrade
- |
# apk_update
echo -e "\e[0Ksection_end:`date +%s`:apk_upgrade\r\e[0K"
- - |
# apk_common
echo -e "\e[0Ksection_start:`date +%s`:apk_common[collapsed=true]\r\e[0KInstalling common packages"
- apk add make git ccache nasm
- |
# apk_common
echo -e "\e[0Ksection_end:`date +%s`:apk_common\r\e[0K"
- - |
# ccache_config
echo -e "\e[0Ksection_start:`date +%s`:ccache_config[collapsed=true]\r\e[0KSetting up ccache config"
- mkdir --parents --verbose ~/.ccache/
- touch ~/.ccache/ccache.conf
- |
# cache.conf
echo Adding ccache configution option
- |
# base_dir
echo base_dir = $PWD | tee -a ~/.ccache/ccache.conf
- |
# cache_dir
echo cache_dir = $PWD/ccache | tee -a ~/.ccache/ccache.conf
- |
# compiler_check
echo compiler_check = content | tee -a ~/.ccache/ccache.conf
- |
# stats_log
echo stats_log = $PWD/ccache_statslog | tee -a ~/.ccache/ccache.conf
- |
# max_size
echo max_size = 50M | tee -a ~/.ccache/ccache.conf
- |
# ccache_config
echo -e "\e[0Ksection_end:`date +%s`:ccache_config\r\e[0K"
- - |
# cache_reset
echo -e "\e[0Ksection_start:`date +%s`:ccache_reset[collapsed=true]\r\e[0KResetting ccache statistics"
- ccache --zero-stats
- ccache --show-stats
- |
# ccache_reset
echo -e "\e[0Ksection_end:`date +%s`:ccache_reset\r\e[0K"
script:
- - |
# apk_toolchain
echo -e "\e[0Ksection_start:`date +%s`:apk_toolchain[collapsed=true]\r\e[0KInstalling toolchain packages"
- apk add gcc
- |
# apk_toolchain
echo -e "\e[0Ksection_end:`date +%s`:apk_toolchain\r\e[0K"
- - |
# apk_development
echo -e "\e[0Ksection_start:`date +%s`:apk_development[collapsed=true]\r\e[0KInstalling development packages"
- apk add musl-dev sdl2_mixer-dev libpng-dev curl-dev libgme-dev libopenmpt-dev
- |
# apk_development
echo -e "\e[0Ksection_end:`date +%s`:apk_development\r\e[0K"
- - |
# make
echo -e "\e[0Ksection_start:`date +%s`:make[collapsed=false]\r\e[0KCompiling SRB2"
- make --directory=src --keep-going CCACHE=1 ERRORMODE=1 NONX86=1 NOEXECINFO=1 || make --directory=src --keep-going CCACHE=1 ERRORMODE=1 NONX86=1 NOEXECINFO=1
- |
# make
echo -e "\e[0Ksection_end:`date +%s`:make\r\e[0K"
after_script:
- - |
# apk_clean
echo -e "\e[0Ksection_start:`date +%s`:apk_clean[collapsed=true]\r\e[0KCleaning of unneeded APK packages"
- apk cache clean
- |
# apk_clean
echo -e "\e[0Ksection_end:`date +%s`:apk_clean\r\e[0K"
- - |
# ccache_stats
echo -e "\e[0Ksection_start:`date +%s`:ccache_stats[collapsed=true]\r\e[0Kccache statistics:"
- ccache --show-stats --verbose
- ccache --show-log-stats --verbose
- |
# ccahe_stats
echo -e "\e[0Ksection_end:`date +%s`:ccache_stats\r\e[0K"

1
CMakeLists.txt
View file

@ -75,6 +75,7 @@ option(SRB2_CONFIG_ERRORMODE "Compile C code with warnings treated as errors." O
option(SRB2_CONFIG_DEBUGMODE "Compile with PARANOIA, ZDEBUG, RANGECHECK and PACKETDROP defined." OFF)
option(SRB2_CONFIG_MOBJCONSISTANCY "Compile with MOBJCONSISTANCY defined." OFF)
option(SRB2_CONFIG_PACKETDROP "Compile with PACKETDROP defined." OFF)
option(SRB2_CONFIG_EXECINFO "Enable stack trace dump support." ON)
option(SRB2_CONFIG_ZDEBUG "Compile with ZDEBUG defined." OFF)
# SRB2_CONFIG_PROFILEMODE is probably superceded by some CMake setting.
option(SRB2_CONFIG_PROFILEMODE "Compile for profiling (GCC only)." OFF)

7
comptime.bat
View file

@ -1,6 +1,7 @@
@echo off
set BRA=Unknown
set REV=illegal
set GL1=Dummy
copy nul: /b +%1\comptime.c tmp.$$$ > nul
move tmp.$$$ %1\comptime.c > nul
@ -13,8 +14,9 @@ goto filwri
:gitrev
set GIT=%2
if "%GIT%"=="" set GIT=git
for /f "usebackq" %%s in (`%GIT% rev-parse --abbrev-ref HEAD`) do @set BRA=%%s
for /f "usebackq" %%s in (`%GIT% rev-parse HEAD`) do @set REV=%%s
for /f "tokens=* usebackq" %%s in (`%GIT% rev-parse --abbrev-ref HEAD`) do @set BRA=%%s
for /f "tokens=* usebackq" %%s in (`%GIT% rev-parse HEAD`) do @set REV=%%s
for /f "tokens=* usebackq" %%s in (`%GIT% log -1 --format^=%%f`) do @set GL1=%%s
set REV=%REV:~0,8%
goto filwri
@ -30,3 +32,4 @@ echo // by the %0 batch file >> %1\comptime.h
echo // >> %1\comptime.h
echo const char* compbranch = "%BRA%"; >> %1\comptime.h
echo const char* comprevision = "%REV%"; >> %1\comptime.h
echo const char* compnote = "%GL1%"; >> %1\comptime.h

8
comptime.sh
View file

@ -12,24 +12,26 @@ version() {
//
const char* compbranch = "$1";
const char* comprevision = "$2";
const char* compnote = "$3";
EOF
}
versiongit() {
gitbranch="$(git rev-parse --abbrev-ref HEAD)"
gitversion="$(git rev-parse HEAD | cut -c -8)"
version "$gitbranch" "$gitversion";
gitsubject="$(git log -1 --format=%f)"
version "$gitbranch" "$gitversion" "$gitsubject";
exit 0
}
versionsvn() {
svnrevision="$(svnversion -n "$1")"
version "Subversion" "r$svnrevision";
version "Subversion" "r$svnrevision" "dummy";
exit 0
}
versionfake() {
version "Unknown" "illegal";
version "Unknown" "illegal" "dummy";
}
compversion() {

9
src/CMakeLists.txt
View file

@ -254,6 +254,7 @@ target_compile_options(SRB2SDL2 PRIVATE
-Winline
-Wformat-y2k
-Wformat-security
-fwrapv
$<$<VERSION_LESS:$<C_COMPILER_VERSION>,2.9.5>:
-Wno-div-by-zero
@ -277,7 +278,7 @@ target_compile_options(SRB2SDL2 PRIVATE
$<$<VERSION_GREATER_EQUAL:$<C_COMPILER_VERSION>,4.5.0>:
-Wlogical-op
-Wno-error=array-bounds
#-Wno-error=array-bounds
>
$<$<VERSION_GREATER_EQUAL:$<C_COMPILER_VERSION>,4.6.0>:
@ -323,6 +324,7 @@ target_compile_options(SRB2SDL2 PRIVATE
-Wno-error=non-literal-null-conversion
-Wno-error=constant-conversion
-Wno-error=unused-but-set-variable
-fwrapv
>
# C, MSVC
@ -376,6 +378,11 @@ endif()
if(SRB2_CONFIG_PACKETDROP)
target_compile_definitions(SRB2SDL2 PRIVATE -DPACKETDROP)
endif()
if(SRB2_CONFIG_EXECINFO)
else()
target_compile_definitions(SRB2SDL2 PRIVATE -DNOEXECINFO)
message(STATUS "You have disabled stack trace dump support")
endif()
if(SRB2_CONFIG_ZDEBUG)
target_compile_definitions(SRB2SDL2 PRIVATE -DZDEBUG)
endif()

3
src/Makefile
View file

@ -66,6 +66,7 @@
# NOPOSTPROCESSING=1 - ?
# MOBJCONSISTANCY=1 - ??
# PACKETDROP=1 - ??
# NOEXECINFO=1 - Disable stack trace dump support
# DEBUGMODE=1 - Enable various debugging capabilities.
# Also disables optimizations.
# NOZLIB=1 - Disable some compression capability. Implies
@ -164,7 +165,7 @@ sources:=
makedir:=../make
# -DCOMPVERSION: flag to use comptime.h
opts:=-DCOMPVERSION -g
opts:=-DCOMPVERSION -g -fwrapv
libs:=
# This is a list of variables names, of which if defined,

2
src/Makefile.d/features.mk
View file

@ -5,7 +5,7 @@
passthru_opts+=\
NO_IPV6 NOHW NOMD5 NOPOSTPROCESSING\
MOBJCONSISTANCY PACKETDROP ZDEBUG\
HAVE_MINIUPNPC\
HAVE_MINIUPNPC NOEXECINFO\
# build with debugging information
ifdef DEBUGMODE

2
src/Makefile.d/versions.mk
View file

@ -116,7 +116,7 @@ ifdef GCC43
#WFLAGS+=-Wno-error=clobbered
endif
ifdef GCC44
WFLAGS+=-Wno-error=array-bounds
#WFLAGS+=-Wno-error=array-bounds
endif
ifdef GCC46
WFLAGS+=-Wno-error=suggest-attribute=noreturn

7
src/b_bot.c
View file

@ -584,11 +584,11 @@ void B_RespawnBot(INT32 playernum)
P_SetOrigin(tails, x, y, z);
if (player->charability == CA_FLY)
{
P_SetPlayerMobjState(tails, S_PLAY_FLY);
P_SetMobjState(tails, S_PLAY_FLY);
tails->player->powers[pw_tailsfly] = (UINT16)-1;
}
else
P_SetPlayerMobjState(tails, S_PLAY_FALL);
P_SetMobjState(tails, S_PLAY_FALL);
P_SetScale(tails, sonic->scale);
tails->destscale = sonic->destscale;
}
@ -614,6 +614,9 @@ void B_HandleFlightIndicator(player_t *player)
// otherwise, spawn it
P_SetTarget(&tails->hnext, P_SpawnMobjFromMobj(tails, 0, 0, 0, MT_OVERLAY));
if (P_MobjWasRemoved(tails->hnext))
return; // we can't spawn one, so it can't exist
P_SetTarget(&tails->hnext->target, tails);
P_SetTarget(&tails->hnext->hprev, tails);
P_SetMobjState(tails->hnext, S_FLIGHTINDICATOR);

23
src/blua/lbaselib.c
View file

@ -275,18 +275,36 @@ static int luaB_dofile (lua_State *L) {
int n = lua_gettop(L);
if (!W_FileHasFolders(wadfiles[numwadfiles - 1]))
luaL_error(L, "dofile() only works with PK3 files");
luaL_error(L, "dofile() only works with PK3 files and folders");
snprintf(fullfilename, sizeof(fullfilename), "Lua/%s", filename);
lumpnum = W_CheckNumForFullNamePK3(fullfilename, numwadfiles - 1, 0);
if (lumpnum == INT16_MAX)
luaL_error(L, "can't find script " LUA_QS, fullfilename);
LUA_LoadLump(numwadfiles - 1, lumpnum, false);
LUA_DoLump(numwadfiles - 1, lumpnum, false);
return lua_gettop(L) - n;
}
// Edited to load PK3 entries instead
static int luaB_loadfile (lua_State *L) {
const char *filename = luaL_checkstring(L, 1);
char fullfilename[256];
UINT16 lumpnum;
if (!W_FileHasFolders(wadfiles[numwadfiles - 1]))
luaL_error(L, "loadfile() only works with PK3 files and folders");
snprintf(fullfilename, sizeof(fullfilename), "Lua/%s", filename);
lumpnum = W_CheckNumForFullNamePK3(fullfilename, numwadfiles - 1, 0);
if (lumpnum == INT16_MAX)
luaL_error(L, "can't find script " LUA_QS, fullfilename);
LUA_LoadLump(numwadfiles - 1, lumpnum);
return 1;
}
static int luaB_assert (lua_State *L) {
luaL_checkany(L, 1);
@ -406,6 +424,7 @@ static const luaL_Reg base_funcs[] = {
{"collectgarbage", luaB_collectgarbage},
{"error", luaB_error},
{"dofile", luaB_dofile},
{"loadfile", luaB_loadfile},
{"gcinfo", luaB_gcinfo},
{"getfenv", luaB_getfenv},
{"getmetatable", luaB_getmetatable},

67
src/console.c
View file

@ -220,13 +220,16 @@ static char *bindtable[NUMINPUTS];
static void CONS_Bind_f(void)
{
size_t na;
char *newcmd;
//size_t newlen = 0;
unsigned int i;
INT32 key;
na = COM_Argc();
if (na != 2 && na != 3)
if (na < 2)
{
CONS_Printf(M_GetText("bind <keyname> [<command>]: create shortcut keys to command(s)\n"));
CONS_Printf(M_GetText("bind <keyname> [<command>] [<arg1>] [...]: create shortcut keys to command(s)\n"));
CONS_Printf("\x82%s", M_GetText("Bind table :\n"));
na = 0;
for (key = 0; key < NUMINPUTS; key++)
@ -250,8 +253,36 @@ static void CONS_Bind_f(void)
Z_Free(bindtable[key]);
bindtable[key] = NULL;
if (na == 3)
bindtable[key] = Z_StrDup(COM_Argv(2));
if (na < 3)
return;
for (i = 2; i < na; ++i)
{
const char *arg = COM_Argv(i);
// on the second iteration, and after
if (i > 2)
{
size_t newlen = strlen(bindtable[key]) + strlen(arg) + 1; // new length, allow space for ' ' and '\0'
size_t curpos = newcmd - bindtable[key]; // offset from newcmd to original pointer
newcmd = bindtable[key] = Z_Realloc(bindtable[key], newlen, PU_STATIC, NULL);
newcmd += curpos; // reapply offset
newcmd[0] = ' '; // replace previous '\0' w/ ' '
++newcmd; // make sure later strcpy doesnt overwrite ' '
}
// first iteration
else
// allocate space for argument and a ' ' or '\0'
newcmd = bindtable[key] = Z_Calloc(strlen(arg) + 1, PU_STATIC, NULL);
// the copy
strcpy(newcmd, arg);
// move window past copied argument for next iteration
newcmd += strlen(arg);
}
}
//======================================================================
@ -937,7 +968,7 @@ boolean CON_Responder(event_t *ev)
return false;
// let go keyup events, don't eat them
if (ev->type != ev_keydown && ev->type != ev_console)
if (ev->type != ev_keydown && ev->type != ev_text && ev->type != ev_console)
{
if (ev->key == gamecontrol[GC_CONSOLE][0] || ev->key == gamecontrol[GC_CONSOLE][1])
consdown = false;
@ -952,7 +983,7 @@ boolean CON_Responder(event_t *ev)
if (modeattacking || metalrecording || marathonmode)
return false;
if (key == gamecontrol[GC_CONSOLE][0] || key == gamecontrol[GC_CONSOLE][1])
if ((key == gamecontrol[GC_CONSOLE][0] || key == gamecontrol[GC_CONSOLE][1]) && !shiftdown)
{
if (consdown) // ignore repeat
return true;
@ -964,7 +995,7 @@ boolean CON_Responder(event_t *ev)
// check other keys only if console prompt is active
if (!consoleready && key < NUMINPUTS) // metzgermeister: boundary check!!
{
if (! menuactive && bindtable[key])
if (ev->type == ev_keydown && !menuactive && bindtable[key])
{
COM_BufAddText(bindtable[key]);
COM_BufAddText("\n");
@ -981,6 +1012,13 @@ boolean CON_Responder(event_t *ev)
}
}
if (ev->type == ev_text)
{
if (!consoletoggle)
CON_InputAddChar(key);
return true;
}
// Always eat ctrl/shift/alt if console open, so the menu doesn't get ideas
if (key == KEY_LSHIFT || key == KEY_RSHIFT
|| key == KEY_LCTRL || key == KEY_RCTRL
@ -1295,21 +1333,12 @@ boolean CON_Responder(event_t *ev)
else if (key == KEY_KPADSLASH)
key = '/';
if (key >= 'a' && key <= 'z')
{
if (capslock ^ shiftdown)
key = shiftxform[key];
}
else if (shiftdown)
key = shiftxform[key];
// enter a char into the command prompt
if (key < 32 || key > 127)
return true;
if (input_sel != input_cur)
CON_InputDelSelection();
CON_InputAddChar(key);
return true;
}
@ -1864,9 +1893,9 @@ void CON_Drawer(void)
if (con_curlines > 0)
CON_DrawConsole();
else if (gamestate == GS_LEVEL
|| gamestate == GS_INTERMISSION || gamestate == GS_ENDING || gamestate == GS_CUTSCENE
|| gamestate == GS_CREDITS || gamestate == GS_EVALUATION || gamestate == GS_WAITINGPLAYERS)
else if (gamestate == GS_LEVEL || gamestate == GS_INTERMISSION || gamestate == GS_CREDITS
|| gamestate == GS_EVALUATION || gamestate == GS_ENDING || gamestate == GS_CUTSCENE
|| gamestate == GS_WAITINGPLAYERS || cv_debug)
CON_DrawHudlines();
Unlock_state();

1
src/d_event.h
View file

@ -22,6 +22,7 @@ typedef enum
{
ev_keydown,
ev_keyup,
ev_text,
ev_console,
ev_mouse,
ev_joystick,

6
src/d_main.c
View file

@ -192,19 +192,19 @@ void D_ProcessEvents(void)
ev = &events[eventtail];
// Set mouse buttons early in case event is eaten later
if (ev->type == ev_keydown || ev->type == ev_keyup)
if (ev->type == ev_keydown || ev->type == ev_keyup || ev->type == ev_text)
{
// Mouse buttons
if ((UINT32)(ev->key - KEY_MOUSE1) < MOUSEBUTTONS)
{
if (ev->type == ev_keydown)
if (ev->type == ev_keydown || ev->type == ev_text)
mouse.buttons |= 1 << (ev->key - KEY_MOUSE1);
else
mouse.buttons &= ~(1 << (ev->key - KEY_MOUSE1));
}
else if ((UINT32)(ev->key - KEY_2MOUSE1) < MOUSEBUTTONS)
{
if (ev->type == ev_keydown)
if (ev->type == ev_keydown || ev->type == ev_text)
mouse2.buttons |= 1 << (ev->key - KEY_2MOUSE1);
else
mouse2.buttons &= ~(1 << (ev->key - KEY_2MOUSE1));

1
src/d_think.h
View file

@ -51,6 +51,7 @@ typedef struct thinker_s
// killough 11/98: count of how many other objects reference
// this one using pointers. Used for garbage collection.
INT32 references;
boolean cachable;
#ifdef PARANOIA
INT32 debug_mobjtype;

56
src/deh_lua.c
View file

@ -600,14 +600,9 @@ static int ScanConstants(lua_State *L, boolean mathlib, const char *word)
return 0;
}
static inline int lib_getenum(lua_State *L)
static inline int getEnum(lua_State *L, boolean mathlib, const char *word)
{
const char *word;
fixed_t i;
boolean mathlib = lua_toboolean(L, lua_upvalueindex(1));
if (lua_type(L,2) != LUA_TSTRING)
return 0;
word = lua_tostring(L,2);
// check actions, super and globals first, as they don't have _G caching implemented
// so they benefit from being checked first
@ -674,6 +669,46 @@ static inline int lib_getenum(lua_State *L)
else if ((!mathlib && LUA_PushGlobals(L, word)) || ScanConstants(L, mathlib, word))
return 1;
return -1;
}
static int constants_get(lua_State *L)
{
const char *key;
int ret;
if (!lua_isstring(L, 2))
return 0;
key = luaL_checkstring(L, 2);
// In Lua, mathlib is never there
ret = getEnum(L, false, key);
if (ret != -1)
// Don't allow A_* or super.
// All userdata is meant to be considered global variables,
// so no need to get more specific than "is it userdata?"
if (!lua_isuserdata(L, -1) && !lua_isfunction(L, -1))
return ret;
return 0;
}
static inline int lib_getenum(lua_State *L)
{
const char *word;
int ret;
boolean mathlib = lua_toboolean(L, lua_upvalueindex(1));
if (lua_type(L,2) != LUA_TSTRING)
return 0;
word = lua_tostring(L,2);
ret = getEnum(L, mathlib, word);
if (ret != -1)
return ret;
if (mathlib) return luaL_error(L, "constant '%s' could not be parsed.\n", word);
return 0;
@ -776,6 +811,15 @@ int LUA_SOCLib(lua_State *L)
LUA_SetCFunctionField(L, "__call", action_call);
lua_pop(L, 1);
// Allow access to constants without forcing the use of name comparison checks Lua-side
// This table will not access global variables, only constants
lua_newuserdata(L, 0);
lua_createtable(L, 0, 2);
lua_pushcfunction(L, constants_get);
lua_setfield(L, -2, "__index");
lua_setmetatable(L, -2);
lua_setglobal(L, "constants");
return 0;
}

6
src/deh_tables.c
View file

@ -370,8 +370,9 @@ const char *const STATE_LIST[] = { // array length left dynamic for sanity testi
"S_XDEATHSTATE",
"S_RAISESTATE",
// Thok
// Thok effect and spin trail
"S_THOK",
"S_THOKEFFECT",
// Player
"S_PLAY_STND",
@ -3560,7 +3561,8 @@ const char *const MOBJTYPE_LIST[] = { // array length left dynamic for sanity t
"MT_NULL",
"MT_UNKNOWN",
"MT_THOK", // Thok! mobj
"MT_THOK", // Spin trail mobj
"MT_THOKEFFECT", // Thok boom effect
"MT_PLAYER",
"MT_TAILSOVERLAY", // c:
"MT_METALJETFUME",

2
src/doomdef.h
View file

@ -540,7 +540,7 @@ extern char liveeventbackup[256];
#define M_GetText(x) (x)
#endif
void M_StartupLocale(void);
extern void *(*M_Memcpy)(void* dest, const void* src, size_t n) FUNCNONNULL;
void *M_Memcpy(void* dest, const void* src, size_t n);
char *va(const char *format, ...) FUNCPRINTF;
char *M_GetToken(const char *inputString);
void M_UnGetToken(void);

6
src/dummy/i_system.c
View file

@ -1,6 +1,7 @@
#include "../doomdef.h"
#include "../doomtype.h"
#include "../i_system.h"
#include "../i_time.h"
FILE *logstream = NULL;
@ -19,6 +20,11 @@ void I_Sleep(UINT32 ms)
(void)ms;
}
void I_SleepDuration(precise_t duration)
{
(void)duration;
}
precise_t I_GetPreciseTime(void)
{
return 0;

2
src/f_finale.c
View file

@ -4524,7 +4524,7 @@ void F_TextPromptDrawer(void)
if (players[j].mo->state == states+S_PLAY_STND && players[j].mo->tics != -1)\
players[j].mo->tics++;\
else if (players[j].mo->state == states+S_PLAY_WAIT)\
P_SetPlayerMobjState(players[j].mo, S_PLAY_STND);\
P_SetMobjState(players[j].mo, S_PLAY_STND);\
}\
}

26
src/filesrch.c
View file

@ -23,6 +23,16 @@
#include <windows.h>
#endif
#include <sys/stat.h>
#ifndef S_ISLNK
#define IGNORE_SYMLINKS
#endif
#ifndef IGNORE_SYMLINKS
#include <unistd.h>
#include <libgen.h>
#include <limits.h>
#endif
#include <string.h>
#include "filesrch.h"
@ -461,6 +471,9 @@ filestatus_t filesearch(char *filename, const char *startpath, const UINT8 *want
}
else if (!strcasecmp(searchname, dent->d_name))
{
#ifndef IGNORE_SYMLINKS
struct stat statbuf;
#endif
switch (checkfilemd5(searchpath, wantedmd5sum))
{
case FS_FOUND:
@ -468,6 +481,19 @@ filestatus_t filesearch(char *filename, const char *startpath, const UINT8 *want
strcpy(filename,searchpath);
else
strcpy(filename,dent->d_name);
#ifndef IGNORE_SYMLINKS
if (lstat(filename, &statbuf) != -1)
{
if (S_ISLNK(statbuf.st_mode))
{
char *tempbuf = realpath(filename, NULL);
if (!tempbuf)
I_Error("Error parsing link %s: %s", filename, strerror(errno));
strncpy(filename, tempbuf, MAX_WADPATH);
free(tempbuf);
}
}
#endif
retval = FS_FOUND;
found = 1;
break;

169
src/g_demo.c
View file

@ -798,32 +798,53 @@ void G_GhostTicker(void)
if (type == MT_GHOST)
{
mobj = P_SpawnGhostMobj(g->mo); // does a large portion of the work for us
mobj->frame = (mobj->frame & ~FF_FRAMEMASK)|tr_trans60<<FF_TRANSSHIFT; // P_SpawnGhostMobj sets trans50, we want trans60
if (!P_MobjWasRemoved(mobj))
mobj->frame = (mobj->frame & ~FF_FRAMEMASK)|tr_trans60<<FF_TRANSSHIFT; // P_SpawnGhostMobj sets trans50, we want trans60
}
else if (type == MT_THOKEFFECT)
{
mobj = P_SpawnMobjFromMobj(g->mo, 0, 0, FixedDiv(g->mo->height, g->mo->scale)*3/4, type);
mobj->angle = g->mo->angle + ANGLE_90;
mobj->fuse = 7;
mobj->scale = g->mo->scale / 3;
mobj->destscale = 10 * g->mo->scale;
mobj->colorized = true;
mobj->color = g->mo->color;
mobj->momx = -g->mo->momx / 2;
mobj->momy = -g->mo->momy / 2;
}
else
{
mobj = P_SpawnMobjFromMobj(g->mo, 0, 0, -FixedDiv(FixedMul(g->mo->info->height, g->mo->scale) - g->mo->height,3*FRACUNIT), MT_THOK);
mobj->sprite = states[mobjinfo[type].spawnstate].sprite;
mobj->frame = (states[mobjinfo[type].spawnstate].frame & FF_FRAMEMASK) | tr_trans60<<FF_TRANSSHIFT;
mobj->color = g->mo->color;
mobj->skin = g->mo->skin;
P_SetScale(mobj, (mobj->destscale = g->mo->scale));
if (type == MT_THOK) // spintrail-specific modification for MT_THOK
if (!P_MobjWasRemoved(mobj))
{
mobj->frame = FF_TRANS80;
mobj->fuse = mobj->tics;
mobj->sprite = states[mobjinfo[type].spawnstate].sprite;
mobj->frame = (states[mobjinfo[type].spawnstate].frame & FF_FRAMEMASK) | tr_trans60<<FF_TRANSSHIFT;
mobj->color = g->mo->color;
mobj->skin = g->mo->skin;
P_SetScale(mobj, (mobj->destscale = g->mo->scale));
if (type == MT_THOK) // spintrail-specific modification for MT_THOK
{
mobj->frame = FF_TRANS80;
mobj->fuse = mobj->tics;
}
mobj->tics = -1; // nope.
}
mobj->tics = -1; // nope.
}
mobj->floorz = mobj->z;
mobj->ceilingz = mobj->z+mobj->height;
P_UnsetThingPosition(mobj);
mobj->flags = MF_NOBLOCKMAP|MF_NOCLIP|MF_NOCLIPHEIGHT|MF_NOGRAVITY; // make an ATTEMPT to curb crazy SOCs fucking stuff up...
P_SetThingPosition(mobj);
if (!mobj->fuse)
mobj->fuse = 8;
P_SetTarget(&mobj->target, g->mo);
if (!P_MobjWasRemoved(mobj))
{
mobj->floorz = mobj->z;
mobj->ceilingz = mobj->z+mobj->height;
P_UnsetThingPosition(mobj);
mobj->flags = MF_NOBLOCKMAP|MF_NOCLIP|MF_NOCLIPHEIGHT|MF_NOGRAVITY; // make an ATTEMPT to curb crazy SOCs fucking stuff up...
P_SetThingPosition(mobj);
if (!mobj->fuse)
mobj->fuse = 8;
P_SetTarget(&mobj->target, g->mo);
}
}
}
if (xziptic & EZT_HIT)
@ -847,6 +868,8 @@ void G_GhostTicker(void)
|| health != 0 || i >= 4) // only spawn for the first 4 hits per frame, to prevent ghosts from splode-spamming too bad.
continue;
poof = P_SpawnMobj(x, y, z, MT_GHOST);
if (P_MobjWasRemoved(poof))
continue;
poof->angle = angle;
poof->flags = MF_NOBLOCKMAP|MF_NOCLIP|MF_NOCLIPHEIGHT|MF_NOGRAVITY; // make an ATTEMPT to curb crazy SOCs fucking stuff up...
poof->health = 0;
@ -892,19 +915,22 @@ void G_GhostTicker(void)
if (follow)
P_RemoveMobj(follow);
P_SetTarget(&follow, P_SpawnMobjFromMobj(g->mo, 0, 0, 0, MT_GHOST));
P_SetTarget(&follow->tracer, g->mo);
follow->tics = -1;
temp = READINT16(g->p)<<FRACBITS;
follow->height = FixedMul(follow->scale, temp);
if (!P_MobjWasRemoved(follow))
{
P_SetTarget(&follow->tracer, g->mo);
follow->tics = -1;
temp = READINT16(g->p)<<FRACBITS;
follow->height = FixedMul(follow->scale, temp);
if (followtic & FZT_LINKDRAW)
follow->flags2 |= MF2_LINKDRAW;
if (followtic & FZT_LINKDRAW)
follow->flags2 |= MF2_LINKDRAW;
if (followtic & FZT_COLORIZED)
follow->colorized = true;
if (followtic & FZT_COLORIZED)
follow->colorized = true;
if (followtic & FZT_SKIN)
follow->skin = skins[READUINT8(g->p)];
if (followtic & FZT_SKIN)
follow->skin = &skins[READUINT8(g->p)];
}
}
if (follow)
{
@ -1094,31 +1120,50 @@ void G_ReadMetalTic(mobj_t *metal)
{
mobj = P_SpawnGhostMobj(metal); // does a large portion of the work for us
}
else if (type == MT_THOKEFFECT)
{
mobj = P_SpawnMobjFromMobj(metal, 0, 0, FixedDiv(metal->height, metal->scale)*3/4, type);
mobj->angle = metal->angle + ANGLE_90;
mobj->fuse = 7;
mobj->scale = metal->scale / 3;
mobj->destscale = 10 * metal->scale;
mobj->colorized = true;
mobj->color = metal->color;
mobj->momx = -metal->momx / 2;
mobj->momy = -metal->momy / 2;
}
else
{
mobj = P_SpawnMobjFromMobj(metal, 0, 0, -FixedDiv(FixedMul(metal->info->height, metal->scale) - metal->height,3*FRACUNIT), MT_THOK);
mobj->sprite = states[mobjinfo[type].spawnstate].sprite;
mobj->frame = states[mobjinfo[type].spawnstate].frame;
mobj->angle = metal->angle;
mobj->color = metal->color;
mobj->skin = metal->skin;
P_SetScale(mobj, (mobj->destscale = metal->scale));
if (type == MT_THOK) // spintrail-specific modification for MT_THOK
if (!P_MobjWasRemoved(mobj))
{
mobj->frame = FF_TRANS70;
mobj->fuse = mobj->tics;
mobj->sprite = states[mobjinfo[type].spawnstate].sprite;
mobj->frame = states[mobjinfo[type].spawnstate].frame;
mobj->angle = metal->angle;
mobj->color = metal->color;
mobj->skin = metal->skin;
P_SetScale(mobj, (mobj->destscale = metal->scale));
if (type == MT_THOK) // spintrail-specific modification for MT_THOK
{
mobj->frame = FF_TRANS70;
mobj->fuse = mobj->tics;
}
mobj->tics = -1; // nope.
}
mobj->tics = -1; // nope.
}
mobj->floorz = mobj->z;
mobj->ceilingz = mobj->z+mobj->height;
P_UnsetThingPosition(mobj);
mobj->flags = MF_NOBLOCKMAP|MF_NOCLIP|MF_NOCLIPHEIGHT|MF_NOGRAVITY; // make an ATTEMPT to curb crazy SOCs fucking stuff up...
P_SetThingPosition(mobj);
if (!mobj->fuse)
mobj->fuse = 8;
P_SetTarget(&mobj->target, metal);
if (!P_MobjWasRemoved(mobj))
{
mobj->floorz = mobj->z;
mobj->ceilingz = mobj->z+mobj->height;
P_UnsetThingPosition(mobj);
mobj->flags = MF_NOBLOCKMAP|MF_NOCLIP|MF_NOCLIPHEIGHT|MF_NOGRAVITY; // make an ATTEMPT to curb crazy SOCs fucking stuff up...
P_SetThingPosition(mobj);
if (!mobj->fuse)
mobj->fuse = 8;
P_SetTarget(&mobj->target, metal);
}
}
}
if (xziptic & EZT_SPRITE)
@ -1140,19 +1185,23 @@ void G_ReadMetalTic(mobj_t *metal)
if (follow)
P_RemoveMobj(follow);
P_SetTarget(&follow, P_SpawnMobjFromMobj(metal, 0, 0, 0, MT_GHOST));
P_SetTarget(&follow->tracer, metal);
follow->tics = -1;
temp = READINT16(metal_p)<<FRACBITS;
follow->height = FixedMul(follow->scale, temp);
if (!P_MobjWasRemoved(follow))
{
P_SetTarget(&follow->tracer, metal);
follow->tics = -1;
temp = READINT16(metal_p)<<FRACBITS;
follow->height = FixedMul(follow->scale, temp);
if (followtic & FZT_LINKDRAW)
follow->flags2 |= MF2_LINKDRAW;
if (followtic & FZT_LINKDRAW)
follow->flags2 |= MF2_LINKDRAW;
if (followtic & FZT_COLORIZED)
follow->colorized = true;
if (followtic & FZT_COLORIZED)
follow->colorized = true;
if (followtic & FZT_SKIN)
follow->skin = &skins[READUINT8(metal_p)];
}
if (followtic & FZT_SKIN)
follow->skin = skins[READUINT8(metal_p)];
}
if (follow)
{
@ -2535,7 +2584,9 @@ void G_AddGhost(char *defdemoname)
{ // A bit more complex than P_SpawnPlayer because ghosts aren't solid and won't just push themselves out of the ceiling.
fixed_t z,f,c;
fixed_t offset = mthing->z << FRACBITS;
gh->mo = P_SpawnMobj(mthing->x << FRACBITS, mthing->y << FRACBITS, 0, MT_GHOST);
P_SetTarget(&gh->mo, P_SpawnMobj(mthing->x << FRACBITS, mthing->y << FRACBITS, 0, MT_GHOST));
if (P_MobjWasRemoved(gh->mo))
return;
gh->mo->angle = FixedAngle(mthing->angle << FRACBITS);
f = gh->mo->floorz;
c = gh->mo->ceilingz - mobjinfo[MT_PLAYER].height;

31
src/g_game.c
View file

@ -308,7 +308,9 @@ consvar_t cv_chatheight= CVAR_INIT ("chatheight", "8", CV_SAVE, chatheight_cons_
consvar_t cv_chatnotifications= CVAR_INIT ("chatnotifications", "On", CV_SAVE, CV_OnOff, NULL);
// chat spam protection (why would you want to disable that???)
consvar_t cv_chatspamprotection= CVAR_INIT ("chatspamprotection", "On", CV_SAVE, CV_OnOff, NULL);
consvar_t cv_chatspamprotection= CVAR_INIT ("chatspamprotection", "On", CV_SAVE|CV_NETVAR, CV_OnOff, NULL);
consvar_t cv_chatspamspeed= CVAR_INIT ("chatspamspeed", "35", CV_SAVE|CV_NETVAR, CV_Unsigned, NULL);
consvar_t cv_chatspamburst= CVAR_INIT ("chatspamburst", "3", CV_SAVE|CV_NETVAR, CV_Unsigned, NULL);
// minichat text background
consvar_t cv_chatbacktint = CVAR_INIT ("chatbacktint", "On", CV_SAVE, CV_OnOff, NULL);
@ -5380,16 +5382,29 @@ void G_FreeMapSearch(mapsearchfreq_t *freq, INT32 freqc)
INT32 G_FindMapByNameOrCode(const char *mapname, char **realmapnamep)
{
boolean usemapcode = false;
INT32 newmapnum;
size_t mapnamelen;
size_t mapnamelen = strlen(mapname);
char *p;
mapnamelen = strlen(mapname);
if (mapnamelen == 2)/* maybe two digit code */
if (mapnamelen == 1)
{
if (mapname[0] == '*') // current map
{
usemapcode = true;
newmapnum = gamemap;
}
else if (mapname[0] == '+' && mapheaderinfo[gamemap-1]) // next map
{
usemapcode = true;
newmapnum = mapheaderinfo[gamemap-1]->nextlevel;
if (newmapnum < 1 || newmapnum > NUMMAPS)
{
CONS_Alert(CONS_ERROR, M_GetText("NextLevel (%d) is not a valid map.\n"), newmapnum);
return 0;
}
}
}
else if (mapnamelen == 2)/* maybe two digit code */
{
if (( newmapnum = M_MapNumber(mapname[0], mapname[1]) ))
usemapcode = true;

2
src/g_game.h
View file

@ -53,7 +53,7 @@ extern consvar_t cv_instantretry;
// used in game menu
extern consvar_t cv_tutorialprompt;
extern consvar_t cv_chatwidth, cv_chatnotifications, cv_chatheight, cv_chattime, cv_consolechat, cv_chatbacktint, cv_chatspamprotection, cv_compactscoreboard;
extern consvar_t cv_chatwidth, cv_chatnotifications, cv_chatheight, cv_chattime, cv_consolechat, cv_chatbacktint, cv_chatspamprotection, cv_chatspamspeed, cv_chatspamburst, cv_compactscoreboard;
extern consvar_t cv_crosshair, cv_crosshair2;
extern consvar_t cv_invertmouse, cv_alwaysfreelook, cv_chasefreelook, cv_mousemove;
extern consvar_t cv_invertmouse2, cv_alwaysfreelook2, cv_chasefreelook2, cv_mousemove2;

1
src/hardware/hw_defs.h
View file

@ -283,6 +283,7 @@ enum hwdsetspecialstate
HWD_SET_SHADERS,
HWD_SET_TEXTUREFILTERMODE,
HWD_SET_TEXTUREANISOTROPICMODE,
HWD_SET_WIREFRAME,
HWD_NUMSTATE
};

11
src/hardware/hw_draw.c
View file

@ -1319,6 +1319,7 @@ void HWR_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 color)
FOutVector v[4];
FSurfaceInfo Surf;
float fx, fy, fw, fh;
UINT8 alphalevel = ((color & V_ALPHAMASK) >> V_ALPHASHIFT);
UINT8 perplayershuffle = 0;
@ -1483,8 +1484,16 @@ void HWR_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 color)
Surf.PolyColor = V_GetColor(color);
if (alphalevel)
{
if (alphalevel == 10) Surf.PolyColor.s.alpha = softwaretranstogl_lo[st_translucency]; // V_HUDTRANSHALF
else if (alphalevel == 11) Surf.PolyColor.s.alpha = softwaretranstogl[st_translucency]; // V_HUDTRANS
else if (alphalevel == 12) Surf.PolyColor.s.alpha = softwaretranstogl_hi[st_translucency]; // V_HUDTRANSDOUBLE
else Surf.PolyColor.s.alpha = softwaretranstogl[10-alphalevel];
}
HWD.pfnDrawPolygon(&Surf, v, 4,
PF_Modulated|PF_NoTexture|PF_NoDepthTest);
PF_Modulated|PF_NoTexture|PF_NoDepthTest|PF_Translucent);
}
#ifdef HAVE_PNG

1
src/hardware/hw_light.c
View file

@ -138,6 +138,7 @@ light_t *t_lspr[NUMSPRITES] =
&lspr[NOLIGHT], // SPR_UNKN
&lspr[NOLIGHT], // SPR_THOK
&lspr[NOLIGHT], // SPR_THKE
&lspr[SUPERSONIC_L],// SPR_PLAY
// Enemies

528
src/hardware/hw_main.c
View file

File diff suppressed because it is too large Load diff

2
src/hardware/hw_main.h
View file

@ -107,6 +107,8 @@ extern consvar_t cv_glslopecontrast;
extern consvar_t cv_glbatching;
extern consvar_t cv_glwireframe;
extern float gl_viewwidth, gl_viewheight, gl_baseviewwindowy;
extern float gl_viewwindowx, gl_basewindowcentery;

2
src/hardware/hw_md2.c
View file

@ -1487,6 +1487,8 @@ boolean HWR_DrawModel(gl_vissprite_t *spr)
#undef INTERPOLERATION_LIMIT
#endif
if (spr->mobj->type == MT_OVERLAY) // Handle overlays
R_ThingOffsetOverlay(spr->mobj, &interp.x, &interp.y);
//Hurdler: it seems there is still a small problem with mobj angle
p.x = FIXED_TO_FLOAT(interp.x);
p.y = FIXED_TO_FLOAT(interp.y)+md2->offset;

7
src/hardware/r_opengl/r_opengl.c
View file

@ -302,6 +302,8 @@ typedef void (APIENTRY * PFNglDisable) (GLenum cap);
static PFNglDisable pglDisable;
typedef void (APIENTRY * PFNglGetFloatv) (GLenum pname, GLfloat *params);
static PFNglGetFloatv pglGetFloatv;
typedef void (APIENTRY * PFNglPolygonMode) (GLenum, GLenum);
static PFNglPolygonMode pglPolygonMode;
/* Depth Buffer */
typedef void (APIENTRY * PFNglClearDepth) (GLclampd depth);
@ -476,6 +478,7 @@ boolean SetupGLfunc(void)
GETOPENGLFUNC(pglGetFloatv, glGetFloatv)
GETOPENGLFUNC(pglGetIntegerv, glGetIntegerv)
GETOPENGLFUNC(pglGetString, glGetString)
GETOPENGLFUNC(pglPolygonMode, glPolygonMode)
GETOPENGLFUNC(pglClearDepth, glClearDepth)
GETOPENGLFUNC(pglDepthFunc, glDepthFunc)
@ -2474,6 +2477,10 @@ EXPORT void HWRAPI(SetSpecialState) (hwdspecialstate_t IdState, INT32 Value)
Flush(); //??? if we want to change filter mode by texture, remove this
break;
case HWD_SET_WIREFRAME:
pglPolygonMode(GL_FRONT_AND_BACK, Value ? GL_LINE : GL_FILL);
break;
default:
break;
}

96
src/hu_stuff.c
View file

@ -79,6 +79,7 @@ patch_t *nto_font[NT_FONTSIZE];
static player_t *plr;
boolean chat_on; // entering a chat message?
boolean chat_on_first_event; // blocker for first chat input event
static char w_chat[HU_MAXMSGLEN + 1];
static size_t c_input = 0; // let's try to make the chat input less shitty.
static boolean headsupactive = false;
@ -618,7 +619,9 @@ static void Command_CSay_f(void)
DoSayCommand(0, 1, HU_CSAY);
}
static tic_t stop_spamming[MAXPLAYERS];
static tic_t spam_tokens[MAXPLAYERS];
static tic_t spam_tics[MAXPLAYERS];
/** Receives a message, processing an ::XD_SAY command.
* \sa DoSayCommand
@ -670,14 +673,14 @@ static void Got_Saycmd(UINT8 **p, INT32 playernum)
// before we do anything, let's verify the guy isn't spamming, get this easier on us.
//if (stop_spamming[playernum] != 0 && cv_chatspamprotection.value && !(flags & HU_CSAY))
if (stop_spamming[playernum] != 0 && consoleplayer != playernum && cv_chatspamprotection.value && !(flags & HU_CSAY))
if (spam_tokens[playernum] <= 0 && cv_chatspamprotection.value && !(flags & HU_CSAY))
{
CONS_Debug(DBG_NETPLAY,"Received SAY cmd too quickly from Player %d (%s), assuming as spam and blocking message.\n", playernum+1, player_names[playernum]);
stop_spamming[playernum] = 4;
spam_tics[playernum] = 0;
spam_eatmsg = 1;
}
else
stop_spamming[playernum] = 4; // you can hold off for 4 tics, can you?
spam_tokens[playernum] -= 1;
// run the lua hook even if we were supposed to eat the msg, netgame consistency goes first.
@ -857,6 +860,25 @@ static void Got_Saycmd(UINT8 **p, INT32 playernum)
//
void HU_Ticker(void)
{
// do this server-side, too
if (netgame)
{
size_t i = 0;
// handle spam while we're at it:
for(; (i<MAXPLAYERS); i++)
{
if (spam_tokens[i] < (tic_t)cv_chatspamburst.value)
{
if (++spam_tics[i] >= (tic_t)cv_chatspamspeed.value)
{
spam_tokens[i]++;
spam_tics[i] = 0;
}
}
}
}
if (dedicated)
return;
@ -879,13 +901,6 @@ void HU_Ticker(void)
{
size_t i = 0;
// handle spam while we're at it:
for(; (i<MAXPLAYERS); i++)
{
if (stop_spamming[i] > 0)
stop_spamming[i]--;
}
// handle chat timers
for (i=0; (i<chat_nummsg_min); i++)
{
@ -1025,7 +1040,7 @@ boolean HU_Responder(event_t *ev)
{
INT32 c=0;
if (ev->type != ev_keydown)
if (ev->type != ev_keydown && ev->type != ev_text)
return false;
// only KeyDown events now...
@ -1054,11 +1069,15 @@ boolean HU_Responder(event_t *ev)
if (!chat_on)
{
if (ev->type == ev_text)
return false;
// enter chat mode
if ((ev->key == gamecontrol[GC_TALKKEY][0] || ev->key == gamecontrol[GC_TALKKEY][1])
&& netgame && !OLD_MUTE) // check for old chat mute, still let the players open the chat incase they want to scroll otherwise.
{
chat_on = true;
chat_on_first_event = false;
w_chat[0] = 0;
teamtalk = false;
chat_scrollmedown = true;
@ -1069,6 +1088,7 @@ boolean HU_Responder(event_t *ev)
&& netgame && !OLD_MUTE)
{
chat_on = true;
chat_on_first_event = false;
w_chat[0] = 0;
teamtalk = G_GametypeHasTeams(); // Don't teamtalk if we don't have teams.
chat_scrollmedown = true;
@ -1078,6 +1098,31 @@ boolean HU_Responder(event_t *ev)
}
else // if chat_on
{
if (!chat_on_first_event)
{
// since the text event is sent immediately after the keydown event,
// we need to make sure that nothing is displayed once the chat
// opens, otherwise a 't' would be outputted.
chat_on_first_event = true;
return true;
}
if (ev->type == ev_text)
{
if ((c < HU_FONTSTART || c > HU_FONTEND || !hu_font[c-HU_FONTSTART])
&& c != ' ') // Allow spaces, of course
{
return false;
}
if (CHAT_MUTE || strlen(w_chat) >= HU_MAXMSGLEN)
return true;
memmove(&w_chat[c_input + 1], &w_chat[c_input], strlen(w_chat) - c_input + 1);
w_chat[c_input] = c;
c_input++;
return true;
}
// Ignore modifier keys
// Note that we do this here so users can still set
@ -1087,23 +1132,8 @@ boolean HU_Responder(event_t *ev)
|| ev->key == KEY_LALT || ev->key == KEY_RALT)
return true;
c = (INT32)ev->key;
// I know this looks very messy but this works. If it ain't broke, don't fix it!
// shift LETTERS to uppercase if we have capslock or are holding shift
if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
{
if (shiftdown ^ capslock)
c = shiftxform[c];
}
else // if we're holding shift we should still shift non letter symbols
{
if (shiftdown)
c = shiftxform[c];
}
// pasting. pasting is cool. chat is a bit limited, though :(
if ((c == 'v' || c == 'V') && ctrldown)
if (c == 'v' && ctrldown)
{
const char *paste;
size_t chatlen;
@ -1171,16 +1201,6 @@ boolean HU_Responder(event_t *ev)
else
c_input++;
}
else if ((c >= HU_FONTSTART && c <= HU_FONTEND && hu_font[c-HU_FONTSTART])
|| c == ' ') // Allow spaces, of course
{
if (CHAT_MUTE || strlen(w_chat) >= HU_MAXMSGLEN)
return true;
memmove(&w_chat[c_input + 1], &w_chat[c_input], strlen(w_chat) - c_input + 1);
w_chat[c_input] = c;
c_input++;
}
else if (c == KEY_BACKSPACE)
{
if (CHAT_MUTE || c_input <= 0)

41
src/i_time.c
View file

@ -30,12 +30,6 @@ static precise_t enterprecise, oldenterprecise;
static fixed_t entertic, oldentertics;
static double tictimer;
// A little more than the minimum sleep duration on Windows.
// May be incorrect for other platforms, but we don't currently have a way to
// query the scheduler granularity. SDL will do what's needed to make this as
// low as possible though.
#define MIN_SLEEP_DURATION_MS 2.1
tic_t I_GetTime(void)
{
return g_time.time;
@ -88,38 +82,3 @@ void I_UpdateTime(fixed_t timescale)
g_time.timefrac = FLOAT_TO_FIXED(fractional);
}
}
void I_SleepDuration(precise_t duration)
{
UINT64 precision = I_GetPrecisePrecision();
INT32 sleepvalue = cv_sleep.value;
UINT64 delaygranularity;
precise_t cur;
precise_t dest;
{
double gran = round(((double)(precision / 1000) * sleepvalue * MIN_SLEEP_DURATION_MS));
delaygranularity = (UINT64)gran;
}
cur = I_GetPreciseTime();
dest = cur + duration;
// the reason this is not dest > cur is because the precise counter may wrap
// two's complement arithmetic is our friend here, though!
// e.g. cur 0xFFFFFFFFFFFFFFFE = -2, dest 0x0000000000000001 = 1
// 0x0000000000000001 - 0xFFFFFFFFFFFFFFFE = 3
while ((INT64)(dest - cur) > 0)
{
// If our cv_sleep value exceeds the remaining sleep duration, use the
// hard sleep function.
if (sleepvalue > 0 && (dest - cur) > delaygranularity)
{
I_Sleep(sleepvalue);
}
// Otherwise, this is a spinloop.
cur = I_GetPreciseTime();
}
}

33
src/info.c
View file

@ -33,7 +33,8 @@ char sprnames[NUMSPRITES + 1][5] =
"NULL", // invisible object
"UNKN",
"THOK", // Thok! mobj
"THOK", // Spin trail mobj
"THKE", // Thok boom effect
"PLAY",
// Enemies
@ -703,8 +704,9 @@ state_t states[NUMSTATES] =
{SPR_UNKN, FF_FULLBRIGHT, -1, {A_InfoState}, 5, 0, S_NULL}, // S_XDEATHSTATE
{SPR_UNKN, FF_FULLBRIGHT, -1, {A_InfoState}, 6, 0, S_NULL}, // S_RAISESTATE
// Thok
// Spin trail and thok boom effect
{SPR_THOK, FF_TRANS50, 8, {NULL}, 0, 0, S_NULL}, // S_THOK
{SPR_THKE, FF_TRANS50|FF_PAPERSPRITE, 8, {NULL}, 0, 0, S_NULL}, // S_THOKEFFECT
// Player
{SPR_PLAY, SPR2_STND|FF_ANIMATE, 105, {NULL}, 0, 7, S_PLAY_WAIT}, // S_PLAY_STND
@ -4078,6 +4080,33 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
MF_NOBLOCKMAP|MF_NOCLIP|MF_NOCLIPHEIGHT|MF_NOGRAVITY|MF_SCENERY, // flags
S_NULL // raisestate
},
{ // MT_THOKEFFECT
-1, // doomednum
S_THOKEFFECT, // spawnstate
1000, // spawnhealth
S_NULL, // seestate
sfx_None, // seesound
8, // reactiontime
sfx_None, // attacksound
S_NULL, // painstate
0, // painchance
sfx_None, // painsound
S_NULL, // meleestate
S_NULL, // missilestate
S_NULL, // deathstate
S_NULL, // xdeathstate
sfx_None, // deathsound
8, // speed
32*FRACUNIT, // radius
64*FRACUNIT, // height
0, // display offset
16, // mass
0, // damage
sfx_None, // activesound
MF_NOBLOCKMAP|MF_NOCLIP|MF_NOCLIPHEIGHT|MF_NOGRAVITY|MF_SCENERY, // flags
S_NULL // raisestate
},
{ // MT_PLAYER
-1, // doomednum

9
src/info.h
View file

@ -580,7 +580,8 @@ typedef enum sprite
SPR_NULL, // invisible object
SPR_UNKN,
SPR_THOK, // Thok! mobj
SPR_THOK, // Spin trail mobj
SPR_THKE, // Thok boom effect
SPR_PLAY,
// Enemies
@ -1182,8 +1183,9 @@ typedef enum state
S_XDEATHSTATE,
S_RAISESTATE,
// Thok
// Thok boom effect and spin trail
S_THOK,
S_THOKEFFECT,
// Player
S_PLAY_STND,
@ -4392,7 +4394,8 @@ typedef enum mobj_type
MT_NULL,
MT_UNKNOWN,
MT_THOK, // Thok! mobj
MT_THOK, // Spin trail mobj
MT_THOKEFFECT, // Thok boom effect
MT_PLAYER,
MT_TAILSOVERLAY, // c:
MT_METALJETFUME,

12
src/lua_baselib.c
View file

@ -1346,6 +1346,17 @@ static int lib_pSetObjectMomZ(lua_State *L)
return 0;
}
static int lib_pIsLocalPlayer(lua_State *L)
{
player_t *player = *((player_t **)luaL_checkudata(L, 1, META_PLAYER));
//NOHUD
//INLEVEL
if (!player)
return LUA_ErrInvalid(L, "player_t");
lua_pushboolean(L, P_IsLocalPlayer(player));
return 1;
}
static int lib_pPlayJingle(lua_State *L)
{
player_t *player = NULL;
@ -4277,6 +4288,7 @@ static luaL_Reg lib[] = {
{"P_InQuicksand",lib_pInQuicksand},
{"P_InJumpFlipSector",lib_pInJumpFlipSector},
{"P_SetObjectMomZ",lib_pSetObjectMomZ},
{"P_IsLocalPlayer",lib_pIsLocalPlayer},
{"P_PlayJingle",lib_pPlayJingle},
{"P_PlayJingleMusic",lib_pPlayJingleMusic},
{"P_RestoreMusic",lib_pRestoreMusic},

2
src/lua_hook.h
View file

@ -126,7 +126,9 @@ int LUA_HookPlayer(player_t *, int hook);
int LUA_HookTiccmd(player_t *, ticcmd_t *, int hook);
int LUA_HookKey(event_t *event, int hook); // Hooks for key events
void LUA_HookPreThinkFrame(void);
void LUA_HookThinkFrame(void);
void LUA_HookPostThinkFrame(void);
int LUA_HookMobjLineCollide(mobj_t *, line_t *);
int LUA_HookTouchSpecial(mobj_t *special, mobj_t *toucher);
int LUA_HookShouldDamage(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 damage, UINT8 damagetype);

37
src/lua_hooklib.c
View file

@ -76,12 +76,12 @@ static boolean mobj_hook_available(int hook_type, mobjtype_t mobj_type)
);
}
static int hook_in_list
static unsigned hook_in_list
(
const char * const name,
const char * const * const list
){
int type;
unsigned type;
for (type = 0; list[type] != NULL; ++type)
{
@ -200,7 +200,7 @@ static void add_hook_ref(lua_State *L, int idx)
static int lib_addHook(lua_State *L)
{
const char * name;
int type;
unsigned type;
if (!lua_lumploading)
return luaL_error(L, "This function cannot be called from within a hook or coroutine!");
@ -671,10 +671,8 @@ void LUA_HookHUD(int hook_type, huddrawlist_h list)
SPECIALIZED HOOKS
========================================================================= */
void LUA_HookThinkFrame(void)
static void hook_think_frame(int type)
{
const int type = HOOK(ThinkFrame);
// variables used by perf stats
int hook_index = 0;
precise_t time_taken = 0;
@ -692,7 +690,7 @@ void LUA_HookThinkFrame(void)
{
get_hook(&hook, map->ids, k);
if (cv_perfstats.value == 3)
if (cv_perfstats.value >= 3)
{
lua_pushvalue(gL, -1);/* need the function again */
time_taken = I_GetPreciseTime();
@ -700,12 +698,18 @@ void LUA_HookThinkFrame(void)
call_single_hook(&hook);
if (cv_perfstats.value == 3)
if (cv_perfstats.value >= 3)
{
lua_Debug ar;
time_taken = I_GetPreciseTime() - time_taken;
lua_getinfo(gL, ">S", &ar);
PS_SetThinkFrameHookInfo(hook_index, time_taken, ar.short_src);
if (type == 4) // sorry for magic numbers
PS_SetPreThinkFrameHookInfo(hook_index, time_taken, ar.short_src);
else if (type == 5)
PS_SetThinkFrameHookInfo(hook_index, time_taken, ar.short_src);
else if (type == 6)
PS_SetPostThinkFrameHookInfo(hook_index, time_taken, ar.short_src);
hook_index++;
}
}
@ -714,6 +718,21 @@ void LUA_HookThinkFrame(void)
}
}
void LUA_HookPreThinkFrame(void)
{
hook_think_frame(HOOK(PreThinkFrame));
}
void LUA_HookThinkFrame(void)
{
hook_think_frame(HOOK(ThinkFrame));
}
void LUA_HookPostThinkFrame(void)
{
hook_think_frame(HOOK(PostThinkFrame));
}
int LUA_HookMobjLineCollide(mobj_t *mobj, line_t *line)
{
Hook_State hook;

174
src/lua_maplib.c
View file

@ -35,10 +35,14 @@ enum sector_e {
sector_floorpic,
sector_floorxoffset,
sector_flooryoffset,
sector_floorxscale,
sector_flooryscale,
sector_floorangle,
sector_ceilingpic,
sector_ceilingxoffset,
sector_ceilingyoffset,
sector_ceilingxscale,
sector_ceilingyscale,
sector_ceilingangle,
sector_lightlevel,
sector_floorlightlevel,
@ -74,10 +78,14 @@ static const char *const sector_opt[] = {
"floorpic",
"floorxoffset",
"flooryoffset",
"floorxscale",
"flooryscale",
"floorangle",
"ceilingpic",
"ceilingxoffset",
"ceilingyoffset",
"ceilingxscale",
"ceilingyscale",
"ceilingangle",
"lightlevel",
"floorlightlevel",
@ -188,8 +196,16 @@ enum side_e {
side_offsety_top,
side_offsetx_mid,
side_offsety_mid,
side_offsetx_bottom,
side_offsetx_bot,
side_offsety_bottom,
side_offsety_bot,
side_scalex_top,
side_scaley_top,
side_scalex_mid,
side_scaley_mid,
side_scalex_bottom,
side_scaley_bottom,
side_toptexture,
side_bottomtexture,
side_midtexture,
@ -208,8 +224,16 @@ static const char *const side_opt[] = {
"offsety_top",
"offsetx_mid",
"offsety_mid",
"offsetx_bottom",
"offsetx_bot",
"offsety_bottom",
"offsety_bot",
"scalex_top",
"scaley_top",
"scalex_mid",
"scaley_mid",
"scalex_bottom",
"scaley_bottom",
"toptexture",
"bottomtexture",
"midtexture",
@ -249,8 +273,16 @@ enum ffloor_e {
ffloor_topheight,
ffloor_toppic,
ffloor_toplightlevel,
ffloor_topxoffs,
ffloor_topyoffs,
ffloor_topxscale,
ffloor_topyscale,
ffloor_bottomheight,
ffloor_bottompic,
ffloor_bottomxoffs,
ffloor_bottomyoffs,
ffloor_bottomxscale,
ffloor_bottomyscale,
ffloor_tslope,
ffloor_bslope,
ffloor_sector,
@ -275,8 +307,16 @@ static const char *const ffloor_opt[] = {
"topheight",
"toppic",
"toplightlevel",
"topxoffs",
"topyoffs",
"topxscale",
"topyscale",
"bottomheight",
"bottompic",
"bottomxoffs",
"bottomyoffs",
"bottomxscale",
"bottomyscale",
"t_slope",
"b_slope",
"sector", // secnum pushed as control sector userdata
@ -656,20 +696,20 @@ static int sector_get(lua_State *L)
return 1;
}
case sector_floorxoffset:
{
lua_pushfixed(L, sector->floorxoffset);
return 1;
}
case sector_flooryoffset:
{
lua_pushfixed(L, sector->flooryoffset);
return 1;
}
case sector_floorxscale:
lua_pushfixed(L, sector->floorxscale);
return 1;
case sector_flooryscale:
lua_pushfixed(L, sector->flooryscale);
return 1;
case sector_floorangle:
{
lua_pushangle(L, sector->floorangle);
return 1;
}
case sector_ceilingpic: // ceilingpic
{
levelflat_t *levelflat = &levelflats[sector->ceilingpic];
@ -680,20 +720,20 @@ static int sector_get(lua_State *L)
return 1;
}
case sector_ceilingxoffset:
{
lua_pushfixed(L, sector->ceilingxoffset);
return 1;
}
case sector_ceilingyoffset:
{
lua_pushfixed(L, sector->ceilingyoffset);
return 1;
}
case sector_ceilingxscale:
lua_pushfixed(L, sector->ceilingxscale);
return 1;
case sector_ceilingyscale:
lua_pushfixed(L, sector->ceilingyscale);
return 1;
case sector_ceilingangle:
{
lua_pushangle(L, sector->ceilingangle);
return 1;
}
case sector_lightlevel:
lua_pushinteger(L, sector->lightlevel);
return 1;
@ -845,6 +885,12 @@ static int sector_set(lua_State *L)
case sector_flooryoffset:
sector->flooryoffset = luaL_checkfixed(L, 3);
break;
case sector_floorxscale:
sector->floorxscale = luaL_checkfixed(L, 3);
break;
case sector_flooryscale:
sector->flooryscale = luaL_checkfixed(L, 3);
break;
case sector_floorangle:
sector->floorangle = luaL_checkangle(L, 3);
break;
@ -857,6 +903,12 @@ static int sector_set(lua_State *L)
case sector_ceilingyoffset:
sector->ceilingyoffset = luaL_checkfixed(L, 3);
break;
case sector_ceilingxscale:
sector->ceilingxscale = luaL_checkfixed(L, 3);
break;
case sector_ceilingyscale:
sector->ceilingyscale = luaL_checkfixed(L, 3);
break;
case sector_ceilingangle:
sector->ceilingangle = luaL_checkangle(L, 3);
break;
@ -1143,7 +1195,7 @@ static int line_num(lua_State *L)
static int sidenum_get(lua_State *L)
{
UINT16 *sidenum = *((UINT16 **)luaL_checkudata(L, 1, META_SIDENUM));
UINT32 *sidenum = *((UINT32 **)luaL_checkudata(L, 1, META_SIDENUM));
int i;
lua_settop(L, 2);
if (!lua_isnumber(L, 2))
@ -1210,11 +1262,31 @@ static int side_get(lua_State *L)
case side_offsety_mid:
lua_pushfixed(L, side->offsety_mid);
return 1;
case side_offsetx_bottom:
case side_offsetx_bot:
lua_pushfixed(L, side->offsetx_bot);
lua_pushfixed(L, side->offsetx_bottom);
return 1;
case side_offsety_bottom:
case side_offsety_bot:
lua_pushfixed(L, side->offsety_bot);
lua_pushfixed(L, side->offsety_bottom);
return 1;
case side_scalex_top:
lua_pushfixed(L, side->scalex_top);
return 1;
case side_scaley_top:
lua_pushfixed(L, side->scaley_top);
return 1;
case side_scalex_mid:
lua_pushfixed(L, side->scalex_mid);
return 1;
case side_scaley_mid:
lua_pushfixed(L, side->scaley_mid);
return 1;
case side_scalex_bottom:
lua_pushfixed(L, side->scalex_bottom);
return 1;
case side_scaley_bottom:
lua_pushfixed(L, side->scaley_bottom);
return 1;
case side_toptexture:
lua_pushinteger(L, side->toptexture);
@ -1302,10 +1374,30 @@ static int side_set(lua_State *L)
side->offsety_mid = luaL_checkfixed(L, 3);
break;
case side_offsetx_bot:
side->offsetx_bot = luaL_checkfixed(L, 3);
case side_offsetx_bottom:
side->offsetx_bottom = luaL_checkfixed(L, 3);
break;
case side_offsety_bot:
side->offsety_bot = luaL_checkfixed(L, 3);
case side_offsety_bottom:
side->offsety_bottom = luaL_checkfixed(L, 3);
break;
case side_scalex_top:
side->scalex_top = luaL_checkfixed(L, 3);
break;
case side_scaley_top:
side->scaley_top = luaL_checkfixed(L, 3);
break;
case side_scalex_mid:
side->scalex_mid = luaL_checkfixed(L, 3);
break;
case side_scaley_mid:
side->scaley_mid = luaL_checkfixed(L, 3);
break;
case side_scalex_bottom:
side->scalex_bottom = luaL_checkfixed(L, 3);
break;
case side_scaley_bottom:
side->scaley_bottom = luaL_checkfixed(L, 3);
break;
case side_toptexture:
side->toptexture = luaL_checkinteger(L, 3);
@ -2122,6 +2214,18 @@ static int ffloor_get(lua_State *L)
case ffloor_toplightlevel:
lua_pushinteger(L, *ffloor->toplightlevel);
return 1;
case ffloor_topxoffs:
lua_pushfixed(L, *ffloor->topxoffs);
return 1;
case ffloor_topyoffs:
lua_pushfixed(L, *ffloor->topyoffs);
return 1;
case ffloor_topxscale:
lua_pushfixed(L, *ffloor->topxscale);
return 1;
case ffloor_topyscale:
lua_pushfixed(L, *ffloor->topyscale);
return 1;
case ffloor_bottomheight:
lua_pushfixed(L, *ffloor->bottomheight);
return 1;
@ -2133,6 +2237,18 @@ static int ffloor_get(lua_State *L)
lua_pushlstring(L, levelflat->name, i);
return 1;
}
case ffloor_bottomxoffs:
lua_pushfixed(L, *ffloor->bottomxoffs);
return 1;
case ffloor_bottomyoffs:
lua_pushfixed(L, *ffloor->bottomyoffs);
return 1;
case ffloor_bottomxscale:
lua_pushfixed(L, *ffloor->bottomxscale);
return 1;
case ffloor_bottomyscale:
lua_pushfixed(L, *ffloor->bottomyscale);
return 1;
case ffloor_tslope:
LUA_PushUserdata(L, *ffloor->t_slope, META_SLOPE);
return 1;
@ -2317,6 +2433,18 @@ static int ffloor_set(lua_State *L)
case ffloor_toplightlevel:
*ffloor->toplightlevel = (INT16)luaL_checkinteger(L, 3);
break;
case ffloor_topxoffs:
*ffloor->topxoffs = luaL_checkfixed(L, 3);
break;
case ffloor_topyoffs:
*ffloor->topyoffs = luaL_checkfixed(L, 3);
break;
case ffloor_topxscale:
*ffloor->topxscale = luaL_checkfixed(L, 3);
break;
case ffloor_topyscale:
*ffloor->topyscale = luaL_checkfixed(L, 3);
break;
case ffloor_bottomheight: { // bottomheight
boolean flag;
fixed_t lastpos = *ffloor->bottomheight;
@ -2335,6 +2463,18 @@ static int ffloor_set(lua_State *L)
case ffloor_bottompic:
*ffloor->bottompic = P_AddLevelFlatRuntime(luaL_checkstring(L, 3));
break;
case ffloor_bottomxoffs:
*ffloor->bottomxoffs = luaL_checkfixed(L, 3);
break;
case ffloor_bottomyoffs:
*ffloor->bottomyoffs = luaL_checkfixed(L, 3);
break;
case ffloor_bottomxscale:
*ffloor->bottomxscale = luaL_checkfixed(L, 3);
break;
case ffloor_bottomyscale:
*ffloor->bottomyscale = luaL_checkfixed(L, 3);
break;
case ffloor_fofflags: {
ffloortype_e oldflags = ffloor->fofflags; // store FOF's old flags
ffloor->fofflags = luaL_checkinteger(L, 3);

5
src/lua_mobjlib.c
View file

@ -641,10 +641,7 @@ static int mobj_set(lua_State *L)
mo->tics = luaL_checkinteger(L, 3);
break;
case mobj_state: // set state by enum
if (mo->player)
P_SetPlayerMobjState(mo, luaL_checkinteger(L, 3));
else
P_SetMobjState(mo, luaL_checkinteger(L, 3));
P_SetMobjState(mo, luaL_checkinteger(L, 3));
break;
case mobj_flags: // special handling for MF_NOBLOCKMAP and MF_NOSECTOR
{

88
src/lua_script.c
View file

@ -604,64 +604,114 @@ void LUA_ClearExtVars(void)
INT32 lua_lumploading = 0;
// Load a script from a MYFILE
static inline void LUA_LoadFile(MYFILE *f, char *name, boolean noresults)
static inline boolean LUA_LoadFile(MYFILE *f, char *name)
{
int errorhandlerindex;
boolean success;
if (!name)
name = wadfiles[f->wad]->filename;
CONS_Printf("Loading Lua script from %s\n", name);
if (!gL) // Lua needs to be initialized
LUA_ClearState();
lua_pushinteger(gL, f->wad);
lua_setfield(gL, LUA_REGISTRYINDEX, "WAD");
lua_pushcfunction(gL, LUA_GetErrorMessage);
errorhandlerindex = lua_gettop(gL);
success = !luaL_loadbuffer(gL, f->data, f->size, va("@%s",name));
if (!success) {
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL,-1));
lua_pop(gL,1);
}
lua_gc(gL, LUA_GCCOLLECT, 0);
lua_remove(gL, errorhandlerindex);
return success;
}
// Runs a script loaded by LUA_LoadFile.
static inline void LUA_DoFile(boolean noresults)
{
int errorhandlerindex;
if (!gL) // LUA_LoadFile should've allocated gL for us!
return;
lua_lumploading++; // turn on loading flag
lua_pushcfunction(gL, LUA_GetErrorMessage);
errorhandlerindex = lua_gettop(gL);
if (luaL_loadbuffer(gL, f->data, f->size, va("@%s",name)) || lua_pcall(gL, 0, noresults ? 0 : LUA_MULTRET, lua_gettop(gL) - 1)) {
lua_insert(gL, -2); // move the function we're calling to the top.
errorhandlerindex = lua_gettop(gL) - 1;
if (lua_pcall(gL, 0, noresults ? 0 : LUA_MULTRET, lua_gettop(gL) - 1)) {
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL,-1));
lua_pop(gL,1);
}
lua_gc(gL, LUA_GCCOLLECT, 0);
lua_remove(gL, errorhandlerindex);
lua_lumploading--; // turn off again
}
// Load a script from a lump
void LUA_LoadLump(UINT16 wad, UINT16 lump, boolean noresults)
static inline MYFILE *LUA_GetFile(UINT16 wad, UINT16 lump, char **name)
{
MYFILE f;
char *name;
MYFILE *f = Z_Malloc(sizeof(MYFILE), PU_LUA, NULL);
size_t len;
f.wad = wad;
f.size = W_LumpLengthPwad(wad, lump);
f.data = Z_Malloc(f.size, PU_LUA, NULL);
W_ReadLumpPwad(wad, lump, f.data);
f.curpos = f.data;
f->wad = wad;
f->size = W_LumpLengthPwad(wad, lump);
f->data = Z_Malloc(f->size, PU_LUA, NULL);
W_ReadLumpPwad(wad, lump, f->data);
f->curpos = f->data;
len = strlen(wadfiles[wad]->filename); // length of file name
if (wadfiles[wad]->type == RET_LUA)
{
name = malloc(len+1);
strcpy(name, wadfiles[wad]->filename);
*name = malloc(len+1);
strcpy(*name, wadfiles[wad]->filename);
}
else // If it's not a .lua file, copy the lump name in too.
{
lumpinfo_t *lump_p = &wadfiles[wad]->lumpinfo[lump];
len += 1 + strlen(lump_p->fullname); // length of file name, '|', and lump name
name = malloc(len+1);
sprintf(name, "%s|%s", wadfiles[wad]->filename, lump_p->fullname);
name[len] = '\0';
*name = malloc(len+1);
sprintf(*name, "%s|%s", wadfiles[wad]->filename, lump_p->fullname);
(*name)[len] = '\0'; // annoying that index takes priority over dereference, but w/e
}
LUA_LoadFile(&f, name, noresults); // actually load file!
return f;
}
// Load a script from a lump
boolean LUA_LoadLump(UINT16 wad, UINT16 lump)
{
char *name = NULL;
MYFILE *f = LUA_GetFile(wad, lump, &name);
boolean success = LUA_LoadFile(f, name); // actually load file!
free(name);
Z_Free(f.data);
Z_Free(f->data);
Z_Free(f);
return success;
}
void LUA_DoLump(UINT16 wad, UINT16 lump, boolean noresults)
{
boolean success = LUA_LoadLump(wad, lump);
if (success)
LUA_DoFile(noresults); // run it
}
#ifdef LUA_ALLOW_BYTECODE

3
src/lua_script.h
View file

@ -45,7 +45,8 @@ extern INT32 lua_lumploading; // is LUA_LoadLump being called?
int LUA_GetErrorMessage(lua_State *L);
int LUA_Call(lua_State *L, int nargs, int nresults, int errorhandlerindex);
void LUA_LoadLump(UINT16 wad, UINT16 lump, boolean noresults);
boolean LUA_LoadLump(UINT16 wad, UINT16 lump);
void LUA_DoLump(UINT16 wad, UINT16 lump, boolean noresults);
#ifdef LUA_ALLOW_BYTECODE
void LUA_DumpFile(const char *filename);
#endif

2
src/lua_taglib.c
View file

@ -228,7 +228,7 @@ static int taglist_get(lua_State *L)
}
else
{
lua_getmetatable(L, 1);
lua_getglobal(L, "taglist");
lua_replace(L, 1);
lua_rawget(L, 1);
return 1;

6
src/m_cheat.c
View file

@ -1019,7 +1019,7 @@ static void OP_CycleThings(INT32 amt)
if (players[0].mo->eflags & MFE_VERTICALFLIP) // correct z when flipped
players[0].mo->z += players[0].mo->height - FixedMul(mobjinfo[op_currentthing].height, players[0].mo->scale);
players[0].mo->height = FixedMul(mobjinfo[op_currentthing].height, players[0].mo->scale);
P_SetPlayerMobjState(players[0].mo, S_OBJPLACE_DUMMY);
P_SetMobjState(players[0].mo, S_OBJPLACE_DUMMY);
op_currentdoomednum = mobjinfo[op_currentthing].doomednum;
}
@ -1528,7 +1528,7 @@ void Command_ObjectPlace_f(void)
else
OP_CycleThings(0); // sets all necessary height values without cycling op_currentthing
P_SetPlayerMobjState(players[0].mo, S_OBJPLACE_DUMMY);
P_SetMobjState(players[0].mo, S_OBJPLACE_DUMMY);
}
// Or are we leaving it instead?
else
@ -1542,7 +1542,7 @@ void Command_ObjectPlace_f(void)
// If still in dummy state, get out of it.
if (players[0].mo->state == &states[S_OBJPLACE_DUMMY])
P_SetPlayerMobjState(players[0].mo, op_oldstate);
P_SetMobjState(players[0].mo, op_oldstate);
// Reset everything back to how it was before we entered objectplace.
P_UnsetThingPosition(players[0].mo);

3
src/m_fixed.h
View file

@ -34,6 +34,7 @@
*/
typedef INT32 fixed_t;
typedef UINT32 ufixed_t;
/*!
\brief convert fixed_t into floating number
@ -106,7 +107,7 @@ FUNCMATH FUNCINLINE static ATTRINLINE fixed_t FixedInt(fixed_t a)
*/
FUNCMATH FUNCINLINE static ATTRINLINE fixed_t FixedDiv(fixed_t a, fixed_t b)
{
if ((abs(a) >> (FRACBITS-2)) >= abs(b))
if (((ufixed_t)abs(a) >> (FRACBITS-2)) >= (ufixed_t)abs(b))
return (a^b) < 0 ? INT32_MIN : INT32_MAX;
return FixedDiv2(a, b);

176
src/m_menu.c
View file

@ -3179,40 +3179,42 @@ boolean M_Responder(event_t *ev)
}
else if (menuactive)
{
if (ev->type == ev_keydown)
if (ev->type == ev_keydown || ev->type == ev_text)
{
keydown++;
ch = ev->key;
// added 5-2-98 remap virtual keys (mouse & joystick buttons)
switch (ch)
if (ev->type == ev_keydown)
{
case KEY_MOUSE1:
case KEY_JOY1:
ch = KEY_ENTER;
break;
case KEY_JOY1 + 3:
ch = 'n';
break;
case KEY_MOUSE1 + 1:
case KEY_JOY1 + 1:
ch = KEY_ESCAPE;
break;
case KEY_JOY1 + 2:
ch = KEY_BACKSPACE;
break;
case KEY_HAT1:
ch = KEY_UPARROW;
break;
case KEY_HAT1 + 1:
ch = KEY_DOWNARROW;
break;
case KEY_HAT1 + 2:
ch = KEY_LEFTARROW;
break;
case KEY_HAT1 + 3:
ch = KEY_RIGHTARROW;
break;
keydown++;
// added 5-2-98 remap virtual keys (mouse & joystick buttons)
switch (ch)
{
case KEY_MOUSE1:
case KEY_JOY1:
ch = KEY_ENTER;
break;
case KEY_JOY1 + 3:
ch = 'n';
break;
case KEY_MOUSE1 + 1:
case KEY_JOY1 + 1:
ch = KEY_ESCAPE;
break;
case KEY_JOY1 + 2:
ch = KEY_BACKSPACE;
break;
case KEY_HAT1:
ch = KEY_UPARROW;
break;
case KEY_HAT1 + 1:
ch = KEY_DOWNARROW;
break;
case KEY_HAT1 + 2:
ch = KEY_LEFTARROW;
break;
case KEY_HAT1 + 3:
ch = KEY_RIGHTARROW;
break;
}
}
}
else if (ev->type == ev_joystick && ev->key == 0 && joywait < I_GetTime())
@ -3374,8 +3376,11 @@ boolean M_Responder(event_t *ev)
// Handle menuitems which need a specific key handling
if (routine && (currentMenu->menuitems[itemOn].status & IT_TYPE) == IT_KEYHANDLER)
{
if (shiftdown && ch >= 32 && ch <= 127)
ch = shiftxform[ch];
// ignore ev_keydown events if the key maps to a character, since
// the ev_text event will follow immediately after in that case.
if (ev->type == ev_keydown && ch >= 32 && ch <= 127)
return true;
routine(ch);
return true;
}
@ -3417,6 +3422,11 @@ boolean M_Responder(event_t *ev)
{
if ((currentMenu->menuitems[itemOn].status & IT_CVARTYPE) == IT_CV_STRING)
{
// ignore ev_keydown events if the key maps to a character, since
// the ev_text event will follow immediately after in that case.
if (ev->type == ev_keydown && ch >= 32 && ch <= 127)
return false;
if (M_ChangeStringCvar(ch))
return true;
else
@ -4130,31 +4140,97 @@ void M_DrawTextBox(INT32 x, INT32 y, INT32 width, INT32 boxlines)
*/
}
static fixed_t staticalong = 0;
//
// Draw the TV static effect on unavailable map icons
//
static void M_DrawStaticBox(fixed_t x, fixed_t y, INT32 flags, fixed_t w, fixed_t h)
{
patch_t *patch;
fixed_t sw, pw;
patch_t *patch = W_CachePatchName("LSSTATIC", PU_PATCH);
static fixed_t staticx = 0, staticy = 0; // Keep track of where we are across function calls
patch = W_CachePatchName("LSSTATIC", PU_PATCH);
pw = patch->width - (sw = w*2); //FixedDiv(w, scale); -- for scale FRACUNIT/2
/*if (pw > 0) -- model code for modders providing weird LSSTATIC
if (!patch->width || !patch->height) // Shouldn't be necessary, but I don't want to get in trouble!
{
if (staticalong > pw)
staticalong -= pw;
W_UnlockCachedPatch(patch);
return;
}
else
staticalong = 0;*/
if (patch->width == 1) // Nothing to randomise or tile
{
// Just stretch the patch over the whole box - no need to draw it 160 times over
// Technically, we should crop and maybe tile and randomise the Y axis, but... it's not worth it here
V_DrawStretchyFixedPatch(x*FRACUNIT, y*FRACUNIT, (w*FRACUNIT) / patch->width, (h*FRACUNIT) / patch->height, flags, patch, NULL);
W_UnlockCachedPatch(patch);
return;
}
if (patch->width == 160) // Something to randomise or tile - but don't!
{
// If it's 160 pixels wide, the modder probably wants the patch fixed in place
// But instead of "just drawing" it, why not allow sequential frames of animation on the Y axis?
// For example, this could be used to make a vignette effect, whether animated or not
// This function is primarily called with a patch region of 160x100, so the frames must be 160x100 too
fixed_t temp = patch->height / 100; // Amount of 160x100 frames in the patch
if (temp) // Don't modulo by zero
temp = (gametic % temp) * h*2*FRACUNIT; // Which frame to draw
if (staticalong > pw) // simplified for base LSSTATIC
staticalong -= pw;
V_DrawCroppedPatch(x*FRACUNIT, y*FRACUNIT, (w*FRACUNIT) / 160, (h*FRACUNIT) / 100, flags, patch, NULL, 0, temp, w*2*FRACUNIT, h*2*FRACUNIT);
W_UnlockCachedPatch(patch);
return;
}
V_DrawCroppedPatch(x<<FRACBITS, y<<FRACBITS, FRACUNIT/2, FRACUNIT/2, flags, patch, NULL, staticalong<<FRACBITS, 0, sw<<FRACBITS, h*2<<FRACBITS); // FixedDiv(h, scale)); -- for scale FRACUNIT/2
staticalong += sw; //M_RandomRange(sw/2, 2*sw); -- turns out less randomisation looks better because immediately adjacent frames can't end up close to each other
// If the patch isn't 1 or 160 pixels wide, that means that it's time for randomised static!
// First, randomise the static patch's offset - It's largely just based on "w", but there's...
// ...the tiniest bit of randomisation, to keep it animated even when the patch width is 160 x [static boxes on-screen]
// Making it TOO randomised could make it randomise to the almost-same position multiple frames in a row - that's bad
staticx = (staticx + (w*4) + (M_RandomByte() % 4)) % (patch->width*2);
if (patch->height == h*2) // Is the patch 100 pixels tall? If so, reset "staticy"...
staticy = 0; // ...in case that one add-on would randomise it and a later add-on wouldn't
else // Otherwise, as we already make "staticx" near-sequential, I think that making "staticy"...
staticy = M_RandomRange(0, (patch->height*2) - 1); // ...fully random instead of sequential increases the... randomness
// The drawing function calls can get a bit lengthy, so let's make a little shortcut
#define DRAWSTATIC(_x,_y,_sx,_sy,_w,_h) V_DrawCroppedPatch((x*FRACUNIT)+((_x)*FRACUNIT/4), (y*FRACUNIT)+((_y)*FRACUNIT/4),\
FRACUNIT/2, FRACUNIT/2, flags, patch, NULL, (_sx)*FRACUNIT/2, (_sy)*FRACUNIT/2, (w*2*FRACUNIT)+((_w)*FRACUNIT/2), (h*2*FRACUNIT)+((_h)*FRACUNIT/2))
// And finally, let's draw it! Don't worry about "staticx" plus "w*2" potentially going off-patch
DRAWSTATIC(0, 0, staticx, staticy, 0, 0); // This gets drawn in all cases
if ((patch->width*2) - staticx >= w*4) // No horizontal tiling
{
if ((patch->height*2) - staticy >= h*4) // Simplest-case scenario, no tiling at all
{}
else // Vertical tiling only
{
for (INT16 j = 2; ((patch->height*j) - staticy) < h*4; j += 2)
DRAWSTATIC(0, (patch->height*j) - staticy, staticx, 0, 0, staticy - (patch->height*j));
}
}
else // Horizontal tiling
{
if ((patch->height*2) - staticy >= h*4) // Horizontal tiling only
{
for (INT16 i = 2; ((patch->width*i) - staticx) < w*4; i += 2)
DRAWSTATIC((patch->width*i) - staticx, 0, 0, staticy, staticx - (patch->width*i), 0);
}
else // Horizontal and vertical tiling
{
for (INT16 j = 2; ((patch->height*j) - staticy) < h*4; j += 2)
DRAWSTATIC(0, (patch->height*j) - staticy, staticx, 0, 0, staticy - (patch->height*j));
for (INT16 i = 2; ((patch->width*i) - staticx) < w*4; i += 2)
{
DRAWSTATIC((patch->width*i) - staticx, 0, 0, staticy, staticx - (patch->width*i), 0);
for (INT16 j = 2; ((patch->height*j) - staticy) < h*4; j += 2)
DRAWSTATIC((patch->width*i) - staticx, (patch->height*j) - staticy, 0, 0, staticx - (patch->width*i), staticy - (patch->height*j));
}
}
}
#undef DRAWSTATIC
// Now that we're done with the patch, it's time to say our goodbyes. Until next time, patch!
W_UnlockCachedPatch(patch);
}
@ -11268,6 +11344,8 @@ static void M_DrawConnectMenu(void)
V_DrawSmallString(currentMenu->x+202, S_LINEY(i)+8, globalflags, "\x85" "Mod");
if (serverlist[slindex].info.cheatsenabled)
V_DrawSmallString(currentMenu->x+222, S_LINEY(i)+8, globalflags, "\x83" "Cheats");
if (Net_IsNodeIPv6(serverlist[slindex].node))
V_DrawSmallString(currentMenu->x+252, S_LINEY(i)+8, globalflags, "\x84" "IPv6");
V_DrawSmallString(currentMenu->x, S_LINEY(i)+8, globalflags,
va("Ping: %u", (UINT32)LONG(serverlist[slindex].info.time)));
@ -11961,7 +12039,7 @@ static void M_HandleConnectIP(INT32 choice)
// Rudimentary number and period enforcing - also allows letters so hostnames can be used instead
// and square brackets for RFC 2732 IPv6 addresses
if ((choice >= '-' && choice <= ':') ||
(choice == '[' || choice == ']') ||
(choice == '[' || choice == ']' || choice == '%') ||
(choice >= 'A' && choice <= 'Z') ||
(choice >= 'a' && choice <= 'z'))
{

421
src/m_misc.c
View file

@ -2207,430 +2207,11 @@ char *sizeu5(size_t num)
return sizeu5_buf;
}
#if defined (__GNUC__) && defined (__i386__) // from libkwave, under GPL
// Alam: note libkwave memcpy code comes from mplayer's libvo/aclib_template.c, r699
/* for small memory blocks (<256 bytes) this version is faster */
#define small_memcpy(dest,src,n)\
{\
register unsigned long int dummy;\
__asm__ __volatile__(\
"cld\n\t"\
"rep; movsb"\
:"=&D"(dest), "=&S"(src), "=&c"(dummy)\
:"0" (dest), "1" (src),"2" (n)\
: "memory", "cc");\
}
/* linux kernel __memcpy (from: /include/asm/string.h) */
ATTRINLINE static FUNCINLINE void *__memcpy (void *dest, const void * src, size_t n)
void *M_Memcpy(void *dest, const void *src, size_t n)
{
int d0, d1, d2;
if ( n < 4 )
{
small_memcpy(dest, src, n);
}
else
{
__asm__ __volatile__ (
"rep ; movsl;"
"testb $2,%b4;"
"je 1f;"
"movsw;"
"1:\ttestb $1,%b4;"
"je 2f;"
"movsb;"
"2:"
: "=&c" (d0), "=&D" (d1), "=&S" (d2)
:"0" (n/4), "q" (n),"1" ((long) dest),"2" ((long) src)
: "memory");
}
return dest;
}
#define SSE_MMREG_SIZE 16
#define MMX_MMREG_SIZE 8
#define MMX1_MIN_LEN 0x800 /* 2K blocks */
#define MIN_LEN 0x40 /* 64-byte blocks */
/* SSE note: i tried to move 128 bytes a time instead of 64 but it
didn't make any measureable difference. i'm using 64 for the sake of
simplicity. [MF] */
static /*FUNCTARGET("sse2")*/ void *sse_cpy(void * dest, const void * src, size_t n)
{
void *retval = dest;
size_t i;
/* PREFETCH has effect even for MOVSB instruction ;) */
__asm__ __volatile__ (
"prefetchnta (%0);"
"prefetchnta 32(%0);"
"prefetchnta 64(%0);"
"prefetchnta 96(%0);"
"prefetchnta 128(%0);"
"prefetchnta 160(%0);"
"prefetchnta 192(%0);"
"prefetchnta 224(%0);"
"prefetchnta 256(%0);"
"prefetchnta 288(%0);"
: : "r" (src) );
if (n >= MIN_LEN)
{
register unsigned long int delta;
/* Align destinition to MMREG_SIZE -boundary */
delta = ((unsigned long int)dest)&(SSE_MMREG_SIZE-1);
if (delta)
{
delta=SSE_MMREG_SIZE-delta;
n -= delta;
small_memcpy(dest, src, delta);
}
i = n >> 6; /* n/64 */
n&=63;
if (((unsigned long)src) & 15)
/* if SRC is misaligned */
for (; i>0; i--)
{
__asm__ __volatile__ (
"prefetchnta 320(%0);"
"prefetchnta 352(%0);"
"movups (%0), %%xmm0;"
"movups 16(%0), %%xmm1;"
"movups 32(%0), %%xmm2;"
"movups 48(%0), %%xmm3;"
"movntps %%xmm0, (%1);"
"movntps %%xmm1, 16(%1);"
"movntps %%xmm2, 32(%1);"
"movntps %%xmm3, 48(%1);"
:: "r" (src), "r" (dest) : "memory");
src = (const unsigned char *)src + 64;
dest = (unsigned char *)dest + 64;
}
else
/*
Only if SRC is aligned on 16-byte boundary.
It allows to use movaps instead of movups, which required data
to be aligned or a general-protection exception (#GP) is generated.
*/
for (; i>0; i--)
{
__asm__ __volatile__ (
"prefetchnta 320(%0);"
"prefetchnta 352(%0);"
"movaps (%0), %%xmm0;"
"movaps 16(%0), %%xmm1;"
"movaps 32(%0), %%xmm2;"
"movaps 48(%0), %%xmm3;"
"movntps %%xmm0, (%1);"
"movntps %%xmm1, 16(%1);"
"movntps %%xmm2, 32(%1);"
"movntps %%xmm3, 48(%1);"
:: "r" (src), "r" (dest) : "memory");
src = ((const unsigned char *)src) + 64;
dest = ((unsigned char *)dest) + 64;
}
/* since movntq is weakly-ordered, a "sfence"
* is needed to become ordered again. */
__asm__ __volatile__ ("sfence":::"memory");
/* enables to use FPU */
__asm__ __volatile__ ("emms":::"memory");
}
/*
* Now do the tail of the block
*/
if (n) __memcpy(dest, src, n);
return retval;
}
static FUNCTARGET("mmx") void *mmx2_cpy(void *dest, const void *src, size_t n)
{
void *retval = dest;
size_t i;
/* PREFETCH has effect even for MOVSB instruction ;) */
__asm__ __volatile__ (
"prefetchnta (%0);"
"prefetchnta 32(%0);"
"prefetchnta 64(%0);"
"prefetchnta 96(%0);"
"prefetchnta 128(%0);"
"prefetchnta 160(%0);"
"prefetchnta 192(%0);"
"prefetchnta 224(%0);"
"prefetchnta 256(%0);"
"prefetchnta 288(%0);"
: : "r" (src));
if (n >= MIN_LEN)
{
register unsigned long int delta;
/* Align destinition to MMREG_SIZE -boundary */
delta = ((unsigned long int)dest)&(MMX_MMREG_SIZE-1);
if (delta)
{
delta=MMX_MMREG_SIZE-delta;
n -= delta;
small_memcpy(dest, src, delta);
}
i = n >> 6; /* n/64 */
n&=63;
for (; i>0; i--)
{
__asm__ __volatile__ (
"prefetchnta 320(%0);"
"prefetchnta 352(%0);"
"movq (%0), %%mm0;"
"movq 8(%0), %%mm1;"
"movq 16(%0), %%mm2;"
"movq 24(%0), %%mm3;"
"movq 32(%0), %%mm4;"
"movq 40(%0), %%mm5;"
"movq 48(%0), %%mm6;"
"movq 56(%0), %%mm7;"
"movntq %%mm0, (%1);"
"movntq %%mm1, 8(%1);"
"movntq %%mm2, 16(%1);"
"movntq %%mm3, 24(%1);"
"movntq %%mm4, 32(%1);"
"movntq %%mm5, 40(%1);"
"movntq %%mm6, 48(%1);"
"movntq %%mm7, 56(%1);"
:: "r" (src), "r" (dest) : "memory");
src = ((const unsigned char *)src) + 64;
dest = ((unsigned char *)dest) + 64;
}
/* since movntq is weakly-ordered, a "sfence"
* is needed to become ordered again. */
__asm__ __volatile__ ("sfence":::"memory");
__asm__ __volatile__ ("emms":::"memory");
}
/*
* Now do the tail of the block
*/
if (n) __memcpy(dest, src, n);
return retval;
}
static FUNCTARGET("mmx") void *mmx1_cpy(void *dest, const void *src, size_t n) //3DNOW
{
void *retval = dest;
size_t i;
/* PREFETCH has effect even for MOVSB instruction ;) */
__asm__ __volatile__ (
"prefetch (%0);"
"prefetch 32(%0);"
"prefetch 64(%0);"
"prefetch 96(%0);"
"prefetch 128(%0);"
"prefetch 160(%0);"
"prefetch 192(%0);"
"prefetch 224(%0);"
"prefetch 256(%0);"
"prefetch 288(%0);"
: : "r" (src));
if (n >= MMX1_MIN_LEN)
{
register unsigned long int delta;
/* Align destinition to MMREG_SIZE -boundary */
delta = ((unsigned long int)dest)&(MMX_MMREG_SIZE-1);
if (delta)
{
delta=MMX_MMREG_SIZE-delta;
n -= delta;
small_memcpy(dest, src, delta);
}
i = n >> 6; /* n/64 */
n&=63;
for (; i>0; i--)
{
__asm__ __volatile__ (
"prefetch 320(%0);"
"prefetch 352(%0);"
"movq (%0), %%mm0;"
"movq 8(%0), %%mm1;"
"movq 16(%0), %%mm2;"
"movq 24(%0), %%mm3;"
"movq 32(%0), %%mm4;"
"movq 40(%0), %%mm5;"
"movq 48(%0), %%mm6;"
"movq 56(%0), %%mm7;"
"movq %%mm0, (%1);"
"movq %%mm1, 8(%1);"
"movq %%mm2, 16(%1);"
"movq %%mm3, 24(%1);"
"movq %%mm4, 32(%1);"
"movq %%mm5, 40(%1);"
"movq %%mm6, 48(%1);"
"movq %%mm7, 56(%1);"
:: "r" (src), "r" (dest) : "memory");
src = ((const unsigned char *)src) + 64;
dest = ((unsigned char *)dest) + 64;
}
__asm__ __volatile__ ("femms":::"memory"); // same as mmx_cpy() but with a femms
}
/*
* Now do the tail of the block
*/
if (n) __memcpy(dest, src, n);
return retval;
}
#endif
// Alam: why? memcpy may be __cdecl/_System and our code may be not the same type
static void *cpu_cpy(void *dest, const void *src, size_t n)
{
if (src == NULL)
{
CONS_Debug(DBG_MEMORY, "Memcpy from 0x0?!: %p %p %s\n", dest, src, sizeu1(n));
return dest;
}
if(dest == NULL)
{
CONS_Debug(DBG_MEMORY, "Memcpy to 0x0?!: %p %p %s\n", dest, src, sizeu1(n));
return dest;
}
return memcpy(dest, src, n);
}
static /*FUNCTARGET("mmx")*/ void *mmx_cpy(void *dest, const void *src, size_t n)
{
#if defined (_MSC_VER) && defined (_X86_)
_asm
{
mov ecx, [n]
mov esi, [src]
mov edi, [dest]
shr ecx, 6 // mit mmx: 64bytes per iteration
jz lower_64 // if lower than 64 bytes
loop_64: // MMX transfers multiples of 64bytes
movq mm0, 0[ESI] // read sources
movq mm1, 8[ESI]
movq mm2, 16[ESI]
movq mm3, 24[ESI]
movq mm4, 32[ESI]
movq mm5, 40[ESI]
movq mm6, 48[ESI]
movq mm7, 56[ESI]
movq 0[EDI], mm0 // write destination
movq 8[EDI], mm1
movq 16[EDI], mm2
movq 24[EDI], mm3
movq 32[EDI], mm4
movq 40[EDI], mm5
movq 48[EDI], mm6
movq 56[EDI], mm7
add esi, 64
add edi, 64
dec ecx
jnz loop_64
emms // close mmx operation
lower_64:// transfer rest of buffer
mov ebx,esi
sub ebx,src
mov ecx,[n]
sub ecx,ebx
shr ecx, 3 // multiples of 8 bytes
jz lower_8
loop_8:
movq mm0, [esi] // read source
movq [edi], mm0 // write destination
add esi, 8
add edi, 8
dec ecx
jnz loop_8
emms // close mmx operation
lower_8:
mov ebx,esi
sub ebx,src
mov ecx,[n]
sub ecx,ebx
rep movsb
mov eax, [dest] // return dest
}
#elif defined (__GNUC__) && defined (__i386__)
void *retval = dest;
size_t i;
if (n >= MMX1_MIN_LEN)
{
register unsigned long int delta;
/* Align destinition to MMREG_SIZE -boundary */
delta = ((unsigned long int)dest)&(MMX_MMREG_SIZE-1);
if (delta)
{
delta=MMX_MMREG_SIZE-delta;
n -= delta;
small_memcpy(dest, src, delta);
}
i = n >> 6; /* n/64 */
n&=63;
for (; i>0; i--)
{
__asm__ __volatile__ (
"movq (%0), %%mm0;"
"movq 8(%0), %%mm1;"
"movq 16(%0), %%mm2;"
"movq 24(%0), %%mm3;"
"movq 32(%0), %%mm4;"
"movq 40(%0), %%mm5;"
"movq 48(%0), %%mm6;"
"movq 56(%0), %%mm7;"
"movq %%mm0, (%1);"
"movq %%mm1, 8(%1);"
"movq %%mm2, 16(%1);"
"movq %%mm3, 24(%1);"
"movq %%mm4, 32(%1);"
"movq %%mm5, 40(%1);"
"movq %%mm6, 48(%1);"
"movq %%mm7, 56(%1);"
:: "r" (src), "r" (dest) : "memory");
src = ((const unsigned char *)src) + 64;
dest = ((unsigned char *)dest) + 64;
}
__asm__ __volatile__ ("emms":::"memory");
}
/*
* Now do the tail of the block
*/
if (n) __memcpy(dest, src, n);
return retval;
#else
return cpu_cpy(dest, src, n);
#endif
}
void *(*M_Memcpy)(void* dest, const void* src, size_t n) = cpu_cpy;
/** Memcpy that uses MMX, 3DNow, MMXExt or even SSE
* Do not use on overlapped memory, use memmove for that
*/
void M_SetupMemcpy(void)
{
#if defined (__GNUC__) && defined (__i386__)
if (R_SSE2)
M_Memcpy = sse_cpy;
else if (R_MMXExt)
M_Memcpy = mmx2_cpy;
else if (R_3DNow)
M_Memcpy = mmx1_cpy;
else
#endif
if (R_MMX)
M_Memcpy = mmx_cpy;
#if 0
M_Memcpy = cpu_cpy;
#endif
}
/** Return the appropriate message for a file error or end of file.
*/
const char *M_FileError(FILE *fp)

145
src/m_perfstats.c
View file

@ -65,7 +65,10 @@ static ps_metric_t ps_removecount = {0};
ps_metric_t ps_checkposition_calls = {0};
ps_metric_t ps_lua_prethinkframe_time = {0};
ps_metric_t ps_lua_thinkframe_time = {0};
ps_metric_t ps_lua_postthinkframe_time = {0};
ps_metric_t ps_lua_mobjhooks = {0};
ps_metric_t ps_otherlogictime = {0};
@ -157,7 +160,9 @@ perfstatrow_t gamelogic_rows[] = {
{" mobjs ", " Mobjs: ", &ps_thlist_times[THINK_MOBJ], PS_TIME|PS_LEVEL},
{" dynslop", " Dynamic slopes: ", &ps_thlist_times[THINK_DYNSLOPE], PS_TIME|PS_LEVEL},
{" precip ", " Precipitation: ", &ps_thlist_times[THINK_PRECIP], PS_TIME|PS_LEVEL},
{" lprethinkf", " LUAh_PreThinkFrame:", &ps_lua_prethinkframe_time, PS_TIME|PS_LEVEL},
{" lthinkf", " LUAh_ThinkFrame:", &ps_lua_thinkframe_time, PS_TIME|PS_LEVEL},
{" lpostthinkf", " LUAh_PostThinkFrame:", &ps_lua_postthinkframe_time, PS_TIME|PS_LEVEL},
{" other ", " Other: ", &ps_otherlogictime, PS_TIME|PS_LEVEL},
{0}
};
@ -192,10 +197,43 @@ int ps_frame_index = 0;
int ps_tick_index = 0;
// dynamically allocated resizeable array for thinkframe hook stats
ps_hookinfo_t *prethinkframe_hooks = NULL;
int prethinkframe_hooks_length = 0;
int prethinkframe_hooks_capacity = 16;
ps_hookinfo_t *thinkframe_hooks = NULL;
int thinkframe_hooks_length = 0;
int thinkframe_hooks_capacity = 16;
ps_hookinfo_t *postthinkframe_hooks = NULL;
int postthinkframe_hooks_length = 0;
int postthinkframe_hooks_capacity = 16;
void PS_SetPreThinkFrameHookInfo(int index, precise_t time_taken, char* short_src)
{
if (!prethinkframe_hooks)
{
// array needs to be initialized
prethinkframe_hooks = Z_Calloc(sizeof(ps_hookinfo_t) * prethinkframe_hooks_capacity, PU_STATIC, NULL);
}
if (index >= prethinkframe_hooks_capacity)
{
// array needs more space, realloc with double size
int new_capacity = prethinkframe_hooks_capacity * 2;
prethinkframe_hooks = Z_Realloc(prethinkframe_hooks,
sizeof(ps_hookinfo_t) * new_capacity, PU_STATIC, NULL);
// initialize new memory with zeros so the pointers in the structs are null
memset(&prethinkframe_hooks[prethinkframe_hooks_capacity], 0,
sizeof(ps_hookinfo_t) * prethinkframe_hooks_capacity);
prethinkframe_hooks_capacity = new_capacity;
}
prethinkframe_hooks[index].time_taken.value.p = time_taken;
memcpy(prethinkframe_hooks[index].short_src, short_src, LUA_IDSIZE * sizeof(char));
// since the values are set sequentially from begin to end, the last call should leave
// the correct value to this variable
prethinkframe_hooks_length = index + 1;
}
void PS_SetThinkFrameHookInfo(int index, precise_t time_taken, char* short_src)
{
if (!thinkframe_hooks)
@ -221,6 +259,31 @@ void PS_SetThinkFrameHookInfo(int index, precise_t time_taken, char* short_src)
thinkframe_hooks_length = index + 1;
}
void PS_SetPostThinkFrameHookInfo(int index, precise_t time_taken, char* short_src)
{
if (!postthinkframe_hooks)
{
// array needs to be initialized
postthinkframe_hooks = Z_Calloc(sizeof(ps_hookinfo_t) * postthinkframe_hooks_capacity, PU_STATIC, NULL);
}
if (index >= postthinkframe_hooks_capacity)
{
// array needs more space, realloc with double size
int new_capacity = postthinkframe_hooks_capacity * 2;
postthinkframe_hooks = Z_Realloc(postthinkframe_hooks,
sizeof(ps_hookinfo_t) * new_capacity, PU_STATIC, NULL);
// initialize new memory with zeros so the pointers in the structs are null
memset(&postthinkframe_hooks[postthinkframe_hooks_capacity], 0,
sizeof(ps_hookinfo_t) * postthinkframe_hooks_capacity);
postthinkframe_hooks_capacity = new_capacity;
}
postthinkframe_hooks[index].time_taken.value.p = time_taken;
memcpy(postthinkframe_hooks[index].short_src, short_src, LUA_IDSIZE * sizeof(char));
// since the values are set sequentially from begin to end, the last call should leave
// the correct value to this variable
postthinkframe_hooks_length = index + 1;
}
static boolean PS_HighResolution(void)
{
return (vid.width >= 640 && vid.height >= 400);
@ -564,7 +627,9 @@ void PS_UpdateTickStats(void)
ps_tictime.value.p -
ps_playerthink_time.value.p -
ps_thinkertime.value.p -
ps_lua_thinkframe_time.value.p;
ps_lua_prethinkframe_time.value.p -
ps_lua_thinkframe_time.value.p -
ps_lua_postthinkframe_time.value.p;
PS_CountThinkers();
}
@ -576,21 +641,35 @@ void PS_UpdateTickStats(void)
PS_UpdateRowHistories(misc_calls_rows, false);
}
}
if (cv_perfstats.value == 3 && cv_ps_samplesize.value > 1 && PS_IsLevelActive())
if (cv_ps_samplesize.value > 1)
{
int i;
for (i = 0; i < thinkframe_hooks_length; i++)
if(cv_perfstats.value >= 3 && PS_IsLevelActive())
{
PS_UpdateMetricHistory(&thinkframe_hooks[i].time_taken, true, false, false);
int i;
if (cv_perfstats.value == 3)
{
for (i = 0; i < thinkframe_hooks_length; i++)
PS_UpdateMetricHistory(&thinkframe_hooks[i].time_taken, true, false, false);
}
else if (cv_perfstats.value == 4)
{
for (i = 0; i < prethinkframe_hooks_length; i++)
PS_UpdateMetricHistory(&prethinkframe_hooks[i].time_taken, true, false, false);
}
else if (cv_perfstats.value == 5)
{
for (i = 0; i < postthinkframe_hooks_length; i++)
PS_UpdateMetricHistory(&postthinkframe_hooks[i].time_taken, true, false, false);
}
}
if (cv_perfstats.value)
{
ps_tick_index++;
if (ps_tick_index >= cv_ps_samplesize.value)
ps_tick_index = 0;
if (ps_tick_samples_left)
ps_tick_samples_left--;
}
}
if (cv_perfstats.value && cv_ps_samplesize.value > 1)
{
ps_tick_index++;
if (ps_tick_index >= cv_ps_samplesize.value)
ps_tick_index = 0;
if (ps_tick_samples_left)
ps_tick_samples_left--;
}
}
@ -610,7 +689,7 @@ static void PS_DrawDescriptorHeader(void)
int samples_left = max(ps_frame_samples_left, ps_tick_samples_left);
int x, y;
if (cv_perfstats.value == 3)
if (cv_perfstats.value >= 3)
{
x = 2;
y = 0;
@ -697,7 +776,7 @@ static void PS_DrawGameLogicStats(void)
PS_DrawPerfRows(x, y, V_PURPLEMAP, misc_calls_rows);
}
static void PS_DrawThinkFrameStats(void)
static void draw_think_frame_stats(int hook_length, ps_hookinfo_t *hook)
{
char s[100];
int i;
@ -711,7 +790,7 @@ static void PS_DrawThinkFrameStats(void)
PS_DrawDescriptorHeader();
for (i = 0; i < thinkframe_hooks_length; i++)
for (i = 0; i < hook_length; i++)
{
#define NEXT_ROW() \
@ -724,7 +803,7 @@ if (y > 192) \
break; \
}
char* str = thinkframe_hooks[i].short_src;
char* str = hook[i].short_src;
char* tempstr = tempbuffer;
int len = (int)strlen(str);
char* str_ptr;
@ -771,7 +850,7 @@ if (y > 192) \
if (len > 20)
str += len - 20;
snprintf(s, sizeof s - 1, "%20s: %d", str,
PS_GetMetricScreenValue(&thinkframe_hooks[i].time_taken, true));
PS_GetMetricScreenValue(&hook[i].time_taken, true));
V_DrawSmallString(x, y, V_MONOSPACE | V_ALLOWLOWERCASE | text_color, s);
NEXT_ROW()
@ -780,6 +859,21 @@ if (y > 192) \
}
}
static void PS_DrawPreThinkFrameStats(void)
{
draw_think_frame_stats(prethinkframe_hooks_length, prethinkframe_hooks);
}
static void PS_DrawThinkFrameStats(void)
{
draw_think_frame_stats(thinkframe_hooks_length, thinkframe_hooks);
}
static void PS_DrawPostThinkFrameStats(void)
{
draw_think_frame_stats(postthinkframe_hooks_length, postthinkframe_hooks);
}
void M_DrawPerfStats(void)
{
if (cv_perfstats.value == 1) // rendering
@ -793,7 +887,7 @@ void M_DrawPerfStats(void)
// tics when frame skips happen
PS_DrawGameLogicStats();
}
else if (cv_perfstats.value == 3) // lua thinkframe
else if (cv_perfstats.value >= 3) // lua thinkframe
{
if (!PS_IsLevelActive())
return;
@ -802,13 +896,22 @@ void M_DrawPerfStats(void)
// Low resolutions can't really use V_DrawSmallString that is used by thinkframe stats.
// A low-res version using V_DrawThinString could be implemented,
// but it would have much less space for information.
V_DrawThinString(80, 92, V_MONOSPACE | V_ALLOWLOWERCASE | V_YELLOWMAP, "Perfstats 3 is not available");
V_DrawThinString(80, 92, V_MONOSPACE | V_ALLOWLOWERCASE | V_YELLOWMAP, "Lua Perfstats is not available");
V_DrawThinString(80, 100, V_MONOSPACE | V_ALLOWLOWERCASE | V_YELLOWMAP, "for resolutions below 640x400.");
return;
}
else
if (cv_perfstats.value == 3)
{
PS_DrawThinkFrameStats();
}
else if (cv_perfstats.value == 4)
{
PS_DrawPreThinkFrameStats();
}
else if (cv_perfstats.value == 5)
{
PS_DrawPostThinkFrameStats();
}
}
}

4
src/m_perfstats.h
View file

@ -43,12 +43,16 @@ extern ps_metric_t ps_thlist_times[];
extern ps_metric_t ps_checkposition_calls;
extern ps_metric_t ps_lua_prethinkframe_time;
extern ps_metric_t ps_lua_thinkframe_time;
extern ps_metric_t ps_lua_postthinkframe_time;
extern ps_metric_t ps_lua_mobjhooks;
extern ps_metric_t ps_otherlogictime;
void PS_SetPreThinkFrameHookInfo(int index, precise_t time_taken, char* short_src);
void PS_SetThinkFrameHookInfo(int index, precise_t time_taken, char* short_src);
void PS_SetPostThinkFrameHookInfo(int index, precise_t time_taken, char* short_src);
void PS_UpdateTickStats(void);

10
src/netcode/commands.c
View file

@ -79,7 +79,7 @@ static void Ban_Clear(void)
void Ban_Load_File(boolean warning)
{
FILE *f;
const char *address, *mask;
char *address, *mask;
char buffer[MAX_WADPATH];
if (!I_ClearBans)
@ -100,6 +100,14 @@ void Ban_Load_File(boolean warning)
{
address = strtok(buffer, " \t\r\n");
mask = strtok(NULL, " \t\r\n");
if (address[0] == '[')
{
size_t len;
address++;
len = strlen(address);
if (address[len-1] == ']')
address[len-1] = '\0';
}
I_SetBanAddress(address, mask);

40
src/netcode/d_clisrv.c
View file

@ -90,8 +90,8 @@ INT16 consistancy[BACKUPTICS];
// true when a player is connecting or disconnecting so that the gameplay has stopped in its tracks
boolean hu_stopped = false;
UINT8 adminpassmd5[16];
boolean adminpasswordset = false;
UINT8 (*adminpassmd5)[16];
UINT32 adminpasscount = 0;
tic_t neededtic;
SINT8 servernode = 0; // the number of the server node
@ -862,26 +862,31 @@ static void PT_Login(SINT8 node, INT32 netconsole)
#ifndef NOMD5
UINT8 finalmd5[16];/* Well, it's the cool thing to do? */
UINT32 i;
if (doomcom->datalength < 16)/* ignore partial sends */
return;
if (!adminpasswordset)
if (adminpasscount == 0)
{
CONS_Printf(M_GetText("Password from %s failed (no password set).\n"), player_names[netconsole]);
return;
}
// Do the final pass to compare with the sent md5
D_MD5PasswordPass(adminpassmd5, 16, va("PNUM%02d", netconsole), &finalmd5);
if (!memcmp(netbuffer->u.md5sum, finalmd5, 16))
for (i = 0; i < adminpasscount; i++)
{
CONS_Printf(M_GetText("%s passed authentication.\n"), player_names[netconsole]);
COM_BufInsertText(va("promote %d\n", netconsole)); // do this immediately
// Do the final pass to compare with the sent md5
D_MD5PasswordPass(adminpassmd5[i], 16, va("PNUM%02d", netconsole), &finalmd5);
if (!memcmp(netbuffer->u.md5sum, finalmd5, 16))
{
CONS_Printf(M_GetText("%s passed authentication.\n"), player_names[netconsole]);
COM_BufInsertText(va("promote %d\n", netconsole)); // do this immediately
return;
}
}
else
CONS_Printf(M_GetText("Password from %s failed.\n"), player_names[netconsole]);
CONS_Printf(M_GetText("Password from %s failed.\n"), player_names[netconsole]);
#else
(void)netconsole;
#endif
@ -1512,7 +1517,7 @@ void NetUpdate(void)
nowtime /= NEWTICRATERATIO;
if (nowtime > resptime)
if (nowtime != resptime)
{
resptime = nowtime;
#ifdef HAVE_THREADS
@ -1618,6 +1623,17 @@ INT32 D_NumPlayers(void)
return num;
}
/** Returns the number of nodes on the server.
*/
INT32 D_NumNodes(void)
{
INT32 num = 0;
for (INT32 ix = 0; ix < MAXNETNODES; ix++)
if (netnodes[ix].ingame)
num++;
return num;
}
/** Similar to the above, but counts only bots.
* Purpose is to remove bots from both the player count and the
* max player count on the server view

5
src/netcode/d_clisrv.h
View file

@ -121,14 +121,15 @@ extern char motd[254], server_context[8];
extern UINT8 playernode[MAXPLAYERS];
INT32 D_NumPlayers(void);
INT32 D_NumNodes(void);
INT32 D_NumBots(void);
tic_t GetLag(INT32 node);
void D_MD5PasswordPass(const UINT8 *buffer, size_t len, const char *salt, void *dest);
extern UINT8 adminpassmd5[16];
extern boolean adminpasswordset;
extern UINT8 (*adminpassmd5)[16];
extern UINT32 adminpasscount;
extern boolean hu_stopped;

23
src/netcode/d_net.c
View file

@ -313,9 +313,9 @@ static void RemoveAck(INT32 i)
}
// We have got a packet, proceed the ack request and ack return
static boolean Processackpak(void)
static int Processackpak(void)
{
boolean goodpacket = true;
int goodpacket = 0;
node_t *node = &nodes[doomcom->remotenode];
// Received an ack return, so remove the ack in the list
@ -340,7 +340,7 @@ static boolean Processackpak(void)
{
DEBFILE(va("Discard(1) ack %d (duplicated)\n", ack));
duppacket++;
goodpacket = false; // Discard packet (duplicate)
goodpacket = 1; // Discard packet (duplicate)
}
else
{
@ -350,10 +350,10 @@ static boolean Processackpak(void)
{
DEBFILE(va("Discard(2) ack %d (duplicated)\n", ack));
duppacket++;
goodpacket = false; // Discard packet (duplicate)
goodpacket = 1; // Discard packet (duplicate)
break;
}
if (goodpacket)
if (goodpacket == 0)
{
// Is a good packet so increment the acknowledge number,
// Then search for a "hole" in the queue
@ -414,12 +414,13 @@ static boolean Processackpak(void)
else // Buffer full discard packet, sender will resend it
{ // We can admit the packet but we will not detect the duplication after :(
DEBFILE("no more freeackret\n");
goodpacket = false;
goodpacket = 2;
}
}
}
}
}
// return values: 0 = ok, 1 = duplicate, 2 = out of order
return goodpacket;
}
@ -1069,6 +1070,7 @@ boolean HGetPacket(void)
while(true)
{
//nodejustjoined = I_NetGet();
int goodpacket;
I_NetGet();
if (doomcom->remotenode == -1) // No packet received
@ -1114,8 +1116,15 @@ boolean HGetPacket(void)
}*/
// Proceed the ack and ackreturn field
if (!Processackpak())
goodpacket = Processackpak();
if (goodpacket != 0)
{
// resend the ACK in case the previous ACK didn't reach the client.
// prevents the client's netbuffer from locking up.
if (goodpacket == 1)
Net_SendAcks(doomcom->remotenode);
continue; // discarded (duplicated)
}
// A packet with just ackreturn
if (netbuffer->packettype == PT_NOTHING)

1
src/netcode/d_net.h
View file

@ -70,6 +70,7 @@ boolean HGetPacket(void);
void D_SetDoomcom(void);
boolean D_CheckNetGame(void);
void D_CloseConnection(void);
boolean Net_IsNodeIPv6(INT32 node);
void Net_UnAcknowledgePacket(INT32 node);
void Net_CloseConnection(INT32 node);
void Net_ConnectionTimeout(INT32 node);

46
src/netcode/d_netcmd.c
View file

@ -150,6 +150,7 @@ static void Command_Clearscores_f(void);
// Remote Administration
static void Command_Changepassword_f(void);
static void Command_Clearpassword_f(void);
static void Command_Login_f(void);
static void Got_Verification(UINT8 **cp, INT32 playernum);
static void Got_Removal(UINT8 **cp, INT32 playernum);
@ -379,7 +380,7 @@ consvar_t cv_mute = CVAR_INIT ("mute", "Off", CV_NETVAR|CV_CALL|CV_ALLOWLUA, CV_
consvar_t cv_sleep = CVAR_INIT ("cpusleep", "1", CV_SAVE, sleeping_cons_t, NULL);
static CV_PossibleValue_t perfstats_cons_t[] = {
{0, "Off"}, {1, "Rendering"}, {2, "Logic"}, {3, "ThinkFrame"}, {0, NULL}};
{0, "Off"}, {1, "Rendering"}, {2, "Logic"}, {3, "ThinkFrame"}, {4, "PreThinkFrame"}, {5, "PostThinkFrame"}, {0, NULL}};
consvar_t cv_perfstats = CVAR_INIT ("perfstats", "Off", CV_CALL, perfstats_cons_t, PS_PerfStats_OnChange);
static CV_PossibleValue_t ps_samplesize_cons_t[] = {
{1, "MIN"}, {1000, "MAX"}, {0, NULL}};
@ -468,6 +469,7 @@ void D_RegisterServerCommands(void)
// Remote Administration
COM_AddCommand("password", Command_Changepassword_f, COM_LUA);
COM_AddCommand("clearpassword", Command_Clearpassword_f, COM_LUA);
COM_AddCommand("login", Command_Login_f, COM_LUA); // useful in dedicated to kick off remote admin
COM_AddCommand("promote", Command_Verify_f, COM_LUA);
RegisterNetXCmd(XD_VERIFIED, Got_Verification);
@ -620,6 +622,10 @@ void D_RegisterServerCommands(void)
CV_RegisterVar(&cv_addons_folder);
CV_RegisterVar(&cv_dummyconsvar);
CV_RegisterVar(&cv_chatspamprotection);
CV_RegisterVar(&cv_chatspamspeed);
CV_RegisterVar(&cv_chatspamburst);
}
// =========================================================================
@ -763,7 +769,6 @@ void D_RegisterClientCommands(void)
CV_RegisterVar(&cv_chatheight);
CV_RegisterVar(&cv_chatwidth);
CV_RegisterVar(&cv_chattime);
CV_RegisterVar(&cv_chatspamprotection);
CV_RegisterVar(&cv_chatbacktint);
CV_RegisterVar(&cv_consolechat);
CV_RegisterVar(&cv_chatnotifications);
@ -2841,8 +2846,15 @@ static void Got_Teamchange(UINT8 **cp, INT32 playernum)
void D_SetPassword(const char *pw)
{
D_MD5PasswordPass((const UINT8 *)pw, strlen(pw), BASESALT, &adminpassmd5);
adminpasswordset = true;
adminpassmd5 = Z_Realloc(adminpassmd5, sizeof(*adminpassmd5) * ++adminpasscount, PU_STATIC, NULL);
D_MD5PasswordPass((const UINT8 *)pw, strlen(pw), BASESALT, &adminpassmd5[adminpasscount-1]);
}
void D_ClearPassword(void)
{
Z_Free(adminpassmd5);
adminpassmd5 = NULL;
adminpasscount = 0;
}
// Remote Administration
@ -2860,12 +2872,30 @@ static void Command_Changepassword_f(void)
if (COM_Argc() != 2)
{
CONS_Printf(M_GetText("password <password>: change remote admin password\n"));
CONS_Printf(M_GetText("password <password>: add remote admin password\n"));
return;
}
D_SetPassword(COM_Argv(1));
CONS_Printf(M_GetText("Password set.\n"));
CONS_Printf(M_GetText("Password added.\n"));
#endif
}
// Remote Administration
static void Command_Clearpassword_f(void)
{
#ifdef NOMD5
// If we have no MD5 support then completely disable XD_LOGIN responses for security.
CONS_Alert(CONS_NOTICE, "Remote administration commands are not supported in this build.\n");
#else
if (client) // cannot change remotely
{
CONS_Printf(M_GetText("Only the server can use this.\n"));
return;
}
D_ClearPassword();
CONS_Printf(M_GetText("Passwords cleared.\n"));
#endif
}
@ -3641,11 +3671,11 @@ static void Got_RequestAddfoldercmd(UINT8 **cp, INT32 playernum)
static void Got_Addfilecmd(UINT8 **cp, INT32 playernum)
{
char filename[241];
char filename[MAX_WADPATH+1];
filestatus_t ncs = FS_NOTCHECKED;
UINT8 md5sum[16];
READSTRINGN(*cp, filename, 240);
READSTRINGN(*cp, filename, MAX_WADPATH);
READMEM(*cp, md5sum, 16);
if (playernum != serverplayer)

1
src/netcode/d_netcmd.h
View file

@ -209,6 +209,7 @@ void ClearAdminPlayers(void);
void RemoveAdminPlayer(INT32 playernum);
void ItemFinder_OnChange(void);
void D_SetPassword(const char *pw);
void D_ClearPassword(void);
// used for the player setup menu
UINT8 CanChangeSkin(INT32 playernum);

90
src/netcode/http-mserv.c
View file

@ -35,6 +35,10 @@ Documentation available here.
#define Blame( ... ) \
CONS_Printf("\x85" __VA_ARGS__)
#define PROTO_ANY 0
#define PROTO_V4 1
#define PROTO_V6 2
static void MasterServer_Debug_OnChange (void);
consvar_t cv_masterserver_timeout = CVAR_INIT
@ -59,12 +63,17 @@ consvar_t cv_masterserver_token = CVAR_INIT
static int hms_started;
static boolean hms_allow_ipv6;
static char *hms_api;
#ifdef HAVE_THREADS
static I_mutex hms_api_mutex;
#endif
static char *hms_server_token;
#ifndef NO_IPV6
static char *hms_server_token_ipv6;
#endif
static char hms_useragent[512];
@ -126,7 +135,7 @@ HMS_on_read (char *s, size_t _1, size_t n, void *userdata)
}
static struct HMS_buffer *
HMS_connect (const char *format, ...)
HMS_connect (int proto, const char *format, ...)
{
va_list ap;
CURL *curl;
@ -136,8 +145,14 @@ HMS_connect (const char *format, ...)
size_t token_length;
struct HMS_buffer *buffer;
#ifdef NO_IPV6
if (proto == PROTO_V6)
return NULL;
#endif
if (! hms_started)
{
hms_allow_ipv6 = !M_CheckParm("-noipv6");
if (curl_global_init(CURL_GLOBAL_ALL) != 0)
{
Contact_error();
@ -219,7 +234,9 @@ HMS_connect (const char *format, ...)
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
#ifndef NO_IPV6
if (M_CheckParm("-noipv6"))
if (proto == PROTO_V6)
curl_easy_setopt(curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V6);
if (proto == PROTO_V4)
#endif
curl_easy_setopt(curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
@ -309,7 +326,7 @@ HMS_fetch_rooms (int joining, int query_id)
(void)query_id;
hms = HMS_connect("rooms");
hms = HMS_connect(PROTO_ANY, "rooms");
if (! hms)
return 0;
@ -409,7 +426,7 @@ HMS_register (void)
char *title;
hms = HMS_connect("rooms/%d/register", ms_RoomId);
hms = HMS_connect(PROTO_V4, "rooms/%d/register", ms_RoomId);
if (! hms)
return 0;
@ -441,6 +458,27 @@ HMS_register (void)
HMS_end(hms);
#ifndef NO_IPV6
if (!hms_allow_ipv6)
return ok;
hms = HMS_connect(PROTO_V6, "rooms/%d/register", ms_RoomId);
if (! hms)
return 0;
curl_easy_setopt(hms->curl, CURLOPT_POSTFIELDS, post);
ok = HMS_do(hms);
if (ok)
{
hms_server_token_ipv6 = strdup(strtok(hms->buffer, "\n"));
}
HMS_end(hms);
#endif
return ok;
}
@ -450,7 +488,7 @@ HMS_unlist (void)
struct HMS_buffer *hms;
int ok;
hms = HMS_connect("servers/%s/unlist", hms_server_token);
hms = HMS_connect(PROTO_V4, "servers/%s/unlist", hms_server_token);
if (! hms)
return 0;
@ -462,6 +500,23 @@ HMS_unlist (void)
free(hms_server_token);
#ifndef NO_IPV6
if (hms_server_token_ipv6 && hms_allow_ipv6)
{
hms = HMS_connect(PROTO_V6, "servers/%s/unlist", hms_server_token_ipv6);
if (! hms)
return 0;
curl_easy_setopt(hms->curl, CURLOPT_CUSTOMREQUEST, "POST");
ok = HMS_do(hms);
HMS_end(hms);
free(hms_server_token_ipv6);
}
#endif
return ok;
}
@ -475,7 +530,7 @@ HMS_update (void)
char *title;
hms = HMS_connect("servers/%s/update", hms_server_token);
hms = HMS_connect(PROTO_V4, "servers/%s/update", hms_server_token);
if (! hms)
return 0;
@ -494,6 +549,21 @@ HMS_update (void)
ok = HMS_do(hms);
HMS_end(hms);
#ifndef NO_IPV6
if (hms_server_token_ipv6 && hms_allow_ipv6)
{
hms = HMS_connect(PROTO_V6, "servers/%s/update", hms_server_token_ipv6);
if (! hms)
return ok;
curl_easy_setopt(hms->curl, CURLOPT_POSTFIELDS, post);
ok = HMS_do(hms);
HMS_end(hms);
}
#endif
return ok;
}
@ -505,7 +575,7 @@ HMS_list_servers (void)
char *list;
char *p;
hms = HMS_connect("servers");
hms = HMS_connect(PROTO_ANY, "servers");
if (! hms)
return;
@ -554,10 +624,10 @@ HMS_fetch_servers (msg_server_t *list, int room_number, int query_id)
if (room_number > 0)
{
hms = HMS_connect("rooms/%d/servers", room_number);
hms = HMS_connect(PROTO_ANY, "rooms/%d/servers", room_number);
}
else
hms = HMS_connect("servers");
hms = HMS_connect(PROTO_ANY, "servers");
if (! hms)
return NULL;
@ -661,7 +731,7 @@ HMS_compare_mod_version (char *buffer, size_t buffer_size)
char *version;
char *version_name;
hms = HMS_connect("versions/%d", MODID);
hms = HMS_connect(PROTO_ANY, "versions/%d", MODID);
if (! hms)
return 0;

31
src/netcode/i_tcp.c
View file

@ -83,6 +83,10 @@
#undef ETIMEDOUT
#endif
#define ETIMEDOUT WSAETIMEDOUT
#ifdef EHOSTUNREACH
#undef EHOSTUNREACH
#endif
#define EHOSTUNREACH WSAEHOSTUNREACH
#ifndef IOC_VENDOR
#define IOC_VENDOR 0x18000000
#endif
@ -404,6 +408,20 @@ static const char *SOCK_GetBanMask(size_t ban)
return NULL;
}
#ifdef HAVE_IPV6
static boolean SOCK_cmpipv6(mysockaddr_t *a, mysockaddr_t *b, UINT8 mask)
{
UINT8 bitmask;
I_Assert(mask <= 128);
if (memcmp(&a->ip6.sin6_addr, &b->ip6.sin6_addr, mask / 8) != 0)
return false;
if (mask % 8 == 0)
return true;
bitmask = 255 << (mask % 8);
return (a->ip6.sin6_addr.s6_addr[mask / 8] & bitmask) == (b->ip6.sin6_addr.s6_addr[mask / 8] & bitmask);
}
#endif
static boolean SOCK_cmpaddr(mysockaddr_t *a, mysockaddr_t *b, UINT8 mask)
{
UINT32 bitmask = INADDR_NONE;
@ -416,7 +434,7 @@ static boolean SOCK_cmpaddr(mysockaddr_t *a, mysockaddr_t *b, UINT8 mask)
&& (b->ip4.sin_port == 0 || (a->ip4.sin_port == b->ip4.sin_port));
#ifdef HAVE_IPV6
else if (b->any.sa_family == AF_INET6)
return !memcmp(&a->ip6.sin6_addr, &b->ip6.sin6_addr, sizeof(b->ip6.sin6_addr))
return SOCK_cmpipv6(a, b, mask)
&& (b->ip6.sin6_port == 0 || (a->ip6.sin6_port == b->ip6.sin6_port));
#endif
else
@ -678,7 +696,7 @@ static void SOCK_Send(void)
if (c == ERRSOCKET)
{
int e = errno; // save error code so it can't be modified later
if (e != ECONNREFUSED && e != EWOULDBLOCK)
if (e != ECONNREFUSED && e != EWOULDBLOCK && e != EHOSTUNREACH)
I_Error("SOCK_Send, error sending to node %d (%s) #%u: %s", doomcom->remotenode,
SOCK_GetNodeAddress(doomcom->remotenode), e, strerror(e));
}
@ -1362,4 +1380,13 @@ boolean I_InitTcpNetwork(void)
return ret;
}
boolean Net_IsNodeIPv6(INT32 node)
{
#ifdef NO_IPV6
return false;
#else
return clientaddress[node].any.sa_family == AF_INET6;
#endif
}
#include "i_addrinfo.c"

9
src/netcode/mserv.c
View file

@ -60,7 +60,7 @@ static CV_PossibleValue_t masterserver_update_rate_cons_t[] = {
{0,NULL}
};
consvar_t cv_masterserver = CVAR_INIT ("masterserver", "https://mb.srb2.org/MS/0", CV_SAVE|CV_CALL, NULL, MasterServer_OnChange);
consvar_t cv_masterserver = CVAR_INIT ("masterserver", "https://ds.ms.srb2.org/MS/0", CV_SAVE|CV_CALL, NULL, MasterServer_OnChange);
consvar_t cv_servername = CVAR_INIT ("servername", "SRB2 server", CV_SAVE|CV_NETVAR|CV_CALL|CV_NOINIT|CV_ALLOWLUA, NULL, Update_parameters);
consvar_t cv_masterserver_update_rate = CVAR_INIT ("masterserver_update_rate", "15", CV_SAVE|CV_CALL|CV_NOINIT, masterserver_update_rate_cons_t, Update_parameters);
@ -539,6 +539,13 @@ static void MasterServer_OnChange(void)
CV_StealthSet(&cv_masterserver, cv_masterserver.defaultvalue);
}
if (
! cv_masterserver.changed &&
strcmp(cv_masterserver.string, "https://mb.srb2.org/MS/0") == 0
){
CV_StealthSet(&cv_masterserver, cv_masterserver.defaultvalue);
}
Set_api(cv_masterserver.string);
if (Online())

4
src/netcode/server_connection.c
View file

@ -109,7 +109,7 @@ static void SV_SendServerInfo(INT32 node, tic_t servertime)
netbuffer->u.serverinfo.leveltime = (tic_t)LONG(leveltime);
// Exclude bots from both counts
netbuffer->u.serverinfo.numberofplayer = (UINT8)(D_NumPlayers() - D_NumBots());
netbuffer->u.serverinfo.numberofplayer = (UINT8)(D_NumNodes() - (dedicated ? 1 : 0));
netbuffer->u.serverinfo.maxplayer = (UINT8)(cv_maxplayers.value - D_NumBots());
netbuffer->u.serverinfo.refusereason = GetRefuseReason(node);
@ -164,7 +164,7 @@ static void SV_SendPlayerInfo(INT32 node)
for (UINT8 i = 0; i < MAXPLAYERS; i++)
{
if (!playeringame[i])
if (playernode[i] == UINT8_MAX || !netnodes[playernode[i]].ingame)
{
netbuffer->u.playerinfo[i].num = 255; // This slot is empty.
continue;

921
src/p_enemy.c
View file

File diff suppressed because it is too large Load diff

17
src/p_floor.c
View file

@ -1212,6 +1212,19 @@ static boolean T_SectorHasEnemies(sector_t *sec)
return false;
}
static void T_UpdateMobjPlaneZ(sector_t *sec)
{
msecnode_t *node = sec->touching_thinglist; // things touching this sector
mobj_t *mo;
while (node)
{
mo = node->m_thing;
mo->floorz = P_FloorzAtPos(mo->x, mo->y, mo->z, mo->height);
mo->ceilingz = P_CeilingzAtPos(mo->x, mo->y, mo->z, mo->height);
node = node->m_thinglist_next;
}
}
//
// T_NoEnemiesThinker
//
@ -1921,6 +1934,9 @@ void EV_CrumbleChain(sector_t *sec, ffloor_t *rover)
for (c = topz; c > bottomz; c -= spacing)
{
spawned = P_SpawnMobj(a, b, c, type);
if (P_MobjWasRemoved(spawned))
continue;
spawned->angle += P_RandomKey(36)*ANG10; // irrelevant for default objects but might make sense for some custom ones
if (fromcenter)
@ -1938,6 +1954,7 @@ void EV_CrumbleChain(sector_t *sec, ffloor_t *rover)
// no longer exists (can't collide with again)
rover->fofflags &= ~FOF_EXISTS;
rover->master->frontsector->moved = true;
T_UpdateMobjPlaneZ(sec); // prevent objects from floating
P_RecalcPrecipInSector(sec);
}

287
src/p_inter.c
View file

@ -256,6 +256,9 @@ void P_DoNightsScore(player_t *player)
player->linktimer = nightslinktics;
}
if (P_MobjWasRemoved(dummymo))
return;
// Award 10-100 score, doubled if bonus time is active
P_AddPlayerScore(player, min(player->linkcount,10)*(player->bonustime ? 20 : 10));
P_SetMobjState(dummymo, (player->bonustime ? dummymo->info->xdeathstate : dummymo->info->spawnstate) + min(player->linkcount,10)-1);
@ -526,7 +529,7 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
else if (player->pflags & PF_GLIDING && !P_IsObjectOnGround(toucher))
{
player->pflags &= ~(PF_GLIDING|PF_JUMPED|PF_NOJUMPDAMAGE);
P_SetPlayerMobjState(toucher, S_PLAY_FALL);
P_SetMobjState(toucher, S_PLAY_FALL);
toucher->momz += P_MobjFlip(toucher) * (player->speed >> 3);
toucher->momx = 7*toucher->momx>>3;
toucher->momy = 7*toucher->momy>>3;
@ -1246,7 +1249,7 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
P_ResetPlayer(player);
P_SetPlayerMobjState(toucher, S_PLAY_FALL);
P_SetMobjState(toucher, S_PLAY_FALL);
}
}
return;
@ -1301,7 +1304,8 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
{
// A flicky orbits us now
mobj_t *flickyobj = P_SpawnMobj(toucher->x, toucher->y, toucher->z + toucher->info->height, MT_NIGHTOPIANHELPER);
P_SetTarget(&flickyobj->target, toucher);
if (!P_MobjWasRemoved(flickyobj))
P_SetTarget(&flickyobj->target, toucher);
player->powers[pw_nights_helper] = (UINT16)special->info->speed;
}
@ -1312,7 +1316,8 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
if (playeringame[i] && players[i].mo && players[i].powers[pw_carry] == CR_NIGHTSMODE) {
players[i].powers[pw_nights_helper] = (UINT16)special->info->speed;
flickyobj = P_SpawnMobj(players[i].mo->x, players[i].mo->y, players[i].mo->z + players[i].mo->info->height, MT_NIGHTOPIANHELPER);
P_SetTarget(&flickyobj->target, players[i].mo);
if (!P_MobjWasRemoved(flickyobj))
P_SetTarget(&flickyobj->target, players[i].mo);
}
if (special->info->deathsound != sfx_None)
S_StartSound(NULL, special->info->deathsound);
@ -1553,7 +1558,7 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
if (player->pflags & PF_GLIDING && !P_IsObjectOnGround(toucher))
{
player->pflags &= ~(PF_GLIDING|PF_JUMPED|PF_NOJUMPDAMAGE);
P_SetPlayerMobjState(toucher, S_PLAY_FALL);
P_SetMobjState(toucher, S_PLAY_FALL);
toucher->momz += P_MobjFlip(toucher) * (player->speed >> 3);
toucher->momx = 7*toucher->momx>>3;
toucher->momy = 7*toucher->momy>>3;
@ -1604,7 +1609,7 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
if (player->pflags & PF_GLIDING && !P_IsObjectOnGround(toucher))
{
player->pflags &= ~(PF_GLIDING|PF_JUMPED|PF_NOJUMPDAMAGE);
P_SetPlayerMobjState(toucher, S_PLAY_FALL);
P_SetMobjState(toucher, S_PLAY_FALL);
toucher->momz += P_MobjFlip(toucher) * (player->speed >> 3);
toucher->momx = 7*toucher->momx>>3;
toucher->momy = 7*toucher->momy>>3;
@ -1640,7 +1645,7 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
special->momx = special->momy = 0;
// Buenos Dias Mandy
P_SetPlayerMobjState(toucher, S_PLAY_STUN);
P_SetMobjState(toucher, S_PLAY_STUN);
player->pflags &= ~PF_APPLYAUTOBRAKE;
P_ResetPlayer(player);
player->drawangle = special->angle + ANGLE_180;
@ -1719,7 +1724,7 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
{
player->powers[pw_carry] = CR_MACESPIN;
S_StartSound(toucher, sfx_spin);
P_SetPlayerMobjState(toucher, S_PLAY_ROLL);
P_SetMobjState(toucher, S_PLAY_ROLL);
}
else
player->powers[pw_carry] = CR_GENERIC;
@ -1780,7 +1785,7 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
{
if (player->bot && player->bot != BOT_MPAI && toucher->state-states != S_PLAY_GASP)
S_StartSound(toucher, special->info->deathsound); // Force it to play a sound for bots
P_SetPlayerMobjState(toucher, S_PLAY_GASP);
P_SetMobjState(toucher, S_PLAY_GASP);
P_ResetPlayer(player);
}
@ -1821,9 +1826,12 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
if (!player->bot && player->bot != BOT_MPAI && special->fuse <= TICRATE && player->powers[pw_carry] != CR_MINECART && !(player->powers[pw_ignorelatch] & (1<<15)))
{
mobj_t *mcart = P_SpawnMobj(special->x, special->y, special->z, MT_MINECART);
P_SetTarget(&mcart->target, toucher);
mcart->angle = toucher->angle = player->drawangle = special->angle;
mcart->friction = FRACUNIT;
if (!P_MobjWasRemoved(mcart))
{
P_SetTarget(&mcart->target, toucher);
mcart->angle = toucher->angle = player->drawangle = special->angle;
mcart->friction = FRACUNIT;
}
P_ResetPlayer(player);
player->pflags |= PF_JUMPDOWN;
@ -1847,7 +1855,7 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
toucher->momz = toucher->tracer->momz + P_AproxDistance(toucher->tracer->momx, toucher->tracer->momy)/2;
P_ResetPlayer(player);
player->pflags &= ~PF_APPLYAUTOBRAKE;
P_SetPlayerMobjState(toucher, S_PLAY_FALL);
P_SetMobjState(toucher, S_PLAY_FALL);
P_SetTarget(&toucher->tracer->target, NULL);
P_KillMobj(toucher->tracer, toucher, special, 0);
P_SetTarget(&toucher->tracer, NULL);
@ -2593,7 +2601,8 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, UINT8 damaget
break;
}
P_SetMobjState(scoremobj, scorestate);
if (!P_MobjWasRemoved(scoremobj))
P_SetMobjState(scoremobj, scorestate);
source->player->scoreadd = locscoreadd;
}
@ -2754,6 +2763,8 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, UINT8 damaget
mo = P_SpawnMobj(inflictor->x + inflictor->momx, inflictor->y + inflictor->momy, inflictor->z + (inflictor->height / 2) + inflictor->momz, MT_EXTRALARGEBUBBLE);
else
mo = P_SpawnMobj(target->x, target->y, target->z, MT_EXTRALARGEBUBBLE);
if (P_MobjWasRemoved(mo))
break;
mo->destscale = target->scale;
P_SetScale(mo, mo->destscale);
P_SetMobjState(mo, mo->info->raisestate);
@ -2832,8 +2843,11 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, UINT8 damaget
mo->angle = FixedAngle((P_RandomKey(36)*10)<<FRACBITS);
mo2 = P_SpawnMobjFromMobj(mo, 0, 0, 0, MT_BOSSJUNK);
mo2->angle = mo->angle;
P_SetMobjState(mo2, S_BOSSSEBH2);
if (!P_MobjWasRemoved(mo2))
{
mo2->angle = mo->angle;
P_SetMobjState(mo2, S_BOSSSEBH2);
}
if (++i == 2) // we've already removed 2 of these, let's stop now
break;
@ -2932,7 +2946,10 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, UINT8 damaget
if (flip)
momz *= -1;
#define makechunk(angtweak, xmov, ymov) \
do {\
chunk = P_SpawnMobjFromMobj(target, 0, 0, 0, MT_SPIKE);\
if (P_MobjWasRemoved(chunk))\
break;\
P_SetMobjState(chunk, target->info->xdeathstate);\
chunk->health = 0;\
chunk->angle = angtweak;\
@ -2942,7 +2959,8 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, UINT8 damaget
chunk->y += ymov;\
P_SetThingPosition(chunk);\
P_InstaThrust(chunk,chunk->angle, 4*scale);\
chunk->momz = momz
chunk->momz = momz;\
} while (0)
makechunk(ang + ANGLE_180, -xoffs, -yoffs);
makechunk(ang, xoffs, yoffs);
@ -2955,20 +2973,23 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, UINT8 damaget
momz *= -1;
chunk = P_SpawnMobjFromMobj(target, 0, 0, 0, MT_SPIKE);
P_SetMobjState(chunk, target->info->deathstate);
chunk->health = 0;
chunk->angle = ang + ANGLE_180;
P_UnsetThingPosition(chunk);
chunk->flags = MF_NOCLIP;
chunk->x -= xoffs;
chunk->y -= yoffs;
if (flip)
chunk->z -= 12*scale;
else
chunk->z += 12*scale;
P_SetThingPosition(chunk);
P_InstaThrust(chunk, chunk->angle, 2*scale);
chunk->momz = momz;
if (!P_MobjWasRemoved(chunk))
{
P_SetMobjState(chunk, target->info->deathstate);
chunk->health = 0;
chunk->angle = ang + ANGLE_180;
P_UnsetThingPosition(chunk);
chunk->flags = MF_NOCLIP;
chunk->x -= xoffs;
chunk->y -= yoffs;
if (flip)
chunk->z -= 12*scale;
else
chunk->z += 12*scale;
P_SetThingPosition(chunk);
P_InstaThrust(chunk, chunk->angle, 2*scale);
chunk->momz = momz;
}
P_SetMobjState(target, target->info->deathstate);
target->health = 0;
@ -2977,7 +2998,10 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, UINT8 damaget
target->flags = MF_NOCLIP;
target->x += xoffs;
target->y += yoffs;
target->z = chunk->z;
if (flip)
target->z -= 12*scale;
else
target->z += 12*scale;
P_SetThingPosition(target);
P_InstaThrust(target, target->angle, 2*scale);
target->momz = momz;
@ -3000,21 +3024,25 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, UINT8 damaget
sprflip = P_RandomChance(FRACUNIT/2);
#define makechunk(angtweak, xmov, ymov) \
chunk = P_SpawnMobjFromMobj(target, 0, 0, 0, MT_WALLSPIKE);\
P_SetMobjState(chunk, target->info->xdeathstate);\
chunk->health = 0;\
chunk->angle = target->angle;\
P_UnsetThingPosition(chunk);\
chunk->flags = MF_NOCLIP;\
chunk->x += xmov - forwardxoffs;\
chunk->y += ymov - forwardyoffs;\
P_SetThingPosition(chunk);\
P_InstaThrust(chunk, angtweak, 4*scale);\
chunk->momz = P_RandomRange(5, 7)*scale;\
if (flip)\
chunk->momz *= -1;\
if (sprflip)\
chunk->frame |= FF_VERTICALFLIP
do {\
chunk = P_SpawnMobjFromMobj(target, 0, 0, 0, MT_WALLSPIKE);\
if (P_MobjWasRemoved(chunk))\
break;\
P_SetMobjState(chunk, target->info->xdeathstate);\
chunk->health = 0;\
chunk->angle = target->angle;\
P_UnsetThingPosition(chunk);\
chunk->flags = MF_NOCLIP;\
chunk->x += xmov - forwardxoffs;\
chunk->y += ymov - forwardyoffs;\
P_SetThingPosition(chunk);\
P_InstaThrust(chunk, angtweak, 4*scale);\
chunk->momz = P_RandomRange(5, 7)*scale;\
if (flip)\
chunk->momz *= -1;\
if (sprflip)\
chunk->frame |= FF_VERTICALFLIP;\
} while (0)
makechunk(ang + ANGLE_180, -xoffs, -yoffs);
sprflip = !sprflip;
@ -3026,21 +3054,23 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, UINT8 damaget
sprflip = P_RandomChance(FRACUNIT/2);
chunk = P_SpawnMobjFromMobj(target, 0, 0, 0, MT_WALLSPIKE);
P_SetMobjState(chunk, target->info->deathstate);
chunk->health = 0;
chunk->angle = target->angle;
P_UnsetThingPosition(chunk);
chunk->flags = MF_NOCLIP;
chunk->x += forwardxoffs - xoffs;
chunk->y += forwardyoffs - yoffs;
P_SetThingPosition(chunk);
P_InstaThrust(chunk, ang + ANGLE_180, 2*scale);
chunk->momz = P_RandomRange(5, 7)*scale;
if (flip)
chunk->momz *= -1;
if (sprflip)
chunk->frame |= FF_VERTICALFLIP;
if (!P_MobjWasRemoved(chunk))
{
P_SetMobjState(chunk, target->info->deathstate);
chunk->health = 0;
chunk->angle = target->angle;
P_UnsetThingPosition(chunk);
chunk->flags = MF_NOCLIP;
chunk->x += forwardxoffs - xoffs;
chunk->y += forwardyoffs - yoffs;
P_SetThingPosition(chunk);
P_InstaThrust(chunk, ang + ANGLE_180, 2*scale);
chunk->momz = P_RandomRange(5, 7)*scale;
if (flip)
chunk->momz *= -1;
if (sprflip)
chunk->frame |= FF_VERTICALFLIP;
}
P_SetMobjState(target, target->info->deathstate);
target->health = 0;
@ -3059,9 +3089,9 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, UINT8 damaget
else if (target->player)
{
if (damagetype == DMG_DROWNED || damagetype == DMG_SPACEDROWN)
P_SetPlayerMobjState(target, target->info->xdeathstate);
P_SetMobjState(target, target->info->xdeathstate);
else
P_SetPlayerMobjState(target, target->info->deathstate);
P_SetMobjState(target, target->info->deathstate);
}
else
#ifdef DEBUG_NULL_DEATHSTATE
@ -3115,7 +3145,7 @@ static void P_NiGHTSDamage(mobj_t *target, mobj_t *source)
}
player->powers[pw_flashing] = flashingtics;
P_SetPlayerMobjState(target, S_PLAY_NIGHTS_STUN);
P_SetMobjState(target, S_PLAY_NIGHTS_STUN);
S_StartSound(target, sfx_nghurt);
player->mo->spriteroll = 0;
@ -3336,7 +3366,7 @@ static void P_KillPlayer(player_t *player, mobj_t *source, INT32 damage)
if (!player->spectator)
player->mo->flags2 &= ~MF2_DONTDRAW;
P_SetPlayerMobjState(player->mo, player->mo->info->deathstate);
P_SetMobjState(player->mo, player->mo->info->deathstate);
if ((gametyperules & GTR_TEAMFLAGS) && (player->gotflag & (GF_REDFLAG|GF_BLUEFLAG)))
{
P_PlayerFlagBurst(player, false);
@ -3410,7 +3440,7 @@ static void P_SuperDamage(player_t *player, mobj_t *inflictor, mobj_t *source, I
P_InstaThrust(player->mo, ang, fallbackspeed);
P_SetPlayerMobjState(player->mo, S_PLAY_STUN);
P_SetMobjState(player->mo, S_PLAY_STUN);
P_ResetPlayer(player);
@ -3921,6 +3951,8 @@ void P_PlayerRingBurst(player_t *player, INT32 num_rings)
z += player->mo->height - mobjinfo[objType].height;
mo = P_SpawnMobj(player->mo->x, player->mo->y, z, objType);
if (P_MobjWasRemoved(mo))
continue;
mo->fuse = 8*TICRATE;
P_SetTarget(&mo->target, player->mo);
@ -4054,6 +4086,9 @@ void P_PlayerWeaponPanelBurst(player_t *player)
z += player->mo->height - mobjinfo[weptype].height;
mo = P_SpawnMobj(player->mo->x, player->mo->y, z, weptype);
if (P_MobjWasRemoved(mo))
continue;
mo->reactiontime = ammoamt;
mo->flags2 |= MF2_DONTRESPAWN;
mo->flags &= ~(MF_NOGRAVITY|MF_NOCLIPHEIGHT);
@ -4087,13 +4122,13 @@ void P_PlayerWeaponAmmoBurst(player_t *player)
mobj_t *mo;
angle_t fa;
fixed_t ns;
INT32 i = 0;
INT32 i;
fixed_t z;
mobjtype_t weptype = 0;
powertype_t power = 0;
while (true)
for (i = 0;; i++)
{
if (player->powers[pw_bouncering])
{
@ -4138,6 +4173,8 @@ void P_PlayerWeaponAmmoBurst(player_t *player)
z += player->mo->height - mobjinfo[weptype].height;
mo = P_SpawnMobj(player->mo->x, player->mo->y, z, weptype);
if (P_MobjWasRemoved(mo))
continue;
mo->health = player->powers[power];
mo->flags2 |= MF2_DONTRESPAWN;
mo->flags &= ~(MF_NOGRAVITY|MF_NOCLIPHEIGHT);
@ -4163,8 +4200,6 @@ void P_PlayerWeaponAmmoBurst(player_t *player)
if (i & 1)
P_SetObjectMomZ(mo, 3*FRACUNIT, true);
i++;
}
}
@ -4189,45 +4224,50 @@ void P_PlayerWeaponPanelOrAmmoBurst(player_t *player)
player->ringweapons &= ~rwflag; \
SETUP_DROP(pickup) \
mo = P_SpawnMobj(player->mo->x, player->mo->y, z, pickup); \
mo->reactiontime = 0; \
mo->flags2 |= MF2_DONTRESPAWN; \
mo->flags &= ~(MF_NOGRAVITY|MF_NOCLIPHEIGHT); \
P_SetTarget(&mo->target, player->mo); \
mo->fuse = 12*TICRATE; \
mo->destscale = player->mo->scale; \
P_SetScale(mo, player->mo->scale); \
mo->momx = FixedMul(FINECOSINE(fa),ns); \
if (!(twodlevel || (player->mo->flags2 & MF2_TWOD))) \
mo->momy = FixedMul(FINESINE(fa),ns); \
P_SetObjectMomZ(mo, 4*FRACUNIT, false); \
if (i & 1) \
P_SetObjectMomZ(mo, 4*FRACUNIT, true); \
if (player->mo->eflags & MFE_VERTICALFLIP) \
mo->flags2 |= MF2_OBJECTFLIP; \
++i; \
if (!P_MobjWasRemoved(mo)) \
{ \
mo->reactiontime = 0; \
mo->flags2 |= MF2_DONTRESPAWN; \
mo->flags &= ~(MF_NOGRAVITY|MF_NOCLIPHEIGHT); \
P_SetTarget(&mo->target, player->mo); \
mo->fuse = 12*TICRATE; \
mo->destscale = player->mo->scale; \
P_SetScale(mo, player->mo->scale); \
mo->momx = FixedMul(FINECOSINE(fa),ns); \
if (!(twodlevel || (player->mo->flags2 & MF2_TWOD))) \
mo->momy = FixedMul(FINESINE(fa),ns); \
P_SetObjectMomZ(mo, 4*FRACUNIT, false); \
if (i & 1) \
P_SetObjectMomZ(mo, 4*FRACUNIT, true); \
if (player->mo->eflags & MFE_VERTICALFLIP) \
mo->flags2 |= MF2_OBJECTFLIP; \
} \
} \
else if (player->powers[power] > 0) \
{ \
SETUP_DROP(ammo) \
mo = P_SpawnMobj(player->mo->x, player->mo->y, z, ammo); \
mo->health = player->powers[power]; \
mo->flags2 |= MF2_DONTRESPAWN; \
mo->flags &= ~(MF_NOGRAVITY|MF_NOCLIPHEIGHT); \
P_SetTarget(&mo->target, player->mo); \
mo->fuse = 12*TICRATE; \
mo->destscale = player->mo->scale; \
P_SetScale(mo, player->mo->scale); \
mo->momx = FixedMul(FINECOSINE(fa),ns); \
if (!(twodlevel || (player->mo->flags2 & MF2_TWOD))) \
mo->momy = FixedMul(FINESINE(fa),ns); \
P_SetObjectMomZ(mo, 3*FRACUNIT, false); \
if (i & 1) \
P_SetObjectMomZ(mo, 3*FRACUNIT, true); \
if (player->mo->eflags & MFE_VERTICALFLIP) \
mo->flags2 |= MF2_OBJECTFLIP; \
player->powers[power] = 0; \
++i; \
}
if (!P_MobjWasRemoved(mo)) \
{ \
mo->health = player->powers[power]; \
mo->flags2 |= MF2_DONTRESPAWN; \
mo->flags &= ~(MF_NOGRAVITY|MF_NOCLIPHEIGHT); \
P_SetTarget(&mo->target, player->mo); \
mo->fuse = 12*TICRATE; \
mo->destscale = player->mo->scale; \
P_SetScale(mo, player->mo->scale); \
mo->momx = FixedMul(FINECOSINE(fa),ns); \
if (!(twodlevel || (player->mo->flags2 & MF2_TWOD))) \
mo->momy = FixedMul(FINESINE(fa),ns); \
P_SetObjectMomZ(mo, 3*FRACUNIT, false); \
if (i & 1) \
P_SetObjectMomZ(mo, 3*FRACUNIT, true); \
if (player->mo->eflags & MFE_VERTICALFLIP) \
mo->flags2 |= MF2_OBJECTFLIP; \
player->powers[power] = 0; \
} \
} \
++i
DROP_WEAPON(RW_BOUNCE, MT_BOUNCEPICKUP, MT_BOUNCERING, pw_bouncering);
DROP_WEAPON(RW_RAIL, MT_RAILPICKUP, MT_RAILRING, pw_railring);
@ -4351,23 +4391,26 @@ void P_PlayerEmeraldBurst(player_t *player, boolean toss)
momy = 0;
mo = P_SpawnMobj(player->mo->x, player->mo->y, z, MT_FLINGEMERALD);
mo->health = 1;
mo->threshold = stoneflag;
mo->flags2 |= (MF2_DONTRESPAWN|MF2_SLIDEPUSH);
mo->flags &= ~(MF_NOGRAVITY|MF_NOCLIPHEIGHT);
P_SetTarget(&mo->target, player->mo);
mo->fuse = 12*TICRATE;
P_SetMobjState(mo, statenum);
mo->momx = momx;
mo->momy = momy;
P_SetObjectMomZ(mo, 3*FRACUNIT, false);
if (player->mo->eflags & MFE_VERTICALFLIP)
if (!P_MobjWasRemoved(mo))
{
mo->momz = -mo->momz;
mo->flags2 |= MF2_OBJECTFLIP;
mo->health = 1;
mo->threshold = stoneflag;
mo->flags2 |= (MF2_DONTRESPAWN|MF2_SLIDEPUSH);
mo->flags &= ~(MF_NOGRAVITY|MF_NOCLIPHEIGHT);
P_SetTarget(&mo->target, player->mo);
mo->fuse = 12*TICRATE;
P_SetMobjState(mo, statenum);
mo->momx = momx;
mo->momy = momy;
P_SetObjectMomZ(mo, 3*FRACUNIT, false);
if (player->mo->eflags & MFE_VERTICALFLIP)
{
mo->momz = -mo->momz;
mo->flags2 |= MF2_OBJECTFLIP;
}
}
if (toss)
@ -4395,6 +4438,8 @@ void P_PlayerFlagBurst(player_t *player, boolean toss)
type = MT_BLUEFLAG;
flag = P_SpawnMobj(player->mo->x, player->mo->y, player->mo->z, type);
if (P_MobjWasRemoved(flag))
return;
if (player->mo->eflags & MFE_VERTICALFLIP)
{

4
src/p_local.h
View file

@ -71,6 +71,7 @@ typedef enum
NUM_THINKERLISTS
} thinklistnum_t; /**< Thinker lists. */
extern thinker_t thlist[];
extern mobj_t *mobjcache;
void P_InitThinkers(void);
void P_AddThinker(const thinklistnum_t n, thinker_t *thinker);
@ -288,7 +289,7 @@ mobjtype_t P_GetMobjtype(UINT16 mthingtype);
void P_RespawnSpecials(void);
mobj_t *P_SpawnMobj(fixed_t x, fixed_t y, fixed_t z, mobjtype_t type);
mobj_t *P_SpawnMobj(fixed_t x, fixed_t y, fixed_t z, mobjtype_t type, ...);
void P_RecalcPrecipInSector(sector_t *sector);
void P_PrecipitationEffects(void);
@ -296,7 +297,6 @@ void P_PrecipitationEffects(void);
void P_RemoveMobj(mobj_t *th);
boolean P_MobjWasRemoved(mobj_t *th);
void P_RemoveSavegameMobj(mobj_t *th);
boolean P_SetPlayerMobjState(mobj_t *mobj, statenum_t state);
boolean P_SetMobjState(mobj_t *mobj, statenum_t state);
void P_RunShields(void);
void P_RunOverlays(void);

30
src/p_map.c
View file

@ -264,7 +264,7 @@ boolean P_DoSpring(mobj_t *spring, mobj_t *object)
UINT8 secondjump = object->player->secondjump;
UINT16 tailsfly = object->player->powers[pw_tailsfly];
if (object->player->pflags & PF_GLIDING)
P_SetPlayerMobjState(object, S_PLAY_FALL);
P_SetMobjState(object, S_PLAY_FALL);
P_ResetPlayer(object->player);
object->player->pflags |= pflags;
object->player->secondjump = secondjump;
@ -403,7 +403,7 @@ boolean P_DoSpring(mobj_t *spring, mobj_t *object)
}
if (object->player->pflags & PF_GLIDING)
P_SetPlayerMobjState(object, S_PLAY_FALL);
P_SetMobjState(object, S_PLAY_FALL);
if ((spring->info->painchance == 3))
{
if (!(pflags = (object->player->pflags & PF_SPINNING)) &&
@ -411,11 +411,11 @@ boolean P_DoSpring(mobj_t *spring, mobj_t *object)
|| (spring->flags2 & MF2_AMBUSH)))
{
pflags = PF_SPINNING;
P_SetPlayerMobjState(object, S_PLAY_ROLL);
P_SetMobjState(object, S_PLAY_ROLL);
S_StartSound(object, sfx_spin);
}
else
P_SetPlayerMobjState(object, S_PLAY_ROLL);
P_SetMobjState(object, S_PLAY_ROLL);
}
else
{
@ -424,7 +424,7 @@ boolean P_DoSpring(mobj_t *spring, mobj_t *object)
pflags = object->player->pflags & (PF_STARTJUMP | PF_JUMPED | PF_NOJUMPDAMAGE | PF_SPINNING | PF_THOKKED | PF_BOUNCING); // I still need these.
if (wasSpindashing) // Ensure we're in the rolling state, and not spindash.
P_SetPlayerMobjState(object, S_PLAY_ROLL);
P_SetMobjState(object, S_PLAY_ROLL);
if (object->player->charability == CA_GLIDEANDCLIMB && object->player->skidtime && (pflags & PF_JUMPED))
{
@ -439,7 +439,7 @@ boolean P_DoSpring(mobj_t *spring, mobj_t *object)
if (spring->info->painchance == 1) // For all those ancient, SOC'd abilities.
{
object->player->pflags |= P_GetJumpFlags(object->player);
P_SetPlayerMobjState(object, S_PLAY_JUMP);
P_SetMobjState(object, S_PLAY_JUMP);
}
else if ((spring->info->painchance == 2) || ((spring->info->painchance != 3) && (pflags & PF_BOUNCING))) // Adding momentum only.
{
@ -456,16 +456,16 @@ boolean P_DoSpring(mobj_t *spring, mobj_t *object)
object->player->secondjump = secondjump;
}
else if (object->player->dashmode >= DASHMODE_THRESHOLD)
P_SetPlayerMobjState(object, S_PLAY_DASH);
P_SetMobjState(object, S_PLAY_DASH);
else if (P_IsObjectOnGround(object))
P_SetPlayerMobjState(object, (horizspeed >= FixedMul(object->player->runspeed, object->scale)) ? S_PLAY_RUN : S_PLAY_WALK);
P_SetMobjState(object, (horizspeed >= FixedMul(object->player->runspeed, object->scale)) ? S_PLAY_RUN : S_PLAY_WALK);
else
P_SetPlayerMobjState(object, (object->momz > 0) ? S_PLAY_SPRING : S_PLAY_FALL);
P_SetMobjState(object, (object->momz > 0) ? S_PLAY_SPRING : S_PLAY_FALL);
}
else if (P_MobjFlip(object)*vertispeed > 0)
P_SetPlayerMobjState(object, S_PLAY_SPRING);
P_SetMobjState(object, S_PLAY_SPRING);
else
P_SetPlayerMobjState(object, S_PLAY_FALL);
P_SetMobjState(object, S_PLAY_FALL);
}
else if (horizspeed
&& object->tracer
@ -547,7 +547,7 @@ static void P_DoFanAndGasJet(mobj_t *spring, mobj_t *object)
if (p && !p->powers[pw_tailsfly] && !p->powers[pw_carry]) // doesn't reset anim for Tails' flight
{
P_ResetPlayer(p);
P_SetPlayerMobjState(object, S_PLAY_FALL);
P_SetMobjState(object, S_PLAY_FALL);
P_SetTarget(&object->tracer, spring);
p->powers[pw_carry] = CR_FAN;
}
@ -565,7 +565,7 @@ static void P_DoFanAndGasJet(mobj_t *spring, mobj_t *object)
{
P_ResetPlayer(p);
if (p->panim != PA_FALL)
P_SetPlayerMobjState(object, S_PLAY_FALL);
P_SetMobjState(object, S_PLAY_FALL);
}
break;
default:
@ -1047,7 +1047,7 @@ static boolean PIT_CheckThing(mobj_t *thing)
thing->flags2 &= ~MF2_DONTDRAW; // don't leave the rock invisible if it was flashing prior to boarding
P_SetTarget(&thing->tracer, tmthing);
P_ResetPlayer(tmthing->player);
P_SetPlayerMobjState(tmthing, S_PLAY_WALK);
P_SetMobjState(tmthing, S_PLAY_WALK);
tmthing->player->powers[pw_carry] = CR_ROLLOUT;
P_SetTarget(&tmthing->tracer, thing);
if (!P_IsObjectOnGround(thing))
@ -2865,6 +2865,8 @@ boolean P_CheckMove(mobj_t *thing, fixed_t x, fixed_t y, boolean allowdropoff)
{
boolean moveok;
mobj_t *hack = P_SpawnMobjFromMobj(thing, 0, 0, 0, MT_RAY);
if (P_MobjWasRemoved(hack))
return false;
hack->radius = thing->radius;
hack->height = thing->height;

1121
src/p_mobj.c
View file

File diff suppressed because it is too large Load diff

2
src/p_polyobj.c
View file

@ -1243,6 +1243,8 @@ boolean Polyobj_rotate(polyobj_t *po, angle_t delta, boolean turnplayers, boolea
// Returns NULL if no such polyobject exists.
polyobj_t *Polyobj_GetForNum(INT32 id)
{
if (numPolyObjects == 0)
return NULL;
INT32 curidx = PolyObjects[id % numPolyObjects].first;
while (curidx != numPolyObjects && PolyObjects[curidx].id != id)

321
src/p_saveg.c
View file

@ -867,24 +867,47 @@ static void P_NetUnArchiveWaypoints(void)
#define SD_TRIGGERTAG 0x02
#define SD_TRIGGERER 0x04
#define SD_GRAVITY 0x08
#define SD_FXSCALE 0x10
#define SD_FYSCALE 0x20
#define SD_CXSCALE 0x40
#define SD_CYSCALE 0x80
#define LD_FLAG 0x01
#define LD_SPECIAL 0x02
#define LD_CLLCOUNT 0x04
#define LD_S1TEXOFF 0x08
#define LD_S1TOPTEX 0x10
#define LD_S1BOTTEX 0x20
#define LD_S1MIDTEX 0x40
#define LD_DIFF2 0x80
#define LD_FLAG 0x01
#define LD_SPECIAL 0x02
#define LD_CLLCOUNT 0x04
#define LD_ARGS 0x08
#define LD_STRINGARGS 0x10
#define LD_EXECUTORDELAY 0x20
#define LD_SIDE1 0x40
#define LD_SIDE2 0x80
// diff2 flags
#define LD_S2TEXOFF 0x01
#define LD_S2TOPTEX 0x02
#define LD_S2BOTTEX 0x04
#define LD_S2MIDTEX 0x08
#define LD_ARGS 0x10
#define LD_STRINGARGS 0x20
#define LD_EXECUTORDELAY 0x40
// sidedef flags
enum
{
LD_SDTEXOFFX = 1,
LD_SDTEXOFFY = 1<<1,
LD_SDTOPTEX = 1<<2,
LD_SDBOTTEX = 1<<3,
LD_SDMIDTEX = 1<<4,
LD_SDTOPOFFX = 1<<5,
LD_SDTOPOFFY = 1<<6,
LD_SDMIDOFFX = 1<<7,
LD_SDMIDOFFY = 1<<8,
LD_SDBOTOFFX = 1<<9,
LD_SDBOTOFFY = 1<<10,
LD_SDTOPSCALEX = 1<<11,
LD_SDTOPSCALEY = 1<<12,
LD_SDMIDSCALEX = 1<<13,
LD_SDMIDSCALEY = 1<<14,
LD_SDBOTSCALEX = 1<<15,
LD_SDBOTSCALEY = 1<<16,
LD_SDLIGHT = 1<<17,
LD_SDTOPLIGHT = 1<<18,
LD_SDMIDLIGHT = 1<<19,
LD_SDBOTLIGHT = 1<<20,
LD_SDREPEATCNT = 1<<21,
LD_SDFLAGS = 1<<22
};
static boolean P_AreArgsEqual(const line_t *li, const line_t *spawnli)
{
@ -1035,6 +1058,14 @@ static void ArchiveSectors(void)
diff2 |= SD_CXOFFS;
if (ss->ceilingyoffset != spawnss->ceilingyoffset)
diff2 |= SD_CYOFFS;
if (ss->floorxscale != spawnss->floorxscale)
diff2 |= SD_FXSCALE;
if (ss->flooryscale != spawnss->flooryscale)
diff2 |= SD_FYSCALE;
if (ss->ceilingxscale != spawnss->ceilingxscale)
diff2 |= SD_CXSCALE;
if (ss->ceilingyscale != spawnss->ceilingyscale)
diff2 |= SD_CYSCALE;
if (ss->floorangle != spawnss->floorangle)
diff2 |= SD_FLOORANG;
if (ss->ceilingangle != spawnss->ceilingangle)
@ -1145,6 +1176,14 @@ static void ArchiveSectors(void)
WRITEUINT8(save_p, ss->triggerer);
if (diff4 & SD_GRAVITY)
WRITEFIXED(save_p, ss->gravity);
if (diff4 & SD_FXSCALE)
WRITEFIXED(save_p, ss->floorxscale);
if (diff4 & SD_FYSCALE)
WRITEFIXED(save_p, ss->flooryscale);
if (diff4 & SD_CXSCALE)
WRITEFIXED(save_p, ss->ceilingxscale);
if (diff4 & SD_CYSCALE)
WRITEFIXED(save_p, ss->ceilingyscale);
if (diff & SD_FFLOORS)
ArchiveFFloors(ss);
}
@ -1266,24 +1305,117 @@ static void UnArchiveSectors(void)
sectors[i].triggerer = READUINT8(save_p);
if (diff4 & SD_GRAVITY)
sectors[i].gravity = READFIXED(save_p);
if (diff4 & SD_FXSCALE)
sectors[i].floorxscale = READFIXED(save_p);
if (diff4 & SD_FYSCALE)
sectors[i].flooryscale = READFIXED(save_p);
if (diff4 & SD_CXSCALE)
sectors[i].ceilingxscale = READFIXED(save_p);
if (diff4 & SD_CYSCALE)
sectors[i].ceilingyscale = READFIXED(save_p);
if (diff & SD_FFLOORS)
UnArchiveFFloors(&sectors[i]);
}
}
static UINT32 GetSideDiff(const side_t *si, const side_t *spawnsi)
{
UINT32 diff = 0;
if (si->textureoffset != spawnsi->textureoffset)
diff |= LD_SDTEXOFFX;
if (si->rowoffset != spawnsi->rowoffset)
diff |= LD_SDTEXOFFY;
//SoM: 4/1/2000: Some textures are colormaps. Don't worry about invalid textures.
if (si->toptexture != spawnsi->toptexture)
diff |= LD_SDTOPTEX;
if (si->bottomtexture != spawnsi->bottomtexture)
diff |= LD_SDBOTTEX;
if (si->midtexture != spawnsi->midtexture)
diff |= LD_SDMIDTEX;
if (si->offsetx_top != spawnsi->offsetx_top)
diff |= LD_SDTOPOFFX;
if (si->offsetx_mid != spawnsi->offsetx_mid)
diff |= LD_SDMIDOFFX;
if (si->offsetx_bottom != spawnsi->offsetx_bottom)
diff |= LD_SDBOTOFFX;
if (si->offsety_top != spawnsi->offsety_top)
diff |= LD_SDTOPOFFY;
if (si->offsety_mid != spawnsi->offsety_mid)
diff |= LD_SDMIDOFFY;
if (si->offsety_bottom != spawnsi->offsety_bottom)
diff |= LD_SDBOTOFFY;
if (si->scalex_top != spawnsi->scalex_top)
diff |= LD_SDTOPSCALEX;
if (si->scalex_mid != spawnsi->scalex_mid)
diff |= LD_SDMIDSCALEX;
if (si->scalex_bottom != spawnsi->scalex_bottom)
diff |= LD_SDBOTSCALEX;
if (si->scaley_top != spawnsi->scaley_top)
diff |= LD_SDTOPSCALEY;
if (si->scaley_mid != spawnsi->scaley_mid)
diff |= LD_SDMIDSCALEY;
if (si->scaley_bottom != spawnsi->scaley_bottom)
diff |= LD_SDBOTSCALEY;
if (si->repeatcnt != spawnsi->repeatcnt)
diff |= LD_SDREPEATCNT;
return diff;
}
static void ArchiveSide(const side_t *si, UINT32 diff)
{
WRITEUINT32(save_p, diff);
if (diff & LD_SDTEXOFFX)
WRITEFIXED(save_p, si->textureoffset);
if (diff & LD_SDTEXOFFY)
WRITEFIXED(save_p, si->rowoffset);
if (diff & LD_SDTOPTEX)
WRITEINT32(save_p, si->toptexture);
if (diff & LD_SDBOTTEX)
WRITEINT32(save_p, si->bottomtexture);
if (diff & LD_SDMIDTEX)
WRITEINT32(save_p, si->midtexture);
if (diff & LD_SDTOPOFFX)
WRITEFIXED(save_p, si->offsetx_top);
if (diff & LD_SDMIDOFFX)
WRITEFIXED(save_p, si->offsetx_mid);
if (diff & LD_SDBOTOFFX)
WRITEFIXED(save_p, si->offsetx_bottom);
if (diff & LD_SDTOPOFFY)
WRITEFIXED(save_p, si->offsety_top);
if (diff & LD_SDMIDOFFY)
WRITEFIXED(save_p, si->offsety_mid);
if (diff & LD_SDBOTOFFY)
WRITEFIXED(save_p, si->offsety_bottom);
if (diff & LD_SDTOPSCALEX)
WRITEFIXED(save_p, si->scalex_top);
if (diff & LD_SDMIDSCALEX)
WRITEFIXED(save_p, si->scalex_mid);
if (diff & LD_SDBOTSCALEX)
WRITEFIXED(save_p, si->scalex_bottom);
if (diff & LD_SDTOPSCALEY)
WRITEFIXED(save_p, si->scaley_top);
if (diff & LD_SDMIDSCALEY)
WRITEFIXED(save_p, si->scaley_mid);
if (diff & LD_SDBOTSCALEY)
WRITEFIXED(save_p, si->scaley_bottom);
if (diff & LD_SDREPEATCNT)
WRITEINT16(save_p, si->repeatcnt);
}
static void ArchiveLines(void)
{
size_t i;
const line_t *li = lines;
const line_t *spawnli = spawnlines;
const side_t *si;
const side_t *spawnsi;
UINT8 diff, diff2; // no diff3
UINT8 diff;
UINT32 diff2;
UINT32 diff3;
for (i = 0; i < numlines; i++, spawnli++, li++)
{
diff = diff2 = 0;
diff = diff2 = diff3 = 0;
if (li->special != spawnli->special)
diff |= LD_SPECIAL;
@ -1292,84 +1424,44 @@ static void ArchiveLines(void)
diff |= LD_CLLCOUNT;
if (!P_AreArgsEqual(li, spawnli))
diff2 |= LD_ARGS;
diff |= LD_ARGS;
if (!P_AreStringArgsEqual(li, spawnli))
diff2 |= LD_STRINGARGS;
diff |= LD_STRINGARGS;
if (li->executordelay != spawnli->executordelay)
diff2 |= LD_EXECUTORDELAY;
diff |= LD_EXECUTORDELAY;
if (li->sidenum[0] != NO_SIDEDEF)
{
si = &sides[li->sidenum[0]];
spawnsi = &spawnsides[li->sidenum[0]];
if (si->textureoffset != spawnsi->textureoffset)
diff |= LD_S1TEXOFF;
//SoM: 4/1/2000: Some textures are colormaps. Don't worry about invalid textures.
if (si->toptexture != spawnsi->toptexture)
diff |= LD_S1TOPTEX;
if (si->bottomtexture != spawnsi->bottomtexture)
diff |= LD_S1BOTTEX;
if (si->midtexture != spawnsi->midtexture)
diff |= LD_S1MIDTEX;
diff2 = GetSideDiff(&sides[li->sidenum[0]], &spawnsides[li->sidenum[0]]);
if (diff2)
diff |= LD_SIDE1;
}
if (li->sidenum[1] != NO_SIDEDEF)
{
si = &sides[li->sidenum[1]];
spawnsi = &spawnsides[li->sidenum[1]];
if (si->textureoffset != spawnsi->textureoffset)
diff2 |= LD_S2TEXOFF;
if (si->toptexture != spawnsi->toptexture)
diff2 |= LD_S2TOPTEX;
if (si->bottomtexture != spawnsi->bottomtexture)
diff2 |= LD_S2BOTTEX;
if (si->midtexture != spawnsi->midtexture)
diff2 |= LD_S2MIDTEX;
diff3 = GetSideDiff(&sides[li->sidenum[1]], &spawnsides[li->sidenum[1]]);
if (diff3)
diff |= LD_SIDE2;
}
if (diff2)
diff |= LD_DIFF2;
if (diff)
{
WRITEUINT32(save_p, i);
WRITEUINT8(save_p, diff);
if (diff & LD_DIFF2)
WRITEUINT8(save_p, diff2);
if (diff & LD_FLAG)
WRITEINT16(save_p, li->flags);
if (diff & LD_SPECIAL)
WRITEINT16(save_p, li->special);
if (diff & LD_CLLCOUNT)
WRITEINT16(save_p, li->callcount);
si = &sides[li->sidenum[0]];
if (diff & LD_S1TEXOFF)
WRITEFIXED(save_p, si->textureoffset);
if (diff & LD_S1TOPTEX)
WRITEINT32(save_p, si->toptexture);
if (diff & LD_S1BOTTEX)
WRITEINT32(save_p, si->bottomtexture);
if (diff & LD_S1MIDTEX)
WRITEINT32(save_p, si->midtexture);
si = &sides[li->sidenum[1]];
if (diff2 & LD_S2TEXOFF)
WRITEFIXED(save_p, si->textureoffset);
if (diff2 & LD_S2TOPTEX)
WRITEINT32(save_p, si->toptexture);
if (diff2 & LD_S2BOTTEX)
WRITEINT32(save_p, si->bottomtexture);
if (diff2 & LD_S2MIDTEX)
WRITEINT32(save_p, si->midtexture);
if (diff2 & LD_ARGS)
if (diff & LD_ARGS)
{
UINT8 j;
for (j = 0; j < NUMLINEARGS; j++)
WRITEINT32(save_p, li->args[j]);
}
if (diff2 & LD_STRINGARGS)
if (diff & LD_STRINGARGS)
{
UINT8 j;
for (j = 0; j < NUMLINESTRINGARGS; j++)
@ -1388,19 +1480,64 @@ static void ArchiveLines(void)
WRITECHAR(save_p, li->stringargs[j][k]);
}
}
if (diff2 & LD_EXECUTORDELAY)
if (diff & LD_EXECUTORDELAY)
WRITEINT32(save_p, li->executordelay);
if (diff & LD_SIDE1)
ArchiveSide(&sides[li->sidenum[0]], diff2);
if (diff & LD_SIDE2)
ArchiveSide(&sides[li->sidenum[1]], diff3);
}
}
WRITEUINT32(save_p, 0xffffffff);
}
static void UnArchiveSide(side_t *si)
{
UINT32 diff = READUINT32(save_p);
if (diff & LD_SDTEXOFFX)
si->textureoffset = READFIXED(save_p);
if (diff & LD_SDTEXOFFY)
si->rowoffset = READFIXED(save_p);
if (diff & LD_SDTOPTEX)
si->toptexture = READINT32(save_p);
if (diff & LD_SDBOTTEX)
si->bottomtexture = READINT32(save_p);
if (diff & LD_SDMIDTEX)
si->midtexture = READINT32(save_p);
if (diff & LD_SDTOPOFFX)
si->offsetx_top = READFIXED(save_p);
if (diff & LD_SDMIDOFFX)
si->offsetx_mid = READFIXED(save_p);
if (diff & LD_SDBOTOFFX)
si->offsetx_bottom = READFIXED(save_p);
if (diff & LD_SDTOPOFFY)
si->offsety_top = READFIXED(save_p);
if (diff & LD_SDMIDOFFY)
si->offsety_mid = READFIXED(save_p);
if (diff & LD_SDBOTOFFY)
si->offsety_bottom = READFIXED(save_p);
if (diff & LD_SDTOPSCALEX)
si->scalex_top = READFIXED(save_p);
if (diff & LD_SDMIDSCALEX)
si->scalex_mid = READFIXED(save_p);
if (diff & LD_SDBOTSCALEX)
si->scalex_bottom = READFIXED(save_p);
if (diff & LD_SDTOPSCALEY)
si->scaley_top = READFIXED(save_p);
if (diff & LD_SDMIDSCALEY)
si->scaley_mid = READFIXED(save_p);
if (diff & LD_SDBOTSCALEY)
si->scaley_bottom = READFIXED(save_p);
if (diff & LD_SDREPEATCNT)
si->repeatcnt = READINT16(save_p);
}
static void UnArchiveLines(void)
{
UINT32 i;
line_t *li;
side_t *si;
UINT8 diff, diff2; // no diff3
UINT8 diff;
for (;;)
{
@ -1414,44 +1551,19 @@ static void UnArchiveLines(void)
diff = READUINT8(save_p);
li = &lines[i];
if (diff & LD_DIFF2)
diff2 = READUINT8(save_p);
else
diff2 = 0;
if (diff & LD_FLAG)
li->flags = READINT16(save_p);
if (diff & LD_SPECIAL)
li->special = READINT16(save_p);
if (diff & LD_CLLCOUNT)
li->callcount = READINT16(save_p);
si = &sides[li->sidenum[0]];
if (diff & LD_S1TEXOFF)
si->textureoffset = READFIXED(save_p);
if (diff & LD_S1TOPTEX)
si->toptexture = READINT32(save_p);
if (diff & LD_S1BOTTEX)
si->bottomtexture = READINT32(save_p);
if (diff & LD_S1MIDTEX)
si->midtexture = READINT32(save_p);
si = &sides[li->sidenum[1]];
if (diff2 & LD_S2TEXOFF)
si->textureoffset = READFIXED(save_p);
if (diff2 & LD_S2TOPTEX)
si->toptexture = READINT32(save_p);
if (diff2 & LD_S2BOTTEX)
si->bottomtexture = READINT32(save_p);
if (diff2 & LD_S2MIDTEX)
si->midtexture = READINT32(save_p);
if (diff2 & LD_ARGS)
if (diff & LD_ARGS)
{
UINT8 j;
for (j = 0; j < NUMLINEARGS; j++)
li->args[j] = READINT32(save_p);
}
if (diff2 & LD_STRINGARGS)
if (diff & LD_STRINGARGS)
{
UINT8 j;
for (j = 0; j < NUMLINESTRINGARGS; j++)
@ -1472,9 +1584,12 @@ static void UnArchiveLines(void)
li->stringargs[j][len] = '\0';
}
}
if (diff2 & LD_EXECUTORDELAY)
if (diff & LD_EXECUTORDELAY)
li->executordelay = READINT32(save_p);
if (diff & LD_SIDE1)
UnArchiveSide(&sides[li->sidenum[0]]);
if (diff & LD_SIDE2)
UnArchiveSide(&sides[li->sidenum[1]]);
}
}

92
src/p_setup.c
View file

@ -1055,6 +1055,9 @@ static void P_LoadSectors(UINT8 *data)
ss->floorxoffset = ss->flooryoffset = 0;
ss->ceilingxoffset = ss->ceilingyoffset = 0;
ss->floorxscale = ss->flooryscale = FRACUNIT;
ss->ceilingxscale = ss->ceilingyscale = FRACUNIT;
ss->floorangle = ss->ceilingangle = 0;
ss->floorlightlevel = ss->ceilinglightlevel = 0;
@ -1352,8 +1355,11 @@ static void P_LoadSidedefs(UINT8 *data)
}
sd->rowoffset = SHORT(msd->rowoffset)<<FRACBITS;
sd->offsetx_top = sd->offsetx_mid = sd->offsetx_bot = 0;
sd->offsety_top = sd->offsety_mid = sd->offsety_bot = 0;
sd->offsetx_top = sd->offsetx_mid = sd->offsetx_bottom = 0;
sd->offsety_top = sd->offsety_mid = sd->offsety_bottom = 0;
sd->scalex_top = sd->scalex_mid = sd->scalex_bottom = FRACUNIT;
sd->scaley_top = sd->scaley_mid = sd->scaley_bottom = FRACUNIT;
P_SetSidedefSector(i, (UINT16)SHORT(msd->sector));
@ -1693,6 +1699,14 @@ static void ParseTextmapSectorParameter(UINT32 i, const char *param, const char
sectors[i].ceilingxoffset = FLOAT_TO_FIXED(atof(val));
else if (fastcmp(param, "ypanningceiling"))
sectors[i].ceilingyoffset = FLOAT_TO_FIXED(atof(val));
else if (fastcmp(param, "xscalefloor"))
sectors[i].floorxscale = FLOAT_TO_FIXED(atof(val));
else if (fastcmp(param, "yscalefloor"))
sectors[i].flooryscale = FLOAT_TO_FIXED(atof(val));
else if (fastcmp(param, "xscaleceiling"))
sectors[i].ceilingxscale = FLOAT_TO_FIXED(atof(val));
else if (fastcmp(param, "yscaleceiling"))
sectors[i].ceilingyscale = FLOAT_TO_FIXED(atof(val));
else if (fastcmp(param, "rotationfloor"))
sectors[i].floorangle = FixedAngle(FLOAT_TO_FIXED(atof(val)));
else if (fastcmp(param, "rotationceiling"))
@ -1888,13 +1902,25 @@ static void ParseTextmapSidedefParameter(UINT32 i, const char *param, const char
else if (fastcmp(param, "offsetx_mid"))
sides[i].offsetx_mid = atol(val) << FRACBITS;
else if (fastcmp(param, "offsetx_bottom"))
sides[i].offsetx_bot = atol(val) << FRACBITS;
sides[i].offsetx_bottom = atol(val) << FRACBITS;
else if (fastcmp(param, "offsety_top"))
sides[i].offsety_top = atol(val) << FRACBITS;
else if (fastcmp(param, "offsety_mid"))
sides[i].offsety_mid = atol(val) << FRACBITS;
else if (fastcmp(param, "offsety_bottom"))
sides[i].offsety_bot = atol(val) << FRACBITS;
sides[i].offsety_bottom = atol(val) << FRACBITS;
else if (fastcmp(param, "scalex_top"))
sides[i].scalex_top = FLOAT_TO_FIXED(atof(val));
else if (fastcmp(param, "scalex_mid"))
sides[i].scalex_mid = FLOAT_TO_FIXED(atof(val));
else if (fastcmp(param, "scalex_bottom"))
sides[i].scalex_bottom = FLOAT_TO_FIXED(atof(val));
else if (fastcmp(param, "scaley_top"))
sides[i].scaley_top = FLOAT_TO_FIXED(atof(val));
else if (fastcmp(param, "scaley_mid"))
sides[i].scaley_mid = FLOAT_TO_FIXED(atof(val));
else if (fastcmp(param, "scaley_bottom"))
sides[i].scaley_bottom = FLOAT_TO_FIXED(atof(val));
else if (fastcmp(param, "texturetop"))
sides[i].toptexture = R_TextureNumForName(val);
else if (fastcmp(param, "texturebottom"))
@ -2599,10 +2625,22 @@ static void P_WriteTextmap(void)
fprintf(f, "offsetx_mid = %d;\n", wsides[i].offsetx_mid >> FRACBITS);
if (wsides[i].offsety_mid != 0)
fprintf(f, "offsety_mid = %d;\n", wsides[i].offsety_mid >> FRACBITS);
if (wsides[i].offsetx_bot != 0)
fprintf(f, "offsetx_bottom = %d;\n", wsides[i].offsetx_bot >> FRACBITS);
if (wsides[i].offsety_bot != 0)
fprintf(f, "offsety_bottom = %d;\n", wsides[i].offsety_bot >> FRACBITS);
if (wsides[i].offsetx_bottom != 0)
fprintf(f, "offsetx_bottom = %d;\n", wsides[i].offsetx_bottom >> FRACBITS);
if (wsides[i].offsety_bottom != 0)
fprintf(f, "offsety_bottom = %d;\n", wsides[i].offsety_bottom >> FRACBITS);
if (wsides[i].scalex_top != FRACUNIT)
fprintf(f, "scalex_top = %f;\n", FIXED_TO_FLOAT(wsides[i].scalex_top));
if (wsides[i].scaley_top != FRACUNIT)
fprintf(f, "scaley_top = %f;\n", FIXED_TO_FLOAT(wsides[i].scaley_top));
if (wsides[i].scalex_mid != FRACUNIT)
fprintf(f, "scalex_mid = %f;\n", FIXED_TO_FLOAT(wsides[i].scalex_mid));
if (wsides[i].scaley_mid != FRACUNIT)
fprintf(f, "scaley_mid = %f;\n", FIXED_TO_FLOAT(wsides[i].scaley_mid));
if (wsides[i].scalex_bottom != FRACUNIT)
fprintf(f, "scalex_bottom = %f;\n", FIXED_TO_FLOAT(wsides[i].scalex_bottom));
if (wsides[i].scaley_bottom != FRACUNIT)
fprintf(f, "scaley_bottom = %f;\n", FIXED_TO_FLOAT(wsides[i].scaley_bottom));
if (wsides[i].toptexture > 0 && wsides[i].toptexture < numtextures)
fprintf(f, "texturetop = \"%.*s\";\n", 8, textures[wsides[i].toptexture]->name);
if (wsides[i].bottomtexture > 0 && wsides[i].bottomtexture < numtextures)
@ -2658,6 +2696,14 @@ static void P_WriteTextmap(void)
fprintf(f, "xpanningceiling = %f;\n", FIXED_TO_FLOAT(tempsec.ceilingxoffset));
if (tempsec.ceilingyoffset != 0)
fprintf(f, "ypanningceiling = %f;\n", FIXED_TO_FLOAT(tempsec.ceilingyoffset));
if (tempsec.floorxscale != 0)
fprintf(f, "xscalefloor = %f;\n", FIXED_TO_FLOAT(tempsec.floorxscale));
if (tempsec.flooryscale != 0)
fprintf(f, "yscalefloor = %f;\n", FIXED_TO_FLOAT(tempsec.flooryscale));
if (tempsec.ceilingxscale != 0)
fprintf(f, "xscaleceiling = %f;\n", FIXED_TO_FLOAT(tempsec.ceilingxscale));
if (tempsec.ceilingyscale != 0)
fprintf(f, "yscaleceiling = %f;\n", FIXED_TO_FLOAT(tempsec.ceilingyscale));
if (wsectors[i].floorangle != 0)
fprintf(f, "rotationfloor = %f;\n", FIXED_TO_FLOAT(AngleFixed(wsectors[i].floorangle)));
if (wsectors[i].ceilingangle != 0)
@ -2893,6 +2939,9 @@ static void P_LoadTextmap(void)
sc->floorxoffset = sc->flooryoffset = 0;
sc->ceilingxoffset = sc->ceilingyoffset = 0;
sc->floorxscale = sc->flooryscale = FRACUNIT;
sc->ceilingxscale = sc->ceilingyscale = FRACUNIT;
sc->floorangle = sc->ceilingangle = 0;
sc->floorlightlevel = sc->ceilinglightlevel = 0;
@ -2927,22 +2976,26 @@ static void P_LoadTextmap(void)
P_InitializeSector(sc);
if (textmap_colormap.used)
{
INT32 rgba = P_ColorToRGBA(textmap_colormap.lightcolor, textmap_colormap.lightalpha);
INT32 fadergba = P_ColorToRGBA(textmap_colormap.fadecolor, textmap_colormap.fadealpha);
// Convert alpha values from old 0-25 (A-Z) range to 0-255 range
UINT8 lightalpha = (textmap_colormap.lightalpha * 102) / 10;
UINT8 fadealpha = (textmap_colormap.fadealpha * 102) / 10;
INT32 rgba = P_ColorToRGBA(textmap_colormap.lightcolor, lightalpha);
INT32 fadergba = P_ColorToRGBA(textmap_colormap.fadecolor, fadealpha);
sc->extra_colormap = sc->spawn_extra_colormap = R_CreateColormap(rgba, fadergba, textmap_colormap.fadestart, textmap_colormap.fadeend, textmap_colormap.flags);
}
if (textmap_planefloor.defined == (PD_A|PD_B|PD_C|PD_D))
{
{
sc->f_slope = MakeViaEquationConstants(textmap_planefloor.a, textmap_planefloor.b, textmap_planefloor.c, textmap_planefloor.d);
sc->hasslope = true;
}
}
if (textmap_planeceiling.defined == (PD_A|PD_B|PD_C|PD_D))
{
{
sc->c_slope = MakeViaEquationConstants(textmap_planeceiling.a, textmap_planeceiling.b, textmap_planeceiling.c, textmap_planeceiling.d);
sc->hasslope = true;
}
}
TextmapFixFlatOffsets(sc);
}
@ -2979,8 +3032,10 @@ static void P_LoadTextmap(void)
// Defaults.
sd->textureoffset = 0;
sd->rowoffset = 0;
sd->offsetx_top = sd->offsetx_mid = sd->offsetx_bot = 0;
sd->offsety_top = sd->offsety_mid = sd->offsety_bot = 0;
sd->offsetx_top = sd->offsetx_mid = sd->offsetx_bottom = 0;
sd->offsety_top = sd->offsety_mid = sd->offsety_bottom = 0;
sd->scalex_top = sd->scalex_mid = sd->scalex_bottom = FRACUNIT;
sd->scaley_top = sd->scaley_mid = sd->scaley_bottom = FRACUNIT;
sd->toptexture = R_TextureNumForName("-");
sd->midtexture = R_TextureNumForName("-");
sd->bottomtexture = R_TextureNumForName("-");
@ -3306,7 +3361,7 @@ static void P_LoadSegs(UINT8 *data)
seg->length = P_SegLength(seg);
#ifdef HWRENDER
seg->flength = (rendermode == render_opengl) ? P_SegLengthFloat(seg) : 0;
seg->flength = P_SegLengthFloat(seg);
#endif
seg->glseg = false;
@ -3548,7 +3603,7 @@ static boolean P_LoadExtendedSubsectorsAndSegs(UINT8 **data, nodetype_t nodetype
}
seg->length = P_SegLength(seg);
#ifdef HWRENDER
seg->flength = (rendermode == render_opengl) ? P_SegLengthFloat(seg) : 0;
seg->flength = P_SegLengthFloat(seg);
#endif
}
@ -7821,6 +7876,7 @@ boolean P_LoadLevel(boolean fromnetsave, boolean reloadinggamestate)
Patch_FreeTag(PU_PATCH_LOWPRIORITY);
Patch_FreeTag(PU_PATCH_ROTATED);
Z_FreeTags(PU_LEVEL, PU_PURGELEVEL - 1);
mobjcache = NULL;
R_InitializeLevelInterpolators();

18
src/p_spec.c
View file

@ -2735,7 +2735,7 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
mo->player->rmomx = mo->player->rmomy = 1;
mo->player->cmomx = mo->player->cmomy = 0;
P_ResetPlayer(mo->player);
P_SetPlayerMobjState(mo, S_PLAY_STND);
P_SetMobjState(mo, S_PLAY_STND);
// Reset bot too.
if (bot) {
@ -2746,7 +2746,7 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
bot->player->rmomx = bot->player->rmomy = 1;
bot->player->cmomx = bot->player->cmomy = 0;
P_ResetPlayer(bot->player);
P_SetPlayerMobjState(bot, S_PLAY_STND);
P_SetMobjState(bot, S_PLAY_STND);
}
}
break;
@ -4566,7 +4566,7 @@ static void P_ProcessSpeedPad(player_t *player, sector_t *sector, sector_t *rove
if (!(player->pflags & PF_SPINNING))
player->pflags |= PF_SPINNING;
P_SetPlayerMobjState(player->mo, S_PLAY_ROLL);
P_SetMobjState(player->mo, S_PLAY_ROLL);
}
player->powers[pw_flashing] = TICRATE/3;
@ -4744,7 +4744,7 @@ static void P_ProcessZoomTube(player_t *player, mtag_t sectag, boolean end)
if (player->mo->state-states != S_PLAY_ROLL)
{
P_SetPlayerMobjState(player->mo, S_PLAY_ROLL);
P_SetMobjState(player->mo, S_PLAY_ROLL);
S_StartSound(player->mo, sfx_spin);
}
}
@ -4958,7 +4958,7 @@ static void P_ProcessRopeHang(player_t *player, mtag_t sectag)
player->pflags &= ~(PF_JUMPED|PF_NOJUMPDAMAGE|PF_GLIDING|PF_BOUNCING|PF_SLIDING|PF_CANCARRY);
player->climbing = 0;
P_SetThingPosition(player->mo);
P_SetPlayerMobjState(player->mo, S_PLAY_RIDE);
P_SetMobjState(player->mo, S_PLAY_RIDE);
}
static boolean P_SectorHasSpecial(sector_t *sec)
@ -5017,7 +5017,7 @@ static void P_EvaluateSpecialFlags(player_t *player, sector_t *sector, sector_t
if (!player->powers[pw_carry])
{
P_ResetPlayer(player);
P_SetPlayerMobjState(player->mo, S_PLAY_FALL);
P_SetMobjState(player->mo, S_PLAY_FALL);
P_SetTarget(&player->mo->tracer, player->mo);
player->powers[pw_carry] = CR_FAN;
}
@ -5032,7 +5032,7 @@ static void P_EvaluateSpecialFlags(player_t *player, sector_t *sector, sector_t
if (!(player->pflags & PF_SPINNING))
{
player->pflags |= PF_SPINNING;
P_SetPlayerMobjState(player->mo, S_PLAY_ROLL);
P_SetMobjState(player->mo, S_PLAY_ROLL);
S_StartAttackSound(player->mo, sfx_spin);
if (abs(player->rmomx) < FixedMul(5*FRACUNIT, player->mo->scale)
@ -5605,6 +5605,8 @@ static ffloor_t *P_AddFakeFloor(sector_t *sec, sector_t *sec2, line_t *master, I
fflr->bottompic = &sec2->floorpic;
fflr->bottomxoffs = &sec2->floorxoffset;
fflr->bottomyoffs = &sec2->flooryoffset;
fflr->bottomxscale = &sec2->floorxscale;
fflr->bottomyscale = &sec2->flooryscale;
fflr->bottomangle = &sec2->floorangle;
// Add the ceiling
@ -5613,6 +5615,8 @@ static ffloor_t *P_AddFakeFloor(sector_t *sec, sector_t *sec2, line_t *master, I
fflr->toplightlevel = &sec2->lightlevel;
fflr->topxoffs = &sec2->ceilingxoffset;
fflr->topyoffs = &sec2->ceilingyoffset;
fflr->topxscale = &sec2->ceilingxscale;
fflr->topyscale = &sec2->ceilingyscale;
fflr->topangle = &sec2->ceilingangle;
// Add slopes

4
src/p_telept.c
View file

@ -96,7 +96,7 @@ void P_MixUp(mobj_t *thing, fixed_t x, fixed_t y, fixed_t z, angle_t angle,
P_ClearStarPost(starpostnum);
P_ResetPlayer(thing->player);
P_SetPlayerMobjState(thing, S_PLAY_STND);
P_SetMobjState(thing, S_PLAY_STND);
P_FlashPal(thing->player, PAL_MIXUP, 10);
}
@ -153,7 +153,7 @@ boolean P_Teleport(mobj_t *thing, fixed_t x, fixed_t y, fixed_t z, angle_t angle
thing->player->rmomx = thing->player->rmomy = 0;
thing->player->speed = 0;
P_ResetPlayer(thing->player);
P_SetPlayerMobjState(thing, S_PLAY_STND);
P_SetMobjState(thing, S_PLAY_STND);
thing->reactiontime = TICRATE/2; // don't move for about half a second
thing->player->drawangle = angle;

43
src/p_tick.c
View file

@ -217,6 +217,7 @@ void P_AddThinker(const thinklistnum_t n, thinker_t *thinker)
thlist[n].prev = thinker;
thinker->references = 0; // killough 11/98: init reference counter to 0
thinker->cachable = n == THINK_MOBJ;
#ifdef PARANOIA
thinker->debug_mobjtype = MT_NULL;
@ -226,21 +227,22 @@ void P_AddThinker(const thinklistnum_t n, thinker_t *thinker)
#ifdef PARANOIA
static const char *MobjTypeName(const mobj_t *mobj)
{
mobjtype_t type;
actionf_p1 p1 = mobj->thinker.function.acp1;
if (p1 == (actionf_p1)P_MobjThinker)
{
return MOBJTYPE_LIST[mobj->type];
}
else if (p1 == (actionf_p1)P_RemoveThinkerDelayed)
{
if (mobj->thinker.debug_mobjtype != MT_NULL)
{
return MOBJTYPE_LIST[mobj->thinker.debug_mobjtype];
}
}
type = mobj->type;
else if (p1 == (actionf_p1)P_RemoveThinkerDelayed && mobj->thinker.debug_mobjtype != MT_NULL)
type = mobj->thinker.debug_mobjtype;
else
return "<Not a mobj>";
return "<Not a mobj>";
if (type < 0 || type >= NUMMOBJTYPES || (type >= MT_FIRSTFREESLOT && !FREE_MOBJS[type - MT_FIRSTFREESLOT]))
return "<Invalid mobj type>";
else if (type >= MT_FIRSTFREESLOT)
return FREE_MOBJS[type - MT_FIRSTFREESLOT]; // This doesn't include "MT_"...
else
return MOBJTYPE_LIST[type];
}
static const char *MobjThinkerName(const mobj_t *mobj)
@ -319,7 +321,16 @@ void P_RemoveThinkerDelayed(thinker_t *thinker)
(next->prev = currentthinker = thinker->prev)->next = next;
R_DestroyLevelInterpolators(thinker);
Z_Free(thinker);
if (thinker->cachable)
{
// put cachable thinkers in the mobj cache, so we can avoid allocations
((mobj_t *)thinker)->hnext = mobjcache;
mobjcache = (mobj_t *)thinker;
}
else
{
Z_Free(thinker);
}
}
//
@ -758,7 +769,9 @@ void P_Ticker(boolean run)
ps_lua_mobjhooks.value.i = 0;
ps_checkposition_calls.value.i = 0;
LUA_HOOK(PreThinkFrame);
PS_START_TIMING(ps_lua_prethinkframe_time);
LUA_HookPreThinkFrame();
PS_STOP_TIMING(ps_lua_prethinkframe_time);
PS_START_TIMING(ps_playerthink_time);
for (i = 0; i < MAXPLAYERS; i++)
@ -856,7 +869,9 @@ void P_Ticker(boolean run)
if (modeattacking)
G_GhostTicker();
LUA_HOOK(PostThinkFrame);
PS_START_TIMING(ps_lua_postthinkframe_time);
LUA_HookPostThinkFrame();
PS_STOP_TIMING(ps_lua_postthinkframe_time);
}
if (run)

699
src/p_user.c
View file

File diff suppressed because it is too large Load diff

44
src/r_bsp.c
View file

@ -277,6 +277,8 @@ sector_t *R_FakeFlat(sector_t *sec, sector_t *tempsec, INT32 *floorlightlevel,
tempsec->floorpic = s->floorpic;
tempsec->floorxoffset = s->floorxoffset;
tempsec->flooryoffset = s->flooryoffset;
tempsec->floorxscale = s->floorxscale;
tempsec->flooryscale = s->flooryscale;
tempsec->floorangle = s->floorangle;
if (underwater)
@ -287,6 +289,8 @@ sector_t *R_FakeFlat(sector_t *sec, sector_t *tempsec, INT32 *floorlightlevel,
tempsec->ceilingpic = tempsec->floorpic;
tempsec->ceilingxoffset = tempsec->floorxoffset;
tempsec->ceilingyoffset = tempsec->flooryoffset;
tempsec->ceilingxscale = tempsec->floorxscale;
tempsec->ceilingyscale = tempsec->flooryscale;
tempsec->ceilingangle = tempsec->floorangle;
}
else
@ -294,6 +298,8 @@ sector_t *R_FakeFlat(sector_t *sec, sector_t *tempsec, INT32 *floorlightlevel,
tempsec->ceilingpic = s->ceilingpic;
tempsec->ceilingxoffset = s->ceilingxoffset;
tempsec->ceilingyoffset = s->ceilingyoffset;
tempsec->ceilingxscale = s->ceilingxscale;
tempsec->ceilingyscale = s->ceilingyscale;
tempsec->ceilingangle = s->ceilingangle;
}
}
@ -317,6 +323,8 @@ sector_t *R_FakeFlat(sector_t *sec, sector_t *tempsec, INT32 *floorlightlevel,
tempsec->floorpic = tempsec->ceilingpic = s->ceilingpic;
tempsec->floorxoffset = tempsec->ceilingxoffset = s->ceilingxoffset;
tempsec->flooryoffset = tempsec->ceilingyoffset = s->ceilingyoffset;
tempsec->floorxscale = tempsec->ceilingxscale = s->ceilingxscale;
tempsec->flooryscale = tempsec->ceilingyscale = s->ceilingyscale;
tempsec->floorangle = tempsec->ceilingangle = s->ceilingangle;
if (s->floorpic == skyflatnum) // SKYFIX?
@ -325,6 +333,8 @@ sector_t *R_FakeFlat(sector_t *sec, sector_t *tempsec, INT32 *floorlightlevel,
tempsec->floorpic = tempsec->ceilingpic;
tempsec->floorxoffset = tempsec->ceilingxoffset;
tempsec->flooryoffset = tempsec->ceilingyoffset;
tempsec->floorxscale = tempsec->ceilingxscale;
tempsec->flooryscale = tempsec->ceilingyscale;
tempsec->floorangle = tempsec->ceilingangle;
}
else
@ -333,6 +343,8 @@ sector_t *R_FakeFlat(sector_t *sec, sector_t *tempsec, INT32 *floorlightlevel,
tempsec->floorpic = s->floorpic;
tempsec->floorxoffset = s->floorxoffset;
tempsec->flooryoffset = s->flooryoffset;
tempsec->floorxscale = s->floorxscale;
tempsec->flooryscale = s->flooryscale;
tempsec->floorangle = s->floorangle;
}
@ -362,12 +374,16 @@ boolean R_IsEmptyLine(seg_t *line, sector_t *front, sector_t *back)
&& back->c_slope == front->c_slope
&& back->lightlevel == front->lightlevel
&& !line->sidedef->midtexture
// Check offsets too!
// Check offsets and scale too!
&& back->floorxoffset == front->floorxoffset
&& back->flooryoffset == front->flooryoffset
&& back->floorxscale == front->floorxscale
&& back->flooryscale == front->flooryscale
&& back->floorangle == front->floorangle
&& back->ceilingxoffset == front->ceilingxoffset
&& back->ceilingyoffset == front->ceilingyoffset
&& back->ceilingxscale == front->ceilingxscale
&& back->ceilingyscale == front->ceilingyscale
&& back->ceilingangle == front->ceilingangle
// Consider altered lighting.
&& back->floorlightlevel == front->floorlightlevel
@ -909,7 +925,9 @@ static void R_Subsector(size_t num)
|| (frontsector->heightsec != -1 && sectors[frontsector->heightsec].ceilingpic == skyflatnum))
{
floorplane = R_FindPlane(frontsector->floorheight, frontsector->floorpic, floorlightlevel,
frontsector->floorxoffset, frontsector->flooryoffset, frontsector->floorangle, floorcolormap, NULL, NULL, frontsector->f_slope);
frontsector->floorxoffset, frontsector->flooryoffset,
frontsector->floorxscale, frontsector->flooryscale, frontsector->floorangle,
floorcolormap, NULL, NULL, frontsector->f_slope);
}
else
floorplane = NULL;
@ -918,8 +936,9 @@ static void R_Subsector(size_t num)
|| frontsector->ceilingpic == skyflatnum
|| (frontsector->heightsec != -1 && sectors[frontsector->heightsec].floorpic == skyflatnum))
{
ceilingplane = R_FindPlane(frontsector->ceilingheight, frontsector->ceilingpic,
ceilinglightlevel, frontsector->ceilingxoffset, frontsector->ceilingyoffset, frontsector->ceilingangle,
ceilingplane = R_FindPlane(frontsector->ceilingheight, frontsector->ceilingpic, ceilinglightlevel,
frontsector->ceilingxoffset, frontsector->ceilingyoffset,
frontsector->ceilingxscale, frontsector->ceilingyscale, frontsector->ceilingangle,
ceilingcolormap, NULL, NULL, frontsector->c_slope);
}
else
@ -962,8 +981,9 @@ static void R_Subsector(size_t num)
viewz < heightcheck);
ffloor[numffloors].plane = R_FindPlane(*rover->bottomheight, *rover->bottompic,
*frontsector->lightlist[light].lightlevel, *rover->bottomxoffs,
*rover->bottomyoffs, *rover->bottomangle, *frontsector->lightlist[light].extra_colormap, rover, NULL, *rover->b_slope);
*frontsector->lightlist[light].lightlevel, *rover->bottomxoffs, *rover->bottomyoffs,
*rover->bottomxscale, *rover->bottomyscale, *rover->bottomangle,
*frontsector->lightlist[light].extra_colormap, rover, NULL, *rover->b_slope);
ffloor[numffloors].slope = *rover->b_slope;
@ -991,7 +1011,8 @@ static void R_Subsector(size_t num)
light = R_GetPlaneLight(frontsector, planecenterz, viewz < heightcheck);
ffloor[numffloors].plane = R_FindPlane(*rover->topheight, *rover->toppic,
*frontsector->lightlist[light].lightlevel, *rover->topxoffs, *rover->topyoffs, *rover->topangle,
*frontsector->lightlist[light].lightlevel, *rover->topxoffs, *rover->topyoffs,
*rover->topxscale, *rover->topyscale, *rover->topangle,
*frontsector->lightlist[light].extra_colormap, rover, NULL, *rover->t_slope);
ffloor[numffloors].slope = *rover->t_slope;
@ -1033,7 +1054,9 @@ static void R_Subsector(size_t num)
{
light = R_GetPlaneLight(frontsector, polysec->floorheight, viewz < polysec->floorheight);
ffloor[numffloors].plane = R_FindPlane(polysec->floorheight, polysec->floorpic,
(light == -1 ? frontsector->lightlevel : *frontsector->lightlist[light].lightlevel), polysec->floorxoffset, polysec->flooryoffset,
(light == -1 ? frontsector->lightlevel : *frontsector->lightlist[light].lightlevel),
polysec->floorxoffset, polysec->flooryoffset,
polysec->floorxscale, polysec->flooryscale,
polysec->floorangle-po->angle,
(light == -1 ? frontsector->extra_colormap : *frontsector->lightlist[light].extra_colormap), NULL, po,
NULL); // will ffloors be slopable eventually?
@ -1057,7 +1080,10 @@ static void R_Subsector(size_t num)
{
light = R_GetPlaneLight(frontsector, polysec->floorheight, viewz < polysec->floorheight);
ffloor[numffloors].plane = R_FindPlane(polysec->ceilingheight, polysec->ceilingpic,
(light == -1 ? frontsector->lightlevel : *frontsector->lightlist[light].lightlevel), polysec->ceilingxoffset, polysec->ceilingyoffset, polysec->ceilingangle-po->angle,
(light == -1 ? frontsector->lightlevel : *frontsector->lightlist[light].lightlevel),
polysec->ceilingxoffset, polysec->ceilingyoffset,
polysec->ceilingxscale, polysec->ceilingyscale,
polysec->ceilingangle-po->angle,
(light == -1 ? frontsector->extra_colormap : *frontsector->lightlist[light].extra_colormap), NULL, po,
NULL); // will ffloors be slopable eventually?

18
src/r_defs.h
View file

@ -218,12 +218,16 @@ typedef struct ffloor_s
INT16 *toplightlevel;
fixed_t *topxoffs;
fixed_t *topyoffs;
fixed_t *topxscale;
fixed_t *topyscale;
angle_t *topangle;
fixed_t *bottomheight;
INT32 *bottompic;
fixed_t *bottomxoffs;
fixed_t *bottomyoffs;
fixed_t *bottomxscale;
fixed_t *bottomyscale;
angle_t *bottomangle;
// Pointers to pointers. Yup.
@ -429,6 +433,10 @@ typedef struct sector_s
fixed_t floorxoffset, flooryoffset;
fixed_t ceilingxoffset, ceilingyoffset;
// floor and ceiling texture scale
fixed_t floorxscale, flooryscale;
fixed_t ceilingxscale, ceilingyscale;
// flat angle
angle_t floorangle;
angle_t ceilingangle;
@ -564,8 +572,11 @@ typedef struct
fixed_t rowoffset;
// per-texture offsets for UDMF
fixed_t offsetx_top, offsetx_mid, offsetx_bot;
fixed_t offsety_top, offsety_mid, offsety_bot;
fixed_t offsetx_top, offsetx_mid, offsetx_bottom;
fixed_t offsety_top, offsety_mid, offsety_bottom;
fixed_t scalex_top, scalex_mid, scalex_bottom;
fixed_t scaley_top, scaley_mid, scaley_bottom;
// Texture indices.
// We do not maintain names here.
@ -759,10 +770,13 @@ typedef struct drawseg_s
fixed_t bsilheight; // do not clip sprites above this
fixed_t tsilheight; // do not clip sprites below this
fixed_t offsetx;
// Pointers to lists for sprite clipping, all three adjusted so [x1] is first value.
INT16 *sprtopclip;
INT16 *sprbottomclip;
fixed_t *maskedtexturecol;
fixed_t *invscale;
struct visplane_s *ffloorplanes[MAXFFLOORS];
INT32 numffloorplanes;

19
src/r_draw.c
View file

@ -106,14 +106,13 @@ fixed_t ds_xfrac, ds_yfrac, ds_xstep, ds_ystep;
INT32 ds_waterofs, ds_bgofs;
UINT16 ds_flatwidth, ds_flatheight;
boolean ds_powersoftwo, ds_solidcolor;
boolean ds_powersoftwo, ds_solidcolor, ds_fog;
UINT8 *ds_source; // points to the start of a flat
UINT8 *ds_transmap; // one of the translucency tables
// Vectors for Software's tilted slope drawers
floatv3_t *ds_su, *ds_sv, *ds_sz;
floatv3_t *ds_sup, *ds_svp, *ds_szp;
floatv3_t ds_su, ds_sv, ds_sz, ds_slopelight;
float focallengthf, zeroheight;
/** \brief Variable flat sizes
@ -930,13 +929,15 @@ static void R_CalcTiltedLighting(fixed_t start, fixed_t end)
}
}
#define PLANELIGHTFLOAT (BASEVIDWIDTH * BASEVIDWIDTH / vid.width / zeroheight / 21.0f * FIXED_TO_FLOAT(fovtan))
// Lighting is simple. It's just linear interpolation from start to end
#define CALC_SLOPE_LIGHT { \
float planelightfloat = PLANELIGHTFLOAT; \
float lightstart, lightend; \
lightend = (iz + ds_szp->x*width) * planelightfloat; \
lightstart = iz * planelightfloat; \
R_CalcTiltedLighting(FloatToFixed(lightstart), FloatToFixed(lightend)); \
static void R_CalcSlopeLight(void)
{
float iz = ds_slopelight.z + ds_slopelight.y * (centery - ds_y) + ds_slopelight.x * (ds_x1 - centerx);
float lightstart = iz * PLANELIGHTFLOAT;
float lightend = (iz + ds_slopelight.x * (ds_x2 - ds_x1)) * PLANELIGHTFLOAT;
R_CalcTiltedLighting(FloatToFixed(lightstart), FloatToFixed(lightend));
}
// ==========================================================================

7
src/r_draw.h
View file

@ -61,7 +61,7 @@ extern fixed_t ds_xfrac, ds_yfrac, ds_xstep, ds_ystep;
extern INT32 ds_waterofs, ds_bgofs;
extern UINT16 ds_flatwidth, ds_flatheight;
extern boolean ds_powersoftwo, ds_solidcolor;
extern boolean ds_powersoftwo, ds_solidcolor, ds_fog;
extern UINT8 *ds_source;
extern UINT8 *ds_transmap;
@ -71,8 +71,7 @@ typedef struct {
} floatv3_t;
// Vectors for Software's tilted slope drawers
extern floatv3_t *ds_su, *ds_sv, *ds_sz;
extern floatv3_t *ds_sup, *ds_svp, *ds_szp;
extern floatv3_t ds_su, ds_sv, ds_sz, ds_slopelight;
extern float focallengthf, zeroheight;
// Variable flat sizes
@ -178,8 +177,6 @@ void R_Draw2sMultiPatchTranslucentColumn_8(void);
void R_DrawFogColumn_8(void);
void R_DrawColumnShadowed_8(void);
#define PLANELIGHTFLOAT (BASEVIDWIDTH * BASEVIDWIDTH / vid.width / zeroheight / 21.0f * FIXED_TO_FLOAT(fovtan))
void R_DrawSpan_8(void);
void R_DrawTranslucentSpan_8(void);
void R_DrawTiltedSpan_8(void);

160
src/r_draw8.c
View file

@ -676,12 +676,11 @@ void R_DrawTiltedSpan_8(void)
double endz, endu, endv;
UINT32 stepu, stepv;
iz = ds_szp->z + ds_szp->y*(centery-ds_y) + ds_szp->x*(ds_x1-centerx);
iz = ds_sz.z + ds_sz.y*(centery-ds_y) + ds_sz.x*(ds_x1-centerx);
uz = ds_su.z + ds_su.y*(centery-ds_y) + ds_su.x*(ds_x1-centerx);
vz = ds_sv.z + ds_sv.y*(centery-ds_y) + ds_sv.x*(ds_x1-centerx);
CALC_SLOPE_LIGHT
uz = ds_sup->z + ds_sup->y*(centery-ds_y) + ds_sup->x*(ds_x1-centerx);
vz = ds_svp->z + ds_svp->y*(centery-ds_y) + ds_svp->x*(ds_x1-centerx);
R_CalcSlopeLight();
dest = ylookup[ds_y] + columnofs[ds_x1];
source = ds_source;
@ -700,18 +699,18 @@ void R_DrawTiltedSpan_8(void)
*dest = colormap[source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)]];
dest++;
iz += ds_szp->x;
uz += ds_sup->x;
vz += ds_svp->x;
iz += ds_sz.x;
uz += ds_su.x;
vz += ds_sv.x;
} while (--width >= 0);
#else
startz = 1.f/iz;
startu = uz*startz;
startv = vz*startz;
izstep = ds_szp->x * SPANSIZE;
uzstep = ds_sup->x * SPANSIZE;
vzstep = ds_svp->x * SPANSIZE;
izstep = ds_sz.x * SPANSIZE;
uzstep = ds_su.x * SPANSIZE;
vzstep = ds_sv.x * SPANSIZE;
//x1 = 0;
width++;
@ -753,9 +752,9 @@ void R_DrawTiltedSpan_8(void)
else
{
double left = width;
iz += ds_szp->x * left;
uz += ds_sup->x * left;
vz += ds_svp->x * left;
iz += ds_sz.x * left;
uz += ds_su.x * left;
vz += ds_sv.x * left;
endz = 1.f/iz;
endu = uz*endz;
@ -799,12 +798,11 @@ void R_DrawTiltedTranslucentSpan_8(void)
double endz, endu, endv;
UINT32 stepu, stepv;
iz = ds_szp->z + ds_szp->y*(centery-ds_y) + ds_szp->x*(ds_x1-centerx);
iz = ds_sz.z + ds_sz.y*(centery-ds_y) + ds_sz.x*(ds_x1-centerx);
uz = ds_su.z + ds_su.y*(centery-ds_y) + ds_su.x*(ds_x1-centerx);
vz = ds_sv.z + ds_sv.y*(centery-ds_y) + ds_sv.x*(ds_x1-centerx);
CALC_SLOPE_LIGHT
uz = ds_sup->z + ds_sup->y*(centery-ds_y) + ds_sup->x*(ds_x1-centerx);
vz = ds_svp->z + ds_svp->y*(centery-ds_y) + ds_svp->x*(ds_x1-centerx);
R_CalcSlopeLight();
dest = ylookup[ds_y] + columnofs[ds_x1];
source = ds_source;
@ -822,18 +820,18 @@ void R_DrawTiltedTranslucentSpan_8(void)
colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
*dest = *(ds_transmap + (colormap[source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)]] << 8) + *dest);
dest++;
iz += ds_szp->x;
uz += ds_sup->x;
vz += ds_svp->x;
iz += ds_sz.x;
uz += ds_su.x;
vz += ds_sv.x;
} while (--width >= 0);
#else
startz = 1.f/iz;
startu = uz*startz;
startv = vz*startz;
izstep = ds_szp->x * SPANSIZE;
uzstep = ds_sup->x * SPANSIZE;
vzstep = ds_svp->x * SPANSIZE;
izstep = ds_sz.x * SPANSIZE;
uzstep = ds_su.x * SPANSIZE;
vzstep = ds_sv.x * SPANSIZE;
//x1 = 0;
width++;
@ -875,9 +873,9 @@ void R_DrawTiltedTranslucentSpan_8(void)
else
{
double left = width;
iz += ds_szp->x * left;
uz += ds_sup->x * left;
vz += ds_svp->x * left;
iz += ds_sz.x * left;
uz += ds_su.x * left;
vz += ds_sv.x * left;
endz = 1.f/iz;
endu = uz*endz;
@ -922,12 +920,11 @@ void R_DrawTiltedWaterSpan_8(void)
double endz, endu, endv;
UINT32 stepu, stepv;
iz = ds_szp->z + ds_szp->y*(centery-ds_y) + ds_szp->x*(ds_x1-centerx);
iz = ds_sz.z + ds_sz.y*(centery-ds_y) + ds_sz.x*(ds_x1-centerx);
uz = ds_su.z + ds_su.y*(centery-ds_y) + ds_su.x*(ds_x1-centerx);
vz = ds_sv.z + ds_sv.y*(centery-ds_y) + ds_sv.x*(ds_x1-centerx);
CALC_SLOPE_LIGHT
uz = ds_sup->z + ds_sup->y*(centery-ds_y) + ds_sup->x*(ds_x1-centerx);
vz = ds_svp->z + ds_svp->y*(centery-ds_y) + ds_svp->x*(ds_x1-centerx);
R_CalcSlopeLight();
dest = ylookup[ds_y] + columnofs[ds_x1];
dsrc = screens[1] + (ds_y+ds_bgofs)*vid.width + ds_x1;
@ -946,18 +943,18 @@ void R_DrawTiltedWaterSpan_8(void)
colormap = planezlight[tiltlighting[ds_x1++]] + (ds_colormap - colormaps);
*dest = *(ds_transmap + (colormap[source[((v >> nflatyshift) & nflatmask) | (u >> nflatxshift)]] << 8) + *dsrc++);
dest++;
iz += ds_szp->x;
uz += ds_sup->x;
vz += ds_svp->x;
iz += ds_sz.x;
uz += ds_su.x;
vz += ds_sv.x;
} while (--width >= 0);
#else
startz = 1.f/iz;
startu = uz*startz;
startv = vz*startz;
izstep = ds_szp->x * SPANSIZE;
uzstep = ds_sup->x * SPANSIZE;
vzstep = ds_svp->x * SPANSIZE;
izstep = ds_sz.x * SPANSIZE;
uzstep = ds_su.x * SPANSIZE;
vzstep = ds_sv.x * SPANSIZE;
//x1 = 0;
width++;
@ -999,9 +996,9 @@ void R_DrawTiltedWaterSpan_8(void)
else
{
double left = width;
iz += ds_szp->x * left;
uz += ds_sup->x * left;
vz += ds_svp->x * left;
iz += ds_sz.x * left;
uz += ds_su.x * left;
vz += ds_sv.x * left;
endz = 1.f/iz;
endu = uz*endz;
@ -1044,12 +1041,11 @@ void R_DrawTiltedSplat_8(void)
double endz, endu, endv;
UINT32 stepu, stepv;
iz = ds_szp->z + ds_szp->y*(centery-ds_y) + ds_szp->x*(ds_x1-centerx);
iz = ds_sz.z + ds_sz.y*(centery-ds_y) + ds_sz.x*(ds_x1-centerx);
uz = ds_su.z + ds_su.y*(centery-ds_y) + ds_su.x*(ds_x1-centerx);
vz = ds_sv.z + ds_sv.y*(centery-ds_y) + ds_sv.x*(ds_x1-centerx);
CALC_SLOPE_LIGHT
uz = ds_sup->z + ds_sup->y*(centery-ds_y) + ds_sup->x*(ds_x1-centerx);
vz = ds_svp->z + ds_svp->y*(centery-ds_y) + ds_svp->x*(ds_x1-centerx);
R_CalcSlopeLight();
dest = ylookup[ds_y] + columnofs[ds_x1];
source = ds_source;
@ -1071,18 +1067,18 @@ void R_DrawTiltedSplat_8(void)
*dest = colormap[val];
dest++;
iz += ds_szp->x;
uz += ds_sup->x;
vz += ds_svp->x;
iz += ds_sz.x;
uz += ds_su.x;
vz += ds_sv.x;
} while (--width >= 0);
#else
startz = 1.f/iz;
startu = uz*startz;
startv = vz*startz;
izstep = ds_szp->x * SPANSIZE;
uzstep = ds_sup->x * SPANSIZE;
vzstep = ds_svp->x * SPANSIZE;
izstep = ds_sz.x * SPANSIZE;
uzstep = ds_su.x * SPANSIZE;
vzstep = ds_sv.x * SPANSIZE;
//x1 = 0;
width++;
@ -1128,9 +1124,9 @@ void R_DrawTiltedSplat_8(void)
else
{
double left = width;
iz += ds_szp->x * left;
uz += ds_sup->x * left;
vz += ds_svp->x * left;
iz += ds_sz.x * left;
uz += ds_su.x * left;
vz += ds_sv.x * left;
endz = 1.f/iz;
endu = uz*endz;
@ -1613,9 +1609,9 @@ void R_DrawTiltedFloorSprite_8(void)
double endz, endu, endv;
UINT32 stepu, stepv;
iz = ds_szp->z + ds_szp->y*(centery-ds_y) + ds_szp->x*(ds_x1-centerx);
uz = ds_sup->z + ds_sup->y*(centery-ds_y) + ds_sup->x*(ds_x1-centerx);
vz = ds_svp->z + ds_svp->y*(centery-ds_y) + ds_svp->x*(ds_x1-centerx);
iz = ds_sz.z + ds_sz.y*(centery-ds_y) + ds_sz.x*(ds_x1-centerx);
uz = ds_su.z + ds_su.y*(centery-ds_y) + ds_su.x*(ds_x1-centerx);
vz = ds_sv.z + ds_sv.y*(centery-ds_y) + ds_sv.x*(ds_x1-centerx);
dest = ylookup[ds_y] + columnofs[ds_x1];
source = (UINT16 *)ds_source;
@ -1626,9 +1622,9 @@ void R_DrawTiltedFloorSprite_8(void)
startu = uz*startz;
startv = vz*startz;
izstep = ds_szp->x * SPANSIZE;
uzstep = ds_sup->x * SPANSIZE;
vzstep = ds_svp->x * SPANSIZE;
izstep = ds_sz.x * SPANSIZE;
uzstep = ds_su.x * SPANSIZE;
vzstep = ds_sv.x * SPANSIZE;
//x1 = 0;
width++;
@ -1673,9 +1669,9 @@ void R_DrawTiltedFloorSprite_8(void)
else
{
double left = width;
iz += ds_szp->x * left;
uz += ds_sup->x * left;
vz += ds_svp->x * left;
iz += ds_sz.x * left;
uz += ds_su.x * left;
vz += ds_sv.x * left;
endz = 1.f/iz;
endu = uz*endz;
@ -1722,9 +1718,9 @@ void R_DrawTiltedTranslucentFloorSprite_8(void)
double endz, endu, endv;
UINT32 stepu, stepv;
iz = ds_szp->z + ds_szp->y*(centery-ds_y) + ds_szp->x*(ds_x1-centerx);
uz = ds_sup->z + ds_sup->y*(centery-ds_y) + ds_sup->x*(ds_x1-centerx);
vz = ds_svp->z + ds_svp->y*(centery-ds_y) + ds_svp->x*(ds_x1-centerx);
iz = ds_sz.z + ds_sz.y*(centery-ds_y) + ds_sz.x*(ds_x1-centerx);
uz = ds_su.z + ds_su.y*(centery-ds_y) + ds_su.x*(ds_x1-centerx);
vz = ds_sv.z + ds_sv.y*(centery-ds_y) + ds_sv.x*(ds_x1-centerx);
dest = ylookup[ds_y] + columnofs[ds_x1];
source = (UINT16 *)ds_source;
@ -1735,9 +1731,9 @@ void R_DrawTiltedTranslucentFloorSprite_8(void)
startu = uz*startz;
startv = vz*startz;
izstep = ds_szp->x * SPANSIZE;
uzstep = ds_sup->x * SPANSIZE;
vzstep = ds_svp->x * SPANSIZE;
izstep = ds_sz.x * SPANSIZE;
uzstep = ds_su.x * SPANSIZE;
vzstep = ds_sv.x * SPANSIZE;
//x1 = 0;
width++;
@ -1782,9 +1778,9 @@ void R_DrawTiltedTranslucentFloorSprite_8(void)
else
{
double left = width;
iz += ds_szp->x * left;
uz += ds_sup->x * left;
vz += ds_svp->x * left;
iz += ds_sz.x * left;
uz += ds_su.x * left;
vz += ds_sv.x * left;
endz = 1.f/iz;
endu = uz*endz;
@ -2013,9 +2009,7 @@ void R_DrawTiltedFogSpan_8(void)
UINT8 *dest = ylookup[ds_y] + columnofs[ds_x1];
double iz = ds_szp->z + ds_szp->y*(centery-ds_y) + ds_szp->x*(ds_x1-centerx);
CALC_SLOPE_LIGHT
R_CalcSlopeLight();
do
{
@ -2067,9 +2061,7 @@ void R_DrawTiltedSolidColorSpan_8(void)
UINT8 source = ds_source[0];
UINT8 *dest = ylookup[ds_y] + columnofs[ds_x1];
double iz = ds_szp->z + ds_szp->y*(centery-ds_y) + ds_szp->x*(ds_x1-centerx);
CALC_SLOPE_LIGHT
R_CalcSlopeLight();
do
{
@ -2088,9 +2080,7 @@ void R_DrawTiltedTransSolidColorSpan_8(void)
UINT8 source = ds_source[0];
UINT8 *dest = ylookup[ds_y] + columnofs[ds_x1];
double iz = ds_szp->z + ds_szp->y*(centery-ds_y) + ds_szp->x*(ds_x1-centerx);
CALC_SLOPE_LIGHT
R_CalcSlopeLight();
do
{
@ -2131,9 +2121,7 @@ void R_DrawTiltedWaterSolidColorSpan_8(void)
UINT8 *dest = ylookup[ds_y] + columnofs[ds_x1];
UINT8 *dsrc = screens[1] + (ds_y+ds_bgofs)*vid.width + ds_x1;
double iz = ds_szp->z + ds_szp->y*(centery-ds_y) + ds_szp->x*(ds_x1-centerx);
CALC_SLOPE_LIGHT
R_CalcSlopeLight();
do
{

144
src/r_draw8_npo2.c
View file

@ -114,12 +114,11 @@ void R_DrawTiltedSpan_NPO2_8(void)
struct libdivide_u32_t x_divider = libdivide_u32_gen(ds_flatwidth);
struct libdivide_u32_t y_divider = libdivide_u32_gen(ds_flatheight);
iz = ds_szp->z + ds_szp->y*(centery-ds_y) + ds_szp->x*(ds_x1-centerx);
iz = ds_sz.z + ds_sz.y*(centery-ds_y) + ds_sz.x*(ds_x1-centerx);
uz = ds_su.z + ds_su.y*(centery-ds_y) + ds_su.x*(ds_x1-centerx);
vz = ds_sv.z + ds_sv.y*(centery-ds_y) + ds_sv.x*(ds_x1-centerx);
CALC_SLOPE_LIGHT
uz = ds_sup->z + ds_sup->y*(centery-ds_y) + ds_sup->x*(ds_x1-centerx);
vz = ds_svp->z + ds_svp->y*(centery-ds_y) + ds_svp->x*(ds_x1-centerx);
R_CalcSlopeLight();
dest = ylookup[ds_y] + columnofs[ds_x1];
source = ds_source;
@ -154,18 +153,18 @@ void R_DrawTiltedSpan_NPO2_8(void)
*dest = colormap[source[((y * ds_flatwidth) + x)]];
}
dest++;
iz += ds_szp->x;
uz += ds_sup->x;
vz += ds_svp->x;
iz += ds_sz.x;
uz += ds_su.x;
vz += ds_sv.x;
} while (--width >= 0);
#else
startz = 1.f/iz;
startu = uz*startz;
startv = vz*startz;
izstep = ds_szp->x * SPANSIZE;
uzstep = ds_sup->x * SPANSIZE;
vzstep = ds_svp->x * SPANSIZE;
izstep = ds_sz.x * SPANSIZE;
uzstep = ds_su.x * SPANSIZE;
vzstep = ds_sv.x * SPANSIZE;
//x1 = 0;
width++;
@ -239,9 +238,9 @@ void R_DrawTiltedSpan_NPO2_8(void)
else
{
double left = width;
iz += ds_szp->x * left;
uz += ds_sup->x * left;
vz += ds_svp->x * left;
iz += ds_sz.x * left;
uz += ds_su.x * left;
vz += ds_sv.x * left;
endz = 1.f/iz;
endu = uz*endz;
@ -304,12 +303,11 @@ void R_DrawTiltedTranslucentSpan_NPO2_8(void)
struct libdivide_u32_t x_divider = libdivide_u32_gen(ds_flatwidth);
struct libdivide_u32_t y_divider = libdivide_u32_gen(ds_flatheight);
iz = ds_szp->z + ds_szp->y*(centery-ds_y) + ds_szp->x*(ds_x1-centerx);
iz = ds_sz.z + ds_sz.y*(centery-ds_y) + ds_sz.x*(ds_x1-centerx);
uz = ds_su.z + ds_su.y*(centery-ds_y) + ds_su.x*(ds_x1-centerx);
vz = ds_sv.z + ds_sv.y*(centery-ds_y) + ds_sv.x*(ds_x1-centerx);
CALC_SLOPE_LIGHT
uz = ds_sup->z + ds_sup->y*(centery-ds_y) + ds_sup->x*(ds_x1-centerx);
vz = ds_svp->z + ds_svp->y*(centery-ds_y) + ds_svp->x*(ds_x1-centerx);
R_CalcSlopeLight();
dest = ylookup[ds_y] + columnofs[ds_x1];
source = ds_source;
@ -343,18 +341,18 @@ void R_DrawTiltedTranslucentSpan_NPO2_8(void)
*dest = *(ds_transmap + (colormap[source[((y * ds_flatwidth) + x)]] << 8) + *dest);
}
dest++;
iz += ds_szp->x;
uz += ds_sup->x;
vz += ds_svp->x;
iz += ds_sz.x;
uz += ds_su.x;
vz += ds_sv.x;
} while (--width >= 0);
#else
startz = 1.f/iz;
startu = uz*startz;
startv = vz*startz;
izstep = ds_szp->x * SPANSIZE;
uzstep = ds_sup->x * SPANSIZE;
vzstep = ds_svp->x * SPANSIZE;
izstep = ds_sz.x * SPANSIZE;
uzstep = ds_su.x * SPANSIZE;
vzstep = ds_sv.x * SPANSIZE;
//x1 = 0;
width++;
@ -428,9 +426,9 @@ void R_DrawTiltedTranslucentSpan_NPO2_8(void)
else
{
double left = width;
iz += ds_szp->x * left;
uz += ds_sup->x * left;
vz += ds_svp->x * left;
iz += ds_sz.x * left;
uz += ds_su.x * left;
vz += ds_sv.x * left;
endz = 1.f/iz;
endu = uz*endz;
@ -492,12 +490,11 @@ void R_DrawTiltedSplat_NPO2_8(void)
struct libdivide_u32_t x_divider = libdivide_u32_gen(ds_flatwidth);
struct libdivide_u32_t y_divider = libdivide_u32_gen(ds_flatheight);
iz = ds_szp->z + ds_szp->y*(centery-ds_y) + ds_szp->x*(ds_x1-centerx);
iz = ds_sz.z + ds_sz.y*(centery-ds_y) + ds_sz.x*(ds_x1-centerx);
uz = ds_su.z + ds_su.y*(centery-ds_y) + ds_su.x*(ds_x1-centerx);
vz = ds_sv.z + ds_sv.y*(centery-ds_y) + ds_sv.x*(ds_x1-centerx);
CALC_SLOPE_LIGHT
uz = ds_sup->z + ds_sup->y*(centery-ds_y) + ds_sup->x*(ds_x1-centerx);
vz = ds_svp->z + ds_svp->y*(centery-ds_y) + ds_svp->x*(ds_x1-centerx);
R_CalcSlopeLight();
dest = ylookup[ds_y] + columnofs[ds_x1];
source = ds_source;
@ -536,18 +533,18 @@ void R_DrawTiltedSplat_NPO2_8(void)
*dest = colormap[val];
dest++;
iz += ds_szp->x;
uz += ds_sup->x;
vz += ds_svp->x;
iz += ds_sz.x;
uz += ds_su.x;
vz += ds_sv.x;
} while (--width >= 0);
#else
startz = 1.f/iz;
startu = uz*startz;
startv = vz*startz;
izstep = ds_szp->x * SPANSIZE;
uzstep = ds_sup->x * SPANSIZE;
vzstep = ds_svp->x * SPANSIZE;
izstep = ds_sz.x * SPANSIZE;
uzstep = ds_su.x * SPANSIZE;
vzstep = ds_sv.x * SPANSIZE;
//x1 = 0;
width++;
@ -625,9 +622,9 @@ void R_DrawTiltedSplat_NPO2_8(void)
else
{
double left = width;
iz += ds_szp->x * left;
uz += ds_sup->x * left;
vz += ds_svp->x * left;
iz += ds_sz.x * left;
uz += ds_su.x * left;
vz += ds_sv.x * left;
endz = 1.f/iz;
endu = uz*endz;
@ -970,9 +967,9 @@ void R_DrawTiltedFloorSprite_NPO2_8(void)
struct libdivide_u32_t x_divider = libdivide_u32_gen(ds_flatwidth);
struct libdivide_u32_t y_divider = libdivide_u32_gen(ds_flatheight);
iz = ds_szp->z + ds_szp->y*(centery-ds_y) + ds_szp->x*(ds_x1-centerx);
uz = ds_sup->z + ds_sup->y*(centery-ds_y) + ds_sup->x*(ds_x1-centerx);
vz = ds_svp->z + ds_svp->y*(centery-ds_y) + ds_svp->x*(ds_x1-centerx);
iz = ds_sz.z + ds_sz.y*(centery-ds_y) + ds_sz.x*(ds_x1-centerx);
uz = ds_su.z + ds_su.y*(centery-ds_y) + ds_su.x*(ds_x1-centerx);
vz = ds_sv.z + ds_sv.y*(centery-ds_y) + ds_sv.x*(ds_x1-centerx);
dest = ylookup[ds_y] + columnofs[ds_x1];
source = (UINT16 *)ds_source;
@ -983,9 +980,9 @@ void R_DrawTiltedFloorSprite_NPO2_8(void)
startu = uz*startz;
startv = vz*startz;
izstep = ds_szp->x * SPANSIZE;
uzstep = ds_sup->x * SPANSIZE;
vzstep = ds_svp->x * SPANSIZE;
izstep = ds_sz.x * SPANSIZE;
uzstep = ds_su.x * SPANSIZE;
vzstep = ds_sv.x * SPANSIZE;
//x1 = 0;
width++;
@ -1060,9 +1057,9 @@ void R_DrawTiltedFloorSprite_NPO2_8(void)
else
{
double left = width;
iz += ds_szp->x * left;
uz += ds_sup->x * left;
vz += ds_svp->x * left;
iz += ds_sz.x * left;
uz += ds_su.x * left;
vz += ds_sv.x * left;
endz = 1.f/iz;
endu = uz*endz;
@ -1126,9 +1123,9 @@ void R_DrawTiltedTranslucentFloorSprite_NPO2_8(void)
struct libdivide_u32_t x_divider = libdivide_u32_gen(ds_flatwidth);
struct libdivide_u32_t y_divider = libdivide_u32_gen(ds_flatheight);
iz = ds_szp->z + ds_szp->y*(centery-ds_y) + ds_szp->x*(ds_x1-centerx);
uz = ds_sup->z + ds_sup->y*(centery-ds_y) + ds_sup->x*(ds_x1-centerx);
vz = ds_svp->z + ds_svp->y*(centery-ds_y) + ds_svp->x*(ds_x1-centerx);
iz = ds_sz.z + ds_sz.y*(centery-ds_y) + ds_sz.x*(ds_x1-centerx);
uz = ds_su.z + ds_su.y*(centery-ds_y) + ds_su.x*(ds_x1-centerx);
vz = ds_sv.z + ds_sv.y*(centery-ds_y) + ds_sv.x*(ds_x1-centerx);
dest = ylookup[ds_y] + columnofs[ds_x1];
source = (UINT16 *)ds_source;
@ -1139,9 +1136,9 @@ void R_DrawTiltedTranslucentFloorSprite_NPO2_8(void)
startu = uz*startz;
startv = vz*startz;
izstep = ds_szp->x * SPANSIZE;
uzstep = ds_sup->x * SPANSIZE;
vzstep = ds_svp->x * SPANSIZE;
izstep = ds_sz.x * SPANSIZE;
uzstep = ds_su.x * SPANSIZE;
vzstep = ds_sv.x * SPANSIZE;
//x1 = 0;
width++;
@ -1216,9 +1213,9 @@ void R_DrawTiltedTranslucentFloorSprite_NPO2_8(void)
else
{
double left = width;
iz += ds_szp->x * left;
uz += ds_sup->x * left;
vz += ds_svp->x * left;
iz += ds_sz.x * left;
uz += ds_su.x * left;
vz += ds_sv.x * left;
endz = 1.f/iz;
endu = uz*endz;
@ -1411,12 +1408,11 @@ void R_DrawTiltedWaterSpan_NPO2_8(void)
struct libdivide_u32_t x_divider = libdivide_u32_gen(ds_flatwidth);
struct libdivide_u32_t y_divider = libdivide_u32_gen(ds_flatheight);
iz = ds_szp->z + ds_szp->y*(centery-ds_y) + ds_szp->x*(ds_x1-centerx);
iz = ds_sz.z + ds_sz.y*(centery-ds_y) + ds_sz.x*(ds_x1-centerx);
uz = ds_su.z + ds_su.y*(centery-ds_y) + ds_su.x*(ds_x1-centerx);
vz = ds_sv.z + ds_sv.y*(centery-ds_y) + ds_sv.x*(ds_x1-centerx);
CALC_SLOPE_LIGHT
uz = ds_sup->z + ds_sup->y*(centery-ds_y) + ds_sup->x*(ds_x1-centerx);
vz = ds_svp->z + ds_svp->y*(centery-ds_y) + ds_svp->x*(ds_x1-centerx);
R_CalcSlopeLight();
dest = ylookup[ds_y] + columnofs[ds_x1];
dsrc = screens[1] + (ds_y+ds_bgofs)*vid.width + ds_x1;
@ -1451,18 +1447,18 @@ void R_DrawTiltedWaterSpan_NPO2_8(void)
*dest = *(ds_transmap + (colormap[source[((y * ds_flatwidth) + x)]] << 8) + *dsrc++);
}
dest++;
iz += ds_szp->x;
uz += ds_sup->x;
vz += ds_svp->x;
iz += ds_sz.x;
uz += ds_su.x;
vz += ds_sv.x;
} while (--width >= 0);
#else
startz = 1.f/iz;
startu = uz*startz;
startv = vz*startz;
izstep = ds_szp->x * SPANSIZE;
uzstep = ds_sup->x * SPANSIZE;
vzstep = ds_svp->x * SPANSIZE;
izstep = ds_sz.x * SPANSIZE;
uzstep = ds_su.x * SPANSIZE;
vzstep = ds_sv.x * SPANSIZE;
//x1 = 0;
width++;
@ -1536,9 +1532,9 @@ void R_DrawTiltedWaterSpan_NPO2_8(void)
else
{
double left = width;
iz += ds_szp->x * left;
uz += ds_sup->x * left;
vz += ds_svp->x * left;
iz += ds_sz.x * left;
uz += ds_su.x * left;
vz += ds_sv.x * left;
endz = 1.f/iz;
endu = uz*endz;

43
src/r_main.c
View file

@ -356,7 +356,7 @@ angle_t R_PointToAngle2(fixed_t pviewx, fixed_t pviewy, fixed_t x, fixed_t y)
fixed_t R_PointToDist2(fixed_t px2, fixed_t py2, fixed_t px1, fixed_t py1)
{
angle_t angle;
fixed_t dx, dy, dist;
ufixed_t dx, dy, dist;
dx = abs(px1 - px2);
dy = abs(py1 - py2);
@ -957,16 +957,6 @@ void R_ExecuteSetViewSize(void)
dy = FixedMul(abs(dy), fovtan);
yslopetab[i] = FixedDiv(centerx*FRACUNIT, dy);
}
if (ds_su)
Z_Free(ds_su);
if (ds_sv)
Z_Free(ds_sv);
if (ds_sz)
Z_Free(ds_sz);
ds_su = ds_sv = ds_sz = NULL;
ds_sup = ds_svp = ds_szp = NULL;
}
memset(scalelight, 0xFF, sizeof(scalelight));
@ -1012,9 +1002,6 @@ void R_Init(void)
R_InitViewBorder();
R_SetViewSize(); // setsizeneeded is set true
//I_OutputMsg("\nR_InitPlanes");
R_InitPlanes();
// this is now done by SCR_Recalc() at the first mode set
//I_OutputMsg("\nR_InitLightTables");
R_InitLightTables();
@ -1027,6 +1014,34 @@ void R_Init(void)
framecount = 0;
}
//
// R_IsPointInSector
//
boolean R_IsPointInSector(sector_t *sector, fixed_t x, fixed_t y)
{
size_t i;
line_t *closest = NULL;
fixed_t closestdist = INT32_MAX;
for (i = 0; i < sector->linecount; i++)
{
vertex_t v;
fixed_t dist;
// find the line closest to the point we're looking for.
P_ClosestPointOnLine(x, y, sector->lines[i], &v);
dist = R_PointToDist2(0, 0, v.x - x, v.y - y);
if (dist < closestdist)
{
closest = sector->lines[i];
closestdist = dist;
}
}
// if the side of the closest line is in this sector, we're inside of it.
return P_PointOnLineSide(x, y, closest) == 0 ? closest->frontsector == sector : closest->backsector == sector;
}
//
// R_PointInSubsector
//

1
src/r_main.h
View file

@ -79,6 +79,7 @@ fixed_t R_PointToDist(fixed_t x, fixed_t y);
fixed_t R_PointToDist2(fixed_t px2, fixed_t py2, fixed_t px1, fixed_t py1);
fixed_t R_ScaleFromGlobalAngle(angle_t visangle);
boolean R_IsPointInSector(sector_t *sector, fixed_t x, fixed_t y);
subsector_t *R_PointInSubsector(fixed_t x, fixed_t y);
subsector_t *R_PointInSubsectorOrNull(fixed_t x, fixed_t y);

294
src/r_plane.c
View file

@ -83,22 +83,15 @@ static fixed_t planeheight;
fixed_t yslopetab[MAXVIDHEIGHT*16];
fixed_t *yslope;
fixed_t cachedheight[MAXVIDHEIGHT];
fixed_t cacheddistance[MAXVIDHEIGHT];
fixed_t cachedxstep[MAXVIDHEIGHT];
fixed_t cachedystep[MAXVIDHEIGHT];
static fixed_t xoffs, yoffs;
static floatv3_t ds_slope_origin, ds_slope_u, ds_slope_v;
static floatv3_t slope_origin, slope_u, slope_v;
static floatv3_t slope_lightu, slope_lightv;
//
// R_InitPlanes
// Only at game startup.
//
void R_InitPlanes(void)
{
// FIXME: unused
}
static void CalcSlopePlaneVectors(visplane_t *pl, fixed_t xoff, fixed_t yoff);
static void CalcSlopeLightVectors(pslope_t *slope, fixed_t xpos, fixed_t ypos, fixed_t height, float ang, angle_t plangle);
static void DoSlopeCrossProducts(void);
static void DoSlopeLightCrossProduct(void);
//
// Water ripple effect
@ -159,37 +152,28 @@ static void R_MapPlane(INT32 y, INT32 x1, INT32 x2)
planecos = FINECOSINE(angle);
planesin = FINESINE(angle);
if (planeheight != cachedheight[y])
// [RH] Notice that I dumped the caching scheme used by Doom.
// It did not offer any appreciable speedup.
distance = FixedMul(planeheight, yslope[y]);
span = abs(centery - y);
if (span) // Don't divide by zero
{
cachedheight[y] = planeheight;
cacheddistance[y] = distance = FixedMul(planeheight, yslope[y]);
span = abs(centery - y);
if (span) // Don't divide by zero
{
ds_xstep = FixedMul(planesin, planeheight) / span;
ds_ystep = FixedMul(planecos, planeheight) / span;
}
else
ds_xstep = ds_ystep = FRACUNIT;
cachedxstep[y] = ds_xstep;
cachedystep[y] = ds_ystep;
ds_xstep = FixedMul(planesin, planeheight) / span;
ds_ystep = FixedMul(planecos, planeheight) / span;
ds_xstep = FixedMul(currentplane->xscale, ds_xstep);
ds_ystep = FixedMul(currentplane->yscale, ds_ystep);
}
else
{
distance = cacheddistance[y];
ds_xstep = cachedxstep[y];
ds_ystep = cachedystep[y];
}
ds_xstep = ds_ystep = FRACUNIT;
// [RH] Instead of using the xtoviewangle array, I calculated the fractional values
// at the middle of the screen, then used the calculated ds_xstep and ds_ystep
// to step from those to the proper texture coordinate to start drawing at.
// That way, the texture coordinate is always calculated by its position
// on the screen and not by its position relative to the edge of the visplane.
ds_xfrac = xoffs + FixedMul(planecos, distance) + (x1 - centerx) * ds_xstep;
ds_yfrac = yoffs - FixedMul(planesin, distance) + (x1 - centerx) * ds_ystep;
ds_xfrac = xoffs + FixedMul(currentplane->xscale, FixedMul(planecos, distance)) + (x1 - centerx) * ds_xstep;
ds_yfrac = yoffs - FixedMul(currentplane->yscale, FixedMul(planesin, distance)) + (x1 - centerx) * ds_ystep;
// Water ripple effect
if (planeripple.active)
@ -238,9 +222,9 @@ static void R_MapTiltedPlane(INT32 y, INT32 x1, INT32 x2)
{
ds_bgofs = R_CalculateRippleOffset(y);
ds_sup = &ds_su[y];
ds_svp = &ds_sv[y];
ds_szp = &ds_sz[y];
R_CalculatePlaneRipple(currentplane->viewangle + currentplane->plangle);
CalcSlopePlaneVectors(currentplane, (xoffs + planeripple.xfrac), (yoffs + planeripple.yfrac));
ds_bgofs >>= FRACBITS;
@ -275,10 +259,7 @@ static void R_MapFogPlane(INT32 y, INT32 x1, INT32 x2)
if (x1 >= vid.width)
x1 = vid.width - 1;
if (planeheight != cachedheight[y])
distance = FixedMul(planeheight, yslope[y]);
else
distance = cacheddistance[y];
distance = FixedMul(planeheight, yslope[y]);
pindex = distance >> LIGHTZSHIFT;
if (pindex >= MAXLIGHTZ)
@ -361,9 +342,6 @@ void R_ClearPlanes(void)
{
freehead = &(*freehead)->next;
}
// texture calculation
memset(cachedheight, 0, sizeof (cachedheight));
}
static visplane_t *new_visplane(unsigned hash)
@ -391,7 +369,8 @@ static visplane_t *new_visplane(unsigned hash)
// If not, allocates another of them.
//
visplane_t *R_FindPlane(fixed_t height, INT32 picnum, INT32 lightlevel,
fixed_t xoff, fixed_t yoff, angle_t plangle, extracolormap_t *planecolormap,
fixed_t xoff, fixed_t yoff, fixed_t xscale, fixed_t yscale,
angle_t plangle, extracolormap_t *planecolormap,
ffloor_t *pfloor, polyobj_t *polyobj, pslope_t *slope)
{
visplane_t *check;
@ -399,8 +378,9 @@ visplane_t *R_FindPlane(fixed_t height, INT32 picnum, INT32 lightlevel,
if (!slope) // Don't mess with this right now if a slope is involved
{
xoff += viewx;
yoff -= viewy;
xoff += FixedMul(viewx, xscale);
yoff -= FixedMul(viewy, yscale);
if (plangle != 0)
{
// Add the view offset, rotated by the plane angle.
@ -441,16 +421,16 @@ visplane_t *R_FindPlane(fixed_t height, INT32 picnum, INT32 lightlevel,
hash = visplane_hash(picnum, lightlevel, height);
for (check = visplanes[hash]; check; check = check->next)
{
if (polyobj != check->polyobj)
continue;
if (height == check->height && picnum == check->picnum
&& lightlevel == check->lightlevel
&& xoff == check->xoffs && yoff == check->yoffs
&& xscale == check->xscale && yscale == check->yscale
&& planecolormap == check->extra_colormap
&& check->viewx == viewx && check->viewy == viewy && check->viewz == viewz
&& check->viewangle == viewangle
&& check->plangle == plangle
&& check->slope == slope)
&& check->slope == slope
&& check->polyobj == polyobj)
{
return check;
}
@ -470,6 +450,8 @@ visplane_t *R_FindPlane(fixed_t height, INT32 picnum, INT32 lightlevel,
check->maxx = -1;
check->xoffs = xoff;
check->yoffs = yoff;
check->xscale = xscale;
check->yscale = yscale;
check->extra_colormap = planecolormap;
check->ffloor = pfloor;
check->viewx = viewx;
@ -546,6 +528,8 @@ visplane_t *R_CheckPlane(visplane_t *pl, INT32 start, INT32 stop)
new_pl->lightlevel = pl->lightlevel;
new_pl->xoffs = pl->xoffs;
new_pl->yoffs = pl->yoffs;
new_pl->xscale = pl->xscale;
new_pl->yscale = pl->yscale;
new_pl->extra_colormap = pl->extra_colormap;
new_pl->ffloor = pl->ffloor;
new_pl->viewx = pl->viewx;
@ -686,8 +670,6 @@ static INT64 R_GetSlopeZAt(const pslope_t *slope, fixed_t x, fixed_t y)
// Sets the texture origin vector of the sloped plane.
static void R_SetSlopePlaneOrigin(pslope_t *slope, fixed_t xpos, fixed_t ypos, fixed_t zpos, fixed_t xoff, fixed_t yoff, fixed_t angle)
{
floatv3_t *p = &ds_slope_origin;
INT64 vx = (INT64)xpos + (INT64)xoff;
INT64 vy = (INT64)ypos - (INT64)yoff;
@ -695,125 +677,164 @@ static void R_SetSlopePlaneOrigin(pslope_t *slope, fixed_t xpos, fixed_t ypos, f
float vyf = vy / (float)FRACUNIT;
float ang = ANG2RAD(ANGLE_270 - angle);
// p is the texture origin in view space
// slope_origin is the texture origin in view space
// Don't add in the offsets at this stage, because doing so can result in
// errors if the flat is rotated.
p->x = vxf * cos(ang) - vyf * sin(ang);
p->z = vxf * sin(ang) + vyf * cos(ang);
p->y = (R_GetSlopeZAt(slope, -xoff, yoff) - zpos) / (float)FRACUNIT;
slope_origin.x = vxf * cos(ang) - vyf * sin(ang);
slope_origin.z = vxf * sin(ang) + vyf * cos(ang);
slope_origin.y = (R_GetSlopeZAt(slope, -xoff, yoff) - zpos) / (float)FRACUNIT;
}
// This function calculates all of the vectors necessary for drawing a sloped plane.
void R_SetSlopePlane(pslope_t *slope, fixed_t xpos, fixed_t ypos, fixed_t zpos, fixed_t xoff, fixed_t yoff, angle_t angle, angle_t plangle)
{
// Potentially override other stuff for now cus we're mean. :< But draw a slope plane!
// I copied ZDoom's code and adapted it to SRB2... -Red
floatv3_t *m = &ds_slope_v, *n = &ds_slope_u;
fixed_t height, temp;
fixed_t height, z_at_xy;
float ang;
R_SetSlopePlaneOrigin(slope, xpos, ypos, zpos, xoff, yoff, angle);
height = P_GetSlopeZAt(slope, xpos, ypos);
zeroheight = FixedToFloat(height - zpos);
// m is the v direction vector in view space
ang = ANG2RAD(ANGLE_180 - (angle + plangle));
m->x = cos(ang);
m->z = sin(ang);
// n is the u direction vector in view space
n->x = sin(ang);
n->z = -cos(ang);
CalcSlopeLightVectors(slope, xpos, ypos, height, ang, plangle);
if (ds_solidcolor || ds_fog)
{
DoSlopeLightCrossProduct();
return;
}
// slope_v is the v direction vector in view space
slope_v.x = cos(ang);
slope_v.z = sin(ang);
// slope_u is the u direction vector in view space
slope_u.x = sin(ang);
slope_u.z = -cos(ang);
plangle >>= ANGLETOFINESHIFT;
temp = P_GetSlopeZAt(slope, xpos + FINESINE(plangle), ypos + FINECOSINE(plangle));
m->y = FixedToFloat(temp - height);
temp = P_GetSlopeZAt(slope, xpos + FINECOSINE(plangle), ypos - FINESINE(plangle));
n->y = FixedToFloat(temp - height);
z_at_xy = P_GetSlopeZAt(slope, xpos + FINESINE(plangle), ypos + FINECOSINE(plangle));
slope_v.y = FixedToFloat(z_at_xy - height);
z_at_xy = P_GetSlopeZAt(slope, xpos + FINECOSINE(plangle), ypos - FINESINE(plangle));
slope_u.y = FixedToFloat(z_at_xy - height);
DoSlopeCrossProducts();
DoSlopeLightCrossProduct();
}
// This function calculates all of the vectors necessary for drawing a sloped and scaled plane.
void R_SetScaledSlopePlane(pslope_t *slope, fixed_t xpos, fixed_t ypos, fixed_t zpos, fixed_t xs, fixed_t ys, fixed_t xoff, fixed_t yoff, angle_t angle, angle_t plangle)
{
floatv3_t *m = &ds_slope_v, *n = &ds_slope_u;
fixed_t height, temp;
fixed_t height, z_at_xy;
float xscale = FixedToFloat(xs);
float yscale = FixedToFloat(ys);
float ang;
R_SetSlopePlaneOrigin(slope, xpos, ypos, zpos, xoff, yoff, angle);
height = P_GetSlopeZAt(slope, xpos, ypos);
zeroheight = FixedToFloat(height - zpos);
// m is the v direction vector in view space
ang = ANG2RAD(ANGLE_180 - (angle + plangle));
m->x = yscale * cos(ang);
m->z = yscale * sin(ang);
CalcSlopeLightVectors(slope, xpos, ypos, height, ang, plangle);
if (ds_solidcolor || ds_fog)
{
DoSlopeLightCrossProduct();
return;
}
float xscale = FixedToFloat(xs);
float yscale = FixedToFloat(ys);
// m is the v direction vector in view space
slope_v.x = yscale * cos(ang);
slope_v.z = yscale * sin(ang);
// n is the u direction vector in view space
n->x = xscale * sin(ang);
n->z = -xscale * cos(ang);
slope_u.x = xscale * sin(ang);
slope_u.z = -xscale * cos(ang);
ang = ANG2RAD(plangle);
temp = P_GetSlopeZAt(slope, xpos + FloatToFixed(yscale * sin(ang)), ypos + FloatToFixed(yscale * cos(ang)));
m->y = FixedToFloat(temp - height);
temp = P_GetSlopeZAt(slope, xpos + FloatToFixed(xscale * cos(ang)), ypos - FloatToFixed(xscale * sin(ang)));
n->y = FixedToFloat(temp - height);
z_at_xy = P_GetSlopeZAt(slope, xpos + FloatToFixed(yscale * sin(ang)), ypos + FloatToFixed(yscale * cos(ang)));
slope_v.y = FixedToFloat(z_at_xy - height);
z_at_xy = P_GetSlopeZAt(slope, xpos + FloatToFixed(xscale * cos(ang)), ypos - FloatToFixed(xscale * sin(ang)));
slope_u.y = FixedToFloat(z_at_xy - height);
DoSlopeCrossProducts();
DoSlopeLightCrossProduct();
}
void R_CalculateSlopeVectors(void)
static void CalcSlopeLightVectors(pslope_t *slope, fixed_t xpos, fixed_t ypos, fixed_t height, float ang, angle_t plangle)
{
fixed_t z_at_xy;
slope_lightv.x = cos(ang);
slope_lightv.z = sin(ang);
slope_lightu.x = sin(ang);
slope_lightu.z = -cos(ang);
plangle >>= ANGLETOFINESHIFT;
z_at_xy = P_GetSlopeZAt(slope, xpos + FINESINE(plangle), ypos + FINECOSINE(plangle));
slope_lightv.y = FixedToFloat(z_at_xy - height);
z_at_xy = P_GetSlopeZAt(slope, xpos + FINECOSINE(plangle), ypos - FINESINE(plangle));
slope_lightu.y = FixedToFloat(z_at_xy - height);
}
// Eh. I tried making this stuff fixed-point and it exploded on me. Here's a macro for the only floating-point vector function I recall using.
#define CROSS(d, v1, v2) \
d.x = (v1.y * v2.z) - (v1.z * v2.y);\
d.y = (v1.z * v2.x) - (v1.x * v2.z);\
d.z = (v1.x * v2.y) - (v1.y * v2.x)
static void DoSlopeCrossProducts(void)
{
float sfmult = 65536.f;
// Eh. I tried making this stuff fixed-point and it exploded on me. Here's a macro for the only floating-point vector function I recall using.
#define CROSS(d, v1, v2) \
d->x = (v1.y * v2.z) - (v1.z * v2.y);\
d->y = (v1.z * v2.x) - (v1.x * v2.z);\
d->z = (v1.x * v2.y) - (v1.y * v2.x)
CROSS(ds_sup, ds_slope_origin, ds_slope_v);
CROSS(ds_svp, ds_slope_origin, ds_slope_u);
CROSS(ds_szp, ds_slope_v, ds_slope_u);
#undef CROSS
CROSS(ds_su, slope_origin, slope_v);
CROSS(ds_sv, slope_origin, slope_u);
CROSS(ds_sz, slope_v, slope_u);
ds_sup->z *= focallengthf;
ds_svp->z *= focallengthf;
ds_szp->z *= focallengthf;
ds_su.z *= focallengthf;
ds_sv.z *= focallengthf;
ds_sz.z *= focallengthf;
if (ds_solidcolor)
return;
// Premultiply the texture vectors with the scale factors
if (ds_powersoftwo)
sfmult *= (1 << nflatshiftup);
sfmult *= 1 << nflatshiftup;
ds_sup->x *= sfmult;
ds_sup->y *= sfmult;
ds_sup->z *= sfmult;
ds_svp->x *= sfmult;
ds_svp->y *= sfmult;
ds_svp->z *= sfmult;
ds_su.x *= sfmult;
ds_su.y *= sfmult;
ds_su.z *= sfmult;
ds_sv.x *= sfmult;
ds_sv.y *= sfmult;
ds_sv.z *= sfmult;
}
void R_SetTiltedSpan(INT32 span)
static void DoSlopeLightCrossProduct(void)
{
if (ds_su == NULL)
ds_su = Z_Malloc(sizeof(*ds_su) * vid.height, PU_STATIC, NULL);
if (ds_sv == NULL)
ds_sv = Z_Malloc(sizeof(*ds_sv) * vid.height, PU_STATIC, NULL);
if (ds_sz == NULL)
ds_sz = Z_Malloc(sizeof(*ds_sz) * vid.height, PU_STATIC, NULL);
CROSS(ds_slopelight, slope_lightv, slope_lightu);
ds_sup = &ds_su[span];
ds_svp = &ds_sv[span];
ds_szp = &ds_sz[span];
ds_slopelight.z *= focallengthf;
}
static void R_SetSlopePlaneVectors(visplane_t *pl, INT32 y, fixed_t xoff, fixed_t yoff)
#undef CROSS
static void CalcSlopePlaneVectors(visplane_t *pl, fixed_t xoff, fixed_t yoff)
{
R_SetTiltedSpan(y);
R_SetSlopePlane(pl->slope, pl->viewx, pl->viewy, pl->viewz, xoff, yoff, pl->viewangle, pl->plangle);
R_CalculateSlopeVectors();
if (!ds_fog && (pl->xscale != FRACUNIT || pl->yscale != FRACUNIT))
{
R_SetScaledSlopePlane(pl->slope, pl->viewx, pl->viewy, pl->viewz,
FixedDiv(FRACUNIT, pl->xscale), FixedDiv(FRACUNIT, pl->yscale),
FixedDiv(xoff, pl->xscale), FixedDiv(yoff, pl->yscale), pl->viewangle, pl->plangle);
}
else
R_SetSlopePlane(pl->slope, pl->viewx, pl->viewy, pl->viewz, xoff, yoff, pl->viewangle, pl->plangle);
}
static inline void R_AdjustSlopeCoordinates(vector3_t *origin)
@ -850,7 +871,6 @@ void R_DrawSinglePlane(visplane_t *pl)
INT32 light = 0;
INT32 x, stop;
ffloor_t *rover;
boolean fog = false;
INT32 spanfunctype = BASEDRAWFUNC;
void (*mapfunc)(INT32, INT32, INT32);
@ -864,6 +884,8 @@ void R_DrawSinglePlane(visplane_t *pl)
return;
}
ds_powersoftwo = ds_solidcolor = ds_fog = false;
planeripple.active = false;
if (pl->polyobj)
@ -928,13 +950,13 @@ void R_DrawSinglePlane(visplane_t *pl)
}
else if (pl->ffloor->fofflags & FOF_FOG)
{
fog = true;
ds_fog = true;
spanfunctype = SPANDRAWFUNC_FOG;
light = (pl->lightlevel >> LIGHTSEGSHIFT);
}
else light = (pl->lightlevel >> LIGHTSEGSHIFT);
if (pl->ffloor->fofflags & FOF_RIPPLE && !fog)
if (pl->ffloor->fofflags & FOF_RIPPLE && !ds_fog)
{
planeripple.active = true;
@ -962,9 +984,7 @@ void R_DrawSinglePlane(visplane_t *pl)
light = (pl->lightlevel >> LIGHTSEGSHIFT);
}
ds_powersoftwo = ds_solidcolor = false;
if (fog)
if (ds_fog)
{
// Since all fog planes do is apply a colormap, it's not required
// to know any information about their textures.
@ -1000,13 +1020,6 @@ void R_DrawSinglePlane(visplane_t *pl)
}
}
// Don't mess with angle on slopes! We'll handle this ourselves later
if (!pl->slope && viewangle != pl->viewangle+pl->plangle)
{
memset(cachedheight, 0, sizeof (cachedheight));
viewangle = pl->viewangle+pl->plangle;
}
mapfunc = R_MapPlane;
if (ds_solidcolor)
@ -1037,13 +1050,13 @@ void R_DrawSinglePlane(visplane_t *pl)
if (pl->slope)
{
if (fog)
if (ds_fog)
mapfunc = R_MapTiltedFogPlane;
else
{
mapfunc = R_MapTiltedPlane;
if (!pl->plangle && !ds_solidcolor)
if (!pl->plangle && !ds_solidcolor && pl->xscale == FRACUNIT && pl->yscale == FRACUNIT)
{
if (ds_powersoftwo)
R_AdjustSlopeCoordinates(&pl->slope->o);
@ -1052,21 +1065,10 @@ void R_DrawSinglePlane(visplane_t *pl)
}
}
if (planeripple.active)
{
if (!ds_fog && planeripple.active)
planeheight = abs(P_GetSlopeZAt(pl->slope, pl->viewx, pl->viewy) - pl->viewz);
R_PlaneBounds(pl);
for (x = pl->high; x < pl->low; x++)
{
ds_bgofs = R_CalculateRippleOffset(x);
R_CalculatePlaneRipple(pl->viewangle + pl->plangle);
R_SetSlopePlaneVectors(pl, x, (xoffs + planeripple.xfrac), (yoffs + planeripple.yfrac));
}
}
else
R_SetSlopePlaneVectors(pl, 0, xoffs, yoffs);
CalcSlopePlaneVectors(pl, xoffs, yoffs);
switch (spanfunctype)
{

14
src/r_plane.h
View file

@ -49,6 +49,7 @@ typedef struct visplane_s
INT32 high, low; // R_PlaneBounds should set these.
fixed_t xoffs, yoffs; // Scrolling flats.
fixed_t xscale, yscale;
struct ffloor_s *ffloor;
polyobj_t *polyobj;
@ -62,21 +63,16 @@ extern visplane_t *ceilingplane;
// Visplane related.
extern INT16 floorclip[MAXVIDWIDTH], ceilingclip[MAXVIDWIDTH];
extern fixed_t frontscale[MAXVIDWIDTH], yslopetab[MAXVIDHEIGHT*16];
extern fixed_t cachedheight[MAXVIDHEIGHT];
extern fixed_t cacheddistance[MAXVIDHEIGHT];
extern fixed_t cachedxstep[MAXVIDHEIGHT];
extern fixed_t cachedystep[MAXVIDHEIGHT];
extern fixed_t *yslope;
extern lighttable_t **planezlight;
void R_InitPlanes(void);
void R_ClearPlanes(void);
void R_ClearFFloorClips (void);
void R_DrawPlanes(void);
visplane_t *R_FindPlane(fixed_t height, INT32 picnum, INT32 lightlevel, fixed_t xoff, fixed_t yoff, angle_t plangle,
extracolormap_t *planecolormap, ffloor_t *ffloor, polyobj_t *polyobj, pslope_t *slope);
visplane_t *R_FindPlane(fixed_t height, INT32 picnum, INT32 lightlevel, fixed_t xoff, fixed_t yoff, fixed_t xscale, fixed_t yscale,
angle_t plangle, extracolormap_t *planecolormap, ffloor_t *ffloor, polyobj_t *polyobj, pslope_t *slope);
visplane_t *R_CheckPlane(visplane_t *pl, INT32 start, INT32 stop);
void R_ExpandPlane(visplane_t *pl, INT32 start, INT32 stop);
void R_PlaneBounds(visplane_t *plane);
@ -87,10 +83,6 @@ void R_DrawSinglePlane(visplane_t *pl);
// Calculates the slope vectors needed for tilted span drawing.
void R_SetSlopePlane(pslope_t *slope, fixed_t xpos, fixed_t ypos, fixed_t zpos, fixed_t xoff, fixed_t yoff, angle_t angle, angle_t plangle);
void R_SetScaledSlopePlane(pslope_t *slope, fixed_t xpos, fixed_t ypos, fixed_t zpos, fixed_t xs, fixed_t ys, fixed_t xoff, fixed_t yoff, angle_t angle, angle_t plangle);
void R_CalculateSlopeVectors(void);
// Sets the slope vector pointers for the current tilted span.
void R_SetTiltedSpan(INT32 span);
typedef struct planemgr_s
{

406
src/r_segs.c
View file

@ -48,15 +48,18 @@ fixed_t rw_distance;
//
static INT32 rw_x, rw_stopx;
static angle_t rw_centerangle;
static fixed_t rw_offset;
static fixed_t rw_offset_top, rw_offset_mid, rw_offset_bot;
static fixed_t rw_offset2; // for splats
static fixed_t rw_offset, rw_offsetx;
static fixed_t rw_offset_top, rw_offset_mid, rw_offset_bottom;
static fixed_t rw_scale, rw_scalestep;
static fixed_t rw_midtexturemid, rw_toptexturemid, rw_bottomtexturemid;
static INT32 worldtop, worldbottom, worldhigh, worldlow;
static INT32 worldtopslope, worldbottomslope, worldhighslope, worldlowslope; // worldtop/bottom at end of slope
static fixed_t rw_toptextureslide, rw_midtextureslide, rw_bottomtextureslide; // Defines how to adjust Y offsets along the wall for slopes
static fixed_t rw_midtextureback, rw_midtexturebackslide; // Values for masked midtexture height calculation
static fixed_t rw_midtexturescalex, rw_midtexturescaley;
static fixed_t rw_toptexturescalex, rw_toptexturescaley;
static fixed_t rw_bottomtexturescalex, rw_bottomtexturescaley;
static fixed_t rw_invmidtexturescalex, rw_invtoptexturescalex, rw_invbottomtexturescalex;
// Lactozilla: 3D floor clipping
static boolean rw_floormarked = false;
@ -71,8 +74,10 @@ static fixed_t topfrac, topstep;
static fixed_t bottomfrac, bottomstep;
static lighttable_t **walllights;
static fixed_t *maskedtexturecol;
static fixed_t *maskedtexturecol = NULL;
static fixed_t *maskedtextureheight = NULL;
static fixed_t *thicksidecol = NULL;
static fixed_t *invscale = NULL;
//SoM: 3/23/2000: Use boom opening limit removal
static size_t numopenings;
@ -162,7 +167,8 @@ void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2)
frontsector = curline->frontsector;
backsector = curline->backsector;
texnum = R_GetTextureNum(curline->sidedef->midtexture);
sidedef = curline->sidedef;
texnum = R_GetTextureNum(sidedef->midtexture);
windowbottom = windowtop = sprbotscreen = INT32_MAX;
ldef = curline->linedef;
@ -200,9 +206,13 @@ void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2)
colfunc = colfuncs[COLDRAWFUNC_FUZZY];
}
fixed_t wall_scaley = sidedef->scaley_mid;
fixed_t scalestep = FixedDiv(ds->scalestep, wall_scaley);
fixed_t scale1 = FixedDiv(ds->scale1, wall_scaley);
range = max(ds->x2-ds->x1, 1);
rw_scalestep = ds->scalestep;
spryscale = ds->scale1 + (x1 - ds->x1)*rw_scalestep;
rw_scalestep = scalestep;
spryscale = scale1 + (x1 - ds->x1)*rw_scalestep;
// Texture must be cached before setting colfunc_2s,
// otherwise texture[texnum]->holes may be false when it shouldn't be
@ -313,8 +323,8 @@ void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2)
else
back = backsector;
if (ds->curline->sidedef->repeatcnt)
repeats = 1 + ds->curline->sidedef->repeatcnt;
if (sidedef->repeatcnt)
repeats = 1 + sidedef->repeatcnt;
else if (ldef->flags & ML_WRAPMIDTEX)
{
fixed_t high, low;
@ -340,15 +350,14 @@ void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2)
{
if (times > 0)
{
rw_scalestep = ds->scalestep;
spryscale = ds->scale1 + (x1 - ds->x1)*rw_scalestep;
if (dc_numlights)
{ // reset all lights to their starting heights
for (i = 0; i < dc_numlights; i++)
{
rlight = &dc_lightlist[i];
rlight->height = rlight->startheight;
}
rw_scalestep = scalestep;
spryscale = scale1 + (x1 - ds->x1)*rw_scalestep;
// reset all lights to their starting heights
for (i = 0; i < dc_numlights; i++)
{
rlight = &dc_lightlist[i];
rlight->height = rlight->startheight;
}
}
@ -390,8 +399,10 @@ void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2)
sprbotscreen = INT32_MAX;
sprtopscreen = windowtop = (centeryfrac - FixedMul(dc_texturemid, spryscale));
realbot = windowbottom = FixedMul(textureheight[texnum], spryscale) + sprtopscreen;
dc_iscale = 0xffffffffu / (unsigned)spryscale;
realbot = FixedMul(textureheight[texnum], spryscale) + sprtopscreen;
dc_iscale = FixedMul(ds->invscale[dc_x], wall_scaley);
windowbottom = realbot;
// draw the texture
col = (column_t *)((UINT8 *)R_GetColumn(texnum, (maskedtexturecol[dc_x] >> FRACBITS)) - 3);
@ -466,7 +477,7 @@ void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2)
dc_colormap = frontsector->extra_colormap->colormap + (dc_colormap - colormaps);
sprtopscreen = centeryfrac - FixedMul(dc_texturemid, spryscale);
dc_iscale = 0xffffffffu / (unsigned)spryscale;
dc_iscale = FixedMul(ds->invscale[dc_x], wall_scaley);
// draw the texture
col = (column_t *)((UINT8 *)R_GetColumn(texnum, (maskedtexturecol[dc_x] >> FRACBITS)) - 3);
@ -525,7 +536,7 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
INT32 i, p;
fixed_t bottombounds = viewheight << FRACBITS;
fixed_t topbounds = (con_clipviewtop - 1) << FRACBITS;
fixed_t offsetvalue = 0;
fixed_t offsetvalue;
lightlist_t *light;
r_lightlist_t *rlight;
INT32 range;
@ -534,11 +545,13 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
// NOTE: INT64 instead of fixed_t because overflow concerns
INT64 top_frac, top_step, bottom_frac, bottom_step;
// skew FOF walls with slopes?
boolean slopeskew = false;
fixed_t ffloortextureslide = 0;
INT32 oldx = -1;
fixed_t left_top, left_bottom; // needed here for slope skewing
pslope_t *skewslope = NULL;
boolean do_texture_skew;
UINT32 lineflags;
fixed_t wall_scalex, wall_scaley;
void (*colfunc_2s) (column_t *);
@ -550,7 +563,7 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
curline = ds->curline;
backsector = pfloor->target;
frontsector = curline->frontsector == pfloor->target ? curline->backsector : curline->frontsector;
texnum = R_GetTextureNum(sides[pfloor->master->sidenum[0]].midtexture);
sidedef = &sides[pfloor->master->sidenum[0]];
colfunc = colfuncs[BASEDRAWFUNC];
@ -558,8 +571,13 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
{
size_t linenum = curline->linedef-backsector->lines[0];
newline = pfloor->master->frontsector->lines[0] + linenum;
texnum = R_GetTextureNum(sides[newline->sidenum[0]].midtexture);
sidedef = &sides[newline->sidenum[0]];
lineflags = newline->flags;
}
else
lineflags = pfloor->master->flags;
texnum = R_GetTextureNum(sidedef->midtexture);
if (pfloor->fofflags & FOF_TRANSLUCENT)
{
@ -711,7 +729,13 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
walllights = scalelight[lightnum];
}
maskedtexturecol = ds->thicksidecol;
wall_scalex = FixedDiv(FRACUNIT, sidedef->scalex_mid);
wall_scaley = sidedef->scaley_mid;
thicksidecol = ds->thicksidecol;
for (INT32 x = x1; x <= x2; x++)
thicksidecol[x] = FixedDiv(thicksidecol[x], wall_scalex) + ds->offsetx;
mfloorclip = ds->sprbottomclip;
mceilingclip = ds->sprtopclip;
@ -721,51 +745,29 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
left_top = P_GetFFloorTopZAt (pfloor, ds->leftpos.x, ds->leftpos.y) - viewz;
left_bottom = P_GetFFloorBottomZAt(pfloor, ds->leftpos.x, ds->leftpos.y) - viewz;
do_texture_skew = lineflags & ML_SKEWTD;
skewslope = *pfloor->t_slope; // skew using top slope by default
if (newline)
{
if (newline->flags & ML_SKEWTD)
slopeskew = true;
}
else if (pfloor->master->flags & ML_SKEWTD)
slopeskew = true;
if (slopeskew)
dc_texturemid = left_top;
if (do_texture_skew)
dc_texturemid = FixedMul(left_top, wall_scaley);
else
dc_texturemid = *pfloor->topheight - viewz;
dc_texturemid = FixedMul(*pfloor->topheight - viewz, wall_scaley);
if (newline)
offsetvalue = sidedef->rowoffset + sidedef->offsety_mid;
if (lineflags & ML_DONTPEGBOTTOM)
{
offsetvalue = sides[newline->sidenum[0]].rowoffset + sides[newline->sidenum[0]].offsety_mid;
if (newline->flags & ML_DONTPEGBOTTOM)
{
skewslope = *pfloor->b_slope; // skew using bottom slope
if (slopeskew)
dc_texturemid = left_bottom;
else
offsetvalue -= *pfloor->topheight - *pfloor->bottomheight;
}
}
else
{
offsetvalue = sides[pfloor->master->sidenum[0]].rowoffset + sides[pfloor->master->sidenum[0]].offsety_mid;
if (curline->linedef->flags & ML_DONTPEGBOTTOM)
{
skewslope = *pfloor->b_slope; // skew using bottom slope
if (slopeskew)
dc_texturemid = left_bottom;
else
offsetvalue -= *pfloor->topheight - *pfloor->bottomheight;
}
skewslope = *pfloor->b_slope; // skew using bottom slope
if (do_texture_skew)
dc_texturemid = FixedMul(left_bottom, wall_scaley);
else
offsetvalue -= FixedMul(*pfloor->topheight - *pfloor->bottomheight, wall_scaley);
}
if (slopeskew)
if (do_texture_skew && skewslope)
{
angle_t lineangle = R_PointToAngle2(curline->v1->x, curline->v1->y, curline->v2->x, curline->v2->y);
if (skewslope)
ffloortextureslide = FixedMul(skewslope->zdelta, FINECOSINE((lineangle-skewslope->xydirection)>>ANGLETOFINESHIFT));
ffloortextureslide = FixedMul(skewslope->zdelta, FINECOSINE((lineangle-skewslope->xydirection)>>ANGLETOFINESHIFT));
}
dc_texturemid += offsetvalue;
@ -819,7 +821,7 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
if (ffloortextureslide)
{
if (oldx != -1)
dc_texturemid += FixedMul(ffloortextureslide, maskedtexturecol[oldx]-maskedtexturecol[dc_x]);
dc_texturemid += FixedMul(ffloortextureslide, thicksidecol[oldx]-thicksidecol[dc_x]);
oldx = dc_x;
}
@ -852,10 +854,10 @@ void R_RenderThickSideRange(drawseg_t *ds, INT32 x1, INT32 x2, ffloor_t *pfloor)
continue;
}
dc_iscale = 0xffffffffu / (unsigned)spryscale;
dc_iscale = FixedMul(0xffffffffu / (unsigned)spryscale, wall_scaley);
// Get data for the column
col = (column_t *)((UINT8 *)R_GetColumn(texnum, (maskedtexturecol[dc_x] >> FRACBITS)) - 3);
col = (column_t *)((UINT8 *)R_GetColumn(texnum, (thicksidecol[dc_x] >> FRACBITS)) - 3);
// SoM: New code does not rely on R_DrawColumnShadowed_8 which
// will (hopefully) put less strain on the stack.
@ -1044,13 +1046,18 @@ UINT32 nombre = 100000;
static void R_RenderSegLoop (void)
{
angle_t angle;
fixed_t textureoffset;
size_t pindex;
INT32 yl;
INT32 yh;
INT32 mid;
fixed_t texturecolumn = 0;
fixed_t toptexturecolumn = 0;
fixed_t bottomtexturecolumn = 0;
fixed_t oldtexturecolumn = -1;
fixed_t oldtexturecolumn_top = -1;
fixed_t oldtexturecolumn_bottom = -1;
INT32 top;
INT32 bottom;
INT32 i;
@ -1217,17 +1224,8 @@ static void R_RenderSegLoop (void)
//SoM: Calculate offsets for Thick fake floors.
// calculate texture offset
angle = (rw_centerangle + xtoviewangle[rw_x])>>ANGLETOFINESHIFT;
texturecolumn = rw_offset-FixedMul(FINETANGENT(angle),rw_distance);
if (oldtexturecolumn != -1) {
rw_bottomtexturemid += FixedMul(rw_bottomtextureslide, oldtexturecolumn-texturecolumn);
rw_midtexturemid += FixedMul(rw_midtextureslide, oldtexturecolumn-texturecolumn);
rw_toptexturemid += FixedMul(rw_toptextureslide, oldtexturecolumn-texturecolumn);
rw_midtextureback += FixedMul(rw_midtexturebackslide, oldtexturecolumn-texturecolumn);
}
oldtexturecolumn = texturecolumn;
INT32 itexturecolumn = texturecolumn >> FRACBITS;
textureoffset = rw_offset - FixedMul(FINETANGENT(angle), rw_distance);
texturecolumn = FixedDiv(textureoffset, rw_invmidtexturescalex);
// texturecolumn and lighting are independent of wall tiers
if (segtextured)
@ -1240,7 +1238,6 @@ static void R_RenderSegLoop (void)
dc_colormap = walllights[pindex];
dc_x = rw_x;
dc_iscale = 0xffffffffu / (unsigned)rw_scale;
if (frontsector->extra_colormap)
dc_colormap = frontsector->extra_colormap->colormap + (dc_colormap - colormaps);
@ -1290,10 +1287,13 @@ static void R_RenderSegLoop (void)
// single sided line
if (yl <= yh && yh >= 0 && yl < viewheight)
{
fixed_t offset = texturecolumn + rw_offsetx;
dc_yl = yl;
dc_yh = yh;
dc_texturemid = rw_midtexturemid;
dc_source = R_GetColumn(midtexture, itexturecolumn + (rw_offset_mid>>FRACBITS));
dc_iscale = FixedMul(0xffffffffu / (unsigned)rw_scale, rw_midtexturescaley);
dc_source = R_GetColumn(midtexture, offset >> FRACBITS);
dc_texheight = textureheight[midtexture]>>FRACBITS;
//profile stuff ---------------------------------------------------------
@ -1342,6 +1342,8 @@ static void R_RenderSegLoop (void)
if (mid >= floorclip[rw_x])
mid = floorclip[rw_x]-1;
toptexturecolumn = FixedDiv(textureoffset, rw_invtoptexturescalex);
if (mid >= yl) // back ceiling lower than front ceiling ?
{
if (yl >= viewheight) // entirely off bottom of screen
@ -1351,10 +1353,16 @@ static void R_RenderSegLoop (void)
}
else if (mid >= 0) // safe to draw top texture
{
fixed_t offset = rw_offset_top;
if (rw_toptexturescalex < 0)
offset = -offset;
offset = toptexturecolumn + offset;
dc_yl = yl;
dc_yh = mid;
dc_texturemid = rw_toptexturemid;
dc_source = R_GetColumn(toptexture, itexturecolumn + (rw_offset_top>>FRACBITS));
dc_iscale = FixedMul(0xffffffffu / (unsigned)rw_scale, rw_toptexturescaley);
dc_source = R_GetColumn(toptexture, offset >> FRACBITS);
dc_texheight = textureheight[toptexture]>>FRACBITS;
colfunc();
ceilingclip[rw_x] = (INT16)mid;
@ -1364,6 +1372,10 @@ static void R_RenderSegLoop (void)
}
else if (!rw_ceilingmarked)
ceilingclip[rw_x] = topclip;
if (oldtexturecolumn_top != -1)
rw_toptexturemid += FixedMul(rw_toptextureslide, oldtexturecolumn_top-toptexturecolumn);
oldtexturecolumn_top = toptexturecolumn;
}
else if (markceiling && (!rw_ceilingmarked)) // no top wall
ceilingclip[rw_x] = topclip;
@ -1378,6 +1390,8 @@ static void R_RenderSegLoop (void)
if (mid <= ceilingclip[rw_x])
mid = ceilingclip[rw_x]+1;
bottomtexturecolumn = FixedDiv(textureoffset, rw_invbottomtexturescalex);
if (mid <= yh) // back floor higher than front floor ?
{
if (yh < 0) // entirely off top of screen
@ -1387,10 +1401,16 @@ static void R_RenderSegLoop (void)
}
else if (mid < viewheight) // safe to draw bottom texture
{
fixed_t offset = rw_offset_bottom;
if (rw_bottomtexturescalex < 0)
offset = -offset;
offset = bottomtexturecolumn + offset;
dc_yl = mid;
dc_yh = yh;
dc_texturemid = rw_bottomtexturemid;
dc_source = R_GetColumn(bottomtexture, itexturecolumn + (rw_offset_bot>>FRACBITS));
dc_iscale = FixedMul(0xffffffffu / (unsigned)rw_scale, rw_bottomtexturescaley);
dc_source = R_GetColumn(bottomtexture, offset >> FRACBITS);
dc_texheight = textureheight[bottomtexture]>>FRACBITS;
colfunc();
floorclip[rw_x] = (INT16)mid;
@ -1400,24 +1420,43 @@ static void R_RenderSegLoop (void)
}
else if (!rw_floormarked)
floorclip[rw_x] = bottomclip;
if (oldtexturecolumn_bottom != -1)
rw_bottomtexturemid += FixedMul(rw_bottomtextureslide, oldtexturecolumn_bottom-bottomtexturecolumn);
oldtexturecolumn_bottom = bottomtexturecolumn;
}
else if (markfloor && (!rw_floormarked)) // no bottom wall
floorclip[rw_x] = bottomclip;
}
if (maskedtexture || numthicksides)
{
// save texturecol
// for backdrawing of masked mid texture
maskedtexturecol[rw_x] = texturecolumn + rw_offset_mid;
if (maskedtexturecol)
maskedtexturecol[rw_x] = texturecolumn + rw_offsetx;
if (maskedtextureheight != NULL) {
maskedtextureheight[rw_x] = (curline->linedef->flags & ML_MIDPEG) ?
max(rw_midtexturemid, rw_midtextureback) :
min(rw_midtexturemid, rw_midtextureback);
}
if (thicksidecol)
thicksidecol[rw_x] = textureoffset;
if (maskedtextureheight)
{
if (curline->linedef->flags & ML_MIDPEG)
maskedtextureheight[rw_x] = max(rw_midtexturemid, rw_midtextureback);
else
maskedtextureheight[rw_x] = min(rw_midtexturemid, rw_midtextureback);
}
if (midtexture || maskedtextureheight)
{
if (oldtexturecolumn != -1)
{
rw_midtexturemid += FixedMul(rw_midtextureslide, oldtexturecolumn-texturecolumn);
rw_midtextureback += FixedMul(rw_midtexturebackslide, oldtexturecolumn-texturecolumn);
}
oldtexturecolumn = texturecolumn;
}
if (invscale)
invscale[rw_x] = 0xffffffffu / (unsigned)rw_scale;
if (dc_numlights)
{
for (i = 0; i < dc_numlights; i++)
@ -1506,10 +1545,9 @@ static void R_AllocClippingTables(size_t range)
static void R_AllocTextureColumnTables(size_t range)
{
size_t pos = curtexturecolumntable - texturecolumntable;
size_t need = range * 3;
// For both tables, we reserve exactly an amount of memory that's equivalent to
// how many columns the seg will take on the entire screen (think about it)
if (pos + range < texturecolumntablesize)
if (pos + need < texturecolumntablesize)
return;
fixed_t *oldtable = texturecolumntable;
@ -1518,7 +1556,7 @@ static void R_AllocTextureColumnTables(size_t range)
if (texturecolumntablesize == 0)
texturecolumntablesize = 16384;
texturecolumntablesize += range;
texturecolumntablesize += need;
texturecolumntable = Z_Realloc(texturecolumntable, texturecolumntablesize * sizeof (*texturecolumntable), PU_STATIC, NULL);
curtexturecolumntable = texturecolumntable + pos;
@ -1532,6 +1570,8 @@ static void R_AllocTextureColumnTables(size_t range)
ds->maskedtexturecol = (ds->maskedtexturecol - oldtable) + texturecolumntable;
if (ds->thicksidecol + ds->x1 >= oldtable && ds->thicksidecol + ds->x1 <= oldlast)
ds->thicksidecol = (ds->thicksidecol - oldtable) + texturecolumntable;
if (ds->invscale + ds->x1 >= oldtable && ds->invscale + ds->x1 <= oldlast)
ds->invscale = (ds->invscale - oldtable) + texturecolumntable;
}
}
@ -1555,7 +1595,11 @@ void R_StoreWallRange(INT32 start, INT32 stop)
fixed_t ceilingfrontslide, floorfrontslide, ceilingbackslide, floorbackslide;
static size_t maxdrawsegs = 0;
maskedtexturecol = NULL;
maskedtextureheight = NULL;
thicksidecol = NULL;
invscale = NULL;
//initialize segleft and segright
memset(&segleft, 0x00, sizeof(segleft));
memset(&segright, 0x00, sizeof(segright));
@ -1712,6 +1756,7 @@ void R_StoreWallRange(INT32 start, INT32 stop)
ds_p->maskedtexturecol = NULL;
ds_p->numthicksides = numthicksides = 0;
ds_p->thicksidecol = NULL;
ds_p->invscale = NULL;
ds_p->tsilheight = 0;
numbackffloors = 0;
@ -1751,32 +1796,67 @@ void R_StoreWallRange(INT32 start, INT32 stop)
ceilingbackslide = FixedMul(backsector->c_slope->zdelta, FINECOSINE((lineangle-backsector->c_slope->xydirection)>>ANGLETOFINESHIFT));
}
rw_midtexturescalex = sidedef->scalex_mid;
rw_midtexturescaley = sidedef->scaley_mid;
rw_invmidtexturescalex = FixedDiv(FRACUNIT, rw_midtexturescalex);
if (!backsector)
{
fixed_t texheight;
// single sided line
midtexture = R_GetTextureNum(sidedef->midtexture);
texheight = textureheight[midtexture];
// a single sided line is terminal, so it must mark ends
markfloor = markceiling = true;
if (linedef->flags & ML_NOSKEW) {
if (linedef->flags & ML_DONTPEGBOTTOM)
rw_midtexturemid = frontsector->floorheight + texheight - viewz;
else
rw_midtexturemid = frontsector->ceilingheight - viewz;
}
else if (linedef->flags & ML_DONTPEGBOTTOM)
fixed_t rowoffset = sidedef->rowoffset + sidedef->offsety_mid;
fixed_t texheight = textureheight[midtexture];
if (rw_midtexturescaley > 0)
{
rw_midtexturemid = worldbottom + texheight;
rw_midtextureslide = floorfrontslide;
if (linedef->flags & ML_NOSKEW)
{
if (linedef->flags & ML_DONTPEGBOTTOM)
rw_midtexturemid = FixedMul(frontsector->floorheight - viewz, rw_midtexturescaley) + texheight;
else
rw_midtexturemid = FixedMul(frontsector->ceilingheight - viewz, rw_midtexturescaley);
}
else if (linedef->flags & ML_DONTPEGBOTTOM)
{
rw_midtexturemid = FixedMul(worldbottom, rw_midtexturescaley) + texheight;
rw_midtextureslide = floorfrontslide;
}
else
{
// top of texture at top
rw_midtexturemid = FixedMul(worldtop, rw_midtexturescaley);
rw_midtextureslide = ceilingfrontslide;
}
}
else
{
// top of texture at top
rw_midtexturemid = worldtop;
rw_midtextureslide = ceilingfrontslide;
// Upside down
rowoffset = -rowoffset;
if (linedef->flags & ML_NOSKEW)
{
if (linedef->flags & ML_DONTPEGBOTTOM)
rw_midtexturemid = FixedMul(frontsector->floorheight - viewz, rw_midtexturescaley);
else
rw_midtexturemid = FixedMul(frontsector->ceilingheight - viewz, rw_midtexturescaley) + texheight;
}
else if (linedef->flags & ML_DONTPEGBOTTOM)
{
rw_midtexturemid = FixedMul(worldbottom, rw_midtexturescaley);
rw_midtextureslide = floorfrontslide;
}
else
{
// top of texture at top
rw_midtexturemid = FixedMul(worldtop, rw_midtexturescaley) + texheight;
rw_midtextureslide = ceilingfrontslide;
}
}
rw_midtexturemid += sidedef->rowoffset + sidedef->offsety_mid;
rw_midtexturemid += rowoffset;
ds_p->silhouette = SIL_BOTH;
ds_p->sprtopclip = screenheightarray;
@ -1901,6 +1981,8 @@ void R_StoreWallRange(INT32 start, INT32 stop)
//SoM: 3/22/2000: Check floor x and y offsets.
|| backsector->floorxoffset != frontsector->floorxoffset
|| backsector->flooryoffset != frontsector->flooryoffset
|| backsector->floorxscale != frontsector->floorxscale
|| backsector->flooryscale != frontsector->flooryscale
|| backsector->floorangle != frontsector->floorangle
//SoM: 3/22/2000: Prevents bleeding.
|| (frontsector->heightsec != -1 && frontsector->floorpic != skyflatnum)
@ -1934,6 +2016,8 @@ void R_StoreWallRange(INT32 start, INT32 stop)
//SoM: 3/22/2000: Check floor x and y offsets.
|| backsector->ceilingxoffset != frontsector->ceilingxoffset
|| backsector->ceilingyoffset != frontsector->ceilingyoffset
|| backsector->ceilingxscale != frontsector->ceilingxscale
|| backsector->ceilingyscale != frontsector->ceilingyscale
|| backsector->ceilingangle != frontsector->ceilingangle
//SoM: 3/22/2000: Prevents bleeding.
|| (frontsector->heightsec != -1 && frontsector->ceilingpic != skyflatnum)
@ -1962,16 +2046,28 @@ void R_StoreWallRange(INT32 start, INT32 stop)
}
}
fixed_t toprowoffset = sidedef->rowoffset + sidedef->offsety_top;
fixed_t botrowoffset = sidedef->rowoffset + sidedef->offsety_bottom;
// check TOP TEXTURE
if (!bothceilingssky // never draw the top texture if on
&& (worldhigh < worldtop || worldhighslope < worldtopslope))
{
fixed_t texheight;
// top texture
toptexture = R_GetTextureNum(sidedef->toptexture);
texheight = textureheight[toptexture];
if (!(linedef->flags & ML_SKEWTD)) { // Ignore slopes for lower/upper textures unless flag is checked
rw_toptexturescalex = sidedef->scalex_top;
rw_toptexturescaley = sidedef->scaley_top;
rw_invtoptexturescalex = FixedDiv(FRACUNIT, rw_toptexturescalex);
if (rw_toptexturescaley < 0)
toprowoffset = -toprowoffset;
fixed_t texheight = textureheight[toptexture];
// Ignore slopes for lower/upper textures unless flag is checked
if (!(linedef->flags & ML_SKEWTD))
{
if (linedef->flags & ML_DONTPEGTOP)
rw_toptexturemid = frontsector->ceilingheight - viewz;
else
@ -1988,7 +2084,10 @@ void R_StoreWallRange(INT32 start, INT32 stop)
rw_toptexturemid = worldhigh + texheight;
rw_toptextureslide = ceilingbackslide;
}
rw_toptexturemid = FixedMul(rw_toptexturemid, rw_toptexturescaley);
}
// check BOTTOM TEXTURE
if (!bothfloorssky // never draw the bottom texture if on
&& (worldlow > worldbottom || worldlowslope > worldbottomslope)) // Only if VISIBLE!!!
@ -1996,7 +2095,17 @@ void R_StoreWallRange(INT32 start, INT32 stop)
// bottom texture
bottomtexture = R_GetTextureNum(sidedef->bottomtexture);
if (!(linedef->flags & ML_SKEWTD)) { // Ignore slopes for lower/upper textures unless flag is checked
rw_bottomtexturescalex = sidedef->scalex_bottom;
rw_bottomtexturescaley = sidedef->scaley_bottom;
rw_invbottomtexturescalex = FixedDiv(FRACUNIT, rw_bottomtexturescalex);
if (rw_bottomtexturescaley < 0)
botrowoffset = -botrowoffset;
// Ignore slopes for lower/upper textures unless flag is checked
if (!(linedef->flags & ML_SKEWTD))
{
if (linedef->flags & ML_DONTPEGBOTTOM)
rw_bottomtexturemid = frontsector->floorheight - viewz;
else
@ -2009,18 +2118,22 @@ void R_StoreWallRange(INT32 start, INT32 stop)
rw_bottomtexturemid = worldbottom;
rw_bottomtextureslide = floorfrontslide;
}
else { // top of texture at top
else
{
// top of texture at top
rw_bottomtexturemid = worldlow;
rw_bottomtextureslide = floorbackslide;
}
rw_bottomtexturemid = FixedMul(rw_bottomtexturemid, rw_bottomtexturescaley);
}
rw_toptexturemid += sidedef->rowoffset + sidedef->offsety_top;
rw_bottomtexturemid += sidedef->rowoffset + sidedef->offsety_bot;
R_AllocTextureColumnTables(rw_stopx - start);
rw_toptexturemid += toprowoffset;
rw_bottomtexturemid += botrowoffset;
// allocate space for masked texture tables
R_AllocTextureColumnTables(rw_stopx - start);
if (frontsector && backsector && !Tag_Compare(&frontsector->tags, &backsector->tags) && (backsector->ffloors || frontsector->ffloors))
{
ffloor_t *rover;
@ -2031,10 +2144,9 @@ void R_StoreWallRange(INT32 start, INT32 stop)
// Used for height comparisons and etc across FOFs and slopes
fixed_t high1, highslope1, low1, lowslope1, high2, highslope2, low2, lowslope2;
//markceiling = markfloor = true;
maskedtexture = true;
ds_p->thicksidecol = maskedtexturecol = curtexturecolumntable - rw_x;
ds_p->thicksidecol = thicksidecol = curtexturecolumntable - rw_x;
curtexturecolumntable += rw_stopx - rw_x;
lowcut = max(worldbottom, worldlow) + viewz;
@ -2213,21 +2325,20 @@ void R_StoreWallRange(INT32 start, INT32 stop)
ds_p->numthicksides = numthicksides = i;
}
// masked midtexture
if (sidedef->midtexture > 0 && sidedef->midtexture < numtextures)
{
// masked midtexture
if (!ds_p->thicksidecol)
{
ds_p->maskedtexturecol = maskedtexturecol = curtexturecolumntable - rw_x;
curtexturecolumntable += rw_stopx - rw_x;
}
else
ds_p->maskedtexturecol = ds_p->thicksidecol;
ds_p->maskedtexturecol = maskedtexturecol = curtexturecolumntable - rw_x;
curtexturecolumntable += rw_stopx - rw_x;
maskedtextureheight = ds_p->maskedtextureheight; // note to red, this == &(ds_p->maskedtextureheight[0])
maskedtexture = true;
if (curline->polyseg)
{ // use REAL front and back floors please, so midtexture rendering isn't mucked up
{
// use REAL front and back floors please, so midtexture rendering isn't mucked up
rw_midtextureslide = rw_midtexturebackslide = 0;
if (linedef->flags & ML_MIDPEG)
rw_midtexturemid = rw_midtextureback = max(curline->frontsector->floorheight, curline->backsector->floorheight) - viewz;
@ -2238,7 +2349,8 @@ void R_StoreWallRange(INT32 start, INT32 stop)
{
// Set midtexture starting height
if (linedef->flags & ML_NOSKEW)
{ // Ignore slopes when texturing
{
// Ignore slopes when texturing
rw_midtextureslide = rw_midtexturebackslide = 0;
if (linedef->flags & ML_MIDPEG)
rw_midtexturemid = rw_midtextureback = max(frontsector->floorheight, backsector->floorheight) - viewz;
@ -2261,6 +2373,10 @@ void R_StoreWallRange(INT32 start, INT32 stop)
rw_midtexturebackslide = ceilingbackslide;
}
}
rw_midtexturemid = FixedMul(rw_midtexturemid, rw_midtexturescaley);
rw_midtextureback = FixedMul(rw_midtextureback, rw_midtexturescaley);
rw_midtexturemid += sidedef->rowoffset + sidedef->offsety_mid;
rw_midtextureback += sidedef->rowoffset + sidedef->offsety_mid;
@ -2273,6 +2389,8 @@ void R_StoreWallRange(INT32 start, INT32 stop)
if (segtextured)
{
fixed_t sideoffset = sidedef->textureoffset;
offsetangle = rw_normalangle-rw_angle1;
if (offsetangle > ANGLE_180)
@ -2297,14 +2415,20 @@ void R_StoreWallRange(INT32 start, INT32 stop)
if (rw_normalangle-rw_angle1 < ANGLE_180)
rw_offset = -rw_offset;
/// don't use texture offset for splats
rw_offset2 = rw_offset + curline->offset;
rw_offset += sidedef->textureoffset + curline->offset;
rw_offset_top = sidedef->offsetx_top;
rw_offset_mid = sidedef->offsetx_mid;
rw_offset_bot = sidedef->offsetx_bot;
rw_offset += curline->offset;
rw_centerangle = ANGLE_90 + viewangle - rw_normalangle;
rw_offset_top = sideoffset + sidedef->offsetx_top;
rw_offset_mid = sideoffset + sidedef->offsetx_mid;
rw_offset_bottom = sideoffset + sidedef->offsetx_bottom;
rw_offsetx = rw_offset_mid;
if (rw_midtexturescalex < 0)
rw_offsetx = -rw_offsetx;
if (numthicksides)
ds_p->offsetx = rw_offsetx;
// calculate light table
// use different light tables
// for horizontal / vertical / diagonal
@ -2324,6 +2448,12 @@ void R_StoreWallRange(INT32 start, INT32 stop)
walllights = scalelight[lightnum];
}
if (maskedtexture)
{
ds_p->invscale = invscale = curtexturecolumntable - rw_x;
curtexturecolumntable += rw_stopx - rw_x;
}
// if a floor / ceiling plane is on the wrong side
// of the view plane, it is definitely invisible
// and doesn't need to be marked.

2
src/r_skins.c
View file

@ -377,7 +377,7 @@ static void SetSkin(player_t *player, INT32 skinnum)
P_SetScale(player->mo, player->mo->scale);
player->mo->radius = radius;
P_SetPlayerMobjState(player->mo, player->mo->state-states); // Prevent visual errors when switching between skins with differing number of frames
P_SetMobjState(player->mo, player->mo->state-states); // Prevent visual errors when switching between skins with differing number of frames
}
}

38
src/r_splats.c
View file

@ -369,7 +369,7 @@ static void R_RasterizeFloorSplat(floorsplat_t *pSplat, vector2_t *verts, visspr
ds_flatwidth = pSplat->width;
ds_flatheight = pSplat->height;
ds_powersoftwo = ds_solidcolor = false;
ds_powersoftwo = ds_solidcolor = ds_fog = false;
if (R_CheckSolidColorFlat())
ds_solidcolor = true;
@ -381,9 +381,7 @@ static void R_RasterizeFloorSplat(floorsplat_t *pSplat, vector2_t *verts, visspr
if (pSplat->slope)
{
R_SetTiltedSpan(0);
R_SetScaledSlopePlane(pSplat->slope, vis->viewpoint.x, vis->viewpoint.y, vis->viewpoint.z, pSplat->xscale, pSplat->yscale, -pSplat->verts[0].x, pSplat->verts[0].y, vis->viewpoint.angle, pSplat->angle);
R_CalculateSlopeVectors();
}
else if (!ds_solidcolor)
{
@ -391,8 +389,6 @@ static void R_RasterizeFloorSplat(floorsplat_t *pSplat, vector2_t *verts, visspr
if (pSplat->angle)
{
memset(cachedheight, 0, sizeof(cachedheight));
// Add the view offset, rotated by the plane angle.
fixed_t a = -pSplat->verts[0].x + vis->viewpoint.x;
fixed_t b = -pSplat->verts[0].y + vis->viewpoint.y;
@ -547,29 +543,18 @@ static void R_RasterizeFloorSplat(floorsplat_t *pSplat, vector2_t *verts, visspr
angle_t planecos = FINECOSINE(angle);
angle_t planesin = FINESINE(angle);
if (planeheight != cachedheight[y])
// [RH] Notice that I dumped the caching scheme used by Doom.
// It did not offer any appreciable speedup.
distance = FixedMul(planeheight, yslope[y]);
span = abs(centery - y);
if (span) // Don't divide by zero
{
cachedheight[y] = planeheight;
distance = cacheddistance[y] = FixedMul(planeheight, yslope[y]);
span = abs(centery - y);
if (span) // Don't divide by zero
{
xstep = FixedMul(planesin, planeheight) / span;
ystep = FixedMul(planecos, planeheight) / span;
}
else
xstep = ystep = FRACUNIT;
cachedxstep[y] = xstep;
cachedystep[y] = ystep;
xstep = FixedMul(planesin, planeheight) / span;
ystep = FixedMul(planecos, planeheight) / span;
}
else
{
distance = cacheddistance[y];
xstep = cachedxstep[y];
ystep = cachedystep[y];
}
xstep = ystep = FRACUNIT;
ds_xstep = FixedDiv(xstep, pSplat->xscale);
ds_ystep = FixedDiv(ystep, pSplat->yscale);
@ -586,9 +571,6 @@ static void R_RasterizeFloorSplat(floorsplat_t *pSplat, vector2_t *verts, visspr
rastertab[y].minx = INT32_MAX;
rastertab[y].maxx = INT32_MIN;
}
if (!ds_solidcolor && pSplat->angle && !pSplat->slope)
memset(cachedheight, 0, sizeof(cachedheight));
}
static void prepare_rastertab(void)

48
src/r_things.c
View file

@ -1627,6 +1627,8 @@ static void R_ProjectSprite(mobj_t *thing)
height = interp.height; // Ditto
// transform the origin point
if (thing->type == MT_OVERLAY) // Handle overlays
R_ThingOffsetOverlay(thing, &interp.x, &interp.y);
tr_x = interp.x - viewx;
tr_y = interp.y - viewy;
@ -1972,6 +1974,8 @@ static void R_ProjectSprite(mobj_t *thing)
radius = tracer_interp.radius; // For drop shadows
height = tracer_interp.height; // Ditto
if (thing->type == MT_OVERLAY) // Handle overlays
R_ThingOffsetOverlay(thing, &tracer_interp.x, &tracer_interp.y);
tr_x = (tracer_interp.x + sort_x) - viewx;
tr_y = (tracer_interp.y + sort_y) - viewy;
tz = FixedMul(tr_x, viewcos) + FixedMul(tr_y, viewsin);
@ -3566,6 +3570,50 @@ boolean R_ThingIsFullDark(mobj_t *thing)
return ((thing->frame & FF_BRIGHTMASK) == FF_FULLDARK || (thing->renderflags & RF_BRIGHTMASK) == RF_FULLDARK);
}
// Offsets MT_OVERLAY towards the camera at render-time - Works in splitscreen!
// The &x and &y arguments should be pre-interpolated, and will be modified
void R_ThingOffsetOverlay(mobj_t *thing, fixed_t *x, fixed_t *y)
{
mobj_t *mobj = thing;
INT16 offset = 0; // Offset towards or away from the camera, and how much
fixed_t offsetscale = thing->scale; // Occasionally needs to be interpolated
angle_t viewingangle;
UINT8 looplimit = 255; // Prevent infinite loops - A chain of 255 connected overlays is enough for any sane use case
#ifdef PARANOIA
if (P_MobjWasRemoved(mobj) || !x || !y)
I_Error("R_ThingOffsetOverlay: thing, x, or y is invalid");
#endif
do // Get the overlay's offset
{
// Does the overlay use FF_ANIMATE? If not, if var1 is non-zero, it's an underlay instead of an overlay
if (!(mobj->state->frame & FF_ANIMATE) && mobj->state->var1)
offset += 1; // Underlay below the target, away from the camera
else
offset -= 1; // Overlay on top of the target, towards the camera
looplimit -= 1;
mobj = mobj->target;
} while (!P_MobjWasRemoved(mobj) && mobj->type == MT_OVERLAY && looplimit > 0); // Handle overlays following other overlays
// Does the offset scale need to be interpolated?
if (thing->scale != thing->old_scale && R_UsingFrameInterpolation() && !paused)
{
interpmobjstate_t interp = {0};
R_InterpolateMobjState(thing, rendertimefrac, &interp);
offsetscale = interp.scale;
}
// Get the angle from the camera to the X and Y coordinates
viewingangle = R_PointToAngle(*x, *y);
// Finally, offset the X and Y coordinates towards or away from the camera
*x += P_ReturnThrustX(thing, viewingangle, FixedMul(offset * (FRACUNIT/4), offsetscale));
*y += P_ReturnThrustY(thing, viewingangle, FixedMul(offset * (FRACUNIT/4), offsetscale));
}
//
// R_DrawMasked
//

2
src/r_things.h
View file

@ -88,6 +88,8 @@ boolean R_ThingIsFullBright (mobj_t *thing);
boolean R_ThingIsSemiBright (mobj_t *thing);
boolean R_ThingIsFullDark (mobj_t *thing);
void R_ThingOffsetOverlay (mobj_t *thing, fixed_t *outx, fixed_t *outy);
// --------------
// MASKED DRAWING
// --------------

50
src/screen.c
View file

@ -98,14 +98,6 @@ UINT8 *scr_borderpatch; // flat used to fill the reduced view borders set at ST_
// Short and Tall sky drawer, for the current color mode
void (*walldrawerfunc)(void);
boolean R_486 = false;
boolean R_586 = false;
boolean R_MMX = false;
boolean R_SSE = false;
boolean R_3DNow = false;
boolean R_MMXExt = false;
boolean R_SSE2 = false;
void SCR_SetDrawFuncs(void)
{
//
@ -225,48 +217,6 @@ void SCR_SetMode(void)
//
void SCR_Startup(void)
{
const CPUInfoFlags *RCpuInfo = I_CPUInfo();
if (!M_CheckParm("-NOCPUID") && RCpuInfo)
{
#if defined (__i386__) || defined (_M_IX86) || defined (__WATCOMC__)
R_486 = true;
#endif
if (RCpuInfo->RDTSC)
R_586 = true;
if (RCpuInfo->MMX)
R_MMX = true;
if (RCpuInfo->AMD3DNow)
R_3DNow = true;
if (RCpuInfo->MMXExt)
R_MMXExt = true;
if (RCpuInfo->SSE)
R_SSE = true;
if (RCpuInfo->SSE2)
R_SSE2 = true;
CONS_Printf("CPU Info: 486: %i, 586: %i, MMX: %i, 3DNow: %i, MMXExt: %i, SSE2: %i\n", R_486, R_586, R_MMX, R_3DNow, R_MMXExt, R_SSE2);
}
if (M_CheckParm("-486"))
R_486 = true;
if (M_CheckParm("-586"))
R_586 = true;
if (M_CheckParm("-MMX"))
R_MMX = true;
if (M_CheckParm("-3DNow"))
R_3DNow = true;
if (M_CheckParm("-MMXExt"))
R_MMXExt = true;
if (M_CheckParm("-SSE"))
R_SSE = true;
if (M_CheckParm("-noSSE"))
R_SSE = false;
if (M_CheckParm("-SSE2"))
R_SSE2 = true;
M_SetupMemcpy();
if (dedicated)
{
V_Init();

11
src/screen.h
View file

@ -172,17 +172,6 @@ extern void (*spanfunc)(void);
extern void (*spanfuncs[SPANDRAWFUNC_MAX])(void);
extern void (*spanfuncs_npo2[SPANDRAWFUNC_MAX])(void);
// -----
// CPUID
// -----
extern boolean R_ASM;
extern boolean R_486;
extern boolean R_586;
extern boolean R_MMX;
extern boolean R_3DNow;
extern boolean R_MMXExt;
extern boolean R_SSE2;
// ----------------
// screen variables
// ----------------

61
src/sdl/i_system.c
View file

@ -41,6 +41,12 @@ typedef LPVOID (WINAPI *p_MapViewOfFile) (HANDLE, DWORD, DWORD, DWORD, SIZE_T);
#include <ntsecapi.h>
#undef SystemFunction036
// A little more than the minimum sleep duration on Windows.
// May be incorrect for other platforms, but we don't currently have a way to
// query the scheduler granularity. SDL will do what's needed to make this as
// low as possible though.
#define MIN_SLEEP_DURATION_MS 2.1
#endif
#include <stdio.h>
#include <stdlib.h>
@ -138,7 +144,9 @@ typedef LPVOID (WINAPI *p_MapViewOfFile) (HANDLE, DWORD, DWORD, DWORD, SIZE_T);
#endif
#if defined (__unix__) || defined(__APPLE__) || defined (UNIXCOMMON)
#ifndef NOEXECINFO
#include <execinfo.h>
#endif
#include <time.h>
#define UNIXBACKTRACE
#endif
@ -269,13 +277,17 @@ UINT8 keyboard_started = false;
static void write_backtrace(INT32 signal)
{
int fd = -1;
#ifndef NOEXECINFO
size_t size;
#endif
time_t rawtime;
struct tm timeinfo;
ssize_t junk;
enum { BT_SIZE = 1024, STR_SIZE = 32 };
#ifndef NOEXECINFO
void *array[BT_SIZE];
#endif
char timestr[STR_SIZE];
const char *error = "An error occurred within SRB2! Send this stack trace to someone who can help!\n";
@ -308,12 +320,14 @@ static void write_backtrace(INT32 signal)
CRASHLOG_WRITE(strsignal(signal));
CRASHLOG_WRITE("\n"); // Newline for the signal name
#ifndef NOEXECINFO
CRASHLOG_STDERR_WRITE("\nBacktrace:\n");
// Flood the output and log with the backtrace
size = backtrace(array, BT_SIZE);
backtrace_symbols_fd(array, size, fd);
backtrace_symbols_fd(array, size, STDERR_FILENO);
#endif
CRASHLOG_WRITE("\n"); // Write another newline to the log so it looks nice :)
(void)junk;
@ -638,6 +652,7 @@ void I_GetConsoleEvents(void)
else if (tty_con.cursor < sizeof (tty_con.buffer))
{
// push regular character
ev.type = ev_text;
ev.key = tty_con.buffer[tty_con.cursor] = key;
tty_con.cursor++;
// print the current line (this is differential)
@ -2266,6 +2281,52 @@ void I_Sleep(UINT32 ms)
SDL_Delay(ms);
}
void I_SleepDuration(precise_t duration)
{
#if defined(__linux__) || defined(__FreeBSD__)
UINT64 precision = I_GetPrecisePrecision();
struct timespec ts = {
.tv_sec = duration / precision,
.tv_nsec = duration * 1000000000 / precision % 1000000000,
};
int status;
do status = clock_nanosleep(CLOCK_MONOTONIC, 0, &ts, &ts);
while (status == EINTR);
#else
UINT64 precision = I_GetPrecisePrecision();
INT32 sleepvalue = cv_sleep.value;
UINT64 delaygranularity;
precise_t cur;
precise_t dest;
{
double gran = round(((double)(precision / 1000) * sleepvalue * MIN_SLEEP_DURATION_MS));
delaygranularity = (UINT64)gran;
}
cur = I_GetPreciseTime();
dest = cur + duration;
// the reason this is not dest > cur is because the precise counter may wrap
// two's complement arithmetic is our friend here, though!
// e.g. cur 0xFFFFFFFFFFFFFFFE = -2, dest 0x0000000000000001 = 1
// 0x0000000000000001 - 0xFFFFFFFFFFFFFFFE = 3
while ((INT64)(dest - cur) > 0)
{
// If our cv_sleep value exceeds the remaining sleep duration, use the
// hard sleep function.
if (sleepvalue > 0 && (dest - cur) > delaygranularity)
{
I_Sleep(sleepvalue);
}
// Otherwise, this is a spinloop.
cur = I_GetPreciseTime();
}
#endif
}
#ifdef NEWSIGNALHANDLER
ATTRNORETURN static FUNCNORETURN void newsignalhandler_Warn(const char *pr)
{

43
src/sdl/i_video.c
View file

@ -382,10 +382,8 @@ static INT32 Impl_SDL_Scancode_To_Keycode(SDL_Scancode code)
return 0;
}
static boolean IgnoreMouse(void)
static boolean ShouldIgnoreMouse(void)
{
if (cv_alwaysgrabmouse.value)
return false;
if (menuactive)
return !M_MouseNeeded();
if (paused || con_destlines || chat_on)
@ -393,11 +391,20 @@ static boolean IgnoreMouse(void)
if (gamestate != GS_LEVEL && gamestate != GS_INTERMISSION &&
gamestate != GS_CONTINUING && gamestate != GS_CUTSCENE)
return true;
if (!mousegrabbedbylua)
return true;
return false;
}
static boolean ShouldGrabMouse(void)
{
if (cv_alwaysgrabmouse.value)
return true;
if (ShouldIgnoreMouse())
return false;
if (!mousegrabbedbylua)
return false;
return true;
}
static void SDLdoGrabMouse(void)
{
SDL_ShowCursor(SDL_DISABLE);
@ -424,7 +431,7 @@ void I_UpdateMouseGrab(void)
{
if (SDL_WasInit(SDL_INIT_VIDEO) == SDL_INIT_VIDEO && window != NULL
&& SDL_GetMouseFocus() == window && SDL_GetKeyboardFocus() == window
&& USE_MOUSEINPUT && !IgnoreMouse())
&& USE_MOUSEINPUT && ShouldGrabMouse())
SDLdoGrabMouse();
}
@ -640,7 +647,7 @@ static void Impl_HandleWindowEvent(SDL_WindowEvent evt)
}
//else firsttimeonmouse = SDL_FALSE;
if (USE_MOUSEINPUT && !IgnoreMouse())
if (USE_MOUSEINPUT && ShouldGrabMouse())
SDLdoGrabMouse();
}
else if (!mousefocus && !kbfocus)
@ -686,13 +693,26 @@ static void Impl_HandleKeyboardEvent(SDL_KeyboardEvent evt, Uint32 type)
if (event.key) D_PostEvent(&event);
}
static void Impl_HandleTextEvent(SDL_TextInputEvent evt)
{
event_t event;
event.type = ev_text;
if (evt.text[1] != '\0')
{
// limit ourselves to ASCII for now, we can add UTF-8 support later
return;
}
event.key = evt.text[0];
D_PostEvent(&event);
}
static void Impl_HandleMouseMotionEvent(SDL_MouseMotionEvent evt)
{
static boolean firstmove = true;
if (USE_MOUSEINPUT)
{
if ((SDL_GetMouseFocus() != window && SDL_GetKeyboardFocus() != window) || (IgnoreMouse() && !firstmove))
if ((SDL_GetMouseFocus() != window && SDL_GetKeyboardFocus() != window) || (!ShouldGrabMouse() && !firstmove))
{
SDLdoUngrabMouse();
firstmove = false;
@ -745,7 +765,7 @@ static void Impl_HandleMouseButtonEvent(SDL_MouseButtonEvent evt, Uint32 type)
// this apparently makes a mouse button down event but not a mouse button up event,
// resulting in whatever key was pressed down getting "stuck" if we don't ignore it.
// -- Monster Iestyn (28/05/18)
if (SDL_GetMouseFocus() != window || IgnoreMouse())
if (SDL_GetMouseFocus() != window || ShouldIgnoreMouse())
return;
/// \todo inputEvent.button.which
@ -934,6 +954,9 @@ void I_GetEvent(void)
case SDL_KEYDOWN:
Impl_HandleKeyboardEvent(evt.key, evt.type);
break;
case SDL_TEXTINPUT:
Impl_HandleTextEvent(evt.text);
break;
case SDL_MOUSEMOTION:
//if (!mouseMotionOnce)
Impl_HandleMouseMotionEvent(evt.motion);
@ -1127,7 +1150,7 @@ void I_StartupMouse(void)
}
else
firsttimeonmouse = SDL_FALSE;
if (cv_usemouse.value && !IgnoreMouse())
if (cv_usemouse.value && ShouldGrabMouse())
SDLdoGrabMouse();
else
SDLdoUngrabMouse();

2
src/sdl/macosx/Srb2mac.pbproj/project.pbxproj
View file

@ -2133,7 +2133,7 @@
INSTALL_PATH = "$(HOME)/Applications";
JAVA_COMPILER_DEBUGGING_SYMBOLS = NO;
OPTIMIZATION_CFLAGS = "-O2";
OTHER_CFLAGS = "-DMAC_ALERT -DUNIXCOMMON -DSDLMAIN -DHAVE_MIXER -DHAVE_PNG -D_BIG_ENDIAN -DSTDC_HEADERS -DSDL -Wall -Winline -fno-strict-aliasing";
OTHER_CFLAGS = "-DMAC_ALERT -DUNIXCOMMON -DSDLMAIN -DHAVE_MIXER -DHAVE_PNG -D_BIG_ENDIAN -DSTDC_HEADERS -DSDL -Wall -Winline -fno-strict-aliasing -fwrapv";
OTHER_REZFLAGS = "";
PREBINDING = NO;
PRODUCT_NAME = Srb2;

10
src/taglist.c
View file

@ -180,10 +180,10 @@ void Taggroup_Add (taggroup_t *garray[], const mtag_t tag, size_t id)
if (Taggroup_Find(group, id) != (size_t)-1)
return;
if (! in_bit_array(tags_available, tag))
if (! in_bit_array(tags_available, (UINT16)tag))
{
num_tags++;
set_bit_array(tags_available, tag);
set_bit_array(tags_available, (UINT16)tag);
}
// Create group if empty.
@ -220,10 +220,10 @@ static void Taggroup_Add_Init(taggroup_t *garray[], const mtag_t tag, size_t id)
group = garray[(UINT16)tag];
if (! in_bit_array(tags_available, tag))
if (! in_bit_array(tags_available, (UINT16)tag))
{
num_tags++;
set_bit_array(tags_available, tag);
set_bit_array(tags_available, (UINT16)tag);
}
// Create group if empty.
@ -271,7 +271,7 @@ void Taggroup_Remove (taggroup_t *garray[], const mtag_t tag, size_t id)
if (group->count == 1 && total_elements_with_tag(tag) == 1)
{
num_tags--;
unset_bit_array(tags_available, tag);
unset_bit_array(tags_available, (UINT16)tag);
}
// Strip away taggroup if no elements left.

39
src/v_video.c
View file

@ -1163,12 +1163,32 @@ void V_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 c)
{
UINT8 *dest;
const UINT8 *deststop;
UINT32 alphalevel = ((c & V_ALPHAMASK) >> V_ALPHASHIFT);
UINT32 blendmode = ((c & V_BLENDMASK) >> V_BLENDSHIFT);
UINT8 perplayershuffle = 0;
if (rendermode == render_none)
return;
v_translevel = NULL;
if (alphalevel || blendmode)
{
if (alphalevel == 10) // V_HUDTRANSHALF
alphalevel = hudminusalpha[st_translucency];
else if (alphalevel == 11) // V_HUDTRANS
alphalevel = 10 - st_translucency;
else if (alphalevel == 12) // V_HUDTRANSDOUBLE
alphalevel = hudplusalpha[st_translucency];
if (alphalevel >= 10)
return; // invis
if (alphalevel || blendmode)
v_translevel = R_GetBlendTable(blendmode+1, alphalevel);
}
#ifdef HWRENDER
//if (rendermode != render_soft && !con_startup) // Not this again
if (rendermode == render_opengl)
@ -1178,6 +1198,8 @@ void V_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 c)
}
#endif
if (splitscreen && (c & V_PERPLAYER))
{
fixed_t adjusty = ((c & V_NOSCALESTART) ? vid.height : BASEVIDHEIGHT)>>1;
@ -1312,8 +1334,21 @@ void V_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 c)
c &= 255;
for (;(--h >= 0) && dest < deststop; dest += vid.width)
memset(dest, c, w * vid.bpp);
// borrowing this from jimitia's new hud drawing functions rq
if (alphalevel)
{
v_translevel += c<<8;
for (;(--h >= 0) && dest < deststop; dest += vid.width)
{
for (x = 0; x < w; x++)
dest[x] = v_translevel[dest[x]];
}
}
else
{
for (;(--h >= 0) && dest < deststop; dest += vid.width)
memset(dest, c, w * vid.bpp);
}
}
#ifdef HWRENDER

8
src/w_wad.c
View file

@ -208,7 +208,7 @@ static void W_LoadDehackedLumpsPK3(UINT16 wadnum, boolean mainfile)
posStart = W_CheckNumForFullNamePK3("Init.lua", wadnum, 0);
if (posStart != INT16_MAX)
{
LUA_LoadLump(wadnum, posStart, true);
LUA_DoLump(wadnum, posStart, true);
}
else
{
@ -217,7 +217,7 @@ static void W_LoadDehackedLumpsPK3(UINT16 wadnum, boolean mainfile)
{
posEnd = W_CheckNumForFolderEndPK3("Lua/", wadnum, posStart);
for (; posStart < posEnd; posStart++)
LUA_LoadLump(wadnum, posStart, true);
LUA_DoLump(wadnum, posStart, true);
}
}
@ -250,7 +250,7 @@ static void W_LoadDehackedLumps(UINT16 wadnum, boolean mainfile)
lumpinfo_t *lump_p = wadfiles[wadnum]->lumpinfo;
for (lump = 0; lump < wadfiles[wadnum]->numlumps; lump++, lump_p++)
if (memcmp(lump_p->name,"LUA_",4)==0)
LUA_LoadLump(wadnum, lump, true);
LUA_DoLump(wadnum, lump, true);
}
{
@ -993,7 +993,7 @@ UINT16 W_InitFile(const char *filename, boolean mainfile, boolean startup)
DEH_LoadDehackedLumpPwad(numwadfiles - 1, 0, mainfile);
break;
case RET_LUA:
LUA_LoadLump(numwadfiles - 1, 0, true);
LUA_DoLump(numwadfiles - 1, 0, true);
break;
default:
break;