Compare commits

...
75 Commits
Author SHA1 Message Date
alufolie91 0da78ae3d1 Merge branch 'Saturn-Next' into retrySOCK 2026-11-19 15:46:21 +01:00
alufolie91 86976192f1 fix gl skydome "cap"
so turns out the texture coords for the dome cap were never initialized at all, which is what caused the weird "stripey" effect at times
just set it to the sky textures middle for the cap
2026-11-19 14:45:32 +01:00
alufolie91 67bac0aa88 fix zero division in HWR_SplitSprite
same fix as HWR_SplitWall
this may throw nan texture uv coords into gl which may be uncool
2026-11-19 14:44:52 +01:00
alufolie91 033e0cd416 match software slope contrast inversal in opengl 2026-11-19 14:44:48 +01:00
alufolie91 18a72d617d smol controller rumble tweaks
-Grow makes rumble twice as strong, while shrink halves its intensity, thought this be funny
-increase rumble length of first drift level slightly
-reduce rumble length of stairjank a little
- remove intensity clamps from ticker as G_PlayerDeviceRumble will already clamp it anyways
2026-11-19 14:44:42 +01:00
alufolie91 f0667895eb prefer statvfs over statfs for unix (from srb2classic) + other haiku stuff
should make I_GetDiskFreeSpace work on haiku
statvfs is the posix variant of statfs apparently so all nice there
2026-11-16 00:40:02 +01:00
alufolie91 b58bc02940 scale software vhs offset by udup
missed that when i added this oopsie
2026-11-16 00:05:00 +01:00
alufolie91 6b84c86197 fix vhs effect bars when rewinding
noticed while doing the shader thing
basically the effect is supposed to stack
but both calls being recursive, updated just the same bar positions, so both sets of bars would just draw over each other
this basically just like, keeps seperate positions for when rewind it true
this is probably how it was intended to work, otherwise that code makes not much sense
2026-11-15 01:26:57 +01:00
alufolie91 cc952dfd52 use software wall/slope contrast checks in gl paletterendering mode
simple enough change which should make this match up more, tho shouldnt be super different
2026-11-14 06:40:07 +01:00
alufolie91 063f94da8b fix slope contrast
missed a fix when ported it so the contrast direction was off by 90 degrees
also apparently i moved the software contrast part to never apply to fofs for some reason?
rechecked against the srb2 code for this and now properly matches up
2026-11-14 06:40:07 +01:00
alufolie91 457cae0ed9 adjust floor fudge for palette render
this significantly more matches software especially when drawing horizonlines
as gl was too dark in the distance compared to software
theres still some things left to recheck to better match software lighting (ex. wallcontrast) but too lazy atm
2026-11-14 06:40:07 +01:00
alufolie91 b990589e66 smol style fixes lua mobj and player lib 2026-11-14 06:40:07 +01:00
alufolie91 f029a2b7d8 Merge branch 'Saturn-Next' into retrySOCK 2026-11-12 20:54:24 +01:00
alufolie91 32bd5a02ec fix some smol style gripes in lua mobj and player lib 2026-11-12 20:46:01 +01:00
indev 546fae5110 Merge branch 'remove-lua-udata-lib' into Saturn-Next 2026-11-12 22:43:23 +03:00
alufolie91 ee4c060cc8 add rumble type for wallbonks
yoinked from blan
will also look into drift release rumble, but we have that per lua in sg anyways
2026-11-12 20:31:27 +01:00
alufolie91 ebd5b86e87 use screen_width/height for scr_resolution uniform
those are meant for this kinda crap
2026-11-12 19:39:50 +01:00
alufolie91 9321036049 further simplify downsample stuff
man idk why i even did the whole desktop res shit
somehow kept forgetting we should just check against the drawable/window size as it determines the main framebuffer size
so we just can use SDL_GetWindowSize and get rid of all the other crap
2026-11-11 12:26:53 +01:00
alufolie91 12f43ae504 move horizonline stuff back to plane preprocessor
well "back" we still had it there, but the subsector marking logic can just be there
was kinda too lazy before to do this lul
saves some time as we dont need to go thru all subsectors again at mapload, which there can be many of
2026-11-11 12:25:20 +01:00
alufolie91 cfc94c0f9e fix horizonlines on fofs in opengl
not super cool but seems to work just fine
the new subsector flag may even improve performance in some cases since the horizonspecial check seems to mess up the branch predictor often lol
2026-11-11 00:55:41 +01:00
indev 148bd1ab4d Remove lua_udatalib, and use Lua_CreateFieldTable for mobj and player instead
Need to test this a little but in theory, udatalib doesn't really give
much benefits, and using fields table and enum is safer than messing
with offsetof
2026-11-10 21:53:23 +03:00
alufolie91 3385df4c7e allow gl fbo to be enabled at all times
not just when downsampling
as this may improve performance in some cases
2026-11-10 17:48:30 +01:00
alufolie91 561f871e61 fix downsample state not refreshing in the right place
needs to be done before refreshing the surface, as OglSdlSurface needs to determine the state to toggle the fbo
2026-11-10 17:48:27 +01:00
alufolie91 bffafa0540 make screen fbo msaa compatible
quite a mess but "works"
the reason this didnt work before was
i mostly tried doing this per multisample textures which you cant really copy from
now we do it per color rbo which you also cant really copy from, but is the recommended way
so now each time we try to copy from the screen (screentextures, screenshots, etc.) we blit the msaa fbo into the normal fbo so we can copy from that
its probably a little slow, but cant really do much about it besides getting rid of screen textures and replacing them with more fbo logic.....
2026-11-10 17:27:11 +01:00
alufolie91 473619ab66 add I_CheckAboveDesktopRes
forgor i added this originally for the resolution list rework stuff so was missing here lul
2026-11-09 20:51:02 +01:00
alufolie91 d75638cbfc remove alpha to coverage (a2c) support
while this can look nice in some cases with msaa, it has the effect that everything transclucent is twice as translucent as it should be besides just being a kinda confusing option for almost everyone
so just delet it and simplify code
2026-11-09 20:26:50 +01:00
alufolie91 f09b591989 set screentexture filtermode to linear when downsampling
nearest-neighbour filtering is good from upscaling from a lower resolution, but will produce super ugly mixels and shimmering when downsampling from a higher resolution
2026-11-09 20:19:14 +01:00
alufolie91 79d75aa08d simplify gl "downsampling" stuff
still kinda meh but whatever, shit works
2026-11-09 20:19:08 +01:00
alufolie91 486560d79e fix typo
:blobcatpats:
2026-11-09 20:18:03 +01:00
alufolie91 953b0c8f94 opengl: make stencil attachment for fbo with EXT a requierement
while not compeletely needed, we use the stencil buffer for some stuff, so dont really feel like having to deal with potential issues here
besides, probably any gpu in almost the last 2 decades should support this and even gl3.0 anyways, so this is just bloat we do not need
2026-11-09 20:17:59 +01:00
alufolie91 5639e872f1 delet this
cant remember what this was used for lul
2026-11-09 20:17:51 +01:00
alufolie91 80da0fc538 fix G_GetDemoDate
forgor to change this back oopsie
2026-11-07 13:52:29 +01:00
alufolie91 014126b57d Merge branch 'origin/polyholes' into Saturn-Next 2026-11-06 17:21:19 +01:00
alufolie91 d7b150a04f (hopefully) make replay date stuff more thread safe
dont do locale stuff from thread, use localtime_r && localtime_r as localtime is not threadsafe either
G_GetDemoDate returns malloc´d buffer again, tho not strictly necessary
also, fix dates not always being initialized in all cases and type issue with G_GetCreationTime
2026-11-06 16:14:39 +01:00
alufolie91 5751f9b29b fix windoze compile
windoze does not have threads.h and thread_local is only a keyword per c23....
thanks michealslop....
2026-11-05 15:55:22 +01:00
alufolie91 9a100439df Merge branch 'Saturn-Next' into retrySOCK 2026-11-05 15:40:28 +01:00
alufolie91 1a29bd1e63 Merge branch 'Saturn-Next' into polyholes 2026-11-05 15:38:42 +01:00
alufolie91 e54b6a780d "fix" skywalls on hadal trench and candy lake
this whole sky handling is just incredibly stupid and wouldve been such an easy fix, but here we go
this is just more stupid hacks but i really dont feel bad here since the code already hacked around a bunch of shit
just hoping this wont cause any issues on some maps and needs testing
sigh
2026-11-05 15:38:11 +01:00
alufolie91 c1a0b97c54 add checks for missing bsp lumps
not sure why there werent any, the other map lumps have those, and a corrupted file may have those missing also which would just crash instead of telling you wtf is wrong
2026-11-05 15:38:07 +01:00
alufolie91 b8aaf63b20 use "rawlinedef" when checking for seg issues
smth smth byte order or whatever but is consistent with the rest of the code anyways
2026-11-05 15:38:04 +01:00
alufolie91 d43b60ad83 fix blendmodes and line translucency on polyobject sides in gl
this is also how vanilla kart handled this code eitherways
2026-11-05 15:38:00 +01:00
alufolie91 cb5d3ab4e1 add compile flag for building with thread sanitizer
indev noticed thats a thing that exists
wouldve been quite useful a bunch of times before lol
also some fixes for the other sanitizer flags
2026-11-04 01:42:11 +01:00
alufolie91 eba1cfb94d remove "flatcheck" from HWR_PrecacheLevelFlats
in practice this did nothing really
would be more useful for encore but that aint working for us so whatever
2026-11-04 01:38:30 +01:00
alufolie91 f5030e6a3c fix some holes and cracks in the gl renderer on some maps
hopefully...
this is adapted from the large refactor but that was slow as shit
needs testing to see if this messes with something
2026-11-04 00:27:22 +01:00
alufolie91 3b37f85024 Merge branch 'Saturn-Next' into retrySOCK 2026-10-16 15:24:18 +02:00
alufolie91 27a65ef973 Merge branch 'Saturn-Next' into retrySOCK 2026-09-27 17:54:06 +02:00
alufolie91 ffa9b2fa9a Merge branch 'Saturn-Next' into retrySOCK 2026-09-23 19:41:27 +02:00
alufolie91 ab9e0f923e Merge branch 'Saturn-Next' into retrySOCK 2026-09-18 18:31:42 +02:00
alufolie91 8bf3953b4a Merge branch 'Saturn-Next' into retrySOCK 2026-09-07 19:30:21 +02:00
alufolie91 44ef42cf84 start retry attempt prints from 1 not 0 2026-08-24 14:02:47 +02:00
alufolie91 746035bfea add missing line breaks to sock_send prints 2026-08-24 14:01:00 +02:00
alufolie91 70bc9879b3 Merge branch 'Saturn-Next' into retrySOCK 2026-08-24 13:57:25 +02:00
alufolie91 0e6a794a84 Merge branch 'Saturn-Next' into retrySOCK 2026-08-21 16:24:10 +02:00
alufolie91 4eccf40a0a Merge branch 'Saturn-Next' into retrySOCK 2026-08-07 16:38:50 +02:00
alufolie91 e3fd46297a Merge branch 'Saturn-Next' into retrySOCK 2026-08-01 16:29:40 +02:00
alufolie91 4c2e119385 Merge branch 'Saturn-Next' into retrySOCK 2026-07-24 16:22:36 +02:00
alufolie91 229a6a161e Merge branch 'Saturn-Next' into retrySOCK 2026-07-21 16:11:43 +02:00
alufolie91 1b2e4a1acc Merge branch 'Saturn-Next' into retrySOCK 2026-07-20 16:45:09 +02:00
alufolie91 2e6d49fcd6 Merge remote-tracking branch 'origin/Saturn-Next' into retrySOCK 2026-07-20 11:47:57 +02:00
alufolie91 7a8c66781b Merge branch 'Saturn-Next' into retrySOCK 2026-07-10 20:10:39 +02:00
alufolie91 c877226bfe Merge branch 'Saturn-Next' into retrySOCK 2026-07-08 18:57:24 +02:00
alufolie91 ac3c8b1d25 Merge branch 'Saturn-Next' into retrySOCK 2026-07-02 21:27:14 +02:00
alufolie91 feeba45b0d Merge branch 'Saturn-Next' into retrySOCK 2026-06-29 17:28:41 +02:00
alufolie91 06f3d2c91b Merge branch 'Saturn-Next' into retrySOCK 2026-06-28 22:58:25 +02:00
alufolie91 332fadc823 Merge branch 'Saturn-Next' into retrySOCK 2026-06-28 19:17:09 +02:00
alufolie91 39dc1b85e3 Merge branch 'Saturn-Next' into retrySOCK 2026-06-28 16:28:33 +02:00
alufolie91 5b2413444f Merge branch 'Saturn-Next' into retrySOCK 2026-06-27 18:53:02 +02:00
alufolie91 7855b2ed95 Merge branch 'Saturn-Next' into retrySOCK 2026-06-22 21:14:19 +02:00
alufolie91 caebe62ddb Merge branch 'Saturn-Next' into retrySOCK 2026-06-15 17:14:08 +02:00
alufolie91 9de285caac use sizeu1 instead of %lu
windoze.......
2026-06-13 13:41:00 +02:00
alufolie91 9bb4420ad3 Merge branch 'Saturn-Next' into retrySOCK 2026-06-13 13:37:44 +02:00
alufolie91 8dc3d870a1 Merge branch 'Saturn-Next' into retrySOCK 2026-06-12 22:08:53 +02:00
alufolie91 158546bd73 Merge remote-tracking branch 'origin/Saturn-Next' into retrySOCK 2026-06-12 21:21:33 +02:00
alufolie91 b89a3f1017 Merge branch 'Saturn-Next' into retrySOCK 2026-06-08 16:58:06 +02:00
alufolie91 f2e355a5a8 SOCK_Send: retry failed connections
very sketchy since idk networking for shit
but seems to work so far?
2026-06-05 13:21:26 +02:00
38 changed files with 2714 additions and 2018 deletions

No files matched your search

