Compare commits

..
Author SHA1 Message Date
Alug 9dd38ec75e Merge branch 'Saturn-Next' into fixceemake 2025-12-26 21:47:34 +01:00
Alug c0775ff87b Merge pull request #214 from P-AS/fixceeemake
Fix the fixceemake branch for macOS CMake (and aarch64 Linux too)
2025-11-22 18:48:21 +01:00
cobalt2727 04e649d716 fix ARM builds being completely broken
If merged, this is the quickest approach to resolve https://github.com/STJr/SRB2/issues/513

...alternatively, we could just remove the option altogether but I don't have the time right now to test whether it's needed or not

To the best of my knowledge, this covers all possible amd64 `CMAKE_SYSTEM_PROCESSOR` values based on what I'm seeing at https://stackoverflow.com/questions/70475665/what-are-the-possible-values-of-cmake-system-processor
2025-11-21 00:55:56 -05:00
PAS ee31cc1722 Fix macOS/CMake build
Moved C++ includes out of extern "C" blocks
Added missing algorithm includes
Disabled threads on macOS, since macOS doesn't support C11 threads.h
Added extern "C" blocks to src/sdl/macosx/mac_resources.h and src/p_tick.h
Added #ifdef HAVE_THREADS guard to src/sdl/i_threads.c
Removed mac_alert code while I'm at it, since it's obsolete in SDL2
2025-11-18 12:47:40 -05:00
Alug 7657858407 CMAKE:fixup bunch of stuff
- Add saturnpak, saturnjoin, screenfbo settings
- Add libbacktrace stuff (hope thats correct)
- set openmpt, discordrpc and libbacktrace as optional libs
- move asset hashes to d_main, fixing CMAKECONFIG (which fixes commit stuff)
- propely handle md5 sources
- set "-rdynamic" and "-g" (-g1 on non debug builds) so libbacktrace can get proper backtraces
2025-11-14 06:00:43 +01:00
Alug 8af93e5f26 our windoze lib directory is libs not thirdparty 2025-11-13 20:06:25 +01:00
Alug fb640821c0 copy pa- uuhh port blankarts cmake build stuff
it actually compiles an executable that even starts!!!
TODO:
- fix windoze lib stuff, we dont use cpm
- fix git commit related stuff (shows just "illegal" on titlescreen)
- readd saturn specific things like saturnpak, fbo etc
- fix  CMAKECONFIG
2025-11-13 19:54:36 +01:00
174 changed files with 4978 additions and 8065 deletions

No files matched your search

+144 -72
View File
@@ -1,20 +1,25 @@
cmake_minimum_required(VERSION 3.5) cmake_minimum_required(VERSION 3.14 FATAL_ERROR)
if(${PROJECT_SOURCE_DIR} MATCHES ${PROJECT_BINARY_DIR}) if("${CMAKE_CURRENT_BINARY_DIR}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}")
message(FATAL_ERROR "In-source builds will bring you a world of pain. Please make a separate directory to invoke CMake from.") message(FATAL_ERROR "In-source builds are blocked. Please build from a separate directory.")
endif() endif()
# Set up CMAKE path
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/Modules/")
include(CMakeDependentOption)
#include(cmake/CPM.cmake)
# DO NOT CHANGE THIS SRB2 STRING! Some variable names depend on this string. # DO NOT CHANGE THIS SRB2 STRING! Some variable names depend on this string.
# Version change is fine. # Version change is fine.
project(SRB2 project(SRB2
VERSION 1.6 VERSION 1.6
LANGUAGES C CXX) LANGUAGES C CXX)
set(CMAKE_CXX_STANDARD 17) if(APPLE)
set(CMAKE_CXX_STANDARD_REQUIRED ON) # DiscordRPC needs but does not properly specify ObjC
#set(CMAKE_CXX_EXTENSIONS OFF) # optional but recommended: disables GNU extensions, forces pure ISO C++ enable_language(OBJC)
set(CMAKE_CXX_EXTENSIONS ON) endif()
set(CMAKE_C_EXTENSIONS ON)
##### PACKAGE CONFIGURATION ##### ##### PACKAGE CONFIGURATION #####
@@ -31,7 +36,7 @@ if("${SRB2_CPACK_GENERATOR}" STREQUAL "")
endif() endif()
set(CPACK_GENERATOR ${SRB2_CPACK_GENERATOR}) set(CPACK_GENERATOR ${SRB2_CPACK_GENERATOR})
set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Sonic Robo Blast 2 Kart" CACHE STRING "Program name for display purposes") set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "SRB2Kart" CACHE STRING "Program name for display purposes")
set(CPACK_PACKAGE_VENDOR "Kart Krew" CACHE STRING "Vendor name for display purposes") set(CPACK_PACKAGE_VENDOR "Kart Krew" CACHE STRING "Vendor name for display purposes")
#set(CPACK_PACKAGE_DESCRIPTION_FILE ) #set(CPACK_PACKAGE_DESCRIPTION_FILE )
set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE") set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE")
@@ -39,54 +44,125 @@ set(CPACK_PACKAGE_VERSION_MAJOR ${SRB2_VERSION_MAJOR})
set(CPACK_PACKAGE_VERSION_MINOR ${SRB2_VERSION_MINOR}) set(CPACK_PACKAGE_VERSION_MINOR ${SRB2_VERSION_MINOR})
set(CPACK_PACKAGE_VERSION_PATCH ${SRB2_VERSION_PATCH}) set(CPACK_PACKAGE_VERSION_PATCH ${SRB2_VERSION_PATCH})
set(CPACK_PACKAGE_INSTALL_DIRECTORY "CMake ${CMAKE_VERSION_MAJOR}.${CMAKE_VERSION_MINOR}") set(CPACK_PACKAGE_INSTALL_DIRECTORY "CMake ${CMAKE_VERSION_MAJOR}.${CMAKE_VERSION_MINOR}")
SET(CPACK_OUTPUT_FILE_PREFIX package)
include(CPack) include(CPack)
# Set up CMAKE path # Options
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/Modules/")
### Useful functions if("${CMAKE_SYSTEM_NAME}" MATCHES Linux)
set(SRB2_CONFIG_SYSTEM_LIBRARIES_DEFAULT ON)
else()
set(SRB2_CONFIG_SYSTEM_LIBRARIES_DEFAULT OFF)
endif()
# Prepend sources with current source directory option(
function(prepend_sources SOURCE_FILES) SRB2_CONFIG_SYSTEM_LIBRARIES
foreach(SOURCE_FILE ${${SOURCE_FILES}}) "Link dependencies using CMake's find_package and do not use internal builds"
set(MODIFIED ${MODIFIED} ${CMAKE_CURRENT_SOURCE_DIR}/${SOURCE_FILE}) ${SRB2_CONFIG_SYSTEM_LIBRARIES_DEFAULT}
endforeach() )
set(${SOURCE_FILES} ${MODIFIED} PARENT_SCOPE) option(SRB2_CONFIG_ENABLE_TESTS "Build the test suite" OFF)
endfunction() # This option isn't recommended for distribution builds and probably won't work (yet).
cmake_dependent_option(
SRB2_CONFIG_SHARED_INTERNAL_LIBRARIES
"Use dynamic libraries when compiling internal dependencies"
OFF "NOT SRB2_CONFIG_SYSTEM_LIBRARIES"
OFF
)
option(SRB2_CONFIG_ENABLE_DISCORDRPC "Enable Discord RPC features" ON)
option(SRB2_CONFIG_STATIC_STDLIB "Link static version of standard library. All dependencies must also be static" ON)
option(SRB2_CONFIG_HWRENDER "Enable hardware render (OpenGL) support" ON)
option(SRB2_CONFIG_STATIC_OPENGL "Enable static linking GL (do not do this)" OFF)
option(SRB2_CONFIG_ERRORMODE "Compile C code with warnings treated as errors." OFF)
option(SRB2_CONFIG_DEBUGMODE "Compile with PARANOIA, ZDEBUG, RANGECHECK and PACKETDROP defined." OFF)
option(SRB2_CONFIG_MOBJCONSISTANCY "Compile with MOBJCONSISTANCY defined." OFF)
option(SRB2_CONFIG_PACKETDROP "Compile with PACKETDROP defined." OFF)
option(SRB2_CONFIG_ZDEBUG "Compile with ZDEBUG defined." OFF)
# SRB2_CONFIG_PROFILEMODE is probably superceded by some CMake setting.
option(SRB2_CONFIG_PROFILEMODE "Compile for profiling (GCC only)." OFF)
option(SRB2_CONFIG_TRACY "Compile with Tracy profiling enabled" OFF)
option(SRB2_CONFIG_ASAN "Compile with AddressSanitizer (libasan)." OFF)
option(SRB2_CONFIG_UBSAN "Compile with UndefinedBehaviorSanitizer (libubsan)." OFF)
set(SRB2_CONFIG_ASSET_DIRECTORY "" CACHE PATH "Path to directory that contains all asset files for the installer. If set, assets will be part of installation and cpack.")
option(SRB2_CONFIG_LTO "Enable link time optimizations, improves performance at the cost of longer link times." ON)
option(SRB2_CONFIG_TIDY "Enable clang tiny, checks compiled code for issues at the cost of longer compile times." OFF)
# Macro to add OSX framework # man i suck at explaining lmao
macro(add_framework fwname appname) option(SRB2_CONFIG_SATURNPAK "Enable Saturn specific special packet. Required for using the newer resynch system" ON)
find_library(FRAMEWORK_${fwname} option(SRB2_CONFIG_SATURNJOIN "Enable Saturn specific allowjoin toggle." ON)
NAMES ${fwname} option(SRB2_CONFIG_SCREENFBO "Enable hardware render (OpenGL) FBO downsampling support" ON)
PATHS ${CMAKE_OSX_SYSROOT}/System/Library option(SRB2_CONFIG_LIBBACKTRACE "Enable using libbacktrace for crashlogs" ON)
${CMAKE_OSX_SYSROOT}/Library
/System/Library
/Library
ATH_SUFFIXES Frameworks
NO_DEFAULT_PATH)
if( ${FRAMEWORK_${fwname}} STREQUAL FRAMEWORK_${fwname}-NOTFOUND)
MESSAGE(ERROR ": Framework ${fwname} not found")
else()
TARGET_LINK_LIBRARIES(${appname} PRIVATE "${FRAMEWORK_${fwname}}/${fwname}")
MESSAGE(STATUS "Framework ${fwname} found at ${FRAMEWORK_${fwname}}")
endif()
endmacro()
# Macro to copy Windows DLLs to Debug/Release folder for easy debugging #if(SRB2_CONFIG_ENABLE_TESTS)
# Note: this is general purpose, we could copy anything. Just using for DLLs on MSVC though # https://github.com/catchorg/Catch2
macro(copy_files_to_build_dir target dlllist_var) # CPMAddPackage(
if(MSVC) # NAME Catch2
# http://stackoverflow.com/a/26983405/3064195 # VERSION 3.1.1
foreach(dlllist_item ${${dlllist_var}}) # GITHUB_REPOSITORY catchorg/Catch2
get_filename_component(dllname ${dlllist_item} NAME) # OPTIONS
add_custom_command(TARGET ${target} POST_BUILD # "CATCH_INSTALL_DOCS OFF"
COMMAND ${CMAKE_COMMAND} -E copy_if_different # )
${dlllist_item} # list(APPEND CMAKE_MODULE_PATH "${Catch2_SOURCE_DIR}/extras")
$<TARGET_FILE_DIR:${target}>/${dllname} # include(CTest)
) # include(Catch)
endforeach() # add_executable(srb2tests)
# # To add tests, use target_sources to add individual test files to the target in subdirs.
# target_link_libraries(srb2tests PRIVATE Catch2::Catch2 Catch2::Catch2WithMain)
# target_compile_features(srb2tests PRIVATE c_std_11 cxx_std_17)
# catch_discover_tests(srb2tests)
#endif()
# Enable CCache
# (Set USE_CCACHE=ON to use, CCACHE_OPTIONS for options)
if("${CMAKE_HOST_SYSTEM_NAME}" STREQUAL Windows)
option(USE_CCACHE "Enable ccache support" OFF)
if(USE_CCACHE)
find_program(CCACHE_TOOL_PATH ccache)
if(CCACHE_TOOL_PATH)
set(CMAKE_C_COMPILER_LAUNCHER ${CCACHE_TOOL_PATH} CACHE STRING "" FORCE)
set(CMAKE_CXX_COMPILER_LAUNCHER ${CCACHE_TOOL_PATH} CACHE STRING "" FORCE)
else()
message(WARNING "USE_CCACHE was set but ccache is not found (set CCACHE_TOOL_PATH)")
endif()
endif() endif()
endmacro() else()
# TODO: fix windoze crap, i dont want cpm lol
#CPMAddPackage(
# NAME Ccache.cmake
# GITHUB_REPOSITORY TheLartians/Ccache.cmake
# VERSION 1.2.5
#)
endif()
# Dependencies
#add_subdirectory(thirdparty)
if("${SRB2_CONFIG_SYSTEM_LIBRARIES}")
find_package(ZLIB REQUIRED)
find_package(PNG REQUIRED)
find_package(SDL2 REQUIRED)
find_package(SDL2_mixer REQUIRED)
find_package(CURL REQUIRED)
find_package(OPENMPT OPTIONAL)
find_package(GME REQUIRED)
find_package(DiscordRPC OPTIONAL)
find_package(libbacktrace OPTIONAL)
endif()
if(${PROJECT_SOURCE_DIR} MATCHES ${PROJECT_BINARY_DIR})
message(FATAL_ERROR "In-source builds will bring you a world of pain. Please make a separate directory to invoke CMake from.")
endif()
if ((${SRB2_USE_CCACHE}) AND (${CMAKE_C_COMPILER} MATCHES "clang"))
message(WARNING "Using clang and CCache: You may want to set environment variable CCACHE_CPP2=yes to prevent include errors during compile.")
endif()
# Add sources from Sourcefile
function(target_sourcefile type)
file(STRINGS Sourcefile list
REGEX "[-0-9A-Za-z_]+\.${type}")
target_sources(SRB2SDL2 PRIVATE ${list})
endfunction()
# bitness check # bitness check
set(SRB2_SYSTEM_BITS 0) set(SRB2_SYSTEM_BITS 0)
@@ -102,32 +178,12 @@ if(${SRB2_SYSTEM_BITS} EQUAL 0)
message(STATUS "Target bitness is unknown") message(STATUS "Target bitness is unknown")
endif() endif()
# OS macros
if (UNIX)
add_definitions(-DUNIXCOMMON)
add_link_options(-rdynamic) # Use -rdynamic so a backtrace log shows function names
endif()
if(CMAKE_COMPILER_IS_GNUCC)
find_program(OBJCOPY objcopy)
endif()
if(${CMAKE_SYSTEM} MATCHES "Linux")
add_definitions(-DLINUX)
if(${SRB2_SYSTEM_BITS} EQUAL 64)
add_definitions(-DLINUX64)
endif()
endif()
if(${CMAKE_SYSTEM} MATCHES "Darwin")
add_definitions(-DMACOSX)
endif()
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin") set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
set(CMAKE_PDB_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin") set(CMAKE_PDB_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
# Set EXE names so the assets CMakeLists can refer to its target # Set EXE names so the assets CMakeLists can refer to its target
set(SRB2_SDL2_EXE_NAME srb2kart CACHE STRING "Executable binary output name") set(SRB2_SDL2_EXE_NAME "" CACHE STRING "Override executable binary output name")
set(SRB2_SDL2_EXE_SUFFIX "" CACHE STRING "Optional executable suffix, separated by an underscore")
include_directories(${CMAKE_CURRENT_BINARY_DIR}/src) include_directories(${CMAKE_CURRENT_BINARY_DIR}/src)
@@ -139,6 +195,22 @@ set(GIT_EXECUTABLE "git" CACHE FILEPATH "Path to git binary")
include(GitUtilities) include(GitUtilities)
git_latest_commit(SRB2_COMP_COMMIT "${CMAKE_SOURCE_DIR}") git_latest_commit(SRB2_COMP_COMMIT "${CMAKE_SOURCE_DIR}")
git_current_branch(SRB2_GIT_BRANCH "${CMAKE_SOURCE_DIR}") git_current_branch(SRB2_GIT_BRANCH "${CMAKE_SOURCE_DIR}")
#git_working_tree_dirty(SRB2_COMP_UNCOMMITTED "${CMAKE_SOURCE_DIR}") #TODO: fix this
set(SRB2_COMP_BRANCH "${SRB2_GIT_BRANCH}") set(SRB2_COMP_BRANCH "${SRB2_GIT_BRANCH}")
set(SRB2_COMP_REVISION "${SRB2_COMP_COMMIT}") set(SRB2_COMP_REVISION "${SRB2_COMP_COMMIT}")
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/src/config.h.in ${CMAKE_CURRENT_BINARY_DIR}/src/config.h) configure_file(${CMAKE_CURRENT_SOURCE_DIR}/src/config.h.in ${CMAKE_CURRENT_BINARY_DIR}/src/config.h)
if("${SRB2_SDL2_EXE_NAME}" STREQUAL "")
list(APPEND EXE_NAME_PARTS "srb2kart-saturn")
if(NOT "${SRB2_GIT_BRANCH}" STREQUAL "master")
list(APPEND EXE_NAME_PARTS ${SRB2_GIT_BRANCH})
endif()
else()
list(APPEND EXE_NAME_PARTS ${SRB2_SDL2_EXE_NAME})
endif()
list(APPEND EXE_NAME_PARTS ${SRB2_SDL2_EXE_SUFFIX})
list(JOIN EXE_NAME_PARTS "_" EXE_NAME)
set_target_properties(SRB2SDL2 PROPERTIES OUTPUT_NAME ${EXE_NAME})
+3 -3
View File
@@ -22,14 +22,14 @@ We also have a Flatpak available on [Flathub](https://flathub.org/en/apps/org.sr
See [SRB2 Wiki/Source code compiling](http://wiki.srb2.org/wiki/Source_code_compiling). The compiling process for SRB2Kart is largely identical to SRB2. See [SRB2 Wiki/Source code compiling](http://wiki.srb2.org/wiki/Source_code_compiling). The compiling process for SRB2Kart is largely identical to SRB2.
For Windows only the Makefile build system with GCC or Clang compiler is supported. Currently only the Makefile build system with GCC or Clang compiler is supported.
CMake is NOT supported at the moment, but will be availible again soon.
Visual C++ (MSVC) is unsupported. Visual C++ (MSVC) is unsupported.
64-bit Windows builds are supported and recommended over 32-bit builds, they will build automatically when using the MSYS2 MinGW 64-bit executable (requires the mingw-w64-x86_64-gcc package), no extra flags needed! 64-bit Windows builds are supported and recommended over 32-bit builds, they will build automatically when using the MSYS2 MinGW 64-bit executable (requires the mingw-w64-x86_64-gcc package), no extra flags needed!
The specific DLLs can be found under /libs/dll-binaries/(i686 for 32bit/x86_64 for 64-bit)/ or in the Release packages The specific DLLs can be found under /libs/dll-binaries/(i686 for 32bit/x86_64 for 64-bit)/ or in the Release packages
MacOS and Linux can be build with CMake, but it is recommended to use the Makefile for Linux over CMake
Alternatively the [srb2bld](https://github.com/Bijman/srb2bld) script by Bijman can be used aswell! Alternatively the [srb2bld](https://github.com/Bijman/srb2bld) script by Bijman can be used aswell!
## Disclaimer ## Disclaimer
+32 -44
View File
@@ -5,60 +5,48 @@ if(${CMAKE_SYSTEM} MATCHES Linux)
return() return()
endif() endif()
# For prepending the current source path, later if("${SRB2_CONFIG_ASSET_DIRECTORY}" STREQUAL "")
FUNCTION(PREPEND var prefix) message(WARNING "SRB2_CONFIG_ASSET_DIRECTORY is not set, so installation will not contain data files.")
SET(listVar "") return()
FOREACH(f ${ARGN}) endif()
LIST(APPEND listVar "${prefix}/${f}")
ENDFOREACH(f)
SET(${var} "${listVar}" PARENT_SCOPE)
ENDFUNCTION(PREPEND)
set(SRB2_ASSET_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/installer" get_filename_component(SRB2_ASSET_DIRECTORY_ABSOLUTE "${SRB2_CONFIG_ASSET_DIRECTORY}" ABSOLUTE)
CACHE STRING "Path to directory that contains all asset files for the installer.")
set(SRB2_ASSET_HASHED set(SRB2_ASSETS_DOCS
"srb2.srb;\ "README.txt"
gfx.kart;\ "HISTORY.txt"
textures.kart;\ "README-SDL.txt"
chars.kart;\ "LICENSE.txt"
maps.kart" "LICENSE-3RD-PARTY.txt"
CACHE STRING "Asset filenames to apply MD5 checks. No spaces between entries!"
) )
list(TRANSFORM SRB2_ASSETS_DOCS PREPEND "/")
list(TRANSFORM SRB2_ASSETS_DOCS PREPEND "${SRB2_ASSET_DIRECTORY_ABSOLUTE}")
set(SRB2_ASSET_DOCS ####################
"README.txt;\ # POST-V2.2 NOTE: Do not forget to add patch.pk3 to the end of this list!
HISTORY.txt;\ ####################
LICENSE.txt;\
LICENSE-3RD-PARTY.txt" set(SRB2_ASSETS_GAME
CACHE STRING "Documentation filenames. In OS X, these are packaged separately from other assets. No spaces between entries!" "srb2.srb"
"gfx.kart"
"textures.kart"
"chars.kart"
"maps.kart"
) )
list(TRANSFORM SRB2_ASSETS_GAME PREPEND "/")
list(TRANSFORM SRB2_ASSETS_GAME PREPEND "${SRB2_ASSET_DIRECTORY_ABSOLUTE}")
PREPEND(SRB2_ASSET_DOCS ${SRB2_ASSET_DIRECTORY} ${SRB2_ASSET_DOCS}) set(SRB2_ASSETS ${SRB2_ASSET_DOCS} ${SRB2_ASSETS_GAME})
foreach(SRB2_ASSET ${SRB2_ASSET_HASHED})
file(MD5 ${SRB2_ASSET_DIRECTORY}/${SRB2_ASSET} "SRB2_ASSET_${SRB2_ASSET}_HASH")
set(SRB2_ASSET_${SRB2_ASSET}_HASH ${SRB2_ASSET_${SRB2_ASSET}_HASH} PARENT_SCOPE)
endforeach()
# Installation # Installation
if(${CMAKE_SYSTEM} MATCHES Darwin) if(${CMAKE_SYSTEM} MATCHES Darwin)
get_target_property(outname SRB2SDL2 OUTPUT_NAME) get_target_property(outname SRB2SDL2 OUTPUT_NAME)
install(DIRECTORY "${SRB2_ASSET_DIRECTORY}/" install(FILES ${SRB2_ASSETS} DESTINATION "${outname}.app/Contents/Resources")
DESTINATION "${outname}.app/Contents/Resources" install(DIRECTORY "${SRB2_ASSET_DIRECTORY_ABSOLUTE}/models" DESTINATION "${outname}.app/Contents/Resources")
) install(FILES ${SRB2_ASSETS_DOCS} DESTINATION .)
install(FILES ${SRB2_ASSET_DOCS}
DESTINATION .
OPTIONAL
)
else() else()
install(DIRECTORY "${SRB2_ASSET_DIRECTORY}/" install(FILES ${SRB2_ASSETS} DESTINATION .)
DESTINATION . install(DIRECTORY "${SRB2_ASSET_DIRECTORY_ABSOLUTE}/models" DESTINATION .)
)
# Docs are assumed to be located in SRB2_ASSET_DIRECTORY, so don't install again
#install(FILES ${SRB2_ASSET_DOCS}
# DESTINATION .
# OPTIONAL
#)
endif() endif()
+19
View File
@@ -0,0 +1,19 @@
cmake_minimum_required(VERSION 3.5 FATAL_ERROR)
set(CMAKE_BINARY_DIR "${BINARY_DIR}")
set(CMAKE_CURRENT_BINARY_DIR "${BINARY_DIR}")
# Set up CMAKE path
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/")
include(GitUtilities)
git_current_branch(SRB2_COMP_BRANCH)
git_working_tree_dirty(SRB2_COMP_UNCOMMITTED)
git_latest_commit(SRB2_COMP_REVISION)
git_subject(subject)
string(REGEX REPLACE "([\"\\])" "\\\\\\1" SRB2_COMP_LASTCOMMIT "${subject}")
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/src/config.h.in" "${CMAKE_CURRENT_SOURCE_DIR}/src/config.h")
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/src/config.h.in" "${CMAKE_CURRENT_SOURCE_DIR}/build/src/config.h")
+10
View File
@@ -21,3 +21,13 @@ find_library(DISCORDRPC_LIBRARY
set(DISCORDRPC_PROCESS_INCLUDES DISCORDRPC_INCLUDE_DIR) set(DISCORDRPC_PROCESS_INCLUDES DISCORDRPC_INCLUDE_DIR)
set(DISCORDRPC_PROCESS_LIBS DISCORDRPC_LIBRARY) set(DISCORDRPC_PROCESS_LIBS DISCORDRPC_LIBRARY)
libfind_process(DISCORDRPC) libfind_process(DISCORDRPC)
if(DISCORDRPC_FOUND AND NOT TARGET DiscordRPC::DiscordRPC)
add_library(DiscordRPC::DiscordRPC UNKNOWN IMPORTED)
set_target_properties(
DiscordRPC::DiscordRPC
PROPERTIES
IMPORTED_LOCATION "${DISCORDRPC_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${DISCORDRPC_INCLUDE_DIR}"
)
endif()
+11 -2
View File
@@ -1,6 +1,6 @@
include(LibFindMacros) include(LibFindMacros)
libfind_pkg_check_modules(GME_PKGCONF LIBGME) libfind_pkg_check_modules(GME_PKGCONF GME)
find_path(GME_INCLUDE_DIR find_path(GME_INCLUDE_DIR
NAMES gme.h NAMES gme.h
@@ -8,7 +8,6 @@ find_path(GME_INCLUDE_DIR
${GME_PKGCONF_INCLUDE_DIRS} ${GME_PKGCONF_INCLUDE_DIRS}
"/usr/include/gme" "/usr/include/gme"
"/usr/local/include/gme" "/usr/local/include/gme"
PATH_SUFFIXES gme
) )
find_library(GME_LIBRARY find_library(GME_LIBRARY
@@ -22,3 +21,13 @@ find_library(GME_LIBRARY
set(GME_PROCESS_INCLUDES GME_INCLUDE_DIR) set(GME_PROCESS_INCLUDES GME_INCLUDE_DIR)
set(GME_PROCESS_LIBS GME_LIBRARY) set(GME_PROCESS_LIBS GME_LIBRARY)
libfind_process(GME) libfind_process(GME)
if(GME_FOUND AND NOT TARGET gme)
add_library(gme UNKNOWN IMPORTED)
set_target_properties(
gme
PROPERTIES
IMPORTED_LOCATION "${GME_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${GME_INCLUDE_DIR}"
)
endif()
+11 -2
View File
@@ -1,6 +1,6 @@
include(LibFindMacros) include(LibFindMacros)
libfind_pkg_check_modules(OPENMPT_PKGCONF LIBOPENMPT) libfind_pkg_check_modules(OPENMPT_PKGCONF OPENMPT)
find_path(OPENMPT_INCLUDE_DIR find_path(OPENMPT_INCLUDE_DIR
NAMES libopenmpt.h NAMES libopenmpt.h
@@ -8,7 +8,6 @@ find_path(OPENMPT_INCLUDE_DIR
${OPENMPT_PKGCONF_INCLUDE_DIRS} ${OPENMPT_PKGCONF_INCLUDE_DIRS}
"/usr/include/libopenmpt" "/usr/include/libopenmpt"
"/usr/local/include/libopenmpt" "/usr/local/include/libopenmpt"
PATH_SUFFIXES libopenmpt
) )
find_library(OPENMPT_LIBRARY find_library(OPENMPT_LIBRARY
@@ -22,3 +21,13 @@ find_library(OPENMPT_LIBRARY
set(OPENMPT_PROCESS_INCLUDES OPENMPT_INCLUDE_DIR) set(OPENMPT_PROCESS_INCLUDES OPENMPT_INCLUDE_DIR)
set(OPENMPT_PROCESS_LIBS OPENMPT_LIBRARY) set(OPENMPT_PROCESS_LIBS OPENMPT_LIBRARY)
libfind_process(OPENMPT) libfind_process(OPENMPT)
if(OPENMPT_FOUND AND NOT TARGET openmpt)
add_library(openmpt UNKNOWN IMPORTED)
set_target_properties(
openmpt
PROPERTIES
IMPORTED_LOCATION "${OPENMPT_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${OPENMPT_INCLUDE_DIR}"
)
endif()
+10
View File
@@ -31,3 +31,13 @@ find_library(SDL2_LIBRARY
set(SDL2_PROCESS_INCLUDES SDL2_INCLUDE_DIR) set(SDL2_PROCESS_INCLUDES SDL2_INCLUDE_DIR)
set(SDL2_PROCESS_LIBS SDL2_LIBRARY) set(SDL2_PROCESS_LIBS SDL2_LIBRARY)
libfind_process(SDL2) libfind_process(SDL2)
if(SDL2_FOUND AND NOT TARGET SDL2::SDL2)
add_library(SDL2::SDL2 UNKNOWN IMPORTED)
set_target_properties(
SDL2::SDL2
PROPERTIES
IMPORTED_LOCATION "${SDL2_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${SDL2_INCLUDE_DIR}"
)
endif()
+10
View File
@@ -32,3 +32,13 @@ find_library(SDL2_MIXER_LIBRARY
set(SDL2_MIXER_PROCESS_INCLUDES SDL2_MIXER_INCLUDE_DIR) set(SDL2_MIXER_PROCESS_INCLUDES SDL2_MIXER_INCLUDE_DIR)
set(SDL2_MIXER_PROCESS_LIBS SDL2_MIXER_LIBRARY) set(SDL2_MIXER_PROCESS_LIBS SDL2_MIXER_LIBRARY)
libfind_process(SDL2_MIXER) libfind_process(SDL2_MIXER)
if(SDL2_MIXER_FOUND AND NOT TARGET SDL2_mixer::SDL2_mixer)
add_library(SDL2_mixer::SDL2_mixer UNKNOWN IMPORTED)
set_target_properties(
SDL2_mixer::SDL2_mixer
PROPERTIES
IMPORTED_LOCATION "${SDL2_MIXER_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${SDL2_MIXER_INCLUDE_DIR}"
)
endif()
+39 -23
View File
@@ -6,38 +6,54 @@ endif()
set(__GitUtilities ON) set(__GitUtilities ON)
function(git_describe variable path) macro(_git_command)
execute_process(COMMAND "${GIT_EXECUTABLE}" "describe" execute_process(
WORKING_DIRECTORY "${path}" COMMAND "${GIT_EXECUTABLE}" ${ARGN}
RESULT_VARIABLE result WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
OUTPUT_VARIABLE output OUTPUT_VARIABLE output
ERROR_QUIET ERROR_QUIET
OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_STRIP_TRAILING_WHITESPACE
) )
endmacro()
macro(_git_easy_command)
_git_command(${ARGN})
set(${variable} "${output}" PARENT_SCOPE)
endmacro()
function(git_current_branch variable)
_git_command(symbolic-ref -q --short HEAD)
# If a detached head, a ref could still be resolved.
if("${output}" STREQUAL "")
_git_command(describe --all --exact-match)
# Get the ref, in the form heads/master or
# remotes/origin/master so isolate the final part.
string(REGEX REPLACE ".*/" "" output "${output}")
endif()
set(${variable} "${output}" PARENT_SCOPE) set(${variable} "${output}" PARENT_SCOPE)
endfunction() endfunction()
function(git_current_branch variable path) function(git_latest_commit variable)
execute_process(COMMAND ${GIT_EXECUTABLE} "symbolic-ref" "--short" "HEAD" _git_easy_command(rev-parse --short HEAD)
WORKING_DIRECTORY "${path}"
RESULT_VARIABLE result
OUTPUT_VARIABLE output
ERROR_QUIET
OUTPUT_STRIP_TRAILING_WHITESPACE
)
set(${variable} "${output}" PARENT_SCOPE)
endfunction() endfunction()
function(git_latest_commit variable path) function(git_working_tree_dirty variable)
execute_process(COMMAND ${GIT_EXECUTABLE} "rev-parse" "--short" "HEAD" _git_command(status --porcelain -uno)
WORKING_DIRECTORY "${path}"
RESULT_VARIABLE result
OUTPUT_VARIABLE output
ERROR_QUIET
OUTPUT_STRIP_TRAILING_WHITESPACE
)
set(${variable} "${output}" PARENT_SCOPE) if(output STREQUAL "")
set(${variable} FALSE PARENT_SCOPE)
else()
set(${variable} TRUE PARENT_SCOPE)
endif()
endfunction()
function(git_subject variable)
_git_easy_command(log -1 "--format=%h %s")
endfunction()
function(get_git_dir variable)
_git_easy_command(rev-parse --git-dir)
endfunction() endfunction()
+18 -37
View File
@@ -1,4 +1,4 @@
# Version 2.4 # Version 2.2
# Public Domain, originally written by Lasse Kärkkäinen <tronic> # Public Domain, originally written by Lasse Kärkkäinen <tronic>
# Maintained at https://github.com/Tronic/cmake-modules # Maintained at https://github.com/Tronic/cmake-modules
# Please send your improvements as pull requests on Github. # Please send your improvements as pull requests on Github.
@@ -52,10 +52,6 @@ function (libfind_pkg_detect PREFIX)
if (libraryargs) if (libraryargs)
find_library(${PREFIX}_LIBRARY NAMES ${libraryargs} HINTS ${${PREFIX}_PKGCONF_LIBRARY_DIRS}) find_library(${PREFIX}_LIBRARY NAMES ${libraryargs} HINTS ${${PREFIX}_PKGCONF_LIBRARY_DIRS})
endif() endif()
# Read pkg-config version
if (${PREFIX}_PKGCONF_VERSION)
set(${PREFIX}_VERSION ${${PREFIX}_PKGCONF_VERSION} PARENT_SCOPE)
endif()
endfunction() endfunction()
# Extracts a version #define from a version.h file, output stored to <PREFIX>_VERSION. # Extracts a version #define from a version.h file, output stored to <PREFIX>_VERSION.
@@ -129,39 +125,24 @@ function (libfind_process PREFIX)
# Process deps to add to # Process deps to add to
foreach (i ${PREFIX} ${${PREFIX}_DEPENDENCIES}) foreach (i ${PREFIX} ${${PREFIX}_DEPENDENCIES})
if (DEFINED ${i}_INCLUDE_OPTS) if (DEFINED ${i}_INCLUDE_OPTS OR DEFINED ${i}_LIBRARY_OPTS)
# The package seems to export option lists that we can use, woohoo! # The package seems to export option lists that we can use, woohoo!
list(APPEND includeopts ${${i}_INCLUDE_OPTS}) list(APPEND includeopts ${${i}_INCLUDE_OPTS})
else()
if (DEFINED ${i}_INCLUDE_DIR)
# Singular forms can be used
list(APPEND includeopts ${i}_INCLUDE_DIR)
else()
if (DEFINED ${i}_INCLUDE_DIRS)
# Plural forms can be used
list(APPEND includeopts ${i}_INCLUDE_DIRS)
else()
# Oh no, we don't know the option names
message(FATAL_ERROR "We couldn't determine config variable names for ${i} includes. Aieeh!")
endif()
endif()
endif()
if (DEFINED ${i}_LIBRARY_OPTS)
# The package seems to export option lists that we can use, woohoo!
list(APPEND libraryopts ${${i}_LIBRARY_OPTS}) list(APPEND libraryopts ${${i}_LIBRARY_OPTS})
else() else()
if (DEFINED ${i}_LIBRARY) # If plural forms don't exist or they equal singular forms
if ((NOT DEFINED ${i}_INCLUDE_DIRS AND NOT DEFINED ${i}_LIBRARIES) OR
({i}_INCLUDE_DIR STREQUAL ${i}_INCLUDE_DIRS AND ${i}_LIBRARY STREQUAL ${i}_LIBRARIES))
# Singular forms can be used # Singular forms can be used
list(APPEND libraryopts ${i}_LIBRARY) if (DEFINED ${i}_INCLUDE_DIR)
else() list(APPEND includeopts ${i}_INCLUDE_DIR)
if (DEFINED ${i}_LIBRARIES)
# Plural forms can be used
list(APPEND libraryopts ${i}_LIBRARIES)
else()
# Oh no, we don't know the option names
message(FATAL_ERROR "We couldn't determine config variable names for ${i} libraries. Aieeh!")
endif() endif()
if (DEFINED ${i}_LIBRARY)
list(APPEND libraryopts ${i}_LIBRARY)
endif()
else()
# Oh no, we don't know the option names
message(FATAL_ERROR "We couldn't determine config variable names for ${i} includes and libs. Aieeh!")
endif() endif()
endif() endif()
endforeach() endforeach()
@@ -228,12 +209,12 @@ function (libfind_process PREFIX)
message(STATUS " ${PREFIX}_LIBRARY_OPTS=${libraryopts}") message(STATUS " ${PREFIX}_LIBRARY_OPTS=${libraryopts}")
message(STATUS " ${PREFIX}_LIBRARIES=${libs}") message(STATUS " ${PREFIX}_LIBRARIES=${libs}")
endif() endif()
set (${PREFIX}_INCLUDE_OPTS ${includeopts} PARENT_SCOPE)
set (${PREFIX}_LIBRARY_OPTS ${libraryopts} PARENT_SCOPE)
set (${PREFIX}_INCLUDE_DIRS ${includes} PARENT_SCOPE)
set (${PREFIX}_LIBRARIES ${libs} PARENT_SCOPE)
set (${PREFIX}_FOUND TRUE PARENT_SCOPE)
endif() endif()
set (${PREFIX}_INCLUDE_OPTS ${includeopts} PARENT_SCOPE)
set (${PREFIX}_LIBRARY_OPTS ${libraryopts} PARENT_SCOPE)
set (${PREFIX}_INCLUDE_DIRS ${includes} PARENT_SCOPE)
set (${PREFIX}_LIBRARIES ${libs} PARENT_SCOPE)
set (${PREFIX}_FOUND TRUE PARENT_SCOPE)
return() return()
endif() endif()
+1
View File
@@ -1,4 +1,5 @@
/cscope.out /cscope.out
*.json *.json
*.idx *.idx
config.h
*.gdb_history *.gdb_history
+381 -541
View File
@@ -1,436 +1,146 @@
# SRB2 Core add_executable(SRB2SDL2 MACOSX_BUNDLE WIN32)
if(("${CMAKE_COMPILER_IS_GNUCC}" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang") AND "${CMAKE_SYSTEM_NAME}" MATCHES "Windows")
target_link_options(SRB2SDL2 PRIVATE "-Wl,--disable-dynamicbase")
if("${SRB2_CONFIG_STATIC_STDLIB}")
# On MinGW with internal libraries, link the standard library statically
if(CMAKE_LINKER_TYPE STREQUAL "LLD")
target_link_options(SRB2SDL2 PRIVATE -Wl, -static-libgcc -static-libstdc++ -static -lpthread)
else()
target_link_options(SRB2SDL2 PRIVATE -Wl,--add-stdcall-alias -static-libgcc -static-libstdc++ -static -lpthread)
endif()
set(THREADS_PREFER_PTHREAD_FLAG TRUE)
find_package(Threads REQUIRED)
target_link_libraries(SRB2SDL2 PRIVATE Threads::Threads)
endif()
if(CMAKE_SIZEOF_VOID_P EQUAL 4)
target_link_options(SRB2SDL2 PRIVATE "-Wl,--large-address-aware")
endif()
endif()
set(SRB2_CONFIG_STD23 OFF CACHE BOOL
"Compiles the game under c23 and cxx23 instead c11 and cxx17.")
if(SRB2_CONFIG_STD23)
message("-- Compiling game with C23 and CXX23.")
target_compile_features(SRB2SDL2 PRIVATE c_std_23 cxx_std_23)
set_property(TARGET SRB2SDL2 PROPERTY C_STANDARD 23)
set_property(TARGET SRB2SDL2 PROPERTY CXX_STANDARD 23)
else()
message("-- Compiling game with C11 and CXX17.")
target_compile_features(SRB2SDL2 PRIVATE c_std_11 cxx_std_17)
set_property(TARGET SRB2SDL2 PROPERTY C_STANDARD 11)
set_property(TARGET SRB2SDL2 PROPERTY CXX_STANDARD 17)
endif()
# Core sources # Core sources
set(SRB2_CORE_SOURCES target_sourcefile(c)
core/memory.cpp target_sources(SRB2SDL2 PRIVATE comptime.c config.h.in)
core/thread_pool.cpp
am_map.c
b_bot.c
command.c
comptime.c
console.c
d_clisrv.c
d_main.c
d_net.c
d_netcmd.c
d_netfil.c
d_protocol.c
dehacked.c
f_finale.c
f_wipe.c
filesrch.c
g_game.c
g_demo.c
g_input.c
hu_stuff.c
i_tcp.c
info.c
k_hud.c
lzf.c
m_aatree.c
m_anigif.c
m_argv.c
m_bbox.c
m_cheat.c
m_curl.c
m_cond.c
m_emotes.cpp
m_fixed.c
m_menu.c
m_textinput.c
m_misc.c
m_perfstats.c
m_queue.c
m_random.c
md5.c
mserv.c
http-mserv.c
qs22j.c
r_skins.c
s_sound.c
screen.c
sounds.c
st_stuff.c
string.c
tables.c
v_video.c
w_wad.cpp
y_inter.c
z_zone.cpp
)
set(SRB2_CORE_HEADERS target_sources(SRB2SDL2 PRIVATE md5.c md5.h)
core/memory.h
core/thread_pool.h
m_curl.h
m_emotes.h
k_hud.h
am_map.h
b_bot.h
byteptr.h
command.h
console.h
d_clisrv.h
d_event.h
d_main.h
d_net.h
d_netcmd.h
d_netfil.h
d_player.h
d_protocol.h
d_think.h
d_ticcmd.h
dehacked.h
doomdata.h
doomdef.h
doomstat.h
doomtype.h
endian.h
f_finale.h
fastcmp.h
filesrch.h
g_game.h
g_demo.h
g_input.h
g_state.h
hu_stuff.h
i_joy.h
i_net.h
i_sound.h
i_system.h
i_tcp.h
i_time.h
i_video.h
info.h
keys.h
lzf.h
m_aatree.h
m_anigif.h
m_argv.h
m_bbox.h
m_cheat.h
m_cond.h
m_dllist.h
m_fixed.h
m_menu.h
m_textinput.h
m_misc.h
m_queue.h
m_perfstats.h
m_random.h
m_swap.h
md5.h
mserv.h
qs22j.h
r_skins.h
s_sound.h
screen.h
sounds.h
st_stuff.h
tables.h
v_video.h
w_wad.h
y_inter.h
z_zone.h
config.h.in
)
set(SRB2_CORE_RENDER_SOURCES
r_bsp.cpp
r_data.c
r_draw.cpp
r_fps.cpp
r_main.cpp
r_patch.cpp
r_patchrotation.cpp
r_plane.cpp
r_segs.cpp
r_sky.c
r_splats.c
r_things.cpp
r_portal.c
r_bsp.h
r_data.h
r_defs.h
r_draw.h
r_fps.h
r_local.h
r_main.h
r_patch.h
r_patchrotation.h
r_plane.h
r_segs.h
r_sky.h
r_splats.h
r_state.h
r_things.h
r_portal.h
)
set(SRB2_CORE_GAME_SOURCES
p_ceilng.c
p_enemy.c
p_floor.c
p_inter.c
p_lights.c
p_map.c
p_maputl.cpp
p_mobj.c
p_polyobj.c
p_saveg.c
p_setup.c
p_sight.c
p_slopes.c
p_spec.c
p_telept.c
p_tick.c
p_user.c
k_director.c
k_kart.c
k_stats.c
i_time.c
p_local.h
p_maputl.h
p_mobj.h
p_polyobj.h
p_pspr.h
p_saveg.h
p_setup.h
p_slopes.h
p_spec.h
p_tick.h
k_director.h
k_kart.h
k_stats.h
)
prepend_sources(SRB2_CORE_SOURCES)
prepend_sources(SRB2_CORE_HEADERS)
prepend_sources(SRB2_CORE_RENDER_SOURCES)
prepend_sources(SRB2_CORE_GAME_SOURCES)
set(SRB2_CORE_HEADERS ${SRB2_CORE_HEADERS} ${CMAKE_CURRENT_BINARY_DIR}/config.h)
source_group("Main" FILES ${SRB2_CORE_SOURCES} ${SRB2_CORE_HEADERS})
source_group("Renderer" FILES ${SRB2_CORE_RENDER_SOURCES})
source_group("Game" FILES ${SRB2_CORE_GAME_SOURCES})
### Configuration ### Configuration
set(SRB2_CONFIG_HAVE_BLUA ON CACHE BOOL set(SRB2_CONFIG_DEV_BUILD OFF CACHE BOOL
"Enable Lua interpreter support") "Compile a development build of SRB2Kart.")
set(SRB2_CONFIG_HAVE_PNG ON CACHE BOOL
"Enable PNG support. Depends on zlib, so will be disabled if you don't enable that too.")
set(SRB2_CONFIG_HAVE_ZLIB ON CACHE BOOL
"Enable zlib support.")
set(SRB2_CONFIG_HAVE_GME ON CACHE BOOL
"Enable GME support.")
set(SRB2_CONFIG_HAVE_OPENMPT ON CACHE BOOL
"Enable OpenMPT support.")
set(SRB2_CONFIG_HAVE_DISCORDRPC OFF CACHE BOOL
"Enable Discord rich presence support.")
set(SRB2_CONFIG_HAVE_CURL ON CACHE BOOL
"Enable curl support, used for downloading files via HTTP.")
set(SRB2_CONFIG_HWRENDER ON CACHE BOOL
"Enable hardware rendering through OpenGL.")
set(SRB2_CONFIG_STATIC_OPENGL OFF CACHE BOOL
"Use statically linked OpenGL. NOT RECOMMENDED.")
set(SRB2_CONFIG_DEDICATED OFF CACHE BOOL
"Build a dedicated server.")
set(SRB2_CONFIG_LIBBACKTRACE ON CACHE BOOL
"Enable using libbacktrace for crashlogs.")
set(SRB2_CONFIG_LTO ON CACHE BOOL
"Enable link time optimizations, improves performance at the cost of longer link times.")
set(SRB2_CONFIG_ASAN OFF CACHE BOOL
"Compile with AddressSanitizer (libasan).")
set(SRB2_CONFIG_UBSAN OFF CACHE BOOL
"Compile with UndefinedBehaviorSanitizer (libubsan).")
set(SRB2_CONFIG_SATURNPAK ON CACHE BOOL set(SRB2_CONFIG_SKIP_COMPTIME OFF CACHE BOOL
"Enable Saturn specific special packet. Required for using the newer resynch system") "Skip Comptime rebuild.")
set(SRB2_CONFIG_SATURNJOIN ON CACHE BOOL
"Enable Saturn specific allowjoin toggle.")
set(SRB2_CONFIG_SCREENFBO ON CACHE BOOL
"Enable hardware renderer (OpenGL) FBO downsampling support")
if(${SRB2_CONFIG_DEDICATED}) if(NOT SRB2_CONFIG_SKIP_COMPTIME)
set(SRB2_CONFIG_HAVE_GME NO) # This updates the modification time for comptime.c at the
set(SRB2_CONFIG_HAVE_OPENMPT NO) # end of building so when the build system is ran next time,
set(SRB2_CONFIG_HWRENDER NO) # that file gets flagged. comptime.c will always be rebuilt.
endif() #
# This begs the question, why always rebuild comptime.c?
### use internal libraries? # Some things like the git commit must be checked each time
if(${CMAKE_SYSTEM} MATCHES "Windows") ###set on Windows only # the program is built. But the build system determines which
set(SRB2_CONFIG_USE_INTERNAL_LIBRARIES OFF CACHE BOOL # files should be rebuilt before anything else. So
"Use SRB2Kart's internal copies of required dependencies (SDL2, PNG, zlib, GME, OpenMPT).") # comptime.c, which only needs to be rebuilt based on
endif() # information known at build time, must be told to rebuild
# before that information can be ascertained.
if(${SRB2_CONFIG_HAVE_BLUA}) add_custom_command(
add_definitions(-DHAVE_BLUA) TARGET SRB2SDL2
set(SRB2_LUA_SOURCES POST_BUILD
lua_baselib.c COMMAND ${CMAKE_COMMAND} -E touch_nocreate ${CMAKE_CURRENT_SOURCE_DIR}/comptime.c
lua_blockmaplib.c
lua_consolelib.c
lua_hooklib.c
lua_hudlib.c
lua_hudlib_drawlist.c
lua_infolib.c
lua_maplib.c
lua_mathlib.c
lua_mobjlib.c
lua_playerlib.c
lua_script.c
lua_skinlib.c
lua_thinkerlib.c
lua_udatalib.c
lua_glib.c
) )
set(SRB2_LUA_HEADERS
lua_hook.h
lua_hud.h
lua_hudlib_drawlist.h
lua_libs.h
lua_script.h
lua_udatalib.h
lua_glib.h
)
prepend_sources(SRB2_LUA_SOURCES)
prepend_sources(SRB2_LUA_HEADERS)
source_group("LUA" FILES ${SRB2_LUA_SOURCES} ${SRB2_LUA_HEADERS})
set(SRB2_BLUA_SOURCES
blua/lapi.c
blua/lauxlib.c
blua/lbaselib.c
blua/ldblib.c
blua/lcode.c
blua/ldebug.c
blua/ldo.c
blua/ldump.c
blua/lfunc.c
blua/lgc.c
blua/linit.c
blua/liolib.c
blua/llex.c
blua/lmem.c
blua/lobject.c
blua/lopcodes.c
blua/lparser.c
blua/lstate.c
blua/lstring.c
blua/lstrlib.c
blua/ltable.c
blua/ltablib.c
blua/ltm.c
blua/lundump.c
blua/lvm.c
blua/lzio.c
)
set(SRB2_BLUA_HEADERS
blua/lapi.h
blua/lauxlib.h
blua/lcode.h
blua/ldebug.h
blua/ldo.h
blua/lfunc.h
blua/lgc.h
blua/llex.h
blua/llimits.h
blua/lmem.h
blua/lobject.h
blua/lopcodes.h
blua/lparser.h
blua/lstate.h
blua/lstring.h
blua/ltable.h
blua/ltm.h
blua/lua.h
blua/luaconf.h
blua/lualib.h
blua/lundump.h
blua/lvm.h
blua/lzio.h
)
prepend_sources(SRB2_BLUA_SOURCES)
prepend_sources(SRB2_BLUA_HEADERS)
source_group("LUA\\Interpreter" FILES ${SRB2_BLUA_SOURCES} ${SRB2_BLUA_HEADERS})
endif() endif()
if(${SRB2_CONFIG_HAVE_GME}) set(GIT_EXECUTABLE "git" CACHE FILEPATH "Path to git binary")
if(${SRB2_CONFIG_USE_INTERNAL_LIBRARIES}) add_custom_target(_SRB2_reconf ALL
set(GME_FOUND ON) COMMAND ${CMAKE_COMMAND} -DGIT_EXECUTABLE=${GIT_EXECUTABLE} -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DBINARY_DIR=${CMAKE_CURRENT_BINARY_DIR}/.. -P ${CMAKE_CURRENT_SOURCE_DIR}/../cmake/Comptime.cmake
set(GME_INCLUDE_DIRS ${CMAKE_SOURCE_DIR}/libs/gme/include) WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/.."
if(${SRB2_SYSTEM_BITS} EQUAL 64) )
set(GME_LIBRARIES "-L${CMAKE_SOURCE_DIR}/libs/gme/win64 -lgme") add_dependencies(SRB2SDL2 _SRB2_reconf)
else() # 32-bit
set(GME_LIBRARIES "-L${CMAKE_SOURCE_DIR}/libs/gme/win32 -lgme") if(SRB2_CONFIG_ASAN)
endif() target_compile_options(SRB2SDL2 PRIVATE -fsanitize=address)
else() target_link_options(SRB2SDL2 PRIVATE -fsanitize=address)
find_package(GME) endif()
endif()
if(${GME_FOUND}) if(SRB2_CONFIG_UBSAN)
set(SRB2_HAVE_GME ON) target_compile_options(SRB2SDL2 PRIVATE -fsanitize=undefined)
add_definitions(-DHAVE_LIBGME) target_link_options(SRB2SDL2 PRIVATE -fsanitize=undefined)
else() endif()
message(WARNING "You have specified that GME is available but it was not found.")
if(SRB2_CONFIG_TIDY)
set(CMAKE_CXX_CLANG_TIDY "clang-tidy;-checks=*")
endif()
add_subdirectory(blua)
add_subdirectory(sdl)
add_subdirectory(core)
# OS macros
if (UNIX)
target_compile_definitions(SRB2SDL2 PRIVATE -DUNIXCOMMON)
target_link_libraries(SRB2SDL2 PRIVATE -rdynamic) # Use -rdynamic so a backtrace log shows function names
endif()
if(CMAKE_COMPILER_IS_GNUCC)
find_program(OBJCOPY objcopy)
endif()
if("${CMAKE_SYSTEM_NAME}" MATCHES "Linux")
target_compile_definitions(SRB2SDL2 PRIVATE -DLINUX)
if(${SRB2_SYSTEM_BITS} EQUAL 64)
target_compile_definitions(SRB2SDL2 PRIVATE -DLINUX64)
endif() endif()
endif() endif()
if(${SRB2_CONFIG_HAVE_DISCORDRPC}) if("${CMAKE_SYSTEM_NAME}" MATCHES "Darwin")
if(${SRB2_CONFIG_USE_INTERNAL_LIBRARIES}) target_compile_definitions(SRB2SDL2 PRIVATE -DMACOSX)
set(DISCORDRPC_FOUND ON)
if(${SRB2_SYSTEM_BITS} EQUAL 64)
set(DISCORDRPC_INCLUDE_DIRS ${CMAKE_SOURCE_DIR}/libs/discord-rpc/win64-dynamic/include)
set(DISCORDRPC_LIBRARIES "-L${CMAKE_SOURCE_DIR}/libs/discord-rpc/win64-dynamic/lib -ldiscord-rpc")
else() # 32-bit
set(DISCORDRPC_INCLUDE_DIRS ${CMAKE_SOURCE_DIR}/libs/discord-rpc/win32-dynamic/include)
set(DISCORDRPC_LIBRARIES "-L${CMAKE_SOURCE_DIR}/libs/discord-rpc/win32-dynamic/lib -ldiscord-rpc")
endif()
else()
find_package(DiscordRPC)
endif()
if(${DISCORDRPC_FOUND})
set(SRB2_HAVE_DISCORDRPC ON)
add_definitions(-DHAVE_DISCORDRPC)
add_definitions(-DUSE_STUN)
set(SRB2_DISCORDRPC_SOURCES discord.c stun.c)
set(SRB2_DISCORDRPC_HEADERS discord.h stun.h)
prepend_sources(SRB2_DISCORDRPC_SOURCES)
prepend_sources(SRB2_DISCORDRPC_HEADERS)
source_group("Discord Rich Presence" FILES ${SRB2_DISCORDRPC_SOURCES} ${SRB2_DISCORDRPC_HEADERS})
else()
message(WARNING "You have specified that Discord Rich Presence is available but it was not found.")
endif()
endif() endif()
if(${SRB2_CONFIG_HAVE_OPENMPT}) # add toggle for this
if(${SRB2_CONFIG_USE_INTERNAL_LIBRARIES}) target_link_libraries(SRB2SDL2 PRIVATE openmpt)
set(OPENMPT_FOUND ON) target_compile_definitions(SRB2SDL2 PRIVATE -DHAVE_OPENMPT)
set(OPENMPT_INCLUDE_DIRS ${CMAKE_SOURCE_DIR}/libs/libopenmpt/inc)
if(${SRB2_SYSTEM_BITS} EQUAL 64) target_link_libraries(SRB2SDL2 PRIVATE ZLIB::ZLIB PNG::PNG CURL::libcurl)
set(OPENMPT_LIBRARIES "-L${CMAKE_SOURCE_DIR}/libs/libopenmpt/lib/x86_64/mingw -lopenmpt") target_compile_definitions(SRB2SDL2 PRIVATE -DHAVE_ZLIB -DHAVE_PNG -DHAVE_CURL -D_LARGEFILE64_SOURCE)
else() # 32-bit
set(OPENMPT_LIBRARIES "-L${CMAKE_SOURCE_DIR}/libs/libopenmpt/lib/x86/mingw -lopenmpt") target_compile_definitions(SRB2SDL2 PRIVATE -DUSE_STUN)
endif() if(SRB2_CONFIG_ENABLE_DISCORDRPC)
else() target_link_libraries(SRB2SDL2 PRIVATE DiscordRPC::DiscordRPC)
find_package(OPENMPT) target_compile_definitions(SRB2SDL2 PRIVATE -DHAVE_DISCORDRPC)
endif() target_sources(SRB2SDL2 PRIVATE discord.c)
if(${OPENMPT_FOUND}) endif()
set(SRB2_HAVE_OPENMPT ON)
add_definitions(-DHAVE_OPENMPT) if(${SRB2_CONFIG_LIBBACKTRACE})
else() target_link_libraries(SRB2SDL2 PRIVATE libbacktrace)
message(WARNING "You have specified that OpenMPT is available but it was not found.") target_compile_definitions(SRB2SDL2 PRIVATE -DHAVE_LIBBACKTRACE)
endif() endif()
# FIXME macOS does not support C11 threads.h
if(NOT "${CMAKE_SYSTEM_NAME}" MATCHES "Darwin")
set(SRB2_HAVE_THREADS ON)
target_compile_definitions(SRB2SDL2 PRIVATE -DHAVE_THREADS)
endif() endif()
if(${SRB2_CONFIG_HAVE_ZLIB}) if(${SRB2_CONFIG_HAVE_ZLIB})
if(${SRB2_CONFIG_USE_INTERNAL_LIBRARIES}) if(${SRB2_CONFIG_USE_INTERNAL_LIBRARIES})
set(ZLIB_FOUND ON) set(ZLIB_FOUND ON)
set(ZLIB_COMPAT ON)
set(WITH_GTEST OFF)
set(ZLIB_INCLUDE_DIRS ${CMAKE_SOURCE_DIR}/libs/zlib) set(ZLIB_INCLUDE_DIRS ${CMAKE_SOURCE_DIR}/libs/zlib)
if(${SRB2_SYSTEM_BITS} EQUAL 64) if(${SRB2_SYSTEM_BITS} EQUAL 64)
set(ZLIB_LIBRARIES "-L${CMAKE_SOURCE_DIR}/libs/zlib/win32 -lz64") set(ZLIB_LIBRARIES "-L${CMAKE_SOURCE_DIR}/libs/zlib/win32 -lz64")
@@ -442,9 +152,9 @@ if(${SRB2_CONFIG_HAVE_ZLIB})
endif() endif()
if(${ZLIB_FOUND}) if(${ZLIB_FOUND})
set(SRB2_HAVE_ZLIB ON) set(SRB2_HAVE_ZLIB ON)
add_definitions(-DHAVE_ZLIB) target_compile_definitions(SRB2SDL2 PRIVATE -DHAVE_ZLIB)
else() else()
message(WARNING "You have specified that ZLIB is available but it was not found. SRB2Kart may not compile correctly.") message(WARNING "You have specified that ZLIB is available but it was not found. SRB2Kart-Saturn may not compile correctly.")
endif() endif()
endif() endif()
@@ -463,162 +173,292 @@ if(${SRB2_CONFIG_HAVE_PNG} AND ${SRB2_CONFIG_HAVE_ZLIB})
endif() endif()
if(${PNG_FOUND}) if(${PNG_FOUND})
set(SRB2_HAVE_PNG ON) set(SRB2_HAVE_PNG ON)
add_definitions(-DHAVE_PNG) target_compile_definitions(SRB2SDL2 PRIVATE -DHAVE_PNG)
add_definitions(-D_LARGEFILE64_SOURCE) target_compile_definitions(SRB2SDL2 PRIVATE -D_LARGEFILE64_SOURCE)
source_group("Main" FILES ${SRB2_CORE_SOURCES} ${SRB2_CORE_HEADERS})
else() else()
message(WARNING "You have specified that PNG is available but it was not found. SRB2Kart may not compile correctly.") message(WARNING "You have specified that PNG is available but it was not found. SRB2Kart-Saturn may not compile correctly.")
endif() endif()
endif() endif()
endif() endif()
if(${SRB2_CONFIG_HAVE_CURL}) if("${SRB2_CONFIG_HWRENDER}")
if(${SRB2_CONFIG_USE_INTERNAL_LIBRARIES}) target_compile_definitions(SRB2SDL2 PRIVATE -DHWRENDER)
set(CURL_FOUND ON) add_subdirectory(hardware)
set(CURL_INCLUDE_DIRS ${CMAKE_SOURCE_DIR}/libs/curl/include)
if(${SRB2_SYSTEM_BITS} EQUAL 64) if("${SRB2_CONFIG_STATIC_OPENGL}")
set(CURL_LIBRARIES "-L${CMAKE_SOURCE_DIR}/libs/curl/lib64 -lcurl") find_package(OpenGL)
else() # 32-bit if(${OPENGL_FOUND})
set(CURL_LIBRARIES "-L${CMAKE_SOURCE_DIR}/libs/curl/lib32 -lcurl") target_compile_definitions(SRB2SDL2 PRIVATE -DSTATIC_OPENGL)
else()
message(WARNING "You have specified static opengl but opengl was not found. Not setting HWRENDER.")
endif() endif()
else()
find_package(CURL)
endif()
if(${CURL_FOUND})
set(SRB2_HAVE_CURL ON)
add_definitions(-DHAVE_CURL)
else()
message(WARNING "You have specified that CURL is available but it was not found. SRB2Kart may not compile correctly.")
endif() endif()
endif() endif()
if(${SRB2_CONFIG_LIBBACKTRACE}) # TODO: build this with the game
if(${SRB2_CONFIG_USE_INTERNAL_LIBRARIES}) if(${CMAKE_SYSTEM} MATCHES Windows AND ${CMAKE_C_COMPILER_ID} MATCHES "GNU" AND ${SRB2_SYSTEM_BITS} EQUAL 32)
if(${SRB2_SYSTEM_BITS} EQUAL 64) target_link_libraries(SRB2SDL2 PRIVATE
set(LIBBACKTRACE_FOUND ON) "${CMAKE_CURRENT_SOURCE_DIR}/../libs/drmingw/lib/win32/libexchndl.a"
set(LIBBACKTRACE_INCLUDE_DIRS ${CMAKE_SOURCE_DIR}/libs/libbacktrace/include) "${CMAKE_CURRENT_SOURCE_DIR}/../libs/drmingw/lib/win32/libmgwhelp.a"
set(LIBBACKTRACE_LIBRARIES "-L${CMAKE_SOURCE_DIR}/libs/libbacktrace/lib/x86_64 -lbacktrace")
else() # 32-bit
message(WARNING "libbacktrace is unsupported on 32-bit builds.")
endif()
else()
find_package(libbacktrace)
endif()
if(${LIBBACKTRACE_FOUND})
set(SRB2_HAVE_LIBBACKTRACE ON)
add_definitions(-DHAVE_LIBBACKTRACE)
else()
message(WARNING "You have specified that libbacktrace is available but it was not found.")
endif()
endif()
if(${SRB2_CONFIG_HWRENDER})
add_definitions(-DHWRENDER)
set(SRB2_HWRENDER_SOURCES
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_batching.c
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_shaders.c
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_bsp.c
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_cache.cpp
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_clip.c
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_draw.c
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_main.cpp
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_portal.c
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_md2.c
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_md2load.c
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_md3load.c
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_model.c
${CMAKE_CURRENT_SOURCE_DIR}/hardware/u_list.c
) )
target_include_directories(SRB2SDL2 PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/../libs/drmingw/include")
set (SRB2_HWRENDER_HEADERS
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_batching.h
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_shaders.h
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_clip.h
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_data.h
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_defs.h
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_gl.h
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_glob.h
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_main.h
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_portal.h
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_md2.h
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_md2load.h
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_md3load.h
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_model.h
${CMAKE_CURRENT_SOURCE_DIR}/hardware/u_list.h
)
set(SRB2_R_OPENGL_SOURCES
${CMAKE_CURRENT_SOURCE_DIR}/hardware/r_opengl/r_opengl.c
)
set(SRB2_R_OPENGL_HEADERS
${CMAKE_CURRENT_SOURCE_DIR}/hardware/r_opengl/r_opengl.h
)
endif()
if(${SRB2_CONFIG_HWRENDER} AND ${SRB2_CONFIG_STATIC_OPENGL})
find_package(OpenGL)
if(${OPENGL_FOUND})
add_definitions(-DHWRENDER)
add_definitions(-DSTATIC_OPENGL)
else()
message(WARNING "You have specified static opengl but opengl was not found. Not setting HWRENDER.")
endif()
endif()
if(${SRB2_CONFIG_HWRENDER} AND ${SRB2_CONFIG_SCREENFBO})
add_definitions(-DUSE_FBO_OGL)
endif()
if(${SRB2_CONFIG_SATURNPAK})
add_definitions(-DDOSATURNPAK)
endif()
if(${SRB2_CONFIG_SATURNJOIN})
add_definitions(-DDOSATURNJOIN)
endif() endif()
# Targets # Targets
# If using CCACHE, then force it.
# https://github.com/Cockatrice/Cockatrice/pull/3052/files
if ("${CMAKE_SYSTEM_NAME}" MATCHES "Darwin")
get_property(RULE_LAUNCH_COMPILE GLOBAL PROPERTY RULE_LAUNCH_COMPILE)
if(RULE_LAUNCH_COMPILE)
MESSAGE(STATUS "Force enabling CCache usage under macOS")
# Set up wrapper scripts
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/../cmake/launch-c.in ${CMAKE_BINARY_DIR}/launch-c)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/../cmake/launch-cxx.in ${CMAKE_BINARY_DIR}/launch-cxx)
execute_process(COMMAND chmod a+rx
"${CMAKE_BINARY_DIR}/launch-c"
"${CMAKE_BINARY_DIR}/launch-cxx")
# Set Xcode project attributes to route compilation through our scripts
set(CMAKE_XCODE_ATTRIBUTE_CC "${CMAKE_BINARY_DIR}/launch-c")
set(CMAKE_XCODE_ATTRIBUTE_CXX "${CMAKE_BINARY_DIR}/launch-cxx")
set(CMAKE_XCODE_ATTRIBUTE_LD "${CMAKE_BINARY_DIR}/launch-c")
set(CMAKE_XCODE_ATTRIBUTE_LDPLUSPLUS "${CMAKE_BINARY_DIR}/launch-cxx")
endif()
endif()
# Compatibility flag with later versions of GCC # Compatibility flag with later versions of GCC
# We should really fix our code to not need this # We should really fix our code to not need this
if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
if (CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|x64|amd64|AMD64|em64t|EM64T)") if (CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|x64|amd64|AMD64|em64t|EM64T)")
add_compile_options(-mno-ms-bitfields) target_compile_options(SRB2SDL2 PRIVATE -mno-ms-bitfields)
endif() endif()
add_compile_options(-Wno-trigraphs) target_compile_options(SRB2SDL2 PRIVATE -Wno-trigraphs)
endif() endif()
# TODO: fix prng and P_CreateBlockmap overflow at some point # TODO: fix prng and P_CreateBlockmap overflow at some point
add_compile_options(-fwrapv) target_compile_options(SRB2SDL2 PRIVATE -fwrapv)
if (${CMAKE_BUILD_TYPE} MATCHES Debug) if (${CMAKE_BUILD_TYPE} MATCHES Debug)
add_compile_options(-O0) target_compile_options(SRB2SDL2 PRIVATE -O0)
target_compile_options(SRB2SDL2 PRIVATE -g)
else() else()
add_compile_options(-O3) target_compile_options(SRB2SDL2 PRIVATE -O3)
target_compile_options(SRB2SDL2 PRIVATE -g1) #should be enough for libbacktrace
endif() endif()
add_compile_options(-g) # Compiler warnings configuration
target_compile_options(SRB2SDL2 PRIVATE
# Using generator expressions to handle per-language compile options
add_definitions(-DCMAKECONFIG) # C, GNU
# This is a direct translation from versions.mk
$<$<AND:$<COMPILE_LANGUAGE:C>,$<C_COMPILER_ID:GNU>>:
-Wall
-Wextra
-Wno-trigraphs
-W # Was controlled by RELAXWARNINGS
-Wfloat-equal
-Wundef
-Wpointer-arith
-Wbad-function-cast
-Wcast-qual
-Wcast-align # Was controlled by NOCASTALIGNWARN
-Wwrite-strings
-Wsign-compare
-Wno-comment
-Wno-alloc-size-larger-than # holy shit, be quiet up GCC
-Wmissing-prototypes
-Wmissing-declarations
-Wmissing-noreturn
-Wnested-externs
-Wformat-y2k
-Wformat-security
#add_library(SRB2Core STATIC $<$<VERSION_LESS:$<C_COMPILER_VERSION>,2.9.5>:
# ${SRB2_CORE_SOURCES} -Wno-div-by-zero
# ${SRB2_CORE_HEADERS} -Wendif-labels
# ${SRB2_CORE_RENDER_SOURCES} -Wdisabled-optimization
# ${SRB2_CORE_GAME_SOURCES} >
# ${SRB2_LUA_SOURCES}
# ${SRB2_LUA_HEADERS}
# ${SRB2_BLUA_SOURCES}
# ${SRB2_BLUA_HEADERS}
#)
if(${SRB2_CONFIG_DEDICATED}) $<$<VERSION_GREATER_EQUAL:$<C_COMPILER_VERSION>,4.0.0>:
add_subdirectory(dedicated) -Wold-style-definition
else() -Wmissing-field-initializers
add_subdirectory(sdl) >
$<$<VERSION_GREATER_EQUAL:$<C_COMPILER_VERSION>,4.1.0>:
-Wshadow
>
$<$<VERSION_GREATER_EQUAL:$<C_COMPILER_VERSION>,4.3.0>:
-funit-at-a-time
-Wlogical-op
>
$<$<VERSION_GREATER_EQUAL:$<C_COMPILER_VERSION>,4.5.0>:
-Wlogical-op
-Wno-error=array-bounds
>
$<$<VERSION_GREATER_EQUAL:$<C_COMPILER_VERSION>,4.6.0>:
-Wno-suggest-attribute=noreturn
-Wno-error=suggest-attribute=noreturn
>
$<$<VERSION_GREATER_EQUAL:$<C_COMPILER_VERSION>,5.4.0>:
-Wno-logical-op
-Wno-error=logical-op
>
$<$<VERSION_GREATER_EQUAL:$<C_COMPILER_VERSION>,6.1.0>:
-Wno-tautological-compare
-Wno-error=tautological-compare
>
$<$<VERSION_GREATER_EQUAL:$<C_COMPILER_VERSION>,7.1.0>:
-Wno-error=format-overflow=2
-Wimplicit-fallthrough=4
>
$<$<VERSION_GREATER_EQUAL:$<C_COMPILER_VERSION>,8.1.0>:
-Wno-error=format-overflow
-Wno-error=stringop-truncation
-Wno-error=stringop-overflow
-Wno-format-overflow
-Wno-stringop-truncation
-Wno-stringop-overflow
-Wno-error=multistatement-macros
>
$<$<VERSION_GREATER_EQUAL:$<C_COMPILER_VERSION>,9.1.0>:
-Wno-error=address-of-packed-member
>
>
# C, Clang and Apple Clang
$<$<AND:$<COMPILE_LANGUAGE:C>,$<OR:$<C_COMPILER_ID:AppleClang>,$<C_COMPILER_ID:Clang>>>:
-Wall
-Wextra
-Wno-absolute-value
-Wno-trigraphs
-Wno-error=non-literal-null-conversion
-Wno-error=constant-conversion
-Wno-unused-but-set-variable
-Wno-error=unused-but-set-variable
>
# C++, GNU, Clang and Apple Clang
$<$<AND:$<COMPILE_LANGUAGE:CXX>,$<OR:$<C_COMPILER_ID:GNU>,$<C_COMPILER_ID:AppleClang>,$<C_COMPILER_ID:Clang>>>:
-Wall
-Wno-unused-function
-Wno-unused-but-set-variable
-Wno-unused-private-field
>
# GNU
$<$<C_COMPILER_ID:GNU>:
-fmax-errors=5
>
)
if(SRB2_CONFIG_ERRORMODE)
target_compile_options(SRB2SDL2 PRIVATE
$<$<OR:$<C_COMPILER_ID:GNU>,$<C_COMPILER_ID:AppleClang>,$<C_COMPILER_ID:Clang>>:
-Werror
>
)
endif() endif()
if(NOT ${SRB2_SDL2_AVAILABLE} AND NOT ${SRB2_WIN32_AVAILABLE}) # Link warnings configuration
message(FATAL_ERROR "There are no targets available to build an SRB2Kart executable. :(") target_link_options(SRB2SDL2 PRIVATE
$<$<C_COMPILER_ID:GNU>:
# -Wl,--as-needed - Was controlled by NOLDWARNING
>
)
if(${SRB2_CONFIG_DEV_BUILD})
target_compile_definitions(SRB2SDL2 PRIVATE -DDEVELOP)
endif()
target_compile_definitions(SRB2SDL2 PRIVATE -DCMAKECONFIG)
# Misc. build options from Makefiles
if(SRB2_CONFIG_DEBUGMODE)
target_compile_definitions(SRB2SDL2 PRIVATE -D_DEBUG -DZDEBUG -DPARANOIA -DRANGECHECK -DPACKETDROP)
endif()
if(SRB2_CONFIG_MOBJCONSISTANCY)
target_compile_definitions(SRB2SDL2 PRIVATE -DMOBJCONSISTANCY)
endif()
if(SRB2_CONFIG_PACKETDROP)
target_compile_definitions(SRB2SDL2 PRIVATE -DPACKETDROP)
endif()
if(SRB2_CONFIG_ZDEBUG)
target_compile_definitions(SRB2SDL2 PRIVATE -DZDEBUG)
endif()
if(SRB2_CONFIG_PROFILEMODE AND "${CMAKE_C_COMPILER_ID}" STREQUAL "GNU")
target_compile_options(SRB2SDL2 PRIVATE -pg)
target_link_options(SRB2SDL2 PRIVATE -pg)
endif()
if(SRB2_CONFIG_LTO AND NOT SRB2_CONFIG_DEBUGMODE)
set_property(TARGET SRB2SDL2 PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
endif()
if(${SRB2_CONFIG_SCREENFBO} AND NOT ${SRB2_CONFIG_STATIC_OPENGL})
target_compile_definitions(SRB2SDL2 PRIVATE -DUSE_FBO_OGL)
endif()
if(${SRB2_CONFIG_SATURNPAK})
target_compile_definitions(SRB2SDL2 PRIVATE -DDOSATURNPAK)
endif()
if(${SRB2_CONFIG_SATURNJOIN})
target_compile_definitions(SRB2SDL2 PRIVATE -DDOSATURNJOIN)
endif()
# strip debug symbols into separate file when using gcc or clang.
# to be consistent with Makefile, don't generate for OS X.
if((CMAKE_COMPILER_IS_GNUCC OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang") AND NOT ("${CMAKE_SYSTEM_NAME}" MATCHES Darwin))
if((${CMAKE_BUILD_TYPE} MATCHES Debug) OR (${CMAKE_BUILD_TYPE} MATCHES RelWithDebInfo))
if(${CMAKE_BUILD_TYPE} MATCHES Debug)
set(OBJCOPY_ONLY_KEEP_DEBUG "--only-keep-debug")
endif()
message(STATUS "Will make separate debug symbols in *.debug")
add_custom_command(TARGET SRB2SDL2 POST_BUILD
COMMAND ${CMAKE_OBJCOPY} ${OBJCOPY_ONLY_KEEP_DEBUG} $<TARGET_FILE:SRB2SDL2> $<TARGET_FILE:SRB2SDL2>.debug
# mold linker: .gnu_debuglink is present by default, so --add-gnu-debuglink would fail
COMMAND ${CMAKE_OBJCOPY} --strip-debug --remove-section=.gnu_debuglink $<TARGET_FILE:SRB2SDL2>
COMMAND ${CMAKE_OBJCOPY} --add-gnu-debuglink=$<TARGET_FILE:SRB2SDL2>.debug $<TARGET_FILE:SRB2SDL2>
)
endif()
endif()
# copy DLLs to bin/ directory if building internal shared on windows
if("${CMAKE_SYSTEM_NAME}" STREQUAL Windows AND NOT "${SRB2_CONFIG_INTERNAL_LIBRARIES}" AND "${SRB2_CONFIG_SHARED_INTERNAL_LIBRARIES}")
set(ADDITIONAL_DLLS "")
if("${CMAKE_C_COMPILER_ID}" STREQUAL GNU OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
# also copy implicitly linked system libraries
get_filename_component(MINGW_BIN_PATH ${CMAKE_CXX_COMPILER} PATH)
if("${CMAKE_C_COMPILER_ID}" STREQUAL GNU)
list(APPEND ADDITIONAL_DLLS
"libgcc_s_dw2-1.dll"
"libstdc++-6.dll"
"libwinpthread-1.dll"
)
else()
list(APPEND ADDITIONAL_DLLS
"libunwind.dll"
"libc++.dll"
"libwinpthread-1.dll"
)
endif()
list(TRANSFORM ADDITIONAL_DLLS PREPEND "${MINGW_BIN_PATH}/")
endif()
add_custom_command(TARGET SRB2SDL2 POST_BUILD
COMMAND ${CMAKE_COMMAND} -E copy_if_different
$<TARGET_RUNTIME_DLLS:SRB2SDL2>
${ADDITIONAL_DLLS}
$<TARGET_FILE_DIR:SRB2SDL2>
COMMAND_EXPAND_LISTS
COMMENT "Copying runtime DLLs"
)
endif() endif()
+5 -6
View File
@@ -93,7 +93,7 @@
# NOLDWARNING=1 - ? # NOLDWARNING=1 - ?
# NOSDLMAIN=1 - ? # NOSDLMAIN=1 - ?
# SDLMAIN=1 - ? # SDLMAIN=1 - ?
# NOLTO=1 - Disable link time optimizations # USELTO=1 - Enable building with LTO.
# #
# Library configuration flags: # Library configuration flags:
# Everything here is an override. # Everything here is an override.
@@ -260,7 +260,7 @@ 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 ifdef USELTO
# compile with LTO # compile with LTO
opts+=-flto=auto opts+=-flto=auto
libs+=-flto=auto libs+=-flto=auto
@@ -269,13 +269,13 @@ endif
ifdef USEASAN ifdef USEASAN
# compile with asan # compile with asan
opts+=-O1 -fsanitize=address -fno-omit-frame-pointer -fno-common opts+=-fsanitize=address
libs+=-fsanitize=address libs+=-fsanitize=address
endif endif
ifdef USEUBSAN ifdef USEUBSAN
# compile with ubsan # compile with asan
opts+=-O1 -fsanitize=undefined -fno-omit-frame-pointer opts+=-fsanitize=undefined
libs+=-fsanitize=undefined libs+=-fsanitize=undefined
endif endif
@@ -295,7 +295,6 @@ opts+=$(debug_opts)
opts+=$(foreach v,$(passthru_opts),$(if $($(v)),-D$(v))) opts+=$(foreach v,$(passthru_opts),$(if $($(v)),-D$(v)))
CWFLAGS+=-std=gnu17
CXXFLAGS+=-std=c++17 # force c17 for c++ since most vpss run older ubuntu versions with old compilers CXXFLAGS+=-std=c++17 # force c17 for c++ since most vpss run older ubuntu versions with old compilers
opts+=$(WFLAGS) $(CFLAGS) opts+=$(WFLAGS) $(CFLAGS)
+3 -3
View File
@@ -64,9 +64,9 @@ endif
# This must have high to low order. # This must have high to low order.
gcc_versions:=\ gcc_versions:=\
152 151 150 15\ 151 150 15\
142 141 140 14\ 142 141 140 14\
133 132 131 130 13\ 132 131 130 13\
123 122 121 120 12\ 123 122 121 120 12\
114 113 112 111 110 11\ 114 113 112 111 110 11\
105 104 103 102 101 100 10\ 105 104 103 102 101 100 10\
@@ -77,7 +77,7 @@ gcc_versions:=\
55 54 53 52 51 50\ 55 54 53 52 51 50\
49 48 47 46 45 44 43 42 41 40 49 48 47 46 45 44 43 42 41 40
latest_gcc_version:=15.2 latest_gcc_version:=15.1.1
# Automatically set version flag, but not if one was # Automatically set version flag, but not if one was
# manually set. And don't bother if this is a clean only # manually set. And don't bother if this is a clean only
+12 -16
View File
@@ -20,11 +20,7 @@ $(foreach v,$(join $(wordlist 2,$(_n),- $(gcc_versions)),\
CXXFLAGS+= -Wno-aggregate-return CXXFLAGS+= -Wno-aggregate-return
# -W -Wno-unused # -W -Wno-unused
WFLAGS:=-Wall -Wnull-dereference WFLAGS:=-Wall -Wno-trigraphs
#WFLAGS+=-Wno-trigraphs
ifdef GCC152
WFLAGS+=-Wzero-as-null-pointer-constant
endif
ifndef GCC295 ifndef GCC295
#WFLAGS+=-Wno-packed #WFLAGS+=-Wno-packed
endif endif
@@ -32,7 +28,7 @@ ifndef RELAXWARNINGS
WFLAGS+=-W WFLAGS+=-W
#WFLAGS+=-Wno-sign-compare #WFLAGS+=-Wno-sign-compare
ifndef GCC295 ifndef GCC295
# WFLAGS+=-Wno-div-by-zero WFLAGS+=-Wno-div-by-zero
endif endif
#WFLAGS+=-Wsystem-headers #WFLAGS+=-Wsystem-headers
WFLAGS+=-Wfloat-equal WFLAGS+=-Wfloat-equal
@@ -63,7 +59,7 @@ endif
endif endif
WFLAGS+=-Wsign-compare WFLAGS+=-Wsign-compare
ifdef GCC91 ifdef GCC91
# WFLAGS+=-Wno-error=address-of-packed-member WFLAGS+=-Wno-error=address-of-packed-member
endif endif
ifdef GCC45 ifdef GCC45
WFLAGS+=-Wlogical-op WFLAGS+=-Wlogical-op
@@ -106,14 +102,14 @@ endif
endif endif
WFLAGS+=-Wformat-y2k WFLAGS+=-Wformat-y2k
ifdef GCC71 ifdef GCC71
#WFLAGS+=-Wno-error=format-overflow=2 WFLAGS+=-Wno-error=format-overflow=2
endif endif
WFLAGS+=-Wformat-security WFLAGS+=-Wformat-security
ifndef GCC29 ifndef GCC29
#WFLAGS+=-Winit-self #WFLAGS+=-Winit-self
endif endif
ifdef GCC46 ifdef GCC46
#WFLAGS+=-Wno-suggest-attribute=noreturn WFLAGS+=-Wno-suggest-attribute=noreturn
endif endif
ifdef NOLDWARNING ifdef NOLDWARNING
@@ -131,21 +127,21 @@ ifdef GCC44
#WFLAGS+=-Wno-error=array-bounds #WFLAGS+=-Wno-error=array-bounds
endif endif
ifdef GCC46 ifdef GCC46
# WFLAGS+=-Wno-error=suggest-attribute=noreturn WFLAGS+=-Wno-error=suggest-attribute=noreturn
endif endif
ifdef GCC54 ifdef GCC54
# WFLAGS+=-Wno-logical-op -Wno-error=logical-op WFLAGS+=-Wno-logical-op -Wno-error=logical-op
endif endif
ifdef GCC61 ifdef GCC61
# WFLAGS+=-Wno-tautological-compare -Wno-error=tautological-compare WFLAGS+=-Wno-tautological-compare -Wno-error=tautological-compare
endif endif
ifdef GCC71 ifdef GCC71
WFLAGS+=-Wimplicit-fallthrough=4 WFLAGS+=-Wimplicit-fallthrough=4
endif endif
ifdef GCC81 ifdef GCC81
# WFLAGS+=-Wno-error=format-overflow WFLAGS+=-Wno-error=format-overflow
# WFLAGS+=-Wno-format-overflow WFLAGS+=-Wno-format-overflow
# WFLAGS+=-Wno-error=multistatement-macros WFLAGS+=-Wno-error=multistatement-macros
endif endif
ifneq (,$(filter $(CC) $(CXX),clang clang++)) ifneq (,$(filter $(CC) $(CXX),clang clang++))
@@ -184,6 +180,6 @@ endif
# Lua # Lua
ifdef GCC43 ifdef GCC43
ifndef GCC44 ifndef GCC44
#WFLAGS+=-Wno-logical-op WFLAGS+=-Wno-logical-op
endif endif
endif endif
+4
View File
@@ -226,6 +226,10 @@ const char *I_LocateWad(void)
return "/sdcard/srb2"; return "/sdcard/srb2";
} }
void I_GetJoystickEvents(void){}
void I_GetJoystick2Events(void){}
char *I_GetEnv(const char *name) char *I_GetEnv(const char *name)
{ {
LOGW("I_GetEnv() called?!"); LOGW("I_GetEnv() called?!");
+1
View File
@@ -0,0 +1 @@
target_sourcefile(c)
+18 -39
View File
@@ -434,7 +434,7 @@ LUA_API void lua_pushnumber (lua_State *L, lua_Number n) {
LUA_API void lua_pushlstring (lua_State *L, const char *s, size_t len) { LUA_API void lua_pushlstring (lua_State *L, const char *s, size_t len) {
lua_lock(L); lua_lock(L);
luaC_checkGC(L); luaC_checkGC(L);
setsvalue2s(L, L->top, (len == 0) ? luaS_newlstr(L, "", 0) : luaS_newlstr(L, s, len)); setsvalue2s(L, L->top, (len == 0) ? luaS_new(L, "") : luaS_newlstr(L, s, len));
api_incr_top(L); api_incr_top(L);
lua_unlock(L); lua_unlock(L);
} }
@@ -519,23 +519,6 @@ LUA_API int lua_pushthread (lua_State *L) {
** get functions (Lua -> stack) ** get functions (Lua -> stack)
*/ */
static void auxgetstr (lua_State *L, TValue *t, const char *k) {
TValue *slot;
TValue key;
TString *str = luaS_new(L, k);
api_checkvalidindex(L, t);
if (luaV_fastget(L, t, str, slot, luaH_getstr)) {
setobj2s(L, L->top, slot);
api_incr_top(L);
}
else {
setsvalue(L, &key, str);
luaV_finishget(L, t, L->top, L->top, slot);
api_incr_top(L);
}
lua_unlock(L);
}
LUA_API void lua_gettable (lua_State *L, int idx) { LUA_API void lua_gettable (lua_State *L, int idx) {
StkId t; StkId t;
@@ -548,8 +531,15 @@ LUA_API void lua_gettable (lua_State *L, int idx) {
LUA_API void lua_getfield (lua_State *L, int idx, const char *k) { LUA_API void lua_getfield (lua_State *L, int idx, const char *k) {
StkId t;
TValue key;
lua_lock(L); lua_lock(L);
auxgetstr(L, index2adr(L, idx), k); t = index2adr(L, idx);
api_checkvalidindex(L, t);
setsvalue(L, &key, luaS_new(L, k));
luaV_gettable(L, t, &key, L->top);
api_incr_top(L);
lua_unlock(L);
} }
@@ -641,25 +631,6 @@ LUA_API void lua_getfenv (lua_State *L, int idx) {
*/ */
static void auxsetstr (lua_State *L, TValue *t, const char *k) {
TValue key;
TValue *slot;
TString *str = luaS_new(L, k);
api_checknelems(L, 1);
api_checkvalidindex(L, t);
if (luaV_fastset(L, t, str, slot, luaH_setstr, L->top)) {
setobj2t(L, cast(TValue *, slot), L->top - 1);
L->top--; /* pop value */
}
else {
setsvalue2s(L, &key, str);
luaV_finishset(L, t, &key, L->top - 1, slot);
L->top--; /* pop value */
}
lua_unlock(L);
}
LUA_API void lua_settable (lua_State *L, int idx) { LUA_API void lua_settable (lua_State *L, int idx) {
StkId t; StkId t;
lua_lock(L); lua_lock(L);
@@ -673,8 +644,16 @@ LUA_API void lua_settable (lua_State *L, int idx) {
LUA_API void lua_setfield (lua_State *L, int idx, const char *k) { LUA_API void lua_setfield (lua_State *L, int idx, const char *k) {
StkId t;
TValue key;
lua_lock(L); lua_lock(L);
auxsetstr(L, index2adr(L, idx), k); api_checknelems(L, 1);
t = index2adr(L, idx);
api_checkvalidindex(L, t);
setsvalue(L, &key, luaS_new(L, k));
luaV_settable(L, t, &key, L->top - 1);
L->top--; /* pop value */
lua_unlock(L);
} }
+3 -15
View File
@@ -20,7 +20,6 @@
#define lauxlib_c #define lauxlib_c
#define LUA_LIB #define LUA_LIB
#include "ldebug.h"
#include "lua.h" #include "lua.h"
#include "lauxlib.h" #include "lauxlib.h"
@@ -469,19 +468,8 @@ LUALIB_API char *luaL_prepbuffer (luaL_Buffer *B) {
LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) { LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) {
while (l) { while (l--)
size_t space = bufffree(B); luaL_addchar(B, *s++);
if (space == 0) {
luaL_prepbuffer(B);
lua_assert(bufffree(B) == LUAL_BUFFERSIZE);
space = LUAL_BUFFERSIZE;
}
if (space > l) space = l;
memcpy(B->p, s, space);
B->p += space;
s += space;
l -= space;
}
} }
@@ -698,6 +686,6 @@ static int panic (lua_State *L) {
LUALIB_API lua_State *luaL_newstate (void) { LUALIB_API lua_State *luaL_newstate (void) {
lua_State *L = lua_newstate(l_alloc, NULL); lua_State *L = lua_newstate(l_alloc, NULL);
if (l_likely(L)) lua_atpanic(L, &panic); if (L) lua_atpanic(L, &panic);
return L; return L;
} }
+12 -25
View File
@@ -626,20 +626,8 @@ static void codenot (FuncState *fs, expdesc *e) {
removevalues(fs, e->t); removevalues(fs, e->t);
} }
/*
** Check whether expression 'e' is a literal string
*/
static int isKstr (FuncState *fs, expdesc *e) {
return (e->k == VK && ttisstring(&fs->f->k[e->u.s.info]));
}
/*
** Create expression 't[k]'. 't' must have its final result already in a
** register or upvalue. Upvalues can only be indexed by literal strings.
*/
void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) { void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) {
if (t->k == VUPVAL && !isKstr(fs, k)) /* upvalue indexed by non string? */
luaK_exp2anyreg(fs, t); /* put it in a register */
t->u.s.aux = luaK_exp2RK(fs, k); t->u.s.aux = luaK_exp2RK(fs, k);
t->k = VINDEXED; t->k = VINDEXED;
} }
@@ -802,19 +790,18 @@ void luaK_posfix (FuncState *fs, BinOpr op, expdesc *e1, expdesc *e2) {
case OPR_BXOR: codearith(fs, OP_BXOR, e1, e2); break; case OPR_BXOR: codearith(fs, OP_BXOR, e1, e2); break;
case OPR_BSHL: codearith(fs, OP_BSHL, e1, e2); break; case OPR_BSHL: codearith(fs, OP_BSHL, e1, e2); break;
case OPR_BSHR: codearith(fs, OP_BSHR, e1, e2); break; case OPR_BSHR: codearith(fs, OP_BSHR, e1, e2); break;
case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV: case OPR_ADD: codearith(fs, OP_ADD, e1, e2); break;
case OPR_MOD: case OPR_POW: { case OPR_SUB: codearith(fs, OP_SUB, e1, e2); break;
codearith(fs, op - OPR_ADD + OP_ADD, e1, e2); case OPR_MUL: codearith(fs, OP_MUL, e1, e2); break;
break; case OPR_DIV: codearith(fs, OP_DIV, e1, e2); break;
} case OPR_MOD: codearith(fs, OP_MOD, e1, e2); break;
case OPR_EQ: case OPR_LT: case OPR_LE: { case OPR_POW: codearith(fs, OP_POW, e1, e2); break;
codecomp(fs, op - OPR_EQ + OP_EQ, 1, e1, e2); case OPR_EQ: codecomp(fs, OP_EQ, 1, e1, e2); break;
break; case OPR_NE: codecomp(fs, OP_EQ, 0, e1, e2); break;
} case OPR_LT: codecomp(fs, OP_LT, 1, e1, e2); break;
case OPR_NE: case OPR_GT: case OPR_GE: { case OPR_LE: codecomp(fs, OP_LE, 1, e1, e2); break;
codecomp(fs, op - OPR_NE + OP_EQ, 0, e1, e2); case OPR_GT: codecomp(fs, OP_LT, 0, e1, e2); break;
break; case OPR_GE: codecomp(fs, OP_LE, 0, e1, e2); break;
}
default: lua_assert(0); default: lua_assert(0);
} }
} }
+3 -3
View File
@@ -21,13 +21,13 @@
/* /*
** grep "ORDER OPR" if you change these enums (ORDER OP) ** grep "ORDER OPR" if you change these enums
*/ */
typedef enum BinOpr { typedef enum BinOpr {
OPR_ADD, OPR_SUB, OPR_MUL, OPR_DIV, OPR_MOD, OPR_POW, OPR_ADD, OPR_SUB, OPR_MUL, OPR_DIV, OPR_MOD, OPR_POW,
OPR_CONCAT, OPR_CONCAT,
OPR_EQ, OPR_LT, OPR_LE, OPR_NE, OPR_EQ,
OPR_NE, OPR_GT, OPR_GE, OPR_LT, OPR_LE, OPR_GT, OPR_GE,
OPR_AND, OPR_OR, OPR_AND, OPR_OR,
OPR_BAND, OPR_BOR, OPR_BXOR, OPR_BAND, OPR_BOR, OPR_BXOR,
OPR_BSHL, OPR_BSHR, OPR_BSHL, OPR_BSHR,
+5 -28
View File
@@ -542,39 +542,16 @@ static const char *getobjname (lua_State *L, CallInfo *ci, int stackpos,
static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) { static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) {
TMS tm = 0;
Instruction i; Instruction i;
if ((isLua(ci) && ci->tailcalls > 0) || !isLua(ci - 1)) if ((isLua(ci) && ci->tailcalls > 0) || !isLua(ci - 1))
return NULL; /* calling function is not Lua (or is unknown) */ return NULL; /* calling function is not Lua (or is unknown) */
ci--; /* calling function */ ci--; /* calling function */
i = ci_func(ci)->l.p->code[currentpc(L, ci)]; i = ci_func(ci)->l.p->code[currentpc(L, ci)];
switch (GET_OPCODE(i)) { if (GET_OPCODE(i) == OP_CALL || GET_OPCODE(i) == OP_TAILCALL ||
case OP_CALL: GET_OPCODE(i) == OP_TFORLOOP)
case OP_TAILCALL: return getobjname(L, ci, GETARG_A(i), name);
case OP_TFORLOOP: else
return getobjname(L, ci, GETARG_A(i), name); return NULL; /* no useful name can be found */
case OP_GETGLOBAL:
case OP_SELF:
case OP_GETTABLE: tm = TM_INDEX; break;
case OP_SETGLOBAL:
case OP_SETTABLE: tm = TM_NEWINDEX; break;
case OP_EQ: tm = TM_EQ; break;
case OP_ADD: tm = TM_ADD; break;
case OP_SUB: tm = TM_SUB; break;
case OP_MUL: tm = TM_MUL; break;
case OP_DIV: tm = TM_DIV; break;
case OP_MOD: tm = TM_MOD; break;
case OP_POW: tm = TM_POW; break;
case OP_UNM: tm = TM_UNM; break;
case OP_LEN: tm = TM_LEN; break;
case OP_LT: tm = TM_LT; break;
case OP_LE: tm = TM_LE; break;
case OP_CONCAT: tm = TM_CONCAT; break;
default:
return NULL; /* else no useful name can be found */
}
*name = getstr(G(L)->tmname[tm]);
return "metamethod";
} }
+2 -2
View File
@@ -164,7 +164,7 @@ void luaD_reallocCI (lua_State *L, int newsize) {
void luaD_growstack (lua_State *L, int n) { void luaD_growstack (lua_State *L, int n) {
if (n <= L->stacksize) /* double size is enough? */ if (l_likely(n <= L->stacksize)) /* double size is enough? */
luaD_reallocstack(L, 2*L->stacksize); luaD_reallocstack(L, 2*L->stacksize);
else else
luaD_reallocstack(L, L->stacksize + n); luaD_reallocstack(L, L->stacksize + n);
@@ -318,7 +318,7 @@ int luaD_precall (lua_State *L, StkId func, int nresults) {
ci->top = L->top + LUA_MINSTACK; ci->top = L->top + LUA_MINSTACK;
lua_assert(ci->top <= L->stack_last); lua_assert(ci->top <= L->stack_last);
ci->nresults = nresults; ci->nresults = nresults;
if (l_unlikely(L->hookmask & LUA_MASKCALL)) if (L->hookmask & LUA_MASKCALL)
luaD_callhook(L, LUA_HOOKCALL, -1); luaD_callhook(L, LUA_HOOKCALL, -1);
lua_unlock(L); lua_unlock(L);
n = (*curr_func(L)->c.f)(L); /* do the actual call */ n = (*curr_func(L)->c.f)(L); /* do the actual call */
+9 -10
View File
@@ -356,21 +356,20 @@ static int read_line (lua_State *L, FILE *f) {
static int read_chars (lua_State *L, FILE *f, size_t n) { static int read_chars (lua_State *L, FILE *f, size_t n) {
size_t tbr = n; /* number of chars to be read */ size_t rlen; /* how much to read */
size_t rlen; /* how much to read in each cycle */ size_t nr; /* number of chars actually read */
size_t nr; /* number of chars actually read in each cycle */
luaL_Buffer b; luaL_Buffer b;
luaL_buffinit(L, &b); luaL_buffinit(L, &b);
rlen = LUAL_BUFFERSIZE; /* try to read that much each time */ rlen = LUAL_BUFFERSIZE; /* try to read that much each time */
do { do {
char *p = luaL_prepbuffer(&b); char *p = luaL_prepbuffer(&b);
if (rlen > tbr) rlen = tbr; /* cannot read more than asked */ if (rlen > n) rlen = n; /* cannot read more than asked */
nr = fread(p, sizeof(char), rlen, f); nr = fread(p, sizeof(char), rlen, f);
luaL_addsize(&b, nr); luaL_addsize(&b, nr);
tbr -= nr; /* still have to read 'tbr' chars */ n -= nr; /* still have to read `n' chars */
} while (tbr > 0 && nr == rlen); /* until end of count or eof */ } while (n > 0 && nr == rlen); /* until end of count or eof */
luaL_pushresult(&b); /* close buffer */ luaL_pushresult(&b); /* close buffer */
return (tbr == 0 || tbr < n); /* true iff read something */ return (n == 0 || lua_objlen(L, -1) > 0);
} }
@@ -433,13 +432,13 @@ static int f_read (lua_State *L) {
static int io_readline (lua_State *L) { static int io_readline (lua_State *L) {
FILE *f = *(FILE **)lua_touserdata(L, lua_upvalueindex(1)); FILE *f = *(FILE **)lua_touserdata(L, lua_upvalueindex(1));
int success; int sucess;
if (f == NULL) /* file is already closed? */ if (f == NULL) /* file is already closed? */
luaL_error(L, "file is already closed"); luaL_error(L, "file is already closed");
success = read_line(L, f); sucess = read_line(L, f);
if (ferror(f)) if (ferror(f))
return luaL_error(L, "%s", strerror(errno)); return luaL_error(L, "%s", strerror(errno));
if (success) return 1; if (sucess) return 1;
else { /* EOF */ else { /* EOF */
if (lua_toboolean(L, lua_upvalueindex(2))) { /* generator created file? */ if (lua_toboolean(L, lua_upvalueindex(2))) { /* generator created file? */
lua_settop(L, 0); lua_settop(L, 0);
-2
View File
@@ -232,8 +232,6 @@ OP_VARARG/* A B R(A), R(A+1), ..., R(A+B-1) = vararg */
(*) In OP_SETLIST, if (B == 0) then B = `top'; (*) In OP_SETLIST, if (B == 0) then B = `top';
if (C == 0) then next `instruction' is real C if (C == 0) then next `instruction' is real C
(*) In OP_SELF, the index must be a string.
(*) For comparisons, A specifies what condition the test should accept (*) For comparisons, A specifies what condition the test should accept
(true or false). (true or false).
+4 -4
View File
@@ -881,10 +881,10 @@ static const struct {
lu_byte right; /* right priority */ lu_byte right; /* right priority */
} priority[] = { /* ORDER OPR */ } priority[] = { /* ORDER OPR */
{6, 6}, {6, 6}, {7, 7}, {7, 7}, {7, 7}, /* `+' `-' `/' `%' */ {6, 6}, {6, 6}, {7, 7}, {7, 7}, {7, 7}, /* `+' `-' `/' `%' */
{10, 9}, {5, 4}, /* ^, .. (right associative) */ {10, 9}, {5, 4}, /* power and concat (right associative) */
{3, 3}, {3, 3}, {3, 3}, /* ==, <, <= */ {3, 3}, {3, 3}, /* equality and inequality */
{3, 3}, {3, 3}, {3, 3}, /* ~=, >, >= */ {3, 3}, {3, 3}, {3, 3}, {3, 3}, /* order */
{2, 2}, {1, 1} /* and, or */ {2, 2}, {1, 1} /* logical (and/or) */
,{6, 6}, {6, 6}, {6, 6}, /* bit-wise (band/bor/bxor) */ ,{6, 6}, {6, 6}, {6, 6}, /* bit-wise (band/bor/bxor) */
{7, 7}, {7, 7} /* shl/shr */ {7, 7}, {7, 7} /* shl/shr */
}; };
+4 -58
View File
@@ -51,7 +51,7 @@ static TString *newlstr (lua_State *L, const char *str, size_t l,
unsigned int h) { unsigned int h) {
TString *ts; TString *ts;
stringtable *tb; stringtable *tb;
if (l_unlikely(l+1 > (MAX_SIZET - sizeof(TString))/sizeof(char))) if (l+1 > (MAX_SIZET - sizeof(TString))/sizeof(char))
luaM_toobig(L); luaM_toobig(L);
ts = cast(TString *, luaM_malloc(L, (l+1)*sizeof(char)+sizeof(TString))); ts = cast(TString *, luaM_malloc(L, (l+1)*sizeof(char)+sizeof(TString)));
ts->tsv.len = l; ts->tsv.len = l;
@@ -72,72 +72,18 @@ static TString *newlstr (lua_State *L, const char *str, size_t l,
} }
// string hash taken from luaJIT TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
GCObject *o;
/* Unaligned load of uint32_t. */
static inline __attribute__((always_inline)) uint32_t getu32(const void* ptr)
{
uint32_t result;
memcpy(&result, ptr, 4);
return result;
}
// smol macro to look a little less messy lul
#define getu8(p) *cast(const uint8_t *, p)
/* Keyed sparse ARX string hash. Constant time. */
static unsigned hash_sparse(const char *str, size_t len)
{
/* Constants taken from lookup3 hash by Bob Jenkins. */
unsigned int a, b, h = cast(unsigned int, len);
#define rol(x, n) (((x)<<(n)) | ((x)>>(-cast(int, n)&(8*sizeof(x)-1))))
if (len >= 4) { /* Caveat: unaligned access! */
a = getu32(str);
h ^= getu32(str+len-4);
b = getu32(str+(len>>1)-2);
h ^= b; h -= rol(b, 14);
b += getu32(str+(len>>2)-1);
} else if (len > 0) {
a = getu8(str);
h ^= getu8(str+len-1);
b = getu8(str+(len>>1));
h ^= b; h -= rol(b, 14);
} else {
return 0;
}
a ^= h; a -= rol(h, 11);
b ^= a; b -= rol(a, 25);
h ^= b; h -= rol(b, 16);
#undef rol
return h;
}
#undef getu8
static inline __attribute__((always_inline)) unsigned luaS_hash (const char *str, size_t l) {
#if 0
unsigned int h = cast(unsigned int, l); /* seed */ unsigned int h = cast(unsigned int, l); /* seed */
size_t step = (l>>5)+1; /* if string is too long, don't hash all its chars */ size_t step = (l>>5)+1; /* if string is too long, don't hash all its chars */
size_t l1; size_t l1;
for (l1=l; l1>=step; l1-=step) /* compute hash */ for (l1=l; l1>=step; l1-=step) /* compute hash */
h = h ^ ((h<<5)+(h>>2)+cast(unsigned char, str[l1-1])); h = h ^ ((h<<5)+(h>>2)+cast(unsigned char, str[l1-1]));
return h;
#else
return hash_sparse(str, l);
#endif
}
TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
GCObject *o;
unsigned int h = luaS_hash(str, l);
for (o = G(L)->strt.hash[lmod(h, G(L)->strt.size)]; for (o = G(L)->strt.hash[lmod(h, G(L)->strt.size)];
o != NULL; o != NULL;
o = o->gch.next) { o = o->gch.next) {
TString *ts = rawgco2ts(o); TString *ts = rawgco2ts(o);
if (ts->tsv.hash == h && if (l_unlikely(ts->tsv.len == l && (memcmp(str, getstr(ts), l) == 0))) {
ts->tsv.len == l &&
(memcmp(str, getstr(ts), l) == 0)) {
/* string may be dead */ /* string may be dead */
if (isdead(G(L), o)) changewhite(o); if (isdead(G(L), o)) changewhite(o);
return ts; return ts;
+1 -1
View File
@@ -527,7 +527,7 @@ static int str_find_aux (lua_State *L, int find) {
if (find) { if (find) {
lua_pushinteger(L, s1-s+1); /* start */ lua_pushinteger(L, s1-s+1); /* start */
lua_pushinteger(L, res-s); /* end */ lua_pushinteger(L, res-s); /* end */
return push_captures(&ms, NULL, NULL) + 2; return push_captures(&ms, NULL, 0) + 2;
} }
else else
return push_captures(&ms, s1, res); return push_captures(&ms, s1, res);
-7
View File
@@ -81,7 +81,6 @@ static /*const*/ Node dummynode_ = {
/* /*
** hash for lua_Numbers ** hash for lua_Numbers
*/ */
#if 0
static Node *hashnum (const Table *t, lua_Number n) { static Node *hashnum (const Table *t, lua_Number n) {
unsigned int a[numints]; unsigned int a[numints];
int i; int i;
@@ -91,12 +90,6 @@ static Node *hashnum (const Table *t, lua_Number n) {
for (i = 1; i < numints; i++) a[0] += a[i]; for (i = 1; i < numints; i++) a[0] += a[i];
return hashmod(t, a[0]); return hashmod(t, a[0]);
} }
#else
// our lua_Number is just typedef´d int32 so no need to do any of the above
static inline Node *hashnum (const Table *t, lua_Number n) {
return hashmod(t, cast(unsigned int, n));
}
#endif
+3 -3
View File
@@ -772,10 +772,10 @@ union luai_Cast { double l_d; long l_l; };
#include <stdio.h> #include <stdio.h>
#if defined(__GNUC__) #if defined(__GNUC__)
#define l_likely(x) (__builtin_expect(!!(x), 1)) #define l_likely(x) (__builtin_expect(((x) != 0), 1))
#define l_unlikely(x) (__builtin_expect(!!(x), 0)) #define l_unlikely(x) (__builtin_expect(((x) != 0), 0))
#else #else
#define l_likely(x) (x) #define l_likely(x) (x)
#define l_unlikely(x) (x) #define l_unlikely(x) (x)
#endif #endif
+51 -135
View File
@@ -28,7 +28,7 @@
/* limit for table tag-method chains (to avoid infinite loops) */ /* limit for table tag-method chains (to avoid loops) */
#define MAXTAGLOOP 100 #define MAXTAGLOOP 100
@@ -105,88 +105,57 @@ static void callTM (lua_State *L, const TValue *f, const TValue *p1,
} }
/* void luaV_gettable (lua_State *L, TValue *t, TValue *key, StkId val) {
** Finish the table access 'val = t[key]'. int loop;
** if 'slot' is NULL, 't' is not a table; otherwise, 'slot' points to
** t[k] entry (which must be nil).
*/
void luaV_finishget (lua_State *L, TValue *t, TValue *key, StkId val,
TValue *slot) {
int loop; /* counter to avoid infinite loops */
TValue *tm; /* metamethod */
for (loop = 0; loop < MAXTAGLOOP; loop++) { for (loop = 0; loop < MAXTAGLOOP; loop++) {
if (slot == NULL) { /* 't' is not a table? */ TValue *tm;
lua_assert(!ttistable(t)); if (ttistable(t)) { /* `t' is a table? */
tm = luaT_gettmbyobj(L, t, TM_INDEX); Table *h = hvalue(t);
if (l_unlikely(ttisnil(tm))) const TValue *res = luaH_get(h, key); /* do a primitive get */
luaG_typeerror(L, t, "index"); /* no metamethod */ if (!ttisnil(res) || /* result is no nil? */
/* else will try the metamethod */ (tm = fasttm(L, h->metatable, TM_INDEX)) == NULL) { /* or no TM? */
} setobj2s(L, val, res);
else { /* 't' is a table */
lua_assert(ttisnil(slot));
tm = fasttm(L, hvalue(t)->metatable, TM_INDEX); /* table's metamethod */
if (tm == NULL) { /* no metamethod? */
setnilvalue(val); /* result is nil */
return; return;
} }
/* else will try the metamethod */ /* else will try the tag method */
} }
if (ttisfunction(tm)) { /* is metamethod a function? */ else if (l_unlikely(ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX))))
callTMres(L, val, tm, t, key); /* call it */ luaG_typeerror(L, t, "index");
if (ttisfunction(tm)) {
callTMres(L, val, tm, t, key);
return; return;
} }
t = tm; /* else try to access 'tm[key]' */ t = tm; /* else repeat with `tm' */
if (luaV_fastget(L,t,key,slot,luaH_get)) { /* fast track? */
setobj2s(L, val, slot); /* done */
return;
}
/* else repeat (tail call 'luaV_finishget') */
} }
luaG_runerror(L, "'__index' chain too long; possible loop"); luaG_runerror(L, "loop in gettable");
} }
/* void luaV_settable (lua_State *L, TValue *t, TValue *key, StkId val) {
** Finish a table assignment 't[key] = val'. int loop;
** If 'slot' is NULL, 't' is not a table. Otherwise, 'slot' points
** to the entry 't[key]', or to 'luaO_nilobject' if there is no such
** entry. (The value at 'slot' must be nil, otherwise 'luaV_fastset'
** would have done the job.)
*/
void luaV_finishset (lua_State *L, TValue *t, TValue *key,
StkId val, TValue *slot) {
int loop; /* counter to avoid infinite loops */
for (loop = 0; loop < MAXTAGLOOP; loop++) { for (loop = 0; loop < MAXTAGLOOP; loop++) {
TValue *tm; TValue *tm = NULL;
if (slot != NULL) { if (ttistable(t)) { /* `t' is a table? */
lua_assert(ttistable(t) && ttisnil(slot));
Table *h = hvalue(t); Table *h = hvalue(t);
/* must check the metamethod */ TValue *oldval = luaH_set(L, h, key); /* do a primitive set */
/* slot is nil=> look for newindex, slot is not nil => look for usedindex */ /* oldval is nil=> look for newindex, oldval is not nil => look for usedindex */
if (!((ttisnil(slot) && ((tm = fasttm(L, h->metatable, TM_NEWINDEX)) != NULL)) || if (!((ttisnil(oldval) && ((tm = fasttm(L, h->metatable, TM_NEWINDEX)) != NULL)) ||
((!ttisnil(slot)) && ((tm = fasttm(L, h->metatable, TM_USEDINDEX)) != NULL)))) { ((!ttisnil(oldval)) && ((tm = fasttm(L, h->metatable, TM_USEDINDEX)) != NULL)))) {
/* no metamethod and (now) there is an entry with given key */ setobj2t(L, oldval, val);
setobj2t(L, cast(TValue *, slot), val);
luaC_barriert(L, h, val); luaC_barriert(L, h, val);
return; return;
} }
/* else will try the metamethod */ /* else will try the tag method */
} }
else { /* not a table; check metamethod */ else if (l_unlikely(ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX))))
if (l_unlikely(ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX)))) luaG_typeerror(L, t, "index");
luaG_typeerror(L, t, "index");
}
/* try the metamethod */
if (ttisfunction(tm)) { if (ttisfunction(tm)) {
callTM(L, tm, t, key, val); callTM(L, tm, t, key, val);
return; return;
} }
t = tm; /* else repeat assignment over 'tm' */ t = tm; /* else repeat with `tm' */
if (luaV_fastset(L, t, key, slot, luaH_set, val))
return; /* done */
/* else loop */
} }
luaG_runerror(L, "settable chain too long; possible loop"); luaG_runerror(L, "loop in settable");
} }
@@ -397,7 +366,6 @@ static void Arith (lua_State *L, StkId ra, TValue *rb,
#define arith_op(op,tm) { \ #define arith_op(op,tm) { \
StkId ra = RA(i); \
TValue *rb = RKB(i); \ TValue *rb = RKB(i); \
TValue *rc = RKC(i); \ TValue *rc = RKC(i); \
if (ttisnumber(rb) && ttisnumber(rc)) { \ if (ttisnumber(rb) && ttisnumber(rc)) { \
@@ -409,21 +377,6 @@ static void Arith (lua_State *L, StkId ra, TValue *rb,
} }
/*
** copy of 'luaV_gettable', but protecting call to potential metamethod
** (which can reallocate the stack)
*/
#define gettableProtected(L,t,k,v) { TValue *slot; \
if (luaV_fastget(L,t,k,slot,luaH_get)) { setobj2s(L, v, slot); } \
else Protect(luaV_finishget(L,t,k,v,slot)); }
/* same for 'luaV_settable' */
#define settableProtected(L,t,k,v) { TValue *slot; \
if (!luaV_fastset(L,t,k,slot,luaH_set,v)) \
Protect(luaV_finishset(L,t,k,v,slot)); }
void luaV_execute (lua_State *L, int nexeccalls) { void luaV_execute (lua_State *L, int nexeccalls) {
LClosure *cl; LClosure *cl;
@@ -433,12 +386,13 @@ void luaV_execute (lua_State *L, int nexeccalls) {
reentry: /* entry point */ reentry: /* entry point */
lua_assert(isLua(L->ci)); lua_assert(isLua(L->ci));
pc = L->savedpc; pc = L->savedpc;
cl = &clvalue(L->ci->func)->l; /* local reference to function's closure */ cl = &clvalue(L->ci->func)->l;
k = cl->p->k; /* local reference to function's constant table */ base = L->base;
base = L->base; /* local copy of function's base */ k = cl->p->k;
/* main loop of interpreter */ /* main loop of interpreter */
for (;;) { for (;;) {
const Instruction i = *pc++; const Instruction i = *pc++;
StkId ra;
if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) && if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) &&
(--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) { (--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) {
traceexec(L, pc); traceexec(L, pc);
@@ -448,28 +402,26 @@ void luaV_execute (lua_State *L, int nexeccalls) {
} }
base = L->base; base = L->base;
} }
/* warning!! several calls may realloc the stack and invalidate `ra' */
ra = RA(i);
lua_assert(base == L->base && L->base == L->ci->base); lua_assert(base == L->base && L->base == L->ci->base);
lua_assert(base <= L->top && L->top <= L->stack + L->stacksize); lua_assert(base <= L->top && L->top <= L->stack + L->stacksize);
lua_assert(L->top == L->ci->top || luaG_checkopenop(i)); lua_assert(L->top == L->ci->top || luaG_checkopenop(i));
switch (GET_OPCODE(i)) { switch (GET_OPCODE(i)) {
case OP_MOVE: { case OP_MOVE: {
StkId ra = RA(i);
setobjs2s(L, ra, RB(i)); setobjs2s(L, ra, RB(i));
continue; continue;
} }
case OP_LOADK: { case OP_LOADK: {
StkId ra = RA(i);
setobj2s(L, ra, KBx(i)); setobj2s(L, ra, KBx(i));
continue; continue;
} }
case OP_LOADBOOL: { case OP_LOADBOOL: {
StkId ra = RA(i);
setbvalue(ra, GETARG_B(i)); setbvalue(ra, GETARG_B(i));
if (GETARG_C(i)) pc++; /* skip next instruction (if C) */ if (GETARG_C(i)) pc++; /* skip next instruction (if C) */
continue; continue;
} }
case OP_LOADNIL: { case OP_LOADNIL: {
StkId ra = RA(i);
TValue *rb = RB(i); TValue *rb = RB(i);
do { do {
setnilvalue(rb--); setnilvalue(rb--);
@@ -477,13 +429,11 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue; continue;
} }
case OP_GETUPVAL: { case OP_GETUPVAL: {
StkId ra = RA(i);
int b = GETARG_B(i); int b = GETARG_B(i);
setobj2s(L, ra, cl->upvals[b]->v); setobj2s(L, ra, cl->upvals[b]->v);
continue; continue;
} }
case OP_GETGLOBAL: { case OP_GETGLOBAL: {
StkId ra = RA(i);
TValue g; TValue g;
TValue *rb = KBx(i); TValue *rb = KBx(i);
sethvalue(L, &g, cl->env); sethvalue(L, &g, cl->env);
@@ -492,14 +442,10 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue; continue;
} }
case OP_GETTABLE: { case OP_GETTABLE: {
StkId ra = RA(i); Protect(luaV_gettable(L, RB(i), RKC(i), ra));
StkId rb = RB(i);
TValue *rc = RKC(i);
gettableProtected(L, rb, rc, ra);
continue; continue;
} }
case OP_SETGLOBAL: { case OP_SETGLOBAL: {
StkId ra = RA(i);
TValue g; TValue g;
sethvalue(L, &g, cl->env); sethvalue(L, &g, cl->env);
lua_assert(ttisstring(KBx(i))); lua_assert(ttisstring(KBx(i)));
@@ -507,21 +453,16 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue; continue;
} }
case OP_SETUPVAL: { case OP_SETUPVAL: {
StkId ra = RA(i);
UpVal *uv = cl->upvals[GETARG_B(i)]; UpVal *uv = cl->upvals[GETARG_B(i)];
setobj(L, uv->v, ra); setobj(L, uv->v, ra);
luaC_barrier(L, uv, ra); luaC_barrier(L, uv, ra);
continue; continue;
} }
case OP_SETTABLE: { case OP_SETTABLE: {
StkId ra = RA(i); Protect(luaV_settable(L, ra, RKB(i), RKC(i)));
TValue *rb = RKB(i);
TValue *rc = RKC(i);
settableProtected(L, ra, rb, rc);
continue; continue;
} }
case OP_NEWTABLE: { case OP_NEWTABLE: {
StkId ra = RA(i);
int b = GETARG_B(i); int b = GETARG_B(i);
int c = GETARG_C(i); int c = GETARG_C(i);
sethvalue(L, ra, luaH_new(L, luaO_fb2int(b), luaO_fb2int(c))); sethvalue(L, ra, luaH_new(L, luaO_fb2int(b), luaO_fb2int(c)));
@@ -529,16 +470,9 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue; continue;
} }
case OP_SELF: { case OP_SELF: {
TValue *slot;
StkId ra = RA(i);
StkId rb = RB(i); StkId rb = RB(i);
TValue *rc = RKC(i); setobjs2s(L, ra+1, rb);
TString *key = rawtsvalue(rc); /* key must be a string */ Protect(luaV_gettable(L, rb, RKC(i), ra));
setobjs2s(L, ra + 1, rb);
if (luaV_fastget(L, rb, key, slot, luaH_getstr)) {
setobj2s(L, ra, slot);
}
else Protect(luaV_finishget(L, rb, rc, ra, slot));
continue; continue;
} }
case OP_ADD: { case OP_ADD: {
@@ -554,7 +488,6 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue; continue;
} }
case OP_DIV: { case OP_DIV: {
StkId ra = RA(i);
TValue *rb = RKB(i); TValue *rb = RKB(i);
TValue *rc = RKC(i); TValue *rc = RKC(i);
if (ttisnumber(rb) && ttisnumber(rc)) { if (ttisnumber(rb) && ttisnumber(rc)) {
@@ -570,7 +503,6 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue; continue;
} }
case OP_MOD: { case OP_MOD: {
StkId ra = RA(i);
TValue *rb = RKB(i); TValue *rb = RKB(i);
TValue *rc = RKC(i); TValue *rc = RKC(i);
if (ttisnumber(rb) && ttisnumber(rc)) { if (ttisnumber(rb) && ttisnumber(rc)) {
@@ -590,27 +522,26 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue; continue;
} }
case OP_BAND: { case OP_BAND: {
arith_op(luai_numand, TM_AND); arith_op(luai_numand, TM_AND);
continue; continue;
} }
case OP_BOR: { case OP_BOR: {
arith_op(luai_numor, TM_OR); arith_op(luai_numor, TM_OR);
continue; continue;
} }
case OP_BXOR: { case OP_BXOR: {
arith_op(luai_numxor, TM_XOR); arith_op(luai_numxor, TM_XOR);
continue; continue;
} }
case OP_BSHL: { case OP_BSHL: {
arith_op(luai_numshl, TM_SHL); arith_op(luai_numshl, TM_SHL);
continue; continue;
} }
case OP_BSHR: { case OP_BSHR: {
arith_op(luai_numshr, TM_SHR); arith_op(luai_numshr, TM_SHR);
continue; continue;
} }
case OP_BNOT: { case OP_BNOT: {
StkId ra = RA(i);
TValue *rb = RB(i); TValue *rb = RB(i);
if (ttisnumber(rb)) { if (ttisnumber(rb)) {
lua_Number nb = nvalue(rb); lua_Number nb = nvalue(rb);
@@ -622,7 +553,6 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue; continue;
} }
case OP_UNM: { case OP_UNM: {
StkId ra = RA(i);
TValue *rb = RB(i); TValue *rb = RB(i);
if (ttisnumber(rb)) { if (ttisnumber(rb)) {
lua_Number nb = nvalue(rb); lua_Number nb = nvalue(rb);
@@ -634,13 +564,11 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue; continue;
} }
case OP_NOT: { case OP_NOT: {
StkId ra = RA(i);
int res = l_isfalse(RB(i)); /* next assignment may change this value */ int res = l_isfalse(RB(i)); /* next assignment may change this value */
setbvalue(ra, res); setbvalue(ra, res);
continue; continue;
} }
case OP_LEN: { case OP_LEN: {
StkId ra = RA(i);
TValue *rb = RB(i); TValue *rb = RB(i);
switch (ttype(rb)) { switch (ttype(rb)) {
case LUA_TTABLE: { case LUA_TTABLE: {
@@ -698,14 +626,12 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue; continue;
} }
case OP_TEST: { case OP_TEST: {
StkId ra = RA(i);
if (l_isfalse(ra) != GETARG_C(i)) if (l_isfalse(ra) != GETARG_C(i))
dojump(L, pc, GETARG_sBx(*pc)); dojump(L, pc, GETARG_sBx(*pc));
pc++; pc++;
continue; continue;
} }
case OP_TESTSET: { case OP_TESTSET: {
StkId ra = RA(i);
TValue *rb = RB(i); TValue *rb = RB(i);
if (l_isfalse(rb) != GETARG_C(i)) { if (l_isfalse(rb) != GETARG_C(i)) {
setobjs2s(L, ra, rb); setobjs2s(L, ra, rb);
@@ -715,7 +641,6 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue; continue;
} }
case OP_CALL: { case OP_CALL: {
StkId ra = RA(i);
int b = GETARG_B(i); int b = GETARG_B(i);
int nresults = GETARG_C(i) - 1; int nresults = GETARG_C(i) - 1;
if (b != 0) L->top = ra+b; /* else previous instruction set top */ if (b != 0) L->top = ra+b; /* else previous instruction set top */
@@ -737,7 +662,6 @@ void luaV_execute (lua_State *L, int nexeccalls) {
} }
} }
case OP_TAILCALL: { case OP_TAILCALL: {
StkId ra = RA(i);
int b = GETARG_B(i); int b = GETARG_B(i);
if (b != 0) L->top = ra+b; /* else previous instruction set top */ if (b != 0) L->top = ra+b; /* else previous instruction set top */
L->savedpc = pc; L->savedpc = pc;
@@ -770,7 +694,6 @@ void luaV_execute (lua_State *L, int nexeccalls) {
} }
} }
case OP_RETURN: { case OP_RETURN: {
StkId ra = RA(i);
int b = GETARG_B(i); int b = GETARG_B(i);
if (b != 0) L->top = ra+b-1; if (b != 0) L->top = ra+b-1;
if (L->openupval) luaF_close(L, base); if (L->openupval) luaF_close(L, base);
@@ -786,7 +709,6 @@ void luaV_execute (lua_State *L, int nexeccalls) {
} }
} }
case OP_FORLOOP: { case OP_FORLOOP: {
StkId ra = RA(i);
lua_Number step = nvalue(ra+2); lua_Number step = nvalue(ra+2);
lua_Number idx = luai_numadd(nvalue(ra), step); /* increment index */ lua_Number idx = luai_numadd(nvalue(ra), step); /* increment index */
lua_Number limit = nvalue(ra+1); lua_Number limit = nvalue(ra+1);
@@ -799,7 +721,6 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue; continue;
} }
case OP_FORPREP: { case OP_FORPREP: {
StkId ra = RA(i);
const TValue *init = ra; const TValue *init = ra;
const TValue *plimit = ra+1; const TValue *plimit = ra+1;
const TValue *pstep = ra+2; const TValue *pstep = ra+2;
@@ -816,7 +737,6 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue; continue;
} }
case OP_TFORLOOP: { case OP_TFORLOOP: {
StkId ra = RA(i);
StkId cb = ra + 3; /* call base */ StkId cb = ra + 3; /* call base */
setobjs2s(L, cb+2, ra+2); setobjs2s(L, cb+2, ra+2);
setobjs2s(L, cb+1, ra+1); setobjs2s(L, cb+1, ra+1);
@@ -833,7 +753,6 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue; continue;
} }
case OP_SETLIST: { case OP_SETLIST: {
StkId ra = RA(i);
int n = GETARG_B(i); int n = GETARG_B(i);
int c = GETARG_C(i); int c = GETARG_C(i);
int last; int last;
@@ -856,12 +775,10 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue; continue;
} }
case OP_CLOSE: { case OP_CLOSE: {
StkId ra = RA(i);
luaF_close(L, ra); luaF_close(L, ra);
continue; continue;
} }
case OP_CLOSURE: { case OP_CLOSURE: {
StkId ra = RA(i);
Proto *p; Proto *p;
Closure *ncl; Closure *ncl;
int nup, j; int nup, j;
@@ -882,7 +799,6 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue; continue;
} }
case OP_VARARG: { case OP_VARARG: {
StkId ra = RA(i);
int b = GETARG_B(i) - 1; int b = GETARG_B(i) - 1;
int j; int j;
CallInfo *ci = L->ci; CallInfo *ci = L->ci;
+4 -52
View File
@@ -22,62 +22,14 @@
(ttype(o1) == ttype(o2) && luaV_equalval(L, o1, o2)) (ttype(o1) == ttype(o2) && luaV_equalval(L, o1, o2))
/*
** fast track for 'gettable': if 't' is a table and 't[k]' is not nil,
** return 1 with 'slot' pointing to 't[k]' (final result). Otherwise,
** return 0 (meaning it will have to check metamethod) with 'slot'
** pointing to a nil 't[k]' (if 't' is a table) or NULL (otherwise).
** 'f' is the raw get function to use.
*/
#define luaV_fastget(L,t,k,slot,f) \
(!ttistable(t) \
? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \
: (slot = f(hvalue(t), k), /* else, do raw access */ \
!ttisnil(slot))) /* result not nil? */
/*
** standard implementation for 'gettable'
*/
#define luaV_gettable(L,t,k,v) { TValue *slot; \
if (luaV_fastget(L,t,k,slot,luaH_get)) { setobj2s(L, v, slot); } \
else luaV_finishget(L,t,k,v,slot); }
/*
** Fast track for set table. If 't' is a table and 't[k]' is not nil,
** call GC barrier, do a raw 't[k]=v', and return true; otherwise,
** return false with 'slot' equal to NULL (if 't' is not a table) or
** 'nil'. (This is needed by 'luaV_finishget'.) Note that, if the macro
** returns true, there is no need to 'invalidateTMcache', because the
** call is not creating a new entry.
*/
#define luaV_fastset(L,t,k,slot,f,v) \
(!ttistable(t) \
? (slot = NULL, 0) \
: (slot = f(L, hvalue(t), k), \
ttisnil(slot) ? 0 \
: (__extension__ ({ \
if (valiswhite(v) && isblack(obj2gco(hvalue(t)))) \
luaC_barrierback(L, hvalue(t)); \
setobj2t(L, cast(TValue *,slot), v); \
1; \
}))))
#define luaV_settable(L,t,k,v) { TValue *slot; \
if (!luaV_fastset(L,t,k,slot,luaH_set,v)) \
luaV_finishset(L,t,k,v,slot); }
LUAI_FUNC int luaV_lessthan (lua_State *L, TValue *l, TValue *r); LUAI_FUNC int luaV_lessthan (lua_State *L, TValue *l, TValue *r);
LUAI_FUNC int luaV_equalval (lua_State *L, const TValue *t1, const TValue *t2); LUAI_FUNC int luaV_equalval (lua_State *L, const TValue *t1, const TValue *t2);
LUAI_FUNC const TValue *luaV_tonumber (const TValue *obj, TValue *n); LUAI_FUNC const TValue *luaV_tonumber (const TValue *obj, TValue *n);
LUAI_FUNC int luaV_tostring (lua_State *L, StkId obj); LUAI_FUNC int luaV_tostring (lua_State *L, StkId obj);
LUAI_FUNC void luaV_finishget (lua_State *L, TValue *t, TValue *key, LUAI_FUNC void luaV_gettable (lua_State *L, TValue *t, TValue *key,
StkId val, TValue *tm); StkId val);
LUAI_FUNC void luaV_finishset (lua_State *L, TValue *t, TValue *key, LUAI_FUNC void luaV_settable (lua_State *L, TValue *t, TValue *key,
StkId val, TValue *oldval); StkId val);
LUAI_FUNC void luaV_execute (lua_State *L, int nexeccalls); LUAI_FUNC void luaV_execute (lua_State *L, int nexeccalls);
LUAI_FUNC void luaV_concat (lua_State *L, int total, int last); LUAI_FUNC void luaV_concat (lua_State *L, int total, int last);
+4 -66
View File
@@ -1165,39 +1165,6 @@ void VS_Print(vsbuf_t *buf, const char *data)
// //
// ========================================================================= // =========================================================================
#define NAME cvar_map_t
#define KEY_TY const char *
#define VAL_TY consvar_t *
#define HASH_FN FNV1a_HashLowercaseString
#define CMPR_FN vt_cmpr_casestring
#include "verstable.h"
#define NAME netvar_map_t
#define KEY_TY UINT16
#define VAL_TY consvar_t *
#define HASH_FN vt_hash_integer
#define CMPR_FN vt_cmpr_integer
#include "verstable.h"
static cvar_map_t cvar_map;
static netvar_map_t netvar_map;
CONSTRUCTOR static void CV_InitMap(void)
{
// ensure the map is initialized
cvar_map_t_init(&cvar_map);
cvar_map_t_reserve(&cvar_map, 512);
netvar_map_t_init(&netvar_map);
netvar_map_t_reserve(&netvar_map, 256);
}
DESTRUCTOR static void CV_DestroyMap(void)
{
cvar_map_t_cleanup(&cvar_map);
netvar_map_t_cleanup(&netvar_map);
}
static const char *cv_null_string = ""; static const char *cv_null_string = "";
/** Searches if a variable has been registered. /** Searches if a variable has been registered.
@@ -1208,17 +1175,11 @@ static const char *cv_null_string = "";
*/ */
consvar_t *CV_FindVar(const char *name) consvar_t *CV_FindVar(const char *name)
{ {
cvar_map_t_itr it = cvar_map_t_get(&cvar_map, name);
if (!cvar_map_t_is_end(it))
return it.data->val;
// fallback linear search
/*
consvar_t *cvar; consvar_t *cvar;
for (cvar = consvar_vars; cvar; cvar = cvar->next) for (cvar = consvar_vars; cvar; cvar = cvar->next)
if (fasticmp(name, cvar->name)) if (fasticmp(name,cvar->name))
return cvar; return cvar;
*/
return NULL; return NULL;
} }
@@ -1233,7 +1194,7 @@ consvar_t *CV_FindVar(const char *name)
static inline UINT16 CV_ComputeNetid(const char *s) static inline UINT16 CV_ComputeNetid(const char *s)
{ {
UINT16 ret = 0, i = 0; UINT16 ret = 0, i = 0;
static const UINT16 premiers[16] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53}; static UINT16 premiers[16] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53};
while (*s) while (*s)
{ {
@@ -1252,17 +1213,11 @@ static inline UINT16 CV_ComputeNetid(const char *s)
*/ */
static consvar_t *CV_FindNetVar(UINT16 netid) static consvar_t *CV_FindNetVar(UINT16 netid)
{ {
netvar_map_t_itr it = netvar_map_t_get(&netvar_map, netid);
if (!netvar_map_t_is_end(it))
return it.data->val;
/*
consvar_t *cvar; consvar_t *cvar;
for (cvar = consvar_vars; cvar; cvar = cvar->next) for (cvar = consvar_vars; cvar; cvar = cvar->next)
if (cvar->netid == netid) if (cvar->netid == netid)
return cvar; return cvar;
*/
if (netid == 44542) // ouch this hack if (netid == 44542) // ouch this hack
return &cv_karteliminatelast; return &cv_karteliminatelast;
@@ -1328,11 +1283,6 @@ void CV_RegisterVar(consvar_t *variable)
// the SetValue will set this bit // the SetValue will set this bit
variable->flags &= ~CV_MODIFIED; variable->flags &= ~CV_MODIFIED;
cvar_map_t_insert(&cvar_map, variable->name, variable);
if (variable->flags & CV_NETVAR)
netvar_map_t_insert(&netvar_map, variable->netid, variable);
} }
/** Finds the string value of a console variable. /** Finds the string value of a console variable.
@@ -1638,21 +1588,9 @@ size_t CV_LoadNetVars(const UINT8 *bufstart)
// prevent "invalid command received" // prevent "invalid command received"
serverloading = true; serverloading = true;
// we can use our netvar map instead of going through all cvars each time
netvar_map_t_itr it;
for (it = netvar_map_t_first(&netvar_map);
!netvar_map_t_is_end(it);
it = netvar_map_t_next(it))
{
cvar = it.data->val;
Setvalue(cvar, cvar->defaultvalue, true);
}
/*
for (cvar = consvar_vars; cvar; cvar = cvar->next) for (cvar = consvar_vars; cvar; cvar = cvar->next)
if (cvar->flags & CV_NETVAR) if (cvar->flags & CV_NETVAR)
Setvalue(cvar, cvar->defaultvalue, true); Setvalue(cvar, cvar->defaultvalue, true);
*/
count = READUINT16(p); count = READUINT16(p);
while (count--) while (count--)
@@ -1855,7 +1793,7 @@ void CV_AddValue(consvar_t *var, INT32 increment)
if (newvalue == oldvalue) if (newvalue == oldvalue)
break; // don't loop forever if there's none of a certain gametype break; // don't loop forever if there's none of a certain gametype
if (newvalue >= 0 && newvalue < NUMMAPS && !mapheaderinfo[newvalue]) if (newvalue >= 0 && !mapheaderinfo[newvalue])
continue; // Don't allocate the header. That just makes memory usage skyrocket. continue; // Don't allocate the header. That just makes memory usage skyrocket.
} while (!M_CanShowLevelInList(newvalue, gt)); } while (!M_CanShowLevelInList(newvalue, gt));
+71 -33
View File
@@ -46,16 +46,16 @@
#ifdef HAVE_THREADS #ifdef HAVE_THREADS
I_mutex con_mutex; I_mutex con_mutex;
// I_In_Exiting_Signal_Handler is an evil hack // g_in_exiting_signal_handler is an evil hack
// to avoid infinite SIGABRT recursion in the signal handler // to avoid infinite SIGABRT recursion in the signal handler
// due to poisoned locks or mach-o kernel not supporting locks in signals // due to poisoned locks or mach-o kernel not supporting locks in signals
// or something like that. idk // or something like that. idk
# define Lock_state() if (!I_In_Exiting_Signal_Handler()) { I_lock_mutex(&con_mutex); } # define Lock_state() if (!g_in_exiting_signal_handler) { I_lock_mutex(&con_mutex); }
# define Unlock_state() if (!I_In_Exiting_Signal_Handler()) { I_unlock_mutex(con_mutex); } # define Unlock_state() if (!g_in_exiting_signal_handler) { I_unlock_mutex(con_mutex); }
#else /*HAVE_THREADS*/ #else/*HAVE_THREADS*/
# define Lock_state() # define Lock_state()
# define Unlock_state() # define Unlock_state()
#endif /*HAVE_THREADS*/ #endif/*HAVE_THREADS*/
static boolean con_started = false; // console has been initialised static boolean con_started = false; // console has been initialised
boolean con_startup = false; // true at game startup, screen need refreshing boolean con_startup = false; // true at game startup, screen need refreshing
@@ -640,25 +640,65 @@ INT32 CON_ShiftChar(INT32 ch)
if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'))
{ {
if (shiftdown ^ capslock) if (cv_keyboardlayout.value == 3)
ch = shiftxform[ch];
}
else // if we're holding shift we should still shift non letter symbols
{
if (shiftdown)
ch = shiftxform[ch];
else if (cv_keyboardlayout.value == 3)
{ {
if (altdown & 0x2) if (shiftdown ^ capslock)
ch = shiftxform[ch];
else if (altdown & 0x2)
ch = french_altgrxform[ch]; ch = french_altgrxform[ch];
else else
ch = HU_FallBackFrSpecialLetter(ch); ch = HU_FallBackFrSpecialLetter(ch);
} }
else
{
if (shiftdown ^ capslock)
ch = shiftxform[ch];
}
}
else // if we're holding shift we should still shift non letter symbols
{
if (cv_keyboardlayout.value == 3)
{
if (shiftdown)
ch = shiftxform[ch];
else if (altdown & 0x2)
ch = french_altgrxform[ch];
else
ch = HU_FallBackFrSpecialLetter(ch);
}
else
{
if (shiftdown)
ch = shiftxform[ch];
}
} }
return ch; return ch;
} }
INT32 CON_ShitAndAltGrChar(INT32 ch)
{
if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'))
{
if (shiftdown ^ capslock)
ch = shiftxform[ch];
}
else // if we're holding shift we should still shift non letter symbols
{
if (shiftdown)
ch = shiftxform[ch];
else if (altdown & 0x2)
{
ch = french_altgrxform[ch];
}
else
{
ch = HU_FallBackFrSpecialLetter(ch);
}
}
return ch;
}
// Clear time of console heads up messages // Clear time of console heads up messages
// //
@@ -852,7 +892,7 @@ boolean CON_Responder(event_t *ev)
return true; return true;
// ctrl modifier -- changes behavior, adds shortcuts // ctrl modifier -- changes behavior, adds shortcuts
if (ctrldown && (cv_keyboardlayout.value != 3 || !altdown)) if ((cv_keyboardlayout.value != 3 && ctrldown) || (cv_keyboardlayout.value == 3 && ctrldown && !altdown))
{ {
// show all cvars/commands that match what we have inputted // show all cvars/commands that match what we have inputted
if (key == KEY_TAB) if (key == KEY_TAB)
@@ -1182,10 +1222,19 @@ void CON_LogMessage(const char *msg)
// Console print! Wahooo! Lots o fun! // Console print! Wahooo! Lots o fun!
// //
static inline void CONS_PrintMsg(char *txt) void CONS_Printf(const char *fmt, ...)
{ {
va_list argptr;
static char *txt = NULL;
boolean startup; boolean startup;
if (txt == NULL)
txt = malloc(8192);
va_start(argptr, fmt);
vsnprintf(txt, 8192, fmt, argptr);
va_end(argptr);
// echo console prints to log file // echo console prints to log file
DEBFILE(txt); DEBFILE(txt);
@@ -1211,21 +1260,6 @@ static inline void CONS_PrintMsg(char *txt)
} }
} }
void CONS_Printf(const char *fmt, ...)
{
va_list argptr;
static char *txt = NULL;
if (txt == NULL)
txt = malloc(8192);
va_start(argptr, fmt);
vsnprintf(txt, 8192, fmt, argptr);
va_end(argptr);
CONS_PrintMsg(txt);
}
void CONS_Alert(alerttype_t level, const char *fmt, ...) void CONS_Alert(alerttype_t level, const char *fmt, ...)
{ {
va_list argptr; va_list argptr;
@@ -1254,7 +1288,9 @@ void CONS_Alert(alerttype_t level, const char *fmt, ...)
break; break;
} }
CONS_PrintMsg(txt); // I am lazy and I feel like just letting CONS_Printf take care of things.
// Is that okay?
CONS_Printf("%s", txt);
} }
void CONS_Debug(INT32 debugflags, const char *fmt, ...) void CONS_Debug(INT32 debugflags, const char *fmt, ...)
@@ -1272,9 +1308,11 @@ void CONS_Debug(INT32 debugflags, const char *fmt, ...)
vsnprintf(txt, 8192, fmt, argptr); vsnprintf(txt, 8192, fmt, argptr);
va_end(argptr); va_end(argptr);
CONS_PrintMsg(txt); // Again I am lazy, oh well
CONS_Printf("%s", txt);
} }
// Print an error message, and wait for ENTER key to continue. // Print an error message, and wait for ENTER key to continue.
// To make sure the user has seen the message // To make sure the user has seen the message
// //
+1 -8
View File
@@ -13,10 +13,6 @@
#ifndef __CONSOLE__ #ifndef __CONSOLE__
#define __CONSOLE__ #define __CONSOLE__
#ifdef __cplusplus
extern "C" {
#endif
#include "d_event.h" #include "d_event.h"
#include "command.h" #include "command.h"
#include "i_threads.h" #include "i_threads.h"
@@ -49,6 +45,7 @@ extern UINT8 *yellowmap, *purplemap, *greenmap, *bluemap, *graymap, *redmap, *or
extern UINT8 *consolebgmap; extern UINT8 *consolebgmap;
INT32 CON_ShiftChar(INT32 ch); INT32 CON_ShiftChar(INT32 ch);
INT32 CON_ShitAndAltGrChar(INT32 ch);
void CON_SetupBackColormap(void); void CON_SetupBackColormap(void);
void CON_ClearHUD(void); // clear heads up messages void CON_ClearHUD(void); // clear heads up messages
@@ -66,8 +63,4 @@ boolean CON_Ready(void);
void CON_LogMessage(const char *msg); void CON_LogMessage(const char *msg);
#ifdef __cplusplus
} // extern "C"
#endif
#endif #endif
+383 -522
View File
File diff suppressed because it is too large. Load diff
+3 -7
View File
@@ -600,8 +600,6 @@ extern consvar_t cv_discordinvites;
extern consvar_t cv_serverinfoscreen; extern consvar_t cv_serverinfoscreen;
extern consvar_t cv_serveraddoninfo;
// Used in d_net, the only dependence // Used in d_net, the only dependence
//tic_t ExpandTics(INT32 low, tic_t basetic); //tic_t ExpandTics(INT32 low, tic_t basetic);
void D_ClientServerInit(void); void D_ClientServerInit(void);
@@ -656,17 +654,15 @@ void D_ResetTiccmds(void);
tic_t GetLag(INT32 node); tic_t GetLag(INT32 node);
extern boolean hu_resynching; extern UINT8 hu_resynching;
#ifdef SATURNPAK #ifdef SATURNPAK
extern boolean hu_redownloadinggamestate; extern UINT8 hu_redownloadinggamestate;
#endif #endif
extern boolean hu_stopped; // kart, true when the game is stopped for players due to a disconnecting or connecting player extern boolean hu_stopped; // kart, true when the game is stopped for players due to a disconnecting or connecting player
#define SAVEGAMESIZE (768*1024)
typedef struct rewind_s typedef struct rewind_s
{ {
UINT8 savebuffer[SAVEGAMESIZE]; UINT8 savebuffer[(768*1024)];
tic_t leveltime; tic_t leveltime;
size_t demopos; size_t demopos;
+79 -126
View File
@@ -130,8 +130,8 @@ static size_t startuppwadcount = 0;
// autoloading // autoloading
static char *autoloadwadfiles[MAX_WADFILES]; static char *autoloadwadfiles[MAX_WADFILES];
static char *autoloadwadfilespost[MAX_WADFILES]; static char *autoloadwadfilespost[MAX_WADFILES];
static size_t autoloadwadcount = 0; static size_t autoloadcount = 0;
static size_t postloadwadcount = 0; static size_t postloadcount = 0;
// //
boolean devparm = false; // started game with -devparm boolean devparm = false; // started game with -devparm
@@ -274,17 +274,21 @@ static void D_Renderview(void)
R_ApplyLevelInterpolators(R_GetTimeFrac(RTF_LEVEL)); R_ApplyLevelInterpolators(R_GetTimeFrac(RTF_LEVEL));
if (rendermode == render_soft && cv_homremoval.value) if (rendermode == render_soft)
{ {
if (cv_homremoval.value == 1) // if this is display player 1
if (cv_homremoval.value)
{ {
// Clear the software screen buffer to remove HOM if (cv_homremoval.value == 1)
memset(vid.screens[0], 31, vid.width * vid.height); {
} // Clear the software screen buffer to remove HOM
else if (cv_homremoval.value == 2) memset(vid.screens[0], 31, vid.width * vid.height);
{ }
//'development' HOM removal -- makes it blindingly obvious if HOM is spotted. else if (cv_homremoval.value == 2)
memset(vid.screens[0], 32+(timeinmap&15), vid.width * vid.height); {
//'development' HOM removal -- makes it blindingly obvious if HOM is spotted.
memset(vid.screens[0], 32+(timeinmap&15), vid.width * vid.height);
}
} }
} }
@@ -318,6 +322,7 @@ static void D_Renderview(void)
break; break;
default: // Initialize for P1 default: // Initialize for P1
viewwindowy = viewwindowx = 0; viewwindowy = viewwindowx = 0;
objectsdrawn = 0;
break; break;
} }
@@ -328,17 +333,19 @@ static void D_Renderview(void)
} }
else if (rendermode == render_soft) else if (rendermode == render_soft)
#endif #endif
{
R_RenderPlayerView(&players[displayplayers[i]]); R_RenderPlayerView(&players[displayplayers[i]]);
}
if (rendermode == render_soft)
{
if (i == 0)
R_ApplyViewMorph();
if (i == 0)
R_ApplyViewMorph();
#ifdef MOTIONBLUR #ifdef MOTIONBLUR
V_DoPostProcessor(i, postimgparam[i]); V_DoPostProcessor(i, postimgparam[i]);
#else #else
V_DoPostProcessor(i, 0); V_DoPostProcessor(i, 0);
#endif #endif
}
} }
} }
@@ -362,45 +369,6 @@ static void D_Renderview(void)
// added comment : there is a wipe eatch change of the gamestate // added comment : there is a wipe eatch change of the gamestate
gamestate_t wipegamestate = GS_LEVEL; gamestate_t wipegamestate = GS_LEVEL;
static void D_MakeIntermissionBG(void)
{
if (!lastdraw)
return;
if (rendermode == render_none)
{
lastdraw = false;
return;
}
// no more valid map
// shouldnt happen at this point, but better safe than sorry!
if (!numsectors)
{
lastdraw = false;
return;
}
// need to render level again for this
// should be fine since at this point we did not unload it yet
if (cv_renderview.value)
{
D_Renderview();
}
#ifdef HWRENDER
if (rendermode == render_opengl)
{
HWR_MakeScreenTexture();
}
else
#endif
{
VID_BlitLinearScreen(vid.screens[0], vid.screens[1], vid.width, vid.height, vid.width, vid.width);
}
lastdraw = false;
}
static boolean D_Display(void) static boolean D_Display(void)
{ {
boolean ranwipe = false; boolean ranwipe = false;
@@ -558,8 +526,6 @@ static boolean D_Display(void)
break; break;
} }
D_MakeIntermissionBG();
if (gamestate == GS_LEVEL) if (gamestate == GS_LEVEL)
{ {
// draw the view directly // draw the view directly
@@ -570,6 +536,16 @@ static boolean D_Display(void)
PS_STOP_TIMING(ps_rendercalltime); PS_STOP_TIMING(ps_rendercalltime);
} }
if (lastdraw)
{
if (rendermode == render_soft)
{
VID_BlitLinearScreen(vid.screens[0], vid.screens[1], vid.width, vid.height, vid.width, vid.width);
}
lastdraw = false;
}
PS_START_TIMING(ps_uitime); PS_START_TIMING(ps_uitime);
ST_Drawer(); ST_Drawer();
HU_Drawer(); HU_Drawer();
@@ -688,7 +664,7 @@ void D_SRB2Loop(void)
tic_t entertic = 0, oldentertics = 0, realtics = 0, rendertimeout = INFTICS; tic_t entertic = 0, oldentertics = 0, realtics = 0, rendertimeout = INFTICS;
double deltatics = 0.0; double deltatics = 0.0;
double deltasecs = 0.0; double deltasecs = 0.0;
UINT64 precision = 0; UINT64 precision;
boolean interp = false; boolean interp = false;
boolean doDisplay = false; boolean doDisplay = false;
@@ -733,11 +709,6 @@ void D_SRB2Loop(void)
precise_t elapsed; precise_t elapsed;
precise_t enterprecise, finishprecise; precise_t enterprecise, finishprecise;
if (I_Interrupted())
{
I_Quit();
}
enterprecise = I_GetPreciseTime(); enterprecise = I_GetPreciseTime();
memset(&g_dc, 0, sizeof(g_dc)); memset(&g_dc, 0, sizeof(g_dc));
@@ -812,6 +783,11 @@ void D_SRB2Loop(void)
doDisplay = true; doDisplay = true;
} }
if (!dedicated)
{
G_DeviceLEDTick();
}
} }
if (interp) if (interp)
@@ -853,13 +829,6 @@ void D_SRB2Loop(void)
if (takescreenshot) if (takescreenshot)
M_DoScreenShot(); M_DoScreenShot();
#ifndef DEDICATED
if (!dedicated && renderisnewtic)
{
G_DeviceLEDTick();
}
#endif
// consoleplayer -> displayplayers (hear sounds from viewpoint) // consoleplayer -> displayplayers (hear sounds from viewpoint)
S_UpdateSounds(); // move positional sounds S_UpdateSounds(); // move positional sounds
@@ -938,9 +907,7 @@ void D_ClearState(void)
// okay, stop now // okay, stop now
// (otherwise the game still thinks we're playing!) // (otherwise the game still thinks we're playing!)
#ifdef HAVE_CURL
CURLAbortFile(); CURLAbortFile();
#endif
SV_StopServer(); SV_StopServer();
SV_ResetServer(); SV_ResetServer();
@@ -1004,9 +971,6 @@ void D_ClearState(void)
// //
void D_StartTitle(void) void D_StartTitle(void)
{ {
if (dedicated)
I_Error("D_StartTitle is called on dedicated server");
D_ClearState(); D_ClearState();
multiplayer = netgame = false; // title menu shouldnt be a netgame or multiplayer lmao multiplayer = netgame = false; // title menu shouldnt be a netgame or multiplayer lmao
F_StartTitleScreen(); F_StartTitleScreen();
@@ -1068,38 +1032,25 @@ static INT32 D_DetectFileType(const char* filename)
} }
// autoload that shit // autoload that shit
static void D_AutoloadFile(const char *file, char **filearray, size_t *index) static void D_AutoloadFile(const char *file, char **filearray, size_t index)
{ {
char *newfile; char *newfile;
INT32 fileType = D_DetectFileType(file); INT32 fileType = D_DetectFileType(file);
if (*index >= MAX_WADFILES)
{
CONS_Printf("D_AutoloadFile: Failed to add file %s! Too many autoloaded files\n", file);
return;
}
if (!fileType) if (!fileType)
{ {
CONS_Printf("D_AutoloadFile: File %s is unknown or invalid\n", file); CONS_Printf("D_AutoloadFile: File %s is unknown or invalid\n", file);
return; return;
} }
if (fileType == 1)
{
CONS_Printf("D_AutoloadFile: File %s is a directory\n", file);
return;
}
if (fileType <= 6) if (fileType <= 6)
{ {
newfile = malloc(strlen(file) + 1); newfile = malloc(strlen(file) + 1);
if (!newfile) if (!newfile)
I_Error("D_AutoloadFile: No more free memory to autoload file %s", file); I_Error("No more free memory to AutoloadFile %s",file);
strcpy(newfile, file); strcpy(newfile, file);
filearray[*index] = newfile; filearray[index] = newfile;
(*index)++;
} }
else else
{ {
@@ -1142,7 +1093,7 @@ static void D_FindAddonsToAutoload(void)
// If the file is found, run our shit // If the file is found, run our shit
if (!autoloadconfigfile) // nope outta here if (!autoloadconfigfile) // nope outta here
{ {
autoloadwadcount = postloadwadcount = 0; // so D_AddAutoloadFiles can skip everything since nothings there to autoload autoloadcount = postloadcount = 0; // so D_AddAutoloadFiles can skip everything since nothings there to autoload
return; return;
} }
@@ -1168,34 +1119,27 @@ static void D_FindAddonsToAutoload(void)
if (newline) if (newline)
*newline = '\0'; *newline = '\0';
// ok so theres still issues with players adding stuff to autoload by accident
// sometimes this stuff contains maps
// you can probably imagine how that goes in a netgame....
if (W_CheckAutoLoadContainsMap(wadsToAutoload))
{
CONS_Printf("Autoload: file %s contains map data! skipping...", wadsToAutoload);
continue;
}
if (!postload && W_CheckPostLoadList(wadsToAutoload)) if (!postload && W_CheckPostLoadList(wadsToAutoload))
{ {
CONS_Printf("Autoload: forcing postload for file %s\n", wadsToAutoload); CONS_Printf("forcing postload for file %s\n", wadsToAutoload);
postload = true; postload = true;
} }
// LOAD IT // LOAD IT
if (!postload) if (!postload)
{ {
D_AutoloadFile(wadsToAutoload, autoloadwadfiles, &autoloadwadcount); D_AutoloadFile(wadsToAutoload, autoloadwadfiles, autoloadcount);
autoloadcount++;
} }
else else
{ {
D_AutoloadFile(wadsToAutoload, autoloadwadfilespost, &postloadwadcount); D_AutoloadFile(wadsToAutoload, autoloadwadfilespost, postloadcount);
postloadcount++;
} }
} }
autoloadwadfiles[autoloadwadcount] = NULL; autoloadwadfiles[autoloadcount] = NULL;
autoloadwadfilespost[postloadwadcount] = NULL; autoloadwadfilespost[postloadcount] = NULL;
// we dont want memory leaks around here do we? // we dont want memory leaks around here do we?
fclose(autoloadconfigfile); fclose(autoloadconfigfile);
@@ -1204,7 +1148,7 @@ static void D_FindAddonsToAutoload(void)
static void D_AddAutoloadFiles(void) static void D_AddAutoloadFiles(void)
{ {
// nothing to autoload // nothing to autoload
if (autoloadwadcount == 0) if (autoloadcount == 0)
return; return;
CONS_Printf("D_AutoloadFile(): Loading autoloaded addons...\n"); CONS_Printf("D_AutoloadFile(): Loading autoloaded addons...\n");
@@ -1212,15 +1156,15 @@ static void D_AddAutoloadFiles(void)
if (W_AddAutoloadedLocalFiles(autoloadwadfiles) == 0) if (W_AddAutoloadedLocalFiles(autoloadwadfiles) == 0)
CONS_Printf("D_AutoloadFile(): Are you sure you put in valid files or what?\n"); CONS_Printf("D_AutoloadFile(): Are you sure you put in valid files or what?\n");
D_CleanFile(autoloadwadfiles, autoloadwadcount); D_CleanFile(autoloadwadfiles, autoloadcount);
autoloadwadcount = 0; autoloadcount = 0;
} }
void D_AddPostloadFiles(void) void D_AddPostloadFiles(void)
{ {
// nothing to postload // nothing to postload
if (postloadwadcount == 0 || !netgame) if (postloadcount == 0 || !netgame)
return; return;
CONS_Printf("D_AddPostloadFiles(): Loading postloaded addons...\n"); CONS_Printf("D_AddPostloadFiles(): Loading postloaded addons...\n");
@@ -1228,9 +1172,9 @@ void D_AddPostloadFiles(void)
if (W_AddAutoloadedLocalFiles(autoloadwadfilespost) == 0) if (W_AddAutoloadedLocalFiles(autoloadwadfilespost) == 0)
CONS_Printf("D_AddPostloadFiles(): Are you sure you put in valid files or what?\n"); CONS_Printf("D_AddPostloadFiles(): Are you sure you put in valid files or what?\n");
D_CleanFile(autoloadwadfilespost, postloadwadcount); D_CleanFile(autoloadwadfilespost, postloadcount);
postloadwadcount = 0; postloadcount = 0;
} }
// ========================================================================== // ==========================================================================
@@ -1239,7 +1183,7 @@ void D_AddPostloadFiles(void)
static boolean AddIWAD(const char * file, const char *dir) static boolean AddIWAD(const char * file, const char *dir)
{ {
char *path = va(pandf, dir, file); char * path = va(pandf, dir, file);
if (FIL_ReadFileOK(path)) if (FIL_ReadFileOK(path))
{ {
@@ -1267,13 +1211,17 @@ static void IdentifyVersion(void)
#endif #endif
char tempsrb2path[256] = "."; char tempsrb2path[256] = ".";
if (getcwd(tempsrb2path, 256) == NULL) getcwd(tempsrb2path, 256);
strcpy(tempsrb2path, ".");
// get the current directory (possible problem on NT with "." as current dir) // get the current directory (possible problem on NT with "." as current dir)
if (!srb2waddir) if (!srb2waddir)
{ {
srb2waddir = tempsrb2path; if (tempsrb2path[0])
srb2waddir = tempsrb2path;
else
{
srb2waddir = ".";
}
} }
#if (1) // reduce the amount of findfile by only using full cwd in this func #if (1) // reduce the amount of findfile by only using full cwd in this func
@@ -1694,6 +1642,12 @@ void D_SRB2Main(void)
strcpy(srb2, "SRB2Kart"); strcpy(srb2, "SRB2Kart");
D_MakeTitleString(srb2); D_MakeTitleString(srb2);
#if defined (__OS2__) && !defined (HAVE_SDL)
// set PM window title
snprintf(pmData->title, sizeof (pmData->title), "SRB2Kart" VERSIONSTRING ": %s", title);
pmData->title[sizeof (pmData->title) - 1] = '\0';
#endif
if (devparm) if (devparm)
CONS_Printf(M_GetText("Development mode ON.\n")); CONS_Printf(M_GetText("Development mode ON.\n"));
@@ -1817,6 +1771,10 @@ void D_SRB2Main(void)
// Setup default unlockable conditions // Setup default unlockable conditions
M_SetupDefaultConditionSets(); M_SetupDefaultConditionSets();
// Setup character tables
// Have to be done here before files are loaded
M_InitCharacterTables();
// load wad, including the main wad file // load wad, including the main wad file
CONS_Printf("W_InitMultipleFiles(): Adding IWAD and main PWADs.\n"); CONS_Printf("W_InitMultipleFiles(): Adding IWAD and main PWADs.\n");
@@ -1936,8 +1894,7 @@ void D_SRB2Main(void)
if (M_CheckParm("-warp") && M_IsNextParm()) if (M_CheckParm("-warp") && M_IsNextParm())
{ {
const char *word = M_GetNextParm(); const char *word = M_GetNextParm();
pstartmap = G_FindMapByNameOrCode(word, NULL); pstartmap = G_FindMapByNameOrCode(word, 0);
if (! pstartmap) if (! pstartmap)
I_Error("Cannot find a map remotely named '%s'\n", word); I_Error("Cannot find a map remotely named '%s'\n", word);
else else
@@ -2070,13 +2027,9 @@ void D_SRB2Main(void)
if (M_CheckProtoParam("replay")) if (M_CheckProtoParam("replay"))
{ {
const char *replayurl = M_GetProtoParam(); const char *replayurl = M_GetProtoParam();
char *replayname = strrchr(replayurl, '/');
if (!replayurl) if (!replayname || !replayurl)
I_Error("REPLAY: Invalid URL.");
gconst char *replayname = strrchr(replayurl, '/');
if (!replayname)
I_Error("REPLAY: Invalid URL."); I_Error("REPLAY: Invalid URL.");
#define REPLAYDIR "/DownloadedReplays/" #define REPLAYDIR "/DownloadedReplays/"
@@ -2190,8 +2143,8 @@ void D_SRB2Main(void)
if (dedicated && server) if (dedicated && server)
{ {
levelstarttic = gametic;
G_SetGamestate(GS_LEVEL); G_SetGamestate(GS_LEVEL);
if (!P_SetupLevel(false, false)) if (!P_SetupLevel(false, false))
I_Quit(); // fail so reset game stuff I_Quit(); // fail so reset game stuff
} }
+7 -3
View File
@@ -59,7 +59,7 @@ static INT16 reboundsize[MAXREBOUND];
static INT32 rebound_head, rebound_tail; static INT32 rebound_head, rebound_tail;
/// \brief max length per packet /// \brief max length per packet
INT16 hardware_MAXPACKETLENGTH = 0; INT16 hardware_MAXPACKETLENGTH;
boolean (*I_NetGet)(void) = NULL; boolean (*I_NetGet)(void) = NULL;
void (*I_NetSend)(void) = NULL; void (*I_NetSend)(void) = NULL;
@@ -96,7 +96,7 @@ INT32 ticruned = 0, ticmiss = 0;
// globals // globals
INT32 getbps = 0, sendbps = 0; INT32 getbps = 0, sendbps = 0;
float lostpercent = 0.0f, duppercent = 0.0f, gamelostpercent = 0.0f; float lostpercent = 0, duppercent = 0, gamelostpercent = 0;
INT32 packetheaderlength = 0; INT32 packetheaderlength = 0;
boolean Net_GetNetStat(void) boolean Net_GetNetStat(void)
@@ -612,8 +612,12 @@ void Net_WaitAllAckReceived(UINT32 timeout)
static void InitNode(node_t *node) static void InitNode(node_t *node)
{ {
memset(node, 0, sizeof(node_t)); node->acktosend_head = node->acktosend_tail = 0;
memset(node->acktosend, 0, sizeof(node->acktosend));
node->firstacktosend = 0;
node->nextacknum = 1; node->nextacknum = 1;
node->remotefirstack = 0;
node->flags = 0;
} }
static void InitAck(void) static void InitAck(void)
+1
View File
@@ -27,6 +27,7 @@ extern "C" {
// SINT8 is used for nodes sometimes >:( // SINT8 is used for nodes sometimes >:(
#define MAXNETNODES 127 #define MAXNETNODES 127
#define BROADCASTADDR MAXNETNODES #define BROADCASTADDR MAXNETNODES
#define NETSPLITSCREEN // Kart's splitscreen netgame feature
#define STATLENGTH (TICRATE*2) #define STATLENGTH (TICRATE*2)
+491 -159
View File
@@ -54,9 +54,6 @@
#include "fastcmp.h" #include "fastcmp.h"
#include "m_perfstats.h" #include "m_perfstats.h"
#include "r_data.h"
#include "r_skins.h"
#ifdef NETGAME_DEVMODE #ifdef NETGAME_DEVMODE
#define CV_RESTRICT CV_NETVAR #define CV_RESTRICT CV_NETVAR
#else #else
@@ -252,7 +249,7 @@ consvar_t cv_competitionboxes = {"competitionboxes", "Random", CV_NETVAR|CV_CHEA
#ifdef SEENAMES #ifdef SEENAMES
static CV_PossibleValue_t seenames_cons_t[] = {{0, "Off"}, {1, "Colorless"}, {2, "Team"}, {3, "Ally/Foe"}, {0, NULL}}; static CV_PossibleValue_t seenames_cons_t[] = {{0, "Off"}, {1, "Colorless"}, {2, "Team"}, {3, "Ally/Foe"}, {0, NULL}};
consvar_t cv_seenames = {"seenames", "Off", CV_SAVE, seenames_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_seenames = {"seenames", "Off", CV_SAVE, seenames_cons_t, 0, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_allowseenames = {"allowseenames", "No", CV_NETVAR, CV_YesNo, NULL, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_allowseenames = {"allowseenames", "No", CV_NETVAR, CV_YesNo, NULL, 0, NULL, NULL, 0, 0, NULL};
#endif #endif
@@ -461,16 +458,16 @@ consvar_t cv_showping = {"showping", "Always", CV_SAVE, showping_cons_t, NULL, 0
static CV_PossibleValue_t pingmeasurement_cons_t[] = {{0, "Frames"}, {1, "Milliseconds"}, {0, NULL}}; static CV_PossibleValue_t pingmeasurement_cons_t[] = {{0, "Frames"}, {1, "Milliseconds"}, {0, NULL}};
consvar_t cv_pingmeasurement = {"pingmeasurement", "Frames", CV_SAVE, pingmeasurement_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_pingmeasurement = {"pingmeasurement", "Frames", CV_SAVE, pingmeasurement_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_pingicon = {"pingicon", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_pingicon = {"pingicon", "On", CV_SAVE, CV_OnOff, 0, 0, NULL, NULL, 0, 0, NULL};
static CV_PossibleValue_t cv_pingstyle_cons_t[] = {{0, "New"}, {1, "Old"}, {0, NULL}}; static CV_PossibleValue_t cv_pingstyle_cons_t[] = {{0, "New"}, {1, "Old"}, {0, NULL}};
consvar_t cv_pingstyle = {"pingstyle", "New", CV_SAVE, cv_pingstyle_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_pingstyle = {"pingstyle", "New", CV_SAVE, cv_pingstyle_cons_t, 0, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_luaimmersion = {"luaimmersion", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_luaimmersion = {"luaimmersion", "On", CV_SAVE, CV_OnOff, 0, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_showviewpointtext = {"showviewpointtext", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_showviewpointtext = {"showviewpointtext", "On", CV_SAVE, CV_OnOff, 0, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_showdownloadprompt = {"showdownloadprompt", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_showdownloadprompt = {"showdownloadprompt", "On", CV_SAVE, CV_OnOff, 0, 0, NULL, NULL, 0, 0, NULL};
// Intermission time Tails 04-19-2002 // Intermission time Tails 04-19-2002
static CV_PossibleValue_t inttime_cons_t[] = {{0, "MIN"}, {3600, "MAX"}, {0, NULL}}; static CV_PossibleValue_t inttime_cons_t[] = {{0, "MIN"}, {3600, "MAX"}, {0, NULL}};
@@ -900,7 +897,6 @@ void D_RegisterClientCommands(void)
CV_RegisterVar(&cv_mindelay); CV_RegisterVar(&cv_mindelay);
CV_RegisterVar(&cv_gentlemens); CV_RegisterVar(&cv_gentlemens);
CV_RegisterVar(&cv_serverinfoscreen); CV_RegisterVar(&cv_serverinfoscreen);
CV_RegisterVar(&cv_serveraddoninfo);
#ifdef NETGAME_DEVMODE #ifdef NETGAME_DEVMODE
CV_RegisterVar(&cv_fishcake); CV_RegisterVar(&cv_fishcake);
@@ -1010,9 +1006,6 @@ void D_RegisterClientCommands(void)
CV_RegisterVar(&cv_gamepadled[i]); CV_RegisterVar(&cv_gamepadled[i]);
} }
CV_RegisterVar(&cv_gamepadledifunfocused);
CV_RegisterVar(&cv_rumbleifunfocused);
CV_RegisterVar(&cv_usemouse); CV_RegisterVar(&cv_usemouse);
CV_RegisterVar(&cv_invertmouse); CV_RegisterVar(&cv_invertmouse);
CV_RegisterVar(&cv_mousexsens); CV_RegisterVar(&cv_mousexsens);
@@ -1209,11 +1202,11 @@ static boolean AllowedPlayerNameChar(char ch)
static boolean EnsurePlayerNameIsGood(char *name, INT32 playernum) static boolean EnsurePlayerNameIsGood(char *name, INT32 playernum)
{ {
size_t ix, len = strlen(name); INT32 ix;
if (len == 0 || len > MAXPLAYERNAME) if (strlen(name) == 0 || strlen(name) > MAXPLAYERNAME)
return false; // Empty or too long. return false; // Empty or too long.
if (name[0] == ' ' || name[len-1] == ' ') if (name[0] == ' ' || name[strlen(name)-1] == ' ')
return false; // Starts or ends with a space. return false; // Starts or ends with a space.
if (isdigit(name[0])) if (isdigit(name[0]))
return false; // Starts with a digit. return false; // Starts with a digit.
@@ -1227,19 +1220,20 @@ static boolean EnsurePlayerNameIsGood(char *name, INT32 playernum)
// Also, anything over 0x80 is disallowed too, since compilers love to // Also, anything over 0x80 is disallowed too, since compilers love to
// differ on whether they're printable characters or not. // differ on whether they're printable characters or not.
for (ix = 0; ix < len; ix++) for (ix = 0; name[ix] != '\0'; ix++)
if (!AllowedPlayerNameChar(name[ix])) if (!AllowedPlayerNameChar(name[ix]))
return false; return false;
// Check if a player is currently using the name, case-insensitively. // Check if a player is currently using the name, case-insensitively.
for (ix = 0; ix < MAXPLAYERS; ix++) for (ix = 0; ix < MAXPLAYERS; ix++)
{ {
if (ix != (size_t)playernum && playeringame[ix] if (ix != playernum && playeringame[ix]
&& fasticmp(name, player_names[ix])) && fasticmp(name, player_names[ix]))
{ {
// We shouldn't kick people out just because // We shouldn't kick people out just because
// they joined the game with the same name // they joined the game with the same name
// as someone else -- modify the name instead. // as someone else -- modify the name instead.
size_t len = strlen(name);
// Recursion! // Recursion!
// Slowly strip characters off the end of the // Slowly strip characters off the end of the
@@ -1458,9 +1452,7 @@ UINT8 CanChangeSkin(INT32 playernum)
return true; return true;
} }
if (players[playernum].spectator || if (players[playernum].spectator || players[playernum].playerstate == PST_DEAD || players[playernum].playerstate == PST_REBORN)
players[playernum].playerstate == PST_DEAD ||
players[playernum].playerstate == PST_REBORN)
return true; return true;
return false; return false;
@@ -1494,145 +1486,446 @@ static void ForceAllSkins(INT32 forcedskin)
} }
} }
static INT32 chmappending; static INT32 snacpending = 0, snac2pending = 0, snac3pending = 0, snac4pending = 0, chmappending = 0;
static INT32 snacpending[MAXSPLITSCREENPLAYERS];
// wonky compat, idk if anything uses this....
#define playerisbot (splitplayer == 1 && botingame)
// name, color, or skin has changed // name, color, or skin has changed
// //
static void SendNameAndColor(UINT8 splitplayer) static void SendNameAndColor(void)
{ {
char buf[MAXPLAYERNAME+2]; char buf[MAXPLAYERNAME+2];
char *p; char *p;
p = buf; p = buf;
// splitscreen
if (splitscreen < splitplayer && !playerisbot)
return;
const INT32 pnum = P_GetLocalPlayerNumForNum(splitplayer);
player_t *player = &players[pnum];
// TODO: make those cvars arrays
consvar_t *playercolor, *playername, *playerskin;
consvar_t *colorvars[] = {&cv_playercolor, &cv_playercolor2, &cv_playercolor3, &cv_playercolor4};
consvar_t *namevars[] = {&cv_playername, &cv_playername2, &cv_playername3, &cv_playername4};
consvar_t *skinvars[] = {&cv_skin, &cv_skin2, &cv_skin3, &cv_skin4};
playercolor = colorvars[splitplayer];
playername = namevars[splitplayer];
playerskin = skinvars[splitplayer];
// normal player colors // normal player colors
if (G_GametypeHasTeams()) if (G_GametypeHasTeams())
{ {
if (player->ctfteam == 1 && playercolor->value != skincolor_redteam) if (players[consoleplayer].ctfteam == 1 && cv_playercolor.value != skincolor_redteam)
CV_StealthSetValue(playercolor, skincolor_redteam); CV_StealthSetValue(&cv_playercolor, skincolor_redteam);
else if (player->ctfteam == 2 && playercolor->value != skincolor_blueteam) else if (players[consoleplayer].ctfteam == 2 && cv_playercolor.value != skincolor_blueteam)
CV_StealthSetValue(playercolor, skincolor_blueteam); CV_StealthSetValue(&cv_playercolor, skincolor_blueteam);
} }
// never allow the color "none" // never allow the color "none"
if (!playercolor->value) if (!cv_playercolor.value)
{ {
if (player->skincolor) if (players[consoleplayer].skincolor)
CV_StealthSetValue(playercolor, player->skincolor); CV_StealthSetValue(&cv_playercolor, players[consoleplayer].skincolor);
else if (skins[player->skin].prefcolor) else if (skins[players[consoleplayer].skin].prefcolor)
CV_StealthSetValue(playercolor, skins[player->skin].prefcolor); CV_StealthSetValue(&cv_playercolor, skins[players[consoleplayer].skin].prefcolor);
else else
CV_StealthSet(playercolor, playercolor->defaultvalue); CV_StealthSet(&cv_playercolor, cv_playercolor.defaultvalue);
} }
if (fastcmp(cv_playername.string, player_names[consoleplayer])
&& cv_playercolor.value == players[consoleplayer].skincolor
&& fastcmp(cv_skin.string, skins[players[consoleplayer].skin].name))
return;
// We'll handle it later if we're not playing. // We'll handle it later if we're not playing.
if (!Playing()) if (!Playing())
return; return;
if (fastcmp(playername->string, player_names[pnum])
&& playercolor->value == player->skincolor
&& fastcmp(playerskin->string, skins[player->skin].name))
return;
if (playerisbot)
{
players[pnum].skincolor = botcolor;
if (players[pnum].mo)
players[pnum].mo->color = players[pnum].skincolor;
SetPlayerSkinByNum(pnum, botskin-1);
return;
}
// If you're not in a netgame, merely update the skin, color, and name. // If you're not in a netgame, merely update the skin, color, and name.
if (!netgame) if (!netgame)
{ {
INT32 foundskin; INT32 foundskin;
CleanupPlayerName(pnum, playername->zstring); CleanupPlayerName(consoleplayer, cv_playername.zstring);
strcpy(player_names[pnum], playername->zstring); strcpy(player_names[consoleplayer], cv_playername.zstring);
player->skincolor = playercolor->value; players[consoleplayer].skincolor = cv_playercolor.value;
if (player->mo) if (players[consoleplayer].mo)
player->mo->color = player->skincolor; players[consoleplayer].mo->color = players[consoleplayer].skincolor;
if ((foundskin = R_SkinAvailable(playerskin->string)) != -1) if ((foundskin = R_SkinAvailable(cv_skin.string)) != -1)
{ {
playerskin->value = foundskin; cv_skin.value = foundskin;
SetPlayerSkin(pnum, playerskin->string); SetPlayerSkin(consoleplayer, cv_skin.string);
CV_StealthSet(playerskin, skins[playerskin->value].name); CV_StealthSet(&cv_skin, skins[cv_skin.value].name);
} }
else else
{ {
playerskin->value = player->skin; cv_skin.value = players[consoleplayer].skin;
CV_StealthSet(playerskin, skins[player->skin].name); CV_StealthSet(&cv_skin, skins[players[consoleplayer].skin].name);
// will always be same as current // will always be same as current
SetPlayerSkin(pnum, playerskin->string); SetPlayerSkin(consoleplayer, cv_skin.string);
} }
return; return;
} }
snacpending[splitplayer]++; snacpending++;
// Don't change name if muted // Don't change name if muted
if (player_name_changes[pnum] >= MAXNAMECHANGES) if (player_name_changes[consoleplayer] >= MAXNAMECHANGES)
{ {
CV_StealthSet(playername, player_names[pnum]); CV_StealthSet(&cv_playername, player_names[consoleplayer]);
HU_AddChatText("\x85*You must wait to change your name again", false); HU_AddChatText("\x85*You must wait to change your name again", false);
} }
else if (cv_mute.value && !(server || IsPlayerAdmin(pnum))) else if (cv_mute.value && !(server || IsPlayerAdmin(consoleplayer)))
CV_StealthSet(playername, player_names[pnum]); CV_StealthSet(&cv_playername, player_names[consoleplayer]);
else // Cleanup name if changing it else // Cleanup name if changing it
CleanupPlayerName(pnum, playername->zstring); CleanupPlayerName(consoleplayer, cv_playername.zstring);
// Don't change skin if the server doesn't want you to. // Don't change skin if the server doesn't want you to.
if (!CanChangeSkin(pnum)) if (!CanChangeSkin(consoleplayer))
CV_StealthSet(playerskin, skins[player->skin].name); CV_StealthSet(&cv_skin, skins[players[consoleplayer].skin].name);
// check if player has the skin loaded (cv_skin may have // check if player has the skin loaded (cv_skin may have
// the name of a skin that was available in the previous game) // the name of a skin that was available in the previous game)
playerskin->value = R_SkinAvailable(playerskin->string); cv_skin.value = R_SkinAvailable(cv_skin.string);
if (playerskin->value < 0) if (cv_skin.value < 0)
{ {
INT32 skinnum = player->skin; INT32 skinnum = players[consoleplayer].skin;
CV_StealthSet(playerskin, skins[skinnum].name); CV_StealthSet(&cv_skin, skins[skinnum].name);
playerskin->value = skinnum; cv_skin.value = skinnum;
} }
// Finally write out the complete packet and send it off. // Finally write out the complete packet and send it off.
WRITESTRINGN(p, playername->zstring, MAXPLAYERNAME); WRITESTRINGN(p, cv_playername.zstring, MAXPLAYERNAME);
WRITEUINT8(p, (UINT8)playercolor->value); WRITEUINT8(p, (UINT8)cv_playercolor.value);
WRITEUINT8(p, (UINT8)playerskin->value); WRITEUINT8(p, (UINT8)cv_skin.value);
SendNetXCmdForPlayer(splitplayer, XD_NAMEANDCOLOR, buf, p - buf); SendNetXCmdForPlayer(0, XD_NAMEANDCOLOR, buf, p - buf);
}
// splitscreen
static void SendNameAndColor2(void)
{
INT32 secondplaya = -1;
char buf[MAXPLAYERNAME+2];
char *p;
if (splitscreen < 1 && !botingame)
return; // can happen if skin2/color2/name2 changed
if (displayplayers[1] != consoleplayer)
secondplaya = displayplayers[1];
else if (!netgame) // HACK
secondplaya = 1;
if (secondplaya == -1)
return;
p = buf;
// normal player colors
if (G_GametypeHasTeams())
{
if (players[secondplaya].ctfteam == 1 && cv_playercolor2.value != skincolor_redteam)
CV_StealthSetValue(&cv_playercolor2, skincolor_redteam);
else if (players[secondplaya].ctfteam == 2 && cv_playercolor2.value != skincolor_blueteam)
CV_StealthSetValue(&cv_playercolor2, skincolor_blueteam);
}
// never allow the color "none"
if (!cv_playercolor2.value)
{
if (players[secondplaya].skincolor)
CV_StealthSetValue(&cv_playercolor2, players[secondplaya].skincolor);
else if (skins[players[secondplaya].skin].prefcolor)
CV_StealthSetValue(&cv_playercolor2, skins[players[secondplaya].skin].prefcolor);
else
CV_StealthSet(&cv_playercolor2, cv_playercolor2.defaultvalue);
}
// We'll handle it later if we're not playing.
if (!Playing())
return;
// If you're not in a netgame, merely update the skin, color, and name.
if (botingame)
{
players[secondplaya].skincolor = botcolor;
if (players[secondplaya].mo)
players[secondplaya].mo->color = players[secondplaya].skincolor;
SetPlayerSkinByNum(secondplaya, botskin-1);
return;
}
else if (!netgame)
{
INT32 foundskin;
CleanupPlayerName(secondplaya, cv_playername2.zstring);
strcpy(player_names[secondplaya], cv_playername2.zstring);
// don't use displayplayers[1]: the second player must be 1
players[secondplaya].skincolor = cv_playercolor2.value;
if (players[secondplaya].mo)
players[secondplaya].mo->color = players[secondplaya].skincolor;
if ((foundskin = R_SkinAvailable(cv_skin2.string)) != -1)
{
cv_skin2.value = foundskin;
SetPlayerSkin(secondplaya, cv_skin2.string);
}
else
{
cv_skin2.value = players[secondplaya].skin;
CV_StealthSet(&cv_skin2, skins[players[secondplaya].skin].name);
// will always be same as current
SetPlayerSkin(secondplaya, cv_skin2.string);
}
return;
}
snac2pending++;
// Don't change name if muted
if (player_name_changes[displayplayers[1]] >= MAXNAMECHANGES)
{
CV_StealthSet(&cv_playername2, player_names[displayplayers[1]]);
HU_AddChatText("\x85*You must wait to change your name again", false);
}
else if (cv_mute.value && !(server || IsPlayerAdmin(displayplayers[1])))
CV_StealthSet(&cv_playername2, player_names[displayplayers[1]]);
else // Cleanup name if changing it
CleanupPlayerName(displayplayers[1], cv_playername2.zstring);
// Don't change skin if the server doesn't want you to.
if (!CanChangeSkin(displayplayers[1]))
CV_StealthSet(&cv_skin2, skins[players[displayplayers[1]].skin].name);
// check if player has the skin loaded (cv_skin2 may have
// the name of a skin that was available in the previous game)
cv_skin2.value = R_SkinAvailable(cv_skin2.string);
if (cv_skin2.value < 0)
{
INT32 skinnum = players[displayplayers[1]].skin;
CV_StealthSet(&cv_skin2, skins[skinnum].name);
cv_skin2.value = skinnum;
}
// Finally write out the complete packet and send it off.
WRITESTRINGN(p, cv_playername2.zstring, MAXPLAYERNAME);
WRITEUINT8(p, (UINT8)cv_playercolor2.value);
WRITEUINT8(p, (UINT8)cv_skin2.value);
SendNetXCmdForPlayer(1, XD_NAMEANDCOLOR, buf, p - buf);
}
static void SendNameAndColor3(void)
{
INT32 thirdplaya = -1;
char buf[MAXPLAYERNAME+2];
char *p;
if (splitscreen < 2)
return; // can happen if skin3/color3/name3 changed
if (displayplayers[2] != consoleplayer)
thirdplaya = displayplayers[2];
else if (!netgame) // HACK
thirdplaya = 2;
if (thirdplaya == -1)
return;
p = buf;
// normal player colors
if (G_GametypeHasTeams())
{
if (players[thirdplaya].ctfteam == 1 && cv_playercolor3.value != skincolor_redteam)
CV_StealthSetValue(&cv_playercolor3, skincolor_redteam);
else if (players[thirdplaya].ctfteam == 2 && cv_playercolor3.value != skincolor_blueteam)
CV_StealthSetValue(&cv_playercolor3, skincolor_blueteam);
}
// never allow the color "none"
if (!cv_playercolor3.value)
{
if (players[thirdplaya].skincolor)
CV_StealthSetValue(&cv_playercolor3, players[thirdplaya].skincolor);
else if (skins[players[thirdplaya].skin].prefcolor)
CV_StealthSetValue(&cv_playercolor3, skins[players[thirdplaya].skin].prefcolor);
else
CV_StealthSet(&cv_playercolor3, cv_playercolor3.defaultvalue);
}
// We'll handle it later if we're not playing.
if (!Playing())
return;
// If you're not in a netgame, merely update the skin, color, and name.
if (!netgame)
{
INT32 foundskin;
CleanupPlayerName(thirdplaya, cv_playername3.zstring);
strcpy(player_names[thirdplaya], cv_playername3.zstring);
// don't use displayplayers[2]: the third player must be 2
players[thirdplaya].skincolor = cv_playercolor3.value;
if (players[thirdplaya].mo)
players[thirdplaya].mo->color = players[thirdplaya].skincolor;
if ((foundskin = R_SkinAvailable(cv_skin3.string)) != -1)
{
cv_skin3.value = foundskin;
SetPlayerSkin(thirdplaya, cv_skin3.string);
}
else
{
cv_skin3.value = players[thirdplaya].skin;
CV_StealthSet(&cv_skin3, skins[players[thirdplaya].skin].name);
// will always be same as current
SetPlayerSkin(thirdplaya, cv_skin3.string);
}
return;
}
snac3pending++;
// Don't change name if muted
if (player_name_changes[displayplayers[2]] >= MAXNAMECHANGES)
{
CV_StealthSet(&cv_playername3, player_names[displayplayers[2]]);
HU_AddChatText("\x85*You must wait to change your name again", false);
}
else if (cv_mute.value && !(server || IsPlayerAdmin(displayplayers[2])))
CV_StealthSet(&cv_playername3, player_names[displayplayers[2]]);
else // Cleanup name if changing it
CleanupPlayerName(displayplayers[2], cv_playername3.zstring);
// Don't change skin if the server doesn't want you to.
if (!CanChangeSkin(displayplayers[2]))
CV_StealthSet(&cv_skin3, skins[players[displayplayers[2]].skin].name);
// check if player has the skin loaded (cv_skin3 may have
// the name of a skin that was available in the previous game)
cv_skin3.value = R_SkinAvailable(cv_skin3.string);
if (cv_skin3.value < 0)
{
INT32 skinnum = players[displayplayers[2]].skin;
CV_StealthSet(&cv_skin3, skins[skinnum].name);
cv_skin3.value = skinnum;
}
// Finally write out the complete packet and send it off.
WRITESTRINGN(p, cv_playername3.zstring, MAXPLAYERNAME);
WRITEUINT8(p, (UINT8)cv_playercolor3.value);
WRITEUINT8(p, (UINT8)cv_skin3.value);
SendNetXCmdForPlayer(2, XD_NAMEANDCOLOR, buf, p - buf);
}
static void SendNameAndColor4(void)
{
INT32 fourthplaya = -1;
char buf[MAXPLAYERNAME+2];
char *p;
if (splitscreen < 3)
return; // can happen if skin4/color4/name4 changed
if (displayplayers[3] != consoleplayer)
fourthplaya = displayplayers[3];
else if (!netgame) // HACK
fourthplaya = 3;
if (fourthplaya == -1)
return;
p = buf;
// normal player colors
if (G_GametypeHasTeams())
{
if (players[fourthplaya].ctfteam == 1 && cv_playercolor4.value != skincolor_redteam)
CV_StealthSetValue(&cv_playercolor4, skincolor_redteam);
else if (players[fourthplaya].ctfteam == 2 && cv_playercolor4.value != skincolor_blueteam)
CV_StealthSetValue(&cv_playercolor4, skincolor_blueteam);
}
// never allow the color "none"
if (!cv_playercolor4.value)
{
if (players[fourthplaya].skincolor)
CV_StealthSetValue(&cv_playercolor4, players[fourthplaya].skincolor);
else if (skins[players[fourthplaya].skin].prefcolor)
CV_StealthSetValue(&cv_playercolor4, skins[players[fourthplaya].skin].prefcolor);
else
CV_StealthSet(&cv_playercolor4, cv_playercolor4.defaultvalue);
}
// We'll handle it later if we're not playing.
if (!Playing())
return;
// If you're not in a netgame, merely update the skin, color, and name.
if (botingame)
{
players[fourthplaya].skincolor = botcolor;
if (players[fourthplaya].mo)
players[fourthplaya].mo->color = players[fourthplaya].skincolor;
SetPlayerSkinByNum(fourthplaya, botskin-1);
return;
}
else if (!netgame)
{
INT32 foundskin;
CleanupPlayerName(fourthplaya, cv_playername4.zstring);
strcpy(player_names[fourthplaya], cv_playername4.zstring);
// don't use displayplayers[3]: the second player must be 4
players[fourthplaya].skincolor = cv_playercolor4.value;
if (players[fourthplaya].mo)
players[fourthplaya].mo->color = players[fourthplaya].skincolor;
if ((foundskin = R_SkinAvailable(cv_skin4.string)) != -1)
{
cv_skin4.value = foundskin;
SetPlayerSkin(fourthplaya, cv_skin4.string);
}
else
{
cv_skin4.value = players[fourthplaya].skin;
CV_StealthSet(&cv_skin4, skins[players[fourthplaya].skin].name);
// will always be same as current
SetPlayerSkin(fourthplaya, cv_skin4.string);
}
return;
}
snac4pending++;
// Don't change name if muted
if (player_name_changes[displayplayers[3]] >= MAXNAMECHANGES)
{
CV_StealthSet(&cv_playername4, player_names[displayplayers[3]]);
HU_AddChatText("\x85*You must wait to change your name again", false);
}
else if (cv_mute.value && !(server || IsPlayerAdmin(displayplayers[3])))
CV_StealthSet(&cv_playername4, player_names[displayplayers[3]]);
else // Cleanup name if changing it
CleanupPlayerName(displayplayers[3], cv_playername4.zstring);
// Don't change skin if the server doesn't want you to.
if (!CanChangeSkin(displayplayers[3]))
CV_StealthSet(&cv_skin4, skins[players[displayplayers[3]].skin].name);
// check if player has the skin loaded (cv_skin4 may have
// the name of a skin that was available in the previous game)
cv_skin4.value = R_SkinAvailable(cv_skin4.string);
if (cv_skin4.value < 0)
{
INT32 skinnum = players[displayplayers[3]].skin;
CV_StealthSet(&cv_skin4, skins[skinnum].name);
cv_skin4.value = skinnum;
}
// Finally write out the complete packet and send it off.
WRITESTRINGN(p, cv_playername4.zstring, MAXPLAYERNAME);
WRITEUINT8(p, (UINT8)cv_playercolor4.value);
WRITEUINT8(p, (UINT8)cv_skin4.value);
SendNetXCmdForPlayer(3, XD_NAMEANDCOLOR, buf, p - buf);
} }
static void Got_NameAndColor(const UINT8 **cp, INT32 playernum) static void Got_NameAndColor(const UINT8 **cp, INT32 playernum)
{ {
player_t *player = &players[playernum]; player_t *p = &players[playernum];
char name[MAXPLAYERNAME+1] = {}; char name[MAXPLAYERNAME+1];
UINT8 color, skin; UINT8 color, skin;
#ifdef PARANOIA #ifdef PARANOIA
@@ -1640,14 +1933,19 @@ static void Got_NameAndColor(const UINT8 **cp, INT32 playernum)
I_Error("There is no player %d!", playernum); I_Error("There is no player %d!", playernum);
#endif #endif
if (P_IsLocalPlayer(player)) if (playernum == consoleplayer)
{ snacpending--; // TODO: make snacpending an array instead of 4 separate vars?
snacpending[playernum]--; else if (playernum == displayplayers[1])
snac2pending--;
else if (playernum == displayplayers[2])
snac3pending--;
else if (playernum == displayplayers[3])
snac4pending--;
#ifdef PARANOIA #ifdef PARANOIA
if (snacpending[playernum] < 0) if (snacpending < 0 || snac2pending < 0 || snac3pending < 0 || snac4pending < 0)
I_Error("snacpending negative!"); I_Error("snacpending negative!");
#endif #endif
}
READSTRINGN(*cp, name, MAXPLAYERNAME); READSTRINGN(*cp, name, MAXPLAYERNAME);
color = READUINT8(*cp); color = READUINT8(*cp);
@@ -1661,32 +1959,33 @@ static void Got_NameAndColor(const UINT8 **cp, INT32 playernum)
} }
// set color // set color
player->skincolor = color % MAXSKINCOLORS; p->skincolor = color % MAXSKINCOLORS;
if (player->mo) if (p->mo)
player->mo->color = (UINT8)player->skincolor; p->mo->color = (UINT8)p->skincolor;
demo_extradata[playernum] |= DXD_COLOR; demo_extradata[playernum] |= DXD_COLOR;
// normal player colors // normal player colors
if (server && !P_IsLocalPlayer(player)) if (server && (p != &players[consoleplayer] && p != &players[displayplayers[1]]
&& p != &players[displayplayers[2]] && p != &players[displayplayers[3]]))
{ {
boolean kick = false; boolean kick = false;
// team colors // team colors
if (G_GametypeHasTeams()) if (G_GametypeHasTeams())
{ {
if (player->ctfteam == 1 && player->skincolor != skincolor_redteam) if (p->ctfteam == 1 && p->skincolor != skincolor_redteam)
kick = true; kick = true;
else if (player->ctfteam == 2 && player->skincolor != skincolor_blueteam) else if (p->ctfteam == 2 && p->skincolor != skincolor_blueteam)
kick = true; kick = true;
} }
// don't allow color "none" // don't allow color "none"
if (!player->skincolor) if (!p->skincolor)
kick = true; kick = true;
if (kick) if (kick)
{ {
CONS_Alert(CONS_WARNING, M_GetText("Illegal color change received from %s (team: %d), color: %d)\n"), player_names[playernum], player->ctfteam, player->skincolor); CONS_Alert(CONS_WARNING, M_GetText("Illegal color change received from %s (team: %d), color: %d)\n"), player_names[playernum], p->ctfteam, p->skincolor);
SendKick(playernum, KICK_MSG_CON_FAIL); SendKick(playernum, KICK_MSG_CON_FAIL);
return; return;
} }
@@ -1698,7 +1997,6 @@ static void Got_NameAndColor(const UINT8 **cp, INT32 playernum)
const INT32 forcedskin = cv_forceskin.value; const INT32 forcedskin = cv_forceskin.value;
SetPlayerSkinByNum(playernum, forcedskin); SetPlayerSkinByNum(playernum, forcedskin);
// TODO: make cv_skin an array
if (playernum == consoleplayer) if (playernum == consoleplayer)
CV_StealthSet(&cv_skin, skins[forcedskin].name); CV_StealthSet(&cv_skin, skins[forcedskin].name);
else if (playernum == displayplayers[1]) else if (playernum == displayplayers[1])
@@ -1712,16 +2010,44 @@ static void Got_NameAndColor(const UINT8 **cp, INT32 playernum)
SetPlayerSkinByNum(playernum, skin); SetPlayerSkinByNum(playernum, skin);
} }
void SendWeaponPref(UINT8 splitplayer) void SendWeaponPref(void)
{ {
UINT8 buf[1]; UINT8 buf[1];
buf[0] = 0; buf[0] = 0;
if (cv_flipcam[0].value)
if (cv_flipcam[splitplayer].value)
buf[0] |= 1; buf[0] |= 1;
SendNetXCmdForPlayer(0, XD_WEAPONPREF, buf, 1);
}
SendNetXCmdForPlayer(splitplayer, XD_WEAPONPREF, buf, 1); void SendWeaponPref2(void)
{
UINT8 buf[1];
buf[0] = 0;
if (cv_flipcam[1].value)
buf[0] |= 1;
SendNetXCmdForPlayer(1, XD_WEAPONPREF, buf, 1);
}
void SendWeaponPref3(void)
{
UINT8 buf[1];
buf[0] = 0;
if (cv_flipcam[2].value)
buf[0] |= 1;
SendNetXCmdForPlayer(2, XD_WEAPONPREF, buf, 1);
}
void SendWeaponPref4(void)
{
UINT8 buf[1];
buf[0] = 0;
if (cv_flipcam[3].value)
buf[0] |= 1;
SendNetXCmdForPlayer(3, XD_WEAPONPREF, buf, 1);
} }
static void Got_WeaponPref(const UINT8 **cp, INT32 playernum) static void Got_WeaponPref(const UINT8 **cp, INT32 playernum)
@@ -1737,10 +2063,23 @@ static void Got_WeaponPref(const UINT8 **cp, INT32 playernum)
player->pflags |= PF_ANALOGMODE; player->pflags |= PF_ANALOGMODE;
} }
void D_SendPlayerConfig(UINT8 splitplayer) void D_SendPlayerConfig(void)
{ {
SendNameAndColor(splitplayer); SendNameAndColor();
SendWeaponPref(splitplayer); if (splitscreen || botingame)
SendNameAndColor2();
if (splitscreen > 1)
SendNameAndColor3();
if (splitscreen > 2)
SendNameAndColor4();
SendWeaponPref();
if (splitscreen)
SendWeaponPref2();
if (splitscreen > 1)
SendWeaponPref3();
if (splitscreen > 2)
SendWeaponPref4();
} }
// Only works for displayplayer, sorry! // Only works for displayplayer, sorry!
@@ -1763,12 +2102,10 @@ INT32 D_LookupPlayer(const char *s)
return playernum; return playernum;
} }
const size_t len = strlen(s);
for (playernum = 0; playernum < MAXPLAYERS; ++playernum) for (playernum = 0; playernum < MAXPLAYERS; ++playernum)
{ {
/* Match name case-insensitively: fully, or partially the start. */ /* Match name case-insensitively: fully, or partially the start. */
if (playeringame[playernum] && (strnicmp(player_names[playernum], s, len) == 0)) if (playeringame[playernum] && (strnicmp(player_names[playernum], s, strlen(s)) == 0))
{ {
return playernum; return playernum;
} }
@@ -1808,15 +2145,13 @@ static void GetViewablePlayerPlaceRange(INT32 *first, INT32 *last)
(*last) = 0; (*last) = 0;
for (i = 0; i < MAXPLAYERS; ++i) for (i = 0; i < MAXPLAYERS; ++i)
{
if (G_CouldView(i)) if (G_CouldView(i))
{ {
place = players[i].kartstuff[k_position]; place = players[i].kartstuff[k_position];
if (place < (*first)) if (place < (*first))
(*first) = place; (*first) = place;
if (place > (*last)) if (place > (*last))
(*last) = place; (*last) = place;
}
} }
} }
@@ -2150,7 +2485,7 @@ void D_MapChange(INT32 mapnum, INT32 newgametype, boolean pencoremode, boolean r
displayplayers[1] = 1; displayplayers[1] = 1;
playeringame[1] = true; playeringame[1] = true;
players[1].bot = 1; players[1].bot = 1;
SendNameAndColor(1); SendNameAndColor2();
} }
} }
@@ -2317,6 +2652,7 @@ static void Command_Map_f(void)
return; return;
} }
last_map_cmd = I_GetTime(); last_map_cmd = I_GetTime();
size_t first_option; size_t first_option;
@@ -2453,7 +2789,7 @@ static void Command_Map_f(void)
// G_TOLFlag handles both multiplayer gametype and ignores it for !multiplayer // G_TOLFlag handles both multiplayer gametype and ignores it for !multiplayer
else else
{ {
if (mapheaderinfo[newmapnum-1] == NULL) if (!mapheaderinfo[newmapnum-1])
{ {
CONS_Alert(CONS_WARNING, M_GetText("Invalid mapheaderinfo for Course %s (%s)\n"), realmapname, G_BuildMapName(newmapnum)); CONS_Alert(CONS_WARNING, M_GetText("Invalid mapheaderinfo for Course %s (%s)\n"), realmapname, G_BuildMapName(newmapnum));
return; return;
@@ -5427,54 +5763,50 @@ static void ForceSkin_OnChange(void)
} }
} }
// Allows the player's name to be changed if cv_mute is off. //Allows the player's name to be changed if cv_mute is off.
static void Name_OnChange(void) static void Name_OnChange(void)
{ {
if (cv_mute.value && !(server || IsPlayerAdmin(consoleplayer))) if (cv_mute.value && !(server || IsPlayerAdmin(consoleplayer)))
{ {
CONS_Alert(CONS_NOTICE, M_GetText("You may not change your name when chat is muted.\n")); CONS_Alert(CONS_NOTICE, M_GetText("You may not change your name when chat is muted.\n"));
CV_StealthSet(&cv_playername, player_names[consoleplayer]); CV_StealthSet(&cv_playername, player_names[consoleplayer]);
return;
} }
else
SendNameAndColor(0); SendNameAndColor();
} }
static void Name2_OnChange(void) static void Name2_OnChange(void)
{ {
if (cv_mute.value) // Secondary player can't be admin. if (cv_mute.value) //Secondary player can't be admin.
{ {
CONS_Alert(CONS_NOTICE, M_GetText("You may not change your name when chat is muted.\n")); CONS_Alert(CONS_NOTICE, M_GetText("You may not change your name when chat is muted.\n"));
CV_StealthSet(&cv_playername2, player_names[displayplayers[1]]); CV_StealthSet(&cv_playername2, player_names[displayplayers[1]]);
return;
} }
else
SendNameAndColor(1); SendNameAndColor2();
} }
static void Name3_OnChange(void) static void Name3_OnChange(void)
{ {
if (cv_mute.value) // Third player can't be admin. if (cv_mute.value) //Third player can't be admin.
{ {
CONS_Alert(CONS_NOTICE, M_GetText("You may not change your name when chat is muted.\n")); CONS_Alert(CONS_NOTICE, M_GetText("You may not change your name when chat is muted.\n"));
CV_StealthSet(&cv_playername3, player_names[displayplayers[2]]); CV_StealthSet(&cv_playername3, player_names[displayplayers[2]]);
return;
} }
else
SendNameAndColor(2); SendNameAndColor3();
} }
static void Name4_OnChange(void) static void Name4_OnChange(void)
{ {
if (cv_mute.value) // Secondary player can't be admin. if (cv_mute.value) //Secondary player can't be admin.
{ {
CONS_Alert(CONS_NOTICE, M_GetText("You may not change your name when chat is muted.\n")); CONS_Alert(CONS_NOTICE, M_GetText("You may not change your name when chat is muted.\n"));
CV_StealthSet(&cv_playername4, player_names[displayplayers[3]]); CV_StealthSet(&cv_playername4, player_names[displayplayers[3]]);
return;
} }
else
SendNameAndColor(3); SendNameAndColor4();
} }
/** Sends a skin change for the console player, unless that player is moving. /** Sends a skin change for the console player, unless that player is moving.
@@ -5496,7 +5828,7 @@ static void Skin_OnChange(void)
} }
if (CanChangeSkin(consoleplayer) && !P_PlayerMoving(consoleplayer)) if (CanChangeSkin(consoleplayer) && !P_PlayerMoving(consoleplayer))
SendNameAndColor(0); SendNameAndColor();
else else
{ {
CONS_Alert(CONS_NOTICE, M_GetText("You can't change your skin at the moment.\n")); CONS_Alert(CONS_NOTICE, M_GetText("You can't change your skin at the moment.\n"));
@@ -5517,7 +5849,7 @@ static void Skin2_OnChange(void)
return; // do whatever you want return; // do whatever you want
if (CanChangeSkin(displayplayers[1]) && !P_PlayerMoving(displayplayers[1])) if (CanChangeSkin(displayplayers[1]) && !P_PlayerMoving(displayplayers[1]))
SendNameAndColor(1); SendNameAndColor2();
else else
{ {
CONS_Alert(CONS_NOTICE, M_GetText("You can't change your skin at the moment.\n")); CONS_Alert(CONS_NOTICE, M_GetText("You can't change your skin at the moment.\n"));
@@ -5533,7 +5865,7 @@ static void Skin3_OnChange(void)
return; // do whatever you want return; // do whatever you want
if (CanChangeSkin(displayplayers[2]) && !P_PlayerMoving(displayplayers[2])) if (CanChangeSkin(displayplayers[2]) && !P_PlayerMoving(displayplayers[2]))
SendNameAndColor(2); SendNameAndColor3();
else else
{ {
CONS_Alert(CONS_NOTICE, M_GetText("You can't change your skin at the moment.\n")); CONS_Alert(CONS_NOTICE, M_GetText("You can't change your skin at the moment.\n"));
@@ -5549,7 +5881,7 @@ static void Skin4_OnChange(void)
return; // do whatever you want return; // do whatever you want
if (CanChangeSkin(displayplayers[3]) && !P_PlayerMoving(displayplayers[3])) if (CanChangeSkin(displayplayers[3]) && !P_PlayerMoving(displayplayers[3]))
SendNameAndColor(3); SendNameAndColor4();
else else
{ {
CONS_Alert(CONS_NOTICE, M_GetText("You can't change your skin at the moment.\n")); CONS_Alert(CONS_NOTICE, M_GetText("You can't change your skin at the moment.\n"));
@@ -5662,7 +5994,7 @@ static void Color_OnChange(void)
if (!P_PlayerMoving(consoleplayer)) if (!P_PlayerMoving(consoleplayer))
{ {
// Color change menu scrolling fix is no longer necessary // Color change menu scrolling fix is no longer necessary
SendNameAndColor(0); SendNameAndColor();
} }
else else
{ {
@@ -5684,7 +6016,7 @@ static void Color2_OnChange(void)
if (!P_PlayerMoving(displayplayers[1])) if (!P_PlayerMoving(displayplayers[1]))
{ {
// Color change menu scrolling fix is no longer necessary // Color change menu scrolling fix is no longer necessary
SendNameAndColor(1); SendNameAndColor2();
} }
else else
{ {
@@ -5701,7 +6033,7 @@ static void Color3_OnChange(void)
if (!P_PlayerMoving(displayplayers[2])) if (!P_PlayerMoving(displayplayers[2]))
{ {
// Color change menu scrolling fix is no longer necessary // Color change menu scrolling fix is no longer necessary
SendNameAndColor(2); SendNameAndColor3();
} }
else else
{ {
@@ -5718,7 +6050,7 @@ static void Color4_OnChange(void)
if (!P_PlayerMoving(displayplayers[3])) if (!P_PlayerMoving(displayplayers[3]))
{ {
// Color change menu scrolling fix is no longer necessary // Color change menu scrolling fix is no longer necessary
SendNameAndColor(3); SendNameAndColor4();
} }
else else
{ {
+10 -3
View File
@@ -21,7 +21,10 @@ extern "C" {
#include "command.h" #include "command.h"
void SendWeaponPref(UINT8 splitplayer); void SendWeaponPref(void);
void SendWeaponPref2(void);
void SendWeaponPref3(void);
void SendWeaponPref4(void);
// console vars // console vars
extern consvar_t cv_playername; extern consvar_t cv_playername;
@@ -93,6 +96,11 @@ extern consvar_t cv_pause;
extern consvar_t cv_restrictskinchange, cv_allowteamchange, cv_ingamecap, cv_respawntime; extern consvar_t cv_restrictskinchange, cv_allowteamchange, cv_ingamecap, cv_respawntime;
extern consvar_t cv_spectatorreentry, cv_antigrief; extern consvar_t cv_spectatorreentry, cv_antigrief;
/*extern consvar_t cv_teleporters, cv_superring, cv_supersneakers, cv_invincibility;
extern consvar_t cv_jumpshield, cv_watershield, cv_ringshield, cv_forceshield, cv_bombshield;
extern consvar_t cv_1up, cv_eggmanbox;
extern consvar_t cv_recycler;*/
// SRB2kart items // SRB2kart items
extern consvar_t cv_sneaker, cv_rocketsneaker, cv_invincibility, cv_banana; extern consvar_t cv_sneaker, cv_rocketsneaker, cv_invincibility, cv_banana;
extern consvar_t cv_eggmanmonitor, cv_orbinaut, cv_jawz, cv_mine; extern consvar_t cv_eggmanmonitor, cv_orbinaut, cv_jawz, cv_mine;
@@ -150,7 +158,6 @@ extern consvar_t cv_pingstyle;
//extern consvar_t cv_smallpos; //extern consvar_t cv_smallpos;
extern consvar_t cv_showminimapnames; extern consvar_t cv_showminimapnames;
extern consvar_t cv_showminimapfinished;
extern consvar_t cv_minihead; extern consvar_t cv_minihead;
extern consvar_t cv_showminimapangle; extern consvar_t cv_showminimapangle;
@@ -288,7 +295,7 @@ typedef union {
// add game commands, needs cleanup // add game commands, needs cleanup
void D_RegisterServerCommands(void); void D_RegisterServerCommands(void);
void D_RegisterClientCommands(void); void D_RegisterClientCommands(void);
void D_SendPlayerConfig(UINT8 splitplayer); void D_SendPlayerConfig(void);
void Command_ExitGame_f(void); void Command_ExitGame_f(void);
void Command_Retry_f(void); void Command_Retry_f(void);
void D_GameTypeChanged(INT32 lastgametype); // not a real _OnChange function anymore void D_GameTypeChanged(INT32 lastgametype); // not a real _OnChange function anymore
+20 -74
View File
@@ -116,8 +116,6 @@ static I_mutex downloadmutex;
#endif #endif
char downloaddir[512] = "DOWNLOAD"; char downloaddir[512] = "DOWNLOAD";
INT32 addontypes[NUMADDONTYPES] = {0};
file_download_t filedownload = {}; file_download_t filedownload = {};
#ifdef HAVE_CURL #ifdef HAVE_CURL
@@ -133,12 +131,8 @@ static UINT32 curl_origtotalfilesize;
static char *curl_realname = NULL; static char *curl_realname = NULL;
fileneeded_t *curl_curfile = NULL; fileneeded_t *curl_curfile = NULL;
HTTP_login *curl_logins = NULL; HTTP_login *curl_logins = NULL;
static void CURLGetFile(void);
#endif #endif
static addontype_t GetAddonType(const char *name);
/** Fills a serverinfo packet with information about wad files loaded. /** Fills a serverinfo packet with information about wad files loaded.
* *
* \todo Give this function a better name since it is in global scope. * \todo Give this function a better name since it is in global scope.
@@ -229,11 +223,8 @@ void D_ParseFileneeded(INT32 fileneedednum_parm, UINT8 *fileneededstr, UINT16 fi
fileneeded[i].willsend = (UINT8)(filestatus >> 4); fileneeded[i].willsend = (UINT8)(filestatus >> 4);
fileneeded[i].totalsize = READUINT32(p); // The four next bytes are the file size fileneeded[i].totalsize = READUINT32(p); // The four next bytes are the file size
fileneeded[i].file = NULL; // The file isn't open yet fileneeded[i].file = NULL; // The file isn't open yet
READSTRINGL(p, fileneeded[i].filename, MAX_WADPATH); // The next bytes are the file name READSTRINGN(p, fileneeded[i].filename, MAX_WADPATH); // The next bytes are the file name
READMEM(p, fileneeded[i].md5sum, 16); // The last 16 bytes are the file checksum READMEM(p, fileneeded[i].md5sum, 16); // The last 16 bytes are the file checksum
// Should be good place to calculate that?
fileneeded[i].type = GetAddonType(fileneeded[i].filename);
} }
} }
@@ -582,48 +573,6 @@ INT32 CL_CheckFiles(void)
return 1; //everything is FS_OPEN or FS_FOUND, proceed to loading return 1; //everything is FS_OPEN or FS_FOUND, proceed to loading
} }
static addontype_t GetAddonType(const char *name)
{
const char *prefix = strchr(name, '_');
// Doesn't have prefix (no '_' character or it is too far and is probably not for prefix but for something like version)
// KRBCL_ is longest prefix i can think of so this should be enough
if (prefix == NULL || prefix - name > 5)
return ADDON_MISC;
// Skip 'K'
if (*name == 'K')
++name;
switch (*name)
{
case 'L':
return ADDON_SCRIPT;
break;
case 'R':
case 'B':
return ADDON_MAP;
break;
case 'C':
return ADDON_CHARACTER;
break;
}
return ADDON_MISC;
}
void CL_CheckAddonTypes(void)
{
memset(&addontypes, 0, sizeof(addontypes));
for (INT32 i = 0; i < fileneedednum; i++)
{
addontypes[fileneeded[i].type]++;
}
}
// Load it now // Load it now
boolean CL_LoadServerFiles(void) boolean CL_LoadServerFiles(void)
{ {
@@ -1009,7 +958,7 @@ void Got_Filetxpak(void)
|| fastcmp(filename, "music.kart") || fastcmp(filename, "music.kart")
|| fastcmp(filename, "patch.kart") || fastcmp(filename, "patch.kart")
)) ))
I_Error("Tried to download base-game file: \"%s\"", filename); I_Error("Tried to download \"%s\"", filename);
if (filenum >= fileneedednum) if (filenum >= fileneedednum)
{ {
@@ -1068,21 +1017,21 @@ void Got_Filetxpak(void)
switch(file->status) switch(file->status)
{ {
case FS_NOTFOUND: case FS_NOTFOUND:
s = "FS_NOTFOUND"; s = "FS_NOTFOUND";
break; break;
case FS_FOUND: case FS_FOUND:
s = "FS_FOUND"; s = "FS_FOUND";
break; break;
case FS_OPEN: case FS_OPEN:
s = "FS_OPEN"; s = "FS_OPEN";
break; break;
case FS_MD5SUMBAD: case FS_MD5SUMBAD:
s = "FS_MD5SUMBAD"; s = "FS_MD5SUMBAD";
break; break;
default: default:
s = "unknown"; s = "unknown";
break; break;
} }
I_Error("Received a file not requested (file id: %d, file status: %s)\n", filenum, s); I_Error("Received a file not requested (file id: %d, file status: %s)\n", filenum, s);
@@ -1356,7 +1305,6 @@ void CURLPrepareFile(const char* url, int dfilenum)
if (!multi_handle) if (!multi_handle)
{ {
cc = curl_global_init(CURL_GLOBAL_ALL); cc = curl_global_init(CURL_GLOBAL_ALL);
if (cc < 0) if (cc < 0)
{ {
I_OutputMsg("libcurl: curl_global_init() returned %d\n", cc); I_OutputMsg("libcurl: curl_global_init() returned %d\n", cc);
@@ -1365,7 +1313,6 @@ void CURLPrepareFile(const char* url, int dfilenum)
{ {
multi_handle = curl_multi_init(); multi_handle = curl_multi_init();
} }
if (!multi_handle) if (!multi_handle)
{ {
I_OutputMsg("libcurl: curl_multi_init() failed\n"); I_OutputMsg("libcurl: curl_multi_init() failed\n");
@@ -1494,7 +1441,7 @@ void CURLAbortFile(void)
#endif #endif
} }
static void CURLGetFile(void) void CURLGetFile(void)
{ {
#ifdef HAVE_THREADS #ifdef HAVE_THREADS
I_lock_mutex(&downloadmutex); I_lock_mutex(&downloadmutex);
@@ -1536,8 +1483,7 @@ static void CURLGetFile(void)
e = m->easy_handle; e = m->easy_handle;
easyres = m->data.result; easyres = m->data.result;
char *filename = malloc(strlen(curl_realname)+1); char *filename = Z_StrDup(curl_realname);
strcpy(filename, curl_realname);
nameonly(filename); nameonly(filename);
if (easyres != CURLE_OK) if (easyres != CURLE_OK)
@@ -1575,7 +1521,7 @@ static void CURLGetFile(void)
} }
} }
free(filename); Z_Free(filename);
curl_curfile->file = NULL; curl_curfile->file = NULL;
filedownload.remaining--; filedownload.remaining--;
mc = curl_multi_remove_handle(multi_handle, e); mc = curl_multi_remove_handle(multi_handle, e);
+1 -12
View File
@@ -40,15 +40,6 @@ typedef enum
FS_FALLBACK, // HTTP failed FS_FALLBACK, // HTTP failed
} filestatus_t; } filestatus_t;
typedef enum addontype_e
{
ADDON_SCRIPT,
ADDON_MAP,
ADDON_CHARACTER,
ADDON_MISC,
NUMADDONTYPES,
} addontype_t;
typedef struct typedef struct
{ {
UINT8 willsend; // Is the server willing to send it? UINT8 willsend; // Is the server willing to send it?
@@ -60,13 +51,11 @@ typedef struct
UINT32 totalsize; UINT32 totalsize;
filestatus_t status; // The value returned by recsearch filestatus_t status; // The value returned by recsearch
boolean justdownloaded; // To prevent late fragments from causing an I_Error boolean justdownloaded; // To prevent late fragments from causing an I_Error
addontype_t type;
} fileneeded_t; } fileneeded_t;
extern INT32 fileneedednum; extern INT32 fileneedednum;
extern fileneeded_t fileneeded[MAX_WADFILES]; extern fileneeded_t fileneeded[MAX_WADFILES];
extern char downloaddir[512]; extern char downloaddir[512];
extern INT32 addontypes[NUMADDONTYPES];
typedef struct typedef struct
{ {
@@ -102,7 +91,6 @@ void D_ParseFileneeded(INT32 fileneedednum_parm, UINT8 *fileneededstr, UINT16 fi
void CL_PrepareDownloadSaveGame(const char *tmpsave); void CL_PrepareDownloadSaveGame(const char *tmpsave);
INT32 CL_CheckFiles(void); INT32 CL_CheckFiles(void);
void CL_CheckAddonTypes(void);
boolean CL_LoadServerFiles(void); boolean CL_LoadServerFiles(void);
void SV_SendRam(INT32 node, void *data, size_t size, freemethod_t freemethod, void SV_SendRam(INT32 node, void *data, size_t size, freemethod_t freemethod,
UINT8 fileid); UINT8 fileid);
@@ -131,6 +119,7 @@ size_t nameonlylength(const char *s);
#ifdef HAVE_CURL #ifdef HAVE_CURL
void CURLPrepareFile(const char* url, int dfilenum); void CURLPrepareFile(const char* url, int dfilenum);
void CURLAbortFile(void); void CURLAbortFile(void);
void CURLGetFile(void);
HTTP_login * CURLGetLogin (const char *url, HTTP_login ***return_prev_next); HTTP_login * CURLGetLogin (const char *url, HTTP_login ***return_prev_next);
size_t curlwrite_data(void *ptr, size_t size, size_t nmemb, FILE *stream); size_t curlwrite_data(void *ptr, size_t size, size_t nmemb, FILE *stream);
#endif #endif
+22 -93
View File
@@ -1,75 +1,21 @@
# Declare dedicated interface sources # Declare dedicated interface sources
set(SRB2_DEDICATED_SOURCES target_sourcefile(c)
i_system.c
i_main.c
i_video.c
i_sound.c
i_threads.c
dosstr.c
endtxt.c
)
set(SRB2_DEDICATED_HEADERS target_sources(SRB2SDL2 PRIVATE)
endtxt.h
)
source_group("Interface Code" FILES ${SRB2_DEDICATED_SOURCES} ${SRB2_DEDICATED_HEADERS})
set(SRB2_DEDICATED_TOTAL_SOURCES
${SRB2_CORE_SOURCES}
${SRB2_CORE_HEADERS}
${SRB2_PNG_SOURCES}
${SRB2_PNG_HEADERS}
${SRB2_CORE_RENDER_SOURCES}
${SRB2_CORE_GAME_SOURCES}
${SRB2_LUA_SOURCES}
${SRB2_LUA_HEADERS}
${SRB2_BLUA_SOURCES}
${SRB2_BLUA_HEADERS}
${SRB2_DEDICATED_SOURCES}
${SRB2_DEDICATED_HEADERS}
)
source_group("Main" FILES ${SRB2_CORE_SOURCES} ${SRB2_CORE_HEADERS})
source_group("Renderer" FILES ${SRB2_CORE_RENDER_SOURCES})
source_group("Game" FILES ${SRB2_CORE_GAME_SOURCES})
source_group("LUA" FILES ${SRB2_LUA_SOURCES} ${SRB2_LUA_HEADERS})
source_group("LUA\\Interpreter" FILES ${SRB2_BLUA_SOURCES} ${SRB2_BLUA_HEADERS})
if(${CMAKE_SYSTEM} MATCHES Windows) if(${CMAKE_SYSTEM} MATCHES Windows)
set(SRB2_DEDICATED_TOTAL_SOURCES ${SRB2_DEDICATED_TOTAL_SOURCES} target_sources(SRB2SDL2 PRIVATE
${CMAKE_SOURCE_DIR}/src/win32/win_dbg.c ../win32/win_dbg.c
${CMAKE_SOURCE_DIR}/src/win32/Srb2win.rc ../win32/Srb2win.rc)
)
endif() endif()
add_executable(SRB2SDL2 MACOSX_BUNDLE WIN32 ${SRB2_DEDICATED_TOTAL_SOURCES})
if(${CMAKE_SYSTEM} MATCHES Windows) if(${CMAKE_SYSTEM} MATCHES Windows)
set_target_properties(SRB2SDL2 PROPERTIES OUTPUT_NAME srb2kartd) set_target_properties(SRB2SDL2 PROPERTIES OUTPUT_NAME srb2legacy)
elseif(${CMAKE_SYSTEM} MATCHES Linux) elseif(${CMAKE_SYSTEM} MATCHES Linux)
set_target_properties(SRB2SDL2 PROPERTIES OUTPUT_NAME lsrb2kartd) set_target_properties(SRB2SDL2 PROPERTIES OUTPUT_NAME lsrb2dlegacy)
else() else()
set_target_properties(SRB2SDL2 PROPERTIES OUTPUT_NAME srb2kartd) set_target_properties(SRB2SDL2 PROPERTIES OUTPUT_NAME srb2legacy)
endif()
if(${CMAKE_SYSTEM} MATCHES Darwin)
find_library(CORE_FOUNDATION_LIBRARY "CoreFoundation")
target_link_libraries(SRB2SDL2 PRIVATE
${CORE_FOUNDATION_LIBRARY}
)
set_target_properties(SRB2SDL2 PROPERTIES OUTPUT_NAME "${CPACK_PACKAGE_DESCRIPTION_SUMMARY}")
# Configure the app bundle icon and plist properties
target_sources(SRB2SDL2 PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/macosx/Srb2mac.icns")
set_target_properties(SRB2SDL2 PROPERTIES
MACOSX_BUNDLE_ICON_FILE "Srb2mac"
MACOSX_BUNDLE_BUNDLE_NAME "Sonic Robo Blast 2"
MACOSX_BUNDLE_BUNDLE_VERSION ${SRB2_VERSION}
RESOURCE "${CMAKE_CURRENT_SOURCE_DIR}/macosx/Srb2mac.icns"
)
endif() endif()
if(${CMAKE_SYSTEM} MATCHES Darwin) if(${CMAKE_SYSTEM} MATCHES Darwin)
@@ -78,27 +24,25 @@ if(${CMAKE_SYSTEM} MATCHES Darwin)
${CORE_LIB} ${CORE_LIB}
${PNG_LIBRARIES} ${PNG_LIBRARIES}
${ZLIB_LIBRARIES} ${ZLIB_LIBRARIES}
${CURL_LIBRARIES}
) )
set_target_properties(SRB2SDL2 PROPERTIES OUTPUT_NAME "${CPACK_PACKAGE_DESCRIPTION_SUMMARY}") set_target_properties(SRB2SDL2 PROPERTIES OUTPUT_NAME "${CPACK_PACKAGE_DESCRIPTION_SUMMARY}")
else() else()
target_link_libraries(SRB2SDL2 PRIVATE target_link_libraries(SRB2SDL2 PRIVATE
${PNG_LIBRARIES} ${PNG_LIBRARIES}
${ZLIB_LIBRARIES} ${ZLIB_LIBRARIES}
${CURL_LIBRARIES}
) )
if(${CMAKE_SYSTEM} MATCHES Linux) if(${CMAKE_SYSTEM} MATCHES Linux)
target_link_libraries(SRB2SDL2 PRIVATE target_link_libraries(SRB2SDL2 PRIVATE
m m
rt rt
pthread
) )
endif() endif()
endif() endif()
if(${SRB2_HAVE_LIBBACKTRACE}) #target_link_libraries(SRB2SDL2 PRIVATE SRB2Core)
target_link_libraries(SRB2SDL2 PRIVATE ${LIBBACKTRACE_LIBRARIES})
endif() set_target_properties(SRB2SDL2 PROPERTIES VERSION ${SRB2_VERSION})
if(${CMAKE_SYSTEM} MATCHES Windows) if(${CMAKE_SYSTEM} MATCHES Windows)
target_link_libraries(SRB2SDL2 PRIVATE target_link_libraries(SRB2SDL2 PRIVATE
@@ -116,34 +60,19 @@ target_include_directories(SRB2SDL2 PRIVATE
target_compile_definitions(SRB2SDL2 PRIVATE target_compile_definitions(SRB2SDL2 PRIVATE
-DDEDICATED -DDEDICATED
-DHAVE_THREADS
) )
if(SRB2_CONFIG_LTO AND NOT SRB2_CONFIG_DEBUGMODE)
set_property(TARGET SRB2SDL2 PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
endif()
if(SRB2_CONFIG_ASAN)
target_compile_options(SRB2SDL2 PRIVATE -fsanitize=address)
target_link_options(SRB2SDL2 PRIVATE -fsanitize=address)
endif()
if(SRB2_CONFIG_UBSAN)
target_compile_options(SRB2SDL2 PRIVATE -fsanitize=undefined)
target_link_options(SRB2SDL2 PRIVATE -fsanitize=undefined)
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)
# message(STATUS "Will make separate debug symbols in *.debug") message(STATUS "Will make separate debug symbols in *.debug")
# add_custom_command(TARGET SRB2SDL2 POST_BUILD add_custom_command(TARGET SRB2SDL2 POST_BUILD
# COMMAND ${OBJCOPY} --only-keep-debug $<TARGET_FILE:SRB2SDL2> $<TARGET_FILE:SRB2SDL2>.debug COMMAND ${OBJCOPY} --only-keep-debug $<TARGET_FILE:SRB2SDL2> $<TARGET_FILE:SRB2SDL2>.debug
# COMMAND ${OBJCOPY} --strip-debug $<TARGET_FILE:SRB2SDL2> COMMAND ${OBJCOPY} --strip-debug $<TARGET_FILE:SRB2SDL2>
# COMMAND ${OBJCOPY} --add-gnu-debuglink=$<TARGET_FILE_NAME:SRB2SDL2>.debug $<TARGET_FILE:SRB2SDL2> COMMAND ${OBJCOPY} --add-gnu-debuglink=$<TARGET_FILE_NAME:SRB2SDL2>.debug $<TARGET_FILE:SRB2SDL2>
# ) )
# endif() endif()
# endif() endif()
#### Installation #### #### Installation ####
if(${CMAKE_SYSTEM} MATCHES Darwin) if(${CMAKE_SYSTEM} MATCHES Darwin)
+12 -35
View File
@@ -167,8 +167,6 @@ static char returnWadPath[256];
#include "../i_video.h" #include "../i_video.h"
#include "../i_sound.h" #include "../i_sound.h"
#include "../i_system.h" #include "../i_system.h"
#include "../i_time.h"
#include "../i_net.h"
#include "../screen.h" //vid.WndParent #include "../screen.h" //vid.WndParent
#include "../d_net.h" #include "../d_net.h"
#include "../g_game.h" #include "../g_game.h"
@@ -194,6 +192,8 @@ UINT8 keyboard_started = false;
#ifdef HAVE_TERMIOS #ifdef HAVE_TERMIOS
// TERMIOS console code from Quake3: thank you! // TERMIOS console code from Quake3: thank you!
boolean stdin_active = true;
typedef struct typedef struct
{ {
size_t cursor; size_t cursor;
@@ -695,7 +695,11 @@ void I_JoyScale4(void)
*/ */
void I_ShutdownJoystick(UINT8 index) void I_ShutdownJoystick(void)
{
}
void I_GetJoystickEvents(UINT8 index)
{ {
(void)index; (void)index;
} }
@@ -735,18 +739,6 @@ const char *I_GetJoyName(INT32 joyindex)
return NULL; return NULL;
} }
boolean I_GamepadHasLED(INT32 playernum)
{
(void)playernum;
return false;
}
boolean I_GamepadHasRumble(INT32 playernum)
{
(void)playernum;
return false;
}
void I_GamepadRumble(INT32 playernum, UINT16 low_strength, UINT16 high_strength, UINT32 duration) void I_GamepadRumble(INT32 playernum, UINT16 low_strength, UINT16 high_strength, UINT32 duration)
{ {
(void)playernum; (void)playernum;
@@ -996,7 +988,7 @@ void I_SleepDuration(precise_t duration)
#endif #endif
} }
static volatile sig_atomic_t g_in_exiting_signal_handler = false; boolean g_in_exiting_signal_handler = false;
static void I_PrintSignal(INT32 signal_num, boolean core_dumped, char *signal_msg) static void I_PrintSignal(INT32 signal_num, boolean core_dumped, char *signal_msg)
{ {
@@ -1060,11 +1052,6 @@ static void I_ReportSignal(int num, int coredumped)
I_OutputMsg("\nProcess killed by signal: %s\n\n", sigmsg); I_OutputMsg("\nProcess killed by signal: %s\n\n", sigmsg);
} }
boolean I_In_Exiting_Signal_Handler(void)
{
return g_in_exiting_signal_handler;
}
#ifndef NEWSIGNALHANDLER #ifndef NEWSIGNALHANDLER
FUNCNORETURN static ATTRNORETURN void signal_handler(INT32 num) FUNCNORETURN static ATTRNORETURN void signal_handler(INT32 num)
{ {
@@ -1084,17 +1071,11 @@ FUNCNORETURN static ATTRNORETURN void signal_handler(INT32 num)
} }
#endif #endif
static volatile sig_atomic_t interrupted = 0; FUNCNORETURN static ATTRNORETURN void quit_handler(int num)
boolean I_Interrupted(void)
{ {
return interrupted; signal(num, SIG_DFL); //default signal action
} raise(num);
I_Quit();
static void quit_handler(int num)
{
(void)num;
interrupted = 1;
} }
#ifdef HAVE_LIBBACKTRACE #ifdef HAVE_LIBBACKTRACE
@@ -1424,7 +1405,6 @@ void I_Quit(void)
/* prevent recursive I_Quit() */ /* prevent recursive I_Quit() */
if (quiting) if (quiting)
goto death; goto death;
quiting = false; quiting = false;
I_ShutdownConsole(); I_ShutdownConsole();
M_SaveConfig(NULL); //save game config, cvars.. M_SaveConfig(NULL); //save game config, cvars..
@@ -1442,17 +1422,14 @@ void I_Quit(void)
// use this for 1.28 19990220 by Kin // use this for 1.28 19990220 by Kin
I_ShutdownGraphics(); I_ShutdownGraphics();
I_ShutdownSystem(); I_ShutdownSystem();
/* if option -noendtxt is set, don't print the text */ /* if option -noendtxt is set, don't print the text */
if (!M_CheckParm("-noendtxt") && W_CheckNumForName("ENDOOM") != LUMPERROR) if (!M_CheckParm("-noendtxt") && W_CheckNumForName("ENDOOM") != LUMPERROR)
{ {
printf("\r"); printf("\r");
ShowEndTxt(); ShowEndTxt();
} }
if (myargmalloc) if (myargmalloc)
free(myargv); // Deallocate allocated memory free(myargv); // Deallocate allocated memory
death: death:
W_Shutdown(); W_Shutdown();
exit(0); exit(0);
+287 -209
View File
File diff suppressed because it is too large. Load diff
-9
View File
@@ -13,10 +13,6 @@
#ifndef __DEHACKED_H__ #ifndef __DEHACKED_H__
#define __DEHACKED_H__ #define __DEHACKED_H__
#ifdef __cplusplus
extern "C" {
#endif
#include "m_fixed.h" // for get_number #include "m_fixed.h" // for get_number
#include "info.h" #include "info.h"
@@ -75,9 +71,4 @@ typedef struct
} MYFILE; } MYFILE;
#define myfeof(a) (a->data + a->size <= a->curpos) #define myfeof(a) (a->data + a->size <= a->curpos)
char *myfgets(char *buf, size_t bufsize, MYFILE *f); char *myfgets(char *buf, size_t bufsize, MYFILE *f);
#ifdef __cplusplus
} // extern "C"
#endif
#endif #endif
+1 -1
View File
@@ -61,7 +61,7 @@ enum
typedef struct typedef struct
{ {
INT16 x, y; INT16 x, y;
} ATTRPACK mapvertex_t; }ATTRPACK mapvertex_t;
// A SideDef, defining the visual appearance of a wall, // A SideDef, defining the visual appearance of a wall,
// by setting textures and offsets. // by setting textures and offsets.
+27 -41
View File
@@ -40,47 +40,24 @@
#define ASMCALL #define ASMCALL
#endif #endif
#include "doomtype.h" #define _USE_MATH_DEFINES // fixes M_PI errors in r_plane.c for Visual Studio
#ifdef __cplusplus
#ifdef __cplusplus /* Only when compiled as C++ */ #include <cmath>
#include <algorithm> /* std::min, std::max, std::sort, … */ #else
#include <math.h>
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
// Force libc++ to expose std::min/std::max even when <cmath> is included first (Apple clang quirk)
#ifndef _LIBCPP_ENABLE_CXX17_REMOVED_FEATURES
#define _LIBCPP_ENABLE_CXX17_REMOVED_FEATURES
#endif
#ifndef _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS
#define _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS
#endif
// Optional: only try <version> if it actually exists (newer Xcode)
#if __has_include(<version>)
#include <version>
#endif
#define _USE_MATH_DEFINES
#include <cmath>
#include <cstdarg>
#include <cstdio>
#include <cstdlib>
#include <cstddef>
#include <cstring>
#include <climits>
extern "C" { extern "C" {
#else #endif
#include <math.h>
#include "doomtype.h"
#include <stdarg.h> #include <stdarg.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <stddef.h>
#include <string.h> #include <string.h>
#include <limits.h>
#endif
#include <sys/types.h> #include <sys/types.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <ctype.h> #include <ctype.h>
@@ -130,8 +107,8 @@ extern char logfilename[1024];
#else #else
#define VERSION 1 // Game version #define VERSION 1 // Game version
#define SUBVERSION 6 // more precise version number #define SUBVERSION 6 // more precise version number
#define VERSIONSTRING "Saturn v9.3" #define VERSIONSTRING "Saturn v9.2"
#define VERSIONSTRINGW L"Saturn v9.3" #define VERSIONSTRINGW L"Saturn v9.2"
#define SATURN_TESTING // comment out for saturn release builds! #define SATURN_TESTING // comment out for saturn release builds!
@@ -516,6 +493,22 @@ extern boolean capslock;
// i_system.c, replace getchar() once the keyboard has been appropriated // i_system.c, replace getchar() once the keyboard has been appropriated
INT32 I_GetKey(void); INT32 I_GetKey(void);
/* http://www.cse.yorku.ca/~oz/hash.html */
static inline
UINT32 quickncasehash (const char *p, size_t n)
{
size_t i = 0;
UINT32 x = 5381;
while (i < n && p[i])
{
x = (x * 33) ^ tolower(p[i]);
i++;
}
return x;
}
#ifndef __cplusplus #ifndef __cplusplus
#ifndef min // Double-Check with WATTCP-32's cdefs.h #ifndef min // Double-Check with WATTCP-32's cdefs.h
#define min(x, y) (((x) < (y)) ? (x) : (y)) #define min(x, y) (((x) < (y)) ? (x) : (y))
@@ -573,13 +566,6 @@ INT32 I_GetKey(void);
// NOTE: you WILL have nasal troubles if the variable is not initialized // NOTE: you WILL have nasal troubles if the variable is not initialized
#define CLEANUP(f) __attribute__((__cleanup__(f))) #define CLEANUP(f) __attribute__((__cleanup__(f)))
// the GNU constructor and destructor attributes
// The constructor attribute causes the function to be called automatically before execution enters main ().
// Similarly, the destructor attribute causes the function to be called automatically after main () has completed or exit () has been called.
// Functions with these attributes are useful for initializing data that will be used implicitly during the execution of the program.
#define CONSTRUCTOR __attribute__((constructor, used))
#define DESTRUCTOR __attribute__((destructor, used))
// An assert-type mechanism. // An assert-type mechanism.
#ifdef PARANOIA #ifdef PARANOIA
#define I_Assert(e) ((e) ? (void)0 : I_Error("assert failed: %s, file %s, line %d", #e, __FILE__, __LINE__)) #define I_Assert(e) ((e) ? (void)0 : I_Error("assert failed: %s, file %s, line %d", #e, __FILE__, __LINE__))
+46 -3
View File
@@ -54,6 +54,7 @@ extern INT16 maptol;
extern UINT8 globalweather; extern UINT8 globalweather;
extern INT32 curWeather; extern INT32 curWeather;
extern INT32 cursaveslot; extern INT32 cursaveslot;
extern INT16 lastmapsaved;
extern boolean gamecomplete; extern boolean gamecomplete;
#define PRECIP_NONE 0 #define PRECIP_NONE 0
@@ -77,6 +78,7 @@ extern boolean imcontinuing; // Temporary flag while continuing
extern UINT8 modeattacking; extern UINT8 modeattacking;
// menu demo things // menu demo things
extern UINT8 numDemos;
extern UINT32 demoDelayTime; extern UINT32 demoDelayTime;
extern UINT32 demoIdleTime; extern UINT32 demoIdleTime;
@@ -112,6 +114,7 @@ extern UINT8 paused; // Game paused?
extern UINT8 window_notinfocus; // are we in focus? (backend independant -- handles auto pausing and display of "focus lost" message) extern UINT8 window_notinfocus; // are we in focus? (backend independant -- handles auto pausing and display of "focus lost" message)
extern boolean nodrawers; extern boolean nodrawers;
extern boolean noblit;
extern boolean lastdraw; extern boolean lastdraw;
#ifdef MOTIONBLUR #ifdef MOTIONBLUR
@@ -202,6 +205,12 @@ extern struct quake
fixed_t radius, intensity; fixed_t radius, intensity;
} quake; } quake;
// NiGHTS grades
typedef struct
{
UINT32 grade[6]; // D, C, B, A, S, X (F: failed to reach any of these)
} nightsgrades_t;
// Custom Lua values // Custom Lua values
// (This is not ifdeffed so the map header structure can stay identical, just in case.) // (This is not ifdeffed so the map header structure can stay identical, just in case.)
typedef struct typedef struct
@@ -252,16 +261,28 @@ typedef struct
UINT8 numlaps; ///< Number of laps in circuit mode, unless overridden. UINT8 numlaps; ///< Number of laps in circuit mode, unless overridden.
SINT8 unlockrequired; ///< Is an unlockable required to play this level? -1 if no. SINT8 unlockrequired; ///< Is an unlockable required to play this level? -1 if no.
UINT8 levelselect; ///< Is this map available in the level select? If so, which map list is it available in? UINT8 levelselect; ///< Is this map available in the level select? If so, which map list is it available in?
SINT8 bonustype; ///< What type of bonus does this level have? (-1 for null.)
SINT8 saveoverride; ///< Set how the game is allowed to save (1 for always, -1 for never, 0 is 2.1 default)
UINT8 levelflags; ///< LF_flags: merged eight booleans into one UINT8 for space, see below UINT8 levelflags; ///< LF_flags: merged eight booleans into one UINT8 for space, see below
UINT8 menuflags; ///< LF2_flags: options that affect record attack / nights mode menus UINT8 menuflags; ///< LF2_flags: options that affect record attack / nights mode menus
// NiGHTS stuff.
UINT8 numGradedMares; ///< Internal. For grade support.
nightsgrades_t *grades; ///< NiGHTS grades. Allocated dynamically for space reasons. Be careful.
// SRB2kart // SRB2kart
//boolean automap; ///< Displays a level's white map outline in modified games
fixed_t mobj_scale; ///< Replacement for TOL_ERZ3 fixed_t mobj_scale; ///< Replacement for TOL_ERZ3
mapheader_lighting_t lighting; ///< Wall and sprite lighting mapheader_lighting_t lighting; ///< Wall and sprite lighting
mapheader_lighting_t lighting_encore; ///< Alternative lighting for Encore mode mapheader_lighting_t lighting_encore; ///< Alternative lighting for Encore mode
boolean use_encore_lighting; ///< Whether to use separate Encore lighting boolean use_encore_lighting; ///< Whether to use separate Encore lighting
// Music stuff.
UINT32 musinterfadeout; ///< Fade out level music on intermission screen in milliseconds
char musintername[7]; ///< Intermission screen music.
// Lua stuff. // Lua stuff.
// (This is not ifdeffed so the map header structure can stay identical, just in case.) // (This is not ifdeffed so the map header structure can stay identical, just in case.)
UINT8 numCustomOptions; ///< Internal. For Lua custom value support. UINT8 numCustomOptions; ///< Internal. For Lua custom value support.
@@ -358,6 +379,8 @@ typedef struct
{ {
tic_t time; ///< Time in which the level was finished. tic_t time; ///< Time in which the level was finished.
tic_t lap; ///< Best lap time for this level. tic_t lap; ///< Best lap time for this level.
//UINT32 score; ///< Score when the level was finished.
//UINT16 rings; ///< Rings when the level was finished.
} recorddata_t; } recorddata_t;
/** Setup for one NiGHTS map. /** Setup for one NiGHTS map.
@@ -371,19 +394,34 @@ typedef struct
#define GRADE_A 5 #define GRADE_A 5
#define GRADE_S 6 #define GRADE_S 6
/*typedef struct
{
// 8 mares, 1 overall (0)
UINT8 nummares;
UINT32 score[9];
UINT8 grade[9];
tic_t time[9];
} nightsdata_t;*/
//extern nightsdata_t *nightsrecords[NUMMAPS];
extern recorddata_t *mainrecords[NUMMAPS]; extern recorddata_t *mainrecords[NUMMAPS];
// mapvisited is now a set of flags that says what we've done in the map. // mapvisited is now a set of flags that says what we've done in the map.
#define MV_VISITED 1 #define MV_VISITED 1
#define MV_BEATEN 2 #define MV_BEATEN 2
#define MV_ALLEMERALDS 4 #define MV_ALLEMERALDS 4
//#define MV_ULTIMATE 8
//#define MV_PERFECT 16
#define MV_MAX 7 // used in gamedata check #define MV_MAX 7 // used in gamedata check
extern UINT8 mapvisited[NUMMAPS]; extern UINT8 mapvisited[NUMMAPS];
extern UINT32 token; ///< Number of tokens collected in a level // Temporary holding place for nights data for the current map
//nightsdata_t ntemprecords;
extern UINT32 token; ///< Number of tokens collected in a level
extern UINT32 tokenlist; ///< List of tokens collected extern UINT32 tokenlist; ///< List of tokens collected
extern INT32 tokenbits; ///< Used for setting token bits extern INT32 tokenbits; ///< Used for setting token bits
extern INT32 sstimer; ///< Time allotted in the special stage extern INT32 sstimer; ///< Time allotted in the special stage
extern UINT32 bluescore; ///< Blue Team Scores extern UINT32 bluescore; ///< Blue Team Scores
extern UINT32 redscore; ///< Red Team Scores extern UINT32 redscore; ///< Red Team Scores
@@ -399,6 +437,9 @@ extern boolean CheckForReverseGravity;
extern UINT16 invulntics; extern UINT16 invulntics;
extern UINT16 sneakertics; extern UINT16 sneakertics;
extern UINT16 flashingtics; extern UINT16 flashingtics;
extern UINT16 tailsflytics;
extern UINT16 underwatertics;
extern UINT16 spacetimetics;
extern UINT16 extralifetics; extern UINT16 extralifetics;
// SRB2kart // SRB2kart
@@ -420,6 +461,7 @@ extern UINT8 introtoplay;
extern UINT8 creditscutscene; extern UINT8 creditscutscene;
extern UINT8 use1upSound; extern UINT8 use1upSound;
extern UINT8 maxXtraLife; // Max extra lives from rings
extern mobj_t *hunt1, *hunt2, *hunt3; // Emerald hunt locations extern mobj_t *hunt1, *hunt2, *hunt3; // Emerald hunt locations
@@ -484,6 +526,7 @@ extern UINT32 timesBeatenWithEmeralds;
// WAD, partly set at startup time. // WAD, partly set at startup time.
extern tic_t gametic; extern tic_t gametic;
#define localgametic leveltime
// Player spawn spots. // Player spawn spots.
extern mapthing_t *playerstarts[MAXPLAYERS]; // Cooperative extern mapthing_t *playerstarts[MAXPLAYERS]; // Cooperative
+5 -16
View File
@@ -68,21 +68,8 @@ extern "C" {
#define strnicmp(x,y,n) strncasecmp(x,y,n) #define strnicmp(x,y,n) strncasecmp(x,y,n)
#endif #endif
// glibc 2.43 made alot of standard lib functions propagate the constness of its input pointers
// to not cause warnings or compile issues on older glibc versions we do this silly thing
// to not have a gazillion glibc version checks
#if defined(__GLIBC_PREREQ)
#if __GLIBC_PREREQ(2, 43)
#define gconst const
#else
#define gconst
#endif
#else
#define gconst
#endif
#ifndef _GNU_SOURCE
char *nongnu_strcasestr(const char *in, const char *what); char *nongnu_strcasestr(const char *in, const char *what);
#ifndef _GNU_SOURCE
#define strcasestr nongnu_strcasestr #define strcasestr nongnu_strcasestr
#endif #endif
@@ -140,9 +127,9 @@ size_t strlcpy(char *dst, const char *src, size_t dsize);
#define STRBUFCPY(dst,src) strlcpy(dst, src, sizeof dst) #define STRBUFCPY(dst,src) strlcpy(dst, src, sizeof dst)
/* Boolean type definition */ /* Boolean type definition */
#include <stdbool.h>
#ifndef _WIN32 #ifndef _WIN32
#include <stdbool.h>
// dont use stdbools _BOOL type // dont use stdbools _BOOL type
// its smaller (1 byte) than the old interger bool (4 bytes) // its smaller (1 byte) than the old interger bool (4 bytes)
// which results in packed struct sizes being mismatched between vanilla and this // which results in packed struct sizes being mismatched between vanilla and this
@@ -150,7 +137,9 @@ size_t strlcpy(char *dst, const char *src, size_t dsize);
// which we cant use as enumeration constants // which we cant use as enumeration constants
typedef int32_t boolean; typedef int32_t boolean;
#else #else
#define boolean int32_t #define false FALSE
#define true TRUE
#define boolean BOOL
#endif #endif
/* 7.18.2.1 Limits of exact-width integer types */ /* 7.18.2.1 Limits of exact-width integer types */
+12 -2
View File
@@ -1110,6 +1110,14 @@ void F_TitleScreenTicker(boolean run)
return; return;
} }
// Replay intro when done cycling through demos
/*if (curDemo == numDemos) -- uuuh... we have a LOT of maps AND a big devteam... probably not gonna see a repeat unless you're super unlucky :V
{
curDemo = 0;
F_StartIntro();
return;
}*/
mapname = G_BuildMapName(G_RandMap(TOL_RACE, -2, false, 0, false, NULL)+1); mapname = G_BuildMapName(G_RandMap(TOL_RACE, -2, false, 0, false, NULL)+1);
numstaff = 1; numstaff = 1;
@@ -1164,7 +1172,9 @@ void F_StartWaitingPlayers(void)
randskin = M_RandomKey(numskins); randskin = M_RandomKey(numskins);
boolean waithires = skins[randskin].flags && SF_HIRES; boolean waithires = skins[randskin].flags && SF_HIRES;
Z_Free(waitcolormap); if (waitcolormap)
Z_Free(waitcolormap);
waitcolormap = R_GetTranslationColormap(randskin, skins[randskin].prefcolor, 0); waitcolormap = R_GetTranslationColormap(randskin, skins[randskin].prefcolor, 0);
if (waithires) if (waithires)
@@ -1308,7 +1318,7 @@ boolean F_ContinueResponder(event_t *event)
keypressed = true; keypressed = true;
imcontinuing = true; imcontinuing = true;
continuetime = TICRATE; continuetime = TICRATE;
S_StartSound(NULL, sfx_itemup); S_StartSound(0, sfx_itemup);
return true; return true;
} }
-5
View File
@@ -361,11 +361,6 @@ void F_RunWipe(UINT8 wipetype, boolean drawMenu)
// on for fade-to-black // on for fade-to-black
for (;;) for (;;)
{ {
if (I_Interrupted())
{
I_Quit();
}
// get fademask first so we can tell if it exists or not // get fademask first so we can tell if it exists or not
fmask = F_GetFadeMask(wipetype, wipeframe++); fmask = F_GetFadeMask(wipetype, wipeframe++);
+11 -14
View File
@@ -49,7 +49,7 @@ size_t menupathindex[menudepth] = {};
size_t menudepthleft = menudepth; size_t menudepthleft = menudepth;
char menusearchbuf[MAXSTRINGLENGTH+1]; char menusearchbuf[MAXSTRINGLENGTH+1];
textinput_t menusearch = {}; textinput_t menusearch;
char **dirmenu = NULL, **coredirmenu = NULL; // core only local for this file char **dirmenu = NULL, **coredirmenu = NULL; // core only local for this file
size_t sizedirmenu = 0, sizecoredirmenu = 0; // ditto size_t sizedirmenu = 0, sizecoredirmenu = 0; // ditto
@@ -111,12 +111,10 @@ filestatus_t filesearch(char *filename, const char *startpath, const UINT8 *want
char *searchname; char *searchname;
int depthleft = maxsearchdepth; int depthleft = maxsearchdepth;
char searchpath[MAXFILEPATH]; char searchpath[MAXFILEPATH];
size_t *searchpathindex = NULL; size_t *searchpathindex;
dirhandle = (DIR**)malloc(maxsearchdepth * sizeof(DIR*)); dirhandle = (DIR**)malloc(maxsearchdepth * sizeof(DIR*));
searchpathindex = (size_t *)malloc(maxsearchdepth * sizeof(size_t)); searchpathindex = (size_t *)malloc(maxsearchdepth * sizeof(size_t));
if (!searchpathindex)
I_Error("out of memory while searching for file %s\n", filename);
strcpy(searchpath, startpath); strcpy(searchpath, startpath);
searchpathindex[--depthleft] = strlen(searchpath) + 1; searchpathindex[--depthleft] = strlen(searchpath) + 1;
@@ -273,13 +271,10 @@ static boolean filemenucmp(char *haystack, char *needle)
{ {
static char localhaystack[128]; static char localhaystack[128];
strlcpy(localhaystack, haystack, 128); strlcpy(localhaystack, haystack, 128);
if (!cv_addons_search_case.value) if (!cv_addons_search_case.value)
strupr(localhaystack); strupr(localhaystack);
if (cv_addons_search_type.value) if (cv_addons_search_type.value)
return (strstr(localhaystack, needle) != NULL); return (strstr(localhaystack, needle) != 0);
return (!strncmp(localhaystack, needle, menusearch.length)); return (!strncmp(localhaystack, needle, menusearch.length));
} }
@@ -319,7 +314,8 @@ void closefilemenu(boolean validsize)
coredirmenu = NULL; coredirmenu = NULL;
} }
Z_Free(refreshdirname); if (refreshdirname)
Z_Free(refreshdirname);
refreshdirname = NULL; refreshdirname = NULL;
} }
@@ -347,7 +343,8 @@ void searchfilemenu(char *tempname)
if (!menusearch.length) if (!menusearch.length)
{ {
Z_Free(dirmenu); if (dirmenu)
Z_Free(dirmenu);
dirmenu = coredirmenu; dirmenu = coredirmenu;
sizedirmenu = sizecoredirmenu; sizedirmenu = sizecoredirmenu;
@@ -389,8 +386,8 @@ void searchfilemenu(char *tempname)
I_Error("searchfilemenu(): could not create \"No results...\"."); I_Error("searchfilemenu(): could not create \"No results...\".");
sizedirmenu = 1; sizedirmenu = 1;
dir_on[menudepthleft] = 0; dir_on[menudepthleft] = 0;
Z_Free(tempname); if (tempname)
Z_Free(tempname);
return; return;
} }
@@ -505,8 +502,8 @@ boolean preparefilemenu(boolean samedepth, boolean replayhut)
{ {
closedir(dirhandle); closedir(dirhandle);
closefilemenu(false); closefilemenu(false);
Z_Free(tempname); if (tempname)
Z_Free(tempname);
return false; return false;
} }
+44 -38
View File
@@ -66,15 +66,17 @@
#include <locale.h> #include <locale.h>
// menu demo things // menu demo things
UINT8 numDemos = 0; //3; -- i'm FED UP of losing my skincolour to a broken demo. change this back when we make new ones
UINT32 demoDelayTime = 15*TICRATE; UINT32 demoDelayTime = 15*TICRATE;
UINT32 demoIdleTime = 3*TICRATE; UINT32 demoIdleTime = 3*TICRATE;
boolean nodrawers = false; // for comparative timing purposes boolean nodrawers = false; // for comparative timing purposes
boolean noblit = false; // for comparative timing purposes
static tic_t demostarttime; // for comparative timing purposes static tic_t demostarttime; // for comparative timing purposes
//@TODO put these all in a struct for namespacing purposes? //@TODO put these all in a struct for namespacing purposes?
static char demoname[128]; static char demoname[128];
savebuffer_t demobuf = {}; savebuffer_t demobuf = {0};
static UINT8 *demotime_p, *demoinfo_p; static UINT8 *demotime_p, *demoinfo_p;
static UINT8 *demoend; static UINT8 *demoend;
static UINT8 demoflags; static UINT8 demoflags;
@@ -1651,12 +1653,10 @@ void G_RecordDemo(const char *name)
maxsize = cv_maxdemosize.value*1024*1024; maxsize = cv_maxdemosize.value*1024*1024;
demobuf.buffer = Z_Malloc(maxsize + 100*1024, PU_STATIC, NULL); demobuf.buffer = Z_Malloc(maxsize + 100*1024, PU_STATIC, NULL);
demoend = demobuf.buffer + maxsize;
if (demobuf.buffer) if (demobuf.buffer)
{
demoend = demobuf.buffer + maxsize;
demo.recording = true; demo.recording = true;
}
else else
CONS_Alert(CONS_ERROR, "Failed to allocate demo buffer\n"); CONS_Alert(CONS_ERROR, "Failed to allocate demo buffer\n");
} }
@@ -1994,6 +1994,7 @@ static UINT8 G_CheckDemoExtraFiles(UINT8 **pp, boolean quick)
UINT8 totalfiles, filesloaded, nmusfilecount; UINT8 totalfiles, filesloaded, nmusfilecount;
char filename[MAX_WADPATH]; char filename[MAX_WADPATH];
UINT8 md5sum[16]; UINT8 md5sum[16];
boolean toomany = false;
boolean alreadyloaded; boolean alreadyloaded;
UINT8 i, j; UINT8 i, j;
UINT8 error = 0; UINT8 error = 0;
@@ -2003,44 +2004,53 @@ static UINT8 G_CheckDemoExtraFiles(UINT8 **pp, boolean quick)
for (i = 0; i < totalfiles; ++i) for (i = 0; i < totalfiles; ++i)
{ {
strlcpy(filename, (char *)(*pp), sizeof filename); if (toomany)
SKIPSTRING((*pp)); SKIPSTRING((*pp));
else
{
strlcpy(filename, (char *)(*pp), sizeof filename);
SKIPSTRING((*pp));
}
READMEM((*pp), md5sum, 16); // hue hue peepee READMEM((*pp), md5sum, 16); // hue hue peepee
alreadyloaded = false; if (!toomany)
nmusfilecount = 0;
for (j = 0; j < numwadfiles; ++j)
{ {
if (wadfiles[j]->important && j > mainwads) alreadyloaded = false;
nmusfilecount++; nmusfilecount = 0;
else
continue;
if (memcmp(md5sum, wadfiles[j]->md5sum, 16) == 0) for (j = 0; j < numwadfiles; ++j)
{ {
alreadyloaded = true; if (wadfiles[j]->important && j > mainwads)
nmusfilecount++;
else
continue;
if (i != nmusfilecount-1 && error < DFILE_ERROR_OUTOFORDER) if (memcmp(md5sum, wadfiles[j]->md5sum, 16) == 0)
error |= DFILE_ERROR_OUTOFORDER; {
alreadyloaded = true;
break; if (i != nmusfilecount-1 && error < DFILE_ERROR_OUTOFORDER)
error |= DFILE_ERROR_OUTOFORDER;
break;
}
} }
}
if (alreadyloaded) if (alreadyloaded)
{ {
filesloaded++; filesloaded++;
continue; continue;
} }
if (numwadfiles >= MAX_WADFILES) if (numwadfiles >= MAX_WADFILES)
error = DFILE_ERROR_CANNOTLOAD;
else if (!quick && findfile(filename, md5sum, false) != FS_FOUND)
error = DFILE_ERROR_CANNOTLOAD;
else if (error < DFILE_ERROR_INCOMPLETEOUTOFORDER)
error |= DFILE_ERROR_NOTLOADED;
} else
error = DFILE_ERROR_CANNOTLOAD; error = DFILE_ERROR_CANNOTLOAD;
else if (!quick && findfile(filename, md5sum, false) != FS_FOUND)
error = DFILE_ERROR_CANNOTLOAD;
else if (error < DFILE_ERROR_INCOMPLETEOUTOFORDER)
error |= DFILE_ERROR_NOTLOADED;
} }
// Get final file count // Get final file count
@@ -2595,7 +2605,7 @@ void G_DoPlayDemo(char *defdemoname)
boolean skiperrors = false; boolean skiperrors = false;
#endif #endif
boolean spectator; boolean spectator;
UINT8 slots[MAXPLAYERS] = {}, kartspeed[MAXPLAYERS] = {}, kartweight[MAXPLAYERS] = {}, numslots = 0; UINT8 slots[MAXPLAYERS], kartspeed[MAXPLAYERS], kartweight[MAXPLAYERS], numslots = 0;
G_InitDemoRewind(); G_InitDemoRewind();
@@ -2606,7 +2616,7 @@ void G_DoPlayDemo(char *defdemoname)
if (defdemoname == NULL) if (defdemoname == NULL)
{ {
demobuf.p = demobuf.buffer; demobuf.p = demobuf.buffer;
pdemoname = ZZ_Calloc(1); // Easier than adding checks for this everywhere it's freed pdemoname = ZZ_Alloc(1); // Easier than adding checks for this everywhere it's freed
} }
else else
{ {
@@ -2618,7 +2628,7 @@ void G_DoPlayDemo(char *defdemoname)
n++; n++;
pdemoname = ZZ_Alloc(strlen(n)+1); pdemoname = ZZ_Alloc(strlen(n)+1);
strcpy(pdemoname, n); strcpy(pdemoname,n);
M_SetPlaybackMenuPointer(); M_SetPlaybackMenuPointer();
@@ -3080,9 +3090,6 @@ post_compat:
if (cv_director.value) if (cv_director.value)
CV_SetValue(&cv_director, 0); CV_SetValue(&cv_director, 0);
if (demo.timing)
G_DoneLevelLoad();
demo.deferstart = true; demo.deferstart = true;
} }
#undef SKIPERRORS #undef SKIPERRORS
@@ -3510,11 +3517,10 @@ static INT32 restorecv_vidwait;
void G_TimeDemo(const char *name) void G_TimeDemo(const char *name)
{ {
nodrawers = M_CheckParm("-nodraw"); nodrawers = M_CheckParm("-nodraw");
noblit = M_CheckParm("-noblit");
restorecv_vidwait = cv_vidwait.value; restorecv_vidwait = cv_vidwait.value;
if (cv_vidwait.value) if (cv_vidwait.value)
CV_Set(&cv_vidwait, "0"); CV_Set(&cv_vidwait, "0");
demo.timing = true; demo.timing = true;
singletics = true; singletics = true;
framecount = 0; framecount = 0;
+49 -21
View File
@@ -61,6 +61,7 @@
gameaction_t gameaction = 0; gameaction_t gameaction = 0;
gamestate_t gamestate = GS_NULL; gamestate_t gamestate = GS_NULL;
UINT8 ultimatemode = false;
boolean botingame = false; boolean botingame = false;
UINT8 botskin = 0; UINT8 botskin = 0;
@@ -68,6 +69,9 @@ UINT8 botcolor = 0;
JoyType_t Joystick[MAXSPLITSCREENPLAYERS] = {}; JoyType_t Joystick[MAXSPLITSCREENPLAYERS] = {};
// 1024 bytes is plenty for a savegame
#define SAVEGAMESIZE (1024)
// SRB2kart // SRB2kart
char gamedatafilename[64] = "kartdata.dat"; char gamedatafilename[64] = "kartdata.dat";
char timeattackfolder[64] = "kart"; char timeattackfolder[64] = "kart";
@@ -86,6 +90,7 @@ INT16 maptol = 0;
UINT8 globalweather = 0; UINT8 globalweather = 0;
INT32 curWeather = PRECIP_NONE; INT32 curWeather = PRECIP_NONE;
INT32 cursaveslot = -1; // Auto-save 1p savegame slot INT32 cursaveslot = -1; // Auto-save 1p savegame slot
INT16 lastmapsaved = 0; // Last map we auto-saved at
boolean gamecomplete = false; boolean gamecomplete = false;
UINT16 mainwads = 0; UINT16 mainwads = 0;
@@ -95,6 +100,7 @@ boolean savemoddata = false;
UINT8 paused = 0; UINT8 paused = 0;
UINT8 modeattacking = ATTACKING_NONE; UINT8 modeattacking = ATTACKING_NONE;
boolean imcontinuing = false; boolean imcontinuing = false;
boolean runemeraldmanager = false;
boolean netgame = false; // only true if packets are broadcast boolean netgame = false; // only true if packets are broadcast
boolean multiplayer = false; boolean multiplayer = false;
@@ -106,6 +112,7 @@ INT32 consoleplayer = 0; // player taking events and displaying
INT32 displayplayers[MAXSPLITSCREENPLAYERS] = {}; // view being displayed INT32 displayplayers[MAXSPLITSCREENPLAYERS] = {}; // view being displayed
tic_t gametic = 0; tic_t gametic = 0;
tic_t levelstarttic = 0; // gametic at level start
UINT32 totalrings = 0; // for intermission UINT32 totalrings = 0; // for intermission
INT16 lastmap = 0; // last level you were at (returning from special stages) INT16 lastmap = 0; // last level you were at (returning from special stages)
tic_t timeinmap = 0; // Ticker for time spent in level (used for levelcard display) tic_t timeinmap = 0; // Ticker for time spent in level (used for levelcard display)
@@ -125,7 +132,7 @@ UINT8 skincolor_bluering = SKINCOLOR_STEEL;
tic_t countdowntimer = 0; tic_t countdowntimer = 0;
boolean countdowntimeup = false; boolean countdowntimeup = false;
cutscene_t *cutscenes[128] = {}; cutscene_t *cutscenes[128];
INT16 nextmapoverride = 0; INT16 nextmapoverride = 0;
boolean skipstats = false; boolean skipstats = false;
@@ -137,7 +144,7 @@ mobj_t *blueflag = NULL;
mapthing_t *rflagpoint = NULL; mapthing_t *rflagpoint = NULL;
mapthing_t *bflagpoint = NULL; mapthing_t *bflagpoint = NULL;
struct quake quake = {}; struct quake quake;
// Map Header Information // Map Header Information
mapheader_t* mapheaderinfo[NUMMAPS] = {}; mapheader_t* mapheaderinfo[NUMMAPS] = {};
@@ -183,6 +190,9 @@ boolean CheckForReverseGravity = false;
UINT16 invulntics = 20*TICRATE; UINT16 invulntics = 20*TICRATE;
UINT16 sneakertics = 20*TICRATE; UINT16 sneakertics = 20*TICRATE;
UINT16 flashingtics = 3*TICRATE/2; // SRB2kart UINT16 flashingtics = 3*TICRATE/2; // SRB2kart
UINT16 tailsflytics = 8*TICRATE;
UINT16 underwatertics = 30*TICRATE;
UINT16 spacetimetics = 11*TICRATE + (TICRATE/2);
UINT16 extralifetics = 4*TICRATE; UINT16 extralifetics = 4*TICRATE;
// SRB2kart // SRB2kart
@@ -200,7 +210,10 @@ const INT32 wipeoutslowtime = 20;
const INT32 wantedreduce = 5*TICRATE; const INT32 wantedreduce = 5*TICRATE;
const INT32 wantedfrequency = 10*TICRATE; const INT32 wantedfrequency = 10*TICRATE;
INT32 gameovertics = 15*TICRATE;
UINT8 use1upSound = 0; UINT8 use1upSound = 0;
UINT8 maxXtraLife = 2; // Max extra lives from rings
UINT8 introtoplay = 0; UINT8 introtoplay = 0;
UINT8 creditscutscene = 0; UINT8 creditscutscene = 0;
@@ -215,7 +228,7 @@ tic_t racecountdown = 0, exitcountdown = 0; // for racing
fixed_t gravity = 0; fixed_t gravity = 0;
fixed_t mapobjectscale = FRACUNIT; fixed_t mapobjectscale = FRACUNIT;
struct maplighting maplighting = {}; struct maplighting maplighting;
INT16 autobalance = 0; //for CTF team balance INT16 autobalance = 0; //for CTF team balance
INT16 teamscramble = 0; //for CTF team scramble INT16 teamscramble = 0; //for CTF team scramble
@@ -443,10 +456,10 @@ consvar_t cv_litesteer[MAXSPLITSCREENPLAYERS] = {
//static CV_PossibleValue_t autoaccelcons_t[] = {{0, "Off"}, {1, "Manual"}, {2, "Automatic"}, {0, NULL}}; //static CV_PossibleValue_t autoaccelcons_t[] = {{0, "Off"}, {1, "Manual"}, {2, "Automatic"}, {0, NULL}};
consvar_t cv_autoaccel[MAXSPLITSCREENPLAYERS] = { consvar_t cv_autoaccel[MAXSPLITSCREENPLAYERS] = {
{"kartautoaccel", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}, {"autoaccel", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL},
{"kartautoaccel2", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}, {"autoaccel2", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL},
{"kartautoaccel3", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}, {"autoaccel3", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL},
{"kartautoaccel4", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL} {"autoaccel4", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}
}; };
static CV_PossibleValue_t driftsparkpulse_t[] = {{0, "MIN"}, {FRACUNIT*3, "MAX"}, {0, NULL}}; static CV_PossibleValue_t driftsparkpulse_t[] = {{0, "MIN"}, {FRACUNIT*3, "MAX"}, {0, NULL}};
@@ -510,8 +523,11 @@ void G_ClearRecords(void)
INT16 i; INT16 i;
for (i = 0; i < NUMMAPS; ++i) for (i = 0; i < NUMMAPS; ++i)
{ {
Z_Free(mainrecords[i]); if (mainrecords[i])
mainrecords[i] = NULL; {
Z_Free(mainrecords[i]);
mainrecords[i] = NULL;
}
} }
} }
@@ -1290,6 +1306,8 @@ static void G_DoLoadLevel(boolean resetplayer)
// Make sure objectplace is OFF when you first start the level! // Make sure objectplace is OFF when you first start the level!
OP_ResetObjectplace(); OP_ResetObjectplace();
levelstarttic = gametic; // for time calculation
if (wipegamestate == GS_LEVEL) if (wipegamestate == GS_LEVEL)
wipegamestate = -1; // force a wipe wipegamestate = -1; // force a wipe
@@ -3343,6 +3361,18 @@ static void G_DoStartVote(void)
gameaction = ga_nothing; gameaction = ga_nothing;
} }
//
// G_UseContinue
//
void G_UseContinue(void)
{
if (gamestate == GS_LEVEL && !netgame && !multiplayer)
{
gameaction = ga_startcont;
lastdraw = true;
}
}
static void G_DoStartContinue(void) static void G_DoStartContinue(void)
{ {
I_Assert(!netgame && !multiplayer); I_Assert(!netgame && !multiplayer);
@@ -3381,7 +3411,7 @@ static void G_DoContinued(void)
token = 0; token = 0;
// Reset # of lives // Reset # of lives
pl->lives = 3; pl->lives = (ultimatemode) ? 1 : 3;
D_MapChange(gamemap, gametype, false, false, 0, false, false); D_MapChange(gamemap, gametype, false, false, 0, false, false);
@@ -3471,7 +3501,7 @@ void G_LoadGameData(void)
INT32 i, j; INT32 i, j;
UINT8 modded = false; UINT8 modded = false;
UINT8 rtemp; UINT8 rtemp;
savebuffer_t save = {}; savebuffer_t save = {0};
//For records //For records
tic_t rectime; tic_t rectime;
@@ -3604,7 +3634,7 @@ void G_SaveGameData(boolean force)
size_t length; size_t length;
INT32 i, j; INT32 i, j;
UINT8 btemp; UINT8 btemp;
savebuffer_t save = {}; savebuffer_t save = {0};
(void)force; (void)force;
char backupfile[MAX_WADPATH+4]; char backupfile[MAX_WADPATH+4];
@@ -3775,7 +3805,7 @@ void G_LoadGame(UINT32 slot, INT16 mapoverride)
size_t length; size_t length;
char vcheck[VERSIONSIZE]; char vcheck[VERSIONSIZE];
char savename[255]; char savename[255];
savebuffer_t save = {}; savebuffer_t save = {0};
// memset savedata to all 0, fixes calling perfectly valid saves corrupt because of bots // memset savedata to all 0, fixes calling perfectly valid saves corrupt because of bots
memset(&savedata, 0, sizeof(savedata)); memset(&savedata, 0, sizeof(savedata));
@@ -3861,7 +3891,7 @@ void G_SaveGame(UINT32 savegameslot)
boolean saved; boolean saved;
char savename[256] = ""; char savename[256] = "";
const char *backup; const char *backup;
savebuffer_t save = {}; savebuffer_t save = {0};
sprintf(savename, savegamename, savegameslot); sprintf(savename, savegamename, savegameslot);
backup = va("%s",savename); backup = va("%s",savename);
@@ -3875,7 +3905,7 @@ void G_SaveGame(UINT32 savegameslot)
char name[VERSIONSIZE]; char name[VERSIONSIZE];
size_t length; size_t length;
save.p = save.buffer = (UINT8 *)Z_Malloc(1024, PU_STATIC, NULL); // 1024 bytes is plenty for a savegame save.p = save.buffer = (UINT8 *)Z_Malloc(SAVEGAMESIZE, PU_STATIC, NULL);
if (!save.p) if (!save.p)
{ {
CONS_Alert(CONS_ERROR, M_GetText("No more free memory for saving game data\n")); CONS_Alert(CONS_ERROR, M_GetText("No more free memory for saving game data\n"));
@@ -4025,6 +4055,7 @@ void G_InitNew(UINT8 pencoremode, const char *mapname, boolean resetplayer, bool
if (W_CheckNumForName(mapname) == LUMPERROR) if (W_CheckNumForName(mapname) == LUMPERROR)
{ {
I_Error("Internal game map '%s' not found\n", mapname); I_Error("Internal game map '%s' not found\n", mapname);
Command_ExitGame_f();
return; return;
} }
@@ -4125,13 +4156,12 @@ static void measurekeywords(mapsearchfreq_t *fr,
{ {
char *qp; char *qp;
char *sp; char *sp;
if (wanttable) if (wanttable)
(*dimp) = Z_Realloc((*dimp), 255 * sizeof (struct searchdim), (*dimp) = Z_Realloc((*dimp), 255 * sizeof (struct searchdim),
PU_STATIC, NULL); PU_STATIC, NULL);
for (qp = strtok(va("%s", q), " "); for (qp = strtok(va("%s", q), " ");
qp && fr->total < 255; qp && fr->total < 255;
qp = strtok(NULL, " ")) qp = strtok(0, " "))
{ {
if (( sp = strcasestr(s, qp) )) if (( sp = strcasestr(s, qp) ))
{ {
@@ -4140,12 +4170,10 @@ static void measurekeywords(mapsearchfreq_t *fr,
(*dimp)[(*cuntp)].pos = sp - s; (*dimp)[(*cuntp)].pos = sp - s;
(*dimp)[(*cuntp)].siz = strlen(qp); (*dimp)[(*cuntp)].siz = strlen(qp);
} }
(*cuntp)++; (*cuntp)++;
fr->total++; fr->total++;
} }
} }
if (wanttable) if (wanttable)
(*dimp) = Z_Realloc((*dimp), (*cuntp) * sizeof (struct searchdim), (*dimp) = Z_Realloc((*dimp), (*cuntp) * sizeof (struct searchdim),
PU_STATIC, NULL); PU_STATIC, NULL);
@@ -4214,7 +4242,7 @@ INT32 G_FindMap(const char *mapname, char **foundmapnamep,
{ {
newmapnum = mapnum; newmapnum = mapnum;
newmapname = realmapname; newmapname = realmapname;
realmapname = NULL; realmapname = 0;
Z_Free(apromapname); Z_Free(apromapname);
if (!wanttable) if (!wanttable)
break; break;
@@ -4235,7 +4263,7 @@ INT32 G_FindMap(const char *mapname, char **foundmapnamep,
{ {
apromapnum = mapnum; apromapnum = mapnum;
apromapname = realmapname; apromapname = realmapname;
realmapname = NULL; realmapname = 0;
} }
} }
else/* ...match individual keywords */ else/* ...match individual keywords */
+5 -1
View File
@@ -39,8 +39,12 @@ extern INT32 player_name_changes[MAXPLAYERS];
extern player_t players[MAXPLAYERS]; extern player_t players[MAXPLAYERS];
extern boolean playeringame[MAXPLAYERS]; extern boolean playeringame[MAXPLAYERS];
// gametic at level start
extern tic_t levelstarttic;
// for modding? // for modding?
extern INT16 prevmap, nextmap; extern INT16 prevmap, nextmap;
extern INT32 gameovertics;
extern tic_t timeinmap; // Ticker for time spent in level (used for levelcard display) extern tic_t timeinmap; // Ticker for time spent in level (used for levelcard display)
extern INT16 rw_maximums[NUM_WEAPONS]; extern INT16 rw_maximums[NUM_WEAPONS];
@@ -126,7 +130,6 @@ extern consvar_t cv_spinoutroll;
extern consvar_t cv_squishdance, cv_squishdancespeed; extern consvar_t cv_squishdance, cv_squishdancespeed;
extern consvar_t cv_playerblendeffects; extern consvar_t cv_playerblendeffects;
extern consvar_t cv_reducevfx;
extern consvar_t cv_cechotoggle; extern consvar_t cv_cechotoggle;
@@ -248,6 +251,7 @@ UINT8 G_GetGametypeColor(INT16 gt);
void G_ExitLevel(void); void G_ExitLevel(void);
void G_NextLevel(void); void G_NextLevel(void);
void G_Continue(void); void G_Continue(void);
void G_UseContinue(void);
void G_AfterIntermission(void); void G_AfterIntermission(void);
void G_EndGame(void); // moved from y_inter.c/h and renamed void G_EndGame(void); // moved from y_inter.c/h and renamed
+7 -29
View File
@@ -81,9 +81,6 @@ consvar_t cv_gamepadled[MAXSPLITSCREENPLAYERS] = {
{"gamepadled4", "Skincolor", CV_SAVE|CV_CALL|CV_NOINIT, gamepadled_cons_t, led_off_handle4, 0, NULL, NULL, 0, 0, NULL} {"gamepadled4", "Skincolor", CV_SAVE|CV_CALL|CV_NOINIT, gamepadled_cons_t, led_off_handle4, 0, NULL, NULL, 0, 0, NULL}
}; };
consvar_t cv_gamepadledifunfocused = {"gamepadledunfocused", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_rumbleifunfocused = {"rumbleifunfocused", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
static void rumble_off_handle(void) static void rumble_off_handle(void)
{ {
if (!cv_rumble[0].value) if (!cv_rumble[0].value)
@@ -933,17 +930,12 @@ 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) || color >= MAXTRANSLATIONS)
{ {
return; return;
} }
if (!I_GamepadHasLED(playernum))
{
return;
}
// so we can override this // so we can override this
skincolor = color ? color : G_GetSkinColorForGamepad(playernum); skincolor = color ? color : G_GetSkinColorForGamepad(playernum);
byte_color = V_GetColor(colortranslations[skincolor][8]).s; byte_color = V_GetColor(colortranslations[skincolor][8]).s;
@@ -953,8 +945,6 @@ void G_SetPlayerGamepadIndicatorColor(INT32 playernum, UINT8 color)
static void G_ResetPlayerGamepadIndicatorColor(INT32 playernum) static void G_ResetPlayerGamepadIndicatorColor(INT32 playernum)
{ {
I_Assert(playernum >= 0 && playernum < MAXSPLITSCREENPLAYERS);
if (cv_gamepadled[playernum].value == 0) if (cv_gamepadled[playernum].value == 0)
{ {
I_SetGamepadIndicatorColor(playernum, 0, 0, 255); I_SetGamepadIndicatorColor(playernum, 0, 0, 255);
@@ -979,22 +969,17 @@ void G_DeviceLEDTick(void)
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
if (!I_GamepadHasLED(i))
{
continue;
}
newcolor = G_GetSkinColorForGamepad(i); newcolor = G_GetSkinColorForGamepad(i);
// compiler be absolutely tripping
// delet this if this gets fixed within gcc
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warray-bounds"
if (curcolor[i] == newcolor) // dont update if same colour if (curcolor[i] == newcolor) // dont update if same colour
{
continue; continue;
} #pragma GCC diagnostic pop
G_SetPlayerGamepadIndicatorColor(i, newcolor); G_SetPlayerGamepadIndicatorColor(i, newcolor);
curcolor[i] = newcolor; curcolor[i] = newcolor;
@@ -1009,7 +994,6 @@ void G_ResetDeviceLED(void)
static void G_ResetPlayerDeviceRumble(INT32 playernum) static void G_ResetPlayerDeviceRumble(INT32 playernum)
{ {
I_Assert(playernum >= 0 && playernum < MAXSPLITSCREENPLAYERS);
I_GamepadRumble(playernum, 0, 0, 0); I_GamepadRumble(playernum, 0, 0, 0);
} }
@@ -1027,7 +1011,7 @@ void G_PlayerDeviceRumble(INT32 playernum, UINT16 low_strength, UINT16 high_stre
{ {
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)
{ {
return; return;
} }
@@ -1070,12 +1054,6 @@ void G_DeviceRumbleTick(void)
continue; continue;
} }
// does not support rumble! :c
if (!I_GamepadHasRumble(i))
{
continue;
}
if (camera[i].freecam) if (camera[i].freecam)
{ {
continue; continue;
-3
View File
@@ -116,9 +116,6 @@ extern consvar_t cv_rumble[MAXSPLITSCREENPLAYERS];
extern consvar_t cv_rumblestrength[MAXSPLITSCREENPLAYERS]; extern consvar_t cv_rumblestrength[MAXSPLITSCREENPLAYERS];
extern consvar_t cv_gamepadled[MAXSPLITSCREENPLAYERS]; extern consvar_t cv_gamepadled[MAXSPLITSCREENPLAYERS];
extern consvar_t cv_gamepadledifunfocused;
extern consvar_t cv_rumbleifunfocused;
extern INT32 mousex, mousey; extern INT32 mousex, mousey;
extern INT32 joyxmove[MAXSPLITSCREENPLAYERS][JOYAXISSET], joyymove[MAXSPLITSCREENPLAYERS][JOYAXISSET]; extern INT32 joyxmove[MAXSPLITSCREENPLAYERS][JOYAXISSET], joyymove[MAXSPLITSCREENPLAYERS][JOYAXISSET];
+1
View File
@@ -52,6 +52,7 @@ typedef enum
} gameaction_t; } gameaction_t;
extern gamestate_t gamestate; extern gamestate_t gamestate;
extern UINT8 ultimatemode; // was sk_insane
extern gameaction_t gameaction; extern gameaction_t gameaction;
extern boolean botingame; extern boolean botingame;
+1
View File
@@ -0,0 +1 @@
target_sourcefile(c)
+1 -1
View File
@@ -391,7 +391,7 @@ void HWR_RenderBatches(void)
nextSurfaceInfo = nextEntry->surf; nextSurfaceInfo = nextEntry->surf;
if (nextPolyFlags & PF_NoTexture) if (nextPolyFlags & PF_NoTexture)
nextTexture = NULL; nextTexture = 0;
if (useshader && currentShader != nextShader) if (useshader && currentShader != nextShader)
{ {
@@ -15,6 +15,8 @@
#ifdef HWRENDER #ifdef HWRENDER
#include <unordered_set>
#include "hw_main.h" #include "hw_main.h"
#include "hw_glob.h" #include "hw_glob.h"
#include "hw_gl.h" #include "hw_gl.h"
@@ -98,7 +100,7 @@ static void HWR_DrawColumnInCache(const column_t *patchcol, UINT8 *block, GLMipm
position = 0; position = 0;
} }
position = max(((position * scale_y) + (FRACUNIT/2)) >> FRACBITS, 0); position = std::max(((position * scale_y) + (FRACUNIT/2)) >> FRACBITS, 0);
if (position + count >= pblockheight) if (position + count >= pblockheight)
count = pblockheight - position; count = pblockheight - position;
@@ -162,7 +164,7 @@ static void HWR_DrawPatchInCache(GLMipmap_t *mipmap,
fixed_t xfrac, xfracstep; fixed_t xfrac, xfracstep;
fixed_t yfracstep, scale_y; fixed_t yfracstep, scale_y;
const column_t *patchcol; const column_t *patchcol;
UINT8 *block = (UINT8 *)(mipmap->data); UINT8 *block = static_cast<UINT8 *>(mipmap->data);
INT32 bpp; INT32 bpp;
INT32 blockmodulo; INT32 blockmodulo;
RGBA_t *palette; RGBA_t *palette;
@@ -212,7 +214,7 @@ static void HWR_DrawTexturePatchInCache(GLMipmap_t *mipmap,
fixed_t xfrac, xfracstep; fixed_t xfrac, xfracstep;
fixed_t yfracstep, scale_y; fixed_t yfracstep, scale_y;
const column_t *patchcol; const column_t *patchcol;
UINT8 *block = (UINT8 *)(mipmap->data); UINT8 *block = static_cast<UINT8 *>(mipmap->data);
INT32 bpp; INT32 bpp;
INT32 blockmodulo; INT32 blockmodulo;
INT32 width, height; INT32 width, height;
@@ -288,7 +290,7 @@ static UINT8 *MakeBlock(GLMipmap_t *glMipmap)
INT32 blocksize = (glMipmap->width * glMipmap->height); INT32 blocksize = (glMipmap->width * glMipmap->height);
bpp = format2bpp(glMipmap->format); bpp = format2bpp(glMipmap->format);
block = (UINT8 *)(Z_Malloc(blocksize*bpp, PU_HWRCACHE, &(glMipmap->data))); block = static_cast<UINT8 *>(Z_Malloc(blocksize*bpp, PU_HWRCACHE, &(glMipmap->data)));
switch (bpp) switch (bpp)
{ {
@@ -325,7 +327,7 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *gltex, boolean noe
texture = textures[texnum]; texture = textures[texnum];
gltex->mipmap.flags = TF_CHROMAKEYED | TF_WRAPXY; gltex->mipmap.flags = TF_CHROMAKEYED | TF_WRAPXY;
gltex->mipmap.format = (GLTextureFormat_t)(textureformat); gltex->mipmap.format = static_cast<GLTextureFormat_t>(textureformat);
// hack the Legacy skies.. // hack the Legacy skies..
if (UNLIKELY(memcmp(texture->name, "SKY", 3) == 0 && if (UNLIKELY(memcmp(texture->name, "SKY", 3) == 0 &&
@@ -344,7 +346,7 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *gltex, boolean noe
colormap += COLORMAP_REMAPOFFSET; colormap += COLORMAP_REMAPOFFSET;
#endif #endif
gltex->mipmap.colormap = (GLColormap_t *)(Z_Calloc(sizeof(*gltex->mipmap.colormap), PU_HWRPATCHCOLMIPMAP, NULL)); gltex->mipmap.colormap = static_cast<GLColormap_t *>(Z_Calloc(sizeof(*gltex->mipmap.colormap), PU_HWRPATCHCOLMIPMAP, NULL));
gltex->mipmap.colormap->source = colormap; gltex->mipmap.colormap->source = colormap;
memcpy(gltex->mipmap.colormap->data, colormap, 256 * sizeof(UINT8)); memcpy(gltex->mipmap.colormap->data, colormap, 256 * sizeof(UINT8));
@@ -377,7 +379,7 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *gltex, boolean noe
// Composite the columns together. // Composite the columns together.
for (i = 0, patch = texture->patches; i < texture->patchcount; i++, patch++) for (i = 0, patch = texture->patches; i < texture->patchcount; i++, patch++)
{ {
pdata = (UINT8 *)(W_CacheLumpNumPwad(patch->wad, patch->lump, PU_LEVEL)); pdata = static_cast<UINT8 *>(W_CacheLumpNumPwad(patch->wad, patch->lump, PU_LEVEL));
realpatch = (softwarepatch_t *)pdata; realpatch = (softwarepatch_t *)pdata;
HWR_DrawTexturePatchInCache(&gltex->mipmap, blockwidth, blockheight, texture, patch, realpatch); HWR_DrawTexturePatchInCache(&gltex->mipmap, blockwidth, blockheight, texture, patch, realpatch);
@@ -413,7 +415,7 @@ void HWR_MakePatch(const patch_t *patch, GLPatch_t *glPatch, GLMipmap_t *glMipma
glMipmap->flags = 0; glMipmap->flags = 0;
// setup the texture info // setup the texture info
glMipmap->format = (GLTextureFormat_t)(patchformat); glMipmap->format = static_cast<GLTextureFormat_t>(patchformat);
glPatch->max_s = (float)patch->width / (float)glMipmap->width; glPatch->max_s = (float)patch->width / (float)glMipmap->width;
glPatch->max_t = (float)patch->height / (float)glMipmap->height; glPatch->max_t = (float)patch->height / (float)glMipmap->height;
@@ -455,7 +457,7 @@ static void HWR_FreeTextureData(patch_t *patch)
if (!patch || !patch->hardware) if (!patch || !patch->hardware)
return; return;
glPatch = (GLPatch_t *)(patch->hardware); glPatch = static_cast<GLPatch_t *>(patch->hardware);
if (vid.glstate == VID_GL_LIBRARY_LOADED) if (vid.glstate == VID_GL_LIBRARY_LOADED)
GL_DeleteTexture(glPatch->mipmap); GL_DeleteTexture(glPatch->mipmap);
@@ -471,7 +473,7 @@ void HWR_FreeTexture(patch_t *patch)
if (patch->hardware) if (patch->hardware)
{ {
GLPatch_t *glPatch = (GLPatch_t *)(patch->hardware); GLPatch_t *glPatch = static_cast<GLPatch_t *>(patch->hardware);
HWR_FreeTextureColormaps(patch); HWR_FreeTextureColormaps(patch);
@@ -497,7 +499,7 @@ static void HWR_FreeTextureColormaps(patch_t *patch)
if (!patch) if (!patch)
return; return;
pat = (GLPatch_t *)(patch->hardware); pat = static_cast<GLPatch_t *>(patch->hardware);
if (!pat) if (!pat)
return; return;
@@ -612,20 +614,25 @@ 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 // lookup for flats that may´ve been already loaded
flatcheck flatpresent; // too lazy to make a hashtable or smth so unordered set will do :carbuncle:
flatcheck_init(&flatpresent); std::unordered_set<UINT32> flatpresent;
lumpnum_t lump;
size_t i, j; size_t i, j;
INT32 k; INT32 k;
auto load_flat = [&](lumpnum_t lump, boolean noencoremap)
{
// flat already loaded?
if (flatpresent.count(lump) == 0)
{
HWR_GetFlat(lump, noencoremap);
flatpresent.insert(lump);
}
};
// special case for encore // special case for encore
#ifdef GLENCORE #ifdef GLENCORE
if (encoremap) if (encoremap)
@@ -642,24 +649,16 @@ static void HWR_PrecacheLevelFlats(void)
const INT32 pic = ceiling ? sec->ceilingpic : sec->floorpic; const INT32 pic = ceiling ? sec->ceilingpic : sec->floorpic;
const levelflat_t *levelflat = &levelflats[pic]; const levelflat_t *levelflat = &levelflats[pic];
lump = levelflat->lumpnum;
if (flatcheck_is_end(flatcheck_get(&flatpresent, levelflat->lumpnum))) load_flat(lump, R_NoEncore(sec, ceiling));
{
HWR_GetFlat(levelflat->lumpnum, R_NoEncore(sec, ceiling));
flatcheck_insert(&flatpresent, levelflat->lumpnum);
}
if (levelflat->speed) // is it an animated flat ? if (levelflat->speed) // is it an animated flat ?
{ {
// start from 0, occasionally basenumlump != flat->lumpnum // start from 0, occasionally basenumlump != flat->lumpnum
for (k = 0; k < levelflat->numpics; k++) for (k = 0; k < levelflat->numpics; k++)
{ {
lumpnum_t lump = levelflat->baselumpnum + k; load_flat(levelflat->baselumpnum + k, R_NoEncore(sec, ceiling));
if (flatcheck_is_end(flatcheck_get(&flatpresent, lump)))
{
HWR_GetFlat(lump, R_NoEncore(sec, ceiling));
flatcheck_insert(&flatpresent, lump);
}
} }
} }
} }
@@ -673,30 +672,20 @@ static void HWR_PrecacheLevelFlats(void)
for (i = 0; i < numlevelflats; i++) for (i = 0; i < numlevelflats; i++)
{ {
const levelflat_t *levelflat = &levelflats[i]; const levelflat_t *levelflat = &levelflats[i];
lump = levelflat->lumpnum;
if (flatcheck_is_end(flatcheck_get(&flatpresent, levelflat->lumpnum))) load_flat(lump, 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 ?
{ {
// start from 0, occasionally basenumlump != flat->lumpnum // start from 0, occasionally basenumlump != flat->lumpnum
for (k = 0; k < levelflat->numpics; k++) for (k = 0; k < levelflat->numpics; k++)
{ {
lumpnum_t lump = levelflat->baselumpnum + k; load_flat(levelflat->baselumpnum + k, false);
if (flatcheck_is_end(flatcheck_get(&flatpresent, lump)))
{
HWR_GetFlat(lump, false);
flatcheck_insert(&flatpresent, lump);
}
} }
} }
} }
} }
flatcheck_cleanup(&flatpresent);
} }
static void HWR_PrecacheLevelTextures(void) static void HWR_PrecacheLevelTextures(void)
@@ -706,7 +695,7 @@ static void HWR_PrecacheLevelTextures(void)
size_t i, j, f; size_t i, j, f;
INT32 h; INT32 h;
texturepresent = (char *)(calloc(gl_numtextures, sizeof(*texturepresent))); texturepresent = static_cast<char *>(calloc(gl_numtextures, sizeof(*texturepresent)));
if (texturepresent == NULL) if (texturepresent == NULL)
I_Error("%s: Out of memory looking up textures", "HWR_PrecacheLevel"); I_Error("%s: Out of memory looking up textures", "HWR_PrecacheLevel");
@@ -881,7 +870,7 @@ void HWR_LoadMapTextures(size_t pnumtextures)
HWR_FreeMapTextures(); HWR_FreeMapTextures();
gl_numtextures = pnumtextures; gl_numtextures = pnumtextures;
gl_textures = (GLMapTextureSet_t *)(calloc(gl_numtextures, sizeof(*gl_textures))); // *2 - 1 for encore-remapped texture and another for noencore texture (unused when not in encore), see: GLMapTextureSet_t gl_textures = static_cast<GLMapTextureSet_t *>(calloc(gl_numtextures, sizeof(*gl_textures))); // *2 - 1 for encore-remapped texture and another for noencore texture (unused when not in encore), see: GLMapTextureSet_t
if (gl_textures == NULL) if (gl_textures == NULL)
I_Error("HWR_LoadMapTextures: ran out of memory for OpenGL textures. Sad!"); I_Error("HWR_LoadMapTextures: ran out of memory for OpenGL textures. Sad!");
@@ -978,7 +967,7 @@ static void HWR_CacheFlat(GLMipmap_t *glMipmap, lumpnum_t flatlumpnum)
W_ReadLump(flatlumpnum, Z_Malloc(size, PU_HWRCACHE, &glMipmap->data)); W_ReadLump(flatlumpnum, Z_Malloc(size, PU_HWRCACHE, &glMipmap->data));
#ifdef GLENCORE #ifdef GLENCORE
flat = (UINT8 *)(glMipmap->data); flat = static_cast<UINT8 *>(glMipmap->data);
for (steppy = 0; steppy < size; steppy++) for (steppy = 0; steppy < size; steppy++)
{ {
if (flat[steppy] == HWR_PATCHES_CHROMAKEY_COLORINDEX) if (flat[steppy] == HWR_PATCHES_CHROMAKEY_COLORINDEX)
@@ -1022,7 +1011,7 @@ void HWR_GetFlat(lumpnum_t flatlumpnum, boolean noencoremap)
if (!noencoremap && encoremap) if (!noencoremap && encoremap)
colormap += COLORMAP_REMAPOFFSET; colormap += COLORMAP_REMAPOFFSET;
#endif #endif
glMipmap->colormap = (GLColormap_t *)(Z_Calloc(sizeof(*glMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL)); glMipmap->colormap = static_cast<GLColormap_t *>(Z_Calloc(sizeof(*glMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL));
glMipmap->colormap->source = colormap; glMipmap->colormap->source = colormap;
memcpy(glMipmap->colormap->data, colormap, 256 * sizeof(UINT8)); memcpy(glMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
} }
@@ -1046,7 +1035,7 @@ void HWR_GetFlat(lumpnum_t flatlumpnum, boolean noencoremap)
// --------------------+ // --------------------+
static void HWR_LoadPatchMipmap(patch_t *patch, GLMipmap_t *glMipmap) static void HWR_LoadPatchMipmap(patch_t *patch, GLMipmap_t *glMipmap)
{ {
GLPatch_t *glPatch = (GLPatch_t *)(patch->hardware); GLPatch_t *glPatch = static_cast<GLPatch_t *>(patch->hardware);
if (!glMipmap->downloaded) if (!glMipmap->downloaded)
{ {
@@ -1067,7 +1056,7 @@ static void HWR_LoadPatchMipmap(patch_t *patch, GLMipmap_t *glMipmap)
// ----------------------+ // ----------------------+
static void HWR_UpdatePatchMipmap(patch_t *patch, GLMipmap_t *glMipmap) static void HWR_UpdatePatchMipmap(patch_t *patch, GLMipmap_t *glMipmap)
{ {
GLPatch_t *glPatch = (GLPatch_t *)(patch->hardware); GLPatch_t *glPatch = static_cast<GLPatch_t *>(patch->hardware);
HWR_MakePatch(patch, glPatch, glMipmap, true); HWR_MakePatch(patch, glPatch, glMipmap, true);
// If hardware does not have the texture, then call GL_SetTexture to upload it // If hardware does not have the texture, then call GL_SetTexture to upload it
@@ -1103,7 +1092,7 @@ void HWR_GetMappedPatch(patch_t *patch, const UINT8 *colormap)
if (!patch->hardware) if (!patch->hardware)
Patch_CreateGL(patch); Patch_CreateGL(patch);
glPatch = (GLPatch_t *)(patch->hardware); glPatch = static_cast<GLPatch_t *>(patch->hardware);
// Blatant hack for encore colormapping aside... // Blatant hack for encore colormapping aside...
if (colormap == colormaps || colormap == NULL || colormap == (const UINT8*)(COLORMAP_REMAPOFFSET)) if (colormap == colormaps || colormap == NULL || colormap == (const UINT8*)(COLORMAP_REMAPOFFSET))
@@ -1139,12 +1128,12 @@ void HWR_GetMappedPatch(patch_t *patch, const UINT8 *colormap)
// (it have a liste of mipmap) // (it have a liste of mipmap)
// this malloc is cleared in HWR_FreeColormapCache // this malloc is cleared in HWR_FreeColormapCache
// (...) unfortunately z_malloc fragment alot the memory :(so malloc is better // (...) unfortunately z_malloc fragment alot the memory :(so malloc is better
newMipmap = (GLMipmap_t *)(calloc(1, sizeof (*newMipmap))); newMipmap = static_cast<GLMipmap_t *>(calloc(1, sizeof (*newMipmap)));
if (newMipmap == NULL) if (newMipmap == NULL)
I_Error("%s: Out of memory", "HWR_GetMappedPatch"); I_Error("%s: Out of memory", "HWR_GetMappedPatch");
glMipmap->nextcolormap = newMipmap; glMipmap->nextcolormap = newMipmap;
newMipmap->colormap = (GLColormap_t *)(Z_Calloc(sizeof(*newMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL)); newMipmap->colormap = static_cast<GLColormap_t *>(Z_Calloc(sizeof(*newMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL));
newMipmap->colormap->source = colormap; newMipmap->colormap->source = colormap;
memcpy(newMipmap->colormap->data, colormap, 256 * sizeof(UINT8)); memcpy(newMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
@@ -1167,7 +1156,7 @@ patch_t *HWR_GetCachedGLPatchPwad(UINT16 wadnum, UINT16 lumpnum)
{ {
void *ptr = Z_Calloc(sizeof(patch_t), PU_PATCH, &lumpcache[lumpnum]); void *ptr = Z_Calloc(sizeof(patch_t), PU_PATCH, &lumpcache[lumpnum]);
Patch_Create(NULL, 0, ptr); Patch_Create(NULL, 0, ptr);
Patch_AllocateHardwarePatch((patch_t *)(ptr)); Patch_AllocateHardwarePatch(static_cast<patch_t *>(ptr));
} }
return (patch_t *)(lumpcache[lumpnum]); return (patch_t *)(lumpcache[lumpnum]);
@@ -1184,7 +1173,7 @@ static void HWR_DrawFadeMaskInCache(GLMipmap_t *mipmap, INT32 pblockwidth, INT32
{ {
INT32 i,j; INT32 i,j;
fixed_t posx, posy, stepx, stepy; fixed_t posx, posy, stepx, stepy;
UINT8 *block = (UINT8 *)(mipmap->data); // places the data directly into here UINT8 *block = static_cast<UINT8 *>(mipmap->data); // places the data directly into here
UINT8 *flat; UINT8 *flat;
UINT8 *dest, *src, texel; UINT8 *dest, *src, texel;
RGBA_t col; RGBA_t col;
@@ -1340,7 +1329,7 @@ void HWR_SetPalette(RGBA_t *palette)
static void HWR_SetPaletteLookup(RGBA_t *palette) static void HWR_SetPaletteLookup(RGBA_t *palette)
{ {
int r, g, b; int r, g, b;
UINT8 *lut = (UINT8 *)(Z_Malloc( UINT8 *lut = static_cast<UINT8 *>(Z_Malloc(
HWR_PALETTE_LUT_SIZE*HWR_PALETTE_LUT_SIZE*HWR_PALETTE_LUT_SIZE*sizeof(UINT8), HWR_PALETTE_LUT_SIZE*HWR_PALETTE_LUT_SIZE*HWR_PALETTE_LUT_SIZE*sizeof(UINT8),
PU_STATIC, NULL)); PU_STATIC, NULL));
#define STEP_SIZE (256/HWR_PALETTE_LUT_SIZE) #define STEP_SIZE (256/HWR_PALETTE_LUT_SIZE)
@@ -1385,7 +1374,7 @@ void HWR_SetMapPalette(void)
if (palsize < 768) // 256 * 3 if (palsize < 768) // 256 * 3
I_Error("HWR_SetMapPalette: A programmer assumed palette lumps are at least 768 bytes long, but apparently this was a wrong assumption!\n"); I_Error("HWR_SetMapPalette: A programmer assumed palette lumps are at least 768 bytes long, but apparently this was a wrong assumption!\n");
RGB_data = (UINT8 *)(W_CacheLumpNum(lumpnum, PU_CACHE)); RGB_data = static_cast<UINT8 *>(W_CacheLumpNum(lumpnum, PU_CACHE));
// we got the RGB palette now, but we need it in RGBA format. // we got the RGB palette now, but we need it in RGBA format.
for (i = 0; i < 256; i++) for (i = 0; i < 256; i++)
{ {
@@ -1420,7 +1409,7 @@ static UINT32 HWR_CreateLightTable(UINT8 *lighttable)
{ {
UINT32 i, id; UINT32 i, id;
RGBA_t *palette = HWR_GetTexturePalette(); RGBA_t *palette = HWR_GetTexturePalette();
RGBA_t *hw_lighttable = (RGBA_t *)(Z_Malloc(256 * 32 * sizeof(RGBA_t), PU_STATIC, NULL)); RGBA_t *hw_lighttable = static_cast<RGBA_t *>(Z_Malloc(256 * 32 * sizeof(RGBA_t), PU_STATIC, NULL));
// To make the palette index -> RGBA mapping easier for the shader, // To make the palette index -> RGBA mapping easier for the shader,
// the hardware lighttable is composed of RGBA colors instead of palette indices. // the hardware lighttable is composed of RGBA colors instead of palette indices.
+1 -1
View File
@@ -335,7 +335,7 @@ angle_t gld_FrustumAngle(angle_t tiltangle)
floatangle = 2.0 + (45.0 + ((double)tilt / 1.9)) * clipfov / 90.0; floatangle = 2.0 + (45.0 + ((double)tilt / 1.9)) * clipfov / 90.0;
if (floatangle >= 180.0) if (floatangle >= 180.0)
return 0xffffffff; return 0xffffffff;
a1 = (angle_t)lrint(ANG1 * floatangle); a1 = (angle_t)xs_CRoundToInt(ANG1 * floatangle);
return a1; return a1;
} }
+1 -1
View File
@@ -54,7 +54,7 @@ struct GLMipmap_s
UINT16 width, height; UINT16 width, height;
UINT32 downloaded; // The GPU has this texture. UINT32 downloaded; // The GPU has this texture.
struct GLMipmap_s *nextcolormap; struct GLMipmap_s *nextcolormap;
struct GLColormap_s *colormap; struct GLColormap_s *colormap;
}; };
typedef struct GLMipmap_s GLMipmap_t; typedef struct GLMipmap_s GLMipmap_t;
+9 -9
View File
@@ -150,7 +150,7 @@ void HWR_DrawStretchyFixedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t p
if (!column->topdelta) if (!column->topdelta)
{ {
const UINT8 *source = (const UINT8 *)(column) + 3; const UINT8 *source = (const UINT8 *)(column) + 3;
HWR_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, source[0]); HWR_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, (column->topdelta == 0xff ? 31 : source[0]));
} }
} }
@@ -222,7 +222,7 @@ void HWR_DrawStretchyFixedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t p
if (alphalevel) if (alphalevel)
{ {
FSurfaceInfo Surf = {}; FSurfaceInfo Surf;
Surf.PolyColor.s.red = Surf.PolyColor.s.green = Surf.PolyColor.s.blue = 0xff; Surf.PolyColor.s.red = Surf.PolyColor.s.green = Surf.PolyColor.s.blue = 0xff;
switch (alphalevel) switch (alphalevel)
@@ -302,7 +302,7 @@ void HWR_DrawCroppedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale,
if (!column->topdelta) if (!column->topdelta)
{ {
const UINT8 *source = (const UINT8 *)(column) + 3; const UINT8 *source = (const UINT8 *)(column) + 3;
HWR_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, source[0]); HWR_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, (column->topdelta == 0xff ? 31 : source[0]));
} }
} }
@@ -385,7 +385,7 @@ void HWR_DrawCroppedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale,
// clip it since it is used for bunny scroll in doom I // clip it since it is used for bunny scroll in doom I
if (alphalevel) if (alphalevel)
{ {
FSurfaceInfo Surf = {}; FSurfaceInfo Surf;
Surf.PolyColor.s.red = Surf.PolyColor.s.green = Surf.PolyColor.s.blue = 0xff; Surf.PolyColor.s.red = Surf.PolyColor.s.green = Surf.PolyColor.s.blue = 0xff;
switch (alphalevel) switch (alphalevel)
@@ -490,7 +490,7 @@ void HWR_DrawFlatFill(INT32 x, INT32 y, INT32 w, INT32 h, lumpnum_t flatlumpnum)
void HWR_FadeScreenMenuBack(UINT16 color, UINT8 strength) void HWR_FadeScreenMenuBack(UINT16 color, UINT8 strength)
{ {
FOutVector v[4]; FOutVector v[4];
FSurfaceInfo Surf = {}; FSurfaceInfo Surf;
FBITFIELD poly_flags = PF_NoTexture|PF_Modulated|PF_NoDepthTest; FBITFIELD poly_flags = PF_NoTexture|PF_Modulated|PF_NoDepthTest;
v[0].x = v[3].x = -1.0f; v[0].x = v[3].x = -1.0f;
@@ -543,7 +543,7 @@ void HWR_FadeScreenMenuBack(UINT16 color, UINT8 strength)
void HWR_DrawConsoleBack(UINT32 color, INT32 height) void HWR_DrawConsoleBack(UINT32 color, INT32 height)
{ {
FOutVector v[4]; FOutVector v[4];
FSurfaceInfo Surf = {}; FSurfaceInfo Surf;
// setup some neat-o translucency effect // setup some neat-o translucency effect
if (!height) //cool hack 0 height is full height if (!height) //cool hack 0 height is full height
@@ -598,7 +598,7 @@ void HWR_drawAMline(const fline_t *fl, INT32 color)
void HWR_DrawDiag(INT32 x, INT32 y, INT32 wh, INT32 color) void HWR_DrawDiag(INT32 x, INT32 y, INT32 wh, INT32 color)
{ {
FOutVector v[4]; FOutVector v[4];
FSurfaceInfo Surf = {}; FSurfaceInfo Surf;
float fx, fy, fw, fh, fwait = 0; float fx, fy, fw, fh, fwait = 0;
RGBA_t *palette; RGBA_t *palette;
@@ -702,7 +702,7 @@ void HWR_DrawDiag(INT32 x, INT32 y, INT32 wh, INT32 color)
void HWR_DrawConsoleFill(INT32 x, INT32 y, INT32 w, INT32 h, UINT32 color, INT32 options) void HWR_DrawConsoleFill(INT32 x, INT32 y, INT32 w, INT32 h, UINT32 color, INT32 options)
{ {
FOutVector v[4]; FOutVector v[4];
FSurfaceInfo Surf = {}; FSurfaceInfo Surf;
float fx, fy, fw, fh; float fx, fy, fw, fh;
if (w < 0 || h < 0) if (w < 0 || h < 0)
@@ -820,7 +820,7 @@ void HWR_DrawConsoleFill(INT32 x, INT32 y, INT32 w, INT32 h, UINT32 color, INT32
void HWR_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 color) void HWR_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 color)
{ {
FOutVector v[4]; FOutVector v[4];
FSurfaceInfo Surf = {}; FSurfaceInfo Surf;
float fx, fy, fw, fh; float fx, fy, fw, fh;
if (w < 0 || h < 0) if (w < 0 || h < 0)
-3
View File
@@ -80,9 +80,6 @@ UINT32 GL_CreateLightTable(RGBA_t *hw_lighttable);
void GL_ClearLightTables(void); void GL_ClearLightTables(void);
void GL_SetScreenPalette(RGBA_t *palette); void GL_SetScreenPalette(RGBA_t *palette);
void GL_Draw2DModel(model_t *model, INT32 frameIndex, INT32 duration, INT32 tics, INT32 nextFrameIndex,
FTransform *pos, float hscale, float vscale, UINT8 flipped, UINT8 hflipped, FSurfaceInfo *Surface);
#ifdef __cplusplus #ifdef __cplusplus
} // extern "C" } // extern "C"
#endif #endif
+122 -123
View File
@@ -101,8 +101,7 @@ sector_t *gl_backsector = NULL;
static constexpr float clipping_distances[] = {1024.0f, 2048.0f, 4096.0f, 6144.0f, 8192.0f, 12288.0f, 16384.0f}; static constexpr float clipping_distances[] = {1024.0f, 2048.0f, 4096.0f, 6144.0f, 8192.0f, 12288.0f, 16384.0f};
// values for bsp culling // values for bsp culling
// slightly higher than the far clipping plane to compensate for impreciseness // slightly higher than the far clipping plane to compensate for impreciseness
static constexpr INT32 bsp_culling_distances[] = { static constexpr INT32 bsp_culling_distances[] = {(1024+512)*FRACUNIT, (2048+512)*FRACUNIT, (4096+512)*FRACUNIT,
(1024+512)*FRACUNIT, (2048+512)*FRACUNIT, (4096+512)*FRACUNIT,
(6144+512)*FRACUNIT, (8192+512)*FRACUNIT, (12288+512)*FRACUNIT, (16384+512)*FRACUNIT}; (6144+512)*FRACUNIT, (8192+512)*FRACUNIT, (12288+512)*FRACUNIT, (16384+512)*FRACUNIT};
// Performance stats // Performance stats
@@ -242,6 +241,7 @@ consvar_t cv_glportals = {"gr_portals", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL,
consvar_t cv_glpaletterendering = {"gr_paletteshader", "Off", CV_CALL|CV_SAVE, CV_OnOff, CV_glpaletterendering_OnChange, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_glpaletterendering = {"gr_paletteshader", "Off", CV_CALL|CV_SAVE, CV_OnOff, CV_glpaletterendering_OnChange, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_glpalettedepth = {"gr_palettedepth", "16 bits", CV_SAVE|CV_CALL, glpalettedepth_cons_t, CV_glpalettedepth_OnChange, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_glpalettedepth = {"gr_palettedepth", "16 bits", CV_SAVE|CV_CALL, glpalettedepth_cons_t, CV_glpalettedepth_OnChange, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_glflashpal = {"gr_flashpal", "On", CV_CALL|CV_SAVE, CV_OnOff, CV_glpaletterendering_OnChange, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_gltexturedepth = {"gr_texturedepth", "32 bits", CV_CALL|CV_SAVE, gltexdepth_cons_t, CV_gltextureformat_OnChange, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_gltexturedepth = {"gr_texturedepth", "32 bits", CV_CALL|CV_SAVE, gltexdepth_cons_t, CV_gltextureformat_OnChange, 0, NULL, NULL, 0, 0, NULL};
@@ -254,13 +254,11 @@ static void CV_screentextures_OnChange(void)
{ {
if (cv_glpaletterendering.value != 0) if (cv_glpaletterendering.value != 0)
CV_SetValue(&cv_glpaletterendering, 0); CV_SetValue(&cv_glpaletterendering, 0);
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
if (cv_glframebuffer.value != 0) if (cv_glframebuffer.value != 0)
CV_SetValue(&cv_glframebuffer, 0); CV_SetValue(&cv_glframebuffer, 0);
#endif #endif
// HACK: set lastdraw so intermission bg can refresh after toggling screentextures
if (gamestate == GS_INTERMISSION)
lastdraw = true;
} }
GL_SetSpecialState(HWD_SET_SCREEN_TEXTURES, cv_glscreentextures.value); GL_SetSpecialState(HWD_SET_SCREEN_TEXTURES, cv_glscreentextures.value);
M_UpdateOGLMenu(); M_UpdateOGLMenu();
@@ -390,11 +388,11 @@ void HWR_ObjectLightLevelPost(gl_vissprite_t *spr, const sector_t *sector, INT32
extralight = FixedMul(extralight, std::min(std::max(0, *lightlevel), 255) * FRACUNIT / 255); extralight = FixedMul(extralight, std::min(std::max(0, *lightlevel), 255) * FRACUNIT / 255);
// simple OGL approximation // simple OGL approximation
const fixed_t tr = R_QuickCamDist(spr->mobj->x, spr->mobj->y); fixed_t tr = R_QuickCamDist(spr->mobj->x, spr->mobj->y);
const fixed_t xscale = FixedDiv((vid.width / 2) << FRACBITS, tr); fixed_t xscale = FixedDiv((vid.width / 2) << FRACBITS, tr);
// Less change in contrast at further distances, to counteract DOOM diminished light // Less change in contrast at further distances, to counteract DOOM diminished light
const fixed_t n = FixedDiv(FixedMul(xscale, LIGHTRESOLUTIONFIX), ((MAXLIGHTSCALE-1) << LIGHTSCALESHIFT)); fixed_t n = FixedDiv(FixedMul(xscale, LIGHTRESOLUTIONFIX), ((MAXLIGHTSCALE-1) << LIGHTSCALESHIFT));
extralight = FixedMul(extralight, std::min(n, FRACUNIT)); extralight = FixedMul(extralight, std::min(n, FRACUNIT));
// Contrast is stronger for normal sprites, stronger than wall lighting is at the same distance // Contrast is stronger for normal sprites, stronger than wall lighting is at the same distance
@@ -517,7 +515,7 @@ static FUINT HWR_CalcWallLight(FUINT lightnum, seg_t *seg, extracolormap_t *colo
if (seg != NULL && P_ApplyLightOffsetFine(lightnum, seg->frontsector)) if (seg != NULL && P_ApplyLightOffsetFine(lightnum, seg->frontsector))
{ {
const INT16 offset = (cv_glfakecontrast.value == 2) ? seg->hwLightOffset : ((INT16)seg->lightOffset * 8); INT16 offset = (cv_glfakecontrast.value == 2) ? seg->hwLightOffset : ((INT16)seg->lightOffset * 8);
finallight += offset; finallight += offset;
finallight = CLAMP(finallight, 0 , 255); finallight = CLAMP(finallight, 0 , 255);
@@ -535,7 +533,7 @@ static FUINT HWR_CalcSlopeLight(FUINT lightnum, pslope_t *slope, const sector_t
if (slope != NULL && sector != NULL && P_ApplyLightOffsetFine(lightnum, sector)) if (slope != NULL && sector != NULL && P_ApplyLightOffsetFine(lightnum, sector))
{ {
const INT16 offset = (cv_glfakecontrast.value == 2) ? slope->hwLightOffset : ((INT16)slope->lightOffset * 8); INT16 offset = (cv_glfakecontrast.value == 2) ? slope->hwLightOffset : ((INT16)slope->lightOffset * 8);
finallight += (fof ? -offset : offset); finallight += (fof ? -offset : offset);
finallight = CLAMP(finallight, 0 , 255); finallight = CLAMP(finallight, 0 , 255);
@@ -552,7 +550,7 @@ static FUINT HWR_CalcSlopeLight(FUINT lightnum, pslope_t *slope, const sector_t
// Render a floor or ceiling convex polygon // Render a floor or ceiling convex polygon
static void HWR_RenderPlane(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) static void HWR_RenderPlane(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 = {}; FSurfaceInfo Surf;
FOutVector *v3d; FOutVector *v3d;
polyvertex_t *pv; polyvertex_t *pv;
pslope_t *slope = NULL; pslope_t *slope = NULL;
@@ -589,11 +587,15 @@ static void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, bool
const sector_t *sec = FOFsector ? FOFsector : gl_frontsector; const sector_t *sec = FOFsector ? FOFsector : gl_frontsector;
// Get the slope pointer to simplify future code // Get the slope pointer to simplify future code
if (!isceiling && sec->f_slope) if (sec->f_slope && !isceiling)
slope = sec->f_slope; slope = sec->f_slope;
else if (isceiling && sec->c_slope) else if (sec->c_slope && isceiling)
slope = sec->c_slope; slope = sec->c_slope;
// Set fixedheight to the slope's height from our viewpoint, if we have a slope
if (slope)
fixedheight = P_GetSlopeZAt(slope, viewx, viewy);
height = FixedToFloat(fixedheight); height = FixedToFloat(fixedheight);
// Allocate plane-vertex buffer if we need to // Allocate plane-vertex buffer if we need to
@@ -685,19 +687,18 @@ static void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, bool
vert->s = (tempxsow * cosangf) - (tempytow * sinangf);\ vert->s = (tempxsow * cosangf) - (tempytow * sinangf);\
vert->t = (tempxsow * sinangf) + (tempytow * cosangf);\ vert->t = (tempxsow * sinangf) + (tempytow * cosangf);\
}\ }\
\
if (slope)\
{\
fixedheight = P_GetSlopeZAt(slope, FloatToFixed((vx)), FloatToFixed((vy)));\
height = FixedToFloat(fixedheight);\
}\
\ \
vert->x = (vx);\ vert->x = (vx);\
vert->y = height;\ vert->y = height;\
vert->z = (vy);\ vert->z = (vy);\
\ \
if (slope)\
{\
fixedheight = P_GetSlopeZAt(slope, FloatToFixed((vx)), FloatToFixed((vy)));\
vert->y = FixedToFloat(fixedheight);\
}\
} }
for (i = 0, v3d = planeVerts; i < (INT32)nrPlaneVerts; i++,v3d++, pv++) for (i = 0, v3d = planeVerts; i < (INT32)nrPlaneVerts; i++,v3d++,pv++)
SETUP3DVERT(v3d, pv->x, pv->y); SETUP3DVERT(v3d, pv->x, pv->y);
if (slope) if (slope)
@@ -1377,9 +1378,10 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
extracolormap_t *colormap = gl_frontsector->extra_colormap; extracolormap_t *colormap = gl_frontsector->extra_colormap;
lightnum = HWR_CalcWallLight(lightnum, gl_curline, colormap); lightnum = HWR_CalcWallLight(lightnum, gl_curline, colormap);
FSurfaceInfo Surf = {}; FSurfaceInfo Surf;
Surf.PolyColor.s.alpha = 255; if (gl_frontsector)
Surf.PolyColor.s.alpha = 255;
const INT32 gl_midtexture = R_GetTextureNum(gl_sidedef->midtexture); const INT32 gl_midtexture = R_GetTextureNum(gl_sidedef->midtexture);
GLMapTexture_t *glTex = NULL; GLMapTexture_t *glTex = NULL;
@@ -1422,11 +1424,6 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
{ {
draw_sky_walls(0, 1, worldhigh, worldhighslope); draw_sky_walls(0, 1, worldhigh, worldhighslope);
} }
// hack to allow height changes in outdoor areas
// This is what gets rid of the upper textures if there should be sky
worldtop = worldhigh;
worldtopslope = worldhighslope;
} }
else else
{ {
@@ -1471,6 +1468,15 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
} }
} }
// hack to allow height changes in outdoor areas
// This is what gets rid of the upper textures if there should be sky
if (gl_frontsector->ceilingpic == skyflatnum
&& gl_backsector->ceilingpic == skyflatnum)
{
worldtop = worldhigh;
worldtopslope = worldhighslope;
}
gl_toptexture = R_GetTextureNum(gl_sidedef->toptexture); gl_toptexture = R_GetTextureNum(gl_sidedef->toptexture);
// check TOP TEXTURE // check TOP TEXTURE
@@ -1779,10 +1785,10 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
// Single sided line... Deal only with the middletexture (if one exists) // Single sided line... Deal only with the middletexture (if one exists)
if (gl_midtexture && gl_linedef->special != HORIZONSPECIAL) // Ignore horizon line for OGL if (gl_midtexture && gl_linedef->special != HORIZONSPECIAL) // Ignore horizon line for OGL
{ {
fixed_t texturevpeg;
glTex = HWR_GetTexture(gl_midtexture, noencore); glTex = HWR_GetTexture(gl_midtexture, noencore);
fixed_t texturevpeg;
// PEGGING // PEGGING
if ((gl_linedef->flags & (ML_DONTPEGBOTTOM|ML_EFFECT2)) == (ML_DONTPEGBOTTOM|ML_EFFECT2)) if ((gl_linedef->flags & (ML_DONTPEGBOTTOM|ML_EFFECT2)) == (ML_DONTPEGBOTTOM|ML_EFFECT2))
texturevpeg = gl_frontsector->floorheight + textureheight[gl_sidedef->midtexture] - gl_frontsector->ceilingheight + gl_sidedef->rowoffset; texturevpeg = gl_frontsector->floorheight + textureheight[gl_sidedef->midtexture] - gl_frontsector->ceilingheight + gl_sidedef->rowoffset;
@@ -1869,8 +1875,8 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
//Hurdler: 3d-floors test //Hurdler: 3d-floors test
if (!gl_drawing_stencil && gl_backsector && gl_frontsector->tag != gl_backsector->tag && (gl_backsector->ffloors || gl_frontsector->ffloors)) if (!gl_drawing_stencil && gl_backsector && gl_frontsector->tag != gl_backsector->tag && (gl_backsector->ffloors || gl_frontsector->ffloors))
{ {
ffloor_t *rover; ffloor_t * rover;
fixed_t highcut = 0, lowcut = 0; fixed_t highcut = 0, lowcut = 0;
fixed_t lowcutslope = 0, highcutslope = 0; fixed_t lowcutslope = 0, highcutslope = 0;
// Used for height comparisons and etc across FOFs and slopes // Used for height comparisons and etc across FOFs and slopes
@@ -2261,7 +2267,7 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
static inline boolean HWR_UsePortals(void) static inline boolean HWR_UsePortals(void)
{ {
return supportstencil && gl_maphasportals && cv_glportals.value; return supportstencil && cv_glportals.value && gl_maphasportals;
} }
// From PrBoom: // From PrBoom:
@@ -2405,8 +2411,7 @@ static inline void DoAddLine(seg_t* line, angle_t angle1, angle_t angle2)
// SoM: Backsector needs to be run through R_FakeFlat // SoM: Backsector needs to be run through R_FakeFlat
static sector_t tempsec; static sector_t tempsec;
auto do_addline = [&](bool dontdraw) auto do_addline = [&](bool dontdraw) {
{
// Single sided line? // Single sided line?
if (!line->backsector) if (!line->backsector)
{ {
@@ -2673,7 +2678,7 @@ static void HWR_RenderPolyObjectPlane(polyobj_t *polysector, boolean isceiling,
float scrollx = 0.0f, scrolly = 0.0f; float scrollx = 0.0f, scrolly = 0.0f;
float anglef = 0.0f, cosangf = 0.0f, sinangf = 0.0f; float anglef = 0.0f, cosangf = 0.0f, sinangf = 0.0f;
angle_t angle = 0; angle_t angle = 0;
FSurfaceInfo Surf = {}; FSurfaceInfo Surf;
fixed_t tempxsow, tempytow; fixed_t tempxsow, tempytow;
size_t nrPlaneVerts; size_t nrPlaneVerts;
@@ -2687,6 +2692,14 @@ static void HWR_RenderPolyObjectPlane(polyobj_t *polysector, boolean isceiling,
if (nrPlaneVerts < 3) // not even a triangle ? if (nrPlaneVerts < 3) // not even a triangle ?
return; return;
if (nrPlaneVerts > INT16_MAX) // FIXME: exceeds plVerts size
{
CONS_Debug(DBG_RENDER, "polygon size of %s exceeds max value of %d vertices\n", sizeu1(nrPlaneVerts), UINT16_MAX);
return;
}
const sector_t *sec = FOFsector ? FOFsector : gl_frontsector;
// Allocate plane-vertex buffer if we need to // Allocate plane-vertex buffer if we need to
if (!planeVerts || nrPlaneVerts > numAllocedPlaneVerts) if (!planeVerts || nrPlaneVerts > numAllocedPlaneVerts)
{ {
@@ -2695,8 +2708,6 @@ static void HWR_RenderPolyObjectPlane(polyobj_t *polysector, boolean isceiling,
Z_Malloc(numAllocedPlaneVerts * sizeof(FOutVector), PU_LEVEL, &planeVerts); Z_Malloc(numAllocedPlaneVerts * sizeof(FOutVector), PU_LEVEL, &planeVerts);
} }
const sector_t *sec = FOFsector ? FOFsector : gl_frontsector;
height = FixedToFloat(fixedheight); height = FixedToFloat(fixedheight);
len = W_LumpLength(lumpnum); len = W_LumpLength(lumpnum);
@@ -2834,8 +2845,9 @@ static void HWR_AddPolyObjectPlanes(void)
light = R_GetPlaneLight(gl_frontsector, polyobjsector->floorheight, true); light = R_GetPlaneLight(gl_frontsector, polyobjsector->floorheight, true);
if (po_ptrs[i]->translucency > 0) if (po_ptrs[i]->translucency > 0)
{ {
FSurfaceInfo Surf = {}; FSurfaceInfo Surf;
FBITFIELD blendmode; FBITFIELD blendmode;
memset(&Surf, 0x00, sizeof(Surf));
blendmode = HWR_TranstableToAlpha(po_ptrs[i]->translucency, &Surf); blendmode = HWR_TranstableToAlpha(po_ptrs[i]->translucency, &Surf);
HWR_AddTransparentPolyobjectFloor(levelflats[polyobjsector->floorpic].lumpnum, po_ptrs[i], false, polyobjsector->floorheight, HWR_AddTransparentPolyobjectFloor(levelflats[polyobjsector->floorpic].lumpnum, po_ptrs[i], false, polyobjsector->floorheight,
(light == -1 ? gl_frontsector->lightlevel : *gl_frontsector->lightlist[light].lightlevel), Surf.PolyColor.s.alpha, polyobjsector, blendmode, (light == -1 ? gl_frontsector->extra_colormap : gl_frontsector->lightlist[light].extra_colormap)); (light == -1 ? gl_frontsector->lightlevel : *gl_frontsector->lightlist[light].lightlevel), Surf.PolyColor.s.alpha, polyobjsector, blendmode, (light == -1 ? gl_frontsector->extra_colormap : gl_frontsector->lightlist[light].extra_colormap));
@@ -2856,8 +2868,9 @@ static void HWR_AddPolyObjectPlanes(void)
light = R_GetPlaneLight(gl_frontsector, polyobjsector->ceilingheight, true); light = R_GetPlaneLight(gl_frontsector, polyobjsector->ceilingheight, true);
if (po_ptrs[i]->translucency > 0) if (po_ptrs[i]->translucency > 0)
{ {
FSurfaceInfo Surf = {}; FSurfaceInfo Surf;
FBITFIELD blendmode; FBITFIELD blendmode;
memset(&Surf, 0x00, sizeof(Surf));
blendmode = HWR_TranstableToAlpha(po_ptrs[i]->translucency, &Surf); blendmode = HWR_TranstableToAlpha(po_ptrs[i]->translucency, &Surf);
HWR_AddTransparentPolyobjectFloor(levelflats[polyobjsector->ceilingpic].lumpnum, po_ptrs[i], true, polyobjsector->ceilingheight, HWR_AddTransparentPolyobjectFloor(levelflats[polyobjsector->ceilingpic].lumpnum, po_ptrs[i], true, polyobjsector->ceilingheight,
(light == -1 ? gl_frontsector->lightlevel : *gl_frontsector->lightlist[light].lightlevel), Surf.PolyColor.s.alpha, polyobjsector, blendmode, (light == -1 ? gl_frontsector->extra_colormap : gl_frontsector->lightlist[light].extra_colormap)); (light == -1 ? gl_frontsector->lightlevel : *gl_frontsector->lightlist[light].lightlevel), Surf.PolyColor.s.alpha, polyobjsector, blendmode, (light == -1 ? gl_frontsector->extra_colormap : gl_frontsector->lightlist[light].extra_colormap));
@@ -2934,7 +2947,7 @@ static void HWR_Subsector(size_t num)
static sector_t tempsec; //SoM: 4/7/2000 static sector_t tempsec; //SoM: 4/7/2000
INT32 floorlightlevel; INT32 floorlightlevel;
INT32 ceilinglightlevel; INT32 ceilinglightlevel;
INT32 locFloorHeight = 0, locCeilingHeight = 0; INT32 locFloorHeight, locCeilingHeight;
INT32 cullFloorHeight, cullCeilingHeight; INT32 cullFloorHeight, cullCeilingHeight;
INT32 light = 0; INT32 light = 0;
extracolormap_t *floorcolormap; extracolormap_t *floorcolormap;
@@ -2980,12 +2993,11 @@ static void HWR_Subsector(size_t num)
cullFloorHeight = P_GetSectorFloorZAt (gl_frontsector, viewx, viewy); cullFloorHeight = P_GetSectorFloorZAt (gl_frontsector, viewx, viewy);
cullCeilingHeight = P_GetSectorCeilingZAt(gl_frontsector, viewx, viewy); cullCeilingHeight = P_GetSectorCeilingZAt(gl_frontsector, viewx, viewy);
locFloorHeight = P_GetSectorFloorZAt (gl_frontsector, gl_frontsector->soundorg.x, gl_frontsector->soundorg.y);
locCeilingHeight = P_GetSectorCeilingZAt(gl_frontsector, gl_frontsector->soundorg.x, gl_frontsector->soundorg.y);
if (gl_frontsector->ffloors) if (gl_frontsector->ffloors)
{ {
locFloorHeight = P_GetSectorFloorZAt (gl_frontsector, gl_frontsector->soundorg.x, gl_frontsector->soundorg.y);
locCeilingHeight = P_GetSectorCeilingZAt(gl_frontsector, gl_frontsector->soundorg.x, gl_frontsector->soundorg.y);
boolean anyMoved = gl_frontsector->moved; boolean anyMoved = gl_frontsector->moved;
if (anyMoved == false) if (anyMoved == false)
@@ -3040,7 +3052,8 @@ static void HWR_Subsector(size_t num)
{ {
HWR_GetFlat(levelflats[gl_frontsector->floorpic].lumpnum, R_NoEncore(gl_frontsector, false)); HWR_GetFlat(levelflats[gl_frontsector->floorpic].lumpnum, R_NoEncore(gl_frontsector, false));
HWR_RenderPlane(sub, &extrasubsectors[num], false, HWR_RenderPlane(sub, &extrasubsectors[num], false,
gl_frontsector->floorheight, // Hack to make things continue to work around slopes.
locFloorHeight == cullFloorHeight ? locFloorHeight : gl_frontsector->floorheight,
// We now return you to your regularly scheduled rendering. // We now return you to your regularly scheduled rendering.
PF_Occlude, floorlightlevel, levelflats[gl_frontsector->floorpic].lumpnum, NULL, 255, floorcolormap); PF_Occlude, floorlightlevel, levelflats[gl_frontsector->floorpic].lumpnum, NULL, 255, floorcolormap);
} }
@@ -3055,7 +3068,8 @@ static void HWR_Subsector(size_t num)
{ {
HWR_GetFlat(levelflats[gl_frontsector->ceilingpic].lumpnum, R_NoEncore(gl_frontsector, true)); HWR_GetFlat(levelflats[gl_frontsector->ceilingpic].lumpnum, R_NoEncore(gl_frontsector, true));
HWR_RenderPlane(sub, &extrasubsectors[num], true, HWR_RenderPlane(sub, &extrasubsectors[num], true,
gl_frontsector->ceilingheight, // Hack to make things continue to work around slopes.
locCeilingHeight == cullCeilingHeight ? locCeilingHeight : gl_frontsector->ceilingheight,
// We now return you to your regularly scheduled rendering. // We now return you to your regularly scheduled rendering.
PF_Occlude, ceilinglightlevel, levelflats[gl_frontsector->ceilingpic].lumpnum, NULL, 255, ceilingcolormap); PF_Occlude, ceilinglightlevel, levelflats[gl_frontsector->ceilingpic].lumpnum, NULL, 255, ceilingcolormap);
} }
@@ -3409,7 +3423,7 @@ static void HWR_DrawSpriteShadow(gl_vissprite_t *spr, patch_t *gpatch, GLPatch_t
{ {
float this_scale = 1.0f; float this_scale = 1.0f;
FOutVector swallVerts[4]; FOutVector swallVerts[4];
FSurfaceInfo sSurf = {}; FSurfaceInfo sSurf;
FBITFIELD blendmode = 0; FBITFIELD blendmode = 0;
fixed_t floorheight, mobjfloor; fixed_t floorheight, mobjfloor;
pslope_t *floorslope; pslope_t *floorslope;
@@ -3645,7 +3659,7 @@ static void HWR_SplitSprite(gl_vissprite_t *spr, const boolean papersprite)
FOutVector baseWallVerts[4]; // This is what the verts should end up as FOutVector baseWallVerts[4]; // This is what the verts should end up as
patch_t *gpatch; patch_t *gpatch;
GLPatch_t *hwrpatch; GLPatch_t *hwrpatch;
FSurfaceInfo Surf = {}; FSurfaceInfo Surf;
extracolormap_t *colormap; extracolormap_t *colormap;
INT32 lightlevel; INT32 lightlevel;
boolean lightset = true; boolean lightset = true;
@@ -3674,7 +3688,7 @@ static void HWR_SplitSprite(gl_vissprite_t *spr, const boolean papersprite)
//Hurdler: 25/04/2000: now support colormap in hardware mode //Hurdler: 25/04/2000: now support colormap in hardware mode
HWR_GetMappedPatch(gpatch, spr->colormap); HWR_GetMappedPatch(gpatch, spr->colormap);
hwrpatch = static_cast<GLPatch_t *>(gpatch->hardware); hwrpatch = ((GLPatch_t *)gpatch->hardware);
// Draw shadow BEFORE sprite // Draw shadow BEFORE sprite
if (UNLIKELY(cv_shadow.value // Shadows enabled if (UNLIKELY(cv_shadow.value // Shadows enabled
@@ -3772,15 +3786,8 @@ static void HWR_SplitSprite(gl_vissprite_t *spr, const boolean papersprite)
blend = HWR_GetBlendModeFlag(blendmode)|PF_Occlude; blend = HWR_GetBlendModeFlag(blendmode)|PF_Occlude;
} }
if (sprmo->player) if (cv_playerfade.value && sprmo->player)
{ Surf.PolyColor.s.alpha = FixedMul(R_DoPlayerFade(sprmo), Surf.PolyColor.s.alpha);
// make hyu´d players translucent with reducevfx, could be done better, but im lazy as crap
if (cv_reducevfx.value && sprmo->player->kartstuff[k_hyudorotimer] > 0)
Surf.PolyColor.s.alpha = static_cast<UINT8>(FixedMul(FRACUNIT/2, static_cast<fixed_t>(Surf.PolyColor.s.alpha)));
if (cv_playerfade.value)
Surf.PolyColor.s.alpha = static_cast<UINT8>(FixedMul(R_DoPlayerFade(sprmo), static_cast<fixed_t>(Surf.PolyColor.s.alpha)));
}
if (HWR_UseShader()) if (HWR_UseShader())
{ {
@@ -3864,7 +3871,7 @@ static void HWR_SplitSprite(gl_vissprite_t *spr, const boolean papersprite)
wallVerts[1].y = endbot; wallVerts[1].y = endbot;
// The x and y only need to be adjusted in the case that it's not a papersprite // The x and y only need to be adjusted in the case that it's not a papersprite
if (cv_glspritebillboarding.value && !papersprite) if (cv_glspritebillboarding.value && sprmo && !papersprite)
{ {
// Get the x and z of the vertices so billboarding draws correctly // Get the x and z of the vertices so billboarding draws correctly
realheight = realbot - realtop; realheight = realbot - realtop;
@@ -3930,7 +3937,7 @@ static void HWR_DrawSprite(gl_vissprite_t *spr)
FOutVector wallVerts[4]; FOutVector wallVerts[4];
patch_t *gpatch; // sprite patch converted to hardware patch_t *gpatch; // sprite patch converted to hardware
GLPatch_t *hwrpatch; GLPatch_t *hwrpatch;
FSurfaceInfo Surf = {}; FSurfaceInfo Surf;
FBITFIELD blend = 0; FBITFIELD blend = 0;
INT32 shader = SHADER_NONE; INT32 shader = SHADER_NONE;
@@ -3962,7 +3969,7 @@ static void HWR_DrawSprite(gl_vissprite_t *spr)
//Hurdler: 25/04/2000: now support colormap in hardware mode //Hurdler: 25/04/2000: now support colormap in hardware mode
HWR_GetMappedPatch(gpatch, spr->colormap); HWR_GetMappedPatch(gpatch, spr->colormap);
hwrpatch = static_cast<GLPatch_t *>(gpatch->hardware); hwrpatch = ((GLPatch_t *)gpatch->hardware);
// create the sprite billboard // create the sprite billboard
// //
@@ -4069,15 +4076,8 @@ static void HWR_DrawSprite(gl_vissprite_t *spr)
blend = HWR_GetBlendModeFlag(blendmode)|PF_Occlude; blend = HWR_GetBlendModeFlag(blendmode)|PF_Occlude;
} }
if (sprmo->player) if (cv_playerfade.value && sprmo->player)
{ Surf.PolyColor.s.alpha = FixedMul(R_DoPlayerFade(sprmo), Surf.PolyColor.s.alpha);
// make hyu´d players translucent with reducevfx, could be done better, but im lazy as crap
if (cv_reducevfx.value && sprmo->player->kartstuff[k_hyudorotimer] > 0)
Surf.PolyColor.s.alpha = static_cast<UINT8>(FixedMul(FRACUNIT/2, static_cast<fixed_t>(Surf.PolyColor.s.alpha)));
if (cv_playerfade.value)
Surf.PolyColor.s.alpha = static_cast<UINT8>(FixedMul(R_DoPlayerFade(sprmo), static_cast<fixed_t>(Surf.PolyColor.s.alpha)));
}
if (HWR_UseShader()) if (HWR_UseShader())
{ {
@@ -4095,7 +4095,7 @@ static void HWR_DrawPrecipitationSprite(gl_vissprite_t *spr)
FOutVector wallVerts[4]; FOutVector wallVerts[4];
patch_t *gpatch; // sprite patch converted to hardware patch_t *gpatch; // sprite patch converted to hardware
GLPatch_t *hwrpatch; GLPatch_t *hwrpatch;
FSurfaceInfo Surf = {}; FSurfaceInfo Surf;
INT32 shader = SHADER_NONE; INT32 shader = SHADER_NONE;
@@ -4112,7 +4112,7 @@ static void HWR_DrawPrecipitationSprite(gl_vissprite_t *spr)
//Hurdler: 25/04/2000: now support colormap in hardware mode //Hurdler: 25/04/2000: now support colormap in hardware mode
HWR_GetMappedPatch(gpatch, spr->colormap); HWR_GetMappedPatch(gpatch, spr->colormap);
hwrpatch = static_cast<GLPatch_t *>(gpatch->hardware); hwrpatch = ((GLPatch_t *)gpatch->hardware);
// create the sprite billboard // create the sprite billboard
// //
@@ -4503,6 +4503,7 @@ static void HWR_RenderDrawNodes(void)
drawnodes.clear(); // clear so our size is 0 again! drawnodes.clear(); // clear so our size is 0 again!
} }
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// Draw all vissprites // Draw all vissprites
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -4839,7 +4840,7 @@ static void HWR_ProjectSprite(mobj_t *thing)
flip = sprframe->flip; // Will only be 0x00 or 0xFF flip = sprframe->flip; // Will only be 0x00 or 0xFF
if (papersprite && ang < ANGLE_180) if (papersprite && ang < ANGLE_180)
flip ^= 0xFF; flip ^= 0xFFFF;
} }
else else
{ {
@@ -5432,7 +5433,7 @@ static void HWR_SetTransformAiming(FTransform *trans)
fixed_t fixedaiming = AIMINGTODY(aimingangle); fixed_t fixedaiming = AIMINGTODY(aimingangle);
trans->viewaiming = FixedToFloat(fixedaiming) * (static_cast<float>(vid.width) / static_cast<float>(vid.height)) / (static_cast<float>(BASEVIDWIDTH) / static_cast<float>(BASEVIDHEIGHT)); trans->viewaiming = FixedToFloat(fixedaiming) * (static_cast<float>(vid.width) / static_cast<float>(vid.height)) / (static_cast<float>(BASEVIDWIDTH) / static_cast<float>(BASEVIDHEIGHT));
if (splitscreen == 1) // only for 2 player splitscreen if (splitscreen == 1) // only for 2 player splitscreen
trans->viewaiming *= 2.125f; // splitscreen adjusts fov with 0.8, so compensate (but only halfway, since splitscreen means only half the screen is used) trans->viewaiming *= 2.125; // splitscreen adjusts fov with 0.8, so compensate (but only halfway, since splitscreen means only half the screen is used)
trans->shearing = true; trans->shearing = true;
gl_aimingangle = 0; gl_aimingangle = 0;
} }
@@ -5537,7 +5538,7 @@ static void HWR_RenderViewpoint(gl_portal_t *rootportal, int stencil_level, bool
player_t *viewplayer = &players[displayplayers[viewssnum]]; player_t *viewplayer = &players[displayplayers[viewssnum]];
const float fpov = FixedToFloat(R_GetPlayerFov(viewplayer)); const float fpov = FixedToFloat(R_GetPlayerFov(viewplayer));
auto reset_viewstate = [&]() auto reset_viewstate = [&](const float fpov)
{ {
HWR_SetTransform(fpov); HWR_SetTransform(fpov);
HWR_ClearSprites(); HWR_ClearSprites();
@@ -5557,7 +5558,7 @@ static void HWR_RenderViewpoint(gl_portal_t *rootportal, int stencil_level, bool
currentportallist = &portallist; currentportallist = &portallist;
HWR_SetPortalState(GLPORTAL_SEARCH); HWR_SetPortalState(GLPORTAL_SEARCH);
reset_viewstate(); reset_viewstate(fpov);
if (rootportal) if (rootportal)
{ {
@@ -5583,7 +5584,7 @@ static void HWR_RenderViewpoint(gl_portal_t *rootportal, int stencil_level, bool
// draw normal things in current frame in current incremented stencil buffer area // draw normal things in current frame in current incremented stencil buffer area
HWR_SetStencilState(HWR_STENCIL_NORMAL, stencil_level); HWR_SetStencilState(HWR_STENCIL_NORMAL, stencil_level);
reset_viewstate(); reset_viewstate(fpov);
if constexpr (Type == RenderViewpointType::kPortal) if constexpr (Type == RenderViewpointType::kPortal)
{ {
@@ -5902,6 +5903,7 @@ void HWR_AddCommands(void)
CV_RegisterVar(&cv_glpaletterendering); CV_RegisterVar(&cv_glpaletterendering);
CV_RegisterVar(&cv_glpalettedepth); CV_RegisterVar(&cv_glpalettedepth);
CV_RegisterVar(&cv_glflashpal);
} }
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -5981,7 +5983,7 @@ static void COM_HWR_glinfo(void)
// if the GPU is super new and supports a bajillion extensions - xyzzy // if the GPU is super new and supports a bajillion extensions - xyzzy
char *copy = strdup((const char*)gl_extensions); char *copy = strdup((const char*)gl_extensions);
char *ext; char *ext = strtok(copy, " ");
if (copy == NULL) if (copy == NULL)
{ {
@@ -5989,8 +5991,6 @@ static void COM_HWR_glinfo(void)
return; return;
} }
ext = strtok(copy, " ");
do do
{ {
CONS_Printf(" - %s\n", ext); CONS_Printf(" - %s\n", ext);
@@ -6060,7 +6060,7 @@ static void HWR_DoPostProcessor(void)
{ {
// Armageddon Blast Flash! // Armageddon Blast Flash!
// Could this even be considered postprocessor? // Could this even be considered postprocessor?
if (!HWR_ShouldUsePaletteRendering()) if (!HWR_PalRenderFlashpal())
{ {
const player_t *player = &players[displayplayers[viewssnum]]; const player_t *player = &players[displayplayers[viewssnum]];
@@ -6073,7 +6073,7 @@ static void HWR_DoPostProcessor(void)
{-4.0f, -4.0f, 4.0f, 0.0f, 0.0f} {-4.0f, -4.0f, 4.0f, 0.0f, 0.0f}
}; };
FSurfaceInfo Surf = {}; FSurfaceInfo Surf;
// This won't change if the flash palettes are changed unfortunately, but it works for its purpose // This won't change if the flash palettes are changed unfortunately, but it works for its purpose
if (player->flashpal == PAL_NUKE) if (player->flashpal == PAL_NUKE)
@@ -6095,62 +6095,61 @@ static void HWR_DoPostProcessor(void)
if (cv_glscreentextures.value != 2) // screen textures are needed for the rest of the effects if (cv_glscreentextures.value != 2) // screen textures are needed for the rest of the effects
return; return;
// Not supported in splitscreen - someone want to add support? //UINT8 viewnum = R_GetViewNumber(); // see below
if (splitscreen || cv_reducevfx.value)
return;
//UINT8 viewnum = R_GetViewNumber();
//camera_t *thiscam = &camera[viewnum]; //camera_t *thiscam = &camera[viewnum];
const camera_t *thiscam = &camera[0]; const camera_t *thiscam = &camera[0];
if (!(thiscam->postimg & POSTIMG_WATER || thiscam->postimg & POSTIMG_HEAT)) // Not supported in splitscreen - someone want to add support?
return; const boolean screenwave = (!splitscreen && (thiscam->postimg & POSTIMG_WATER || thiscam->postimg & POSTIMG_HEAT));
// Capture the screen for intermission and screen waving // Capture the screen for intermission and screen waving
if (gamestate != GS_INTERMISSION) if ((lastdraw || screenwave) && gamestate != GS_INTERMISSION)
GL_MakeScreenTexture(HWD_SCREENTEXTURE_GENERIC1); GL_MakeScreenTexture(HWD_SCREENTEXTURE_GENERIC1);
// Drunken vision! WooOOooo~ // Drunken vision! WooOOooo~
// 10 by 10 grid. 2 coordinates (xy) if (screenwave)
float v[SCREENVERTS][SCREENVERTS][2];
float disStart = (leveltime-1) + FixedToFloat(R_GetTimeFrac(RTF_LEVEL));
UINT8 x, y;
float WAVELENGTH;
float AMPLITUDE;
float FREQUENCY;
// Modifies the wave.
if (thiscam->postimg & POSTIMG_WATER)
{ {
WAVELENGTH = 5.0f; // 10 by 10 grid. 2 coordinates (xy)
AMPLITUDE = 40.0f; float v[SCREENVERTS][SCREENVERTS][2];
FREQUENCY = 8.0f; float disStart = (leveltime-1) + FixedToFloat(R_GetTimeFrac(RTF_LEVEL));
}
else
{
WAVELENGTH = 10.0f;
AMPLITUDE = 60.0f;
FREQUENCY = 4.0f;
}
//static constexpr float scale = ((float)SCREENVERTS - 1.0f) / 9.0f; // well this evals to just 1.0f and what is x / 1? kek UINT8 x, y;
float WAVELENGTH;
float AMPLITUDE;
float FREQUENCY;
for (x = 0; x < SCREENVERTS; x++) // Modifies the wave.
{ if (thiscam->postimg & POSTIMG_WATER)
for (y = 0; y < SCREENVERTS; y++)
{ {
// Change X position based on its Y position. WAVELENGTH = 5.0f;
v[x][y][0] = x-4.5f + sinf(((disStart+(static_cast<float>(y) * WAVELENGTH)) / FREQUENCY)) / AMPLITUDE; // (x / scale) AMPLITUDE = 40.0f;
v[x][y][1] = y-4.5f; // (y / scale) FREQUENCY = 8.0f;
} }
else
{
WAVELENGTH = 10.0f;
AMPLITUDE = 60.0f;
FREQUENCY = 4.0f;
}
//static constexpr float scale = ((float)SCREENVERTS - 1.0f) / 9.0f; // well this evals to just 1.0f and what is x / 1? kek
for (x = 0; x < SCREENVERTS; x++)
{
for (y = 0; y < SCREENVERTS; y++)
{
// Change X position based on its Y position.
v[x][y][0] = x-4.5f + sinf(((disStart+(static_cast<float>(y) * WAVELENGTH)) / FREQUENCY)) / AMPLITUDE; // (x / scale)
v[x][y][1] = y-4.5f; // (y / scale)
}
}
GL_PostImgRedraw(v);
// Capture the screen again for screen waving on the intermission
if (gamestate != GS_INTERMISSION)
GL_MakeScreenTexture(HWD_SCREENTEXTURE_GENERIC1);
} }
GL_PostImgRedraw(v);
// Capture the screen again for screen waving on the intermission
if (gamestate != GS_INTERMISSION)
GL_MakeScreenTexture(HWD_SCREENTEXTURE_GENERIC1);
// Flipping of the screen isn't done here anymore // Flipping of the screen isn't done here anymore
} }
+6 -5
View File
@@ -151,11 +151,6 @@ FUNCINLINE static ATTRINLINE void HWR_RenderVhsEffect(fixed_t upbary, fixed_t do
GL_RenderVhsEffect(upbary, downbary, updistort, downdistort, barsize); GL_RenderVhsEffect(upbary, downbary, updistort, downdistort, barsize);
} }
FUNCINLINE static ATTRINLINE void HWR_MakeScreenTexture(void)
{
GL_MakeScreenTexture(HWD_SCREENTEXTURE_GENERIC1);
}
FUNCINLINE static ATTRINLINE void HWR_MakeScreenFinalTexture(void) FUNCINLINE static ATTRINLINE void HWR_MakeScreenFinalTexture(void)
{ {
GL_MakeScreenTexture(HWD_SCREENTEXTURE_GENERIC2); GL_MakeScreenTexture(HWD_SCREENTEXTURE_GENERIC2);
@@ -213,6 +208,7 @@ extern consvar_t cv_glportals;
extern consvar_t cv_glpaletterendering; extern consvar_t cv_glpaletterendering;
extern consvar_t cv_glpalettedepth; extern consvar_t cv_glpalettedepth;
extern consvar_t cv_glflashpal;
FUNCINLINE static ATTRINLINE boolean HWR_UseShader(void) FUNCINLINE static ATTRINLINE boolean HWR_UseShader(void)
{ {
@@ -224,6 +220,11 @@ FUNCINLINE static ATTRINLINE boolean HWR_ShouldUsePaletteRendering(void)
return (cv_glpaletterendering.value && (pLocalPalette != NULL) && HWR_UseShader()); return (cv_glpaletterendering.value && (pLocalPalette != NULL) && HWR_UseShader());
} }
FUNCINLINE static ATTRINLINE boolean HWR_PalRenderFlashpal(void)
{
return (cv_glflashpal.value && HWR_ShouldUsePaletteRendering());
}
// Returns a pointer to the palette which should be used for caching textures. // Returns a pointer to the palette which should be used for caching textures.
FUNCINLINE static ATTRINLINE RGBA_t *HWR_GetTexturePalette(void) FUNCINLINE static ATTRINLINE RGBA_t *HWR_GetTexturePalette(void)
{ {
+22 -133
View File
@@ -579,7 +579,7 @@ md2found:
fclose(f); fclose(f);
} }
void HWR_AddPlayerMD2(INT32 skin, boolean local) // For MD2's that were added after startup void HWR_AddPlayerMD2(int skin, boolean local) // For MD2's that were added after startup
{ {
FILE *f; FILE *f;
char name[20], filename[32]; char name[20], filename[32];
@@ -693,15 +693,17 @@ static void HWR_CreateBlendedTexture(patch_t *gpatch, patch_t *blendgpatch, GLMi
GLPatch_t *hwrBlendPatch = blendgpatch->hardware; GLPatch_t *hwrBlendPatch = blendgpatch->hardware;
UINT16 w = gpatch->width, h = gpatch->height; UINT16 w = gpatch->width, h = gpatch->height;
UINT32 size = w*h; UINT32 size = w*h;
RGBA_t *image, *blendimage, *cur; RGBA_t *image, *blendimage, *cur, blendcolor;
RGBA_t blendcolor = {};
RGBA_t *palette = HWR_GetTexturePalette(); RGBA_t *palette = HWR_GetTexturePalette();
UINT8 translation[17] = {}; // First the color index UINT8 translation[17]; // First the color index
UINT8 cutoff[17] = {}; // Brightness cutoff before using the next color UINT8 cutoff[17]; // Brightness cutoff before using the next color
UINT8 translen = 0; UINT8 translen = 0;
UINT8 i; UINT8 i;
UINT8 colorbrightnesses[17] = {}; UINT8 colorbrightnesses[17];
UINT8 color_match_lookup[256] = {}; // optimization attempt UINT8 color_match_lookup[256]; // optimization attempt
memset(translation, 0, sizeof(translation));
memset(cutoff, 0, sizeof(cutoff));
if (glMipmap->width == 0) if (glMipmap->width == 0)
{ {
@@ -714,10 +716,14 @@ static void HWR_CreateBlendedTexture(patch_t *gpatch, patch_t *blendgpatch, GLMi
glMipmap->format = GL_TEXFMT_RGBA; glMipmap->format = GL_TEXFMT_RGBA;
} }
Z_Free(glMipmap->data); if (glMipmap->data)
glMipmap->data = NULL; {
Z_Free(glMipmap->data);
glMipmap->data = NULL;
}
cur = Z_Calloc(size*4, PU_HWRMODELTEXTURE, &glMipmap->data); cur = Z_Malloc(size*4, PU_HWRMODELTEXTURE, &glMipmap->data);
memset(cur, 0x00, size*4);
image = hwrPatch->mipmap->data; image = hwrPatch->mipmap->data;
blendimage = hwrBlendPatch->mipmap->data; blendimage = hwrBlendPatch->mipmap->data;
@@ -1031,6 +1037,7 @@ static void HWR_GetBlendedTexture(patch_t *patch, patch_t *blendgpatch, INT32 sk
GLPatch_t *glPatch = patch->hardware; GLPatch_t *glPatch = patch->hardware;
GLMipmap_t *glMipmap, *newMipmap; GLMipmap_t *glMipmap, *newMipmap;
if (blendgpatch == NULL || colormap == colormaps || colormap == NULL) if (blendgpatch == NULL || colormap == colormaps || colormap == NULL)
{ {
// Don't do any blending // Don't do any blending
@@ -1099,7 +1106,7 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
INT32 frame = 0; INT32 frame = 0;
INT32 nextFrame = -1; INT32 nextFrame = -1;
FTransform p; FTransform p;
FSurfaceInfo Surf = {}; FSurfaceInfo Surf;
if (!cv_glmdls.value || spr->precip) if (!cv_glmdls.value || spr->precip)
return; return;
@@ -1191,15 +1198,8 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
Surf.PolyFlags = HWR_GetBlendModeFlag(blendmode); Surf.PolyFlags = HWR_GetBlendModeFlag(blendmode);
} }
if (spr->mobj->player) if (cv_playerfade.value && spr->mobj->player)
{ Surf.PolyColor.s.alpha = FixedMul(R_DoPlayerFade(spr->mobj), Surf.PolyColor.s.alpha);
// make hyu´d players translucent with reducevfx, could be done better, but im lazy as crap
if (cv_reducevfx.value && spr->mobj->player->kartstuff[k_hyudorotimer] > 0)
Surf.PolyColor.s.alpha = FixedMul(FRACUNIT/2, Surf.PolyColor.s.alpha);
if (cv_playerfade.value)
Surf.PolyColor.s.alpha = FixedMul(R_DoPlayerFade(spr->mobj), Surf.PolyColor.s.alpha);
}
// dont forget to enabled the depth test because we can't do this like // dont forget to enabled the depth test because we can't do this like
// before: polygons models are not sorted // before: polygons models are not sorted
@@ -1336,8 +1336,8 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
if (spr->mobj->frame & FF_ANIMATE) if (spr->mobj->frame & FF_ANIMATE)
{ {
// set duration and tics to be the correct values for FF_ANIMATE states // set duration and tics to be the correct values for FF_ANIMATE states
durs = spr->mobj->state->var2; durs = (float)spr->mobj->state->var2;
tics = (INT32)spr->mobj->anim_duration; tics = (float)spr->mobj->anim_duration;
} }
//FIXME: this is not yet correct //FIXME: this is not yet correct
@@ -1468,115 +1468,4 @@ void HWR_DrawMD2(gl_vissprite_t *spr)
} }
} }
// mostly copy paste of HWR_DrawMD2
// very ugly but our model code kinda sucks
void HWR_Draw2DModel(md2_t *md2, INT32 x, INT32 y, INT32 skinnum, skincolors_t color, const UINT8 *colormap, fixed_t scale, INT32 frame, angle_t angle)
{
patch_t *gpatch, *blendgpatch;
GLPatch_t *hwrPatch = NULL, *hwrBlendPatch = NULL;
FTransform p;
FSurfaceInfo Surf = {};
if (!md2->model)
{
char filename[64];
CONS_Debug(DBG_RENDER, "Loading model... (%s)\n", md2->filename);
sprintf(filename, "mdls/%s", md2->filename);
md2->model = md2_readModel(filename);
if (md2->model)
{
md2_printModelInfo(md2->model);
GL_CreateModelVBOs(md2->model);
}
else
{
md2->error = true;
return;
}
}
if (md2->model->meshes[0].numFrames > 0)
frame = frame % md2->model->meshes[0].numFrames;
else
frame = 0;
gpatch = (patch_t *)(md2->glpatch);
if (gpatch)
hwrPatch = ((GLPatch_t *)gpatch->hardware);
if (!gpatch || !hwrPatch ||
((!hwrPatch->mipmap->format || !hwrPatch->mipmap->downloaded) && !md2->notexturefile))
md2_loadTexture(md2);
gpatch = (patch_t*)(md2->glpatch);
if (gpatch)
hwrPatch = ((GLPatch_t *)gpatch->hardware);
blendgpatch = (patch_t*)(md2->blendglpatch);
if (blendgpatch)
hwrBlendPatch = ((GLPatch_t *)blendgpatch->hardware);
if ((gpatch && hwrPatch && hwrPatch->mipmap->format) &&
(!blendgpatch || !hwrBlendPatch ||
((!hwrBlendPatch->mipmap->format || !hwrBlendPatch->mipmap->downloaded) && !md2->noblendfile)))
md2_loadBlendTexture(md2);
blendgpatch = (patch_t*)(md2->blendglpatch);
if (blendgpatch)
hwrBlendPatch = ((GLPatch_t *)blendgpatch->hardware);
Surf.PolyColor.rgba = 0xFFFFFFFF;
Surf.PolyFlags = PF_Occlude | PF_Modulated;
Surf.LightInfo.light_level = 255;
Surf.LightInfo.fade_start = 0;
Surf.LightInfo.fade_end = 31;
if (color != SKINCOLOR_NONE &&
blendgpatch && hwrBlendPatch->mipmap->format &&
gpatch->width == blendgpatch->width && gpatch->height == blendgpatch->height)
{
INT32 tcskinnum = TC_DEFAULT;
if (color)
tcskinnum = skinnum;
HWR_GetBlendedTexture(gpatch, blendgpatch, tcskinnum, colormap, color);
}
else if (hwrPatch && hwrPatch->mipmap->format)
{
GL_SetTexture(hwrPatch->mipmap);
}
memset(&p, 0x00, sizeof(FTransform));
p.x = x*vid.dup + (float)(vid.width - BASEVIDWIDTH*vid.dup)/2.f;
p.y = -420.f; // push it back to prevent wonky culling, idk lul
p.z = y*vid.dup + (float)(vid.height - BASEVIDHEIGHT*vid.dup)/2.f;
p.angley = FixedToFloat(AngleFixed(angle));
p.anglex = 0.f;
p.anglez = 0.f;
p.roll = false;
p.fliptype = TRANSFORM_NONE;
const float fscale = FixedToFloat(scale*vid.dup);
GL_Draw2DModel(
md2->model,
frame,
0.f,
0.f,
-1,
&p,
fscale,
fscale,
true, // flip it vertically lul
false,
&Surf
);
}
#endif //HWRENDER #endif //HWRENDER
-3
View File
@@ -45,9 +45,6 @@ void HWR_InitMD2(void);
void HWR_DrawMD2(gl_vissprite_t *spr); void HWR_DrawMD2(gl_vissprite_t *spr);
void HWR_AddPlayerMD2(INT32 skin, boolean local); void HWR_AddPlayerMD2(INT32 skin, boolean local);
void HWR_AddSpriteMD2(size_t spritenum); void HWR_AddSpriteMD2(size_t spritenum);
void HWR_Draw2DModel(md2_t *md2, INT32 x, INT32 y, INT32 skinnum,
skincolors_t color, const UINT8 *colormap,
fixed_t scale, INT32 frame, angle_t angle);
#ifdef __cplusplus #ifdef __cplusplus
} // extern "C" } // extern "C"
+14 -14
View File
@@ -274,7 +274,7 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
if (!f) if (!f)
return NULL; return NULL;
retModel = (model_t*)Z_Calloc(sizeof(model_t), ztag, NULL); retModel = (model_t*)Z_Calloc(sizeof(model_t), ztag, 0);
//size_t fileLen; //size_t fileLen;
@@ -288,13 +288,13 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
{ {
texPos++; texPos++;
namelen = strlen(texPos) + 1; namelen = strlen(texPos) + 1;
texturefilename = (char*)Z_Malloc(namelen, PU_CACHE, NULL); texturefilename = (char*)Z_Malloc(namelen, PU_CACHE, 0);
strcpy(texturefilename, texPos); strcpy(texturefilename, texPos);
} }
else else
{ {
namelen = strlen(fileName) + 1; namelen = strlen(fileName) + 1;
texturefilename = (char*)Z_Malloc(namelen, PU_CACHE, NULL); texturefilename = (char*)Z_Malloc(namelen, PU_CACHE, 0);
strcpy(texturefilename, fileName); strcpy(texturefilename, fileName);
} }
@@ -316,7 +316,7 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
header = (md2header_t*)buffer; header = (md2header_t*)buffer;
retModel->numMeshes = 1; // MD2 only has one mesh retModel->numMeshes = 1; // MD2 only has one mesh
retModel->meshes = (mesh_t*)Z_Calloc(sizeof(mesh_t) * retModel->numMeshes, ztag, NULL); retModel->meshes = (mesh_t*)Z_Calloc(sizeof(mesh_t) * retModel->numMeshes, ztag, 0);
retModel->meshes[0].numFrames = header->numFrames; retModel->meshes[0].numFrames = header->numFrames;
// const float WUNITS = 1.0f; // const float WUNITS = 1.0f;
// float dataScale = WUNITS; // float dataScale = WUNITS;
@@ -332,7 +332,7 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
if (retModel->numMaterials <= 0) // Always at least one skin, duh if (retModel->numMaterials <= 0) // Always at least one skin, duh
retModel->numMaterials = 1; retModel->numMaterials = 1;
retModel->materials = (material_t*)Z_Calloc(sizeof(material_t)*retModel->numMaterials, ztag, NULL); retModel->materials = (material_t*)Z_Calloc(sizeof(material_t)*retModel->numMaterials, ztag, 0);
// int t; // int t;
for (t = 0; t < retModel->numMaterials; t++) for (t = 0; t < retModel->numMaterials; t++)
@@ -409,9 +409,9 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
float *uvptr; float *uvptr;
dataScale = 0.015624f; // 1 / 64.0f dataScale = 0.015624f; // 1 / 64.0f
retModel->meshes[0].tinyframes = (tinyframe_t*)Z_Calloc(sizeof(tinyframe_t)*header->numFrames, ztag, NULL); retModel->meshes[0].tinyframes = (tinyframe_t*)Z_Calloc(sizeof(tinyframe_t)*header->numFrames, ztag, 0);
retModel->meshes[0].numVertices = header->numXYZ; retModel->meshes[0].numVertices = header->numXYZ;
retModel->meshes[0].uvs = (float*)Z_Malloc(sizeof(float) * 2 * retModel->meshes[0].numVertices, ztag, NULL); retModel->meshes[0].uvs = (float*)Z_Malloc(sizeof(float) * 2 * retModel->meshes[0].numVertices, ztag, 0);
ptr = (char*)frames; ptr = (char*)frames;
for (i = 0; i < header->numFrames; i++, ptr += header->framesize) for (i = 0; i < header->numFrames; i++, ptr += header->framesize)
@@ -423,12 +423,12 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
md2vertex_t *vertex; md2vertex_t *vertex;
md2frame_t *framePtr = (md2frame_t*)ptr; md2frame_t *framePtr = (md2frame_t*)ptr;
retModel->meshes[0].tinyframes[i].vertices = (short*)Z_Malloc(sizeof(short) * 3 * header->numXYZ, ztag, NULL); retModel->meshes[0].tinyframes[i].vertices = (short*)Z_Malloc(sizeof(short) * 3 * header->numXYZ, ztag, 0);
retModel->meshes[0].tinyframes[i].normals = (char*)Z_Malloc(sizeof(char) * 3 * header->numXYZ, ztag, NULL); retModel->meshes[0].tinyframes[i].normals = (char*)Z_Malloc(sizeof(char) * 3 * header->numXYZ, ztag, 0);
// if (retModel->materials[0].lightmap) // if (retModel->materials[0].lightmap)
// retModel->meshes[0].tinyframes[i].tangents = (char*)malloc(sizeof(char));//(char*)Z_Malloc(sizeof(char)*3*header->numVerts, ztag); // retModel->meshes[0].tinyframes[i].tangents = (char*)malloc(sizeof(char));//(char*)Z_Malloc(sizeof(char)*3*header->numVerts, ztag);
retModel->meshes[0].indices = (unsigned short*)Z_Malloc(sizeof(unsigned short) * 3 * header->numTris, ztag, NULL); retModel->meshes[0].indices = (unsigned short*)Z_Malloc(sizeof(unsigned short) * 3 * header->numTris, ztag, 0);
vertptr = retModel->meshes[0].tinyframes[i].vertices; vertptr = retModel->meshes[0].tinyframes[i].vertices;
normptr = retModel->meshes[0].tinyframes[i].normals; normptr = retModel->meshes[0].tinyframes[i].normals;
@@ -484,8 +484,8 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
char *ptr; char *ptr;
retModel->meshes[0].numVertices = header->numTris * 3; retModel->meshes[0].numVertices = header->numTris * 3;
retModel->meshes[0].frames = (mdlframe_t*)Z_Calloc(sizeof(mdlframe_t)*header->numFrames, ztag, NULL); retModel->meshes[0].frames = (mdlframe_t*)Z_Calloc(sizeof(mdlframe_t)*header->numFrames, ztag, 0);
retModel->meshes[0].uvs = (float*)Z_Malloc(sizeof(float) * 2 * retModel->meshes[0].numVertices, ztag, NULL); retModel->meshes[0].uvs = (float*)Z_Malloc(sizeof(float) * 2 * retModel->meshes[0].numVertices, ztag, 0);
trisPtr = tris; trisPtr = tris;
uvptr = retModel->meshes[0].uvs; uvptr = retModel->meshes[0].uvs;
@@ -507,8 +507,8 @@ model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
md2vertex_t *vertex; md2vertex_t *vertex;
md2frame_t *framePtr = (md2frame_t*)ptr; md2frame_t *framePtr = (md2frame_t*)ptr;
retModel->meshes[0].frames[i].normals = (float*)Z_Malloc(sizeof(float) * 3 * header->numTris * 3, ztag, NULL); retModel->meshes[0].frames[i].normals = (float*)Z_Malloc(sizeof(float) * 3 * header->numTris * 3, ztag, 0);
retModel->meshes[0].frames[i].vertices = (float*)Z_Malloc(sizeof(float) * 3 * header->numTris * 3, ztag, NULL); retModel->meshes[0].frames[i].vertices = (float*)Z_Malloc(sizeof(float) * 3 * header->numTris * 3, ztag, 0);
// if (retModel->materials[0].lightmap) // if (retModel->materials[0].lightmap)
// retModel->meshes[0].frames[i].tangents = (float*)malloc(sizeof(float));//(float*)Z_Malloc(sizeof(float)*3*header->numTris*3, ztag); // retModel->meshes[0].frames[i].tangents = (float*)malloc(sizeof(float));//(float*)Z_Malloc(sizeof(float)*3*header->numTris*3, ztag);
//float *vertptr, *normptr; //float *vertptr, *normptr;
+12 -12
View File
@@ -168,7 +168,7 @@ model_t *MD3_LoadModel(const char *fileName, int ztag, boolean useFloat)
if (!f) if (!f)
return NULL; return NULL;
retModel = (model_t*)Z_Calloc(sizeof(model_t), ztag, NULL); retModel = (model_t*)Z_Calloc(sizeof(model_t), ztag, 0);
// find length of file // find length of file
fseek(f, 0, SEEK_END); fseek(f, 0, SEEK_END);
@@ -201,7 +201,7 @@ model_t *MD3_LoadModel(const char *fileName, int ztag, boolean useFloat)
if (retModel->numMaterials <= 0) // Always at least one skin, duh if (retModel->numMaterials <= 0) // Always at least one skin, duh
retModel->numMaterials = 1; retModel->numMaterials = 1;
retModel->materials = (material_t*)Z_Calloc(sizeof(material_t)*retModel->numMaterials, ztag, NULL); retModel->materials = (material_t*)Z_Calloc(sizeof(material_t)*retModel->numMaterials, ztag, 0);
for (t = 0; t < retModel->numMaterials; t++) for (t = 0; t < retModel->numMaterials; t++)
{ {
@@ -225,7 +225,7 @@ model_t *MD3_LoadModel(const char *fileName, int ztag, boolean useFloat)
retModel->materials[t].spheremap = false; retModel->materials[t].spheremap = false;
} }
retModel->meshes = (mesh_t*)Z_Calloc(sizeof(mesh_t)*retModel->numMeshes, ztag, NULL); retModel->meshes = (mesh_t*)Z_Calloc(sizeof(mesh_t)*retModel->numMeshes, ztag, 0);
matCount = 0; matCount = 0;
for (i = 0, surfEnd = 0; i < mdh->numSurfaces; i++) for (i = 0, surfEnd = 0; i < mdh->numSurfaces; i++)
@@ -298,9 +298,9 @@ model_t *MD3_LoadModel(const char *fileName, int ztag, boolean useFloat)
unsigned short *indexptr; unsigned short *indexptr;
md3Triangle *mdT; md3Triangle *mdT;
retModel->meshes[i].tinyframes = (tinyframe_t*)Z_Calloc(sizeof(tinyframe_t)*mdS->numFrames, ztag, NULL); retModel->meshes[i].tinyframes = (tinyframe_t*)Z_Calloc(sizeof(tinyframe_t)*mdS->numFrames, ztag, 0);
retModel->meshes[i].numVertices = mdS->numVerts; retModel->meshes[i].numVertices = mdS->numVerts;
retModel->meshes[i].uvs = (float*)Z_Malloc(sizeof(float)*2*mdS->numVerts, ztag, NULL); retModel->meshes[i].uvs = (float*)Z_Malloc(sizeof(float)*2*mdS->numVerts, ztag, 0);
for (j = 0; j < mdS->numFrames; j++) for (j = 0; j < mdS->numFrames; j++)
{ {
short *vertptr; short *vertptr;
@@ -308,12 +308,12 @@ model_t *MD3_LoadModel(const char *fileName, int ztag, boolean useFloat)
// char *tanptr; // char *tanptr;
int k; int k;
md3Vertex *mdV = (md3Vertex*)((char*)mdS + mdS->offsetXYZNormal + (mdS->numVerts*j*sizeof(md3Vertex))); md3Vertex *mdV = (md3Vertex*)((char*)mdS + mdS->offsetXYZNormal + (mdS->numVerts*j*sizeof(md3Vertex)));
retModel->meshes[i].tinyframes[j].vertices = (short*)Z_Malloc(sizeof(short)*3*mdS->numVerts, ztag, NULL); retModel->meshes[i].tinyframes[j].vertices = (short*)Z_Malloc(sizeof(short)*3*mdS->numVerts, ztag, 0);
retModel->meshes[i].tinyframes[j].normals = (char*)Z_Malloc(sizeof(char)*3*mdS->numVerts, ztag, NULL); retModel->meshes[i].tinyframes[j].normals = (char*)Z_Malloc(sizeof(char)*3*mdS->numVerts, ztag, 0);
// if (retModel->materials[0].lightmap) // if (retModel->materials[0].lightmap)
// retModel->meshes[i].tinyframes[j].tangents = (char*)malloc(sizeof(char));//(char*)Z_Malloc(sizeof(char)*3*mdS->numVerts, ztag); // retModel->meshes[i].tinyframes[j].tangents = (char*)malloc(sizeof(char));//(char*)Z_Malloc(sizeof(char)*3*mdS->numVerts, ztag);
retModel->meshes[i].indices = (unsigned short*)Z_Malloc(sizeof(unsigned short) * 3 * mdS->numTriangles, ztag, NULL); retModel->meshes[i].indices = (unsigned short*)Z_Malloc(sizeof(unsigned short) * 3 * mdS->numTriangles, ztag, 0);
vertptr = retModel->meshes[i].tinyframes[j].vertices; vertptr = retModel->meshes[i].tinyframes[j].vertices;
normptr = retModel->meshes[i].tinyframes[j].normals; normptr = retModel->meshes[i].tinyframes[j].normals;
@@ -374,16 +374,16 @@ model_t *MD3_LoadModel(const char *fileName, int ztag, boolean useFloat)
int k; int k;
retModel->meshes[i].numVertices = mdS->numTriangles * 3;//mdS->numVerts; retModel->meshes[i].numVertices = mdS->numTriangles * 3;//mdS->numVerts;
retModel->meshes[i].frames = (mdlframe_t*)Z_Calloc(sizeof(mdlframe_t)*mdS->numFrames, ztag, NULL); retModel->meshes[i].frames = (mdlframe_t*)Z_Calloc(sizeof(mdlframe_t)*mdS->numFrames, ztag, 0);
retModel->meshes[i].uvs = (float*)Z_Malloc(sizeof(float)*2*mdS->numTriangles*3, ztag, NULL); retModel->meshes[i].uvs = (float*)Z_Malloc(sizeof(float)*2*mdS->numTriangles*3, ztag, 0);
for (j = 0; j < mdS->numFrames; j++) for (j = 0; j < mdS->numFrames; j++)
{ {
float *vertptr; float *vertptr;
float *normptr; float *normptr;
md3Vertex *mdV = (md3Vertex*)((char*)mdS + mdS->offsetXYZNormal + (mdS->numVerts*j*sizeof(md3Vertex))); md3Vertex *mdV = (md3Vertex*)((char*)mdS + mdS->offsetXYZNormal + (mdS->numVerts*j*sizeof(md3Vertex)));
retModel->meshes[i].frames[j].vertices = (float*)Z_Malloc(sizeof(float)*3*mdS->numTriangles*3, ztag, NULL); retModel->meshes[i].frames[j].vertices = (float*)Z_Malloc(sizeof(float)*3*mdS->numTriangles*3, ztag, 0);
retModel->meshes[i].frames[j].normals = (float*)Z_Malloc(sizeof(float)*3*mdS->numTriangles*3, ztag, NULL); retModel->meshes[i].frames[j].normals = (float*)Z_Malloc(sizeof(float)*3*mdS->numTriangles*3, ztag, 0);
// if (retModel->materials[i].lightmap) // if (retModel->materials[i].lightmap)
// retModel->meshes[i].frames[j].tangents = (float*)malloc(sizeof(float));//(float*)Z_Malloc(sizeof(float)*3*mdS->numTriangles*3, ztag); // retModel->meshes[i].frames[j].tangents = (float*)malloc(sizeof(float));//(float*)Z_Malloc(sizeof(float)*3*mdS->numTriangles*3, ztag);
vertptr = retModel->meshes[i].frames[j].vertices; vertptr = retModel->meshes[i].frames[j].vertices;
+9 -9
View File
@@ -189,7 +189,7 @@ model_t *LoadModel(const char *filename, int ztag)
return NULL; return NULL;
} }
model->mdlFilename = (char*)Z_Malloc(strlen(filename)+1, ztag, NULL); model->mdlFilename = (char*)Z_Malloc(strlen(filename)+1, ztag, 0);
strcpy(model->mdlFilename, filename); strcpy(model->mdlFilename, filename);
Optimize(model); Optimize(model);
@@ -237,7 +237,7 @@ void GenerateVertexNormals(model_t *model)
{ {
mdlframe_t *frame = &mesh->frames[j]; mdlframe_t *frame = &mesh->frames[j];
int memTag = PU_STATIC; int memTag = PU_STATIC;
float *newNormals = (float*)Z_Malloc(sizeof(float)*3*mesh->numTriangles*3, memTag, NULL); float *newNormals = (float*)Z_Malloc(sizeof(float)*3*mesh->numTriangles*3, memTag, 0);
int k; int k;
float *vertPtr = frame->vertices; float *vertPtr = frame->vertices;
float *oldNormals; float *oldNormals;
@@ -309,7 +309,7 @@ static boolean AddMaterialToList(materiallist_t **head, material_t *material)
} }
// Didn't find it, so add to the list // Didn't find it, so add to the list
newMatNode = (materiallist_t*)Z_Malloc(sizeof(materiallist_t), PU_CACHE, NULL); newMatNode = (materiallist_t*)Z_Malloc(sizeof(materiallist_t), PU_CACHE, 0);
newMatNode->material = material; newMatNode->material = material;
ListAdd(newMatNode, (listitem_t**)head); ListAdd(newMatNode, (listitem_t**)head);
return true; return true;
@@ -351,7 +351,7 @@ void Optimize(model_t *model)
} }
memTag = PU_STATIC; memTag = PU_STATIC;
newMeshes = (mesh_t*)Z_Calloc(sizeof(mesh_t) * numMeshes, memTag, NULL); newMeshes = (mesh_t*)Z_Calloc(sizeof(mesh_t) * numMeshes, memTag, 0);
i = 0; i = 0;
for (node = matListHead; node; node = node->next) for (node = matListHead; node; node = node->next)
@@ -377,14 +377,14 @@ void Optimize(model_t *model)
newMesh->numFrames = 1; newMesh->numFrames = 1;
newMesh->numTriangles = numTriangles; newMesh->numTriangles = numTriangles;
newMesh->numVertices = numTriangles * 3; newMesh->numVertices = numTriangles * 3;
newMesh->uvs = (float*)Z_Malloc(sizeof(float)*2*numTriangles*3, memTag, NULL); newMesh->uvs = (float*)Z_Malloc(sizeof(float)*2*numTriangles*3, memTag, 0);
newMesh->frames = (mdlframe_t*)Z_Calloc(sizeof(mdlframe_t), memTag, NULL); newMesh->frames = (mdlframe_t*)Z_Calloc(sizeof(mdlframe_t), memTag, 0);
curFrame = &newMesh->frames[0]; curFrame = &newMesh->frames[0];
curFrame->material = curMat; curFrame->material = curMat;
curFrame->normals = (float*)Z_Malloc(sizeof(float)*3*numTriangles*3, memTag, NULL); curFrame->normals = (float*)Z_Malloc(sizeof(float)*3*numTriangles*3, memTag, 0);
curFrame->vertices = (float*)Z_Malloc(sizeof(float)*3*numTriangles*3, memTag, NULL); curFrame->vertices = (float*)Z_Malloc(sizeof(float)*3*numTriangles*3, memTag, 0);
curFrame->colors = (char*)Z_Malloc(sizeof(char)*4*numTriangles*3, memTag, NULL); curFrame->colors = (char*)Z_Malloc(sizeof(char)*4*numTriangles*3, memTag, 0);
// Now traverse the meshes of the model, adding in // Now traverse the meshes of the model, adding in
// vertices/normals/uvs that match the current material // vertices/normals/uvs that match the current material
+3 -9
View File
@@ -109,7 +109,7 @@ boolean HWR_InitShaders(void)
// returns INT32_MAX if not found // returns INT32_MAX if not found
static INT32 strstr_int(const char *str1, const char *str2) static INT32 strstr_int(const char *str1, const char *str2)
{ {
gconst char *location = strstr(str1, str2); char *location = strstr(str1, str2);
if (location) if (location)
return location - str1; return location - str1;
else else
@@ -365,17 +365,13 @@ static void HWR_CompileShader(int index)
if (vertex_source) if (vertex_source)
{ {
char *preprocessed = HWR_PreprocessShader(vertex_source); char *preprocessed = HWR_PreprocessShader(vertex_source);
if (!preprocessed) if (!preprocessed) return;
return;
GL_LoadShader(index, preprocessed, HWD_SHADERSTAGE_VERTEX); GL_LoadShader(index, preprocessed, HWD_SHADERSTAGE_VERTEX);
} }
if (fragment_source) if (fragment_source)
{ {
char *preprocessed = HWR_PreprocessShader(fragment_source); char *preprocessed = HWR_PreprocessShader(fragment_source);
if (!preprocessed) if (!preprocessed) return;
return;
GL_LoadShader(index, preprocessed, HWD_SHADERSTAGE_FRAGMENT); GL_LoadShader(index, preprocessed, HWD_SHADERSTAGE_FRAGMENT);
} }
@@ -391,10 +387,8 @@ void HWR_CompileShaders(void)
{ {
int custom_index = gl_shadertargets[i].custom_shader; int custom_index = gl_shadertargets[i].custom_shader;
HWR_CompileShader(i); HWR_CompileShader(i);
if (!gl_shaders[i].compiled) if (!gl_shaders[i].compiled)
CONS_Alert(CONS_ERROR, "HWR_CompileShaders: Compilation failed for base %s shader!\n", shaderxlat[i].type); CONS_Alert(CONS_ERROR, "HWR_CompileShaders: Compilation failed for base %s shader!\n", shaderxlat[i].type);
if (custom_index != -1) if (custom_index != -1)
{ {
HWR_CompileShader(custom_index); HWR_CompileShader(custom_index);
+19 -9
View File
@@ -78,23 +78,33 @@
// Include GLSL_FLOOR_FUDGES or GLSL_WALL_FUDGES or define the fudges in shaders that use this macro. // Include GLSL_FLOOR_FUDGES or GLSL_WALL_FUDGES or define the fudges in shaders that use this macro.
#define GLSL_DOOM_COLORMAP_DITHER \ #define GLSL_DOOM_COLORMAP_DITHER \
"float baseValue = max(startmap * STARTMAP_FUDGE - scale * 0.5 * SCALE_FUDGE, cap);\n" \ "float baseValue = max(startmap * STARTMAP_FUDGE - scale * 0.5 * SCALE_FUDGE, cap);\n" \
"float patscale = min(scr_resolution.x / 1280.0, scr_resolution.y / 720.0);\n" \ "float endResolutionx = scr_resolution.x;\n" \
"patscale = max(floor(patscale + 0.5), 1.0);\n" \ "float endResolutiony = scr_resolution.y;\n" \
"patscale = 1.0 / patscale;\n" \ "if (scr_resolution.x > 1280.0) {\n" \
"ivec2 p = ivec2(mod(floor(position * patscale), 4.0));\n" \ "endResolutionx = scr_resolution.x * 0.5;\n" \
"float depthfactor = clamp((z - 192.0) / (6144.0 - 192.0), 0.0, 1.0);\n" \ "}\n" \
"if (scr_resolution.y > 720.0) {\n" \
"endResolutiony = scr_resolution.y * 0.5;\n" \
"}\n" \
"float zFactor = clamp((z - 192.0) / (6144.0 - 192.0), 0.0, 1.0);\n" \
"int scaleFactor = int(mix(1.0, 8.0, zFactor));\n" \
"endResolutionx = endResolutionx * scaleFactor;\n" \
"endResolutiony = endResolutiony * scaleFactor;\n" \
"vec2 normalizedPosition = position * vec2(endResolutionx / scr_resolution.x, endResolutiony / scr_resolution.y);\n" \
"int x = int(mod(normalizedPosition.x, 4.0));\n" \
"int y = int(mod(normalizedPosition.y, 4.0));\n" \
"float bayerMatrix[4*4] = float[4*4](\n" \ "float bayerMatrix[4*4] = float[4*4](\n" \
"0.0, 8.0, 2.0, 10.0,\n" \ "0.0, 8.0, 2.0, 10.0,\n" \
"12.0, 4.0, 14.0, 6.0,\n" \ "12.0, 4.0, 14.0, 6.0,\n" \
"3.0, 11.0, 1.0, 9.0,\n" \ "3.0, 11.0, 1.0, 9.0,\n" \
"15.0, 7.0, 13.0, 5.0\n" \ "15.0, 7.0, 13.0, 5.0\n" \
");\n" \ ");\n" \
"float threshold = 16.0;\n" \
"#ifdef SRB2_PALETTE_RENDERING\n" \ "#ifdef SRB2_PALETTE_RENDERING\n" \
"threshold = 11.0;\n" \ "float threshold = (1.0 - pow(zFactor, 2.0)) * (bayerMatrix[y*4 + x] / 11.0);\n" \
"#else\n" \
"float threshold = (1.0 - pow(zFactor, 2.0)) * (bayerMatrix[y*4 + x] / 16.0);\n" \
"#endif\n" \ "#endif\n" \
"threshold = (1.0 - pow(depthfactor, 2.0)) * (bayerMatrix[p.y*4 + p.x] / threshold);\n" \ "return mix(baseValue + threshold - 0.5 / 16.0, baseValue, zFactor);\n"
"return mix(baseValue + threshold - 0.5 / 16.0, baseValue, depthfactor);\n"
#define GLSL_DOOM_COLORMAP_NODITHER \ #define GLSL_DOOM_COLORMAP_NODITHER \
"return max(startmap * STARTMAP_FUDGE - scale * 0.5 * SCALE_FUDGE, cap);\n" \ "return max(startmap * STARTMAP_FUDGE - scale * 0.5 * SCALE_FUDGE, cap);\n" \
+26 -79
View File
@@ -98,10 +98,10 @@ static size_t textureBufferSize = 0;
static LTListItem *LightTablesTail = NULL; static LTListItem *LightTablesTail = NULL;
static LTListItem *LightTablesHead = NULL; static LTListItem *LightTablesHead = NULL;
static RGBA_t screenPalette[256] = {}; // the palette for the postprocessing step in palette rendering static RGBA_t screenPalette[256] = {0}; // the palette for the postprocessing step in palette rendering
static GLuint screenPaletteTex = 0; // 1D texture containing the screen palette static GLuint screenPaletteTex = 0; // 1D texture containing the screen palette
static GLuint paletteLookupTex = 0; // 3D texture containing RGB -> palette index lookup table static GLuint paletteLookupTex = 0; // 3D texture containing RGB -> palette index lookup table
RGBA_t myPaletteData[256] = {}; // the palette for converting textures to RGBA RGBA_t myPaletteData[256] = {0}; // the palette for converting textures to RGBA
static GLint gltexformat = GL_RGB5_A1; static GLint gltexformat = GL_RGB5_A1;
GLint screen_width = 0; // used by Draw2DLine() GLint screen_width = 0; // used by Draw2DLine()
@@ -127,9 +127,9 @@ GLuint gl_num_extensions;
int majorGL = 0, minorGL = 0; int majorGL = 0, minorGL = 0;
//Hurdler: 04/10/2000: added for the kick ass coronas as Boris wanted;-) //Hurdler: 04/10/2000: added for the kick ass coronas as Boris wanted;-)
GLfloat modelMatrix[16] = {}; GLfloat modelMatrix[16] = {0};
GLfloat projMatrix[16] = {}; GLfloat projMatrix[16] = {0};
static GLint viewport[4]; static GLint viewport[4];
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
enum enum
@@ -171,7 +171,7 @@ boolean supportstencil = false;
// flush all of the stored textures, leaving them unavailable at times such as between levels // flush all of the stored textures, leaving them unavailable at times such as between levels
// These need to start at 0 and be set to their number, and be reset to 0 when deleted so that Intel GPUs // These need to start at 0 and be set to their number, and be reset to 0 when deleted so that Intel GPUs
// can know when the textures aren't there, as textures are always considered resident in their virtual memory // can know when the textures aren't there, as textures are always considered resident in their virtual memory
static GLuint screenTextures[NUMSCREENTEXTURES] = {}; static GLuint screenTextures[NUMSCREENTEXTURES] = {0};
#define byte2float(byte) (GLfloat)(byte / 255.0f) #define byte2float(byte) (GLfloat)(byte / 255.0f)
@@ -404,14 +404,6 @@ static PFNglEnableClientState pglEnableClientState;
typedef void (APIENTRY * PFNglDisableClientState) (GLenum cap); typedef void (APIENTRY * PFNglDisableClientState) (GLenum cap);
static PFNglDisableClientState pglDisableClientState; static PFNglDisableClientState pglDisableClientState;
typedef void (APIENTRY * PFNglOrtho) (GLdouble left,
GLdouble right,
GLdouble bottom,
GLdouble top,
GLdouble nearVal,
GLdouble farVal);
static PFNglOrtho pglOrtho;
/* Lighting */ /* Lighting */
typedef void (APIENTRY * PFNglShadeModel) (GLenum mode); typedef void (APIENTRY * PFNglShadeModel) (GLenum mode);
static PFNglShadeModel pglShadeModel; static PFNglShadeModel pglShadeModel;
@@ -753,7 +745,7 @@ typedef struct gl_shaderstate_s
static gl_shaderstate_t gl_shaderstate; static gl_shaderstate_t gl_shaderstate;
// Shader info // Shader info
static float shader_leveltime = 0.0f; static float shader_leveltime = 0;
static float shader_light_x = 0.0f; static float shader_light_x = 0.0f;
static float shader_light_y = 0.0f; static float shader_light_y = 0.0f;
static float shader_light_z = 0.0f; static float shader_light_z = 0.0f;
@@ -866,8 +858,6 @@ void SetupGLFunc4(void)
GetGLfunc(glUniform3fv); GetGLfunc(glUniform3fv);
GetGLfunc(glGetUniformLocation); GetGLfunc(glGetUniformLocation);
GetGLfunc(glOrtho);
#ifdef GLDEBUGMESSAGE #ifdef GLDEBUGMESSAGE
GetGLfunc(glDebugMessageCallback); GetGLfunc(glDebugMessageCallback);
#endif #endif
@@ -1383,19 +1373,19 @@ void GL_Flush(void)
// -----------------+ // -----------------+
INT32 GL_isExtAvailable(const char *extension, const GLubyte *start) INT32 GL_isExtAvailable(const char *extension, const GLubyte *start)
{ {
gconst GLubyte *where, *terminator; GLubyte *where, *terminator;
if (!extension || !start) if (!extension || !start)
return 0; return 0;
where = (gconst GLubyte *)strchr(extension, ' '); where = (GLubyte *) strchr(extension, ' ');
if (where || *extension == '\0') if (where || *extension == '\0')
return 0; return 0;
for (;;) for (;;)
{ {
where = (gconst GLubyte *)strstr((const char *)start, extension); where = (GLubyte *) strstr((const char *) start, extension);
if (!where) if (!where)
break; break;
@@ -3100,39 +3090,6 @@ void GL_DrawModelEx(model_t *model, INT32 frameIndex, float duration, float tics
pglDisable(GL_NORMALIZE); pglDisable(GL_NORMALIZE);
} }
void GL_Draw2DModel(model_t *model, INT32 frameIndex, INT32 duration, INT32 tics, INT32 nextFrameIndex,
FTransform *pos, float hscale, float vscale, UINT8 flipped, UINT8 hflipped, FSurfaceInfo *Surface)
{
// save our matrix´s
pglMatrixMode(GL_PROJECTION);
pglPushMatrix();
pglMatrixMode(GL_MODELVIEW);
pglPushMatrix();
pglMatrixMode(GL_PROJECTION);
pglLoadIdentity();
// switch to ortho mode to make our lives easier
// thisll make sure our coords will be remapped to pixel coords
pglOrtho(0.0f, (float)vid.width, (float)vid.height, 0.0f, NZCLIP_PLANE, FAR_ZCLIP_DEFAULT);
pglMatrixMode(GL_MODELVIEW);
pglLoadIdentity();
pglEnable(GL_DEPTH_TEST);
pglDepthMask(GL_TRUE);
pglClear(GL_DEPTH_BUFFER_BIT);
GL_DrawModelEx(model, frameIndex, duration, tics, nextFrameIndex,
pos, hscale, vscale, flipped, hflipped, Surface);
// restore the matrix´s
pglMatrixMode(GL_PROJECTION);
pglPopMatrix();
pglMatrixMode(GL_MODELVIEW);
pglPopMatrix();
}
// -----------------+ // -----------------+
// SetTransform : // SetTransform :
// -----------------+ // -----------------+
@@ -3591,30 +3548,22 @@ void GL_RenderVhsEffect(fixed_t upbary, fixed_t downbary, UINT8 updistort, UINT8
1.0f, -1.0f, 1.0f 1.0f, -1.0f, 1.0f
}; };
xfix = 1/((float)screen_texsizew/(float)screen_width);
yfix = 1/((float)screen_texsizeh/(float)screen_height);
const GLfloat scrwf = (float)screen_width; const GLfloat scrwf = (float)screen_width;
const GLfloat scrwh = (float)screen_height; const GLfloat scrwh = (float)screen_height;
xfix = 1/((float)screen_texsizew/scrwf);
yfix = 1/((float)screen_texsizeh/scrwh);
GL_SetBlend(PF_Modulated|PF_Translucent|PF_NoDepthTest);
// Slight fuzziness // Slight fuzziness
GL_MakeScreenTexture(HWD_SCREENTEXTURE_VHS); GL_MakeScreenTexture(HWD_SCREENTEXTURE_VHS);
GL_SetBlend(PF_Modulated|PF_Translucent|PF_NoDepthTest);
pglBindTexture(GL_TEXTURE_2D, screenTextures[HWD_SCREENTEXTURE_VHS]); pglBindTexture(GL_TEXTURE_2D, screenTextures[HWD_SCREENTEXTURE_VHS]);
uint32_t r = rand(); const float stride = 2.f/scrwh;
const float ystep = 2.f/scrwh * (float)vid.udup/4.f; for (i = 0; i < 1; i += stride)
for (i = 0; i < 1; i += ystep)
{ {
// avoid calling rand thousands of times fix[2] = (float)(rand() % 128) / -22000.f * xfix;
r ^= r >> 13;
r ^= r >> 11;
r ^= r << 21;
fix[2] = (float)(r & 127) / -22000.f * xfix;
fix[0] = fix[2]; fix[0] = fix[2];
fix[6] = fix[0] + xfix; fix[6] = fix[0] + xfix;
fix[4] = fix[2] + xfix; fix[4] = fix[2] + xfix;
@@ -3632,8 +3581,8 @@ void GL_RenderVhsEffect(fixed_t upbary, fixed_t downbary, UINT8 updistort, UINT8
} }
// Upward bar // Upward bar
GL_MakeScreenTexture(HWD_SCREENTEXTURE_VHS); //GL_MakeScreenTexture(HWD_SCREENTEXTURE_VHS);
pglBindTexture(GL_TEXTURE_2D, screenTextures[HWD_SCREENTEXTURE_VHS]); //pglBindTexture(GL_TEXTURE_2D, screenTextures[HWD_SCREENTEXTURE_VHS]);
color[0] = color[1] = color[2] = 190; color[0] = color[1] = color[2] = 190;
color[3] = 250; color[3] = 250;
@@ -3656,14 +3605,13 @@ void GL_RenderVhsEffect(fixed_t upbary, fixed_t downbary, UINT8 updistort, UINT8
fix[1] = fix[7] += (fix[3] - fix[7])*2; fix[1] = fix[7] += (fix[3] - fix[7])*2;
screenVerts[1] = screenVerts[10] += (screenVerts[4] - screenVerts[1])*2; screenVerts[1] = screenVerts[10] += (screenVerts[4] - screenVerts[1])*2;
pglTexCoordPointer(2, GL_FLOAT, 0, fix); pglTexCoordPointer(2, GL_FLOAT, 0, fix);
pglVertexPointer(3, GL_FLOAT, 0, screenVerts); pglVertexPointer(3, GL_FLOAT, 0, screenVerts);
pglDrawArrays(GL_TRIANGLE_FAN, 0, 4); pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
// Downward bar // Downward bar
GL_MakeScreenTexture(HWD_SCREENTEXTURE_VHS); //GL_MakeScreenTexture(HWD_SCREENTEXTURE_VHS);
pglBindTexture(GL_TEXTURE_2D, screenTextures[HWD_SCREENTEXTURE_VHS]); //pglBindTexture(GL_TEXTURE_2D, screenTextures[HWD_SCREENTEXTURE_VHS]);
fix[0] = 0.0f; fix[0] = 0.0f;
fix[6] = xfix; fix[6] = xfix;
@@ -3682,7 +3630,6 @@ void GL_RenderVhsEffect(fixed_t upbary, fixed_t downbary, UINT8 updistort, UINT8
fix[1] = fix[7] += (fix[3] - fix[7])*2; fix[1] = fix[7] += (fix[3] - fix[7])*2;
screenVerts[1] = screenVerts[10] += (screenVerts[4] - screenVerts[1])*2; screenVerts[1] = screenVerts[10] += (screenVerts[4] - screenVerts[1])*2;
pglTexCoordPointer(2, GL_FLOAT, 0, fix); pglTexCoordPointer(2, GL_FLOAT, 0, fix);
pglVertexPointer(3, GL_FLOAT, 0, screenVerts); pglVertexPointer(3, GL_FLOAT, 0, screenVerts);
pglDrawArrays(GL_TRIANGLE_FAN, 0, 4); pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
@@ -3722,7 +3669,7 @@ void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height, boolean usesh
{ {
float xfix, yfix; float xfix, yfix;
float origaspect, newaspect; float origaspect, newaspect;
float xoff = 1.0f, yoff = 1.0f; // xoffset and yoffset for the polygon to have black bars around the screen float xoff = 1, yoff = 1; // xoffset and yoffset for the polygon to have black bars around the screen
static float off[12] = static float off[12] =
{ {
@@ -3745,19 +3692,19 @@ void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height, boolean usesh
if (origaspect < newaspect) if (origaspect < newaspect)
{ {
xoff = origaspect / newaspect; xoff = origaspect / newaspect;
yoff = 1.0f; yoff = 1;
} }
else if (origaspect > newaspect) else if (origaspect > newaspect)
{ {
xoff = 1.0f; xoff = 1;
yoff = newaspect / origaspect; yoff = newaspect / origaspect;
} }
// float off[12]; // float off[12];
off[0] = off[3] = -xoff; off[0] = off[3] = -xoff;
off[1] = off[10] = -yoff; off[1] = off[10] = -yoff;
off[4] = off[7] = yoff; off[4] = off[7] = yoff;
off[6] = off[9] = xoff; off[6] = off[9] = xoff;
// float fix[8]; // float fix[8];
fix[3] = fix[5] = yfix; fix[3] = fix[5] = yfix;
+5 -7
View File
@@ -189,7 +189,7 @@ HMS_connect (const char *format, ...)
seek = strlen(hms_api) + 1;/* + '/' */ seek = strlen(hms_api) + 1;/* + '/' */
va_start (ap, format); va_start (ap, format);
url = malloc(seek + vsnprintf(NULL, 0, format, ap) + sizeof HMS_QUERY_VERSION - 1 + token_length + 1); url = malloc(seek + vsnprintf(0, 0, format, ap) + sizeof HMS_QUERY_VERSION - 1 + token_length + 1);
va_end (ap); va_end (ap);
sprintf(url, "%s/", hms_api); sprintf(url, "%s/", hms_api);
@@ -225,10 +225,9 @@ HMS_connect (const char *format, ...)
{ {
cc = curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L); cc = curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
if (cc != CURLE_OK) I_OutputMsg("libcurl: %s\n", buffer->errbuf); if (cc != CURLE_OK) I_OutputMsg("libcurl: %s\n", buffer->errbuf);
#ifdef LOGMESSAGES
cc = curl_easy_setopt(curl, CURLOPT_STDERR, logstream); cc = curl_easy_setopt(curl, CURLOPT_STDERR, logstream);
if (cc != CURLE_OK) I_OutputMsg("libcurl: %s\n", buffer->errbuf); if (cc != CURLE_OK) I_OutputMsg("libcurl: %s\n", buffer->errbuf);
#endif
} }
if (M_CheckParm("-bindaddr") && M_IsNextParm()) if (M_CheckParm("-bindaddr") && M_IsNextParm())
@@ -318,7 +317,6 @@ static void
HMS_end (struct HMS_buffer *buffer) HMS_end (struct HMS_buffer *buffer)
{ {
curl_easy_cleanup(buffer->curl); curl_easy_cleanup(buffer->curl);
free(buffer->errbuf);
free(buffer->buffer); free(buffer->buffer);
free(buffer); free(buffer);
} }
@@ -473,8 +471,8 @@ HMS_fetch_servers (msg_server_t *list, int query_id)
*end = '\0'; *end = '\0';
address = strtok(p, " "); address = strtok(p, " ");
port = strtok(NULL, " "); port = strtok(0, " ");
contact = strtok(NULL, ""); contact = strtok(0, "");
if (address && port) if (address && port)
{ {
@@ -541,7 +539,7 @@ HMS_compare_mod_version (char *buffer, size_t buffer_size)
if (HMS_do(hms)) if (HMS_do(hms))
{ {
version = strtok(hms->buffer, " "); version = strtok(hms->buffer, " ");
version_name = strtok(NULL, "\n"); version_name = strtok(0, "\n");
if (version && version_name) if (version && version_name)
{ {
+86 -95
View File
@@ -97,6 +97,7 @@ static textinput_t w_chat;
static boolean headsupactive = false; static boolean headsupactive = false;
boolean hu_showscores = false; // draw rankings boolean hu_showscores = false; // draw rankings
static char hu_tick; static char hu_tick;
static tic_t hu_emoteanim = 0;
emote_autocomplete_t emote_autocomplete = {0}; emote_autocomplete_t emote_autocomplete = {0};
static huddrawlist_h luahuddrawlist_scores = NULL; static huddrawlist_h luahuddrawlist_scores = NULL;
@@ -496,9 +497,7 @@ static void HU_removeChatText_Log(void)
{ {
chat_log[i] = chat_log[i+1]; chat_log[i] = chat_log[i+1];
} }
chat_nummsg_log--; // lost 1 msg. chat_nummsg_log--; // lost 1 msg.
chat_log[chat_nummsg_log] = NULL;
} }
static void Chatlogsize_OnChange(void) static void Chatlogsize_OnChange(void)
@@ -517,7 +516,6 @@ static void Chatlogsize_OnChange(void)
if (new_chat_log == NULL) if (new_chat_log == NULL)
{ {
free(chat_log); free(chat_log);
chat_log = NULL;
return; return;
} }
chat_log = new_chat_log; chat_log = new_chat_log;
@@ -543,8 +541,6 @@ void HU_AddChatText(const char *text, boolean playsound)
HU_removeChatText_Log(); HU_removeChatText_Log();
chat_log[chat_nummsg_log] = malloc(HU_MSGBUFSIZE); chat_log[chat_nummsg_log] = malloc(HU_MSGBUFSIZE);
if (!chat_log[chat_nummsg_log])
I_Error("HU_AddChatText: out of memory for chat log\n");
strcpy(chat_log[chat_nummsg_log], text); strcpy(chat_log[chat_nummsg_log], text);
++chat_nummsg_log; ++chat_nummsg_log;
@@ -627,10 +623,7 @@ static void DoSayCommand(SINT8 target, size_t usedargs, UINT8 flags)
// with that logic, characters 4 and 5 are our numbers: // with that logic, characters 4 and 5 are our numbers:
const char *newmsg; const char *newmsg;
INT32 spc = 1; // used if nodenum[1] is a space. INT32 spc = 1; // used if nodenum[1] is a space.
CLEANUP(pfree) char *nodenum = (char*)malloc(3); CLEANUP(pfree) char *nodenum = (char*) malloc(3);
if (!nodenum)
I_Error("DoSayCommand: out of memory for sending pm\n");
memcpy(nodenum, msg+3, 2); memcpy(nodenum, msg+3, 2);
nodenum[2] = '\0'; nodenum[2] = '\0';
@@ -911,7 +904,7 @@ static void Got_Saycmd(const UINT8 **p, INT32 playernum)
target = READSINT8(*p); target = READSINT8(*p);
flags = READUINT8(*p); flags = READUINT8(*p);
msg = buf; msg = buf;
READSTRINGN(*p, msg, HU_MAXMSGLEN + 1); READSTRINGL(*p, msg, HU_MAXMSGLEN + 1);
if ((cv_mute.value || flags & (HU_CSAY|HU_SERVER_SAY)) && playernum != serverplayer && !(IsPlayerAdmin(playernum))) if ((cv_mute.value || flags & (HU_CSAY|HU_SERVER_SAY)) && playernum != serverplayer && !(IsPlayerAdmin(playernum)))
{ {
@@ -1079,7 +1072,8 @@ static void Got_Saycmd(const UINT8 **p, INT32 playernum)
HU_AddChatText(va(fmt2, prefix, cstart, dispname, textcolor, msg), cv_chatnotifications.value); // add to chat HU_AddChatText(va(fmt2, prefix, cstart, dispname, textcolor, msg), cv_chatnotifications.value); // add to chat
Z_Free(tempchar); if (tempchar)
Z_Free(tempchar);
} }
#ifdef _DEBUG #ifdef _DEBUG
// I just want to point out while I'm here that because the data is still // I just want to point out while I'm here that because the data is still
@@ -1099,6 +1093,7 @@ void HU_Ticker(void)
return; return;
hu_tick++; hu_tick++;
hu_emoteanim++;
hu_tick &= 7; // currently only to blink chat input cursor hu_tick &= 7; // currently only to blink chat input cursor
if (PLAYER1INPUTDOWN(gc_scores)) if (PLAYER1INPUTDOWN(gc_scores))
@@ -1235,9 +1230,7 @@ static void HU_SendChatMessage(void)
{ {
INT32 spc = 1; // used if nodenum[1] is a space. INT32 spc = 1; // used if nodenum[1] is a space.
const char *newmsg; const char *newmsg;
CLEANUP(pfree) char *nodenum = (char*)malloc(3); CLEANUP(pfree) char *nodenum = (char*) malloc(3);
if (!nodenum)
I_Error("HU_SendChatMessage: out of memory for sending pm\n");
// what we're gonna do now is check if the node exists // what we're gonna do now is check if the node exists
// with that logic, characters 4 and 5 are our numbers: // with that logic, characters 4 and 5 are our numbers:
@@ -1491,7 +1484,6 @@ static char *CHAT_WordWrap(INT32 x, INT32 w, INT32 option, const char *string)
x = 0; x = 0;
} }
} }
return newstring; return newstring;
} }
@@ -1530,7 +1522,7 @@ static void HU_drawMiniChat(void)
emote_t *emote = NULL; emote_t *emote = NULL;
int emotelen = 0; int emotelen = 0;
while (msg[j]) // iterate through msg while(msg[j]) // iterate through msg
{ {
if (msg[j] < HU_FONTSTART) // don't draw if (msg[j] < HU_FONTSTART) // don't draw
{ {
@@ -1562,25 +1554,24 @@ static void HU_drawMiniChat(void)
{ {
j++; j++;
} }
prev_linereturn = false; prev_linereturn = false;
dx += charwidth; dx += charwidth;
if (dx >= boxw) if (dx >= boxw)
{ {
dx = 0; dx = 0;
linescount += 1; linescount += 1;
} }
} }
dy = 0; dy = 0;
dx = 0; dx = 0;
msglines += linescount+1; msglines += linescount+1;
Z_Free(msg); if (msg)
Z_Free(msg);
} }
y = chaty - charheight*(msglines+1); y = chaty - charheight*(msglines+1);
#ifdef NETSPLITSCREEN
if (splitscreen) if (splitscreen)
{ {
y -= BASEVIDHEIGHT/2; y -= BASEVIDHEIGHT/2;
@@ -1588,6 +1579,7 @@ static void HU_drawMiniChat(void)
y += 16; y += 16;
} }
else else
#endif
y -= (cv_kartspeedometer.value ? 16 : 0); y -= (cv_kartspeedometer.value ? 16 : 0);
dx = 0; dx = 0;
@@ -1606,7 +1598,7 @@ static void HU_drawMiniChat(void)
emote_t *emote = NULL; emote_t *emote = NULL;
int emotelen = 0; int emotelen = 0;
while (msg[j]) // iterate through msg while(msg[j]) // iterate through msg
{ {
if (msg[j] < HU_FONTSTART) // don't draw if (msg[j] < HU_FONTSTART) // don't draw
{ {
@@ -1651,17 +1643,16 @@ static void HU_drawMiniChat(void)
dx += charwidth; dx += charwidth;
prev_linereturn = false; prev_linereturn = false;
if (dx >= boxw) if (dx >= boxw)
{ {
dx = 0; dx = 0;
dy += charheight; dy += charheight;
} }
} }
dy += charheight; dy += charheight;
dx = 0; dx = 0;
Z_Free(msg); if (msg)
Z_Free(msg);
} }
// decrement addy and make that shit smooth: // decrement addy and make that shit smooth:
@@ -1685,15 +1676,18 @@ static void HU_drawChatLog(INT32 offset)
if (chat_scroll > chat_maxscroll) if (chat_scroll > chat_maxscroll)
chat_scroll = chat_maxscroll; chat_scroll = chat_maxscroll;
#ifdef NETSPLITSCREEN
if (splitscreen) if (splitscreen)
{ {
boxh = max(6, boxh/2); boxh = max(6, boxh/2);
if (splitscreen > 1) if (splitscreen > 1)
boxw = max(64, boxw/2); boxw = max(64, boxw/2);
} }
#endif
y = chaty - offset*charheight - (chat_scroll*charheight) - boxh*charheight - 12; y = chaty - offset*charheight - (chat_scroll*charheight) - boxh*charheight - 12;
#ifdef NETSPLITSCREEN
if (splitscreen) if (splitscreen)
{ {
y -= BASEVIDHEIGHT/2; y -= BASEVIDHEIGHT/2;
@@ -1701,6 +1695,7 @@ static void HU_drawChatLog(INT32 offset)
y += 16; y += 16;
} }
else else
#endif
y -= (cv_kartspeedometer.value ? 16 : 0); y -= (cv_kartspeedometer.value ? 16 : 0);
@@ -1709,7 +1704,7 @@ static void HU_drawChatLog(INT32 offset)
V_DrawFillConsoleMap(chatx, chat_topy, boxw, boxh*charheight +2, 239|V_SNAPTOBOTTOM|V_SNAPTOLEFT); // log box V_DrawFillConsoleMap(chatx, chat_topy, boxw, boxh*charheight +2, 239|V_SNAPTOBOTTOM|V_SNAPTOLEFT); // log box
for (i = 0; i < chat_nummsg_log; i++) // iterate through our chatlog for (i=0; i<chat_nummsg_log; i++) // iterate through our chatlog
{ {
INT32 clrflag = 0; INT32 clrflag = 0;
INT32 j = 0; INT32 j = 0;
@@ -1718,7 +1713,7 @@ static void HU_drawChatLog(INT32 offset)
emote_t *emote = NULL; emote_t *emote = NULL;
int emotelen = 0; int emotelen = 0;
while (msg[j]) // iterate through msg while(msg[j]) // iterate through msg
{ {
if (msg[j] < HU_FONTSTART) // don't draw if (msg[j] < HU_FONTSTART) // don't draw
{ {
@@ -1763,10 +1758,10 @@ static void HU_drawChatLog(INT32 offset)
dy += charheight; dy += charheight;
} }
} }
dy += charheight; dy += charheight;
dx = 0; dx = 0;
Z_Free(msg); if (msg)
Z_Free(msg);
} }
if (((chat_scroll >= chat_maxscroll) || (chat_scrollmedown)) && !(justscrolleddown || justscrolledup || chat_scrolltime)) // was already at the bottom of the page before new maxscroll calculation and was NOT scrolling. if (((chat_scroll >= chat_maxscroll) || (chat_scrollmedown)) && !(justscrolleddown || justscrolledup || chat_scrolltime)) // was already at the bottom of the page before new maxscroll calculation and was NOT scrolling.
@@ -1809,12 +1804,12 @@ static void HU_DrawChat(void)
INT32 t = 0, c = 0, y = chaty - (typelines*charheight); INT32 t = 0, c = 0, y = chaty - (typelines*charheight);
UINT32 i = 0, saylen = strlen(w_chat_buf); // You learn new things everyday! UINT32 i = 0, saylen = strlen(w_chat_buf); // You learn new things everyday!
INT32 cflag = 0; INT32 cflag = 0;
INT32 pm_offset = 0; // for cases when you type emote while also doing /pm
size_t select_start = 0, select_end = 0; size_t select_start = 0, select_end = 0;
const char *ntalk = "Say: ", *ttalk = "Team: "; const char *ntalk = "Say: ", *ttalk = "Team: ";
const char *talk = ntalk; const char *talk = ntalk;
const char *mute = "Chat has been muted."; const char *mute = "Chat has been muted.";
#ifdef NETSPLITSCREEN
if (splitscreen) if (splitscreen)
{ {
y -= BASEVIDHEIGHT/2; y -= BASEVIDHEIGHT/2;
@@ -1825,6 +1820,7 @@ static void HU_DrawChat(void)
} }
} }
else else
#endif
y -= (cv_kartspeedometer.value ? 16 : 0); y -= (cv_kartspeedometer.value ? 16 : 0);
if (teamtalk) if (teamtalk)
@@ -1919,13 +1915,71 @@ static void HU_DrawChat(void)
} }
} }
if (emote_autocomplete.emotestart != -1 && (emote_autocomplete.complete[0] || (w_chat.cursor - emote_autocomplete.emotestart) > 1))
{
emote_t *suggest;
int skip = 0;
const char *complete;
int complete_len;
if (emote_autocomplete.complete[0])
{
complete = emote_autocomplete.complete;
complete_len = strlen(complete);
}
else
{
complete = &w_chat_buf[emote_autocomplete.emotestart];
complete_len = w_chat.cursor - emote_autocomplete.emotestart;
}
// A bit of copy-paste from /pm code :p
INT32 suggesty = chaty - charheight - 1;
size_t longest_suggestion_length = 0;
while ((suggest = M_FindEmote(complete, complete_len, skip)) != NULL)
{
longest_suggestion_length = max(longest_suggestion_length, strlen(suggest->name));
++skip;
}
skip = 0;
#ifdef NETSPLITSCREEN
if (splitscreen)
{
suggesty -= BASEVIDHEIGHT/2;
if (splitscreen > 1)
suggesty += 16;
}
else
#endif
suggesty -= (cv_kartspeedometer.value ? 16 : 0);
while ((suggest = M_FindEmote(complete, complete_len, skip)) != NULL)
{
V_DrawFillConsoleMap(chatx + boxw + 2, suggesty - (7*skip), (longest_suggestion_length+2)*4 + EMOTEWIDTH, 6, V_SNAPTOBOTTOM|V_SNAPTOLEFT);
// Highlight currently suggested emote
int hlflag = 0;
if (skip == emote_autocomplete.skip && emote_autocomplete.complete[0])
hlflag = V_YELLOWMAP;
V_DrawSmallString(chatx + boxw + 4 + EMOTEWIDTH, suggesty - (7*skip), hlflag|V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, va(":%s:", suggest->name));
M_DrawEmote(chatx + boxw + 2, suggesty - skip*7, suggest, V_SNAPTOBOTTOM|V_SNAPTOLEFT);
++skip;
}
}
// handle /pm list. It's messy, horrible and I don't care. // handle /pm list. It's messy, horrible and I don't care.
if (strnicmp(w_chat_buf, "/pm", 3) == 0 && vid.width >= 400 && !teamtalk) // 320x200 unsupported kthxbai if (strnicmp(w_chat_buf, "/pm", 3) == 0 && vid.width >= 400 && !teamtalk) // 320x200 unsupported kthxbai
{ {
INT32 count = 0; INT32 count = 0;
INT32 p_dispy = chaty - charheight - 1; INT32 p_dispy = chaty - charheight - 1;
size_t longest_name_length = 0; size_t longest_name_length = 0;
#ifdef NETSPLITSCREEN
if (splitscreen) if (splitscreen)
{ {
p_dispy -= BASEVIDHEIGHT/2; p_dispy -= BASEVIDHEIGHT/2;
@@ -1933,13 +1987,13 @@ static void HU_DrawChat(void)
p_dispy += 16; p_dispy += 16;
} }
else else
#endif
p_dispy -= (cv_kartspeedometer.value ? 16 : 0); p_dispy -= (cv_kartspeedometer.value ? 16 : 0);
// Find longest player name, for drawing background for /pm list later // Find longest player name, for drawing background for /pm list later
for (i = 0; i < MAXPLAYERS; i++) for (i = 0; i < MAXPLAYERS; i++)
{ {
if (!playeringame[i]) if (!playeringame[i]) continue;
continue;
longest_name_length = max(longest_name_length, strlen(player_names[i])); longest_name_length = max(longest_name_length, strlen(player_names[i]));
} }
@@ -1999,72 +2053,9 @@ static void HU_DrawChat(void)
if (count == 0) // no results. if (count == 0) // no results.
{ {
pm_offset = 48 + 2;
V_DrawFillConsoleMap(chatx + boxw + 2, p_dispy - (6*count), 48, 6, 239 | V_SNAPTOBOTTOM | V_SNAPTOLEFT); // fill it like the chat so the text doesn't become hard to read because of the hud. V_DrawFillConsoleMap(chatx + boxw + 2, p_dispy - (6*count), 48, 6, 239 | V_SNAPTOBOTTOM | V_SNAPTOLEFT); // fill it like the chat so the text doesn't become hard to read because of the hud.
V_DrawSmallString(chatx + boxw + 4, p_dispy - (6*count), V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, "NO RESULT."); V_DrawSmallString(chatx + boxw + 4, p_dispy - (6*count), V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, "NO RESULT.");
} }
else
{
pm_offset = (longest_name_length+4)*4 + 2;
}
}
if (emote_autocomplete.emotestart != -1 && (emote_autocomplete.complete[0] || (w_chat.cursor - emote_autocomplete.emotestart) > 1))
{
emote_t *suggest;
int skip = 0;
const char *complete;
int complete_len;
if (emote_autocomplete.complete[0])
{
complete = emote_autocomplete.complete;
complete_len = strlen(complete);
}
else
{
complete = &w_chat_buf[emote_autocomplete.emotestart];
complete_len = w_chat.cursor - emote_autocomplete.emotestart;
}
// A bit of copy-paste from /pm code :p
INT32 suggesty = chaty - charheight - 1;
size_t longest_suggestion_length = 0;
while ((suggest = M_FindEmote(complete, complete_len, skip)) != NULL)
{
longest_suggestion_length = max(longest_suggestion_length, strlen(suggest->name));
++skip;
}
INT32 emote_suggest_boxw = (longest_suggestion_length+2)*4 + EMOTEWIDTH;
skip = 0;
if (splitscreen)
{
suggesty -= BASEVIDHEIGHT/2;
if (splitscreen > 1)
suggesty += 16;
}
else
suggesty -= (cv_kartspeedometer.value ? 16 : 0);
while ((suggest = M_FindEmote(complete, complete_len, skip)) != NULL)
{
V_DrawFillConsoleMap(chatx + boxw + pm_offset + 2, suggesty - (7*skip), emote_suggest_boxw, 6, V_SNAPTOBOTTOM|V_SNAPTOLEFT);
// Highlight currently suggested emote
int hlflag = 0;
if (skip == emote_autocomplete.skip && emote_autocomplete.complete[0])
hlflag = V_YELLOWMAP;
V_DrawSmallString(chatx + boxw + pm_offset + 4 + EMOTEWIDTH, suggesty - (7*skip), hlflag|V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, va(":%s:", suggest->name));
M_DrawEmote(chatx + boxw + pm_offset + 2, suggesty - skip*7, suggest, V_SNAPTOBOTTOM|V_SNAPTOLEFT);
++skip;
}
} }
HU_drawChatLog(typelines - 1); // typelines is the # of lines we're typing. If there's more than 1 then the log should scroll up to give us more space. HU_drawChatLog(typelines - 1); // typelines is the # of lines we're typing. If there's more than 1 then the log should scroll up to give us more space.
+5
View File
@@ -68,7 +68,12 @@ typedef struct
#define HU_MAXMSGLEN 223 #define HU_MAXMSGLEN 223
#define HU_MSGBUFSIZE 255 #define HU_MSGBUFSIZE 255
#define MAX_CHAT_BUFSIZE 256 // that's enough messages, right? We'll delete the older ones when that gets out of hand. #define MAX_CHAT_BUFSIZE 256 // that's enough messages, right? We'll delete the older ones when that gets out of hand.
#define NETSPLITSCREEN // why the hell WOULDN'T we want this?
#ifdef NETSPLITSCREEN
#define OLDCHAT (cv_consolechat.value == 1 || dedicated || vid.width < 640) #define OLDCHAT (cv_consolechat.value == 1 || dedicated || vid.width < 640)
#else
#define OLDCHAT (cv_consolechat.value == 1 || dedicated || vid.width < 640)
#endif
#define CHAT_MUTE (cv_mute.value && !(server || IsPlayerAdmin(consoleplayer))) // this still allows to open the chat but not to type. That's used for scrolling and whatnot. #define CHAT_MUTE (cv_mute.value && !(server || IsPlayerAdmin(consoleplayer))) // this still allows to open the chat but not to type. That's used for scrolling and whatnot.
#define OLD_MUTE (OLDCHAT && cv_mute.value && !(server || IsPlayerAdmin(consoleplayer))) // this is used to prevent oldchat from opening when muted. #define OLD_MUTE (OLDCHAT && cv_mute.value && !(server || IsPlayerAdmin(consoleplayer))) // this is used to prevent oldchat from opening when muted.
+3
View File
@@ -44,6 +44,9 @@ extern "C" {
struct JoyType_s struct JoyType_s
{ {
/*! if true, we MUST Poll() to get new joystick data,
that is: we NEED the DIRECTINPUTDEVICE2 ! (watchout NT compatibility) */
INT32 bJoyNeedPoll;
/*! this joystick is a gamepad, read: digital axes /*! this joystick is a gamepad, read: digital axes
if FALSE, interpret the joystick event data as JOYAXISRANGE (see above) */ if FALSE, interpret the joystick event data as JOYAXISRANGE (see above) */
INT32 bGamepadStyle; INT32 bGamepadStyle;
+1 -12
View File
@@ -29,10 +29,6 @@ extern "C" {
*/ */
#define MAX_QUIT_FUNCS 16 #define MAX_QUIT_FUNCS 16
void I_GetConsoleEvents(void);
extern boolean consolevent;
extern boolean framebuffer;
/** \brief Graphic system had started up /** \brief Graphic system had started up
*/ */
@@ -43,7 +39,7 @@ extern UINT8 graphics_started;
extern UINT8 keyboard_started; extern UINT8 keyboard_started;
/** \brief Set to true when inside a signal handler that will exit the program. */ /** \brief Set to true when inside a signal handler that will exit the program. */
boolean I_In_Exiting_Signal_Handler(void); extern boolean g_in_exiting_signal_handler;
/** \brief The I_GetFreeMem function /** \brief The I_GetFreeMem function
@@ -148,9 +144,6 @@ extern INT32 numcontrollers;
*/ */
const char *I_GetJoyName(INT32 joyindex); const char *I_GetJoyName(INT32 joyindex);
boolean I_GamepadHasLED(INT32 playernum);
boolean I_GamepadHasRumble(INT32 playernum);
void I_GamepadRumble(INT32 playernum, UINT16 low_strength, UINT16 high_strength, UINT32 duration); void I_GamepadRumble(INT32 playernum, UINT16 low_strength, UINT16 high_strength, UINT32 duration);
void I_SetGamepadIndicatorColor(INT32 playernum, UINT8 red, UINT8 green, UINT8 blue); void I_SetGamepadIndicatorColor(INT32 playernum, UINT8 red, UINT8 green, UINT8 blue);
@@ -198,10 +191,6 @@ INT32 I_StartupSystem(void);
*/ */
void I_ShutdownSystem(void); void I_ShutdownSystem(void);
/** \brief To check if a Interrupt or Terminate Signal was fired
*/
boolean I_Interrupted(void);
/** \brief The I_GetDiskFreeSpace function /** \brief The I_GetDiskFreeSpace function
\param freespace a INT64 pointer to hold the free space amount \param freespace a INT64 pointer to hold the free space amount
+17 -13
View File
@@ -496,10 +496,8 @@ static void cleanupnodes(void)
// Why can't I start at zero? // Why can't I start at zero?
for (j = 1; j < MAXNETNODES; j++) for (j = 1; j < MAXNETNODES; j++)
{
if (!(nodeingame[j] || SV_SendingFile(j))) if (!(nodeingame[j] || SV_SendingFile(j)))
nodeconnected[j] = false; nodeconnected[j] = false;
}
} }
static SINT8 getfreenode(void) static SINT8 getfreenode(void)
@@ -509,13 +507,11 @@ static SINT8 getfreenode(void)
cleanupnodes(); cleanupnodes();
for (j = 0; j < MAXNETNODES; j++) for (j = 0; j < MAXNETNODES; j++)
{
if (!nodeconnected[j]) if (!nodeconnected[j])
{ {
nodeconnected[j] = true; nodeconnected[j] = true;
return j; return j;
} }
}
/** \warning No free node? Just in case a node might not have been freed properly, /** \warning No free node? Just in case a node might not have been freed properly,
* look if there are connected nodes that aren't in game, and forget them. * look if there are connected nodes that aren't in game, and forget them.
@@ -816,7 +812,7 @@ static void SOCK_Send(void)
static void SOCK_FreeNodenum(INT32 numnode) static void SOCK_FreeNodenum(INT32 numnode)
{ {
// can't disconnect from self :) // can't disconnect from self :)
if (numnode <= 0 || numnode > MAXNETNODES) if (!numnode || numnode > MAXNETNODES)
return; return;
DEBFILE(va("Free node %d (%s)\n", numnode, SOCK_GetNodeAddress(numnode))); DEBFILE(va("Free node %d (%s)\n", numnode, SOCK_GetNodeAddress(numnode)));
@@ -1436,12 +1432,14 @@ static void SOCK_RegisterHolePunch(void)
static boolean SOCK_OpenSocket(void) static boolean SOCK_OpenSocket(void)
{ {
memset(clientaddress, 0, sizeof(clientaddress)); size_t i;
memset(clientaddress, 0, sizeof (clientaddress));
memset(nodeconnected, false, sizeof(nodeconnected));
nodeconnected[0] = true; // always connected to self nodeconnected[0] = true; // always connected to self
for (i = 1; i < MAXNETNODES; i++)
nodeconnected[i] = false;
nodeconnected[BROADCASTADDR] = true; nodeconnected[BROADCASTADDR] = true;
I_NetSend = SOCK_Send; I_NetSend = SOCK_Send;
I_NetGet = SOCK_Get; I_NetGet = SOCK_Get;
I_NetCloseSocket = SOCK_CloseSocket; I_NetCloseSocket = SOCK_CloseSocket;
@@ -1481,7 +1479,7 @@ static boolean SOCK_Ban(INT32 node)
{ {
INT32 ban; INT32 ban;
if (node < 0 || node > MAXNETNODES) if (node > MAXNETNODES)
return false; return false;
ban = numbans; ban = numbans;
@@ -1512,8 +1510,11 @@ static boolean SOCK_SetBanUsername(const char *username)
username = "Direct IP ban"; username = "Direct IP ban";
} }
Z_Free(banned[numbans - 1].username); if (banned[numbans - 1].username)
banned[numbans - 1].username = NULL; {
Z_Free(banned[numbans - 1].username);
banned[numbans - 1].username = NULL;
}
banned[numbans - 1].username = Z_StrDup(username); banned[numbans - 1].username = Z_StrDup(username);
@@ -1527,8 +1528,11 @@ static boolean SOCK_SetBanReason(const char *reason)
reason = "No reason given"; reason = "No reason given";
} }
Z_Free(banned[numbans - 1].reason); if (banned[numbans - 1].reason)
banned[numbans - 1].reason = NULL; {
Z_Free(banned[numbans - 1].reason);
banned[numbans - 1].reason = NULL;
}
banned[numbans - 1].reason = Z_StrDup(reason); banned[numbans - 1].reason = Z_StrDup(reason);
+1 -1
View File
@@ -21,7 +21,7 @@
#include "m_fixed.h" #include "m_fixed.h"
#include "i_system.h" #include "i_system.h"
timestate_t g_time = {}; timestate_t g_time;
static CV_PossibleValue_t timescale_cons_t[] = {{FRACUNIT/20, "MIN"}, {20*FRACUNIT, "MAX"}, {0, NULL}}; static CV_PossibleValue_t timescale_cons_t[] = {{FRACUNIT/20, "MIN"}, {20*FRACUNIT, "MAX"}, {0, NULL}};
consvar_t cv_timescale = {"timescale", "1.0", CV_NETVAR|CV_CHEAT|CV_FLOAT, timescale_cons_t, NULL, FRACUNIT, NULL, NULL, 0, 0, NULL}; consvar_t cv_timescale = {"timescale", "1.0", CV_NETVAR|CV_CHEAT|CV_FLOAT, timescale_cons_t, NULL, FRACUNIT, NULL, NULL, 0, 0, NULL};
+2 -9
View File
@@ -125,6 +125,8 @@ boolean I_CheckNativeRes(void);
void I_SetBorderlessWindow(void); void I_SetBorderlessWindow(void);
void I_HandleControllerHatRepeat(void);
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
void RefreshOGLSDLSurface(void); void RefreshOGLSDLSurface(void);
@@ -133,15 +135,6 @@ boolean UseScreenFBO(void);
extern boolean downsample; extern boolean downsample;
#endif #endif
// So we can call this from i_video event loop
void I_ShutdownJoystick(UINT8 index);
// Quick thing to make SDL_JOYDEVICEADDED events less of an abomination
void I_UpdateJoystickDeviceIndex(UINT8 player);
void I_UpdateJoystickDeviceIndices(UINT8 excludePlayer);
void I_HandleControllerHatRepeat(void);
#ifdef __cplusplus #ifdef __cplusplus
} // extern "C" } // extern "C"
#endif #endif
-6
View File
@@ -446,12 +446,6 @@ void K_UpdateDirector(void)
} }
} }
// not sure if we should just stop here?
if (targetposition == MAXPLAYERS)
{
break;
}
target = directorinfo.sortedplayers[targetposition]; target = directorinfo.sortedplayers[targetposition];
// stop here since we're already viewing this player // stop here since we're already viewing this player
+36 -68
View File
@@ -83,7 +83,6 @@ IMPL_HUD_OFFSET(stat); // Stats
// extra hud things // extra hud things
consvar_t cv_showstats = {"showstats", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_showstats = {"showstats", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_showstats_skinname = {"showstats_skinname", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_highresportrait = {"highresportrait", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; // make char potraits use their high-res version instead consvar_t cv_highresportrait = {"highresportrait", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; // make char potraits use their high-res version instead
@@ -93,7 +92,6 @@ consvar_t cv_showinput = {"showinput", "Off", CV_SAVE, inputdisplay_cons_t, NULL
static CV_PossibleValue_t minihead_cons_t[] = {{0, "Off"}, {1, "On"}, {2, "Others"}, {0, NULL}}; static CV_PossibleValue_t minihead_cons_t[] = {{0, "Off"}, {1, "On"}, {2, "Others"}, {0, NULL}};
consvar_t cv_minihead = {"smallminimapplayers", "Off", CV_SAVE, minihead_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_minihead = {"smallminimapplayers", "Off", CV_SAVE, minihead_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_showminimapnames = {"showminimapnames", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_showminimapnames = {"showminimapnames", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_showminimapfinished = {"showminimapfinished", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
CV_PossibleValue_t minimapdot_cons_t[NUMMINIMAPDOTSTUFF]; CV_PossibleValue_t minimapdot_cons_t[NUMMINIMAPDOTSTUFF];
consvar_t cv_showminimapangle = {"showminimapangle", "Off", CV_SAVE, minimapdot_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_showminimapangle = {"showminimapangle", "Off", CV_SAVE, minimapdot_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
@@ -209,7 +207,6 @@ void K_RegisterKartHudStuff(void)
CV_RegisterVar(&cv_kartspeedometer); CV_RegisterVar(&cv_kartspeedometer);
CV_RegisterVar(&cv_showstats); CV_RegisterVar(&cv_showstats);
CV_RegisterVar(&cv_showstats_skinname);
CV_RegisterVar(&cv_showinput); CV_RegisterVar(&cv_showinput);
CV_RegisterVar(&cv_posanim); CV_RegisterVar(&cv_posanim);
@@ -224,7 +221,6 @@ void K_RegisterKartHudStuff(void)
CV_RegisterVar(&cv_minihead); CV_RegisterVar(&cv_minihead);
CV_RegisterVar(&cv_showminimapnames); CV_RegisterVar(&cv_showminimapnames);
CV_RegisterVar(&cv_showminimapfinished);
CV_RegisterVar(&cv_showminimapangle); CV_RegisterVar(&cv_showminimapangle);
CV_RegisterVar(&cv_showlapemblem); CV_RegisterVar(&cv_showlapemblem);
@@ -572,7 +568,7 @@ static patch_t *kp_racefinish[6];
static patch_t *kp_positionnum[NUMPOSNUMS][NUMPOSFRAMES]; static patch_t *kp_positionnum[NUMPOSNUMS][NUMPOSFRAMES];
static patch_t *kp_winnernum[NUMPOSFRAMES]; static patch_t *kp_winnernum[NUMPOSFRAMES];
patch_t *kp_facenum[MAXPLAYERS+1] = {}; patch_t *kp_facenum[MAXPLAYERS+1];
static patch_t *kp_facehighlight[8]; static patch_t *kp_facehighlight[8];
static patch_t *kp_rankbumper; static patch_t *kp_rankbumper;
@@ -935,21 +931,21 @@ const char *K_GetItemPatch(UINT8 item, boolean tiny)
//} //}
static INT32 ITEM_X, ITEM_Y; // Item Window INT32 ITEM_X, ITEM_Y; // Item Window
static INT32 TIME_X, TIME_Y; // Time Sticker INT32 TIME_X, TIME_Y; // Time Sticker
static INT32 LAPS_X, LAPS_Y; // Lap Sticker INT32 LAPS_X, LAPS_Y; // Lap Sticker
static INT32 SPDM_X, SPDM_Y; // Speedometer INT32 SPDM_X, SPDM_Y; // Speedometer
static INT32 POSI_X, POSI_Y; // Position Number INT32 POSI_X, POSI_Y; // Position Number
static INT32 FACE_X, FACE_Y; // Top-four Faces INT32 FACE_X, FACE_Y; // Top-four Faces
static INT32 STCD_X, STCD_Y; // Starting countdown INT32 STCD_X, STCD_Y; // Starting countdown
static INT32 CHEK_Y; // CHECK graphic INT32 CHEK_Y; // CHECK graphic
static INT32 MINI_X, MINI_Y; // Minimap INT32 MINI_X, MINI_Y; // Minimap
static INT32 WANT_X, WANT_Y; // Battle WANTED poster INT32 WANT_X, WANT_Y; // Battle WANTED poster
// This is for the P2 and P4 side of splitscreen. Then we'll flip P1's and P2's to the bottom with V_SPLITSCREEN. // This is for the P2 and P4 side of splitscreen. Then we'll flip P1's and P2's to the bottom with V_SPLITSCREEN.
static INT32 ITEM2_X, ITEM2_Y; INT32 ITEM2_X, ITEM2_Y;
static INT32 LAPS2_X, LAPS2_Y; INT32 LAPS2_X, LAPS2_Y;
static INT32 POSI2_X, POSI2_Y; INT32 POSI2_X, POSI2_Y;
static void K_initKartHUD(void) static void K_initKartHUD(void)
{ {
@@ -1069,7 +1065,7 @@ static void K_initKartHUD(void)
} }
if (timeinmap > 113 || forceshowhud) if (timeinmap > 113 || forceshowhud)
hudtrans = (UINT8)cv_translucenthud.value; hudtrans = cv_translucenthud.value;
else if (timeinmap > 105) else if (timeinmap > 105)
hudtrans = ((((INT32)timeinmap) - 105)*cv_translucenthud.value)/(113-105); hudtrans = ((((INT32)timeinmap) - 105)*cv_translucenthud.value)/(113-105);
else else
@@ -1126,9 +1122,9 @@ void K_KartPlayerHUDUpdate(player_t *player)
UINT8 K_GetHudColor(void) UINT8 K_GetHudColor(void)
{ {
if (cv_colorizedhud.value && cv_colorizedhudcolor.value) if (cv_colorizedhud.value && cv_colorizedhudcolor.value)
return (UINT8)cv_colorizedhudcolor.value; return cv_colorizedhudcolor.value;
return ((stplyr && gamestate == GS_LEVEL) ? stplyr->skincolor : (UINT8)cv_playercolor.value); return ((stplyr && gamestate == GS_LEVEL) ? stplyr->skincolor : cv_playercolor.value);
} }
boolean K_UseColorHud(void) boolean K_UseColorHud(void)
@@ -1419,6 +1415,8 @@ static void K_drawKartStats(void)
break; break;
} }
} }
else
spdoffset = 0;
if (G_BattleGametype() && ((speedostyle != SPEEDO_DIAL) || splitscreen)) if (G_BattleGametype() && ((speedostyle != SPEEDO_DIAL) || splitscreen))
spdoffset += ((stplyr->kartstuff[k_bumper] ? -5 : -8)); spdoffset += ((stplyr->kartstuff[k_bumper] ? -5 : -8));
@@ -1438,16 +1436,13 @@ static void K_drawKartStats(void)
fakeskin = K_GetPlayerSkin(stplyr); fakeskin = K_GetPlayerSkin(stplyr);
// Skin name // Skin name
if (cv_showstats_skinname.value) if (K_IsHighResolution()) // V_DrawSmallString becomes a mess at low resolutions lel
{ {
if (K_IsHighResolution()) // V_DrawSmallString becomes a mess at low resolutions lel V_DrawSmallString(x+20, y+12, flags2, fakeskin->realname);
{ }
V_DrawSmallString(x+20, y+12, flags2, fakeskin->realname); else
} {
else V_DrawThinString(x+20, y+7, flags2, fakeskin->realname);
{
V_DrawThinString(x+20, y+7, flags2, fakeskin->realname);
}
} }
// Icon and stats // Icon and stats
@@ -1531,7 +1526,7 @@ static void K_drawKartItem(void)
{ {
localcolor = K_GetHudColor(); localcolor = K_GetHudColor();
switch ((stplyr->kartstuff[k_itemroulette] % (14*3)) / 3) switch((stplyr->kartstuff[k_itemroulette] % (14*3)) / 3)
{ {
// Each case is handled in threes, to give three frames of in-game time to see the item on the roulette // Each case is handled in threes, to give three frames of in-game time to see the item on the roulette
case 0: // Sneaker case 0: // Sneaker
@@ -2101,7 +2096,7 @@ static void K_DrawKartPositionNum(INT32 num)
fy = POSI_Y; fy = POSI_Y;
fflags = V_SNAPTOLEFT|((stplyrnum == 2) ? V_SPLITSCREEN|V_SNAPTOBOTTOM : 0); // flip P3 to the bottom. fflags = V_SNAPTOLEFT|((stplyrnum == 2) ? V_SPLITSCREEN|V_SNAPTOBOTTOM : 0); // flip P3 to the bottom.
flipdraw = true; flipdraw = true;
if (num >= 10) if (num && num >= 10)
fx += W; // this seems dumb, but we need to do this in order for positions above 10 going off screen. fx += W; // this seems dumb, but we need to do this in order for positions above 10 going off screen.
} }
else // else, that means we're P2 or P4. else // else, that means we're P2 or P4.
@@ -2200,7 +2195,7 @@ static boolean K_drawKartPositionFaces(void)
return true; return true;
if (!LUA_HudEnabled(hud_minirankings)) if (!LUA_HudEnabled(hud_minirankings))
return false; // Don't proceed but still return true for free play above if HUD is disabled. return false; // Don't proceed but still return true for free play above if HUD is disabled.
for (j = 0; j < numplayersingame; j++) for (j = 0; j < numplayersingame; j++)
{ {
@@ -3779,9 +3774,6 @@ static void K_drawKartMinimap(void)
if (!players[i].mo || players[i].spectator) if (!players[i].mo || players[i].spectator)
continue; continue;
if (!cv_showminimapfinished.value && players[i].exiting)
continue;
if (P_IsDisplayPlayer(&players[i])) if (P_IsDisplayPlayer(&players[i]))
{ {
// Draw display players on top of everything else // Draw display players on top of everything else
@@ -3826,7 +3818,7 @@ static void K_drawKartMinimap(void)
if (cv_showminimapangle.value && (minidoticon || minilighticon) && !playertimedout) if (cv_showminimapangle.value && (minidoticon || minilighticon) && !playertimedout)
{ {
UINT8 *colormap = NULL; UINT8 *colormap;
drawinfo_t dims; drawinfo_t dims;
fixed_t interpx, interpy; fixed_t interpx, interpy;
fixed_t xoff = 0, yoff = 0; fixed_t xoff = 0, yoff = 0;
@@ -3837,27 +3829,10 @@ static void K_drawKartMinimap(void)
if (encoremode) if (encoremode)
ang = ANGLE_180 - ang; ang = ANGLE_180 - ang;
if (mobj->color) if (mobj->colorized)
{ colormap = R_GetTranslationColormap(TC_RAINBOW, mobj->color, GTC_CACHE);
if (mobj->colorized) else
{ colormap = R_GetLocalTranslationColormap(mobj->skin, mobj->localskin, mobj->color, GTC_CACHE, mobj->skinlocal);
colormap = R_GetTranslationColormap(TC_RAINBOW, mobj->color, GTC_CACHE);
}
else
{
const INT32 skinnum = K_GetMobjLocalSkinNum(mobj->skin, mobj->localskin, mobj->skinlocal);
// special case if startcolor is not the default (160 / Green)
if (skinnum && skins[skinnum].starttranscolor != skins[0].starttranscolor)
{
colormap = R_GetTranslationColormap(TC_DEFAULT, mobj->color, GTC_CACHE);
}
else
{
colormap = R_GetLocalTranslationColormap(mobj->skin, mobj->localskin, mobj->color, GTC_CACHE, mobj->skinlocal);
}
}
}
interpx = lerp(mobj->old_x, mobj->x); interpx = lerp(mobj->old_x, mobj->x);
interpy = lerp(mobj->old_y, mobj->y); interpy = lerp(mobj->old_y, mobj->y);
@@ -4022,7 +3997,6 @@ static void K_drawBattleFullscreen(void)
{ {
if (stplyrnum == 0) if (stplyrnum == 0)
V_DrawFadeScreen(0xFF00, 16); V_DrawFadeScreen(0xFF00, 16);
if (stplyr->exiting < 6*TICRATE && !stplyr->spectator) if (stplyr->exiting < 6*TICRATE && !stplyr->spectator)
{ {
if (stplyr->kartstuff[k_position] == 1) if (stplyr->kartstuff[k_position] == 1)
@@ -4087,7 +4061,7 @@ static void K_drawBattleFullscreen(void)
{ {
if (i == displayplayers[0]) if (i == displayplayers[0])
continue; continue;
if (playeringame[i]) if (playeringame[i] && !stplyr->spectator)
return; return;
} }
@@ -4338,7 +4312,7 @@ static void K_drawInput(void)
} }
else else
{ {
const boolean analogjoystickmove = cv_usejoystick[stplyrnum].value && !Joystick[stplyrnum].bGamepadStyle; const boolean analogjoystickmove = cv_usejoystick[stplyrnum].value && !Joystick[stplyrnum].bGamepadStyle;
const boolean gamepadjoystickmove = cv_usejoystick[stplyrnum].value && Joystick[stplyrnum].bGamepadStyle; const boolean gamepadjoystickmove = cv_usejoystick[stplyrnum].value && Joystick[stplyrnum].bGamepadStyle;
const UINT8 ssplayer = stplyrnum+1; const UINT8 ssplayer = stplyrnum+1;
@@ -4355,10 +4329,9 @@ static void K_drawInput(void)
{ {
hudforward += KART_FULLTURN; hudforward += KART_FULLTURN;
} }
if (InputDown(gc_aimbackward, ssplayer) || (gamepadjoystickmove && axis > 0)) if (InputDown(gc_aimbackward, ssplayer) || (gamepadjoystickmove && axis > 0))
{ {
hudforward -= KART_FULLTURN; hudforward-= KART_FULLTURN;
} }
} }
@@ -4444,7 +4417,6 @@ static void K_drawChallengerScreen(void)
19,20,19,20,19,20,19,20,19,20, // frame 20-21, 1 tic, 5 alternating: all text vibrates from impact 19,20,19,20,19,20,19,20,19,20, // frame 20-21, 1 tic, 5 alternating: all text vibrates from impact
21,22,23,24 // frame 22-25, 1 tic: CHALLENGER turns gold 21,22,23,24 // frame 22-25, 1 tic: CHALLENGER turns gold
}; };
const UINT8 offset = min(52-1, (3*TICRATE)-mapreset); const UINT8 offset = min(52-1, (3*TICRATE)-mapreset);
V_DrawFadeScreen(0xFF00, 16); // Fade out V_DrawFadeScreen(0xFF00, 16); // Fade out
@@ -4546,7 +4518,6 @@ static void K_drawDistributionDebugger(void)
kp_orbinaut[4], kp_orbinaut[4],
kp_jawz[1] kp_jawz[1]
}; };
INT32 useodds = 0; INT32 useodds = 0;
INT32 pingame = 0, bestbumper = 0; INT32 pingame = 0, bestbumper = 0;
INT32 i; INT32 i;
@@ -4563,10 +4534,8 @@ static void K_drawDistributionDebugger(void)
if (!playeringame[i] || players[i].spectator) if (!playeringame[i] || players[i].spectator)
continue; continue;
pingame++; pingame++;
if (players[i].exiting) if (players[i].exiting)
dontforcespb = true; dontforcespb = true;
if (players[i].kartstuff[k_bumper] > bestbumper) if (players[i].kartstuff[k_bumper] > bestbumper)
bestbumper = players[i].kartstuff[k_bumper]; bestbumper = players[i].kartstuff[k_bumper];
} }
@@ -4720,7 +4689,6 @@ void K_drawKartHUD(void)
{ {
if (LUA_HudEnabled(hud_battlefullscreen)) if (LUA_HudEnabled(hud_battlefullscreen))
K_drawBattleFullscreen(); K_drawBattleFullscreen();
return; return;
} }
-1
View File
@@ -35,7 +35,6 @@ extern consvar_t cv_darkitembox;
extern consvar_t cv_biglaps; extern consvar_t cv_biglaps;
extern consvar_t cv_highresportrait; extern consvar_t cv_highresportrait;
extern consvar_t cv_showstats; extern consvar_t cv_showstats;
extern consvar_t cv_showstats_skinname;
extern consvar_t cv_fancyroulette; extern consvar_t cv_fancyroulette;
extern consvar_t cv_showlaptimes; extern consvar_t cv_showlaptimes;
extern consvar_t cv_battlespeedo; extern consvar_t cv_battlespeedo;
+20 -47
View File
@@ -47,8 +47,6 @@ consvar_t cv_airsparks = {"airdriftsparks", "Off", CV_SAVE, CV_OnOff, NULL, 0, N
consvar_t cv_playerblendeffects = {"playerblendeffects", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_playerblendeffects = {"playerblendeffects", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_reducevfx = {"reducevfx", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
// funn-E streeetch // funn-E streeetch
static CV_PossibleValue_t stretchfactor_t[] = {{0, "MIN"}, {FRACUNIT, "MAX"}, {0, NULL}}; static CV_PossibleValue_t stretchfactor_t[] = {{0, "MIN"}, {FRACUNIT, "MAX"}, {0, NULL}};
consvar_t cv_gravstretch = {"gravstretch", "MIN", CV_SAVE|CV_FLOAT, stretchfactor_t, NULL, 0, NULL, NULL, 0, 0, NULL}; consvar_t cv_gravstretch = {"gravstretch", "MIN", CV_SAVE|CV_FLOAT, stretchfactor_t, NULL, 0, NULL, NULL, 0, 0, NULL};
@@ -484,8 +482,7 @@ UINT8 colortranslations[MAXTRANSLATIONS][16] = {
// //
UINT8 K_RainbowColor(void) UINT8 K_RainbowColor(void)
{ {
const tic_t time = cv_reducevfx.value ? (leveltime >> 3) : leveltime; return (UINT8)(1 + (leveltime % (MAXSKINCOLORS-1)));
return (UINT8)(1 + (time % (MAXSKINCOLORS-1)));
} }
// Define for getting accurate color brightness readings according to how the human eye sees them. // Define for getting accurate color brightness readings according to how the human eye sees them.
@@ -660,22 +657,13 @@ INT32 K_GetSkinNum(player_t *player)
// //
// returns the mobj skinnumber // returns the mobj skinnumber
// accounts for localskins ? // accounts for localskins
// //
INT32 K_GetMobjSkinNum(const skin_t *skin, boolean local) INT32 K_GetMobjSkinNum(const skin_t *skin, boolean local)
{ {
return skin - K_GetSkinArray(local); return skin - K_GetSkinArray(local);
} }
//
// returns the mobj skinnumber
// accounts for localskins
//
INT32 K_GetMobjLocalSkinNum(const skin_t *skin, const skin_t *localskin, boolean local)
{
return localskin ? (localskin - K_GetSkinArray(local)) : (skin - skins);
}
// //
// returns the players skinnumber // returns the players skinnumber
// accounts for localskins // accounts for localskins
@@ -776,8 +764,6 @@ void K_RegisterClientKartStuff(void)
CV_RegisterVar(&cv_playerblendeffects); CV_RegisterVar(&cv_playerblendeffects);
CV_RegisterVar(&cv_reducevfx);
CV_RegisterVar(&cv_saltyhop); CV_RegisterVar(&cv_saltyhop);
CV_RegisterVar(&cv_saltyhopsfx); CV_RegisterVar(&cv_saltyhopsfx);
CV_RegisterVar(&cv_saltysquish); CV_RegisterVar(&cv_saltysquish);
@@ -1489,6 +1475,7 @@ void K_KartBouncing(mobj_t *mobj1, mobj_t *mobj2, boolean bounce, boolean solid)
fixed_t nx = FixedDiv(distx, dist); fixed_t nx = FixedDiv(distx, dist);
fixed_t ny = FixedDiv(disty, dist); fixed_t ny = FixedDiv(disty, dist);
dist = dist ? dist : 1;
distx = FixedMul(mobj1->radius+mobj2->radius, nx); distx = FixedMul(mobj1->radius+mobj2->radius, nx);
disty = FixedMul(mobj1->radius+mobj2->radius, ny); disty = FixedMul(mobj1->radius+mobj2->radius, ny);
@@ -1955,9 +1942,11 @@ static void K_PlayGenericCombatSound(mobj_t *source, mobj_t *other, sfxenum_t sf
if (!skin) if (!skin)
return; return;
boolean alwaysHear = false;
if (cv_kartvoices.value && !P_MobjWasRemoved(other) && other->player != NULL) if (cv_kartvoices.value && !P_MobjWasRemoved(other) && other->player != NULL)
{ {
boolean alwaysHear = P_IsDisplayPlayer(other->player); alwaysHear = P_IsDisplayPlayer(other->player);
S_StartSound(alwaysHear ? NULL : source, skin->soundsid[S_sfx[sfx_id].skinsound]); S_StartSound(alwaysHear ? NULL : source, skin->soundsid[S_sfx[sfx_id].skinsound]);
} }
@@ -2157,13 +2146,7 @@ static void K_GetKartBoostPower(player_t *player)
&& player->speed > 0 && player->speed > 0
&& !player->spectator) && !player->spectator)
{ {
mobj_t *dust = K_SpawnWipeoutTrail(player->mo, true); K_SpawnWipeoutTrail(player->mo, true);
// Technically, all mobjs that think can cause desynchs if they are spawned conditionally, so best we can do
// is to hide them if you are in saltyhop jump
if (dust && player->mo->salty.jump)
dust->flags2 |= MF2_DONTDRAW;
if (leveltime % 6 == 0) if (leveltime % 6 == 0)
S_StartSound(player->mo, sfx_cdfm70); S_StartSound(player->mo, sfx_cdfm70);
} }
@@ -2370,7 +2353,6 @@ void K_SpawnBattlePoints(player_t *source, player_t *victim, UINT8 amount)
break; break;
case 3: case 3:
st = S_BATTLEPOINT3A; st = S_BATTLEPOINT3A;
break;
default: default:
return; // NO STATE! return; // NO STATE!
} }
@@ -3121,18 +3103,17 @@ static mobj_t *K_SpawnKartMissile(mobj_t *source, mobjtype_t type, angle_t an, I
return NULL; return NULL;
} }
static UINT8 K_DriftSparkColor(player_t *player, INT32 charge) static UINT16 K_DriftSparkColor(player_t *player, INT32 charge)
{ {
UINT8 color = SKINCOLOR_NONE; UINT16 color = SKINCOLOR_NONE;
const INT32 sparkval = K_GetKartDriftSparkValue(player);
if (charge >= sparkval*4) if (charge >= K_GetKartDriftSparkValue(player)*4)
{ {
color = K_RainbowColor(); color = K_RainbowColor();
} }
else if (charge >= sparkval*2) else if (charge >= K_GetKartDriftSparkValue(player)*2)
{ {
if (charge <= (sparkval*2)+(24*3)) if (charge <= (K_GetKartDriftSparkValue(player)*2)+(24*3))
color = SKINCOLOR_RASPBERRY; // transition color = SKINCOLOR_RASPBERRY; // transition
else else
color = SKINCOLOR_KETCHUP; color = SKINCOLOR_KETCHUP;
@@ -3613,8 +3594,6 @@ void K_SpawnSparkleTrail(mobj_t *mo)
I_Assert(mo != NULL); I_Assert(mo != NULL);
I_Assert(!P_MobjWasRemoved(mo)); I_Assert(!P_MobjWasRemoved(mo));
const boolean shouldblend = (mo->player && K_PlayerEffectsShouldBlend(mo->player));
for (i = 0; i < 3; i++) for (i = 0; i < 3; i++)
{ {
fixed_t newx = mo->x + mo->momx + (P_RandomRange(-rad, rad)<<FRACBITS); fixed_t newx = mo->x + mo->momx + (P_RandomRange(-rad, rad)<<FRACBITS);
@@ -3632,14 +3611,14 @@ void K_SpawnSparkleTrail(mobj_t *mo)
sparkle->color = mo->color; sparkle->color = mo->color;
if (shouldblend) if (mo->player && K_PlayerEffectsShouldBlend(mo->player))
sparkle->blendmode = AST_ADD; sparkle->blendmode = AST_ADD;
} }
P_SetMobjState(sparkle, S_KARTINVULN_LARGE1); P_SetMobjState(sparkle, S_KARTINVULN_LARGE1);
} }
mobj_t *K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent) void K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent)
{ {
mobj_t *dust; mobj_t *dust;
angle_t aoff; angle_t aoff;
@@ -3676,10 +3655,10 @@ mobj_t *K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent)
dust->momx = mo->momx/2; dust->momx = mo->momx/2;
dust->momy = mo->momy/2; dust->momy = mo->momy/2;
dust->momz = mo->momz/2; dust->momz = mo->momz/2;
dust->flags2 |= MF2_SHADOW;
} }
return dust; if (translucent)
dust->flags2 |= MF2_SHADOW;
} }
// K_DriftDustHandling // K_DriftDustHandling
@@ -4654,7 +4633,8 @@ void K_RepairOrbitChain(mobj_t *orbit)
prev->movedir = num; prev->movedir = num;
} }
player->kartstuff[k_itemamount] = num; if (player->kartstuff[k_itemamount] != num)
player->kartstuff[k_itemamount] = num;
} }
} }
@@ -6179,13 +6159,6 @@ void K_KartUpdatePosition(player_t *player)
} }
} }
// the player should NOT be checked against themselves! lol
// otherwise prevcheck will effectively be halved
// sadly this stuff is exposed to lua and atleast one script uses those so we cant fix it
// oh well
//if (player == &players[i])
//continue;
const boolean isprevcheckpointi = mo->health == players[i].starpostnum; const boolean isprevcheckpointi = mo->health == players[i].starpostnum;
const boolean isnextcheckpointi = mo->health == (players[i].starpostnum + 1); const boolean isnextcheckpointi = mo->health == (players[i].starpostnum + 1);
@@ -6792,7 +6765,7 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
{ {
if (splitscreen) if (splitscreen)
{ {
if (!cv_reducevfx.value && leveltime & 1) if (leveltime & 1)
player->mo->flags2 |= MF2_DONTDRAW; player->mo->flags2 |= MF2_DONTDRAW;
else else
player->mo->flags2 &= ~MF2_DONTDRAW; player->mo->flags2 &= ~MF2_DONTDRAW;
@@ -6818,7 +6791,7 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
if (P_IsDisplayPlayer(player) if (P_IsDisplayPlayer(player)
|| (!P_IsDisplayPlayer(player) && (player->kartstuff[k_hyudorotimer] < (1*TICRATE/2) || player->kartstuff[k_hyudorotimer] > hyudorotime-(1*TICRATE/2)))) || (!P_IsDisplayPlayer(player) && (player->kartstuff[k_hyudorotimer] < (1*TICRATE/2) || player->kartstuff[k_hyudorotimer] > hyudorotime-(1*TICRATE/2))))
{ {
if (!cv_reducevfx.value && leveltime & 1) if (leveltime & 1)
player->mo->flags2 |= MF2_DONTDRAW; player->mo->flags2 |= MF2_DONTDRAW;
else else
player->mo->flags2 &= ~MF2_DONTDRAW; player->mo->flags2 &= ~MF2_DONTDRAW;
+1 -1
View File
@@ -57,7 +57,7 @@ boolean K_ShouldSlopeRoll(mobj_t *mobj);
void K_RollMobjBySlopes(mobj_t *mo, pslope_t *slope); void K_RollMobjBySlopes(mobj_t *mo, pslope_t *slope);
void K_SpawnBoostTrail(player_t *player); void K_SpawnBoostTrail(player_t *player);
void K_SpawnSparkleTrail(mobj_t *mo); void K_SpawnSparkleTrail(mobj_t *mo);
mobj_t *K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent); void K_SpawnWipeoutTrail(mobj_t *mo, boolean translucent);
void K_DriftDustHandling(mobj_t *spawner); void K_DriftDustHandling(mobj_t *spawner);
void K_PuntMine(mobj_t *mine, mobj_t *punter); void K_PuntMine(mobj_t *mine, mobj_t *punter);
void K_DoSneaker(player_t *player, INT32 type); void K_DoSneaker(player_t *player, INT32 type);
+2 -1
View File
@@ -99,7 +99,8 @@ void K_EraseStats(void)
// The only field we want to remember // The only field we want to remember
boolean vanilla = kartstats.vanilla; boolean vanilla = kartstats.vanilla;
Z_Free(kartstats.copy); if (kartstats.copy)
Z_Free(kartstats.copy);
memset(&kartstats, 0, sizeof(kartstats_t)); memset(&kartstats, 0, sizeof(kartstats_t));
-1
View File
@@ -1293,7 +1293,6 @@ static int lib_pPlayRinglossSound(lua_State *L)
player_t *player = NULL; player_t *player = NULL;
mobj_t *damager = NULL; mobj_t *damager = NULL;
NOHUD NOHUD
LUA_UsageWarning(L, "P_PlayRinglossSound: using this function from lua might cause desynchs, consider using S_StartSound(origin, sfx_khurt1 + P_RandomKey(2)) as workaround");
if (!source) if (!source)
return LUA_ErrInvalid(L, "mobj_t"); return LUA_ErrInvalid(L, "mobj_t");
if (!lua_isnone(L, 2) && lua_isuserdata(L, 2)) if (!lua_isnone(L, 2) && lua_isuserdata(L, 2))
+13 -42
View File
@@ -358,8 +358,7 @@ static int lib_cvRegisterVar(lua_State *L)
#define TYPEERROR(f, t) FIELDERROR(f, va("%s expected, got %s", lua_typename(L, t), luaL_typename(L, -1))) #define TYPEERROR(f, t) FIELDERROR(f, va("%s expected, got %s", lua_typename(L, t), luaL_typename(L, -1)))
lua_pushnil(L); lua_pushnil(L);
while (lua_next(L, 1)) while (lua_next(L, 1)) {
{
// stack: cvar table, cvar userdata, key/index, value // stack: cvar table, cvar userdata, key/index, value
// 1 2 3 4 // 1 2 3 4
i = 0; i = 0;
@@ -369,40 +368,26 @@ static int lib_cvRegisterVar(lua_State *L)
else if (lua_isstring(L, 3)) else if (lua_isstring(L, 3))
k = lua_tostring(L, 3); k = lua_tostring(L, 3);
if (i == 1 || (k && fasticmp(k, "name"))) if (i == 1 || (k && fasticmp(k, "name"))) {
{
if (!lua_isstring(L, 4)) if (!lua_isstring(L, 4))
TYPEERROR("name", LUA_TSTRING) TYPEERROR("name", LUA_TSTRING)
cvar->name = Z_StrDup(lua_tostring(L, 4)); cvar->name = Z_StrDup(lua_tostring(L, 4));
} } else if (i == 2 || (k && fasticmp(k, "defaultvalue"))) {
else if (i == 2 || (k && fasticmp(k, "defaultvalue")))
{
if (!lua_isstring(L, 4)) if (!lua_isstring(L, 4))
TYPEERROR("defaultvalue", LUA_TSTRING) TYPEERROR("defaultvalue", LUA_TSTRING)
cvar->defaultvalue = Z_StrDup(lua_tostring(L, 4)); cvar->defaultvalue = Z_StrDup(lua_tostring(L, 4));
} } else if (i == 3 || (k && fasticmp(k, "flags"))) {
else if (i == 3 || (k && fasticmp(k, "flags")))
{
if (!lua_isnumber(L, 4)) if (!lua_isnumber(L, 4))
TYPEERROR("flags", LUA_TNUMBER) TYPEERROR("flags", LUA_TNUMBER)
cvar->flags = (INT32)lua_tointeger(L, 4); cvar->flags = (INT32)lua_tointeger(L, 4);
} } else if (i == 4 || (k && fasticmp(k, "PossibleValue"))) {
else if (i == 4 || (k && fasticmp(k, "PossibleValue"))) if (lua_islightuserdata(L, 4)) {
{
if (lua_islightuserdata(L, 4))
{
CV_PossibleValue_t *pv = lua_touserdata(L, 4); CV_PossibleValue_t *pv = lua_touserdata(L, 4);
if (pv == CV_OnOff || pv == CV_YesNo || pv == CV_Unsigned || pv == CV_Natural) if (pv == CV_OnOff || pv == CV_YesNo || pv == CV_Unsigned || pv == CV_Natural)
cvar->PossibleValue = pv; cvar->PossibleValue = pv;
else else
FIELDERROR("PossibleValue", "CV_PossibleValue_t expected, got unrecognised pointer") FIELDERROR("PossibleValue", "CV_PossibleValue_t expected, got unrecognised pointer")
} } else if (lua_istable(L, 4)) {
else if (lua_istable(L, 4))
{
// Accepts tables in the form of {MIN=0, MAX=9999} or {Red=0, Green=1, Blue=2} // Accepts tables in the form of {MIN=0, MAX=9999} or {Red=0, Green=1, Blue=2}
// and converts them to CV_PossibleValue_t {{0,"MIN"},{9999,"MAX"}} or {{0,"Red"},{1,"Green"},{2,"Blue"}} // and converts them to CV_PossibleValue_t {{0,"MIN"},{9999,"MAX"}} or {{0,"Red"},{1,"Green"},{2,"Blue"}}
// //
@@ -413,9 +398,7 @@ static int lib_cvRegisterVar(lua_State *L)
CV_PossibleValue_t *cvpv; CV_PossibleValue_t *cvpv;
lua_pushnil(L); lua_pushnil(L);
while (lua_next(L, 4)) {
while (lua_next(L, 4))
{
count++; count++;
lua_pop(L, 1); lua_pop(L, 1);
} }
@@ -429,9 +412,7 @@ static int lib_cvRegisterVar(lua_State *L)
i = 0; i = 0;
lua_pushnil(L); lua_pushnil(L);
while (lua_next(L, 4)) {
while (lua_next(L, 4))
{
// stack: [...] PossibleValue table, index, value // stack: [...] PossibleValue table, index, value
// 4 5 6 // 4 5 6
if (lua_type(L, 5) != LUA_TSTRING if (lua_type(L, 5) != LUA_TSTRING
@@ -442,19 +423,14 @@ static int lib_cvRegisterVar(lua_State *L)
i++; i++;
lua_pop(L, 1); lua_pop(L, 1);
} }
cvpv[i].value = 0; cvpv[i].value = 0;
cvpv[i].strvalue = NULL; cvpv[i].strvalue = NULL;
cvar->PossibleValue = cvpv; cvar->PossibleValue = cvpv;
} } else
else
FIELDERROR("PossibleValue", va("%s or CV_PossibleValue_t expected, got %s", lua_typename(L, LUA_TTABLE), luaL_typename(L, -1))) FIELDERROR("PossibleValue", va("%s or CV_PossibleValue_t expected, got %s", lua_typename(L, LUA_TTABLE), luaL_typename(L, -1)))
} } else if (i == 5 || (k && fasticmp(k, "func"))) {
else if (i == 5 || (k && fasticmp(k, "func")))
{
if (!lua_isfunction(L, 4)) if (!lua_isfunction(L, 4))
TYPEERROR("func", LUA_TFUNCTION) TYPEERROR("func", LUA_TFUNCTION)
lua_getfield(L, LUA_REGISTRYINDEX, "CV_OnChange"); lua_getfield(L, LUA_REGISTRYINDEX, "CV_OnChange");
I_Assert(lua_istable(L, 5)); I_Assert(lua_istable(L, 5));
lua_pushlightuserdata(L, cvar); lua_pushlightuserdata(L, cvar);
@@ -462,13 +438,9 @@ static int lib_cvRegisterVar(lua_State *L)
lua_rawset(L, 5); lua_rawset(L, 5);
lua_pop(L, 1); lua_pop(L, 1);
cvar->func = Lua_OnChange; cvar->func = Lua_OnChange;
if (i == 5 && !(cvar->flags & CV_CALL))
{
category = lua_isnoneornil(L, 4) ? NULL : lua_tostring(L, 4);
}
} }
else if ((cvar->flags & CV_CALL && i == 6) else if (((i == 5 && !(cvar->flags & CV_CALL))
|| (cvar->flags & CV_CALL && i == 6))
|| (k && fasticmp(k, "category"))) || (k && fasticmp(k, "category")))
{ {
category = lua_isnoneornil(L, 4) ? NULL : lua_tostring(L, 4); category = lua_isnoneornil(L, 4) ? NULL : lua_tostring(L, 4);
@@ -479,7 +451,6 @@ static int lib_cvRegisterVar(lua_State *L)
{ {
menu_name = lua_isnoneornil(L, 4) ? NULL : lua_tostring(L, 4); menu_name = lua_isnoneornil(L, 4) ? NULL : lua_tostring(L, 4);
} }
lua_pop(L, 1); lua_pop(L, 1);
} }
#undef FIELDERROR #undef FIELDERROR
+39 -29
View File
@@ -199,7 +199,7 @@ FUNCINLINE static ATTRINLINE void add_hook(hook_t *map)
FUNCINLINE static ATTRINLINE void add_mobj_hook(lua_State *L, int hook_type) FUNCINLINE static ATTRINLINE void add_mobj_hook(lua_State *L, int hook_type)
{ {
mobjtype_t mobj_type = luaL_optnumber(L, 3, MT_NULL); mobjtype_t mobj_type = luaL_optnumber(L, 3, MT_NULL);
luaL_argcheck(L, mobj_type < NUMMOBJTYPES, 3, "invalid mobjtype_t"); luaL_argcheck(L, mobj_type < NUMMOBJTYPES, 3, "invalid mobjtype_t");
@@ -296,7 +296,8 @@ struct Hook_State {
INT32 status;/* return status to calling function */ INT32 status;/* return status to calling function */
void * userdata; void * userdata;
int hook_type; int hook_type;
mobjtype_t mobj_type;/* <NUMMOBJTYPES if mobj hook */ mobjtype_t mobj_type;/* >0 if mobj hook */
boolean force_mobj;// allows mobj_type equal 0
const char * string;/* used to fetch table, ran first if set */ const char * string;/* used to fetch table, ran first if set */
int top;/* index of last argument passed to hook */ int top;/* index of last argument passed to hook */
int id;/* id to fetch ref */ int id;/* id to fetch ref */
@@ -363,8 +364,10 @@ FUNCINLINE static ATTRINLINE boolean prepare_hook
int default_status, int default_status,
int hook_type int hook_type
){ ){
hook->force_mobj = false;
return init_hook_type(hook, default_status, return init_hook_type(hook, default_status,
hook_type, NUMMOBJTYPES, NULL, hook_type, 0, NULL,
hookIds[hook_type].numHooks); hookIds[hook_type].numHooks);
} }
@@ -378,6 +381,8 @@ FUNCINLINE static ATTRINLINE boolean prepare_mobj_hook
const mobjtype_t mobj_type = const mobjtype_t mobj_type =
primary_mobj ? primary_mobj->type : NUMMOBJTYPES; primary_mobj ? primary_mobj->type : NUMMOBJTYPES;
hook->force_mobj = true;
return init_hook_type(hook, default_status, return init_hook_type(hook, default_status,
hook_type, mobj_type, NULL, hook_type, mobj_type, NULL,
mobj_hook_available(hook_type, mobj_type)); mobj_hook_available(hook_type, mobj_type));
@@ -390,8 +395,10 @@ FUNCINLINE static ATTRINLINE boolean prepare_string_hook
int hook_type, int hook_type,
const char * string const char * string
){ ){
hook->force_mobj = false;
if (init_hook_type(hook, default_status, if (init_hook_type(hook, default_status,
hook_type, NUMMOBJTYPES, string, hook_type, 0, string,
stringHooks[hook_type].ref)) stringHooks[hook_type].ref))
{ {
lua_pushstring(gL, string); lua_pushstring(gL, string);
@@ -407,7 +414,7 @@ FUNCINLINE static ATTRINLINE boolean prepare_hud_hook
int hook_type int hook_type
){ ){
return init_hook_type(hook, 0, return init_hook_type(hook, 0,
hook_type, NUMMOBJTYPES, NULL, hook_type, 0, NULL,
hudHookIds[hook_type].numHooks); hudHookIds[hook_type].numHooks);
} }
@@ -547,11 +554,14 @@ static int call_hooks
{ {
calls += call_string_hooks(hook); calls += call_string_hooks(hook);
} }
else if (hook->mobj_type < NUMMOBJTYPES) else if (hook->force_mobj)
{ {
/* call generic mobj hooks first */ /* call generic mobj hooks first */
calls += call_mobj_type_hooks(hook, MT_NULL); calls += call_mobj_type_hooks(hook, MT_NULL);
calls += call_mobj_type_hooks(hook, hook->mobj_type);
if (hook->mobj_type < NUMMOBJTYPES)
calls += call_mobj_type_hooks(hook, hook->mobj_type);
ps_lua_mobjhooks.value.i += calls; ps_lua_mobjhooks.value.i += calls;
} }
else else
@@ -605,7 +615,7 @@ FUNCINLINE static ATTRINLINE void res_hud(Hook_State *hook)
int LUA_HookMobj(mobj_t *mobj, int hook_type) int LUA_HookMobj(mobj_t *mobj, int hook_type)
{ {
Hook_State hook = {}; Hook_State hook;
if (prepare_mobj_hook(&hook, false, hook_type, mobj)) if (prepare_mobj_hook(&hook, false, hook_type, mobj))
{ {
LUA_PushUserdata(gL, mobj, META_MOBJ); LUA_PushUserdata(gL, mobj, META_MOBJ);
@@ -616,7 +626,7 @@ int LUA_HookMobj(mobj_t *mobj, int hook_type)
int LUA_Hook2Mobj(mobj_t *t1, mobj_t *t2, int hook_type) int LUA_Hook2Mobj(mobj_t *t1, mobj_t *t2, int hook_type)
{ {
Hook_State hook = {}; Hook_State hook;
if (prepare_mobj_hook(&hook, 0, hook_type, t1)) if (prepare_mobj_hook(&hook, 0, hook_type, t1))
{ {
LUA_PushUserdata(gL, t1, META_MOBJ); LUA_PushUserdata(gL, t1, META_MOBJ);
@@ -628,14 +638,14 @@ int LUA_Hook2Mobj(mobj_t *t1, mobj_t *t2, int hook_type)
void LUA_HookVoid(int type) void LUA_HookVoid(int type)
{ {
Hook_State hook = {}; Hook_State hook;
if (prepare_hook(&hook, 0, type)) if (prepare_hook(&hook, 0, type))
call_hooks(&hook, 0, res_none); call_hooks(&hook, 0, res_none);
} }
void LUA_HookInt(INT32 number, int hook_type) void LUA_HookInt(INT32 number, int hook_type)
{ {
Hook_State hook = {}; Hook_State hook;
if (prepare_hook(&hook, 0, hook_type)) if (prepare_hook(&hook, 0, hook_type))
{ {
lua_pushinteger(gL, number); lua_pushinteger(gL, number);
@@ -645,7 +655,7 @@ void LUA_HookInt(INT32 number, int hook_type)
/*void LUA_HookBool(boolean value, int hook_type) /*void LUA_HookBool(boolean value, int hook_type)
{ {
Hook_State hook = {}; Hook_State hook;
if (prepare_hook(&hook, 0, hook_type)) if (prepare_hook(&hook, 0, hook_type))
{ {
//lua_pushboolean(gL, value); //lua_pushboolean(gL, value);
@@ -655,7 +665,7 @@ void LUA_HookInt(INT32 number, int hook_type)
int LUA_HookPlayer(player_t *player, int hook_type) int LUA_HookPlayer(player_t *player, int hook_type)
{ {
Hook_State hook = {}; Hook_State hook;
if (prepare_hook(&hook, false, hook_type)) if (prepare_hook(&hook, false, hook_type))
{ {
LUA_PushUserdata(gL, player, META_PLAYER); LUA_PushUserdata(gL, player, META_PLAYER);
@@ -666,7 +676,7 @@ int LUA_HookPlayer(player_t *player, int hook_type)
int LUA_HookTiccmd(player_t *player, ticcmd_t *cmd, int hook_type) int LUA_HookTiccmd(player_t *player, ticcmd_t *cmd, int hook_type)
{ {
Hook_State hook = {}; Hook_State hook;
if (prepare_hook(&hook, false, hook_type)) if (prepare_hook(&hook, false, hook_type))
{ {
LUA_PushUserdata(gL, player, META_PLAYER); LUA_PushUserdata(gL, player, META_PLAYER);
@@ -685,7 +695,7 @@ int LUA_HookTiccmd(player_t *player, ticcmd_t *cmd, int hook_type)
void LUA_HookHUD(int hook_type, huddrawlist_h list) void LUA_HookHUD(int hook_type, huddrawlist_h list)
{ {
Hook_State hook = {}; Hook_State hook;
if (prepare_hud_hook(&hook, hook_type)) if (prepare_hud_hook(&hook, hook_type))
{ {
LUA_SetHudHook(hook_type, list); LUA_SetHudHook(hook_type, list);
@@ -713,7 +723,7 @@ static void hook_think_frame(int type)
int hook_index = 0; int hook_index = 0;
precise_t time_taken = 0; precise_t time_taken = 0;
Hook_State hook = {}; Hook_State hook;
const hook_t * map = &hookIds[type]; const hook_t * map = &hookIds[type];
int k; int k;
@@ -773,7 +783,7 @@ void LUA_HookPostThinkFrame(void)
int LUA_HookTouchSpecial(mobj_t *special, mobj_t *toucher) int LUA_HookTouchSpecial(mobj_t *special, mobj_t *toucher)
{ {
Hook_State hook = {}; Hook_State hook;
if (prepare_mobj_hook(&hook, false, MOBJ_HOOK(TouchSpecial), special)) if (prepare_mobj_hook(&hook, false, MOBJ_HOOK(TouchSpecial), special))
{ {
LUA_PushUserdata(gL, special, META_MOBJ); LUA_PushUserdata(gL, special, META_MOBJ);
@@ -792,7 +802,7 @@ static int damage_hook
int hook_type, int hook_type,
Hook_Callback results_handler Hook_Callback results_handler
){ ){
Hook_State hook = {}; Hook_State hook;
if (prepare_mobj_hook(&hook, 0, hook_type, target)) if (prepare_mobj_hook(&hook, 0, hook_type, target))
{ {
LUA_PushUserdata(gL, target, META_MOBJ); LUA_PushUserdata(gL, target, META_MOBJ);
@@ -880,8 +890,8 @@ int LUA_HookBotAI(mobj_t *sonic, mobj_t *tails, ticcmd_t *cmd)
{ {
const char *skin = ((skin_t *)tails->skin)->name; const char *skin = ((skin_t *)tails->skin)->name;
Hook_State hook = {}; Hook_State hook;
BotAI_State botai = {}; BotAI_State botai;
if (prepare_string_hook(&hook, false, STRING_HOOK(BotAI), skin)) if (prepare_string_hook(&hook, false, STRING_HOOK(BotAI), skin))
{ {
@@ -901,7 +911,7 @@ int LUA_HookBotAI(mobj_t *sonic, mobj_t *tails, ticcmd_t *cmd)
void LUA_HookLinedefExecute(line_t *line, mobj_t *mo, sector_t *sector) void LUA_HookLinedefExecute(line_t *line, mobj_t *mo, sector_t *sector)
{ {
Hook_State hook = {}; Hook_State hook;
if (prepare_string_hook if (prepare_string_hook
(&hook, 0, STRING_HOOK(LinedefExecute), line->text)) (&hook, 0, STRING_HOOK(LinedefExecute), line->text))
{ {
@@ -914,7 +924,7 @@ void LUA_HookLinedefExecute(line_t *line, mobj_t *mo, sector_t *sector)
int LUA_HookPlayerMsg(int source, int target, int flags, char *msg, int mute) int LUA_HookPlayerMsg(int source, int target, int flags, char *msg, int mute)
{ {
Hook_State hook = {}; Hook_State hook;
if (prepare_hook(&hook, false, HOOK(PlayerMsg))) if (prepare_hook(&hook, false, HOOK(PlayerMsg)))
{ {
LUA_PushUserdata(gL, &players[source], META_PLAYER); // Source player LUA_PushUserdata(gL, &players[source], META_PLAYER); // Source player
@@ -943,7 +953,7 @@ int LUA_HookPlayerMsg(int source, int target, int flags, char *msg, int mute)
int LUA_HookHurtMsg(player_t *player, mobj_t *inflictor, mobj_t *source) int LUA_HookHurtMsg(player_t *player, mobj_t *inflictor, mobj_t *source)
{ {
Hook_State hook = {}; Hook_State hook;
if (prepare_mobj_hook(&hook, false, MOBJ_HOOK(HurtMsg), inflictor)) if (prepare_mobj_hook(&hook, false, MOBJ_HOOK(HurtMsg), inflictor))
{ {
LUA_PushUserdata(gL, player, META_PLAYER); LUA_PushUserdata(gL, player, META_PLAYER);
@@ -957,7 +967,7 @@ int LUA_HookHurtMsg(player_t *player, mobj_t *inflictor, mobj_t *source)
void LUA_HookNetArchive(lua_CFunction archFunc, savebuffer_t *save) void LUA_HookNetArchive(lua_CFunction archFunc, savebuffer_t *save)
{ {
const hook_t * map = &hookIds[HOOK(NetVars)]; const hook_t * map = &hookIds[HOOK(NetVars)];
Hook_State hook = {}; Hook_State hook;
/* this is a remarkable case where the stack isn't reset */ /* this is a remarkable case where the stack isn't reset */
if (map->numHooks > 0) if (map->numHooks > 0)
{ {
@@ -987,7 +997,7 @@ void LUA_HookNetArchive(lua_CFunction archFunc, savebuffer_t *save)
void LUA_HookPlayerQuit(player_t *plr, int reason) void LUA_HookPlayerQuit(player_t *plr, int reason)
{ {
Hook_State hook = {}; Hook_State hook;
if (prepare_hook(&hook, 0, HOOK(PlayerQuit))) if (prepare_hook(&hook, 0, HOOK(PlayerQuit)))
{ {
LUA_PushUserdata(gL, plr, META_PLAYER); // Player that quit LUA_PushUserdata(gL, plr, META_PLAYER); // Player that quit
@@ -1050,7 +1060,7 @@ int LUA_HookMusicChange(const char *oldname, struct MusicChange *param)
const int type = HOOK(MusicChange); const int type = HOOK(MusicChange);
const hook_t * map = &hookIds[type]; const hook_t * map = &hookIds[type];
Hook_State hook = {}; Hook_State hook;
int k; int k;
@@ -1086,7 +1096,7 @@ int LUA_HookMusicChange(const char *oldname, struct MusicChange *param)
int LUA_HookMusicCredit(musicdef_t *musicdef) int LUA_HookMusicCredit(musicdef_t *musicdef)
{ {
Hook_State hook = {}; Hook_State hook;
if (prepare_hook(&hook, 0, HOOK(MusicCredit))) if (prepare_hook(&hook, 0, HOOK(MusicCredit)))
{ {
LUA_PushUserdata(gL, musicdef, META_MUSICDEF); LUA_PushUserdata(gL, musicdef, META_MUSICDEF);
@@ -1104,7 +1114,7 @@ static int kartdamage_hook
int hook_type, int hook_type,
Hook_Callback results_handler Hook_Callback results_handler
){ ){
Hook_State hook = {}; Hook_State hook;
if (prepare_hook(&hook, 0, hook_type)) if (prepare_hook(&hook, 0, hook_type))
{ {
LUA_PushUserdata(gL, player, META_PLAYER); LUA_PushUserdata(gL, player, META_PLAYER);
@@ -1153,7 +1163,7 @@ boolean LUA_HookPlayerExplode(player_t *player, mobj_t *inflictor, mobj_t *sourc
void LUA_HookSetupVote(INT16 result[], INT16 maxresults, UINT8 gt, UINT8 secondgt) void LUA_HookSetupVote(INT16 result[], INT16 maxresults, UINT8 gt, UINT8 secondgt)
{ {
Hook_State hook = {}; Hook_State hook;
if (prepare_hook(&hook, 0, HOOK(SetupVote))) if (prepare_hook(&hook, 0, HOOK(SetupVote)))
{ {
// { 0, 0, 0, 0, } // { 0, 0, 0, 0, }
+1 -1
View File
@@ -1297,7 +1297,7 @@ static int lib_hudsetvotebackground(lua_State *L)
if (strlen(prefix) != 4) if (strlen(prefix) != 4)
{ {
return luaL_argerror(L, 1, "prefix should be 4 characters wide"); return luaL_argerror(L, 1, "prefix should 4 characters wide");
} }
strncpy(VoteScreen.luaPrefix, prefix, 4); strncpy(VoteScreen.luaPrefix, prefix, 4);
+41 -31
View File
@@ -136,9 +136,18 @@ void LUA_HUD_DestroyDrawList(huddrawlist_h list)
{ {
if (list == NULL) return; if (list == NULL) return;
Z_Free(list->items); if (list->items)
Z_Free(list->olditems); {
Z_Free(list->strbuf); Z_Free(list->items);
}
if (list->olditems)
{
Z_Free(list->olditems);
}
if (list->strbuf)
{
Z_Free(list->strbuf);
}
Z_Free(list); Z_Free(list);
} }
@@ -650,34 +659,34 @@ void LUA_HUD_DrawList(huddrawlist_h list)
case DI_DrawString: case DI_DrawString:
switch(item->align) switch(item->align)
{ {
// hu_font // hu_font
case align_left: case align_left:
V_DrawString(LERPS(x), LERPS(y), item->flags, itemstr); V_DrawString(LERPS(x), LERPS(y), item->flags, itemstr);
break; break;
case align_center: case align_center:
V_DrawCenteredString(LERPS(x), LERPS(y), item->flags, itemstr); V_DrawCenteredString(LERPS(x), LERPS(y), item->flags, itemstr);
break; break;
case align_right: case align_right:
V_DrawRightAlignedString(LERPS(x), LERPS(y), item->flags, itemstr); V_DrawRightAlignedString(LERPS(x), LERPS(y), item->flags, itemstr);
break; break;
case align_fixed: case align_fixed:
V_DrawStringAtFixed(LERPS(x), LERPS(y), item->flags, itemstr); V_DrawStringAtFixed(LERPS(x), LERPS(y), item->flags, itemstr);
break; break;
// hu_font, 0.5x scale // hu_font, 0.5x scale
case align_small: case align_small:
V_DrawSmallString(LERPS(x), LERPS(y), item->flags, itemstr); V_DrawSmallString(LERPS(x), LERPS(y), item->flags, itemstr);
break; break;
case align_smallright: case align_smallright:
V_DrawRightAlignedSmallString(LERPS(x), LERPS(y), item->flags, itemstr); V_DrawRightAlignedSmallString(LERPS(x), LERPS(y), item->flags, itemstr);
break; break;
// tny_font // tny_font
case align_thin: case align_thin:
V_DrawThinString(LERPS(x), LERPS(y), item->flags, itemstr); V_DrawThinString(LERPS(x), LERPS(y), item->flags, itemstr);
break; break;
case align_thinright: case align_thinright:
V_DrawRightAlignedThinString(LERPS(x), LERPS(y), item->flags, itemstr); V_DrawRightAlignedThinString(LERPS(x), LERPS(y), item->flags, itemstr);
break; break;
} }
break; break;
case DI_DrawKartString: case DI_DrawKartString:
V_DrawKartString(LERPS(x), LERPS(y), item->flags, itemstr); V_DrawKartString(LERPS(x), LERPS(y), item->flags, itemstr);
@@ -690,6 +699,7 @@ void LUA_HUD_DrawList(huddrawlist_h list)
break; break;
default: default:
I_Error("can't draw draw list item: invalid draw list item type"); I_Error("can't draw draw list item: invalid draw list item type");
continue;
} }
} }
} }
+1 -1
View File
@@ -25,7 +25,7 @@
#include "lua_hook.h" // cmd errors #include "lua_hook.h" // cmd errors
boolean LUA_CallAction(enum actionnum actionnum, mobj_t *actor); boolean LUA_CallAction(enum actionnum actionnum, mobj_t *actor);
state_t *astate = NULL; state_t *astate;
boolean actionsoverridden[NUMACTIONS] = {false}; boolean actionsoverridden[NUMACTIONS] = {false};
+10 -5
View File
@@ -1506,6 +1506,7 @@ enum mapheaderinfo_e
mapheaderinfo_saveoverride, mapheaderinfo_saveoverride,
mapheaderinfo_levelflags, mapheaderinfo_levelflags,
mapheaderinfo_menuflags, mapheaderinfo_menuflags,
//mapheaderinfo_automap,
mapheaderinfo_mobj_scale, mapheaderinfo_mobj_scale,
}; };
@@ -1541,6 +1542,7 @@ static const char *const mapheaderinfo_opt[] = {
"saveoverride", "saveoverride",
"levelflags", "levelflags",
"menuflags", "menuflags",
//"automap",
"mobj_scale", "mobj_scale",
NULL, NULL,
}; };
@@ -1582,11 +1584,10 @@ static int mapheaderinfo_get(lua_State *L)
lua_pushinteger(L, header->muspos); lua_pushinteger(L, header->muspos);
break; break;
case mapheaderinfo_musinterfadeout: case mapheaderinfo_musinterfadeout:
lua_pushinteger(L, 0); // unused lua_pushinteger(L, header->musinterfadeout);
break; break;
case mapheaderinfo_musintername: case mapheaderinfo_musintername:
// uhh psure its fine to just push nil instead of empty string? lua_pushstring(L, header->musintername);
lua_pushstring(L, NULL);
break; break;
case mapheaderinfo_forcecharacter: case mapheaderinfo_forcecharacter:
lua_pushstring(L, header->forcecharacter); lua_pushstring(L, header->forcecharacter);
@@ -1640,10 +1641,10 @@ static int mapheaderinfo_get(lua_State *L)
lua_pushinteger(L, header->levelselect); lua_pushinteger(L, header->levelselect);
break; break;
case mapheaderinfo_bonustype: case mapheaderinfo_bonustype:
lua_pushinteger(L, 0); // unused lua_pushinteger(L, header->bonustype);
break; break;
case mapheaderinfo_saveoverride: case mapheaderinfo_saveoverride:
lua_pushinteger(L, SAVE_DEFAULT); // unused lua_pushinteger(L, header->saveoverride);
break; break;
case mapheaderinfo_levelflags: case mapheaderinfo_levelflags:
lua_pushinteger(L, header->levelflags); lua_pushinteger(L, header->levelflags);
@@ -1651,9 +1652,13 @@ static int mapheaderinfo_get(lua_State *L)
case mapheaderinfo_menuflags: case mapheaderinfo_menuflags:
lua_pushinteger(L, header->menuflags); lua_pushinteger(L, header->menuflags);
break; break;
/*case mapheaderinfo_automap:
lua_pushstring(L, header->selectheading);
break;*/
case mapheaderinfo_mobj_scale: case mapheaderinfo_mobj_scale:
lua_pushfixed(L, header->mobj_scale); lua_pushfixed(L, header->mobj_scale);
break; break;
// TODO add support for reading numGradedMares and grades
default: default:
{ {
// Read custom vars now // Read custom vars now
Loaded 100 of 174 files, more files were not shown because too many files have changed in this diff. Show more