+2 -2
View File
@@ -246,6 +246,8 @@ set(SRB2_CONFIG_ASAN OFF CACHE BOOL
"Compile with AddressSanitizer (libasan).") "Compile with AddressSanitizer (libasan).")
set(SRB2_CONFIG_UBSAN OFF CACHE BOOL set(SRB2_CONFIG_UBSAN OFF CACHE BOOL
"Compile with UndefinedBehaviorSanitizer (libubsan).") "Compile with UndefinedBehaviorSanitizer (libubsan).")
set(SRB2_CONFIG_TSAN OFF CACHE BOOL
"Compile with ThreadSanitizer (libtsan).")
set(SRB2_CONFIG_MUMBLE ON CACHE BOOL set(SRB2_CONFIG_MUMBLE ON CACHE BOOL
"Enable Mumble support") "Enable Mumble support")
@@ -290,7 +292,6 @@ if(${SRB2_CONFIG_HAVE_BLUA})
lua_script.c lua_script.c
lua_skinlib.c lua_skinlib.c
lua_thinkerlib.c lua_thinkerlib.c
lua_udatalib.c
lua_glib.c lua_glib.c
) )
set(SRB2_LUA_HEADERS set(SRB2_LUA_HEADERS
@@ -300,7 +301,6 @@ if(${SRB2_CONFIG_HAVE_BLUA})
lua_profile.h lua_profile.h
lua_libs.h lua_libs.h
lua_script.h lua_script.h
lua_udatalib.h
lua_glib.h lua_glib.h
) )
+18 -6
View File
@@ -61,7 +61,6 @@
# NOPOSTPROCESSING=1 - ? # NOPOSTPROCESSING=1 - ?
# MOBJCONSISTANCY=1 - ?? # MOBJCONSISTANCY=1 - ??
# PACKETDROP=1 - ?? # PACKETDROP=1 - ??
# NOEXECINFO=1 - Disable stack trace dump support
# DEBUGMODE=1 - Enable various debugging capabilities. # DEBUGMODE=1 - Enable various debugging capabilities.
# Also disables optimizations. # Also disables optimizations.
# #
@@ -75,6 +74,7 @@
# PROFILEMODE=1 - Enable performance profiling (gprof). # PROFILEMODE=1 - Enable performance profiling (gprof).
# USEASAN=1 - Enable building with Address Sanitizer. # USEASAN=1 - Enable building with Address Sanitizer.
# USEUBSAN=1 - Enable building with Undefined Behavior Sanitizer. # USEUBSAN=1 - Enable building with Undefined Behavior Sanitizer.
# USETSAN=1 - Enable building with Thread Sanitizer.
# NOLIBBACKTRACE=1 - Disable using Libbacktrace for crashlog traces. # NOLIBBACKTRACE=1 - Disable using Libbacktrace for crashlog traces.
# #
# General flags for building: # General flags for building:
@@ -261,23 +261,35 @@ debug_opts=-D_DEBUG
else # build a normal optimized version else # build a normal optimized version
debug_opts=-DNDEBUG debug_opts=-DNDEBUG
opts+=-O3 opts+=-O3
ifndef NOLTO
# compile with LTO
opts+=-flto=auto
libs+=-flto=auto
endif
endif endif
ifdef USEASAN ifdef USEASAN
# compile with asan # compile with asan
opts+=-O1 -fsanitize=address -fno-omit-frame-pointer -fno-common opts+=-O1 -fsanitize=address -fno-omit-frame-pointer -fno-common
libs+=-fsanitize=address libs+=-fsanitize=address
NOLTO=1
endif endif
ifdef USEUBSAN ifdef USEUBSAN
# compile with ubsan # compile with ubsan
opts+=-O1 -fsanitize=undefined -fno-omit-frame-pointer opts+=-O1 -fsanitize=undefined -fno-omit-frame-pointer
libs+=-fsanitize=undefined libs+=-fsanitize=undefined
NOLTO=1
endif
ifdef USETSAN
# compile with tsan
opts+=-O1 -fsanitize=thread -fno-omit-frame-pointer
libs+=-fsanitize=thread
NOLTO=1
endif
ifndef DEBUGMODE
ifndef NOLTO
# compile with LTO
opts+=-flto=auto
libs+=-flto=auto
endif
endif endif
ifdef USEJEMALLOC ifdef USEJEMALLOC
-2
View File
@@ -11,8 +11,6 @@ DEDICATED?=0
endif endif
endif endif
NOEXECINFO=1
ifeq (${SDL},1) ifeq (${SDL},1)
EXENAME?=srb2haiku EXENAME?=srb2haiku
else ifeq (${DEDICATED},1) else ifeq (${DEDICATED},1)
-1
View File
@@ -97,6 +97,5 @@ lua_playerlib.c
lua_script.c lua_script.c
lua_skinlib.c lua_skinlib.c
lua_thinkerlib.c lua_thinkerlib.c
lua_udatalib.c
lua_glib.c lua_glib.c
lua_profile.cpp lua_profile.cpp
+2
View File
@@ -1043,6 +1043,8 @@ void D_RegisterClientCommands(void)
CV_RegisterVar(&cv_rumble[i]); CV_RegisterVar(&cv_rumble[i]);
CV_RegisterVar(&cv_rumble_strength[i]); CV_RegisterVar(&cv_rumble_strength[i]);
CV_RegisterVar(&cv_rumble_wallbonk[i]);
CV_RegisterVar(&cv_rumble_spinout[i]); CV_RegisterVar(&cv_rumble_spinout[i]);
CV_RegisterVar(&cv_rumble_sneakerboost[i]); CV_RegisterVar(&cv_rumble_sneakerboost[i]);
CV_RegisterVar(&cv_rumble_offroad[i]); CV_RegisterVar(&cv_rumble_offroad[i]);
+8 -3
View File
@@ -119,20 +119,25 @@ target_compile_definitions(SRB2SDL2 PRIVATE
-DHAVE_THREADS -DHAVE_THREADS
) )
if(SRB2_CONFIG_LTO AND NOT SRB2_CONFIG_DEBUGMODE) if(SRB2_CONFIG_LTO AND NOT SRB2_CONFIG_DEBUGMODE AND NOT SRB2_CONFIG_ASAN AND NOT SRB2_CONFIG_UBSAN AND NOT SRB2_CONFIG_TSAN)
set_property(TARGET SRB2SDL2 PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE) set_property(TARGET SRB2SDL2 PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
endif() endif()
if(SRB2_CONFIG_ASAN) if(SRB2_CONFIG_ASAN)
target_compile_options(SRB2SDL2 PRIVATE -fsanitize=address) target_compile_options(SRB2SDL2 PRIVATE -O1 -fsanitize=address -fno-omit-frame-pointer -fno-common)
target_link_options(SRB2SDL2 PRIVATE -fsanitize=address) target_link_options(SRB2SDL2 PRIVATE -fsanitize=address)
endif() endif()
if(SRB2_CONFIG_UBSAN) if(SRB2_CONFIG_UBSAN)
target_compile_options(SRB2SDL2 PRIVATE -fsanitize=undefined) target_compile_options(SRB2SDL2 PRIVATE -O1 -fsanitize=undefined -fno-omit-frame-pointer)
target_link_options(SRB2SDL2 PRIVATE -fsanitize=undefined) target_link_options(SRB2SDL2 PRIVATE -fsanitize=undefined)
endif() endif()
if(SRB2_CONFIG_TSAN)
target_compile_options(SRB2SDL2 PRIVATE -O1 -fsanitize=thread -fno-omit-frame-pointer)
target_link_options(SRB2SDL2 PRIVATE -fsanitize=thread)
endif()
## strip debug symbols into separate file when using gcc ## strip debug symbols into separate file when using gcc
# if(CMAKE_COMPILER_IS_GNUCC) # if(CMAKE_COMPILER_IS_GNUCC)
# if(${CMAKE_BUILD_TYPE} MATCHES Debug) # if(${CMAKE_BUILD_TYPE} MATCHES Debug)
+13 -12
View File
@@ -64,10 +64,9 @@ typedef LPVOID (WINAPI *p_MapViewOfFile) (HANDLE, DWORD, DWORD, DWORD, SIZE_T);
#include <conio.h> #include <conio.h>
#endif #endif
#if defined (__unix__) || defined(__APPLE__) || (defined (UNIXCOMMON) && !defined (__HAIKU__)) #if defined (__unix__) || defined(__APPLE__) || defined (UNIXCOMMON)
#include <time.h> #if defined (__linux__) || defined (__HAIKU__)
#if defined (__linux__) #include <sys/statvfs.h>
#include <sys/vfs.h>
#elif defined(__APPLE__) #elif defined(__APPLE__)
#include <sys/param.h> #include <sys/param.h>
#include <sys/mount.h> #include <sys/mount.h>
@@ -75,6 +74,7 @@ typedef LPVOID (WINAPI *p_MapViewOfFile) (HANDLE, DWORD, DWORD, DWORD, SIZE_T);
#include <sys/sysctl.h> #include <sys/sysctl.h>
#include <mach/mach.h> #include <mach/mach.h>
#else #else
#include <sys/statvfs.h>
#include <sys/param.h> #include <sys/param.h>
#include <sys/mount.h> #include <sys/mount.h>
/*For meminfo*/ /*For meminfo*/
@@ -87,7 +87,7 @@ typedef LPVOID (WINAPI *p_MapViewOfFile) (HANDLE, DWORD, DWORD, DWORD, SIZE_T);
#endif #endif
#endif #endif
#if defined (__linux__) || (defined (UNIXCOMMON) && !defined (__HAIKU__)) #if defined (__linux__) || defined (UNIXCOMMON)
#ifndef NOTERMIOS #ifndef NOTERMIOS
#include <termios.h> #include <termios.h>
#include <sys/ioctl.h> // ioctl #include <sys/ioctl.h> // ioctl
@@ -99,8 +99,10 @@ typedef LPVOID (WINAPI *p_MapViewOfFile) (HANDLE, DWORD, DWORD, DWORD, SIZE_T);
#include <poll.h> #include <poll.h>
#include <errno.h> #include <errno.h>
#include <sys/wait.h> #include <sys/wait.h>
#ifndef __HAIKU__ // haiku's crash dialog is just objectively better
#define NEWSIGNALHANDLER #define NEWSIGNALHANDLER
#endif #endif
#endif
#ifndef NOMUMBLE #ifndef NOMUMBLE
#ifdef __linux__ // need -lrt #ifdef __linux__ // need -lrt
@@ -131,7 +133,9 @@ typedef LPVOID (WINAPI *p_MapViewOfFile) (HANDLE, DWORD, DWORD, DWORD, SIZE_T);
#include <errno.h> #include <errno.h>
#endif #endif
#if defined (__unix__) || defined(__APPLE__) || defined (UNIXCOMMON)
#include <time.h> #include <time.h>
#endif
/// Locations to directly check for srb2.srb in /// Locations to directly check for srb2.srb in
const char *wadDefaultPaths[] = { const char *wadDefaultPaths[] = {
@@ -1688,6 +1692,7 @@ void I_ShutdownSystem(void)
for (c = MAX_QUIT_FUNCS-1; c >= 0; c--) for (c = MAX_QUIT_FUNCS-1; c >= 0; c--)
if (quit_funcs[c]) if (quit_funcs[c])
(*quit_funcs[c])(); (*quit_funcs[c])();
#ifdef LOGMESSAGES #ifdef LOGMESSAGES
if (logstream) if (logstream)
{ {
@@ -1704,18 +1709,13 @@ void I_ShutdownSystem(void)
void I_GetDiskFreeSpace(INT64 *freespace) void I_GetDiskFreeSpace(INT64 *freespace)
{ {
#if defined (__unix__) || defined(__APPLE__) || defined (UNIXCOMMON) #if defined (__unix__) || defined(__APPLE__) || defined (UNIXCOMMON)
#if defined (SOLARIS) || defined (__HAIKU__) struct statvfs stfs;
*freespace = INT32_MAX; if (statvfs(srb2home, &stfs) == -1)
return;
#else // Both Linux and BSD have this, apparently.
struct statfs stfs;
if (statfs(".", &stfs) == -1)
{ {
*freespace = INT32_MAX; *freespace = INT32_MAX;
return; return;
} }
*freespace = stfs.f_bavail * stfs.f_bsize; *freespace = stfs.f_bavail * stfs.f_bsize;
#endif
#elif defined (_WIN32) #elif defined (_WIN32)
static p_GetDiskFreeSpaceExA pfnGetDiskFreeSpaceEx = NULL; static p_GetDiskFreeSpaceExA pfnGetDiskFreeSpaceEx = NULL;
static boolean testwin95 = false; static boolean testwin95 = false;
@@ -1726,6 +1726,7 @@ void I_GetDiskFreeSpace(INT64 *freespace)
pfnGetDiskFreeSpaceEx = (p_GetDiskFreeSpaceExA)(LPVOID)GetProcAddress(GetModuleHandleA("kernel32.dll"), "GetDiskFreeSpaceExA"); pfnGetDiskFreeSpaceEx = (p_GetDiskFreeSpaceExA)(LPVOID)GetProcAddress(GetModuleHandleA("kernel32.dll"), "GetDiskFreeSpaceExA");
testwin95 = true; testwin95 = true;
} }
if (pfnGetDiskFreeSpaceEx) if (pfnGetDiskFreeSpaceEx)
{ {
if (pfnGetDiskFreeSpaceEx(NULL, &lfreespace, &usedbytes, NULL)) if (pfnGetDiskFreeSpaceEx(NULL, &lfreespace, &usedbytes, NULL))
+27 -58
View File
@@ -63,7 +63,6 @@
// for replay dates // for replay dates
#include <time.h> #include <time.h>
#include <locale.h>
// menu demo things // menu demo things
UINT32 demoDelayTime = 15*TICRATE; UINT32 demoDelayTime = 15*TICRATE;
@@ -2387,7 +2386,9 @@ void G_LoadDemoInfo(menudemo_t *pdemo)
#if defined (_WIN32) #if defined (_WIN32)
// return the file creation time // return the file creation time
// useful for demos that were renamed // useful for demos that were renamed
static long G_GetCreationTime(char *filepath) // windows only, as file creation times are
// very unreliable (or non existant depending on fs) on linux
static time_t G_GetCreationTime(char *filepath)
{ {
struct stat fileinfo; struct stat fileinfo;
@@ -2398,35 +2399,24 @@ static long G_GetCreationTime(char *filepath)
} }
#endif #endif
static char *G_GetDemoDate(menudemo_t *pdemo) static char *G_GetDemoDate(menudemo_t *pdemo, const char *dateformat)
{ {
char *endPos = NULL; char *endPos = NULL;
static char datetime[11]; char *datetime;
time_t file_time = 0; time_t file_time = 0;
const char *format = NULL; struct tm tm_buf;
struct tm *tm_buf = NULL;
CLEANUP(pfree) char *filename = NULL; CLEANUP(pfree) char *filename = NULL;
// get le filepath // get le filepath
filename = strdup(pdemo->filepath); filename = strdup(pdemo->filepath);
if (!filename) if (!filename)
{
#if defined (_WIN32)
// if we cant get a filename try just getting the file creation time
file_time = G_GetCreationTime(pdemo->filepath);
goto skipfilenametime;
#else
return NULL; return NULL;
#endif
}
// get the actual filename Zzz... // get the actual filename Zzz...
nameonly(filename); nameonly(filename);
// the first 10 characters of a replay name usually is a unix timestamp // the first 10 characters of a replay name is a unix timestamp
// not long enough to contain a valid timestamp
if (strlen(filename) < 10) if (strlen(filename) < 10)
{ {
#if defined (_WIN32) #if defined (_WIN32)
@@ -2458,67 +2448,49 @@ static char *G_GetDemoDate(menudemo_t *pdemo)
#endif #endif
} }
#if defined (_WIN32)
skipfilenametime:
#endif
// then throw it into localtime to get an actual human readable format lmao // then throw it into localtime to get an actual human readable format lmao
tm_buf = localtime(&file_time); #if defined(_WIN32)
skipfilenametime:
// cant believe we ended up in 1970 if ((localtime_s(&tm_buf, &file_time) != 0) ||
if (tm_buf == NULL || tm_buf->tm_year <= 110) (tm_buf.tm_year <= 110)) // cant believe we ended up in 1970
{ {
#if defined (_WIN32)
// uh ohh, we got an invalid time // uh ohh, we got an invalid time
// try one more time getting the creation time // try one more time getting the creation time
file_time = G_GetCreationTime(pdemo->filepath); file_time = G_GetCreationTime(pdemo->filepath);
tm_buf = localtime(&file_time);
if (tm_buf == NULL || tm_buf->tm_year <= 110) if ((localtime_s(&tm_buf, &file_time) != 0) ||
(tm_buf.tm_year <= 110))
return NULL; return NULL;
}
goto gotcreationtime;
#else #else
if ((localtime_r(&file_time, &tm_buf) == NULL) ||
(tm_buf.tm_year <= 110)) // cant believe we ended up in 1970
return NULL; return NULL;
#endif #endif
}
#if defined (_WIN32) datetime = malloc(sizeof(pdemo->date)); // mallocma balls
gotcreationtime:
#endif
// US ppl are special (: // no mallocma balls... :c
if (cv_demodateformat.value == 2) if (!datetime)
format = "%m.%d.%Y"; return NULL;
else if (cv_demodateformat.value == 1)
format = "%d.%m.%Y";
else
{
const char *locale = setlocale(LC_TIME, NULL);
if (locale == NULL) if (strftime(datetime, sizeof(pdemo->date), dateformat, &tm_buf) == 0)
format = "%d.%m.%Y"; // fallback to non US format
else if (strstr(locale, "en_US"))
format = "%m.%d.%Y";
else
format = "%d.%m.%Y";
}
if (strftime(datetime, sizeof(datetime), format, tm_buf) == 0)
{ {
free(datetime);
return NULL; return NULL;
} }
return datetime; return datetime;
} }
void G_LoadDemoTitle(menudemo_t *pdemo) void G_LoadDemoTitle(menudemo_t *pdemo, const char *dateformat)
{ {
UINT8 infobuffer[96], *info_p; UINT8 infobuffer[96], *info_p;
UINT16 pdemoversion; UINT16 pdemoversion;
char *demodate = NULL;
size_t count; size_t count;
memset(pdemo->date, 0, sizeof(pdemo->date));
FILE *handle = fopen(pdemo->filepath, "rb"); FILE *handle = fopen(pdemo->filepath, "rb");
if (!handle) if (!handle)
@@ -2546,8 +2518,6 @@ void G_LoadDemoTitle(menudemo_t *pdemo)
pdemoversion = READUINT16(info_p); pdemoversion = READUINT16(info_p);
memset(pdemo->date, 0, sizeof(pdemo->date));
switch (pdemoversion) switch (pdemoversion)
{ {
case DEMOVERSION: // latest always supported case DEMOVERSION: // latest always supported
@@ -2555,13 +2525,12 @@ void G_LoadDemoTitle(menudemo_t *pdemo)
memcpy(pdemo->title, info_p, 64); memcpy(pdemo->title, info_p, 64);
// demo date // demo date
demodate = G_GetDemoDate(pdemo); char *demodate = G_GetDemoDate(pdemo, dateformat);
if (demodate) if (demodate)
{ {
strlcpy(pdemo->date, demodate, sizeof(pdemo->date)); strlcpy(pdemo->date, demodate, sizeof(pdemo->date));
free(demodate);
} }
break; break;
#ifdef DEMO_COMPAT_100 #ifdef DEMO_COMPAT_100
case 0x0001: case 0x0001:
+1 -1
View File
@@ -98,7 +98,7 @@ void G_SetDemoTime(UINT32 ptime, UINT32 plap);
UINT8 G_CmpDemoTime(char *oldname, char *newname); UINT8 G_CmpDemoTime(char *oldname, char *newname);
void G_LoadDemoInfo(menudemo_t *pdemo); void G_LoadDemoInfo(menudemo_t *pdemo);
void G_LoadDemoTitle(menudemo_t *pdemo); // For use in replay search feature void G_LoadDemoTitle(menudemo_t *pdemo, const char *dateformat); // For use in replay search feature
void G_DeferedPlayDemo(const char *demo); void G_DeferedPlayDemo(const char *demo);
typedef enum typedef enum
+65 -71
View File
@@ -17,14 +17,9 @@
#include "g_game.h" #include "g_game.h"
#include "keys.h" #include "keys.h"
#include "hu_stuff.h" // need HUFONT start & end #include "hu_stuff.h" // need HUFONT start & end
#include "d_net.h"
#include "console.h" #include "console.h"
#include "m_menu.h"
#include "i_system.h" #include "i_system.h"
#include "i_video.h"
#include "r_draw.h"
#include "v_video.h" #include "v_video.h"
#define MAXMOUSESENSITIVITY 100 // sensitivity steps #define MAXMOUSESENSITIVITY 100 // sensitivity steps
@@ -36,10 +31,11 @@ static CV_PossibleValue_t turnsmooth_cons_t[] = {{2, "Slow"}, {1, "Fast"}, {0, "
// mouse values are used once // mouse values are used once
consvar_t cv_mousexsens = {"mousexsens", "20", CV_SAVE, mousesens_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_mousexsens = {"mousexsens", "20", CV_SAVE, mousesens_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_mouseysens = {"mouseysens", "20", CV_SAVE, mousesens_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_mouseysens = {"mouseysens", "20", CV_SAVE, mousesens_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_controlperkey = {"controlperkey", "One", CV_SAVE, onecontrolperkey_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_controlperkey = {"controlperkey", "One", CV_SAVE, onecontrolperkey_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_turnsmooth[MAXSPLITSCREENPLAYERS] = { consvar_t cv_turnsmooth[MAXSPLITSCREENPLAYERS] = {
{"turnsmoothing", "Slow", CV_SAVE, turnsmooth_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}, {"turnsmoothing", "Slow", CV_SAVE, turnsmooth_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL},
{"turnsmoothing2", "Slow", CV_SAVE, turnsmooth_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}, {"turnsmoothing2", "Slow", CV_SAVE, turnsmooth_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL},
{"turnsmoothing3", "Slow", CV_SAVE, turnsmooth_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}, {"turnsmoothing3", "Slow", CV_SAVE, turnsmooth_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL},
{"turnsmoothing4", "Slow", CV_SAVE, turnsmooth_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL} {"turnsmoothing4", "Slow", CV_SAVE, turnsmooth_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}
@@ -81,6 +77,7 @@ consvar_t cv_rumble_##type [MAXSPLITSCREENPLAYERS] = {\
{"rumble4_" #type, "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}\ {"rumble4_" #type, "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}\
}; };
IMPL_RUMBLE_TYPE(wallbonk);
IMPL_RUMBLE_TYPE(spinout); IMPL_RUMBLE_TYPE(spinout);
IMPL_RUMBLE_TYPE(sneakerboost); IMPL_RUMBLE_TYPE(sneakerboost);
IMPL_RUMBLE_TYPE(offroad); IMPL_RUMBLE_TYPE(offroad);
@@ -89,7 +86,6 @@ IMPL_RUMBLE_TYPE(stairjank);
IMPL_RUMBLE_TYPE(brakedrift); IMPL_RUMBLE_TYPE(brakedrift);
IMPL_RUMBLE_TYPE(driftcharge); IMPL_RUMBLE_TYPE(driftcharge);
static CV_PossibleValue_t gamepadled_cons_t[] = {{0, "Off"}, {1, "Skincolor"}, {2, "Mobjcolor"}, {0, NULL}}; static CV_PossibleValue_t gamepadled_cons_t[] = {{0, "Off"}, {1, "Skincolor"}, {2, "Mobjcolor"}, {0, NULL}};
consvar_t cv_gamepadled[MAXSPLITSCREENPLAYERS] = { consvar_t cv_gamepadled[MAXSPLITSCREENPLAYERS] = {
{"gamepadled", "Skincolor", CV_SAVE|CV_CALL|CV_NOINIT, gamepadled_cons_t, led_off_handle, 0, NULL, NULL, 0, 0, NULL}, {"gamepadled", "Skincolor", CV_SAVE|CV_CALL|CV_NOINIT, gamepadled_cons_t, led_off_handle, 0, NULL, NULL, 0, 0, NULL},
@@ -195,7 +191,6 @@ void G_MapEventsToControls(event_t *ev)
{ {
CONS_Debug(DBG_GAMELOGIC, "Bad downkey input %d\n",ev->data1); CONS_Debug(DBG_GAMELOGIC, "Bad downkey input %d\n",ev->data1);
} }
#endif #endif
break; break;
@@ -951,16 +946,15 @@ void G_SetPlayerGamepadIndicatorColor(INT32 playernum, UINT8 color)
I_Assert(playernum >= 0 && playernum < MAXSPLITSCREENPLAYERS); I_Assert(playernum >= 0 && playernum < MAXSPLITSCREENPLAYERS);
if (cv_gamepadled[playernum].value == 0 || (window_notinfocus && cv_gamepadledifunfocused.value == 0) if (cv_gamepadled[playernum].value == 0 ||
|| color >= MAXTRANSLATIONS) (window_notinfocus && cv_gamepadledifunfocused.value == 0) ||
color >= MAXTRANSLATIONS)
{ {
return; return;
} }
if (!I_GamepadHasLED(playernum)) if (!I_GamepadHasLED(playernum))
{
return; return;
}
// so we can override this // so we can override this
skincolor = color ? color : G_GetSkinColorForGamepad(playernum); skincolor = color ? color : G_GetSkinColorForGamepad(playernum);
@@ -990,29 +984,21 @@ void G_DeviceLEDTick(void)
UINT8 i, newcolor; UINT8 i, newcolor;
if (numcontrollers == 0) if (numcontrollers == 0)
{
return; return;
}
for (i = 0; i <= splitscreen; i++) for (i = 0; i <= splitscreen; i++)
{ {
if (!cv_usejoystick[i].value || !cv_gamepadled[i].value) if (!cv_usejoystick[i].value || !cv_gamepadled[i].value)
{
continue; continue;
}
// does not have a configurable led! :c // does not have a configurable led! :c
if (!I_GamepadHasLED(i)) if (!I_GamepadHasLED(i))
{
continue; continue;
}
newcolor = G_GetSkinColorForGamepad(i); newcolor = G_GetSkinColorForGamepad(i);
if (curcolor[i] == newcolor) // dont update if same colour if (curcolor[i] == newcolor) // dont update if same colour
{
continue; continue;
}
G_SetPlayerGamepadIndicatorColor(i, newcolor); G_SetPlayerGamepadIndicatorColor(i, newcolor);
curcolor[i] = newcolor; curcolor[i] = newcolor;
@@ -1041,22 +1027,22 @@ void G_ResetAllDeviceRumbles(void)
} }
} }
void G_PlayerDeviceRumble(INT32 playernum, UINT16 low_strength, UINT16 high_strength, UINT32 duration) void G_PlayerDeviceRumble(INT32 playernum, UINT32 low_strength, UINT32 high_strength, UINT32 duration)
{ {
I_Assert(playernum >= 0 && playernum < MAXSPLITSCREENPLAYERS); I_Assert(playernum >= 0 && playernum < MAXSPLITSCREENPLAYERS);
if (cv_rumble[playernum].value == 0 || (window_notinfocus && cv_rumbleifunfocused.value == 0)) if (cv_rumble[playernum].value == 0 || (window_notinfocus && cv_rumbleifunfocused.value == 0))
{
return; return;
}
UINT16 lo, hi;
// doesent need to be super precise // doesent need to be super precise
// but ensure this is within range (0-65535) // but ensure this is within range (0-65535)
// placed here so it applies to lua aswell // placed here so it applies to lua aswell
low_strength = (UINT16)min(FixedMul(low_strength, cv_rumble_strength[playernum].value), UINT16_MAX); lo = (UINT16)min(FixedMul(low_strength, cv_rumble_strength[playernum].value), UINT16_MAX);
high_strength = (UINT16)min(FixedMul(high_strength, cv_rumble_strength[playernum].value), UINT16_MAX); hi = (UINT16)min(FixedMul(high_strength, cv_rumble_strength[playernum].value), UINT16_MAX);
I_GamepadRumble(playernum, low_strength, high_strength, duration); I_GamepadRumble(playernum, lo, hi, duration);
} }
// rumble strengths // rumble strengths
@@ -1077,71 +1063,66 @@ void G_DeviceRumbleTick(void)
UINT8 i; UINT8 i;
if (dedicated || numcontrollers == 0 || gamestate != GS_LEVEL || demo.playback) if (dedicated || numcontrollers == 0 || gamestate != GS_LEVEL || demo.playback)
{
return; return;
}
for (i = 0; i <= splitscreen; i++) for (i = 0; i <= splitscreen; i++)
{ {
if (!cv_usejoystick[i].value || !cv_rumble[i].value) if (!cv_usejoystick[i].value || !cv_rumble[i].value)
{
continue; continue;
}
// does not support rumble! :c // does not support rumble! :c
if (!I_GamepadHasRumble(i)) if (!I_GamepadHasRumble(i))
{
continue; continue;
}
if (camera[i].freecam) if (camera[i].freecam)
{
continue; continue;
}
// SDL rumble strength goes from a range or 0-65535 respectively // SDL rumble strength goes from a range or 0-65535 respectively
// the higher, the stronger it is // the higher, the stronger it is
UINT16 low = 0, high = 0; UINT32 low = 0, high = 0;
// for how long the action should rumble, in ms // for how long the action should rumble, in ms
UINT16 lenght = 57; // 57ms is a short pulse, matches super well with this updating once per tic UINT32 length = 57; // 57ms is a short pulse, matches super well with this updating once per tic
const player_t *player = P_GetLocalPlayerForNum(i); const player_t *player = P_GetLocalPlayerForNum(i);
if (!player) if (!player)
{
continue; continue;
}
// allow lua to do some crap for spectators // allow lua to do some crap for spectators
if (player->spectator || !player->mo) if (player->spectator || !player->mo)
{
continue; continue;
}
// reset the rumble if you exit or are ded lel // reset the rumble if you exit or are ded lel
if (player->exiting || if (player->exiting ||
player->playerstate == PST_DEAD || player->playerstate == PST_DEAD ||
player->kartstuff[k_respawn] > 1) player->kartstuff[k_respawn] > 1)
{ {
G_PlayerDeviceRumble(i, low, high, 0); G_PlayerDeviceRumble(i, 0, 0, 0);
continue; continue;
} }
if (cv_rumble_spinout[i].value if (cv_rumble_wallbonk[i].value &&
&& player->kartstuff[k_spinouttimer]) (player->mo->eflags & MFE_JUSTBOUNCEDWALL))
{
high = RUMBLE_STRONG;
low = RUMBLE_MODERATE;
}
else if (cv_rumble_spinout[i].value &&
player->kartstuff[k_spinouttimer])
{ {
//low = high = FRACUNIT / 6; //low = high = FRACUNIT / 6;
low = high = FixedMul((RUMBLE_VERYSTRONG), (FixedDiv(player->kartstuff[k_spinouttimer], (3*TICRATE / 2)))); // try do some some kinda fadeout, 3*TICRATE / 2 is the "default" spinout time // try do some some kinda fadeout, 3*TICRATE / 2 is the "default" spinout time
low = high = FixedMul(RUMBLE_VERYSTRONG, FixedDiv(player->kartstuff[k_spinouttimer], (3*TICRATE / 2)));
} }
else if (cv_rumble_sneakerboost[i].value else if (cv_rumble_sneakerboost[i].value &&
&& (player->kartstuff[k_sneakertimer] > (sneakertime-(TICRATE/2)))) (player->kartstuff[k_sneakertimer] > (sneakertime-(TICRATE/2))))
{ {
low = high = RUMBLE_STRONG; low = high = RUMBLE_STRONG;
} }
else if (cv_rumble_offroad[i].value else if (cv_rumble_offroad[i].value &&
&& (player->kartstuff[k_offroad]) (player->kartstuff[k_offroad]) &&
&& (player->speed != 0) (player->speed != 0) &&
&& P_IsObjectOnGround(player->mo)) P_IsObjectOnGround(player->mo))
{ {
// weaken this depending on if you got hyu or invinc // weaken this depending on if you got hyu or invinc
if (player->kartstuff[k_hyudorotimer]) if (player->kartstuff[k_hyudorotimer])
@@ -1157,50 +1138,63 @@ void G_DeviceRumbleTick(void)
low = high = RUMBLE_MODERATE; low = high = RUMBLE_MODERATE;
} }
} }
else if (cv_rumble_bananadrag[i].value else if (cv_rumble_bananadrag[i].value &&
&& (player->kartstuff[k_bananadrag] > TICRATE) (player->kartstuff[k_bananadrag] > TICRATE) &&
&& (player->speed != 0) (player->speed != 0) &&
&& P_IsObjectOnGround(player->mo)) P_IsObjectOnGround(player->mo))
{ {
if (leveltime & 1) // this is actually funny lel if (leveltime & 1) // this is actually funny lel
high = RUMBLE_MODERATE; high = RUMBLE_MODERATE;
} }
else if (cv_rumble_stairjank[i].value else if (cv_rumble_stairjank[i].value &&
&& (player->stairjank > 8) (player->stairjank > 8) &&
&& (player->speed != 0) (player->speed != 0) &&
&& P_IsObjectOnGround(player->mo)) P_IsObjectOnGround(player->mo))
{ {
low = high = RUMBLE_VERYWEAK; low = high = RUMBLE_VERYWEAK;
length = 43;
} }
if (cv_rumble_brakedrift[i].value if (cv_rumble_brakedrift[i].value &&
&& player->kartstuff[k_brakedrift]) player->kartstuff[k_brakedrift])
{ {
high = CLAMP((high + RUMBLE_VERYWEAK), 0, UINT16_MAX); high += RUMBLE_VERYWEAK;
} }
// pulse when gettin new driftlevel // pulse when gettin new driftlevel
// let this come last if (cv_rumble_driftcharge[i].value &&
if (cv_rumble_driftcharge[i].value player->kartstuff[k_driftcharge] &&
&& player->kartstuff[k_driftcharge] player->driftlevel)
&& player->driftlevel)
{ {
high = CLAMP((high + RUMBLE_VERYWEAK), 0, UINT16_MAX); high += RUMBLE_VERYWEAK;
// make it rumble slightly longer the higher your driftlevel! // make it rumble slightly longer the higher your driftlevel!
if (player->driftlevel == 2) if (player->driftlevel == 2)
lenght = 114; length = 114;
else if (player->driftlevel == 3) else if (player->driftlevel == 3)
lenght = 174; length = 174;
else
length = 71;
}
// grow makes rumble more intense >:3
if (player->kartstuff[k_growshrinktimer] > 0)
{
high *= 2;
low *= 2;
}
// shrink does the opposite uwu
else if (player->kartstuff[k_growshrinktimer] < 0)
{
high /= 2;
low /= 2;
} }
// hack alert! i just dont want this thing constantly resetting the rumble lol // hack alert! i just dont want this thing constantly resetting the rumble lol
if (low == 0 && high == 0) if (low == 0 && high == 0)
{
continue; continue;
}
G_PlayerDeviceRumble(i, low, high, lenght); G_PlayerDeviceRumble(i, low, high, length);
} }
} }
+3 -1
View File
@@ -118,6 +118,8 @@ extern consvar_t cv_gamepadled[MAXSPLITSCREENPLAYERS];
extern consvar_t cv_rumble[MAXSPLITSCREENPLAYERS]; extern consvar_t cv_rumble[MAXSPLITSCREENPLAYERS];
extern consvar_t cv_rumble_strength[MAXSPLITSCREENPLAYERS]; extern consvar_t cv_rumble_strength[MAXSPLITSCREENPLAYERS];
// rumble types
extern consvar_t cv_rumble_wallbonk[MAXSPLITSCREENPLAYERS];
extern consvar_t cv_rumble_spinout[MAXSPLITSCREENPLAYERS]; extern consvar_t cv_rumble_spinout[MAXSPLITSCREENPLAYERS];
extern consvar_t cv_rumble_sneakerboost[MAXSPLITSCREENPLAYERS]; extern consvar_t cv_rumble_sneakerboost[MAXSPLITSCREENPLAYERS];
extern consvar_t cv_rumble_offroad[MAXSPLITSCREENPLAYERS]; extern consvar_t cv_rumble_offroad[MAXSPLITSCREENPLAYERS];
@@ -151,7 +153,7 @@ void G_DeviceLEDTick(void);
void G_ResetDeviceLED(void); void G_ResetDeviceLED(void);
void G_ResetAllDeviceRumbles(void); void G_ResetAllDeviceRumbles(void);
void G_PlayerDeviceRumble(INT32 playernum, UINT16 low_strength, UINT16 high_strength, UINT32 duration); void G_PlayerDeviceRumble(INT32 playernum, UINT32 low_strength, UINT32 high_strength, UINT32 duration);
void G_DeviceRumbleTick(void); void G_DeviceRumbleTick(void);
// peace to my little coder fingers! // peace to my little coder fingers!
+111 -30
View File
@@ -54,10 +54,6 @@ typedef struct {
// if no portals are found, the portal scanning phase can be skipped while rendering, saving a bit of time. // if no portals are found, the portal scanning phase can be skipped while rendering, saving a bit of time.
boolean gl_maphasportals = false; boolean gl_maphasportals = false;
// Determine on mapload if current map has any Horizonlines present
// avoids doing a bunch of work during rendering
boolean gl_maphashorizonlines = false;
// ========================================================================== // ==========================================================================
// FLOOR & CEILING CONVEX POLYS GENERATION // FLOOR & CEILING CONVEX POLYS GENERATION
// ========================================================================== // ==========================================================================
@@ -96,7 +92,7 @@ static void HWR_FreePoly(poly_t *poly)
// divfrac = how far along partline vector is crossing pt // divfrac = how far along partline vector is crossing pt
static boolean fracdivline(fdivline_t *partline, polyvertex_t *v1, polyvertex_t *v2) static boolean fracdivline(fdivline_t *partline, polyvertex_t *v1, polyvertex_t *v2)
{ {
double frac1, frac2; double frac;
double num; // numerator double num; // numerator
double den; // denominator double den; // denominator
double v1x, v1y, v1dx, v1dy; // polygon side vector, v1->v2 double v1x, v1y, v1dx, v1dy; // polygon side vector, v1->v2
@@ -122,24 +118,23 @@ static boolean fracdivline(fdivline_t *partline, polyvertex_t *v1, polyvertex_t
// first check the frac along the polygon segment, // first check the frac along the polygon segment,
// (do not accept hit with the extensions) // (do not accept hit with the extensions)
num = (v3x - v1x)*v3dy + (v1y - v3y)*v3dx; num = (v3x - v1x)*v3dy + (v1y - v3y)*v3dx;
frac1 = num / den; frac = num / den;
// 0= cross at v1, 1.0= cross at v2 // 0= cross at v1, 1.0= cross at v2
if (frac1 < 0.0 || frac1 > 1.0) // double if (frac < 0.0 || frac > 1.0) // double
return false; // not within the polygon side return false; // not within the polygon side
// now get the frac along the BSP line // now get the frac along the BSP line
// which is useful to determine what is left, what is right // which is useful to determine what is left, what is right
num = (v3x - v1x)*v1dy + (v1y - v3y)*v1dx; num = (v3x - v1x)*v1dy + (v1y - v3y)*v1dx;
frac2 = num / den;
partline->divfrac = frac2; // how far along partline vector partline->divfrac = num / den; // how far along partline vector
// [WDJ] find the interception point along the segment. // [WDJ] find the interception point along the segment.
// It should be slightly more accurate because it is always closer to the // It should be slightly more accurate because it is always closer to the
// crossing point than arbitrary positions on the partition line. // crossing point than arbitrary positions on the partition line.
partline->divpt.x = v1x + v1dx*frac1; partline->divpt.x = v1x + v1dx*frac;
partline->divpt.y = v1y + v1dy*frac1; partline->divpt.y = v1y + v1dy*frac;
return true; return true;
} }
@@ -161,6 +156,71 @@ static boolean SameVertex(polyvertex_t *p1, polyvertex_t *p2)
return true; return true;
} }
// Adapted from function in prboom.
// Point is to rightside of divline when result > 0,
// but result is multiplied by length of divline.
// Returns near 0, when point is on, or nearly on, the divline.
static inline double point_rightside(fdivline_t *dl, polyvertex_t *v4)
{
// Cross product of dl and vector dl->(x,y) to v4,
// is > 0 when v4 is to right side of divline.
// Viewed along divline from vertex, looking towards positive dx,dy.
// If divline is rotated until dy>0 and dx = 0, then true when rotated
// vertex position is to the right of the divline (v4->x > dl->x).
return ((((double)(v4->x) - (double)(dl->x)) * (double)(dl->dy))
- (((double)(v4->y) - (double)(dl->y)) * (double)(dl->dx)));
}
// [WDJ] The front and back MUST match the BSP determination, else it will assign
// this poly to the wrong sector.
// May have 1 point on the line, and other points might be very close to the line.
// Can only trust a test of a point that is NOT on the line.
// Using a tstdist = 0.5f worked, but it might break on very small poly.
// Avactor.wad had polys with d = 9.09, 5552, 1.64, 1011, 14252, 0.0136, 0.00634, 14655, 3,
// -0.3044, 7, 1.53, etc..,
// and one poly with d = -0.023 with the rest of the points d > 0.
// One 14 point poly with divline len=8, had to test 9 points to find d = 36.
// Typical: divline len=70 d=6828, divline len=1.0 d=35, divline len=1.414 d=5.
// The result of point_rightside is proportional to the length of divline.
// The divline length can be from 1.414 to 14000.
static void UnsplitPoly(fdivline_t *dlnp, poly_t *poly,
poly_t **frontpoly, poly_t **backpoly)
{
int32_t i;
double d;
const double tstd = hypot((double)dlnp->dx, (double)dlnp->dy) / 2.0;
double sumd = 0; // accumulated left or rightness.
for (i = 0; i < poly->numpts; i++)
{
// Look for a point that is obviously to the left or right.
d = point_rightside(dlnp, &poly->pts[i]); // d > 0 is right
sumd += d;
if (d > tstd)
goto poly_rightside;
if (d < -tstd)
goto poly_leftside;
}
// Did not find an obvious left or right point, then
if (sumd < 0)
goto poly_leftside;
poly_rightside:
// poly is to rightside of divline.
*frontpoly = poly;
*backpoly = NULL;
return;
poly_leftside:
// poly is to leftside of divline.
*frontpoly = NULL;
*backpoly = poly;
return;
}
// split a _CONVEX_ polygon in two convex polygons // split a _CONVEX_ polygon in two convex polygons
// outputs: // outputs:
// frontpoly : polygon on right side of bsp line // frontpoly : polygon on right side of bsp line
@@ -263,10 +323,7 @@ static void SplitPoly (fdivline_t *dlnp, // splitting parametric line
// linedefs where each side point the same sector, that is: // linedefs where each side point the same sector, that is:
// the deep water effect with the original Doom // the deep water effect with the original Doom
//TODO: make sure front poly is to front of partition line? UnsplitPoly(dlnp, poly, frontpoly, backpoly);
*frontpoly = poly;
*backpoly = NULL;
return; return;
} }
@@ -274,16 +331,14 @@ static void SplitPoly (fdivline_t *dlnp, // splitting parametric line
if (pe < 0) if (pe < 0)
{ {
//I_Error("SplitPoly: only one point for split line (%d %d)", ps, pe); //I_Error("SplitPoly: only one point for split line (%d %d)", ps, pe);
*frontpoly = poly; UnsplitPoly(dlnp, poly, frontpoly, backpoly);
*backpoly = NULL;
return; return;
} }
if (pe <= ps) if (pe <= ps)
{ {
//I_Error("SplitPoly: invalid splitting line (%d %d)", ps, pe); //I_Error("SplitPoly: invalid splitting line (%d %d)", ps, pe);
*frontpoly = poly; UnsplitPoly(dlnp, poly, frontpoly, backpoly);
*backpoly = NULL;
return; return;
} }
@@ -346,7 +401,7 @@ static void SplitPoly (fdivline_t *dlnp, // splitting parametric line
} }
// checks if any line is a portal or horizonline, for optimization // checks if any line is a portal or horizonline, for optimization
static inline void CheckForPortalsAndHorizonLines(boolean firstside, const line_t *line) static inline void CheckForPortalsAndHorizonLines(boolean firstside, const line_t *line, subsector_t *sub)
{ {
// portal check // portal check
if (!gl_maphasportals && firstside && line->special == PORTALSPECIAL) if (!gl_maphasportals && firstside && line->special == PORTALSPECIAL)
@@ -362,8 +417,8 @@ static inline void CheckForPortalsAndHorizonLines(boolean firstside, const line_
} }
// horizonline check // horizonline check
if (!gl_maphashorizonlines && line->special == HORIZONSPECIAL) if (line->special == HORIZONSPECIAL)
gl_maphashorizonlines = true; sub->hashorizon = true;
} }
// Use each seg of the poly as a partition line, keep only the // Use each seg of the poly as a partition line, keep only the
@@ -376,7 +431,7 @@ static inline void CheckForPortalsAndHorizonLines(boolean firstside, const line_
// segcount : number of seg in the array // segcount : number of seg in the array
// Return frontpoly, which may be new or ptr to poly. // Return frontpoly, which may be new or ptr to poly.
// Called from: HWR_SubsecPoly // Called from: HWR_SubsecPoly
static poly_t *CutOutSubsecPoly(seg_t *lseg, INT32 segcount, poly_t *poly) static poly_t *CutOutSubsecPoly(seg_t *lseg, INT32 segcount, poly_t *poly, subsector_t *sub)
{ {
INT32 i, j; INT32 i, j;
poly_t* frontpoly = poly; // default, return same poly poly_t* frontpoly = poly; // default, return same poly
@@ -397,7 +452,7 @@ static poly_t *CutOutSubsecPoly(seg_t *lseg, INT32 segcount, poly_t *poly)
if (!line) if (!line)
continue; continue;
CheckForPortalsAndHorizonLines(lseg->side == 0, line); CheckForPortalsAndHorizonLines(lseg->side == 0, line, sub);
if (line->sidenum[1] != NO_INDEX) if (line->sidenum[1] != NO_INDEX)
{ {
@@ -489,6 +544,23 @@ static poly_t *CutOutSubsecPoly(seg_t *lseg, INT32 segcount, poly_t *poly)
// need 2 points // need 2 points
if (pe >= 0) if (pe >= 0)
{ {
// Cuts that miss the polygon.
if (ps_frac < 0.0 && cutseg.divfrac < 0.0)
continue;
if (ps_frac > 1.0 && cutseg.divfrac > 1.0)
continue;
#define FRAC_EP 0.01f
// Reject cuts that could make the polygon non-convex.
// Cannot make normal cut, ps_frac end is loose.
if ((ps_frac < (0.0 - FRAC_EP)) || (ps_frac > (1.0f + FRAC_EP)))
continue;
// Cannot make normal cut, cutseg.divfrac end is loose.
if ((cutseg.divfrac < (0.0 - FRAC_EP)) || (cutseg.divfrac > (1.0f + FRAC_EP)))
continue;
#undef FRAC_EP
// generate FRONT poly // generate FRONT poly
frontpoly = HWR_AllocPoly(poly_num_pts); frontpoly = HWR_AllocPoly(poly_num_pts);
@@ -543,7 +615,7 @@ static inline void HWR_SubsecPoly(INT32 ssindex, poly_t *poly)
if (poly) if (poly)
{ {
poly = CutOutSubsecPoly(lseg, segcount, poly); poly = CutOutSubsecPoly(lseg, segcount, poly, sub);
#ifdef DEBUG_HWBSP #ifdef DEBUG_HWBSP
totalsubsecpolys++; totalsubsecpolys++;
#endif #endif
@@ -672,7 +744,7 @@ static void WalkBSPNode(INT32 bspnum, poly_t *poly, UINT16 *leafnode, fixed_t *b
#endif #endif
// Recursively divide front space. // Recursively divide front space.
if (LIKELY(frontpoly)) if (frontpoly)
{ {
WalkBSPNode(bsp->children[0], frontpoly, &bsp->children[0],bsp->bbox[0]); WalkBSPNode(bsp->children[0], frontpoly, &bsp->children[0],bsp->bbox[0]);
@@ -680,7 +752,11 @@ static void WalkBSPNode(INT32 bspnum, poly_t *poly, UINT16 *leafnode, fixed_t *b
memcpy(bbox, bsp->bbox[0], 4*sizeof (fixed_t)); memcpy(bbox, bsp->bbox[0], 4*sizeof (fixed_t));
} }
else else
I_Error("WalkBSPNode: no front poly?"); {
// [WDJ] Having no front poly is as likely as no back poly, since
// logic in Split Poly was changed to check poly direction.
// I_Error("HWR_WalkBSPNode: no front poly, bspnum= %d\n", bspnum);
}
// Recursively divide back space. // Recursively divide back space.
if (backpoly) if (backpoly)
@@ -795,7 +871,9 @@ static boolean PointInSeg(polyvertex_t *va, polyvertex_t *v1, polyvertex_t *v2)
#endif #endif
} }
#ifdef DEBUG_HWBSP
static INT32 numsplitpoly; static INT32 numsplitpoly;
#endif
static void SearchSegInBSP(INT32 bspnum, polyvertex_t *p, poly_t *poly) static void SearchSegInBSP(INT32 bspnum, polyvertex_t *p, poly_t *poly)
{ {
@@ -834,8 +912,9 @@ static void SearchSegInBSP(INT32 bspnum, polyvertex_t *p, poly_t *poly)
for (n = k+1; n < newpoly->numpts; n++) for (n = k+1; n < newpoly->numpts; n++)
newpoly->pts[n] = q->pts[n-1]; newpoly->pts[n] = q->pts[n-1];
#ifdef DEBUG_HWBSP
numsplitpoly++; numsplitpoly++;
#endif
extrasubsectors[bspnum].planepoly = newpoly; extrasubsectors[bspnum].planepoly = newpoly;
HWR_FreePoly(q); HWR_FreePoly(q);
return; return;
@@ -881,7 +960,9 @@ static void SolveTProblem(void)
I_FinishUpdate(); // page flip or blit buffer I_FinishUpdate(); // page flip or blit buffer
#endif #endif
#ifdef DEBUG_HWBSP
numsplitpoly = 0; numsplitpoly = 0;
#endif
for (ssnum = 0; ssnum < num_extra_subsector; ssnum++) for (ssnum = 0; ssnum < num_extra_subsector; ssnum++)
{ {
@@ -918,8 +999,8 @@ void HWR_CreatePlanePolygons(INT32 bspnum)
I_FinishUpdate(); // page flip or blit buffer I_FinishUpdate(); // page flip or blit buffer
#endif #endif
// reset the portal and horizonline flag // reset the portal flag
gl_maphasportals = gl_maphashorizonlines = false; gl_maphasportals = false;
// find min/max boundaries of map // find min/max boundaries of map
#ifdef DEBUG_HWBSP #ifdef DEBUG_HWBSP
+2 -23
View File
@@ -614,16 +614,8 @@ void HWR_FreeMapTextures(void)
gl_numtextures = 0; gl_numtextures = 0;
} }
#define NAME flatcheck
#define KEY_TY UINT32
#define HASH_FN vt_hash_integer
#define CMPR_FN vt_cmpr_integer
#include "../verstable.h"
static void HWR_PrecacheLevelFlats(void) static void HWR_PrecacheLevelFlats(void)
{ {
// lookup for flats that may´ve been already loaded
flatcheck flatpresent;
size_t i; size_t i;
INT32 k; INT32 k;
@@ -635,9 +627,6 @@ static void HWR_PrecacheLevelFlats(void)
} }
#endif #endif
flatcheck_init(&flatpresent);
flatcheck_reserve(&flatpresent, numlevelflats);
// special case for encore // special case for encore
#if 0 #if 0
#ifdef GLENCORE #ifdef GLENCORE
@@ -689,11 +678,7 @@ static void HWR_PrecacheLevelFlats(void)
{ {
const levelflat_t *levelflat = &levelflats[i]; const levelflat_t *levelflat = &levelflats[i];
if (flatcheck_is_end(flatcheck_get(&flatpresent, levelflat->lumpnum))) HWR_GetFlat(levelflat->lumpnum, false);
{
HWR_GetFlat(levelflat->lumpnum, false);
flatcheck_insert(&flatpresent, levelflat->lumpnum);
}
if (levelflat->speed) // is it an animated flat ? if (levelflat->speed) // is it an animated flat ?
{ {
@@ -701,17 +686,11 @@ static void HWR_PrecacheLevelFlats(void)
for (k = 0; k < levelflat->numpics; k++) for (k = 0; k < levelflat->numpics; k++)
{ {
lumpnum_t lump = levelflat->baselumpnum + k; lumpnum_t lump = levelflat->baselumpnum + k;
if (flatcheck_is_end(flatcheck_get(&flatpresent, lump))) HWR_GetFlat(lump, false);
{
HWR_GetFlat(lump, false);
flatcheck_insert(&flatpresent, lump);
}
} }
} }
} }
} }
flatcheck_cleanup(&flatpresent);
} }
static void HWR_PrecacheLevelTextures(void) static void HWR_PrecacheLevelTextures(void)
+380 -72
View File
@@ -16,6 +16,7 @@
#include <algorithm> #include <algorithm>
#include <vector> #include <vector>
#include "../d_main.h"
#include "../doomstat.h" #include "../doomstat.h"
#include "../doomdef.h" #include "../doomdef.h"
@@ -120,7 +121,7 @@ ps_metric_t ps_hw_batchdrawtime = {};
static void HWR_SplitWall(sector_t *sector, FOutVector *wallVerts, INT32 texnum, boolean noencore, FSurfaceInfo* Surf, INT32 cutflag, ffloor_t *pfloor, FBITFIELD polyflags); static void HWR_SplitWall(sector_t *sector, FOutVector *wallVerts, INT32 texnum, boolean noencore, FSurfaceInfo* Surf, INT32 cutflag, ffloor_t *pfloor, FBITFIELD polyflags);
static void HWR_RenderWall(FOutVector *wallVerts, FSurfaceInfo *pSurf, FBITFIELD blend, boolean fogwall, INT32 lightlevel, extracolormap_t *wallcolormap); static void HWR_RenderWall(FOutVector *wallVerts, FSurfaceInfo *pSurf, FBITFIELD blend, boolean fogwall, INT32 lightlevel, extracolormap_t *wallcolormap);
static void HWR_AddTransparentFloor(lumpnum_t lumpnum, extrasubsector_t *xsub, boolean isceiling, fixed_t fixedheight, INT32 lightlevel, INT32 alpha, sector_t *FOFSector, FBITFIELD blend, boolean fogplane, extracolormap_t *planecolormap); static void HWR_AddTransparentFloor(lumpnum_t lumpnum, extrasubsector_t *xsub, boolean isceiling, fixed_t fixedheight, INT32 lightlevel, INT32 alpha, sector_t *FOFSector, FBITFIELD blend, boolean fogplane, extracolormap_t *planecolormap, subsector_t *subsector);
static void HWR_AddTransparentWall(FOutVector *wallVerts, FSurfaceInfo *pSurf, INT32 texnum, boolean noencore, FBITFIELD blend, boolean fogwall, INT32 lightlevel, extracolormap_t *wallcolormap); static void HWR_AddTransparentWall(FOutVector *wallVerts, FSurfaceInfo *pSurf, INT32 texnum, boolean noencore, FBITFIELD blend, boolean fogwall, INT32 lightlevel, extracolormap_t *wallcolormap);
static void HWR_AddTransparentPolyobjectFloor(lumpnum_t lumpnum, polyobj_t *polysector, boolean isceiling, fixed_t fixedheight, INT32 lightlevel, INT32 alpha, sector_t *FOFSector, FBITFIELD blend, extracolormap_t *planecolormap); static void HWR_AddTransparentPolyobjectFloor(lumpnum_t lumpnum, polyobj_t *polysector, boolean isceiling, fixed_t fixedheight, INT32 lightlevel, INT32 alpha, sector_t *FOFSector, FBITFIELD blend, extracolormap_t *planecolormap);
@@ -204,7 +205,8 @@ static CV_PossibleValue_t glpalettedepth_cons_t[] = {{16, "16 bits"}, {24, "24 b
consvar_t cv_glscreentextures = {"gr_screentextures", "All", CV_CALL|CV_SAVE, glscreentextures_cons_t, CV_screentextures_OnChange, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_glscreentextures = {"gr_screentextures", "All", CV_CALL|CV_SAVE, glscreentextures_cons_t, CV_screentextures_OnChange, 0, NULL, NULL, 0, 0, NULL};
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
consvar_t cv_glframebuffer = {"gr_framebuffer", "Off", CV_SAVE|CV_CALL|CV_NOINIT, CV_OnOff, CV_glframebuffer_OnChange, 0, NULL, NULL, 0, 0, NULL}; static CV_PossibleValue_t glframebuffer_cons_t[] = {{0, "Off"}, {1, "Downsample"}, {2, "Always"}, {0, NULL}};
consvar_t cv_glframebuffer = {"gr_framebuffer", "Off", CV_SAVE|CV_CALL, glframebuffer_cons_t, CV_glframebuffer_OnChange, 0, NULL, NULL, 0, 0, NULL};
#endif #endif
consvar_t cv_glmdls = {"gr_mdls", "Off", CV_SAVE|CV_CALL, CV_OnOff, M_UpdateOGLMenu, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_glmdls = {"gr_mdls", "Off", CV_SAVE|CV_CALL, CV_OnOff, M_UpdateOGLMenu, 0, NULL, NULL, 0, 0, NULL};
@@ -255,6 +257,7 @@ static void CV_screentextures_OnChange(void)
#endif #endif
intermissionbginit = false; intermissionbginit = false;
} }
GL_SetSpecialState(HWD_SET_SCREEN_TEXTURES, cv_glscreentextures.value); GL_SetSpecialState(HWD_SET_SCREEN_TEXTURES, cv_glscreentextures.value);
M_UpdateOGLMenu(); M_UpdateOGLMenu();
} }
@@ -263,12 +266,11 @@ static void CV_screentextures_OnChange(void)
static void CV_glframebuffer_OnChange(void) static void CV_glframebuffer_OnChange(void)
{ {
ONLY_IF_GL_LOADED ONLY_IF_GL_LOADED
if ((cv_glframebuffer.value != 0 && cv_glscreentextures.value != 2) // screen FBO needs screen textures currently
|| (!supportFBO && cv_glframebuffer.value != 0)) // screen FBO needs screen textures if (cv_glframebuffer.value != 0 && ((cv_glscreentextures.value != 2) || !supportFBO))
CV_SetValue(&cv_glframebuffer, 0); CV_StealthSetValue(&cv_glframebuffer, 0); // dont recursively call this lul
if (loaded_config) // dont do this crap on startup, this is handled elsewhere
I_DownSample(); I_CheckDownSampleState(true);
RefreshOGLSDLSurface();
M_UpdateOGLMenu(); M_UpdateOGLMenu();
intermissionbginit = false; intermissionbginit = false;
} }
@@ -502,6 +504,13 @@ static UINT8 HWR_FogBlockAlpha(INT32 light, extracolormap_t *colormap) // Let's
return surfcolor.s.alpha; return surfcolor.s.alpha;
} }
static boolean HWR_ApplyLightOffset(UINT8 baselightnum, const sector_t *sector)
{
if (HWR_ShouldUsePaletteRendering())
return P_ApplyLightOffset(baselightnum >> LIGHTSEGSHIFT, sector);
return P_ApplyLightOffsetFine(baselightnum, sector);
}
static FUINT HWR_CalcWallLight(FUINT lightnum, seg_t *seg, extracolormap_t *colormap) static FUINT HWR_CalcWallLight(FUINT lightnum, seg_t *seg, extracolormap_t *colormap)
{ {
INT16 finallight = lightnum; INT16 finallight = lightnum;
@@ -509,7 +518,7 @@ static FUINT HWR_CalcWallLight(FUINT lightnum, seg_t *seg, extracolormap_t *colo
if (cv_glfakecontrast.value == 0 || (colormap && HWR_ShouldUsePaletteRendering())) if (cv_glfakecontrast.value == 0 || (colormap && HWR_ShouldUsePaletteRendering()))
return (FUINT)finallight; return (FUINT)finallight;
if (seg != NULL && P_ApplyLightOffsetFine(lightnum, seg->frontsector)) if (seg != NULL && HWR_ApplyLightOffset(lightnum, seg->frontsector))
{ {
const INT16 offset = (cv_glfakecontrast.value == 2) ? seg->hwLightOffset : ((INT16)seg->lightOffset * 8); const INT16 offset = (cv_glfakecontrast.value == 2) ? seg->hwLightOffset : ((INT16)seg->lightOffset * 8);
@@ -520,18 +529,17 @@ static FUINT HWR_CalcWallLight(FUINT lightnum, seg_t *seg, extracolormap_t *colo
return (FUINT)finallight; return (FUINT)finallight;
} }
static FUINT HWR_CalcSlopeLight(FUINT lightnum, pslope_t *slope, const sector_t *sector, const boolean fof) static FUINT HWR_CalcSlopeLight(FUINT lightnum, pslope_t *slope, const sector_t *sector, const boolean reverseLight)
{ {
INT16 finallight = lightnum; INT16 finallight = lightnum;
if (cv_glfakecontrast.value == 0 || cv_glslopecontrast.value == 0) if (cv_glfakecontrast.value == 0 || cv_glslopecontrast.value == 0)
return (FUINT)finallight; return (FUINT)finallight;
if (slope != NULL && sector != NULL && P_ApplyLightOffsetFine(lightnum, sector)) if (slope != NULL && sector != NULL && HWR_ApplyLightOffset(lightnum, sector))
{ {
const INT16 offset = (cv_glfakecontrast.value == 2) ? slope->hwLightOffset : ((INT16)slope->lightOffset * 8); const INT16 offset = (cv_glfakecontrast.value == 2) ? slope->hwLightOffset : ((INT16)slope->lightOffset * 8);
finallight += ((reverseLight && maplighting.directional) ? -offset : offset);
finallight += (fof ? -offset : offset);
finallight = CLAMP(finallight, 0, 255); finallight = CLAMP(finallight, 0, 255);
} }
@@ -695,7 +703,7 @@ static void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, bool
SETUP3DVERT(v3d, pv->x, pv->y); SETUP3DVERT(v3d, pv->x, pv->y);
if (slope) if (slope)
lightlevel = HWR_CalcSlopeLight(lightlevel, slope, gl_frontsector, (FOFsector != NULL)); lightlevel = HWR_CalcSlopeLight(lightlevel, slope, gl_frontsector, (FOFsector && !isceiling) || (!FOFsector && isceiling));
HWR_Lighting(&Surf, lightlevel, planecolormap, P_SectorUsesDirectionalLighting(gl_frontsector)); HWR_Lighting(&Surf, lightlevel, planecolormap, P_SectorUsesDirectionalLighting(gl_frontsector));
@@ -721,7 +729,7 @@ static void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, bool
HWR_ProcessPolygon(&Surf, planeVerts, nrPlaneVerts, PolyFlags, shader, false); HWR_ProcessPolygon(&Surf, planeVerts, nrPlaneVerts, PolyFlags, shader, false);
if (gl_maphashorizonlines && subsector && !FOFsector && cv_glhorizonlines.value) if (subsector && subsector->hashorizon && cv_glhorizonlines.value)
{ {
// Horizon lines // Horizon lines
FOutVector horizonpts[6]; FOutVector horizonpts[6];
@@ -806,6 +814,268 @@ static void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, bool
#undef SETUP3DVERT #undef SETUP3DVERT
} }
static void HWR_RenderFOFHorizonPlane(subsector_t *subsector, extrasubsector_t *xsub, boolean isceiling, fixed_t fixedheight, FBITFIELD PolyFlags, INT32 lightlevel, lumpnum_t lumpnum, sector_t *FOFsector, UINT8 alpha, extracolormap_t *planecolormap)
{
FSurfaceInfo Surf = {};
polyvertex_t *pv;
pslope_t *slope = NULL;
INT32 shader = SHADER_NONE;
size_t nrPlaneVerts;
INT32 i;
float height; // constant y for all points on the convex flat polygon
static float flatxref = 0.0f, flatyref = 0.0f;
static float fflatsize = 64.0f;
static INT32 flatflag = 63;
size_t len;
float tempxsow, tempytow;
float scrollx = 0.0f, scrolly = 0.0f;
float anglef = 0.0f, cosangf = 0.0f, sinangf = 0.0f;
angle_t angle = 0;
static FOutVector *planeVerts = NULL;
static UINT16 numAllocedPlaneVerts = 0;
poly_t *planepoly = xsub->planepoly;
if (!cv_glhorizonlines.value)
return;
if (!subsector || !subsector->hashorizon)
return;
// no convex poly were generated for this subsector
if (!planepoly)
return;
nrPlaneVerts = planepoly->numpts;
if (nrPlaneVerts < 3) // not even a triangle ?
return;
const sector_t *sec = FOFsector;
if (!(PolyFlags & PF_NoTexture))
{
HWR_GetFlat(lumpnum, R_NoEncore(FOFsector, !isceiling));
}
// Get the slope pointer to simplify future code
if (!isceiling && sec->f_slope)
slope = sec->f_slope;
else if (isceiling && sec->c_slope)
slope = sec->c_slope;
height = FixedToFloat(fixedheight);
// Allocate plane-vertex buffer if we need to
if (!planeVerts || nrPlaneVerts > numAllocedPlaneVerts)
{
numAllocedPlaneVerts = (UINT16)nrPlaneVerts;
Z_Free(planeVerts);
Z_Malloc(numAllocedPlaneVerts * sizeof (FOutVector), PU_LEVEL, &planeVerts);
}
len = W_LumpLength(lumpnum);
switch (len)
{
case 4194304: // 2048x2048 lump
fflatsize = 2048.0f;
flatflag = 2047;
break;
case 1048576: // 1024x1024 lump
fflatsize = 1024.0f;
flatflag = 1023;
break;
case 262144: // 512x512 lump
fflatsize = 512.0f;
flatflag = 511;
break;
case 65536: // 256x256 lump
fflatsize = 256.0f;
flatflag = 255;
break;
case 16384: // 128x128 lump
fflatsize = 128.0f;
flatflag = 127;
break;
case 1024: // 32x32 lump
fflatsize = 32.0f;
flatflag = 31;
break;
default: // 64x64 lump
fflatsize = 64.0f;
flatflag = 63;
break;
}
pv = planepoly->pts;
// reference point for flat texture coord for each vertex around the polygon
flatxref = static_cast<float>(static_cast<fixed_t>(pv->x) & (~flatflag)) / fflatsize;
flatyref = static_cast<float>(static_cast<fixed_t>(pv->y) & (~flatflag)) / fflatsize;
if (!isceiling) // it's a floor
{
scrollx = FixedToFloat(sec->floor_xoffs)/fflatsize;
scrolly = FixedToFloat(sec->floor_yoffs)/fflatsize;
angle = sec->floorpic_angle;
}
else // it's a ceiling
{
scrollx = FixedToFloat(sec->ceiling_xoffs)/fflatsize;
scrolly = FixedToFloat(sec->ceiling_yoffs)/fflatsize;
angle = sec->ceilingpic_angle;
}
if (angle) // Only needs to be done if there's an altered angle
{
// This needs to be done so that it scrolls in a different direction after rotation like software
tempxsow = flatxref;
tempytow = flatyref;
anglef = ANG2RAD(InvAngle(angle));
// This needs to be done so everything aligns after rotation
// It would be done so that rotation is done, THEN the translation, but I couldn't get it to rotate AND scroll like software does
cosangf = cosf(anglef);
sinangf = sinf(anglef);
flatxref = (tempxsow * cosangf) - (tempytow * sinangf);
flatyref = (tempxsow * sinangf) + (tempytow * cosangf);
}
#define SETUP3DVERT(vert, vx, vy) {\
/* Hurdler: add scrolling texture on floor/ceiling */\
vert->s = (float)(((vx) / fflatsize) - flatxref + scrollx);\
vert->t = (float)(flatyref - ((vy) / fflatsize) + scrolly);\
\
/* Need to rotate before translate */\
if (angle) /* Only needs to be done if there's an altered angle */\
{\
tempxsow = vert->s;\
tempytow = vert->t;\
vert->s = (tempxsow * cosangf) - (tempytow * sinangf);\
vert->t = (tempxsow * sinangf) + (tempytow * cosangf);\
}\
\
if (slope)\
{\
fixedheight = P_GetSlopeZAt(slope, FloatToFixed((vx)), FloatToFixed((vy)));\
height = FixedToFloat(fixedheight);\
}\
\
vert->x = (vx);\
vert->y = height;\
vert->z = (vy);\
\
}
HWR_Lighting(&Surf, lightlevel, planecolormap, false);
if (PolyFlags & (PF_Translucent|PF_Fog|PF_Additive|PF_Subtractive|PF_ReverseSubtract|PF_Multiplicative|PF_Environment))
{
Surf.PolyColor.s.alpha = (UINT8)alpha;
PolyFlags |= PF_Modulated;
}
else
PolyFlags |= PF_Masked|PF_Modulated;
if (HWR_UseShader())
{
if (PolyFlags & PF_Fog)
shader = SHADER_FOG;
else if (cv_ripplewater.value && (PolyFlags & PF_Ripple))
shader = SHADER_WATER;
else
shader = SHADER_FLOOR;
PolyFlags |= PF_ColorMapped;
}
// Horizon lines
FOutVector horizonpts[6];
float dist, vx, vy;
float x1, y1, xd, yd;
UINT8 numplanes, j;
vertex_t v; // For determining the closest distance from the line to the camera, to split render planes for minimum distortion;
static constexpr float renderdist = 27000.0f; // How far out to properly render the plane
static constexpr float farrenderdist = 32768.0f; // From here, raise plane to horizon level to fill in the line with some texture distortion
const seg_t *line = &segs[subsector->firstline];
for (i = 0; i < subsector->numlines; i++, line++)
{
if (line->polyseg)
continue;
line_t* ld = line->linedef;
if (LIKELY(ld->special != HORIZONSPECIAL))
continue;
if (R_PointOnSegSide(viewx, viewy, line) != 0)
continue;
P_ClosestPointOnLine(viewx, viewy, ld, &v);
dist = FixedToFloat(R_PointToDist(v.x, v.y));
x1 = (line->fv1.x);
y1 = (line->fv1.y);
xd = (line->fv2.x) - x1;
yd = (line->fv2.y) - y1;
// Based on the seg length and the distance from the line, split horizon into multiple poly sets to reduce distortion
dist = sqrtf((xd*xd) + (yd*yd)) / dist / 16.0f;
if (dist > 100.0f)
numplanes = 100;
else
numplanes = (UINT8)dist + 1;
for (j = 0; j < numplanes; j++)
{
// Left side
vx = x1 + xd * j / numplanes;
vy = y1 + yd * j / numplanes;
SETUP3DVERT((&horizonpts[1]), vx, vy);
dist = sqrtf(powf(vx - gl_viewx, 2) + powf(vy - gl_viewy, 2));
vx = (vx - gl_viewx) * renderdist / dist + gl_viewx;
vy = (vy - gl_viewy) * renderdist / dist + gl_viewy;
SETUP3DVERT((&horizonpts[0]), vx, vy);
// Right side
vx = x1 + xd * (j+1) / numplanes;
vy = y1 + yd * (j+1) / numplanes;
SETUP3DVERT((&horizonpts[2]), vx, vy);
dist = sqrtf(powf(vx - gl_viewx, 2) + powf(vy - gl_viewy, 2));
vx = (vx - gl_viewx) * renderdist / dist + gl_viewx;
vy = (vy - gl_viewy) * renderdist / dist + gl_viewy;
SETUP3DVERT((&horizonpts[3]), vx, vy);
// Horizon fills
vx = (horizonpts[0].x - gl_viewx) * farrenderdist / renderdist + gl_viewx;
vy = (horizonpts[0].z - gl_viewy) * farrenderdist / renderdist + gl_viewy;
SETUP3DVERT((&horizonpts[5]), vx, vy);
horizonpts[5].y = gl_viewz;
vx = (horizonpts[3].x - gl_viewx) * farrenderdist / renderdist + gl_viewx;
vy = (horizonpts[3].z - gl_viewy) * farrenderdist / renderdist + gl_viewy;
SETUP3DVERT((&horizonpts[4]), vx, vy);
horizonpts[4].y = gl_viewz;
// Draw
HWR_ProcessPolygon(&Surf, horizonpts, 6, PolyFlags, shader, true);
}
}
#undef SETUP3DVERT
}
#ifdef WALLSPLATS #ifdef WALLSPLATS
static void HWR_DrawSegsSplats(FSurfaceInfo * pSurf) static void HWR_DrawSegsSplats(FSurfaceInfo * pSurf)
{ {
@@ -1010,7 +1280,7 @@ static void HWR_SplitWall(sector_t *sector, FOutVector *wallVerts, INT32 texnum,
// To avoid division by zero, which would result in a NaN, we check if the vertical difference // To avoid division by zero, which would result in a NaN, we check if the vertical difference
// between the two vertices is not zero. // between the two vertices is not zero.
if (std::fpclassify(diff) == FP_ZERO) if (std::fpclassify(diff) == FP_ZERO)
pegmul = 0.0; pegmul = 0.0f;
else else
pegmul = (pegb - pegt) / diff; pegmul = (pegb - pegt) / diff;
@@ -1022,7 +1292,7 @@ static void HWR_SplitWall(sector_t *sector, FOutVector *wallVerts, INT32 texnum,
endpegb = wallVerts[1].t; endpegb = wallVerts[1].t;
if (std::fpclassify(diff) == FP_ZERO) if (std::fpclassify(diff) == FP_ZERO)
endpegmul = 0.0; endpegmul = 0.0f;
else else
endpegmul = (endpegb - endpegt) / diff; endpegmul = (endpegb - endpegt) / diff;
@@ -1239,46 +1509,44 @@ static inline boolean HWR_BlendMidtextureSurface(FSurfaceInfo *pSurf)
pSurf->PolyColor.s.alpha = 0xFF; pSurf->PolyColor.s.alpha = 0xFF;
if (LIKELY(!gl_curline->polyseg)) // check if linedef alpha is within range
{ const boolean linealpha = (gl_linedef->alpha >= 0 && gl_linedef->alpha < FRACUNIT);
// check if linedef alpha is within range
const boolean linealpha = (gl_linedef->alpha >= 0 && gl_linedef->alpha < FRACUNIT);
// set alpha for transparent walls // set alpha for transparent walls
switch (gl_linedef->special) switch (gl_linedef->special)
{ {
// Translucent linedef types // Translucent linedef types
case 102: case 102:
case 121 ... 125: case 121 ... 125:
case 141 ... 145: case 141 ... 145:
case 174: case 174:
case 175: case 175:
case 192: case 192:
case 195: case 195:
case 221: case 221:
case 253: case 253:
case 256: case 256:
if (gl_linedef->blendmode && linealpha) if (gl_linedef->blendmode && linealpha)
blendmode = HWR_SurfaceBlend(gl_linedef->blendmode, R_GetLinedefTransTable(gl_linedef->alpha), pSurf);
else
blendmode = PF_Translucent;
break;
default:
if (gl_linedef->blendmode)
{
if (linealpha)
blendmode = HWR_SurfaceBlend(gl_linedef->blendmode, R_GetLinedefTransTable(gl_linedef->alpha), pSurf); blendmode = HWR_SurfaceBlend(gl_linedef->blendmode, R_GetLinedefTransTable(gl_linedef->alpha), pSurf);
else else
blendmode = PF_Translucent; blendmode = HWR_GetBlendModeFlag(gl_linedef->blendmode);
break; }
default: else if (linealpha)
if (gl_linedef->blendmode) blendmode = HWR_TranstableToAlpha(R_GetLinedefTransTable(gl_linedef->alpha), pSurf);
{ else
if (linealpha) blendmode = PF_Masked;
blendmode = HWR_SurfaceBlend(gl_linedef->blendmode, R_GetLinedefTransTable(gl_linedef->alpha), pSurf); break;
else
blendmode = HWR_GetBlendModeFlag(gl_linedef->blendmode);
}
else if (linealpha)
blendmode = HWR_TranstableToAlpha(R_GetLinedefTransTable(gl_linedef->alpha), pSurf);
else
blendmode = PF_Masked;
break;
}
} }
else if (gl_curline->polyseg->translucency > 0)
if (gl_curline->polyseg && gl_curline->polyseg->translucency > 0)
{ {
// Polyobject translucency is shared between all of its lines // Polyobject translucency is shared between all of its lines
if (gl_curline->polyseg->translucency >= NUMTRANSMAPS) // wall not drawn if (gl_curline->polyseg->translucency >= NUMTRANSMAPS) // wall not drawn
@@ -1385,7 +1653,8 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
// two sided line // two sided line
if (gl_backsector) if (gl_backsector)
{ {
INT32 gl_toptexture = 0, gl_bottomtexture = 0; const INT32 gl_toptexture = R_GetTextureNum(gl_sidedef->toptexture);
const INT32 gl_bottomtexture = R_GetTextureNum(gl_sidedef->bottomtexture);
fixed_t texturevpeg; fixed_t texturevpeg;
@@ -1396,7 +1665,7 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
if (!gl_curline->polyseg) // Don't do it for polyobjects if (!gl_curline->polyseg) // Don't do it for polyobjects
{ {
// Sky Ceilings // Sky Ceilings
wallVerts[3].y = wallVerts[2].y = FLOATMAX; wallVerts[2].y = wallVerts[3].y = FLOATMAX; // draw to top of map space
auto draw_sky_walls = [] auto draw_sky_walls = []
(int vert1, int vert2, fixed_t world, fixed_t worldslope, auto& wwallVerts, auto& sSurf) FUNCINLINE (int vert1, int vert2, fixed_t world, fixed_t worldslope, auto& wwallVerts, auto& sSurf) FUNCINLINE
@@ -1406,6 +1675,9 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
HWR_DrawSkyWall(wwallVerts, &sSurf); HWR_DrawSkyWall(wwallVerts, &sSurf);
}; };
// worldtop = front ceiling
// worldhigh = back ceiling
if (gl_frontsector->ceilingpic == skyflatnum) if (gl_frontsector->ceilingpic == skyflatnum)
{ {
if (gl_backsector->ceilingpic == skyflatnum) if (gl_backsector->ceilingpic == skyflatnum)
@@ -1424,6 +1696,17 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
worldtop = worldhigh; worldtop = worldhigh;
worldtopslope = worldhighslope; worldtopslope = worldhighslope;
} }
else if (!gl_toptexture &&
(worldhigh <= worldtop && worldhighslope <= worldtopslope) && // Assuming ESLOPE is always on with my changes
(worldhigh != worldtop || worldhighslope != worldtopslope))
{
// Only the frontsector is sky.
// If there's no upper texture, extend the sky wall
// down to the lower of the two ceilings.
fixed_t top = std::min(worldtop, worldhigh);
fixed_t topslope = std::min(worldtopslope, worldhighslope);
draw_sky_walls(0, 1, top, topslope, wallVerts, Surf);
}
else else
{ {
// Only the frontsector is sky, just draw a skywall from the front ceiling // Only the frontsector is sky, just draw a skywall from the front ceiling
@@ -1436,8 +1719,11 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
draw_sky_walls(0, 1, worldtop, worldtopslope, wallVerts, Surf); draw_sky_walls(0, 1, worldtop, worldtopslope, wallVerts, Surf);
} }
// worldbottom = front floor
// worldlow = back floor
// Sky Floors // Sky Floors
wallVerts[0].y = wallVerts[1].y = FLOATMIN; wallVerts[0].y = wallVerts[1].y = FLOATMIN; // draw to bottom of map space
if (gl_frontsector->floorpic == skyflatnum) if (gl_frontsector->floorpic == skyflatnum)
{ {
@@ -1449,7 +1735,7 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
if ((worldlow >= worldbottom && worldlowslope >= worldbottomslope) if ((worldlow >= worldbottom && worldlowslope >= worldbottomslope)
&& (worldlow != worldbottom || worldlowslope != worldbottomslope) && (worldlow != worldbottom || worldlowslope != worldbottomslope)
// Removing the second line above will render more rarely visible skywalls. Example: Cave garden ceiling in Dark race // Removing the second line above will render more rarely visible skywalls. Example: Cave garden ceiling in Dark race
&& !(gl_sidedef->bottomtexture)) && !(gl_bottomtexture))
{ {
draw_sky_walls(3, 2, worldlow, worldlowslope, wallVerts, Surf); draw_sky_walls(3, 2, worldlow, worldlowslope, wallVerts, Surf);
} }
@@ -1460,15 +1746,25 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
draw_sky_walls(3, 2, worldbottom, worldbottomslope, wallVerts, Surf); draw_sky_walls(3, 2, worldbottom, worldbottomslope, wallVerts, Surf);
} }
} }
else if ((gl_backsector->floorpic == skyflatnum) && !(gl_sidedef->bottomtexture)) else if ((gl_backsector->floorpic == skyflatnum) && !(gl_bottomtexture))
{ {
// Only the backsector has sky, just draw a skywall from the back floor if there's no bottomtexture // Only the backsector has sky, just draw a skywall from the back floor if there's no bottomtexture
draw_sky_walls(3, 2, worldlow, worldlowslope, wallVerts, Surf); draw_sky_walls(3, 2, worldlow, worldlowslope, wallVerts, Surf);
} }
else if (gl_frontsector->ceilingpic == skyflatnum &&
gl_backsector->ceilingpic == skyflatnum &&
(worldlow >= worldbottom && worldlowslope >= worldbottomslope)
&& (worldlow != worldbottom || worldlowslope != worldbottomslope)
// Removing the second line above will render more rarely visible skywalls. Example: Cave garden ceiling in Dark race
&& !(gl_bottomtexture))
{
// Both ceilings are sky, but neither floor is sky.
// If there's a lower wall gap without a bottom texture,
// draw a skywall from the backsector's higher floor.
draw_sky_walls(3, 2, worldlow, worldlowslope, wallVerts, Surf);
}
} }
gl_toptexture = R_GetTextureNum(gl_sidedef->toptexture);
// check TOP TEXTURE // check TOP TEXTURE
if (gl_toptexture && (worldhighslope < worldtopslope || worldhigh < worldtop)) if (gl_toptexture && (worldhighslope < worldtopslope || worldhigh < worldtop))
{ {
@@ -1532,8 +1828,6 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
HWR_ProjectWall(wallVerts, &Surf, PF_Masked, lightnum, colormap); HWR_ProjectWall(wallVerts, &Surf, PF_Masked, lightnum, colormap);
} }
gl_bottomtexture = R_GetTextureNum(gl_sidedef->bottomtexture);
// check BOTTOM TEXTURE // check BOTTOM TEXTURE
if (gl_bottomtexture && (worldlowslope > worldbottomslope || worldlow > worldbottom)) if (gl_bottomtexture && (worldlowslope > worldbottomslope || worldlow > worldbottom))
{ {
@@ -2936,16 +3230,14 @@ static void HWR_Subsector(size_t num)
UINT8 alpha; UINT8 alpha;
light = R_GetPlaneLight(gl_frontsector, centerHeight, underside); light = R_GetPlaneLight(gl_frontsector, centerHeight, underside);
alpha = HWR_FogBlockAlpha(*gl_frontsector->lightlist[light].lightlevel, rover->master->frontsector->extra_colormap); alpha = HWR_FogBlockAlpha(*gl_frontsector->lightlist[light].lightlevel, rover->master->frontsector->extra_colormap);
HWR_AddTransparentFloor(0, HWR_AddTransparentFloor(0,
&extrasubsectors[num], &extrasubsectors[num],
!bottom, !bottom,
roverheight, roverheight,
*gl_frontsector->lightlist[light].lightlevel, *gl_frontsector->lightlist[light].lightlevel,
alpha, rover->master->frontsector, PF_Fog|PF_NoTexture, alpha, rover->master->frontsector, PF_Fog|PF_NoTexture,
true, rover->master->frontsector->extra_colormap); true, rover->master->frontsector->extra_colormap, sub);
} }
else if ((rover->flags & FF_TRANSLUCENT && rover->alpha < 256) || rover->blend) // SoM: Flags are more efficient else if ((rover->flags & FF_TRANSLUCENT && rover->alpha < 256) || rover->blend) // SoM: Flags are more efficient
{ {
@@ -2957,13 +3249,12 @@ static void HWR_Subsector(size_t num)
roverheight, roverheight,
*gl_frontsector->lightlist[light].lightlevel, *gl_frontsector->lightlist[light].lightlevel,
CLAMP(rover->alpha, 0, 255), rover->master->frontsector, HWR_RippleBlend(gl_frontsector, rover, false) | (rover->blend ? HWR_GetBlendModeFlag(rover->blend) : static_cast<FBITFIELD>(PF_Translucent)), CLAMP(rover->alpha, 0, 255), rover->master->frontsector, HWR_RippleBlend(gl_frontsector, rover, false) | (rover->blend ? HWR_GetBlendModeFlag(rover->blend) : static_cast<FBITFIELD>(PF_Translucent)),
false, gl_frontsector->lightlist[light].extra_colormap); false, gl_frontsector->lightlist[light].extra_colormap, sub);
} }
else else
{ {
HWR_GetFlat(flatlump, R_NoEncore(rover->master->frontsector, bottom)); HWR_GetFlat(flatlump, R_NoEncore(rover->master->frontsector, bottom));
light = R_GetPlaneLight(gl_frontsector, centerHeight, underside); light = R_GetPlaneLight(gl_frontsector, centerHeight, underside);
HWR_RenderPlane(sub, &extrasubsectors[num], !bottom, roverheight, HWR_RippleBlend(gl_frontsector, rover, false)|PF_Occlude, *gl_frontsector->lightlist[light].lightlevel, flatlump, HWR_RenderPlane(sub, &extrasubsectors[num], !bottom, roverheight, HWR_RippleBlend(gl_frontsector, rover, false)|PF_Occlude, *gl_frontsector->lightlist[light].lightlevel, flatlump,
rover->master->frontsector, 255, gl_frontsector->lightlist[light].extra_colormap); rover->master->frontsector, 255, gl_frontsector->lightlist[light].extra_colormap);
} }
@@ -3565,7 +3856,16 @@ static void HWR_SplitSprite(gl_vissprite_t *spr, const boolean papersprite)
realbot = bot = baseWallVerts[0].y; realbot = bot = baseWallVerts[0].y;
towtop = baseWallVerts[3].t; towtop = baseWallVerts[3].t;
towbot = baseWallVerts[0].t; towbot = baseWallVerts[0].t;
towmult = (towbot - towtop) / (top - bot);
float diff = (top - bot);
// If both heights of a side lay on the same position, then this sprite is a triangle.
// To avoid division by zero, which would result in a NaN, we check if the vertical difference
// between the two vertices is not zero.
if (std::fpclassify(diff) == FP_ZERO)
towmult = 0.0f;
else
towmult = (towbot - towtop) / diff;
endrealtop = endtop = baseWallVerts[2].y; endrealtop = endtop = baseWallVerts[2].y;
endrealbot = baseWallVerts[1].y; endrealbot = baseWallVerts[1].y;
@@ -3736,7 +4036,7 @@ static void HWR_SplitSprite(gl_vissprite_t *spr, const boolean papersprite)
if ((endtop <= endrealbot) && (top <= realbot)) if ((endtop <= endrealbot) && (top <= realbot))
return; return;
// If we're ever down here, somehow the above loop hasn't draw all the light levels of sprite // If we're ever down here, somehow the above loop hasn't drawn all the light levels of sprite
wallVerts[3].t = towtop + ((realtop - top) * towmult); wallVerts[3].t = towtop + ((realtop - top) * towmult);
wallVerts[2].t = towtop + ((endrealtop - endtop) * towmult); wallVerts[2].t = towtop + ((endrealtop - endtop) * towmult);
wallVerts[0].t = towtop + ((realtop - bot) * towmult); wallVerts[0].t = towtop + ((realtop - bot) * towmult);
@@ -4167,7 +4467,7 @@ static void HWR_AddTransparentWall(FOutVector *wallVerts, FSurfaceInfo *pSurf, I
wallinfo->wallcolormap = wallcolormap; wallinfo->wallcolormap = wallcolormap;
} }
static void HWR_AddTransparentFloor(lumpnum_t lumpnum, extrasubsector_t *xsub, boolean isceiling, fixed_t fixedheight, INT32 lightlevel, INT32 alpha, sector_t *FOFSector, FBITFIELD blend, boolean fogplane, extracolormap_t *planecolormap) static void HWR_AddTransparentFloor(lumpnum_t lumpnum, extrasubsector_t *xsub, boolean isceiling, fixed_t fixedheight, INT32 lightlevel, INT32 alpha, sector_t *FOFSector, FBITFIELD blend, boolean fogplane, extracolormap_t *planecolormap, subsector_t *subsector)
{ {
planeinfo_t *planeinfo = static_cast<planeinfo_t*>(HWR_CreateDrawNode(DRAWNODE_PLANE)); planeinfo_t *planeinfo = static_cast<planeinfo_t*>(HWR_CreateDrawNode(DRAWNODE_PLANE));
@@ -4181,6 +4481,9 @@ static void HWR_AddTransparentFloor(lumpnum_t lumpnum, extrasubsector_t *xsub, b
planeinfo->blend = blend; planeinfo->blend = blend;
planeinfo->fogplane = fogplane; planeinfo->fogplane = fogplane;
planeinfo->planecolormap = planecolormap; planeinfo->planecolormap = planecolormap;
// horizonplanes need to be drawn BEFORE skywalls, so lets hope this works without too many issues....
HWR_RenderFOFHorizonPlane(subsector, planeinfo->xsub, planeinfo->isceiling, planeinfo->fixedheight, planeinfo->blend, planeinfo->lightlevel, planeinfo->lumpnum, planeinfo->FOFSector, (UINT8)planeinfo->alpha, planeinfo->planecolormap);
} }
// Adding this for now until I can create extrasubsector info for polyobjects // Adding this for now until I can create extrasubsector info for polyobjects
@@ -5089,6 +5392,11 @@ static void HWR_SkyDomeVertex(gl_sky_t *sky, gl_skyvertex_t *vbo, int r, int c,
else else
vbo->v = 1.0f + ((float)(sky->rows - r) / (float)sky->rows) + 0.5f; vbo->v = 1.0f + ((float)(sky->rows - r) / (float)sky->rows) + 0.5f;
} }
else
{
vbo->u = 0.5f / sky->width;
vbo->v = 0.5f / sky->height;
}
if (r != 4) if (r != 4)
{ {
@@ -5875,7 +6183,7 @@ void HWR_Startup(void)
HWR_TogglePaletteRendering(); HWR_TogglePaletteRendering();
if (msaa) if (msaa)
GL_SetSpecialState(HWD_SET_MSAA, a2c ? 2 : 1); GL_SetSpecialState(HWD_SET_MSAA, 1);
HWR_RegisterCommands(); HWR_RegisterCommands();
} }
@@ -5963,7 +6271,7 @@ void HWR_Shutdown(void)
GL_FlushScreenTextures(); GL_FlushScreenTextures();
HWR_ClearAllTextures(); HWR_ClearAllTextures();
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
GL_Framebuffer_Disable(); GL_FBO_Disable();
#endif #endif
} }
-2
View File
@@ -43,7 +43,6 @@ void HWR_Startup(void);
void HWR_Shutdown(void); void HWR_Shutdown(void);
extern unsigned msaa; extern unsigned msaa;
extern boolean a2c;
extern FTransform atransform; extern FTransform atransform;
extern float gl_viewsin, gl_viewcos; extern float gl_viewsin, gl_viewcos;
@@ -172,7 +171,6 @@ void HWR_ProcessSeg(void); // Sort of like GLWall::Process in GZDoom
// hw_bsp.c // hw_bsp.c
void HWR_CreatePlanePolygons(INT32 bspnum); void HWR_CreatePlanePolygons(INT32 bspnum);
extern boolean gl_maphasportals; extern boolean gl_maphasportals;
extern boolean gl_maphashorizonlines;
// Console variables // Console variables
extern CV_PossibleValue_t glanisotropicmode_cons_t[]; extern CV_PossibleValue_t glanisotropicmode_cons_t[];
+5 -21
View File
@@ -193,30 +193,14 @@
"}\n" \ "}\n" \
"#endif\0" "#endif\0"
#define GLSL_SOFTWARE_FRAGMENT_SHADER_NOPAL \
"uniform sampler2D tex;\n" \
"uniform vec4 poly_color;\n" \
"uniform vec4 tint_color;\n" \
"uniform vec4 fade_color;\n" \
"uniform float lighting;\n" \
"uniform float fade_start;\n" \
"uniform float fade_end;\n" \
GLSL_DOOM_COLORMAP \
GLSL_DOOM_LIGHT_EQUATION \
"void main(void) {\n" \
"vec4 texel = texture2D(tex, gl_TexCoord[0].st);\n" \
"vec4 base_color = texel * poly_color;\n" \
"vec4 final_color = base_color;\n" \
GLSL_SOFTWARE_TINT_EQUATION \
GLSL_SOFTWARE_FADE_EQUATION \
"final_color.a = texel.a * poly_color.a;\n" \
"gl_FragColor = final_color;\n" \
"}\n" \
// hand tuned adjustments for light level calculation // hand tuned adjustments for light level calculation
#define GLSL_FLOOR_FUDGES \ #define GLSL_FLOOR_FUDGES \
"#define STARTMAP_FUDGE 1.06\n" \ "#define STARTMAP_FUDGE 1.06\n" \
"#define SCALE_FUDGE 1.15\n" "#ifdef SRB2_PALETTE_RENDERING\n" \
"#define SCALE_FUDGE 1.3\n" \
"#else\n" \
"#define SCALE_FUDGE 1.15\n" \
"#endif\n"
#define GLSL_WALL_FUDGES \ #define GLSL_WALL_FUDGES \
"#define STARTMAP_FUDGE 1.05\n" \ "#define STARTMAP_FUDGE 1.05\n" \
+282 -75
View File
@@ -136,32 +136,61 @@ enum
{ {
FBO_NONE, FBO_NONE,
FBO_ARB, FBO_ARB,
FBO_EXT, FBO_EXT
FBO_EXT_STENCIL // supports stencil attachment
}; };
typedef struct typedef struct
{ {
GLuint fboobj; // actual Framebuffer Object GLuint fboobj; // normal single sample fbo
GLuint rboobj; // Renderbuffer Object GLuint rboobj; // normal single sample rbo for depth and stencil stuff
GLuint tex; // Framebuffer texture GLuint tex; // fbo texture for color
GLuint msaa_fboobj; // msaa fbo
GLuint msaa_rboobj; // msaa rbo for color this time
GLuint msaa_depthrboobj; // msaa rbo for depth and stencil stuff
boolean init; boolean init;
boolean msaa; // true if the msaa fbo is the render target ugh
boolean bound; // true if the fbo is currently bound as the framebuffer
} fboobj_t; } fboobj_t;
// this is a little messy but less messy than having two of those tbh
static fboobj_t framebufferobject = {}; static fboobj_t framebufferobject = {};
int supportFBO = FBO_NONE; int supportFBO = FBO_NONE;
// older gl versions might not have these, so prevent compile errors // older gl versions might not have these, so prevent compile errors
// this should still give a simple depth only rbo #ifndef GL_DEPTH_COMPONENT
#define GL_DEPTH_COMPONENT 0x1902
#endif
#ifndef GL_DEPTH_ATTACHMENT_EXT
#define GL_DEPTH_ATTACHMENT_EXT 0x8D00
#endif
#ifndef GL_DEPTH24_STENCIL8 #ifndef GL_DEPTH24_STENCIL8
GL_DEPTH24_STENCIL8 GL_DEPTH_COMPONENT_EXT #define GL_DEPTH24_STENCIL8 0x88F0
#endif #endif
#ifndef GL_DEPTH_STENCIL_ATTACHMENT #ifndef GL_DEPTH_STENCIL_ATTACHMENT
GL_DEPTH_STENCIL_ATTACHMENT GL_DEPTH_ATTACHMENT_EXT #define GL_DEPTH_STENCIL_ATTACHMENT 0x821A
#endif
#ifndef GL_COLOR_ATTACHMENT0_EXT
#define GL_COLOR_ATTACHMENT0_EXT 0x8CE0
#endif
#ifndef GL_READ_FRAMEBUFFER_EXT
#define GL_READ_FRAMEBUFFER_EXT 0x8CA8
#endif
#ifndef GL_DRAW_FRAMEBUFFER_EXT
#define GL_DRAW_FRAMEBUFFER_EXT 0x8CA9
#endif
#ifndef GL_FRAMEBUFFER_EXT
#define GL_FRAMEBUFFER_EXT 0x8D40
#endif
#ifndef GL_RENDERBUFFER_EXT
#define GL_RENDERBUFFER_EXT 0x8D41
#endif
#ifndef GL_FRAMEBUFFER_COMPLETE_EXT
#define GL_FRAMEBUFFER_COMPLETE_EXT 0x8CD5
#endif #endif
static void GL_Framebuffer_DeleteAttachments(void); static void GL_FBO_DeleteAttachments(void);
static void GL_FBO_Resolve(GLbitfield mask);
#endif #endif
// needed for glportals // needed for glportals
@@ -479,6 +508,10 @@ typedef void (APIENTRY * PFNglRenderbufferStorage) (GLenum target, GLenum intern
static PFNglRenderbufferStorage pglRenderbufferStorage; static PFNglRenderbufferStorage pglRenderbufferStorage;
typedef void (APIENTRY * PFNglFramebufferRenderbuffer) (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLenum renderbuffer); typedef void (APIENTRY * PFNglFramebufferRenderbuffer) (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLenum renderbuffer);
static PFNglFramebufferRenderbuffer pglFramebufferRenderbuffer; static PFNglFramebufferRenderbuffer pglFramebufferRenderbuffer;
typedef void (APIENTRY * PFNglRenderbufferStorageMultisample) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
static PFNglRenderbufferStorageMultisample pglRenderbufferStorageMultisample;
typedef void (APIENTRY * PFNglBlitFramebuffer) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
static PFNglBlitFramebuffer pglBlitFramebuffer;
/* 2.1 extension functions for framebuffers and renderbuffers */ /* 2.1 extension functions for framebuffers and renderbuffers */
typedef void (APIENTRY * PFNglGenFramebuffersEXT) (GLsizei n, GLuint *ids); typedef void (APIENTRY * PFNglGenFramebuffersEXT) (GLsizei n, GLuint *ids);
@@ -769,28 +802,22 @@ static GLRGBAFloat shader_defaultcolor = {1.0f, 1.0f, 1.0f, 1.0f};
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
static int GLFramebuffer_CheckExt(void) static int GLFramebuffer_CheckExt(void)
{ {
// in opengl 3.0 and up fbos are standart and always supported // check for the standard arb extensions
if (majorGL >= 3) // these should be there from version 3.0 onwards
return FBO_ARB;
// gl versions from 2.1 may still support framebuffer objects
// maybe, just maybe, we support the standart extensions
if (GL_isExtAvailable("GL_ARB_framebuffer_no_attachments", gl_extensions) && if (GL_isExtAvailable("GL_ARB_framebuffer_no_attachments", gl_extensions) &&
GL_isExtAvailable("GL_ARB_framebuffer_object", gl_extensions) && GL_isExtAvailable("GL_ARB_framebuffer_object", gl_extensions) &&
GL_isExtAvailable("GL_ARB_framebuffer_sRGB", gl_extensions)) GL_isExtAvailable("GL_ARB_framebuffer_sRGB", gl_extensions))
{
return FBO_ARB; return FBO_ARB;
}
// nope, try the older 2.1 extensions // gl versions from 2.1 and older may still support framebuffer objects
// depending on vendor and driver support
if (GL_isExtAvailable("GL_EXT_framebuffer_no_attachments", gl_extensions) && if (GL_isExtAvailable("GL_EXT_framebuffer_no_attachments", gl_extensions) &&
GL_isExtAvailable("GL_EXT_framebuffer_object", gl_extensions) && GL_isExtAvailable("GL_EXT_framebuffer_object", gl_extensions) &&
GL_isExtAvailable("GL_EXT_framebuffer_sRGB", gl_extensions)) GL_isExtAvailable("GL_EXT_framebuffer_sRGB", gl_extensions) &&
GL_isExtAvailable("GL_EXT_packed_depth_stencil", gl_extensions)) // we use the stencil buffer for stuff like portals, so its better to make stencil extension a requirement
{ {
// perhaps we may even support a stencil attachment
if (GL_isExtAvailable("GL_EXT_packed_depth_stencil", gl_extensions))
return FBO_EXT_STENCIL;
// no stencil support, sad
return FBO_EXT; return FBO_EXT;
} }
@@ -906,38 +933,69 @@ void SetupGLFunc4(void)
GetGLfunc(glRenderbufferStorage); GetGLfunc(glRenderbufferStorage);
GetGLfunc(glFramebufferRenderbuffer); GetGLfunc(glFramebufferRenderbuffer);
// multisample support, this should be in core per gl 3.0 and newer
pglRenderbufferStorageMultisample = GetGLFunc("glRenderbufferStorageMultisample");
pglBlitFramebuffer = GetGLFunc("glBlitFramebuffer");
if (!pglRenderbufferStorageMultisample || !pglBlitFramebuffer)
{
pglRenderbufferStorageMultisample = NULL;
pglBlitFramebuffer = NULL;
GL_DBG_Printf("\nFBO: No multisample support\n");
}
GL_DBG_Printf("\nFBO: ARB extensions found\n"); GL_DBG_Printf("\nFBO: ARB extensions found\n");
} }
else if (fbocheck == FBO_EXT || fbocheck == FBO_EXT_STENCIL) // uh oh only support for EXT prefix fbos... else if (fbocheck == FBO_EXT) // uh oh only support old fbo extensions...
{ {
GetGLfunc(glGenFramebuffersEXT);
GetGLfunc(glBindFramebufferEXT);
GetGLfunc(glDeleteFramebuffersEXT);
GetGLfunc(glFramebufferTexture2DEXT);
GetGLfunc(glCheckFramebufferStatusEXT);
GetGLfunc(glGenRenderbuffersEXT);
GetGLfunc(glBindRenderbufferEXT);
GetGLfunc(glDeleteRenderbuffersEXT);
GetGLfunc(glRenderbufferStorageEXT);
GetGLfunc(glFramebufferRenderbufferEXT);
// remapping galore huehue // remapping galore huehue
// do this so we dont have to dupe half our code // do this so we dont have to dupe half our code
GetGLfunc(glGenFramebuffersEXT);
pglGenFramebuffers = pglGenFramebuffersEXT; pglGenFramebuffers = pglGenFramebuffersEXT;
GetGLfunc(glBindFramebufferEXT);
pglBindFramebuffer = pglBindFramebufferEXT; pglBindFramebuffer = pglBindFramebufferEXT;
GetGLfunc(glDeleteFramebuffersEXT);
pglDeleteFramebuffers = pglDeleteFramebuffersEXT; pglDeleteFramebuffers = pglDeleteFramebuffersEXT;
GetGLfunc(glFramebufferTexture2DEXT);
pglFramebufferTexture2D = pglFramebufferTexture2DEXT; pglFramebufferTexture2D = pglFramebufferTexture2DEXT;
GetGLfunc(glCheckFramebufferStatusEXT);
pglCheckFramebufferStatus = pglCheckFramebufferStatusEXT; pglCheckFramebufferStatus = pglCheckFramebufferStatusEXT;
GetGLfunc(glGenRenderbuffersEXT);
pglGenRenderbuffers = pglGenRenderbuffersEXT; pglGenRenderbuffers = pglGenRenderbuffersEXT;
GetGLfunc(glBindRenderbufferEXT);
pglBindRenderbuffer = pglBindRenderbufferEXT; pglBindRenderbuffer = pglBindRenderbufferEXT;
GetGLfunc(glDeleteRenderbuffersEXT);
pglDeleteRenderbuffers = pglDeleteRenderbuffersEXT; pglDeleteRenderbuffers = pglDeleteRenderbuffersEXT;
GetGLfunc(glRenderbufferStorageEXT);
pglRenderbufferStorage = pglRenderbufferStorageEXT; pglRenderbufferStorage = pglRenderbufferStorageEXT;
GetGLfunc(glFramebufferRenderbufferEXT);
pglFramebufferRenderbuffer = pglFramebufferRenderbufferEXT; pglFramebufferRenderbuffer = pglFramebufferRenderbufferEXT;
if (fbocheck == FBO_EXT) // multisample support needs the EXT multisample and blit extensions
GL_DBG_Printf("\nFBO: EXT extensions found, no stencil\n"); if (GL_isExtAvailable("GL_EXT_framebuffer_multisample", gl_extensions) &&
else if (fbocheck == FBO_EXT_STENCIL) GL_isExtAvailable("GL_EXT_framebuffer_blit", gl_extensions))
GL_DBG_Printf("\nFBO: EXT extensions with packed depth-stencil\n"); {
pglRenderbufferStorageMultisample = GetGLFunc("glRenderbufferStorageMultisampleEXT");
pglBlitFramebuffer = GetGLFunc("glBlitFramebufferEXT");
}
if (!pglRenderbufferStorageMultisample || !pglBlitFramebuffer)
{
pglRenderbufferStorageMultisample = NULL;
pglBlitFramebuffer = NULL;
GL_DBG_Printf("\nFBO: No multisample support\n");
}
GL_DBG_Printf("\nFBO: EXT extensions with packed depth-stencil\n");
} }
supportFBO = fbocheck; supportFBO = fbocheck;
@@ -1151,7 +1209,7 @@ void GL_SetModelView(GLint w, GLint h)
GL_FlushScreenTextures(); GL_FlushScreenTextures();
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
GL_Framebuffer_DeleteAttachments(); GL_FBO_DeleteAttachments();
#endif #endif
} }
@@ -1457,6 +1515,15 @@ void GL_ReadScreenTexture(int tex, UINT8 *restrict dest, INT32 scale)
const INT32 stride = (screen_width/scale)*3; const INT32 stride = (screen_width/scale)*3;
INT32 scanlines = screen_height; INT32 scanlines = screen_height;
GLubyte * restrict image; GLubyte * restrict image;
#ifdef USE_FBO_OGL
const boolean msaa_fbo = (framebufferobject.bound && framebufferobject.msaa);
#endif
#ifdef USE_FBO_OGL
// cant read from the msaa fbo, so gotta blit it first into either the single sample fbo or the screen framebuffer....
if (msaa_fbo)
GL_FBO_Resolve(GL_COLOR_BUFFER_BIT);
#endif
// at the time this function is called, generic2 can be found drawn on the framebuffer // at the time this function is called, generic2 can be found drawn on the framebuffer
// if some other screen texture is needed, draw it to the framebuffer // if some other screen texture is needed, draw it to the framebuffer
@@ -1498,9 +1565,16 @@ void GL_ReadScreenTexture(int tex, UINT8 *restrict dest, INT32 scale)
memcpy(dest + i, image + i*scale, 3); memcpy(dest + i, image + i*scale, 3);
dest += stride; dest += stride;
} }
// this probably could be done with fbos, might mess around with that some time :3
// ...yet still, restrict doesn't make the inner loop any faster // ...yet still, restrict doesn't make the inner loop any faster
free(image - ((screen_height % scale) * screen_width*3)); free(image - ((screen_height % scale) * screen_width*3));
#ifdef USE_FBO_OGL
// this´ll reenable the msaa fbo....
if (msaa_fbo)
GL_FBO_Enable();
#endif
} }
// -----------------+ // -----------------+
@@ -2254,7 +2328,7 @@ static void GL_Shader_SetUniforms(FSurfaceInfo *Surface, GLRGBAFloat *poly, GLRG
UNIFORM_1(shader->uniforms[gluniform_leveltime], shader_leveltime, pglUniform1f); UNIFORM_1(shader->uniforms[gluniform_leveltime], shader_leveltime, pglUniform1f);
UNIFORM_2(shader->uniforms[gluniform_scr_resolution], (GLfloat)vid.width, (GLfloat)vid.height, pglUniform2f); UNIFORM_2(shader->uniforms[gluniform_scr_resolution], (GLfloat)screen_width, (GLfloat)screen_height, pglUniform2f);
#undef UNIFORM_1 #undef UNIFORM_1
#undef UNIFORM_2 #undef UNIFORM_2
@@ -2641,11 +2715,7 @@ void GL_SetSpecialState(hwdspecialstate_t IdState, INT32 Value)
case HWD_SET_MSAA: case HWD_SET_MSAA:
if (Value) if (Value)
{
pglEnable(GL_MULTISAMPLE); pglEnable(GL_MULTISAMPLE);
if (Value == 2)
pglEnable(GL_SAMPLE_ALPHA_TO_COVERAGE);
}
break; break;
case HWD_SET_TEXTUREANISOTROPICMODE: case HWD_SET_TEXTUREANISOTROPICMODE:
@@ -3246,9 +3316,9 @@ void GL_SetTransform(FTransform *stransform)
} }
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
static void GL_Framebuffer_DeleteAttachments(void) static void GL_FBO_DeleteAttachments(void)
{ {
if (supportFBO == FBO_NONE || !framebufferobject.init) if (supportFBO == FBO_NONE)
return; return;
// Unbind the framebuffer // Unbind the framebuffer
@@ -3261,14 +3331,45 @@ static void GL_Framebuffer_DeleteAttachments(void)
if (framebufferobject.rboobj) if (framebufferobject.rboobj)
pglDeleteRenderbuffers(1, &framebufferobject.rboobj); pglDeleteRenderbuffers(1, &framebufferobject.rboobj);
if (framebufferobject.msaa_rboobj)
pglDeleteRenderbuffers(1, &framebufferobject.msaa_rboobj);
if (framebufferobject.msaa_depthrboobj)
pglDeleteRenderbuffers(1, &framebufferobject.msaa_depthrboobj);
framebufferobject.tex = 0; framebufferobject.tex = 0;
framebufferobject.rboobj = 0; framebufferobject.rboobj = 0;
framebufferobject.msaa_rboobj = 0;
framebufferobject.msaa_depthrboobj = 0;
framebufferobject.init = false; framebufferobject.init = false;
framebufferobject.bound = false;
} }
static void GL_Framebuffer_Generate(void) // blit the msaa fbo into the normal single sample fbo
// so we can use it to copy from and stuff
static void GL_FBO_Resolve(GLbitfield mask)
{ {
if (supportFBO == FBO_NONE || framebufferobject.init || !UseScreenFBO()) if (supportFBO == FBO_NONE || !framebufferobject.init || !framebufferobject.msaa)
return;
if (!pglBlitFramebuffer)
return;
pglBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, framebufferobject.msaa_fboobj);
pglBindFramebuffer(GL_DRAW_FRAMEBUFFER_EXT, framebufferobject.fboobj);
pglBlitFramebuffer(0, 0, screen_width, screen_height,
0, 0, screen_width, screen_height,
mask, GL_NEAREST);
pglBindFramebuffer(GL_FRAMEBUFFER_EXT, framebufferobject.fboobj);
}
static void GL_FBO_Generate(void)
{
GLint msaasamples;
if (supportFBO == FBO_NONE || framebufferobject.init)
return; return;
// Generate the framebuffer // Generate the framebuffer
@@ -3283,7 +3384,7 @@ static void GL_Framebuffer_Generate(void)
{ {
pglGenTextures(1, &framebufferobject.tex); pglGenTextures(1, &framebufferobject.tex);
pglBindTexture(GL_TEXTURE_2D, framebufferobject.tex); pglBindTexture(GL_TEXTURE_2D, framebufferobject.tex);
pglTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, screen_width, screen_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); pglTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, screen_width, screen_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
Clamp2D(GL_TEXTURE_WRAP_S); Clamp2D(GL_TEXTURE_WRAP_S);
@@ -3306,18 +3407,13 @@ static void GL_Framebuffer_Generate(void)
pglRenderbufferStorage(GL_RENDERBUFFER_EXT, GL_DEPTH24_STENCIL8, screen_width, screen_height); pglRenderbufferStorage(GL_RENDERBUFFER_EXT, GL_DEPTH24_STENCIL8, screen_width, screen_height);
pglFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER_EXT, framebufferobject.rboobj); pglFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER_EXT, framebufferobject.rboobj);
} }
else if (supportFBO == FBO_EXT || supportFBO == FBO_EXT_STENCIL) else if (supportFBO == FBO_EXT)
{ {
pglRenderbufferStorage(GL_RENDERBUFFER_EXT, (supportFBO == FBO_EXT_STENCIL) ? GL_DEPTH_STENCIL_EXT : GL_DEPTH_COMPONENT, screen_width, screen_height); pglRenderbufferStorage(GL_RENDERBUFFER_EXT, GL_DEPTH_STENCIL_EXT, screen_width, screen_height);
// attach the renderbuffer to depth attachment point
// attach a renderbuffer to depth attachment point
pglFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, framebufferobject.rboobj); pglFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, framebufferobject.rboobj);
// attach the renderbuffer to stencil attachment point
if (supportFBO == FBO_EXT_STENCIL) pglFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, framebufferobject.rboobj);
{
// attach a renderbuffer to stencil attachment point
pglFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, framebufferobject.rboobj);
}
} }
// Clear the renderbuffer // Clear the renderbuffer
@@ -3329,48 +3425,124 @@ static void GL_Framebuffer_Generate(void)
if (pglCheckFramebufferStatus(GL_FRAMEBUFFER_EXT) != GL_FRAMEBUFFER_COMPLETE_EXT) if (pglCheckFramebufferStatus(GL_FRAMEBUFFER_EXT) != GL_FRAMEBUFFER_COMPLETE_EXT)
{ {
//pglGetError(); TODO:implement this or smth //pglGetError(); TODO:implement this or smth
GL_MSG_Error("GL_Framebuffer_Generate: Failed to create Framebuffer Object"); GL_MSG_Error("GL_FBO_Generate: Failed to create Framebuffer Object");
// if this fails, dont retry it a gazillion times // if this fails, dont retry it a gazillion times
// this wouldnt recover // this probably wouldnt recover and we dont want any more black screens...
supportFBO = FBO_NONE; supportFBO = FBO_NONE;
pglBindFramebuffer(GL_FRAMEBUFFER_EXT, 0); pglBindFramebuffer(GL_FRAMEBUFFER_EXT, 0);
return; return;
} }
// Try to set up a multisampled render target for MSAA
framebufferobject.msaa = false;
msaasamples = (GLint)msaa;
// maybe should just make more "supportFBO" cases or smth but :chaosleep:
if (msaasamples > 1 && pglRenderbufferStorageMultisample && pglBlitFramebuffer)
{
if (!framebufferobject.msaa_fboobj)
pglGenFramebuffers(1, &framebufferobject.msaa_fboobj);
pglBindFramebuffer(GL_FRAMEBUFFER_EXT, framebufferobject.msaa_fboobj);
// Generate the multisampled color renderbuffer
if (!framebufferobject.msaa_rboobj)
{
pglGenRenderbuffers(1, &framebufferobject.msaa_rboobj);
pglBindRenderbuffer(GL_RENDERBUFFER_EXT, framebufferobject.msaa_rboobj);
pglRenderbufferStorageMultisample(GL_RENDERBUFFER_EXT, msaasamples, GL_RGBA8, screen_width, screen_height);
pglFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, framebufferobject.msaa_rboobj);
}
// Generate the multisampled depth/stencil renderbuffer
if (!framebufferobject.msaa_depthrboobj)
{
pglGenRenderbuffers(1, &framebufferobject.msaa_depthrboobj);
pglBindRenderbuffer(GL_RENDERBUFFER_EXT, framebufferobject.msaa_depthrboobj);
if (supportFBO == FBO_ARB)
{
pglRenderbufferStorageMultisample(GL_RENDERBUFFER_EXT, msaasamples, GL_DEPTH24_STENCIL8, screen_width, screen_height);
pglFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER_EXT, framebufferobject.msaa_depthrboobj);
}
else if (supportFBO == FBO_EXT)
{
pglRenderbufferStorageMultisample(GL_RENDERBUFFER_EXT, msaasamples, GL_DEPTH_STENCIL_EXT, screen_width, screen_height);
// attach a renderbuffer to depth attachment point
pglFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, framebufferobject.msaa_depthrboobj);
// attach a renderbuffer to stencil attachment point
pglFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, framebufferobject.msaa_depthrboobj);
}
}
pglBindRenderbuffer(GL_RENDERBUFFER_EXT, 0);
if (pglCheckFramebufferStatus(GL_FRAMEBUFFER_EXT) == GL_FRAMEBUFFER_COMPLETE_EXT)
{
framebufferobject.msaa = true;
GL_ClearBuffer(true, true, true, NULL);
GL_DBG_Printf("\nGL_FBO_Generate: Multisampled framebuffer created with %d samples\n", msaasamples);
}
else
{
GL_MSG_Warning("GL_FBO_Generate: Failed to create multisampled Framebuffer Object, falling back to no MSAA");
if (framebufferobject.msaa_rboobj)
pglDeleteRenderbuffers(1, &framebufferobject.msaa_rboobj);
if (framebufferobject.msaa_depthrboobj)
pglDeleteRenderbuffers(1, &framebufferobject.msaa_depthrboobj);
framebufferobject.msaa_rboobj = 0;
framebufferobject.msaa_depthrboobj = 0;
}
}
// Unbind the framebuffer // Unbind the framebuffer
pglBindFramebuffer(GL_FRAMEBUFFER_EXT, 0); pglBindFramebuffer(GL_FRAMEBUFFER_EXT, 0);
framebufferobject.init = true; framebufferobject.init = true;
} }
void GL_Framebuffer_Unbind(void) void GL_FBO_BindMainFrameBuffer(void)
{ {
if (supportFBO == FBO_NONE || !framebufferobject.init) if (supportFBO == FBO_NONE)
return; return;
pglBindFramebuffer(GL_FRAMEBUFFER_EXT, 0); pglBindFramebuffer(GL_FRAMEBUFFER_EXT, 0);
pglBindRenderbuffer(GL_RENDERBUFFER_EXT, 0); pglBindRenderbuffer(GL_RENDERBUFFER_EXT, 0);
framebufferobject.bound = false;
} }
void GL_Framebuffer_Enable(void) void GL_FBO_Enable(void)
{ {
if (supportFBO == FBO_NONE || !UseScreenFBO()) if (supportFBO == FBO_NONE)
return; return;
GL_Framebuffer_Generate(); GL_FBO_Generate();
// failed // failed
if (supportFBO == FBO_NONE || !framebufferobject.init) if (!framebufferobject.init)
return; return;
pglBindFramebuffer(GL_FRAMEBUFFER_EXT, framebufferobject.fboobj); if (framebufferobject.msaa)
pglBindRenderbuffer(GL_RENDERBUFFER_EXT, framebufferobject.rboobj); {
pglBindFramebuffer(GL_FRAMEBUFFER_EXT, framebufferobject.msaa_fboobj);
pglBindRenderbuffer(GL_RENDERBUFFER_EXT, framebufferobject.msaa_rboobj);
}
else
{
pglBindFramebuffer(GL_FRAMEBUFFER_EXT, framebufferobject.fboobj);
pglBindRenderbuffer(GL_RENDERBUFFER_EXT, framebufferobject.rboobj);
}
framebufferobject.bound = true;
} }
void GL_Framebuffer_Disable(void) void GL_FBO_Disable(void)
{ {
if (supportFBO == FBO_NONE || !framebufferobject.init) if (supportFBO == FBO_NONE)
return; return;
pglBindFramebuffer(GL_FRAMEBUFFER_EXT, 0); pglBindFramebuffer(GL_FRAMEBUFFER_EXT, 0);
@@ -3381,7 +3553,14 @@ void GL_Framebuffer_Disable(void)
pglDeleteFramebuffers(1, &framebufferobject.fboobj); pglDeleteFramebuffers(1, &framebufferobject.fboobj);
framebufferobject.fboobj = 0; framebufferobject.fboobj = 0;
GL_Framebuffer_DeleteAttachments(); if (framebufferobject.msaa_fboobj)
pglDeleteFramebuffers(1, &framebufferobject.msaa_fboobj);
framebufferobject.msaa_fboobj = 0;
GL_FBO_DeleteAttachments();
framebufferobject.msaa = false;
framebufferobject.bound = false;
} }
#endif #endif
@@ -3732,10 +3911,20 @@ void GL_RenderVhsEffect(fixed_t upbary, fixed_t downbary, UINT8 updistort, UINT8
void GL_MakeScreenTexture(int tex) void GL_MakeScreenTexture(int tex)
{ {
boolean firstTime; boolean firstTime;
static GLint lastfiltermode[NUMSCREENTEXTURES] = {-1, -1, -1, -1, -1};
#ifdef USE_FBO_OGL
const boolean msaa_fbo = (framebufferobject.bound && framebufferobject.msaa);
#endif
if (!gl_enable_screen_textures) if (!gl_enable_screen_textures)
return; return;
#ifdef USE_FBO_OGL
// cant read from the msaa fbo, so gotta blit it first into either the single sample fbo or the screen framebuffer....
if (msaa_fbo)
GL_FBO_Resolve(GL_COLOR_BUFFER_BIT);
#endif
firstTime = (screenTextures[tex] == 0); firstTime = (screenTextures[tex] == 0);
// Create screen texture // Create screen texture
@@ -3744,18 +3933,36 @@ void GL_MakeScreenTexture(int tex)
pglBindTexture(GL_TEXTURE_2D, screenTextures[tex]); pglBindTexture(GL_TEXTURE_2D, screenTextures[tex]);
// if were downsampling, choose to do that with linear filter instead of nearest neighbor
// otherwise well get ugly mixels
GLint filtermode = I_IsDownsampling() ? GL_LINEAR : GL_NEAREST;
// avoid redundant calls to this, prob doesent really matter tbh
if (filtermode != lastfiltermode[tex] || firstTime)
{
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filtermode);
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filtermode);
lastfiltermode[tex] = filtermode;
}
if (firstTime) if (firstTime)
{ {
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
Clamp2D(GL_TEXTURE_WRAP_S); Clamp2D(GL_TEXTURE_WRAP_S);
Clamp2D(GL_TEXTURE_WRAP_T); Clamp2D(GL_TEXTURE_WRAP_T);
pglCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, screen_texsizew, screen_texsizeh, 0); pglCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, screen_texsizew, screen_texsizeh, 0);
} }
else else
{
pglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, screen_texsizew, screen_texsizeh); pglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, screen_texsizew, screen_texsizeh);
}
tex_downloaded = screenTextures[tex]; tex_downloaded = screenTextures[tex];
#ifdef USE_FBO_OGL
if (msaa_fbo)
GL_FBO_Enable();
#endif
} }
void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height) void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height)
+3 -3
View File
@@ -98,9 +98,9 @@ extern PFNglGetString pglGetString;
#endif #endif
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
void GL_Framebuffer_Unbind(void); void GL_FBO_BindMainFrameBuffer(void);
void GL_Framebuffer_Enable(void); void GL_FBO_Enable(void);
void GL_Framebuffer_Disable(void); void GL_FBO_Disable(void);
extern int supportFBO; extern int supportFBO;
#endif #endif
+34 -4
View File
@@ -752,9 +752,14 @@ static inline ssize_t SOCK_SendToAddr(SOCKET_TYPE socket, mysockaddr_t *sockaddr
static void SOCK_Send(void) static void SOCK_Send(void)
{ {
ssize_t c = ERRSOCKET;
int e = 0; // save error code so it can't be modified later code and avoid calling WSAGetLastError() more then once
size_t i, j; size_t i, j;
int retrycount = 0;
ssize_t c;
int e; // save error code so it can't be modified later code and avoid calling WSAGetLastError() more then once
retry:
c = ERRSOCKET;
e = 0;
if (doomcom->remotenode < 0 || !nodeconnected[doomcom->remotenode]) if (doomcom->remotenode < 0 || !nodeconnected[doomcom->remotenode])
return; return;
@@ -808,10 +813,35 @@ static void SOCK_Send(void)
if (c == ERRSOCKET && e != 0) // 0 means no socket for the address family was found if (c == ERRSOCKET && e != 0) // 0 means no socket for the address family was found
{ {
if (!ALLOWEDERROR(e)) if (ALLOWEDERROR(e))
I_Error("SOCK_Send, error sending to node %d (%s) #%u, %s", doomcom->remotenode, return;
//if (!ALLOWEDERROR(e))
//I_Error("SOCK_Send, error sending to node %d (%s) #%u, %s", doomcom->remotenode,
//SOCK_GetNodeAddress(doomcom->remotenode), e, strerror(e));
// no need to spam this on retries
if (retrycount == 0)
CONS_Alert(CONS_ERROR, "SOCK_Send, error sending to node %d (%s) #%u, %s\n", doomcom->remotenode,
SOCK_GetNodeAddress(doomcom->remotenode), e, strerror(e));
// retry sending it
if (retrycount <= 3)
{
CONS_Printf("SOCK_Send: retrying... Attempt %d\n", retrycount+1);
retrycount++;
// wait quarter of a second or smth
I_Sleep(250);
goto retry;
}
// no recovery, guess we die
I_Error("SOCK_Send, error sending to node %d (%s) #%u, %s", doomcom->remotenode,
SOCK_GetNodeAddress(doomcom->remotenode), e, strerror(e)); SOCK_GetNodeAddress(doomcom->remotenode), e, strerror(e));
} }
if (retrycount > 0)
CONS_Alert(CONS_NOTICE, "SOCK_Send: successfully reconnected on Attempt %d\n", retrycount);
} }
#undef ALLOWEDERROR #undef ALLOWEDERROR
+2 -7
View File
@@ -118,19 +118,14 @@ void I_UpdateNoVsync(void);
*/ */
void I_ReadScreen(UINT8 * restrict scr, INT32 scale); void I_ReadScreen(UINT8 * restrict scr, INT32 scale);
UINT32 I_GetRefreshRate(void); UINT32 I_GetRefreshRate(void);
boolean I_CheckNativeRes(void);
void I_SetBorderlessWindow(void); void I_SetBorderlessWindow(void);
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
void I_CheckDownSampleState(boolean forcerefresh);
void RefreshOGLSDLSurface(void); boolean I_IsDownsampling(void);
void I_DownSample(void);
boolean UseScreenFBO(void); boolean UseScreenFBO(void);
extern boolean downsample;
#endif #endif
// So we can call this from i_video event loop // So we can call this from i_video event loop
+2 -2
View File
@@ -3080,8 +3080,8 @@ static int lib_gPlayerDeviceRumble(lua_State *L)
{ {
INT32 pnum = -1; INT32 pnum = -1;
player_t *player = *((player_t **)luaL_checkudata(L, 1, META_PLAYER)); // retrieve player player_t *player = *((player_t **)luaL_checkudata(L, 1, META_PLAYER)); // retrieve player
UINT16 low_strength = (UINT16)luaL_checkinteger(L, 2); // low frequency rumble motor strenght UINT32 low_strength = (UINT32)luaL_checkinteger(L, 2); // low frequency rumble motor strength
UINT16 high_strength = (UINT16)luaL_checkinteger(L, 3); // high frequency rumble motor strenght UINT32 high_strength = (UINT32)luaL_checkinteger(L, 3); // high frequency rumble motor strength
UINT32 duration = (UINT32)luaL_optinteger(L, 4, 84); // duration of rumble in ms UINT32 duration = (UINT32)luaL_optinteger(L, 4, 84); // duration of rumble in ms
if (!player) if (!player)
-10
View File
@@ -18,7 +18,6 @@
#include "p_slopes.h" #include "p_slopes.h"
#include "r_main.h" #include "r_main.h"
#include "lua_udatalib.h"
#include "lua_script.h" #include "lua_script.h"
#include "lua_libs.h" #include "lua_libs.h"
#include "lua_hud.h" // hud_running errors #include "lua_hud.h" // hud_running errors
@@ -256,15 +255,6 @@ static const char *const vector_opt[] = {
static const char *const array_opt[] ={"iterate",NULL}; static const char *const array_opt[] ={"iterate",NULL};
static const char *const valid_opt[] ={"valid",NULL}; static const char *const valid_opt[] ={"valid",NULL};
#define pushsubsector(L, subsector) LUA_PushUserdata(L, subsector, META_SUBSECTOR)
int udatalib_getter_subsector(lua_State *L)
UDATALIB_SIMPLE_GETTER(subsector_t*, pushsubsector)
#undef pushsubsector
#define pushslope(L, slope) LUA_PushUserdata(L, slope, META_SLOPE)
int udatalib_getter_slope(lua_State *L)
UDATALIB_SIMPLE_GETTER(pslope_t*, pushslope)
#undef pushslope
// iterates through a sector's thinglist! // iterates through a sector's thinglist!
static int lib_iterateSectorThinglist(lua_State *L) static int lib_iterateSectorThinglist(lua_State *L)
{ {
+769 -743
View File
File diff suppressed because it is too large. Load diff
+847 -422
View File
File diff suppressed because it is too large. Load diff
-137
View File
@@ -1,137 +0,0 @@
// SONIC ROBO BLAST 2 KART SATURN
//-----------------------------------------------------------------------------
// Copyright (C) 2025 by Indev.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
// See the 'LICENSE' file for more details.
//-----------------------------------------------------------------------------
/// \file lua_udatalib.c
/// \brief Implementation of lua userdata object metatables based on getter/setter functions
#include "doomtype.h"
#include "m_fixed.h"
#include "lua_udatalib.h"
// Getters
int udatalib_getter_fixed(lua_State *L)
UDATALIB_SIMPLE_GETTER(fixed_t, lua_pushinteger)
int udatalib_getter_angle(lua_State *L)
UDATALIB_SIMPLE_GETTER(angle_t, lua_pushangle)
int udatalib_getter_uint8(lua_State *L)
UDATALIB_SIMPLE_GETTER(UINT8, lua_pushinteger)
int udatalib_getter_sint8(lua_State *L)
UDATALIB_SIMPLE_GETTER(SINT8, lua_pushinteger)
int udatalib_getter_uint16(lua_State *L)
UDATALIB_SIMPLE_GETTER(UINT16, lua_pushinteger)
int udatalib_getter_int16(lua_State *L)
UDATALIB_SIMPLE_GETTER(INT16, lua_pushinteger)
int udatalib_getter_uint32(lua_State *L)
UDATALIB_SIMPLE_GETTER(UINT32, lua_pushinteger)
int udatalib_getter_int32(lua_State *L)
UDATALIB_SIMPLE_GETTER(INT32, lua_pushinteger)
int udatalib_getter_uint64(lua_State *L)
UDATALIB_SIMPLE_GETTER(UINT64, lua_pushinteger)
int udatalib_getter_int64(lua_State *L)
UDATALIB_SIMPLE_GETTER(INT64, lua_pushinteger)
int udatalib_getter_string(lua_State *L)
UDATALIB_SIMPLE_GETTER(const char*, lua_pushstring)
int udatalib_getter_boolean(lua_State *L)
UDATALIB_SIMPLE_GETTER(boolean, lua_pushboolean)
int udatalib_getter_spritenum(lua_State *L)
UDATALIB_SIMPLE_GETTER(spritenum_t, lua_pushinteger)
int udatalib_getter_tic(lua_State *L)
UDATALIB_SIMPLE_GETTER(tic_t, lua_pushinteger)
// Setters
int udatalib_setter_fixed(lua_State *L)
UDATALIB_SIMPLE_SETTER(fixed_t, luaL_checkfixed)
int udatalib_setter_angle(lua_State *L)
UDATALIB_SIMPLE_SETTER(angle_t, luaL_checkangle)
int udatalib_setter_uint8(lua_State *L)
UDATALIB_SIMPLE_SETTER(UINT8, (UINT8)luaL_checkinteger)
int udatalib_setter_sint8(lua_State *L)
UDATALIB_SIMPLE_SETTER(SINT8, luaL_checkinteger)
int udatalib_setter_uint16(lua_State *L)
UDATALIB_SIMPLE_SETTER(UINT16, (UINT16)luaL_checkinteger)
int udatalib_setter_int16(lua_State *L)
UDATALIB_SIMPLE_SETTER(INT16, luaL_checkinteger)
int udatalib_setter_uint32(lua_State *L)
UDATALIB_SIMPLE_SETTER(UINT32, (UINT32)luaL_checkinteger)
int udatalib_setter_int32(lua_State *L)
UDATALIB_SIMPLE_SETTER(INT32, luaL_checkinteger)
int udatalib_setter_uint64(lua_State *L)
UDATALIB_SIMPLE_SETTER(UINT64, (UINT64)luaL_checkinteger)
int udatalib_setter_int64(lua_State *L)
UDATALIB_SIMPLE_SETTER(INT64, luaL_checkinteger)
int udatalib_setter_string(lua_State *L)
UDATALIB_SIMPLE_SETTER(const char*, luaL_checkstring)
int udatalib_setter_boolean(lua_State *L)
UDATALIB_SIMPLE_SETTER(boolean, luaL_checkboolean)
// ffs
int udatalib_setter_boolean_nocheck(lua_State *L)
UDATALIB_SIMPLE_SETTER(boolean, lua_toboolean)
int udatalib_setter_spritenum(lua_State *L)
UDATALIB_SIMPLE_SETTER(spritenum_t, luaL_checkinteger)
int udatalib_setter_tic(lua_State *L)
UDATALIB_SIMPLE_SETTER(tic_t, (tic_t)luaL_checkinteger)
void udatalib_addfield(lua_State *L, int mt, udata_field_t field)
{
int idx = abs_index(L, mt);
lua_createtable(L, 2, 0); // Push table
lua_pushinteger(L, field.offset); // Push offset
lua_pushcclosure(L, field.getter, 1); // Pop offset, push closure
lua_rawseti(L, -2, UDATALIB_GETTER); // Pop closure, add to table
lua_pushinteger(L, field.offset); // Push offset
lua_pushcclosure(L, field.setter, 1); // Pop offset, push closure
lua_rawseti(L, -2, UDATALIB_SETTER); // Pop closure, add to table
lua_pushstring(L, field.name); // Push field name
lua_pushvalue(L, -2); // Copy table
lua_rawset(L, idx); // Pop field name and table, add to metatable
lua_pop(L, 1); // Pop field table
}
void udatalib_addfields(lua_State *L, int mt, const udata_field_t fields[])
{
for (unsigned i = 0; fields[i].name != NULL; ++i)
{
udatalib_addfield(L, mt, fields[i]);
//CONS_Printf("Add field name=%s, offset=%d, getter=%p, setter=%p\n", fields[i].name, fields[i].offset, fields[i].getter, fields[i].setter);
}
}
-114
View File
@@ -1,114 +0,0 @@
// SONIC ROBO BLAST 2 KART SATURN
//-----------------------------------------------------------------------------
// Copyright (C) 2025 by Indev.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
// See the 'LICENSE' file for more details.
//-----------------------------------------------------------------------------
/// \file lua_udatalib.h
/// \brief Implementation of lua userdata object metatables based on getter/setter functions
#ifndef __LUA_UDATALIB_H__
#define __LUA_UDATALIB_H__
#include "doomdef.h"
#include "lua_script.h"
#include "lua_libs.h"
#include "fastcmp.h"
// Indices in getter/setter tables for fields
#define UDATALIB_GETTER 1
#define UDATALIB_SETTER 2
typedef struct udata_field_s {
const char *name;
size_t offset;
lua_CFunction getter;
lua_CFunction setter;
} udata_field_t;
// Simple setters and getters, for situations where getter is simply
// "return obj.field" and setter is "obj.field = value"
int udatalib_getter_fixed(lua_State *L);
int udatalib_getter_angle(lua_State *L);
int udatalib_getter_uint8(lua_State *L);
int udatalib_getter_sint8(lua_State *L);
int udatalib_getter_uint16(lua_State *L);
int udatalib_getter_int16(lua_State *L);
int udatalib_getter_uint32(lua_State *L);
int udatalib_getter_int32(lua_State *L);
int udatalib_getter_uint64(lua_State *L);
int udatalib_getter_int64(lua_State *L);
int udatalib_getter_string(lua_State *L);
int udatalib_getter_boolean(lua_State *L);
int udatalib_getter_spritenum(lua_State *L);
int udatalib_getter_mobj(lua_State *L);
int udatalib_getter_subsector(lua_State *L);
int udatalib_getter_mobjtype(lua_State *L);
int udatalib_getter_player(lua_State *L);
int udatalib_getter_mapthing(lua_State *L);
int udatalib_getter_slope(lua_State *L);
int udatalib_getter_cmd(lua_State *L);
int udatalib_getter_playerstate(lua_State *L);
int udatalib_getter_powers(lua_State *L);
int udatalib_getter_kartstuff(lua_State *L);
int udatalib_getter_pflags(lua_State *L);
int udatalib_getter_panim(lua_State *L);
int udatalib_getter_tic(lua_State *L);
int udatalib_setter_fixed(lua_State *L);
int udatalib_setter_angle(lua_State *L);
int udatalib_setter_uint8(lua_State *L);
int udatalib_setter_sint8(lua_State *L);
int udatalib_setter_uint16(lua_State *L);
int udatalib_setter_int16(lua_State *L);
int udatalib_setter_uint32(lua_State *L);
int udatalib_setter_int32(lua_State *L);
int udatalib_setter_uint64(lua_State *L);
int udatalib_setter_int64(lua_State *L);
int udatalib_setter_string(lua_State *L);
int udatalib_setter_boolean(lua_State *L);
int udatalib_setter_boolean_nocheck(lua_State *L);
int udatalib_setter_spritenum(lua_State *L);
int udatalib_setter_mobj(lua_State *L);
int udatalib_setter_playerstate(lua_State *L);
int udatalib_setter_pflags(lua_State *L);
int udatalib_setter_panim(lua_State *L);
int udatalib_setter_tic(lua_State *L);
// Adds setter and getter for field and stores it as field.name..".get" and
// field.name..".set" in table at index mt. (metatable, usually)
void udatalib_addfield(lua_State *L, int mt, udata_field_t field);
// Convinience function to add array of fields at once.
void udatalib_addfields(lua_State *L, int mt, const udata_field_t fields[]);
// I miss C++ template functons :(
// Get pointer to field value within getter or setter
#define UDATALIB_GETFIELD(type, field) \
{ \
size_t offset = lua_tointeger(L, lua_upvalueindex(1)); \
field = (type*)((uint8_t*)lua_touserdata(L, 1) + offset); \
}
// Creates implementation for simple getter and setter. Super lazy, yes.
// Assumes userdata is a pointer to actual data. Maybe not really safe.
#define UDATALIB_SIMPLE_GETTER(type, pushf) \
{ \
type *field; \
UDATALIB_GETFIELD(type, field) \
pushf(L, *field); \
return 1; \
}
#define UDATALIB_SIMPLE_SETTER(type, checkf) \
{ \
type *field; \
UDATALIB_GETFIELD(type, field) \
*field = checkf(L, 2); \
return 0; \
}
#endif
+1 -2
View File
@@ -14,8 +14,7 @@
#include <string.h> #include <string.h>
#ifdef HAVE_THREADS #ifdef HAVE_THREADS
#include <threads.h> #define local_for_thread _Thread_local
#define local_for_thread thread_local
#else #else
#define local_for_thread #define local_for_thread
#endif #endif
+18 -7
View File
@@ -3989,6 +3989,10 @@ boolean replaynamesloaded = false;
// If it's not equal, that means we started more than one thread (left and re-entered menu for example) // If it's not equal, that means we started more than one thread (left and re-entered menu for example)
size_t replaythreadnum = 0; size_t replaythreadnum = 0;
// for replay dates
#include <locale.h>
const char *demodateformat = "%d.%m.%Y";
#ifdef HAVE_THREADS #ifdef HAVE_THREADS
I_mutex replayquerymutex; I_mutex replayquerymutex;
@@ -4025,6 +4029,7 @@ static void ReplayNamesLoadThread(void* userdata)
menudemo_t *demolist_all_local = (menudemo_t*)malloc(sizeof(menudemo_t)*demolist_all_size_local); menudemo_t *demolist_all_local = (menudemo_t*)malloc(sizeof(menudemo_t)*demolist_all_size_local);
memcpy(demolist_all_local, demolist_all, sizeof(menudemo_t)*demolist_all_size_local); memcpy(demolist_all_local, demolist_all, sizeof(menudemo_t)*demolist_all_size_local);
size_t localreplaythreadnum = replaythreadnum; size_t localreplaythreadnum = replaythreadnum;
const char *localdemodateformat = demodateformat;
Unlock_search_state(); Unlock_search_state();
@@ -4032,13 +4037,7 @@ static void ReplayNamesLoadThread(void* userdata)
{ {
if (demolist_all_local[i].type != MD_SUBDIR) if (demolist_all_local[i].type != MD_SUBDIR)
{ {
G_LoadDemoTitle(&demolist_all_local[i]); G_LoadDemoTitle(&demolist_all_local[i], localdemodateformat);
// this is fucking horrid, but i wanna be able to search for dates
/*if (demolist_all_local[i].date[0] != '\0')
{
snprintf(demolist_all_local[i].title, sizeof(demolist_all_local[i].title), "%s %s", demolist_all_local[i].title, demolist_all_local[i].date);
}*/
} }
} }
@@ -4061,6 +4060,18 @@ static void LoadReplayNames(void)
Lock_search_state(); Lock_search_state();
replaythreadnum++; replaythreadnum++;
replaynamesloaded = false; replaynamesloaded = false;
if (cv_demodateformat.value == 2)
demodateformat = "%m.%d.%Y";
else if (cv_demodateformat.value == 1)
demodateformat = "%d.%m.%Y";
else
{
// get the date format here
// setlocale reads/writes global state
const char *locale = setlocale(LC_TIME, NULL);
// US ppl are special (:
demodateformat = (locale && strstr(locale, "en_US")) ? "%m.%d.%Y" : "%d.%m.%Y";
}
Unlock_search_state(); Unlock_search_state();
#ifdef HAVE_THREADS #ifdef HAVE_THREADS
+2 -2
View File
@@ -1004,7 +1004,7 @@ static menuitem_t OP_ExpOptionsMenu[] =
#ifdef HWRENDER #ifdef HWRENDER
{IT_STRING | IT_CVAR, NULL, "Screen Textures", &cv_glscreentextures, 95}, {IT_STRING | IT_CVAR, NULL, "Screen Textures", &cv_glscreentextures, 95},
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
{IT_STRING | IT_CVAR, NULL, "FBO Downsampling support", &cv_glframebuffer, 100}, {IT_STRING | IT_CVAR, NULL, "FBO support", &cv_glframebuffer, 100},
{IT_STRING | IT_CVAR, NULL, "Palette Depth", &cv_glpalettedepth, 110}, {IT_STRING | IT_CVAR, NULL, "Palette Depth", &cv_glpalettedepth, 110},
{IT_DISABLED, NULL, "", NULL, 120}, // dummy text {IT_DISABLED, NULL, "", NULL, 120}, // dummy text
#else #else
@@ -1030,7 +1030,7 @@ static const char* OP_ExpTooltips[] =
#ifdef HWRENDER #ifdef HWRENDER
"Disabling Screen Textures may result in a performance boost\nbut will break certain effects.\nScreen textures are required at resolutions lower than your desktop resolution!", "Disabling Screen Textures may result in a performance boost\nbut will break certain effects.\nScreen textures are required at resolutions lower than your desktop resolution!",
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
"Allows the game to downsample from a higher resolution\nthan your display in OpenGL renderer mode.\nRequires a GPU with atleast OpenGL 2.1 support.", "Allows the game to downsample from a higher resolution\nthan your display in OpenGL renderer mode.\nThis can be set to automatically enable if the game resolution\nis higher than the current Display Resolution\nor enabled at all times.\nThis may improve performance in some cases.\nRequires a GPU with atleast OpenGL 2.1 support.",
#endif #endif
"Change the bit depth of the Lookup Palette in Palette rendering mode\n 16 bits is like software looks ingame\nwhile 24 bits is how software looks in screenshots.", "Change the bit depth of the Lookup Palette in Palette rendering mode\n 16 bits is like software looks ingame\nwhile 24 bits is how software looks in screenshots.",
#endif #endif
+11 -6
View File
@@ -570,13 +570,13 @@ static void P_LoadSegs(UINT8 *data)
if (seg->sidedef == &sides[seg->linedef->sidenum[0]]) if (seg->sidedef == &sides[seg->linedef->sidenum[0]])
{ {
seg->v1 = lines[ms->linedef].v1; seg->v1 = lines[rawlinedef].v1;
seg->v2 = lines[ms->linedef].v2; seg->v2 = lines[rawlinedef].v2;
} }
else else
{ {
seg->v1 = lines[ms->linedef].v2; seg->v1 = lines[rawlinedef].v2;
seg->v2 = lines[ms->linedef].v1; seg->v2 = lines[rawlinedef].v1;
} }
} }
else else
@@ -584,7 +584,6 @@ static void P_LoadSegs(UINT8 *data)
seg->v1 = &vertexes[v1]; seg->v1 = &vertexes[v1];
seg->v2 = &vertexes[v2]; seg->v2 = &vertexes[v2];
} }
#ifdef HWRENDER #ifdef HWRENDER
if (rendermode == render_opengl) if (rendermode == render_opengl)
{ {
@@ -597,7 +596,6 @@ static void P_LoadSegs(UINT8 *data)
//seg->fv2.z = FixedToFloat(seg->v2->z); //seg->fv2.z = FixedToFloat(seg->v2->z);
} }
#endif #endif
seg->length = P_SegLength(seg); seg->length = P_SegLength(seg);
P_UpdateSegLightOffset(seg); P_UpdateSegLightOffset(seg);
@@ -2096,6 +2094,13 @@ static void P_LoadMapBSP(const virtres_t* virt)
virtlump_t* virtsegs = vres_Find(virt, "SEGS"); virtlump_t* virtsegs = vres_Find(virt, "SEGS");
virtlump_t* virtnodes = vres_Find(virt, "NODES"); virtlump_t* virtnodes = vres_Find(virt, "NODES");
if (!virtssectors)
I_Error("SSECTORS lump not found");
if (!virtsegs)
I_Error("SEGS lump not found");
if (!virtnodes)
I_Error("NODES lump not found");
numsubsectors = virtssectors->size / sizeof(mapsubsector_t); numsubsectors = virtssectors->size / sizeof(mapsubsector_t);
numnodes = virtnodes->size / sizeof(mapnode_t); numnodes = virtnodes->size / sizeof(mapnode_t);
numsegs = virtsegs->size / sizeof(mapseg_t); numsegs = virtsegs->size / sizeof(mapseg_t);
+10 -10
View File
@@ -66,22 +66,22 @@ static void P_UpdateSlopeLightOffset(pslope_t *slope)
nY = FixedDiv(nY, nLen); nY = FixedDiv(nY, nLen);
/* /*
* if (slope is ceiling) if (slope is ceiling)
* { {
* // There is no good way to calculate this condition here. // There is no good way to calculate this condition here.
* // We reverse it in R_FindPlane now. // We reverse it in R_FindPlane now.
* nX = -nX; nX = -nX;
* nY = -nY; nY = -nY;
* } }
*/ */
light = FixedMul(nX, FINECOSINE(maplighting.angle >> ANGLETOFINESHIFT)) light = FixedMul(nX, FINECOSINE(maplighting.angle >> ANGLETOFINESHIFT))
+ FixedMul(nY, FINESINE(maplighting.angle >> ANGLETOFINESHIFT)); + FixedMul(nY, FINESINE(maplighting.angle >> ANGLETOFINESHIFT));
light = (light + FRACUNIT) / 2; light = (light + FRACUNIT) / 2;
} }
else else
{ {
light = FixedDiv(R_PointToAngle2(0, 0, abs(slope->d.x), abs(slope->d.y)), ANGLE_90); light = FixedDiv(R_PointToAngle2(0, 0, abs(slope->normal.y), abs(slope->normal.x)), ANGLE_90);
} }
const int delta = abs(slope->zdelta)*3/2; // *3/2, to make 60 degree slopes match walls. const int delta = abs(slope->zdelta)*3/2; // *3/2, to make 60 degree slopes match walls.
+3
View File
@@ -504,6 +504,9 @@ typedef struct subsector_s
void *splats; // floorsplat_t list void *splats; // floorsplat_t list
#endif #endif
size_t validcount; size_t validcount;
#ifdef HWRENDER
boolean hashorizon; // not really needed for software, this stuff works differently there
#endif
} subsector_t; } subsector_t;
// Sector list node showing all sectors an object appears in. // Sector list node showing all sectors an object appears in.
+14 -14
View File
@@ -350,8 +350,8 @@ void R_ClearPlanes(void)
angle = (viewangle-ANGLE_90)>>ANGLETOFINESHIFT; angle = (viewangle-ANGLE_90)>>ANGLETOFINESHIFT;
// scale will be unit scale at SCREENWIDTH/2 distance // scale will be unit scale at SCREENWIDTH/2 distance
basexscale = FixedDiv (FINECOSINE(angle), centerxfrac); basexscale = FixedDiv(FINECOSINE(angle), centerxfrac);
baseyscale = -FixedDiv (FINESINE(angle), centerxfrac); baseyscale = -FixedDiv(FINESINE(angle), centerxfrac);
} }
static visplane_t *new_visplane(unsigned hash) static visplane_t *new_visplane(unsigned hash)
@@ -440,20 +440,20 @@ visplane_t *R_FindPlane(fixed_t height, INT32 picnum, INT32 lightlevel,
} }
} }
if (slope != NULL && P_ApplyLightOffset(lightlevel >> LIGHTSEGSHIFT, lighting_sector))
{
if (reverseLight && maplighting.directional == true)
{
lightlevel -= slope->lightOffset * 8;
}
else
{
lightlevel += slope->lightOffset * 8;
}
}
if (!pfloor) if (!pfloor)
{ {
if (slope != NULL && P_ApplyLightOffset(lightlevel >> LIGHTSEGSHIFT, lighting_sector))
{
if (reverseLight)
{
lightlevel -= slope->lightOffset * 8;
}
else
{
lightlevel += slope->lightOffset * 8;
}
}
hash = visplane_hash(picnum, lightlevel, height >> FRACBITS); hash = visplane_hash(picnum, lightlevel, height >> FRACBITS);
for (check = visplanes[hash]; check; check = check->next) for (check = visplanes[hash]; check; check = check->next)
+8 -3
View File
@@ -233,20 +233,25 @@ if(${SDL2_FOUND})
-DHAVE_THREADS -DHAVE_THREADS
) )
if(SRB2_CONFIG_LTO AND NOT SRB2_CONFIG_DEBUGMODE) if(SRB2_CONFIG_LTO AND NOT SRB2_CONFIG_DEBUGMODE AND NOT SRB2_CONFIG_ASAN AND NOT SRB2_CONFIG_UBSAN AND NOT SRB2_CONFIG_TSAN)
set_property(TARGET SRB2SDL2 PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE) set_property(TARGET SRB2SDL2 PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
endif() endif()
if(SRB2_CONFIG_ASAN) if(SRB2_CONFIG_ASAN)
target_compile_options(SRB2SDL2 PRIVATE -fsanitize=address) target_compile_options(SRB2SDL2 PRIVATE -O1 -fsanitize=address -fno-omit-frame-pointer -fno-common)
target_link_options(SRB2SDL2 PRIVATE -fsanitize=address) target_link_options(SRB2SDL2 PRIVATE -fsanitize=address)
endif() endif()
if(SRB2_CONFIG_UBSAN) if(SRB2_CONFIG_UBSAN)
target_compile_options(SRB2SDL2 PRIVATE -fsanitize=undefined) target_compile_options(SRB2SDL2 PRIVATE -O1 -fsanitize=undefined -fno-omit-frame-pointer)
target_link_options(SRB2SDL2 PRIVATE -fsanitize=undefined) target_link_options(SRB2SDL2 PRIVATE -fsanitize=undefined)
endif() endif()
if(SRB2_CONFIG_TSAN)
target_compile_options(SRB2SDL2 PRIVATE -O1 -fsanitize=thread -fno-omit-frame-pointer)
target_link_options(SRB2SDL2 PRIVATE -fsanitize=thread)
endif()
if(NOT SRB2_CONFIG_MUMBLE) if(NOT SRB2_CONFIG_MUMBLE)
target_compile_options(SRB2SDL2 PRIVATE -DNOMUMBLE) target_compile_options(SRB2SDL2 PRIVATE -DNOMUMBLE)
endif() endif()
+11 -19
View File
@@ -80,12 +80,9 @@ typedef LPVOID (WINAPI *p_MapViewOfFile) (HANDLE, DWORD, DWORD, DWORD, SIZE_T);
#include "i_ttf.h" #include "i_ttf.h"
#endif #endif
#include "SDL_cpuinfo.h" #if defined (__unix__) || defined(__APPLE__) || defined (UNIXCOMMON)
#define HAVE_SDLCPUINFO #if defined (__linux__) || defined (__HAIKU__)
#include <sys/statvfs.h>
#if defined (__unix__) || defined(__APPLE__) || (defined (UNIXCOMMON) && !defined (__HAIKU__))
#if defined (__linux__)
#include <sys/vfs.h>
#elif defined(__APPLE__) #elif defined(__APPLE__)
#include <sys/param.h> #include <sys/param.h>
#include <sys/mount.h> #include <sys/mount.h>
@@ -93,6 +90,7 @@ typedef LPVOID (WINAPI *p_MapViewOfFile) (HANDLE, DWORD, DWORD, DWORD, SIZE_T);
#include <sys/sysctl.h> #include <sys/sysctl.h>
#include <mach/mach.h> #include <mach/mach.h>
#else #else
#include <sys/statvfs.h>
#include <sys/param.h> #include <sys/param.h>
#include <sys/mount.h> #include <sys/mount.h>
/*For meminfo*/ /*For meminfo*/
@@ -105,7 +103,7 @@ typedef LPVOID (WINAPI *p_MapViewOfFile) (HANDLE, DWORD, DWORD, DWORD, SIZE_T);
#endif #endif
#endif #endif
#if defined (__linux__) || (defined (UNIXCOMMON) && !defined (__HAIKU__)) #if defined (__linux__) || defined (UNIXCOMMON)
#ifndef NOTERMIOS #ifndef NOTERMIOS
#include <termios.h> #include <termios.h>
#include <sys/ioctl.h> // ioctl #include <sys/ioctl.h> // ioctl
@@ -120,8 +118,10 @@ typedef LPVOID (WINAPI *p_MapViewOfFile) (HANDLE, DWORD, DWORD, DWORD, SIZE_T);
#if defined (__unix__) || (defined (UNIXCOMMON) && !defined (__APPLE__)) #if defined (__unix__) || (defined (UNIXCOMMON) && !defined (__APPLE__))
#include <errno.h> #include <errno.h>
#include <sys/wait.h> #include <sys/wait.h>
#ifndef __HAIKU__ // haiku's crash dialog is just objectively better
#define NEWSIGNALHANDLER #define NEWSIGNALHANDLER
#endif #endif
#endif
#ifndef NOMUMBLE #ifndef NOMUMBLE
#ifdef __linux__ // need -lrt #ifdef __linux__ // need -lrt
@@ -195,7 +195,6 @@ static char returnWadPath[256];
#include "../i_sound.h" #include "../i_sound.h"
#include "../i_system.h" #include "../i_system.h"
#include "../i_threads.h" #include "../i_threads.h"
#include "../screen.h" //vid.WndParent
#include "../d_net.h" #include "../d_net.h"
#include "../g_game.h" #include "../g_game.h"
#include "../g_demo.h" #include "../g_demo.h"
@@ -208,9 +207,6 @@ static char returnWadPath[256];
#include "../m_argv.h" #include "../m_argv.h"
#include "../r_main.h" // Frame interpolation/uncapped
#include "../r_fps.h"
#include "../s_sound.h" #include "../s_sound.h"
#include "../d_main.h" #include "../d_main.h"
@@ -274,7 +270,7 @@ static void tty_Clear(void)
write(STDOUT_FILENO, "\r", 1); write(STDOUT_FILENO, "\r", 1);
if (tty_con.cursor>0) if (tty_con.cursor>0)
{ {
for (i=0; i<tty_con.cursor; i++) for (i = 0; i < tty_con.cursor; i++)
{ {
write(STDOUT_FILENO, " ", 1); write(STDOUT_FILENO, " ", 1);
} }
@@ -2291,18 +2287,13 @@ void I_ShutdownSystem(void)
void I_GetDiskFreeSpace(INT64 *freespace) void I_GetDiskFreeSpace(INT64 *freespace)
{ {
#if defined (__unix__) || defined(__APPLE__) || defined (UNIXCOMMON) #if defined (__unix__) || defined(__APPLE__) || defined (UNIXCOMMON)
#if defined (SOLARIS) || defined (__HAIKU__) struct statvfs stfs;
*freespace = INT32_MAX; if (statvfs(srb2home, &stfs) == -1)
return;
#else // Both Linux and BSD have this, apparently.
struct statfs stfs;
if (statfs(".", &stfs) == -1)
{ {
*freespace = INT32_MAX; *freespace = INT32_MAX;
return; return;
} }
*freespace = stfs.f_bavail * stfs.f_bsize; *freespace = stfs.f_bavail * stfs.f_bsize;
#endif
#elif defined (_WIN32) #elif defined (_WIN32)
static p_GetDiskFreeSpaceExA pfnGetDiskFreeSpaceEx = NULL; static p_GetDiskFreeSpaceExA pfnGetDiskFreeSpaceEx = NULL;
static boolean testwin95 = false; static boolean testwin95 = false;
@@ -2313,6 +2304,7 @@ void I_GetDiskFreeSpace(INT64 *freespace)
pfnGetDiskFreeSpaceEx = (p_GetDiskFreeSpaceExA)(LPVOID)GetProcAddress(GetModuleHandleA("kernel32.dll"), "GetDiskFreeSpaceExA"); pfnGetDiskFreeSpaceEx = (p_GetDiskFreeSpaceExA)(LPVOID)GetProcAddress(GetModuleHandleA("kernel32.dll"), "GetDiskFreeSpaceExA");
testwin95 = true; testwin95 = true;
} }
if (pfnGetDiskFreeSpaceEx) if (pfnGetDiskFreeSpaceEx)
{ {
if (pfnGetDiskFreeSpaceEx(NULL, &lfreespace, &usedbytes, NULL)) if (pfnGetDiskFreeSpaceEx(NULL, &lfreespace, &usedbytes, NULL))
+34 -104
View File
@@ -97,11 +97,9 @@ static char vidModeName[33][32]; // allow 33 different modes
rendermode_t rendermode = render_none; rendermode_t rendermode = render_none;
#ifdef HWRENDER #ifdef HWRENDER
unsigned msaa = 0;
// Eee probably the way i organize it isn't best >< // Eee probably the way i organize it isn't best ><
// Just don't know where do i put declaration and "implementation" // Just don't know where do i put declaration and "implementation"
boolean a2c = false; unsigned msaa = 0;
#endif #endif
static void KeyboardLayout_OnChange(void) static void KeyboardLayout_OnChange(void)
@@ -115,10 +113,6 @@ consvar_t cv_keyboardlayout = {"keyboardlayout", "Default US", CV_SAVE|CV_CALL,
static void Impl_SetVsync(void); static void Impl_SetVsync(void);
static INT32 desktopwidth = 0, desktopheight = 0;
static void I_CheckDesktopRes(void);
// synchronize page flipping with screen refresh // synchronize page flipping with screen refresh
consvar_t cv_vidwait = {"vid_wait", "Off", CV_SAVE|CV_CALL|CV_NOINIT, CV_OnOff, Impl_SetVsync, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_vidwait = {"vid_wait", "Off", CV_SAVE|CV_CALL|CV_NOINIT, CV_OnOff, Impl_SetVsync, 0, NULL, NULL, 0, 0, NULL};
static consvar_t cv_stretch = {"stretch", "Off", CV_SAVE|CV_NOSHOWHELP, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; static consvar_t cv_stretch = {"stretch", "Off", CV_SAVE|CV_NOSHOWHELP, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
@@ -197,10 +191,6 @@ static INT32 custom_height = 0;
static SDL_bool Impl_CreateWindow(SDL_bool fullscreen); static SDL_bool Impl_CreateWindow(SDL_bool fullscreen);
static void Impl_SetWindowIcon(void); static void Impl_SetWindowIcon(void);
#ifdef USE_FBO_OGL
boolean downsample = false;
#endif
static INT32 Impl_SDL_Scancode_To_Keycode(SDL_Scancode code) static INT32 Impl_SDL_Scancode_To_Keycode(SDL_Scancode code)
{ {
if (code >= SDL_SCANCODE_A && code <= SDL_SCANCODE_Z) if (code >= SDL_SCANCODE_A && code <= SDL_SCANCODE_Z)
@@ -518,11 +508,11 @@ static void Impl_HandleWindowEvent(SDL_WindowEvent evt)
return; return;
} }
if (windowmoved && rendermode == render_opengl) if (windowmoved)
{ {
I_CheckDesktopRes();
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
I_DownSample(); if (rendermode == render_opengl)
I_CheckDownSampleState(false);
#endif #endif
windowmoved = SDL_FALSE; windowmoved = SDL_FALSE;
} }
@@ -1229,9 +1219,7 @@ static void VID_Command_ModeList_f(void)
// List windowed modes // List windowed modes
INT32 i = 0; INT32 i = 0;
CONS_Printf("NOTE: Under SDL2, all modes are supported on all platforms.\n" CONS_Printf("NOTE: Under SDL2, all modes are supported on all platforms.\n");
"Under opengl, fullscreen only supports native desktop resolution.\n"
"Under software, the mode is stretched up to desktop resolution.\n");
for (i = 0; i < MAXWINMODES; i++) for (i = 0; i < MAXWINMODES; i++)
{ {
@@ -1257,78 +1245,41 @@ static void VID_Command_Mode_f (void)
setmodeneeded = modenum+1; // request vid mode change setmodeneeded = modenum+1; // request vid mode change
} }
// Get the desktop resolution from the current display the gamewindow resides on
static void I_CheckDesktopRes(void)
{
int currentDisplayIndex = -1;
SDL_DisplayMode curmode;
desktopwidth = 0;
desktopheight = 0;
currentDisplayIndex = SDL_GetWindowDisplayIndex(window);
// No valid index
if (currentDisplayIndex < 0)
{
return;
}
if (SDL_GetDesktopDisplayMode(currentDisplayIndex, &curmode) != 0)
{
return;
}
desktopwidth = curmode.w;
desktopheight = curmode.h;
}
// Check if the game resolution matches the desktop resolution
boolean I_CheckNativeRes(void)
{
return (vid.width == desktopwidth && vid.height == desktopheight);
}
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
static boolean vid_downsampling = false;
void RefreshOGLSDLSurface(void) boolean I_IsDownsampling(void)
{ {
if (rendermode == render_opengl) return vid_downsampling;
OglSdlSurface(vid.width, vid.height);
} }
void I_DownSample(void) void I_CheckDownSampleState(boolean forcerefresh)
{ {
boolean needrefresh = false; // no fbo support so we dont care
if (!supportFBO)
if (!cv_glframebuffer.value || !supportFBO || (cv_glscreentextures.value == 0)) // no sense to do this crap if we cant benefit from it
{ {
downsample = false; vid_downsampling = false;
return; return;
} }
if (I_CheckNativeRes() && (downsample == true)) // no sense to do this crap if we cant benefit from it
boolean newdownsamplestate = false;
if (cv_glframebuffer.value && (cv_glscreentextures.value == 2))
{ {
downsample = false; int sdlw, sdlh;
RefreshOGLSDLSurface(); SDL_GetWindowSize(window, &sdlw, &sdlh);
return; if (vid.width > sdlw || vid.height > sdlh)
newdownsamplestate = true;
} }
if ((vid.width > desktopwidth) || (vid.height > desktopheight)) //check if current resolution is higher than current display resolution // state changed or fbo was toggled
if (vid_downsampling != newdownsamplestate || forcerefresh)
{ {
downsample = true; //printf("downsample changed from %d to %d\n", vid_downsampling, newdownsamplestate);
needrefresh = true; // needs to be reset before refreshing the gl surface!
} vid_downsampling = newdownsamplestate;
else if (downsample == true) OglSdlSurface(vid.width, vid.height);
{
downsample = false;
needrefresh = true;
}
if (needrefresh)
{
RefreshOGLSDLSurface();
needrefresh = false;
} }
} }
#endif #endif
@@ -1360,9 +1311,10 @@ static void SDLSetMode(INT32 width, INT32 height, SDL_bool fullscreen)
// Reposition window only in windowed mode // Reposition window only in windowed mode
SDL_SetWindowSize(window, width, height); SDL_SetWindowSize(window, width, height);
const int windowpos = SDL_GetWindowDisplayIndex(window);
SDL_SetWindowPosition(window, SDL_SetWindowPosition(window,
SDL_WINDOWPOS_CENTERED_DISPLAY(SDL_GetWindowDisplayIndex(window)), SDL_WINDOWPOS_CENTERED_DISPLAY(windowpos),
SDL_WINDOWPOS_CENTERED_DISPLAY(SDL_GetWindowDisplayIndex(window)) SDL_WINDOWPOS_CENTERED_DISPLAY(windowpos)
); );
} }
} }
@@ -1382,9 +1334,8 @@ static void SDLSetMode(INT32 width, INT32 height, SDL_bool fullscreen)
#ifdef HWRENDER #ifdef HWRENDER
if (rendermode == render_opengl) if (rendermode == render_opengl)
{ {
I_CheckDesktopRes();
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
I_DownSample(); I_CheckDownSampleState(false);
#endif #endif
OglSdlSurface(vid.width, vid.height); OglSdlSurface(vid.width, vid.height);
} }
@@ -1580,7 +1531,7 @@ void VID_PrepareModeList(void)
static UINT32 refresh_rate; static UINT32 refresh_rate;
static UINT32 VID_GetRefreshRate(void) static UINT32 VID_GetRefreshRate(void)
{ {
int index = SDL_GetWindowDisplayIndex(window); int index;
SDL_DisplayMode m; SDL_DisplayMode m;
if (SDL_WasInit(SDL_INIT_VIDEO) == 0) if (SDL_WasInit(SDL_INIT_VIDEO) == 0)
@@ -1589,6 +1540,8 @@ static UINT32 VID_GetRefreshRate(void)
return 0; return 0;
} }
index = SDL_GetWindowDisplayIndex(window);
if (SDL_GetDesktopDisplayMode(index, &m) != 0) if (SDL_GetDesktopDisplayMode(index, &m) != 0)
{ {
// Error has occurred. // Error has occurred.
@@ -1825,7 +1778,6 @@ void I_StartupGraphics(void)
rendermode = render_opengl; rendermode = render_opengl;
msaa = 0; boolean msaa_set = false; msaa = 0; boolean msaa_set = false;
a2c = false; boolean a2c_set = false;
// MSAA antialiasing // MSAA antialiasing
if (M_CheckParm("-msaa") && M_IsNextParm()) if (M_CheckParm("-msaa") && M_IsNextParm())
@@ -1837,16 +1789,6 @@ void I_StartupGraphics(void)
} }
} }
if (M_CheckParm("-a2c"))
{
a2c = true;
a2c_set = true;
}
else if (M_CheckParm("-noa2c"))
{
a2c_set = true;
}
{ {
char line[16]; char line[16];
char * word; char * word;
@@ -1890,19 +1832,10 @@ void I_StartupGraphics(void)
} }
else else
{ {
CONS_Printf("Using last know MSAA value: %u\n", msaa); CONS_Printf("Using last known MSAA value: %u\n", msaa);
} }
} }
} }
if (!a2c_set)
{
if (fasticmp(word, "a2c"))
{
a2c = true;
CONS_Printf("Using a2c because it was specified to be used earlier\n");
}
}
} }
fclose(file); fclose(file);
@@ -1937,9 +1870,6 @@ void I_StartupGraphics(void)
#ifdef HWRENDER #ifdef HWRENDER
fprintf(file, "msaa %u\n", msaa); fprintf(file, "msaa %u\n", msaa);
if (a2c)
fputs("a2c\n", file);
#endif #endif
fclose(file); fclose(file);
} }
+7 -13
View File
@@ -65,7 +65,7 @@ PFNglGetString pglGetString;
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
boolean UseScreenFBO(void) boolean UseScreenFBO(void)
{ {
return (supportFBO && cv_glframebuffer.value && downsample); return (supportFBO && cv_glframebuffer.value && (cv_glscreentextures.value == 2) && (cv_glframebuffer.value == 2 || I_IsDownsampling()));
} }
#endif #endif
@@ -203,9 +203,9 @@ boolean OglSdlSurface(INT32 w, INT32 h)
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
if (UseScreenFBO()) if (UseScreenFBO())
GL_Framebuffer_Enable(); GL_FBO_Enable();
else else
GL_Framebuffer_Disable(); GL_FBO_Disable();
#endif #endif
if (!first_init) if (!first_init)
@@ -225,7 +225,6 @@ boolean OglSdlSurface(INT32 w, INT32 h)
void OglSdlFinishUpdate(SDL_Window *window) void OglSdlFinishUpdate(SDL_Window *window)
{ {
int sdlw, sdlh; int sdlw, sdlh;
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
const boolean usefbo = UseScreenFBO(); const boolean usefbo = UseScreenFBO();
#endif #endif
@@ -235,9 +234,7 @@ void OglSdlFinishUpdate(SDL_Window *window)
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
if (usefbo) if (usefbo)
{ GL_FBO_BindMainFrameBuffer();
GL_Framebuffer_Unbind();
}
#endif #endif
if (HWR_ShouldUsePaletteRendering()) if (HWR_ShouldUsePaletteRendering())
@@ -255,9 +252,7 @@ void OglSdlFinishUpdate(SDL_Window *window)
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
if (usefbo) if (usefbo)
{ GL_FBO_Enable();
GL_Framebuffer_Enable();
}
#endif #endif
SDL_GL_SwapWindow(window); SDL_GL_SwapWindow(window);
@@ -266,11 +261,10 @@ void OglSdlFinishUpdate(SDL_Window *window)
// Sryder: We need to draw the final screen texture again into the other buffer in the original position so that // Sryder: We need to draw the final screen texture again into the other buffer in the original position so that
// effects that want to take the old screen can do so after this // effects that want to take the old screen can do so after this
// well we dont need it on native res it seems
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
if ((!I_CheckNativeRes() && !usefbo) || WipeInAction) if (!usefbo && (realwidth != sdlw || realheight != sdlh)) // not needed if fbo is in use
#else #else
if (!I_CheckNativeRes() || WipeInAction) if (realwidth != sdlw || realheight != sdlh) // this is not needed if the render size matches window size
#endif #endif
HWR_DrawScreenFinalTexture(realwidth, realheight); HWR_DrawScreenFinalTexture(realwidth, realheight);
} }
+19 -16
View File
@@ -1839,8 +1839,11 @@ void V_DrawHorizontallyScaledFullScreenPatch(patch_t *patch)
void V_DrawVhsEffect(boolean rewind) void V_DrawVhsEffect(boolean rewind)
{ {
fixed_t uby, dby; fixed_t uby, dby;
// upbary is the bar going from top to bottom for some reason static fixed_t upbary_normal = 100*FRACUNIT, downbary_normal = 150*FRACUNIT;
static fixed_t upbary = 100*FRACUNIT, downbary = 150*FRACUNIT; static fixed_t upbary_rewind = 100*FRACUNIT, downbary_rewind = 150*FRACUNIT;
fixed_t *upbary = rewind ? &upbary_rewind : &upbary_normal;
fixed_t *downbary = rewind ? &downbary_rewind : &downbary_normal;
UINT8 barsize, updistort, downdistort; UINT8 barsize, updistort, downdistort;
@@ -1864,20 +1867,20 @@ void V_DrawVhsEffect(boolean rewind)
if (rewind) if (rewind)
V_DrawVhsEffect(false); // experimentation V_DrawVhsEffect(false); // experimentation
upbary -= renderdeltatics * (fixed_t)(vid.udup * (rewind ? 3 : 1.8f)); *upbary -= renderdeltatics * (fixed_t)(vid.udup * (rewind ? 3 : 1.8f));
downbary += renderdeltatics * (vid.udup * (rewind ? 2 : 1)); *downbary += renderdeltatics * (vid.udup * (rewind ? 2 : 1));
if (upbary < -barsize*FRACUNIT) if (*upbary < -barsize*FRACUNIT)
upbary = vid.height << FRACBITS; *upbary = vid.height << FRACBITS;
if (upbary > vid.height << FRACBITS) if (*upbary > vid.height << FRACBITS)
upbary = -barsize*FRACUNIT; *upbary = -barsize*FRACUNIT;
if (downbary > vid.height << FRACBITS) if (*downbary > vid.height << FRACBITS)
downbary = -barsize*FRACUNIT; *downbary = -barsize*FRACUNIT;
if (downbary < -barsize*FRACUNIT) if (*downbary < -barsize*FRACUNIT)
downbary = vid.height << FRACBITS; *downbary = vid.height << FRACBITS;
uby = upbary >> FRACBITS; uby = *upbary >> FRACBITS;
dby = downbary >> FRACBITS; dby = *downbary >> FRACBITS;
#ifdef HWRENDER #ifdef HWRENDER
if (rendermode == render_opengl) if (rendermode == render_opengl)
@@ -1897,7 +1900,7 @@ void V_DrawVhsEffect(boolean rewind)
pos = 0; pos = 0;
for (y = 0; y < vid.height; y+=2) for (y = 0; y < vid.height; y += 2)
{ {
thismapstart = normalmapstart; thismapstart = normalmapstart;
offs = 0; offs = 0;
@@ -1914,7 +1917,7 @@ void V_DrawVhsEffect(boolean rewind)
offs -= downdistort * 2.0f * min(y-dby, dby+barsize-y) / barsize; offs -= downdistort * 2.0f * min(y-dby, dby+barsize-y) / barsize;
} }
offs += M_RandomKey(vid.dup<<1); offs += M_RandomKey(vid.udup<<1);
// lazy way to avoid crashes // lazy way to avoid crashes
if ((y == 0 && offs < 0) || (y >= vid.height-2 && offs > 0)) if ((y == 0 && offs < 0) || (y >= vid.height-2 && offs > 0))