Compare commits

..
7 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
125 changed files with 1949 additions and 2825 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()
+40 -24
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 "")
endfunction() 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()
+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.c
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()
+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
+1 -4
View File
@@ -20,10 +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 -Wno-trigraphs -Wnull-dereference WFLAGS:=-Wall -Wno-trigraphs
ifdef GCC152
WFLAGS+=-Wzero-as-null-pointer-constant
endif
ifndef GCC295 ifndef GCC295
#WFLAGS+=-Wno-packed #WFLAGS+=-Wno-packed
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)
+17 -41
View File
@@ -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, const TValue *t, const char *k) {
const 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);
} }
@@ -640,26 +630,6 @@ LUA_API void lua_getfenv (lua_State *L, int idx) {
** set functions (stack -> Lua) ** set functions (stack -> Lua)
*/ */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-qual"
static void auxsetstr (lua_State *L, const TValue *t, const char *k) {
TValue key;
const 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;
@@ -672,12 +642,18 @@ LUA_API void lua_settable (lua_State *L, int idx) {
lua_unlock(L); lua_unlock(L);
} }
#pragma GCC diagnostic pop
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);
+1 -1
View File
@@ -61,7 +61,7 @@ TValue *luaT_gettm (Table *events, TMS event, TString *ename) {
} }
TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, TMS event) { TValue *luaT_gettmbyobj (lua_State *L, TValue *o, TMS event) {
Table *mt; Table *mt;
switch (ttype(o)) { switch (ttype(o)) {
case LUA_TTABLE: case LUA_TTABLE:
+1 -1
View File
@@ -55,7 +55,7 @@ LUAI_DATA const char *const luaT_typenames[];
LUAI_FUNC TValue *luaT_gettm (Table *events, TMS event, TString *ename); LUAI_FUNC TValue *luaT_gettm (Table *events, TMS event, TString *ename);
LUAI_FUNC TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, TMS event); LUAI_FUNC TValue *luaT_gettmbyobj (lua_State *L, TValue *o, TMS event);
LUAI_FUNC void luaT_init (lua_State *L); LUAI_FUNC void luaT_init (lua_State *L);
#endif #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
+54 -145
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,94 +105,61 @@ 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, const TValue *t, TValue *key, StkId val,
const TValue *slot) {
int loop; /* counter to avoid infinite loops */
const 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");
} }
/*
** Finish a table assignment 't[key] = val'. void luaV_settable (lua_State *L, TValue *t, TValue *key, StkId val) {
** If 'slot' is NULL, 't' is not a table. Otherwise, 'slot' points int loop;
** 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.)
*/
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-qual"
void luaV_finishset (lua_State *L, const TValue *t, TValue *key,
StkId val, const TValue *slot) {
int loop; /* counter to avoid infinite loops */
for (loop = 0; loop < MAXTAGLOOP; loop++) { for (loop = 0; loop < MAXTAGLOOP; loop++) {
const 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");
} }
#pragma GCC diagnostic pop
static int call_binTM (lua_State *L, const TValue *p1, const TValue *p2, static int call_binTM (lua_State *L, TValue *p1, TValue *p2,
StkId res, TMS event) { StkId res, TMS event) {
const TValue *tm = luaT_gettmbyobj(L, p1, event); /* try first operand */ const TValue *tm = luaT_gettmbyobj(L, p1, event); /* try first operand */
if (ttisnil(tm)) if (ttisnil(tm))
@@ -217,7 +184,7 @@ static const TValue *get_compTM (lua_State *L, Table *mt1, Table *mt2,
} }
static int call_orderTM (lua_State *L, const TValue *p1, const TValue *p2, static int call_orderTM (lua_State *L, TValue *p1, TValue *p2,
TMS event) { TMS event) {
const TValue *tm1 = luaT_gettmbyobj(L, p1, event); const TValue *tm1 = luaT_gettmbyobj(L, p1, event);
const TValue *tm2; const TValue *tm2;
@@ -399,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)) { \
@@ -411,24 +377,6 @@ static void Arith (lua_State *L, StkId ra, TValue *rb,
} }
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-qual"
/*
** copy of 'luaV_gettable', but protecting call to potential metamethod
** (which can reallocate the stack)
*/
#define gettableProtected(L,t,k,v) { const 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) { const 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;
@@ -438,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);
@@ -453,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--);
@@ -482,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);
@@ -497,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)));
@@ -512,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)));
@@ -534,16 +470,9 @@ void luaV_execute (lua_State *L, int nexeccalls) {
continue; continue;
} }
case OP_SELF: { case OP_SELF: {
StkId ra = RA(i);
const TValue *slot;
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: {
@@ -559,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)) {
@@ -575,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)) {
@@ -595,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);
@@ -627,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);
@@ -639,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: {
@@ -703,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);
@@ -720,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 */
@@ -742,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;
@@ -775,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);
@@ -791,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);
@@ -804,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;
@@ -821,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);
@@ -838,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;
@@ -861,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;
@@ -887,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;
@@ -911,5 +822,3 @@ void luaV_execute (lua_State *L, int nexeccalls) {
} }
} }
} }
#pragma GCC diagnostic pop
+4 -51
View File
@@ -22,61 +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) { const 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) { const 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, const TValue *t, TValue *key, LUAI_FUNC void luaV_gettable (lua_State *L, TValue *t, TValue *key,
StkId val, const TValue *tm); StkId val);
LUAI_FUNC void luaV_finishset (lua_State *L, const TValue *t, TValue *key, LUAI_FUNC void luaV_settable (lua_State *L, TValue *t, TValue *key,
StkId val, const 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);
+1 -1
View File
@@ -1793,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));
+37 -45
View File
@@ -332,7 +332,7 @@ void RegisterNetXCmd(netxcmd_t id, void (*cmd_f)(const UINT8 **p, INT32 playernu
#ifdef PARANOIA #ifdef PARANOIA
if (id >= MAXNETXCMD) if (id >= MAXNETXCMD)
I_Error("Command id %d too big", id); I_Error("Command id %d too big", id);
if (listnetxcmd[id] != NULL) if (listnetxcmd[id] != 0)
I_Error("Command id %d already used", id); I_Error("Command id %d already used", id);
#endif #endif
listnetxcmd[id] = cmd_f; listnetxcmd[id] = cmd_f;
@@ -365,7 +365,7 @@ void SendNetXCmdForPlayer(UINT8 playerid, netxcmd_t id, const void *param, size_
CONS_Alert(CONS_NOTICE, M_GetText("NetXCmd buffer full, delaying netcmd %d... (size: %d, needed: %s)\n"), id, localtextcmd[playerid][0], sizeu1(nparam)); CONS_Alert(CONS_NOTICE, M_GetText("NetXCmd buffer full, delaying netcmd %d... (size: %d, needed: %s)\n"), id, localtextcmd[playerid][0], sizeu1(nparam));
if (buf == NULL) if (buf == NULL)
{ {
textcmdbuf[playerid] = (textcmdbuf_t*)Z_Malloc(sizeof(textcmdbuf_t), PU_STATIC, NULL); textcmdbuf[playerid] = Z_Malloc(sizeof(textcmdbuf_t), PU_STATIC, NULL);
textcmdbuf[playerid]->cmd[0] = 0; textcmdbuf[playerid]->cmd[0] = 0;
textcmdbuf[playerid]->next = NULL; textcmdbuf[playerid]->next = NULL;
WriteNetXCmd(textcmdbuf[playerid]->cmd, id, param, nparam); WriteNetXCmd(textcmdbuf[playerid]->cmd, id, param, nparam);
@@ -377,7 +377,7 @@ void SendNetXCmdForPlayer(UINT8 playerid, netxcmd_t id, const void *param, size_
if (buf->cmd[0]+2+nparam > MAXTEXTCMD) if (buf->cmd[0]+2+nparam > MAXTEXTCMD)
{ {
buf->next = (textcmdbuf_t*)Z_Malloc(sizeof(textcmdbuf_t), PU_STATIC, NULL); buf->next = Z_Malloc(sizeof(textcmdbuf_t), PU_STATIC, NULL);
buf->next->cmd[0] = 0; buf->next->cmd[0] = 0;
buf->next->next = NULL; buf->next->next = NULL;
WriteNetXCmd(buf->next->cmd, id, param, nparam); WriteNetXCmd(buf->next->cmd, id, param, nparam);
@@ -454,13 +454,13 @@ static UINT8* D_GetTextcmd(tic_t tic, INT32 playernum)
// If we don't have an entry for the tic, make it. // If we don't have an entry for the tic, make it.
if (!textcmdtic) if (!textcmdtic)
{ {
textcmdtic = *tctprev = (textcmdtic_t*)Z_Calloc(sizeof (textcmdtic_t), PU_STATIC, NULL); textcmdtic = *tctprev = Z_Calloc(sizeof (textcmdtic_t), PU_STATIC, NULL);
textcmdtic->tic = tic; textcmdtic->tic = tic;
} }
// If we don't have an entry for the player, make it. // If we don't have an entry for the player, make it.
if (!textcmdtic->playercmds[playernum]) if (!textcmdtic->playercmds[playernum])
textcmdtic->playercmds[playernum] = (UINT8*)Z_Calloc(MAXTEXTCMD, PU_STATIC, NULL); textcmdtic->playercmds[playernum] = Z_Calloc(MAXTEXTCMD, PU_STATIC, NULL);
return textcmdtic->playercmds[playernum]; return textcmdtic->playercmds[playernum];
} }
@@ -1141,7 +1141,7 @@ typedef enum
static void GetPackets(void); static void GetPackets(void);
static cl_mode_t cl_mode = CL_SEARCHING; static cl_mode_t cl_mode = CL_SEARCHING;
static UINT16 cl_lastcheckedfilecount = 0; // used for full file list static UINT16 cl_lastcheckedfilecount = 0; // used for full file list
// Player name send/load // Player name send/load
@@ -1182,7 +1182,7 @@ static void CV_LoadPlayerNames(UINT8 **p)
// //
// Keep the local client informed of our status. // Keep the local client informed of our status.
// //
static void CL_DrawConnectionStatus(void) static inline void CL_DrawConnectionStatus(void)
{ {
INT32 ccstime = I_GetTime(); INT32 ccstime = I_GetTime();
@@ -1217,26 +1217,24 @@ static void CL_DrawConnectionStatus(void)
case CL_DOWNLOADSAVEGAME: case CL_DOWNLOADSAVEGAME:
if (filedownload.current != -1) if (filedownload.current != -1)
{ {
INT32 dldlength = 0; UINT32 currentsize = fileneeded[filedownload.current].currentsize;
fileneeded_t *file = &fileneeded[filedownload.current]; UINT32 totalsize = fileneeded[filedownload.current].totalsize;
UINT32 currentsize = file->currentsize; INT32 dldlength;
UINT32 totalsize = file->totalsize;
cltext = M_GetText("Downloading game state..."); cltext = M_GetText("Downloading game state...");
Net_GetNetStat(); Net_GetNetStat();
if (totalsize != 0) dldlength = (INT32)((currentsize/(double)totalsize) * 256);
dldlength = (INT32)((currentsize/(double)totalsize) * 256);
if (dldlength > 256) if (dldlength > 256)
dldlength = 256; dldlength = 256;
V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, 256, 8, 111); V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, 256, 8, 111);
V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, dldlength, 8, 96); V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, dldlength, 8, 96);
V_DrawString(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE, V_DrawString(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE,
va(" %4uK/%4uK", currentsize>>10, totalsize>>10)); va(" %4uK/%4uK",currentsize>>10,totalsize>>10));
V_DrawRightAlignedString(BASEVIDWIDTH/2+128, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE, V_DrawRightAlignedString(BASEVIDWIDTH/2+128, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE,
va("%3.1fK/s ", ((double)getbps)/1024.0)); va("%3.1fK/s ", ((double)getbps)/1024));
} }
else else
cltext = M_GetText("Waiting to download game state..."); cltext = M_GetText("Waiting to download game state...");
@@ -1272,30 +1270,29 @@ static void CL_DrawConnectionStatus(void)
{ {
if (cl_mode == CL_CHECKFILES) if (cl_mode == CL_CHECKFILES)
{ {
INT32 totalfileslength = 0; INT32 totalfileslength;
INT32 checkednum = 0; INT32 checkednum = 0;
INT32 i; INT32 i;
V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-24-24, V_YELLOWMAP|MENUCAPS, "Press ESC to abort"); V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-24-24, V_YELLOWMAP|MENUCAPS, "Press ESC to abort");
// ima just count files here //ima just count files here
for (i = 0; i < fileneedednum; i++) for (i = 0; i < fileneedednum; i++)
if (fileneeded[i].status != FS_NOTCHECKED) if (fileneeded[i].status != FS_NOTCHECKED)
checkednum++; checkednum++;
// Loading progress // Loading progress
V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-24-32, V_YELLOWMAP|MENUCAPS, "Checking server addons..."); V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-24-32, V_YELLOWMAP|MENUCAPS, "Checking server addons...");
if (fileneedednum != 0) totalfileslength = (INT32)((checkednum/(double)(fileneedednum)) * 256);
totalfileslength = (INT32)((checkednum/(double)fileneedednum) * 256);
M_DrawTextBox(BASEVIDWIDTH/2-128-8, BASEVIDHEIGHT-24-8, 32, 1); M_DrawTextBox(BASEVIDWIDTH/2-128-8, BASEVIDHEIGHT-24-8, 32, 1);
V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, 256, 8, 175); V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, 256, 8, 175);
V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, totalfileslength, 8, 160); V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, totalfileslength, 8, 160);
V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE|MENUCAPS, V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE|MENUCAPS,
va(" %2u/%2u Files", checkednum, fileneedednum)); va(" %2u/%2u Files",checkednum,fileneedednum));
} }
else if (cl_mode == CL_LOADFILES) else if (cl_mode == CL_LOADFILES)
{ {
INT32 totalfileslength = 0; INT32 totalfileslength;
INT32 loadcompletednum = 0; INT32 loadcompletednum = 0;
INT32 i; INT32 i;
@@ -1308,13 +1305,12 @@ static void CL_DrawConnectionStatus(void)
// Loading progress // Loading progress
V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-24-32, V_YELLOWMAP|MENUCAPS, "Loading server addons..."); V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-24-32, V_YELLOWMAP|MENUCAPS, "Loading server addons...");
if (fileneedednum != 0) totalfileslength = (INT32)((loadcompletednum/(double)(fileneedednum)) * 256);
totalfileslength = (INT32)((loadcompletednum/(double)fileneedednum) * 256);
M_DrawTextBox(BASEVIDWIDTH/2-128-8, BASEVIDHEIGHT-24-8, 32, 1); M_DrawTextBox(BASEVIDWIDTH/2-128-8, BASEVIDHEIGHT-24-8, 32, 1);
V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, 256, 8, 175); V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, 256, 8, 175);
V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, totalfileslength, 8, 160); V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, totalfileslength, 8, 160);
V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE|MENUCAPS, V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE|MENUCAPS,
va(" %2u/%2u Files", loadcompletednum, fileneedednum)); va(" %2u/%2u Files",loadcompletednum,fileneedednum));
} }
else if (cl_mode == CL_VIEWSERVER) else if (cl_mode == CL_VIEWSERVER)
{ {
@@ -1442,22 +1438,19 @@ static void CL_DrawConnectionStatus(void)
} }
else if (filedownload.current != -1) else if (filedownload.current != -1)
{ {
INT32 dldlength = 0; INT32 dldlength;
INT32 totalfileslength = 0; INT32 totalfileslength;
UINT32 totaldldsize = 0; UINT32 totaldldsize;
static char tempname[28]; static char tempname[28];
fileneeded_t *file = &fileneeded[filedownload.current]; fileneeded_t *file = &fileneeded[filedownload.current];
char *filename = file->filename; char *filename = file->filename;
UINT32 currentsize = file->currentsize;
UINT32 totalsize = file->totalsize;
// Draw the bottom box. // Draw the bottom box.
M_DrawTextBox(BASEVIDWIDTH/2-128-8, BASEVIDHEIGHT-58-8, 32, 1); M_DrawTextBox(BASEVIDWIDTH/2-128-8, BASEVIDHEIGHT-58-8, 32, 1);
V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-58-14, V_YELLOWMAP|MENUCAPS, "Press ESC to abort"); V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-58-14, V_YELLOWMAP|MENUCAPS, "Press ESC to abort");
Net_GetNetStat(); Net_GetNetStat();
if (totalsize != 0) dldlength = (INT32)((file->currentsize/(double)file->totalsize) * 256);
dldlength = (INT32)((currentsize/(double)totalsize) * 256);
if (dldlength > 256) if (dldlength > 256)
dldlength = 256; dldlength = 256;
V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-58, 256, 8, 175); V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-58, 256, 8, 175);
@@ -1490,30 +1483,29 @@ static void CL_DrawConnectionStatus(void)
V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-58-22, V_YELLOWMAP|MENUCAPS, V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-58-22, V_YELLOWMAP|MENUCAPS,
va(M_GetText("\"%s\""), tempname)); va(M_GetText("\"%s\""), tempname));
V_DrawString(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-58, V_20TRANS|V_MONOSPACE|MENUCAPS, V_DrawString(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-58, V_20TRANS|V_MONOSPACE|MENUCAPS,
va(" %4uK/%4uK", currentsize>>10, totalsize>>10)); va(" %4uK/%4uK",file->currentsize>>10,file->totalsize>>10));
V_DrawRightAlignedString(BASEVIDWIDTH/2+128, BASEVIDHEIGHT-58, V_20TRANS|V_MONOSPACE|MENUCAPS, V_DrawRightAlignedString(BASEVIDWIDTH/2+128, BASEVIDHEIGHT-58, V_20TRANS|V_MONOSPACE|MENUCAPS,
va("%3.1fK/s ", ((double)getbps)/1024.0)); va("%3.1fK/s ", ((double)getbps)/1024));
// Download progress // Download progress
if (currentsize != totalsize) if (file->currentsize != file->totalsize)
totaldldsize = filedownload.completedsize+currentsize; // Add in single file progress download if applicable totaldldsize = filedownload.completedsize+file->currentsize; //Add in single file progress download if applicable
else else
totaldldsize = filedownload.completedsize; totaldldsize = filedownload.completedsize;
V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-24-14, V_YELLOWMAP|MENUCAPS, "Overall Download Progress"); V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT-24-14, V_YELLOWMAP|MENUCAPS, "Overall Download Progress");
if (filedownload.totalsize != 0) totalfileslength = (INT32)((totaldldsize/(double)filedownload.totalsize) * 256);
totalfileslength = (INT32)((totaldldsize/(double)filedownload.totalsize) * 256);
M_DrawTextBox(BASEVIDWIDTH/2-128-8, BASEVIDHEIGHT-24-8, 32, 1); M_DrawTextBox(BASEVIDWIDTH/2-128-8, BASEVIDHEIGHT-24-8, 32, 1);
V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, 256, 8, 175); V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, 256, 8, 175);
V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, totalfileslength, 8, 160); V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, totalfileslength, 8, 160);
if (filedownload.totalsize>>20 >= 10) // display in MB if over 10MB if (filedownload.totalsize>>20 >= 10) //display in MB if over 10MB
V_DrawString(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE|MENUCAPS, V_DrawString(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE|MENUCAPS,
va(" %4uM/%4uM", totaldldsize>>20, filedownload.totalsize>>20)); va(" %4uM/%4uM",totaldldsize>>20,filedownload.totalsize>>20));
else else
V_DrawString(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE|MENUCAPS, V_DrawString(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE|MENUCAPS,
va(" %4uK/%4uK", totaldldsize>>10, filedownload.totalsize>>10)); va(" %4uK/%4uK",totaldldsize>>10,filedownload.totalsize>>10));
V_DrawRightAlignedString(BASEVIDWIDTH/2+128, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE|MENUCAPS, V_DrawRightAlignedString(BASEVIDWIDTH/2+128, BASEVIDHEIGHT-24, V_20TRANS|V_MONOSPACE|MENUCAPS,
va("%2u/%2u Files ", filedownload.completednum, filedownload.totalnum)); va("%2u/%2u Files ", filedownload.completednum, filedownload.totalnum));
@@ -1963,7 +1955,7 @@ static boolean SV_ResendingSavegameToAnyone(void)
static void SV_SendSaveGame(INT32 node, boolean resending) static void SV_SendSaveGame(INT32 node, boolean resending)
{ {
size_t length, compressedlen; size_t length, compressedlen;
savebuffer_t save = {}; savebuffer_t save = {0};
UINT8 *compressedsave; UINT8 *compressedsave;
UINT8 *buffertosend; UINT8 *buffertosend;
@@ -2033,7 +2025,7 @@ static consvar_t cv_dumpconsistency = {"dumpconsistency", "Off", CV_NETVAR, CV_O
static void SV_SavedGame(void) static void SV_SavedGame(void)
{ {
size_t length; size_t length;
savebuffer_t save = {}; savebuffer_t save = {0};
char tmpsave[264]; char tmpsave[264];
if (!cv_dumpconsistency.value) if (!cv_dumpconsistency.value)
@@ -2073,7 +2065,7 @@ static void SV_SavedGame(void)
static void CL_LoadReceivedSavegame(boolean reloading) static void CL_LoadReceivedSavegame(boolean reloading)
{ {
savebuffer_t save = {}; savebuffer_t save = {0};
size_t length, decompressedlen; size_t length, decompressedlen;
char tmpsave[264]; char tmpsave[264];
@@ -7237,7 +7229,7 @@ void CL_ClearRewinds(void)
rewind_t *CL_SaveRewindPoint(size_t demopos) rewind_t *CL_SaveRewindPoint(size_t demopos)
{ {
savebuffer_t save = {}; savebuffer_t save = {0};
rewind_t *rewind; rewind_t *rewind;
if (rewindhead && rewindhead->leveltime + REWIND_POINT_INTERVAL > leveltime) if (rewindhead && rewindhead->leveltime + REWIND_POINT_INTERVAL > leveltime)
@@ -7260,7 +7252,7 @@ rewind_t *CL_SaveRewindPoint(size_t demopos)
rewind_t *CL_RewindToTime(tic_t time) rewind_t *CL_RewindToTime(tic_t time)
{ {
savebuffer_t save = {}; savebuffer_t save = {0};
rewind_t *rewind; rewind_t *rewind;
while (rewindhead && rewindhead->leveltime > time) while (rewindhead && rewindhead->leveltime > time)
+42 -33
View File
@@ -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
}
} }
} }
@@ -657,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;
@@ -776,6 +783,11 @@ void D_SRB2Loop(void)
doDisplay = true; doDisplay = true;
} }
if (!dedicated)
{
G_DeviceLEDTick();
}
} }
if (interp) if (interp)
@@ -817,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
@@ -902,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();
@@ -968,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();
@@ -1211,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
@@ -1638,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"));
@@ -1884,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
+2 -2
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)
+8 -13
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}};
@@ -1009,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);
@@ -2658,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;
@@ -2794,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;
+3 -8
View File
@@ -131,8 +131,6 @@ 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
/** Fills a serverinfo packet with information about wad files loaded. /** Fills a serverinfo packet with information about wad files loaded.
@@ -1307,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);
@@ -1316,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");
@@ -1445,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);
@@ -1487,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)
@@ -1526,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
View File
@@ -119,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)
+7 -3
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;
} }
+9 -32
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>
+4 -2
View File
@@ -1172,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)
@@ -1316,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;
} }
+10 -11
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
@@ -271,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));
} }
@@ -317,7 +314,8 @@ void closefilemenu(boolean validsize)
coredirmenu = NULL; coredirmenu = NULL;
} }
Z_Free(refreshdirname); if (refreshdirname)
Z_Free(refreshdirname);
refreshdirname = NULL; refreshdirname = NULL;
} }
@@ -345,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;
@@ -387,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;
} }
@@ -503,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;
} }
+2 -2
View File
@@ -76,7 +76,7 @@ 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;
@@ -2605,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();
+19 -16
View File
@@ -132,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;
@@ -144,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] = {};
@@ -228,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
@@ -456,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}};
@@ -523,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;
}
} }
} }
@@ -3498,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;
@@ -3631,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];
@@ -3802,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));
@@ -3888,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);
@@ -4158,7 +4161,7 @@ static void measurekeywords(mapsearchfreq_t *fr,
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) ))
{ {
@@ -4239,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;
@@ -4260,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 */
-1
View File
@@ -130,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;
+7 -8
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,7 +930,7 @@ 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;
@@ -948,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);
@@ -978,8 +973,13 @@ void G_DeviceLEDTick(void)
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;
@@ -994,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);
} }
@@ -1012,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;
} }
-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
@@ -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)
{ {
+5 -2
View File
@@ -619,6 +619,7 @@ static void HWR_PrecacheLevelFlats(void)
// lookup for flats that may´ve been already loaded // lookup for flats that may´ve been already loaded
// too lazy to make a hashtable or smth so unordered set will do :carbuncle: // too lazy to make a hashtable or smth so unordered set will do :carbuncle:
std::unordered_set<UINT32> flatpresent; std::unordered_set<UINT32> flatpresent;
lumpnum_t lump;
size_t i, j; size_t i, j;
INT32 k; INT32 k;
@@ -648,8 +649,9 @@ 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;
load_flat(levelflat->lumpnum, R_NoEncore(sec, ceiling)); load_flat(lump, R_NoEncore(sec, ceiling));
if (levelflat->speed) // is it an animated flat ? if (levelflat->speed) // is it an animated flat ?
{ {
@@ -670,8 +672,9 @@ 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;
load_flat(levelflat->lumpnum, false); load_flat(lump, false);
if (levelflat->speed) // is it an animated flat ? if (levelflat->speed) // is it an animated flat ?
{ {
+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;
} }
-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
+35 -45
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
@@ -588,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
@@ -684,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)
@@ -1378,7 +1380,8 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
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;
@@ -1782,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;
@@ -1872,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
@@ -2944,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;
@@ -2990,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)
@@ -3050,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);
} }
@@ -3065,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);
} }
@@ -3782,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 = FixedMul(FRACUNIT/2, Surf.PolyColor.s.alpha);
if (cv_playerfade.value)
Surf.PolyColor.s.alpha = FixedMul(R_DoPlayerFade(sprmo), Surf.PolyColor.s.alpha);
}
if (HWR_UseShader()) if (HWR_UseShader())
{ {
@@ -4079,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 = FixedMul(FRACUNIT/2, Surf.PolyColor.s.alpha);
if (cv_playerfade.value)
Surf.PolyColor.s.alpha = FixedMul(R_DoPlayerFade(sprmo), Surf.PolyColor.s.alpha);
}
if (HWR_UseShader()) if (HWR_UseShader())
{ {
@@ -5443,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;
} }
@@ -5548,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();
@@ -5568,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)
{ {
@@ -5594,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)
{ {
@@ -6110,7 +6100,7 @@ static void HWR_DoPostProcessor(void)
const camera_t *thiscam = &camera[0]; const camera_t *thiscam = &camera[0];
// Not supported in splitscreen - someone want to add support? // Not supported in splitscreen - someone want to add support?
const boolean screenwave = (!splitscreen && !cv_reducevfx.value && (thiscam->postimg & POSTIMG_WATER || thiscam->postimg & POSTIMG_HEAT)); 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 ((lastdraw || screenwave) && gamestate != GS_INTERMISSION) if ((lastdraw || screenwave) && gamestate != GS_INTERMISSION)
+19 -131
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
@@ -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
@@ -1468,116 +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);
memset(&Surf, 0x00, sizeof(FSurfaceInfo));
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
+23 -76
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
@@ -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 -6
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())
@@ -472,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)
{ {
@@ -540,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)
{ {
+12 -18
View File
@@ -497,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)
@@ -518,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;
@@ -1075,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
@@ -1486,7 +1484,6 @@ static char *CHAT_WordWrap(INT32 x, INT32 w, INT32 option, const char *string)
x = 0; x = 0;
} }
} }
return newstring; return newstring;
} }
@@ -1525,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
{ {
@@ -1557,21 +1554,19 @@ 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);
@@ -1603,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
{ {
@@ -1648,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:
@@ -1710,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;
@@ -1719,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
{ {
@@ -1764,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.
-4
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
*/ */
+10 -4
View File
@@ -1510,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);
@@ -1525,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
+8 -6
View File
@@ -568,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;
@@ -1065,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
@@ -1122,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)
@@ -1415,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));
@@ -1524,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
@@ -2193,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++)
{ {
+10 -17
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.
@@ -767,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);
@@ -1480,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);
@@ -3107,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;
@@ -3599,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);
@@ -3618,7 +3611,7 @@ 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;
} }
@@ -6772,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;
@@ -6798,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;
+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))
+22 -22
View File
@@ -615,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);
@@ -626,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);
@@ -638,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);
@@ -655,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);
@@ -665,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);
@@ -676,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);
@@ -695,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);
@@ -723,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;
@@ -783,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);
@@ -802,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);
@@ -890,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))
{ {
@@ -911,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))
{ {
@@ -924,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
@@ -953,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);
@@ -967,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)
{ {
@@ -997,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
@@ -1060,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;
@@ -1096,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);
@@ -1114,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);
@@ -1163,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, }
+12 -3
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);
} }
+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};
+1 -1
View File
@@ -475,7 +475,7 @@ int mobj_localskin_setter(lua_State *L)
} }
else else
{ {
mo->localskin = NULL; mo->localskin = 0;
mo->skinlocal = false; mo->skinlocal = false;
} }
} }
+38 -38
View File
@@ -45,20 +45,20 @@ int hook_defrosting = 0;
// List of internal libraries to load from SRB2 // List of internal libraries to load from SRB2
static lua_CFunction liblist[] = { static lua_CFunction liblist[] = {
LUA_EnumLib, // global metatable for enums LUA_EnumLib, // global metatable for enums
LUA_SOCLib, // A_Action functions, freeslot LUA_SOCLib, // A_Action functions, freeslot
LUA_BaseLib, // string concatination by +, CONS_Printf, p_local.h stuff (P_InstaThrust, P_Move), etc. LUA_BaseLib, // string concatination by +, CONS_Printf, p_local.h stuff (P_InstaThrust, P_Move), etc.
LUA_MathLib, // fixed_t and angle_t math functions LUA_MathLib, // fixed_t and angle_t math functions
LUA_HookLib, // hookAdd and hook-calling functions LUA_HookLib, // hookAdd and hook-calling functions
LUA_ConsoleLib, // console command/variable functions and structs LUA_ConsoleLib, // console command/variable functions and structs
LUA_InfoLib, // info.h stuff: mobjinfo_t, mobjinfo[], state_t, states[] LUA_InfoLib, // info.h stuff: mobjinfo_t, mobjinfo[], state_t, states[]
LUA_MobjLib, // mobj_t, mapthing_t LUA_MobjLib, // mobj_t, mapthing_t
LUA_PlayerLib, // player_t LUA_PlayerLib, // player_t
LUA_SkinLib, // skin_t, skins[] LUA_SkinLib, // skin_t, skins[]
LUA_ThinkerLib, // thinker_t LUA_ThinkerLib, // thinker_t
LUA_MapLib, // line_t, side_t, sector_t, subsector_t LUA_MapLib, // line_t, side_t, sector_t, subsector_t
LUA_BlockmapLib, // blockmap stuff LUA_BlockmapLib, // blockmap stuff
LUA_HudLib, // HUD stuff LUA_HudLib, // HUD stuff
NULL NULL
}; };
@@ -66,8 +66,12 @@ static lua_CFunction liblist[] = {
static void *LUA_Alloc(void *ud, void *ptr, size_t osize, size_t nsize) static void *LUA_Alloc(void *ud, void *ptr, size_t osize, size_t nsize)
{ {
(void)ud; (void)ud;
(void)osize; if (nsize == 0) {
return Z_Realloc(ptr, nsize, PU_LUA, NULL); if (osize != 0)
Z_Free(ptr);
return NULL;
} else
return Z_Realloc(ptr, nsize, PU_LUA, NULL);
} }
// Panic function Lua calls when there's an unprotected error. // Panic function Lua calls when there's an unprotected error.
@@ -209,8 +213,7 @@ void LUA_ClearState(void)
lua_setfield(L, LUA_REGISTRYINDEX, LREG_VALID); lua_setfield(L, LUA_REGISTRYINDEX, LREG_VALID);
// open srb2 libraries // open srb2 libraries
for (i = 0; liblist[i]; i++) for(i = 0; liblist[i]; i++) {
{
lua_pushcfunction(L, liblist[i]); lua_pushcfunction(L, liblist[i]);
lua_call(L, 0, 0); lua_call(L, 0, 0);
} }
@@ -1061,13 +1064,9 @@ static void ArchiveTables(UINT8 **p)
{ {
// Write key // Write key
e = ArchiveValue(p, TABLESINDEX, -2); // key should be either a number or a string, ArchiveValue can handle this. e = ArchiveValue(p, TABLESINDEX, -2); // key should be either a number or a string, ArchiveValue can handle this.
if (e == 1) if (e == 2) // invalid key type (function, thread, lightuserdata, or anything we don't recognise)
n++; // the table contained a new table we'll have to archive. :(
else if (e == 2) // invalid key type (function, thread, lightuserdata, or anything we don't recognise)
{ {
CONS_Alert(CONS_ERROR, "Index '%s' (%s) of table %d could not be archived!\n", lua_tostring(gL, -2), luaL_typename(gL, -2), i); CONS_Alert(CONS_ERROR, "Index '%s' (%s) of table %d could not be archived!\n", lua_tostring(gL, -2), luaL_typename(gL, -2), i);
lua_pop(gL, 1);
continue;
} }
else if (e == 3) // nil key due to invalid userdata. NOT an error. else if (e == 3) // nil key due to invalid userdata. NOT an error.
{ {
@@ -1078,12 +1077,15 @@ static void ArchiveTables(UINT8 **p)
// Write value // Write value
e = ArchiveValue(p, TABLESINDEX, -1); e = ArchiveValue(p, TABLESINDEX, -1);
if (e == 1) if (e == 1)
{
n++; // the table contained a new table we'll have to archive. :( n++; // the table contained a new table we'll have to archive. :(
}
else if (e == 2) // invalid value type else if (e == 2) // invalid value type
{
CONS_Alert(CONS_ERROR, "Type of value for table %d entry '%s' (%s) could not be archived!\n", i, lua_tostring(gL, -2), luaL_typename(gL, -1)); CONS_Alert(CONS_ERROR, "Type of value for table %d entry '%s' (%s) could not be archived!\n", i, lua_tostring(gL, -2), luaL_typename(gL, -1));
}
lua_pop(gL, 1); lua_pop(gL, 1);
} }
lua_pop(gL, 1); lua_pop(gL, 1);
WRITEUINT8(*p, ARCH_TEND); WRITEUINT8(*p, ARCH_TEND);
@@ -1274,21 +1276,13 @@ static void UnArchiveTables(UINT8 **p, boolean network)
UINT8 ret; UINT8 ret;
ret = UnArchiveValue(p, TABLESINDEX, network); ret = UnArchiveValue(p, TABLESINDEX, network);
if (ret == 1) // End of table if (ret == 3)
break;
else if (ret == 2) // Key contains a new table
n++;
else if (ret == 3)
{ {
//CONS_Alert(CONS_WARNING,"Couldn't read mobj_t\n"); //CONS_Alert(CONS_WARNING,"Couldn't read mobj_t\n");
lua_pushnil(gL); lua_pushnil(gL);
} }
else if (ret == 1) // read key
if (lua_isnil(gL, -1)) // If key is nil, skip this entry break;
{
lua_pop(gL, 1);
continue;
}
ret = UnArchiveValue(p, TABLESINDEX, network); ret = UnArchiveValue(p, TABLESINDEX, network);
if (ret == 1) if (ret == 1)
@@ -1297,15 +1291,21 @@ static void UnArchiveTables(UINT8 **p, boolean network)
lua_pop(gL, 1); // Pop key lua_pop(gL, 1); // Pop key
break; break;
} }
else if (ret == 2) // read value
n++;
else if (ret == 3) else if (ret == 3)
{ {
//CONS_Alert(CONS_WARNING,"Couldn't read mobj_t\n"); //CONS_Alert(CONS_WARNING,"Couldn't read mobj_t\n");
lua_pushnil(gL); lua_pushnil(gL);
} }
else if (ret == 2) // read value
n++;
lua_rawset(gL, -3); if (lua_isnil(gL, -2)) // if key is nil (if a function etc was accidentally saved)
{
CONS_Alert(CONS_ERROR, "A nil key in table %d was found! (Invalid key type or corrupted save?)\n", i);
lua_pop(gL, 2); // pop key and value instead of setting them in the table, to prevent Lua panic errors
}
else
lua_rawset(gL, -3);
} }
lua_pop(gL, 1); lua_pop(gL, 1);
+7 -4
View File
@@ -556,7 +556,7 @@ static void GIF_framewrite(void)
} }
else if (gif_dynamicdelay ==(UINT8) 1) else if (gif_dynamicdelay ==(UINT8) 1)
{ {
float delayf = ceilf(100.0f/NEWTICRATE); float delayf = ceil(100.0f/NEWTICRATE);
delay = (UINT16)((I_GetPreciseTime() - gif_prevframetime)) / (I_GetPrecisePrecision() / 1000000) /10/1000; delay = (UINT16)((I_GetPreciseTime() - gif_prevframetime)) / (I_GetPrecisePrecision() / 1000000) /10/1000;
@@ -695,13 +695,16 @@ INT32 GIF_close(void)
fclose(gif_out); fclose(gif_out);
gif_out = NULL; gif_out = NULL;
Z_Free(gifbwr_buf); if (gifbwr_buf)
Z_Free(gifbwr_buf);
gifbwr_buf = gifbwr_cur = NULL; gifbwr_buf = gifbwr_cur = NULL;
Z_Free(gifframe_data); if (gifframe_data)
Z_Free(gifframe_data);
gifframe_data = NULL; gifframe_data = NULL;
Z_Free(giflzw_hashTable); if (giflzw_hashTable)
Z_Free(giflzw_hashTable);
giflzw_hashTable = NULL; giflzw_hashTable = NULL;
Z_Free(scrbuf_screens); Z_Free(scrbuf_screens);
+5 -5
View File
@@ -80,7 +80,7 @@ static UINT8 cheatf_warp(void)
if (success) if (success)
{ {
G_SaveGameData(true); //G_SetGameModified(false); G_SaveGameData(true); //G_SetGameModified(false);
S_StartSound(NULL, sfx_kc42); S_StartSound(0, sfx_kc42);
} }
// Refresh secrets menu existing. // Refresh secrets menu existing.
@@ -117,13 +117,13 @@ static UINT8 cheatf_devmode(void)
#endif #endif
static cheatseq_t cheat_warp = { static cheatseq_t cheat_warp = {
NULL, cheatf_warp, 0, cheatf_warp,
//{ SCRAMBLE('r'), SCRAMBLE('e'), SCRAMBLE('d'), SCRAMBLE('x'), SCRAMBLE('v'), SCRAMBLE('i'), 0xff } //{ SCRAMBLE('r'), SCRAMBLE('e'), SCRAMBLE('d'), SCRAMBLE('x'), SCRAMBLE('v'), SCRAMBLE('i'), 0xff }
{ SCRAMBLE('b'), SCRAMBLE('a'), SCRAMBLE('n'), SCRAMBLE('a'), SCRAMBLE('n'), SCRAMBLE('a'), 0xff } { SCRAMBLE('b'), SCRAMBLE('a'), SCRAMBLE('n'), SCRAMBLE('a'), SCRAMBLE('n'), SCRAMBLE('a'), 0xff }
}; };
static cheatseq_t cheat_warp_joy = { static cheatseq_t cheat_warp_joy = {
NULL, cheatf_warp, 0, cheatf_warp,
/*{ SCRAMBLE(KEY_LEFTARROW), SCRAMBLE(KEY_LEFTARROW), SCRAMBLE(KEY_UPARROW), /*{ SCRAMBLE(KEY_LEFTARROW), SCRAMBLE(KEY_LEFTARROW), SCRAMBLE(KEY_UPARROW),
SCRAMBLE(KEY_RIGHTARROW), SCRAMBLE(KEY_RIGHTARROW), SCRAMBLE(KEY_UPARROW), SCRAMBLE(KEY_RIGHTARROW), SCRAMBLE(KEY_RIGHTARROW), SCRAMBLE(KEY_UPARROW),
SCRAMBLE(KEY_LEFTARROW), SCRAMBLE(KEY_UPARROW), SCRAMBLE(KEY_LEFTARROW), SCRAMBLE(KEY_UPARROW),
@@ -136,7 +136,7 @@ static cheatseq_t cheat_warp_joy = {
#ifdef DEVELOP #ifdef DEVELOP
static cheatseq_t cheat_devmode = { static cheatseq_t cheat_devmode = {
NULL, cheatf_devmode, 0, cheatf_devmode,
{ SCRAMBLE('d'), SCRAMBLE('e'), SCRAMBLE('v'), SCRAMBLE('m'), SCRAMBLE('o'), SCRAMBLE('d'), SCRAMBLE('e'), 0xff } { SCRAMBLE('d'), SCRAMBLE('e'), SCRAMBLE('v'), SCRAMBLE('m'), SCRAMBLE('o'), SCRAMBLE('d'), SCRAMBLE('e'), 0xff }
}; };
#endif #endif
@@ -301,7 +301,7 @@ void Command_CheatNoTarget_f(void)
void Command_Scale_f(void) void Command_Scale_f(void)
{ {
const double scaled = atof(COM_Argv(1)); const double scaled = atof(COM_Argv(1));
fixed_t scale = DoubleToFixed(scaled); fixed_t scale = FLOAT_TO_FIXED(scaled);
REQUIRE_DEVMODE; REQUIRE_DEVMODE;
REQUIRE_INLEVEL; REQUIRE_INLEVEL;
+7 -4
View File
@@ -235,7 +235,7 @@ void M_AddRawCondition(UINT8 set, UINT8 id, conditiontype_t c, INT32 r, INT16 x1
wnum = conditionSets[set - 1].numconditions; wnum = conditionSets[set - 1].numconditions;
num = ++conditionSets[set - 1].numconditions; num = ++conditionSets[set - 1].numconditions;
conditionSets[set - 1].condition = Z_Realloc(conditionSets[set - 1].condition, sizeof(condition_t)*num, PU_STATIC, NULL); conditionSets[set - 1].condition = Z_Realloc(conditionSets[set - 1].condition, sizeof(condition_t)*num, PU_STATIC, 0);
cond = conditionSets[set - 1].condition; cond = conditionSets[set - 1].condition;
@@ -248,9 +248,12 @@ void M_AddRawCondition(UINT8 set, UINT8 id, conditiontype_t c, INT32 r, INT16 x1
void M_ClearConditionSet(UINT8 set) void M_ClearConditionSet(UINT8 set)
{ {
Z_Free(conditionSets[set - 1].condition); if (conditionSets[set - 1].numconditions)
conditionSets[set - 1].condition = NULL; {
conditionSets[set - 1].numconditions = 0; Z_Free(conditionSets[set - 1].condition);
conditionSets[set - 1].condition = NULL;
conditionSets[set - 1].numconditions = 0;
}
conditionSets[set - 1].achieved = false; conditionSets[set - 1].achieved = false;
} }
+4 -4
View File
@@ -12,14 +12,14 @@
#ifndef __M_EMOTES__ #ifndef __M_EMOTES__
#define __M_EMOTES__ #define __M_EMOTES__
#include "doomdef.h"
#include "m_fixed.h"
#include "command.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#include "doomdef.h"
#include "m_fixed.h"
#include "command.h"
extern consvar_t cv_emotes; extern consvar_t cv_emotes;
#define MAXEMOTENAME 32 #define MAXEMOTENAME 32
+29
View File
@@ -265,6 +265,35 @@ FUNCMATH FUNCINLINE static ATTRINLINE fixed_t FixedRound(fixed_t x)
return INT32_MAX; return INT32_MAX;
} }
/** \brief The xs_CRoundToInt function
\param val double number
\return Round toward nearest, but ties round toward even
*/
#if defined(SRB2_BIG_ENDIAN)
#define _xs_iexp_ 0
#define _xs_iman_ 1
#else
#define _xs_iexp_ 1 //intel is little endian
#define _xs_iman_ 0
#endif //BigEndian_
typedef double real64;
typedef union _xs_doubleints
{
real64 val;
unsigned ival[2];
} _xs_doubleints;
FUNCMATH FUNCINLINE static ATTRINLINE int xs_CRoundToInt(real64 val)
{
_xs_doubleints uval;
uval.val = val + 6755399441055744.0;
return uval.ival[_xs_iman_];
}
typedef struct typedef struct
{ {
fixed_t x; fixed_t x;
+79 -119
View File
@@ -12,8 +12,6 @@
/// \file m_menu.c /// \file m_menu.c
/// \brief XMOD's extremely revamped menu system. /// \brief XMOD's extremely revamped menu system.
#include "screen.h"
#include "tables.h"
#ifdef __GNUC__ #ifdef __GNUC__
#include <unistd.h> #include <unistd.h>
#endif #endif
@@ -2936,7 +2934,7 @@ static void M_PrepareLevelSelect(void)
boolean M_CanShowLevelInList(INT32 mapnum, INT32 gt) boolean M_CanShowLevelInList(INT32 mapnum, INT32 gt)
{ {
// invalid mapnum // invalid mapnum
if (mapnum < -1 || mapnum >= NUMMAPS) if (mapnum < -1)
return false; return false;
// Random map! // Random map!
@@ -4719,7 +4717,7 @@ static void M_DrawReplayHut(void)
if (y > scaledviewheight-80) if (y > scaledviewheight-80)
{ {
V_DrawFill(BASEVIDWIDTH-4, 75, 4, scaledviewheight-80, V_SNAPTOTOP|V_SNAPTORIGHT|239); V_DrawFill(BASEVIDWIDTH-4, 75, 4, scaledviewheight-80, V_SNAPTOTOP|V_SNAPTORIGHT|239);
V_DrawFill(BASEVIDWIDTH-3, 76 + (scaledviewheight-80) * replayhutmenuy / y, 2, max((((scaledviewheight-80) * (scaledviewheight-80))-1) / y - 1, 1), V_SNAPTOTOP|V_SNAPTORIGHT|229); V_DrawFill(BASEVIDWIDTH-3, 76 + (scaledviewheight-80) * replayhutmenuy / y, 2, (((scaledviewheight-80) * (scaledviewheight-80))-1) / y - 1, V_SNAPTOTOP|V_SNAPTORIGHT|229);
} }
// Draw the cursor // Draw the cursor
@@ -5356,7 +5354,7 @@ void M_PopupMasterServerRules(void)
{ {
firstDismissedRulesThisBoot = false; firstDismissedRulesThisBoot = false;
M_StartMessage(va("%s\n(press any key)", rules), NULL, MM_NOTHING); M_StartMessage(va("%s\n(press any key)", rules), NULL, MM_NOTHING);
free(rules); Z_Free(rules);
} }
} }
#endif #endif
@@ -5387,7 +5385,7 @@ void M_SlotCvarIntoModMenu(consvar_t* cvar, const char* category, const char* na
{ {
CONS_Printf("custom settings menu initiation\n"); CONS_Printf("custom settings menu initiation\n");
for (CVARSETUP = 0; CVARSETUP < MAXMENUCCVARS; ++CVARSETUP) for (CVARSETUP = 0; CVARSETUP < MAXMENUCCVARS; ++CVARSETUP)
OP_CustomCvarMenu[CVARSETUP] = (menuitem_t){IT_DISABLED, NULL, "", NULL, INT16_MAX}; OP_CustomCvarMenu[CVARSETUP] = (menuitem_t){IT_DISABLED, NULL, "", 0, INT16_MAX};
} }
if (category && ((ccvarposition == 0 && category[0] != '\0') || !fasticmp(category, OP_CustomCvarMenu[ccvarlaststheader].text))) if (category && ((ccvarposition == 0 && category[0] != '\0') || !fasticmp(category, OP_CustomCvarMenu[ccvarlaststheader].text)))
@@ -5522,6 +5520,7 @@ static void M_DrawChecklist(void)
if (conditionSets[unlockables[i].conditionset - 1].numconditions) if (conditionSets[unlockables[i].conditionset - 1].numconditions)
{ {
c = 0;
lastid = -1; lastid = -1;
for (c = 0; c < conditionSets[unlockables[i].conditionset - 1].numconditions; c++) for (c = 0; c < conditionSets[unlockables[i].conditionset - 1].numconditions; c++)
@@ -5681,6 +5680,9 @@ static void M_DrawMusicTest(void)
{ {
INT32 x, y, i; INT32 x, y, i;
x = 90<<FRACBITS;
y = (BASEVIDHEIGHT-32)<<FRACBITS;
y = (BASEVIDWIDTH-vid.scaledwidth)/2; y = (BASEVIDWIDTH-vid.scaledwidth)/2;
V_DrawFill(y-1, 20, vid.scaledwidth+1, 24, 239); V_DrawFill(y-1, 20, vid.scaledwidth+1, 24, 239);
@@ -6556,22 +6558,17 @@ static void M_EraseGuest(INT32 choice)
static void M_OverwriteGuest(const char *which) static void M_OverwriteGuest(const char *which)
{ {
char *rguest; char *rguest = Z_StrDup(va("%s"PATHSEP"replay"PATHSEP"%s"PATHSEP"%s-guest.lmp", srb2home, timeattackfolder, G_BuildMapName(cv_nextmap.value)));
UINT8 *buf; UINT8 *buf;
size_t len; size_t len;
len = FIL_ReadFile(va("%s"PATHSEP"replay"PATHSEP"%s"PATHSEP"%s-%s-%s.lmp", srb2home, timeattackfolder, G_BuildMapName(cv_nextmap.value), cv_chooseskin.string, which), &buf); len = FIL_ReadFile(va("%s"PATHSEP"replay"PATHSEP"%s"PATHSEP"%s-%s-%s.lmp", srb2home, timeattackfolder, G_BuildMapName(cv_nextmap.value), cv_chooseskin.string, which), &buf);
if (!len) {
if (!len)
return; return;
}
rguest = Z_StrDup(va("%s"PATHSEP"replay"PATHSEP"%s"PATHSEP"%s-guest.lmp", srb2home, timeattackfolder, G_BuildMapName(cv_nextmap.value))); if (FIL_FileExists(rguest)) {
if (FIL_FileExists(rguest))
{
M_StopMessage(0); M_StopMessage(0);
remove(rguest); remove(rguest);
} }
FIL_WriteFile(rguest, buf, len); FIL_WriteFile(rguest, buf, len);
Z_Free(rguest); Z_Free(rguest);
@@ -7497,7 +7494,7 @@ static void M_DrawLevelSelectOnly(boolean leftfade, boolean rightfade)
if ((lumpnum = W_CheckNumForName(va("%sE", mapname))) != LUMPERROR) if ((lumpnum = W_CheckNumForName(va("%sE", mapname))) != LUMPERROR)
mappingforencore = (patch_t *)W_CachePatchNum(lumpnum, PU_PATCH);*/ mappingforencore = (patch_t *)W_CachePatchNum(lumpnum, PU_PATCH);*/
V_DrawFixedPatch((x+w)<<FRACBITS, (y)<<FRACBITS, FRACUNIT/2, V_FLIP, PictureOfLevel, NULL); V_DrawFixedPatch((x+w)<<FRACBITS, (y)<<FRACBITS, FRACUNIT/2, V_FLIP, PictureOfLevel, 0);
{ {
static angle_t rubyfloattime = 0; static angle_t rubyfloattime = 0;
@@ -7588,6 +7585,7 @@ static void M_DrawLevelSelectOnly(boolean leftfade, boolean rightfade)
static void M_DrawServerMenu(void) static void M_DrawServerMenu(void)
{ {
M_DrawLevelSelectOnly(false, false); M_DrawLevelSelectOnly(false, false);
#ifdef MASTERSERVER #ifdef MASTERSERVER
if (currentMenu == &MP_ServerDef && cv_advertise.value) // Remind players where they're hosting. if (currentMenu == &MP_ServerDef && cv_advertise.value) // Remind players where they're hosting.
@@ -7902,7 +7900,7 @@ static void M_HandleConnectIP(INT32 choice)
if (exitmenu) if (exitmenu)
{ {
if (currentMenu->prevMenu) if (currentMenu->prevMenu)
M_SetupNextMenu(currentMenu->prevMenu); M_SetupNextMenu (currentMenu->prevMenu);
else else
M_ClearMenus(true); M_ClearMenus(true);
} }
@@ -7948,7 +7946,6 @@ static void M_DrawSetupMultiPlayerMenu(void)
UINT8 i; UINT8 i;
UINT8 s, w; UINT8 s, w;
const UINT8 *flashcol = V_GetStringColormap(highlightflags); const UINT8 *flashcol = V_GetStringColormap(highlightflags);
INT32 skinnum = 0;
INT32 statx, staty; INT32 statx, staty;
UINT32 speenframe; UINT32 speenframe;
INT32 sltw, actw, hetw; INT32 sltw, actw, hetw;
@@ -7996,9 +7993,14 @@ static void M_DrawSetupMultiPlayerMenu(void)
#define GETSELECTEDSPEED (itemOn == 1 && setupm_skinselect < numskins ? skins[skinsorted[setupm_skinselect]].kartspeed : skins[setupm_fakeskin].kartspeed) #define GETSELECTEDSPEED (itemOn == 1 && setupm_skinselect < numskins ? skins[skinsorted[setupm_skinselect]].kartspeed : skins[setupm_fakeskin].kartspeed)
#define GETSELECTEDWEIGHT (itemOn == 1 && setupm_skinselect < numskins ? skins[skinsorted[setupm_skinselect]].kartweight : skins[setupm_fakeskin].kartweight) #define GETSELECTEDWEIGHT (itemOn == 1 && setupm_skinselect < numskins ? skins[skinsorted[setupm_skinselect]].kartweight : skins[setupm_fakeskin].kartweight)
statoffset = 0;
tw = V_StringWidth("Character", 0);//V_StringWidth(GETSELECTEDSKINNAME, 0); tw = V_StringWidth("Character", 0);//V_StringWidth(GETSELECTEDSKINNAME, 0);
st = V_StringWidth(GETSELECTEDSKINNAME, 0); st = V_StringWidth(GETSELECTEDSKINNAME, 0);
INT32 selectedskin = (itemOn == 1 && setupm_skinselect < numskins ? skinsorted[setupm_skinselect] : setupm_fakeskin);
speed = skins[selectedskin].kartspeed;
weight = skins[selectedskin].kartweight;
V_DrawString((mx+(tw/2)) - (st/2), my + 37, V_DrawString((mx+(tw/2)) - (st/2), my + 37,
((MP_PlayerSetupMenu[2].status & IT_TYPE) == IT_SPACE ? V_TRANSLUCENT : 0) | highlightflags | V_ALLOWLOWERCASE, ((MP_PlayerSetupMenu[2].status & IT_TYPE) == IT_SPACE ? V_TRANSLUCENT : 0) | highlightflags | V_ALLOWLOWERCASE,
GETSELECTEDSKINNAME); GETSELECTEDSKINNAME);
@@ -8157,7 +8159,7 @@ static void M_DrawSetupMultiPlayerMenu(void)
V_DrawFixedPatch(((statx+61+GRIDSTATOFFSET)<<FRACBITS) + (FRACUNIT>>1), (staty+67)<<FRACBITS, FRACUNIT>>1, 0, statlr, flashcol); V_DrawFixedPatch(((statx+61+GRIDSTATOFFSET)<<FRACBITS) + (FRACUNIT>>1), (staty+67)<<FRACBITS, FRACUNIT>>1, 0, statlr, flashcol);
V_DrawFixedPatch((statx+40+GRIDSTATOFFSET)<<FRACBITS, (staty+80)<<FRACBITS, FRACUNIT>>1, 0, statud, flashcol); V_DrawFixedPatch((statx+40+GRIDSTATOFFSET)<<FRACBITS, (staty+80)<<FRACBITS, FRACUNIT>>1, 0, statud, flashcol);
// bg // bg
V_DrawFixedPatch(((statx+48+GRIDSTATOFFSET)<<FRACBITS)+(FRACUNIT>>1), (staty+73)<<FRACBITS, FRACUNIT>>1, 0, statbg, NULL); V_DrawFixedPatch(((statx+48+GRIDSTATOFFSET)<<FRACBITS)+(FRACUNIT>>1), (staty+73)<<FRACBITS, FRACUNIT>>1, 0, statbg, 0);
for (i = 0; i < numskins; i++) // draw the stat dots for (i = 0; i < numskins; i++) // draw the stat dots
{ {
@@ -8216,7 +8218,7 @@ static void M_DrawSetupMultiPlayerMenu(void)
V_DrawFixedPatch((statx+64)<<FRACBITS, staty<<FRACBITS, FRACUNIT, 0, statlr, flashcol); V_DrawFixedPatch((statx+64)<<FRACBITS, staty<<FRACBITS, FRACUNIT, 0, statlr, flashcol);
V_DrawFixedPatch((statx+24)<<FRACBITS, (staty+22)<<FRACBITS, FRACUNIT, 0, statud, flashcol); V_DrawFixedPatch((statx+24)<<FRACBITS, (staty+22)<<FRACBITS, FRACUNIT, 0, statud, flashcol);
// bg // bg
V_DrawFixedPatch((statx+34)<<FRACBITS, (staty+10)<<FRACBITS, FRACUNIT, 0, statbg, NULL); V_DrawFixedPatch((statx+34)<<FRACBITS, (staty+10)<<FRACBITS, FRACUNIT, 0, statbg, 0);
for (i = 0; i < numskins; i++) // draw the stat dots for (i = 0; i < numskins; i++) // draw the stat dots
{ {
@@ -8266,9 +8268,10 @@ static void M_DrawSetupMultiPlayerMenu(void)
INT32 curx = (((setupm_skinselect % SKINGRIDNEWWIDTH) * 18) + ((BASEVIDWIDTH / 2) - (18 * SKINGRIDNEWWIDTH/2)) + SKINXSHIFT) + 20; INT32 curx = (((setupm_skinselect % SKINGRIDNEWWIDTH) * 18) + ((BASEVIDWIDTH / 2) - (18 * SKINGRIDNEWWIDTH/2)) + SKINXSHIFT) + 20;
INT32 cury = (((setupm_skinselect / SKINGRIDNEWWIDTH) - setupm_skinypos) * 18) + ((BASEVIDHEIGHT / 2) - (18 * (SKINGRIDNEWWIDTH/2))+ gridyoffset); INT32 cury = (((setupm_skinselect / SKINGRIDNEWWIDTH) - setupm_skinypos) * 18) + ((BASEVIDHEIGHT / 2) - (18 * (SKINGRIDNEWWIDTH/2))+ gridyoffset);
UINT8 cursorframe = (I_GetTime() / 4) % 7; UINT8 cursorframe = (I_GetTime() / 4) % 7;
cursor = (patch_t *)W_CachePatchName(va("K_CHILI%d", cursorframe + 1), PU_PATCH);
V_DrawFixedPatch((curx << FRACBITS) - (FRACUNIT), (cury << FRACBITS) - (FRACUNIT), FRACUNIT+(FRACUNIT>>3), 0, cursor, NULL); cursor = (patch_t *)W_CachePatchName(va("K_CHILI%d", cursorframe + 1), PU_PATCH);
V_DrawFixedPatch((curx << FRACBITS) - (FRACUNIT), (cury << FRACBITS) - (FRACUNIT), FRACUNIT+(FRACUNIT>>3), 0, cursor, NULL);
} }
break; break;
@@ -8307,12 +8310,14 @@ static void M_DrawSetupMultiPlayerMenu(void)
if (setupm_skinselect < numskins) if (setupm_skinselect < numskins)
{ {
UINT8 *cmap = R_GetTranslationColormap(setupm_skinselect, setupm_fakecolor, GTC_MENUCACHE); UINT8 *cmap = R_GetTranslationColormap(setupm_skinselect, setupm_fakecolor, GTC_MENUCACHE);
cursor = facewantprefix[skinsorted[setupm_skinselect]]; cursor = facewantprefix[skinsorted[setupm_skinselect]];
V_DrawFixedPatch(((curx-8) << FRACBITS), ((cury-8) << FRACBITS), FRACUNIT, 0, cursor, cmap); V_DrawFixedPatch(((curx-8) << FRACBITS), ((cury-8) << FRACBITS), FRACUNIT, 0, cursor, cmap);
} }
else else
{ {
UINT8 cursorframe = (I_GetTime() / 4) % 7; UINT8 cursorframe = (I_GetTime() / 4) % 7;
cursor = (patch_t *)W_CachePatchName(va("K_CHILI%d", cursorframe + 1), PU_PATCH); cursor = (patch_t *)W_CachePatchName(va("K_CHILI%d", cursorframe + 1), PU_PATCH);
V_DrawFixedPatch((curx << FRACBITS) - (FRACUNIT), (cury << FRACBITS) - (FRACUNIT), FRACUNIT+(FRACUNIT>>3), 0, cursor, NULL); V_DrawFixedPatch((curx << FRACBITS) - (FRACUNIT), (cury << FRACBITS) - (FRACUNIT), FRACUNIT+(FRACUNIT>>3), 0, cursor, NULL);
} }
@@ -8376,6 +8381,7 @@ static void M_DrawSetupMultiPlayerMenu(void)
else else
{ {
UINT8 cursorframe = (I_GetTime() / 4) % 7; UINT8 cursorframe = (I_GetTime() / 4) % 7;
cursor = (patch_t *)W_CachePatchName(va("K_CHILI%d", cursorframe + 1), PU_PATCH); cursor = (patch_t *)W_CachePatchName(va("K_CHILI%d", cursorframe + 1), PU_PATCH);
V_DrawFixedPatch((curx << FRACBITS) - (FRACUNIT), (cury << FRACBITS) - (FRACUNIT), FRACUNIT+(FRACUNIT>>3), 0, cursor, NULL); V_DrawFixedPatch((curx << FRACBITS) - (FRACUNIT), (cury << FRACBITS) - (FRACUNIT), FRACUNIT+(FRACUNIT>>3), 0, cursor, NULL);
} }
@@ -8500,7 +8506,7 @@ static void M_DrawSetupMultiPlayerMenu(void)
switch (cv_skinselectmenu.value) switch (cv_skinselectmenu.value)
{ {
case SKINMENUTYPE_2D: case SKINMENUTYPE_2D:
skintodisplay = (UINT8)setupm_fakeskin; skintodisplay = setupm_fakeskin;
if (setupm_skinlockedselect) // show the skin we are trying to select if (setupm_skinlockedselect) // show the skin we are trying to select
skintodisplay = skinstats[setupm_skinxpos][setupm_skinypos][setupm_skinselect]; skintodisplay = skinstats[setupm_skinxpos][setupm_skinypos][setupm_skinselect];
else if (skinstatscount[setupm_skinxpos][setupm_skinypos] && itemOn == 1) else if (skinstatscount[setupm_skinxpos][setupm_skinypos] && itemOn == 1)
@@ -8508,22 +8514,19 @@ static void M_DrawSetupMultiPlayerMenu(void)
break; break;
case SKINMENUTYPE_EXTENDED: case SKINMENUTYPE_EXTENDED:
case SKINMENUTYPE_GRID: case SKINMENUTYPE_GRID:
skintodisplay = ((itemOn == 1 && (setupm_skinselect < numskins)) ? skinsorted[setupm_skinselect] : (UINT8)setupm_fakeskin); skintodisplay = (itemOn == 1 && setupm_skinselect < numskins ? skinsorted[setupm_skinselect] : setupm_fakeskin);
break; break;
default: default:
skintodisplay = (UINT8)setupm_fakeskin; skintodisplay = setupm_fakeskin;
break; break;
} }
if (skintodisplay >= MAXSKINS) const INT32 skinnum = R_SkinAvailable(skins[skintodisplay].name);
skintodisplay = 0;
skinnum = R_SkinAvailable(skins[skintodisplay].name); if (skinnum != -1)
sprdef = &skins[skinnum].spritedef;
if (skinnum < 0 || skinnum >= MAXSKINS) else
skinnum = 0; sprdef = &skins[0].spritedef;
sprdef = &skins[skinnum].spritedef;
if (!sprdef->numframes) // No frames ?? if (!sprdef->numframes) // No frames ??
return; // Can't render! return; // Can't render!
@@ -8532,59 +8535,37 @@ static void M_DrawSetupMultiPlayerMenu(void)
if (frame >= sprdef->numframes) // Walking animation missing if (frame >= sprdef->numframes) // Walking animation missing
frame = 0; // Try to use standing frame frame = 0; // Try to use standing frame
sprframe = &sprdef->spriteframes[frame];
// minenice's speen css, it's a piece of shit but hey
speenframe = (I_GetTime()*cv_skinselectspin.value/TICRATE + 1)%8;
// this is a very shitty solution for checking if a sprite needs flipping
// but it works
if ((speenframe > 4) && (sprframe->lumppat[speenframe] == sprframe->lumppat[8-speenframe]))
flags = V_FLIP; // This sprite is left/right flipped!
patch = (patch_t *)W_CachePatchNum(sprframe->lumppat[speenframe], PU_PATCH);
// draw box around guy // draw box around guy
V_DrawFill(mx + 36 - (charw/2), my+65, charw, 84, 239); V_DrawFill(mx + 36 - (charw/2), my+65, charw, 84, 239);
#undef charw
// draw player sprite // draw player sprite
if (setupm_fakecolor) // inverse should never happen if (setupm_fakecolor) // inverse should never happen
{ {
UINT8 *colormap = R_GetTranslationColormap(skintodisplay, setupm_fakecolor, GTC_MENUCACHE); UINT8 *colormap = R_GetTranslationColormap(skintodisplay, setupm_fakecolor, GTC_MENUCACHE);
#ifdef HWRENDER
md2_t *md2 = &md2_playermodels[skinnum]; if (skins[skintodisplay].flags & SF_HIRES)
#endif
mx += 36;
my += 131;
#ifdef HWRENDER
// if we have 3d models enabled and a model exists
// try to show it instead of the sprite
if (rendermode == render_opengl && cv_glmdls.value
&& !md2->error && !md2->notfound)
{ {
const angle_t ROTATE_PER_TIC = (UINT64)ANGLE_45 * cv_skinselectspin.value / TICRATE; V_DrawFixedPatch((mx+36)<<FRACBITS,
angle_t angle = I_GetTime()*ROTATE_PER_TIC + FixedMul(cv_uncappedhud.value ? renderdeltatics : FRACUNIT, ROTATE_PER_TIC); (my+131)<<FRACBITS,
HWR_Draw2DModel(md2, mx, my, skinnum, (skincolors_t)setupm_fakecolor, colormap, 8*FRACUNIT/3, frame, angle); skins[skintodisplay].highresscale,
flags, patch, colormap);
} }
else else
#endif V_DrawMappedPatch(mx+36, my+131, flags, patch, colormap);
{
sprframe = &sprdef->spriteframes[frame];
// minenice's speen css, it's a piece of shit but hey
speenframe = (I_GetTime()*cv_skinselectspin.value/TICRATE + 1)%8;
// this is a very shitty solution for checking if a sprite needs flipping
// but it works
if ((speenframe > 4) && (sprframe->lumppat[speenframe] == sprframe->lumppat[8-speenframe]))
{
flags = V_FLIP; // This sprite is left/right flipped!
}
patch = (patch_t *)W_CachePatchNum(sprframe->lumppat[speenframe], PU_PATCH);
if (skins[skintodisplay].flags & SF_HIRES)
{
V_DrawFixedPatch(mx<<FRACBITS,
my<<FRACBITS,
skins[skintodisplay].highresscale,
flags, patch, colormap);
}
else
{
V_DrawMappedPatch(mx, my, flags, patch, colormap);
}
}
} }
#undef charw
} }
// Handle 1P/2P MP Setup // Handle 1P/2P MP Setup
@@ -9885,7 +9866,7 @@ static void M_DrawLocalSkinMenu(void)
spriteframe_t *sprframe; spriteframe_t *sprframe;
patch_t *patch; patch_t *patch;
UINT8 frame; UINT8 frame;
INT32 skintodisplay = 0; INT16 skintodisplay;
UINT32 speenframe; UINT32 speenframe;
skin_t displayskin; skin_t displayskin;
@@ -9916,12 +9897,12 @@ static void M_DrawLocalSkinMenu(void)
// skin 0 is default player sprite // skin 0 is default player sprite
skintodisplay = R_AnySkinAvailable(cv_fakelocalskin.string); skintodisplay = R_AnySkinAvailable(cv_fakelocalskin.string);
if (skintodisplay < 0) if (skintodisplay == -1)
{ {
// ATTEMPT TO FIND REAL SKIN // ATTEMPT TO FIND REAL SKIN
skintodisplay = R_AnySkinAvailable(cv_skin.string); skintodisplay = R_AnySkinAvailable(cv_skin.string);
if (skintodisplay < 0) // STILL NOTHIN? use sonic instead if (skintodisplay == -1) // STILL NOTHIN? use sonic instead
{ {
skintodisplay = 0; skintodisplay = 0;
} }
@@ -9938,10 +9919,24 @@ static void M_DrawLocalSkinMenu(void)
if (frame >= sprdef->numframes) // Walking animation missing if (frame >= sprdef->numframes) // Walking animation missing
frame = 0; // Try to use standing frame frame = 0; // Try to use standing frame
sprframe = &sprdef->spriteframes[frame];
//minenice's speen css, it's a piece of shit but hey
//patch = (patch_t *)W_CachePatchNum(sprframe->lumppat[1], PU_PATCH);
speenframe = (I_GetTime()*cv_skinselectspin.value/TICRATE + 1)%8;
//this is a very shitty solution for checking if a sprite needs flipping
//but it works
if ((speenframe > 4) && (sprframe->lumppat[speenframe] == sprframe->lumppat[8-speenframe]))
{
flags = V_FLIP; // This sprite is left/right flipped!
}
patch = (patch_t *)W_CachePatchNum(sprframe->lumppat[speenframe], PU_PATCH);
// draw box around guy // draw box around guy
V_DrawFill(mx + 220 - (charw/2), my+54, charw, 84, 239); V_DrawFill(mx + 220 - (charw/2), my+54, charw, 84, 239);
#undef charw
// draw player sprite
UINT8 *colormap = R_GetLocalTranslationColormap(&skins[displayskin.localnum], (displayskin.localskin ? &localskins[displayskin.localnum] : NULL), cv_playercolor.value, GTC_MENUCACHE, displayskin.localskin); UINT8 *colormap = R_GetLocalTranslationColormap(&skins[displayskin.localnum], (displayskin.localskin ? &localskins[displayskin.localnum] : NULL), cv_playercolor.value, GTC_MENUCACHE, displayskin.localskin);
V_DrawMappedPatch(mx, my+50, 0, (patch_t *)W_CachePatchName(displayskin.facewant, PU_PATCH), colormap); V_DrawMappedPatch(mx, my+50, 0, (patch_t *)W_CachePatchName(displayskin.facewant, PU_PATCH), colormap);
@@ -9954,48 +9949,13 @@ static void M_DrawLocalSkinMenu(void)
else else
V_DrawString(mx+20, my+118, V_ALLOWLOWERCASE|highlightflags, displayskin.realname); V_DrawString(mx+20, my+118, V_ALLOWLOWERCASE|highlightflags, displayskin.realname);
// draw player sprite if (displayskin.flags & SF_HIRES)
mx += 220;
my += 120;
#ifdef HWRENDER
md2_t *md2 = (displayskin.localskin ? &md2_localplayermodels[skintodisplay] : &md2_playermodels[skintodisplay]);
// if we have 3d models enabled and a model exists
// try to show it instead of the sprite
if (rendermode == render_opengl && cv_glmdls.value
&& !md2->error && !md2->notfound)
{ {
const angle_t ROTATE_PER_TIC = (UINT64)ANGLE_45 * cv_skinselectspin.value / TICRATE; V_DrawFixedPatch((mx+220)<<FRACBITS, (my+120)<<FRACBITS, displayskin.highresscale, flags, patch, colormap);
angle_t angle = I_GetTime()*ROTATE_PER_TIC + FixedMul(cv_uncappedhud.value ? renderdeltatics : FRACUNIT, ROTATE_PER_TIC);
HWR_Draw2DModel(md2, mx, my, skintodisplay, (skincolors_t)cv_playercolor.value, colormap, 8*FRACUNIT/3, frame, angle);
} }
else else
#endif V_DrawMappedPatch(mx+220, my+120, flags, patch, colormap);
{ #undef charw
sprframe = &sprdef->spriteframes[frame];
// minenice's speen css, it's a piece of shit but hey
speenframe = (I_GetTime()*cv_skinselectspin.value/TICRATE + 1)%8;
// this is a very shitty solution for checking if a sprite needs flipping
// but it works
if ((speenframe > 4) && (sprframe->lumppat[speenframe] == sprframe->lumppat[8-speenframe]))
{
flags = V_FLIP; // This sprite is left/right flipped!
}
patch = (patch_t *)W_CachePatchNum(sprframe->lumppat[speenframe], PU_PATCH);
if (displayskin.flags & SF_HIRES)
{
V_DrawFixedPatch(mx<<FRACBITS, my<<FRACBITS, displayskin.highresscale, flags, patch, colormap);
}
else
{
V_DrawMappedPatch(mx, my, flags, patch, colormap);
}
}
} }
// Draw the video modes list, a-la-Quake // Draw the video modes list, a-la-Quake
+11 -12
View File
@@ -986,7 +986,7 @@ static const char* OP_ExpTooltips[] =
"Skips rendering frames if game logic takes too long\npreventing gameplay issues during performance drops.", // idk im shit as describing things "Skips rendering frames if game logic takes too long\npreventing gameplay issues during performance drops.", // idk im shit as describing things
"Different methods of scaling the votescreen backgrounds.", "Different methods of scaling the votescreen backgrounds.",
#ifdef HWRENDER #ifdef HWRENDER
"Disabling Screen Textures may result in a performance boost\nbut will break certain effects.\nScreen textures are required at resolutions lower than your desktop resolution!" "Should the game do Screen Textures? Provides a good boost to frames\nat the cost of some visual effects not working when disabled.",
#ifdef USE_FBO_OGL #ifdef USE_FBO_OGL
"Allows the game to downsample from a higher resolution\nthan your display in OpenGL renderer mode.\nRequires a GPU with atleast OpenGL 2.1 support.", "Allows the game to downsample from a higher resolution\nthan your display in OpenGL renderer mode.\nRequires a GPU with atleast OpenGL 2.1 support.",
#endif #endif
@@ -1205,10 +1205,6 @@ static menuitem_t OP_FocusOptionsMenu[] =
{IT_STRING|IT_CVAR, NULL, "Show \"FOCUS LOST\"", &cv_showfocuslost, 100}, {IT_STRING|IT_CVAR, NULL, "Show \"FOCUS LOST\"", &cv_showfocuslost, 100},
{IT_STRING|IT_CVAR, NULL, "Visible Mouse", &cv_mousevisible, 120}, {IT_STRING|IT_CVAR, NULL, "Visible Mouse", &cv_mousevisible, 120},
{IT_STRING|IT_CVAR, NULL, "Gamepad LED Color While Unfocused ", &cv_gamepadledifunfocused, 140},
{IT_STRING|IT_CVAR, NULL, "Gamepad Rumble While Unfocused", &cv_rumbleifunfocused, 150},
}; };
static const char* OP_FocusOptionsTooltips[] = static const char* OP_FocusOptionsTooltips[] =
@@ -1220,8 +1216,6 @@ static const char* OP_FocusOptionsTooltips[] =
"Set manual framerate cap while the game is unfocused.", "Set manual framerate cap while the game is unfocused.",
"Should the FOCUS LOST window appear\n while the game is unfocused?", "Should the FOCUS LOST window appear\n while the game is unfocused?",
"Displays the mouse cursor while the game is in focus.", "Displays the mouse cursor while the game is in focus.",
"Should gamepad LED indicator change color when unfocused?",
"Should gamepad rumble apply when unfocused?",
}; };
static menuitem_t OP_DataOptionsMenu[] = static menuitem_t OP_DataOptionsMenu[] =
@@ -1639,10 +1633,13 @@ static menuitem_t OP_AccessibilityMenu[] =
{IT_STRING|IT_CVAR|IT_CV_SLIDER, NULL, "Saturation", &cv_globalsaturation, 25}, {IT_STRING|IT_CVAR|IT_CV_SLIDER, NULL, "Saturation", &cv_globalsaturation, 25},
{IT_SUBMENU|IT_STRING, NULL, "Video Color Settings...", &OP_ColorOptionsDef, 30}, {IT_SUBMENU|IT_STRING, NULL, "Video Color Settings...", &OP_ColorOptionsDef, 30},
{IT_STRING|IT_CVAR, NULL, "Reduce Effects", &cv_reducevfx, 35}, {IT_STRING|IT_CVAR, NULL, "Midnight Channel Flicker", &cv_lessflicker, 35},
{IT_STRING|IT_CVAR, NULL, "Midnight Channel Flicker", &cv_lessflicker, 40}, // obsolete now? or still better be a seperate toggle?
{IT_STRING|IT_CVAR, NULL, "Minimum Sector Brightness", &cv_secbright, 45}, {IT_STRING|IT_CVAR, NULL, "Minimum Sector Brightness", &cv_secbright, 40},
#ifdef HWRENDER
{IT_STRING|IT_CVAR, NULL, "Screen Textures", &cv_glscreentextures, 45},
#endif
{IT_STRING|IT_CVAR, NULL, "Water Surface Ripples", &cv_ripplewater, 50}, {IT_STRING|IT_CVAR, NULL, "Water Surface Ripples", &cv_ripplewater, 50},
@@ -1650,7 +1647,7 @@ static menuitem_t OP_AccessibilityMenu[] =
{IT_STRING|IT_CVAR, NULL, "Quake Screenshakes", &cv_screenquake, 60}, {IT_STRING|IT_CVAR, NULL, "Quake Screenshakes", &cv_screenquake, 60},
{IT_CALL|IT_STRING, NULL, "Camera Options...", M_CameraMenu, 65}, {IT_CALL|IT_STRING, NULL, "Camera Options...", M_CameraMenu, 65},
{IT_HEADER, NULL, "Audio", NULL, 75}, {IT_HEADER, NULL, "Audio", NULL, 75},
@@ -1672,9 +1669,11 @@ static const char* OP_AccessibilityTooltips[] =
"Gamma (brightness) of the game.", "Gamma (brightness) of the game.",
"Saturation of the game.", "Saturation of the game.",
"Advanced color settings of the game.", "Advanced color settings of the game.",
"Reduces or disables certain effects players might be sensitive to\nSuch as flashing, flickering, certain screen effects and more.",
"Disables the flicker effect on Midnight Channel.", "Disables the flicker effect on Midnight Channel.",
"Sets minimum sector brightness, useful for dark areas", "Sets minimum sector brightness, useful for dark areas",
#ifdef HWRENDER
"Should the game do Screen Textures? Provides a good boost to frames\nat the cost of some visual effects not working when disabled.",
#endif
"Toggles the ripple effect on water surfaces", "Toggles the ripple effect on water surfaces",
"Fades other Players that are close to the camera in and out", "Fades other Players that are close to the camera in and out",
"Toggles the screen shake effect during Earthquakes", "Toggles the screen shake effect during Earthquakes",
+6 -7
View File
@@ -540,7 +540,7 @@ static boolean M_BackupConfig(const char *filename)
void M_SaveConfig(const char *filename) void M_SaveConfig(const char *filename)
{ {
FILE *f; FILE *f;
CLEANUP(Z_Pfree) char *filepath = NULL; char *filepath;
// make sure not to write back the config until it's been correctly loaded // make sure not to write back the config until it's been correctly loaded
if (!loaded_config) if (!loaded_config)
@@ -558,7 +558,7 @@ void M_SaveConfig(const char *filename)
// append srb2home to beginning of filename // append srb2home to beginning of filename
// but check if srb2home isn't already there, first // but check if srb2home isn't already there, first
if (!strstr(filename, srb2home)) if (!strstr(filename, srb2home))
filepath = Z_StrDup(va(pandf, srb2home, filename)); filepath = va(pandf,srb2home, filename);
else else
filepath = Z_StrDup(filename); filepath = Z_StrDup(filename);
@@ -1346,15 +1346,14 @@ void M_MinimapGenerate(void)
minigen = AM_MinimapGenerate(mul); minigen = AM_MinimapGenerate(mul);
if (minigen == NULL || minigen->buf == NULL) if (minigen == NULL || minigen->buf == NULL)
{ goto failure;
CONS_Alert(CONS_ERROR, M_GetText("Couldn't create %s\n"), filepath);
return;
}
M_CreateScreenShotPalette(); M_CreateScreenShotPalette();
ret = M_SavePNG(filepath, minigen->buf, minigen->w, minigen->h, screenshot_palette); ret = M_SavePNG(filepath, minigen->buf, minigen->w, minigen->h, screenshot_palette);
free(minigen->buf); failure:
if (minigen->buf != NULL)
free(minigen->buf);
if (ret) if (ret)
{ {
+9 -9
View File
@@ -110,12 +110,12 @@ perfstatrow_t rendertime_rows[] = {
{"ui ", "UI render: ", &ps_uitime, PS_TIME}, {"ui ", "UI render: ", &ps_uitime, PS_TIME},
{"finupdt", "I_FinishUpdate:", &ps_swaptime, PS_TIME}, {"finupdt", "I_FinishUpdate:", &ps_swaptime, PS_TIME},
{} {0}
}; };
perfstatrow_t gamelogicbrief_row[] = { perfstatrow_t gamelogicbrief_row[] = {
{"logic ", "Game logic: ", &ps_tictime, PS_TIME}, {"logic ", "Game logic: ", &ps_tictime, PS_TIME},
{} {0}
}; };
perfstatrow_t commoncounter_rows[] = { perfstatrow_t commoncounter_rows[] = {
@@ -123,20 +123,20 @@ perfstatrow_t commoncounter_rows[] = {
{"sprites", "Sprites: ", &ps_numsprites, 0}, {"sprites", "Sprites: ", &ps_numsprites, 0},
{"drwnode", "Drawnodes: ", &ps_numdrawnodes, 0}, {"drwnode", "Drawnodes: ", &ps_numdrawnodes, 0},
{"plyobjs", "Polyobjects: ", &ps_numpolyobjects, 0}, {"plyobjs", "Polyobjects: ", &ps_numpolyobjects, 0},
{} {0}
}; };
perfstatrow_t interpolation_rows[] = { perfstatrow_t interpolation_rows[] = {
{"intpfrc", "Interp frac: ", &ps_interp_frac, 0}, {"intpfrc", "Interp frac: ", &ps_interp_frac, 0},
{"intplag", "Interp lag: ", &ps_interp_lag, 0}, {"intplag", "Interp lag: ", &ps_interp_lag, 0},
{} {0}
}; };
#ifdef HWRENDER #ifdef HWRENDER
perfstatrow_t batchcount_rows[] = { perfstatrow_t batchcount_rows[] = {
{"polygon", "Polygons: ", &ps_hw_numpolys, 0}, {"polygon", "Polygons: ", &ps_hw_numpolys, 0},
{"vertex ", "Vertices: ", &ps_hw_numverts, 0}, {"vertex ", "Vertices: ", &ps_hw_numverts, 0},
{} {0}
}; };
perfstatrow_t batchcalls_rows[] = { perfstatrow_t batchcalls_rows[] = {
@@ -145,7 +145,7 @@ perfstatrow_t batchcalls_rows[] = {
{"texture", "Textures: ", &ps_hw_numtextures, 0}, {"texture", "Textures: ", &ps_hw_numtextures, 0},
{"polyflg", "Polyflags: ", &ps_hw_numpolyflags, 0}, {"polyflg", "Polyflags: ", &ps_hw_numpolyflags, 0},
{"colors ", "Colors: ", &ps_hw_numcolors, 0}, {"colors ", "Colors: ", &ps_hw_numcolors, 0},
{} {0}
}; };
#endif #endif
@@ -164,7 +164,7 @@ perfstatrow_t gamelogic_rows[] = {
{" lthinkf", " LUAh_ThinkFrame:", &ps_lua_thinkframe_time, PS_TIME|PS_LEVEL}, {" lthinkf", " LUAh_ThinkFrame:", &ps_lua_thinkframe_time, PS_TIME|PS_LEVEL},
{" lpostthinkf", " LUAh_PostThinkFrame:", &ps_lua_postthinkframe_time, PS_TIME|PS_LEVEL}, {" lpostthinkf", " LUAh_PostThinkFrame:", &ps_lua_postthinkframe_time, PS_TIME|PS_LEVEL},
{" other ", " Other: ", &ps_otherlogictime, PS_TIME|PS_LEVEL}, {" other ", " Other: ", &ps_otherlogictime, PS_TIME|PS_LEVEL},
{} {0}
}; };
perfstatrow_t thinkercount_rows[] = { perfstatrow_t thinkercount_rows[] = {
@@ -176,13 +176,13 @@ perfstatrow_t thinkercount_rows[] = {
{" precip ", " Precipitation: ", &ps_precipcount, PS_LEVEL}, {" precip ", " Precipitation: ", &ps_precipcount, PS_LEVEL},
{" other ", " Other: ", &ps_otherthcount, PS_LEVEL}, {" other ", " Other: ", &ps_otherthcount, PS_LEVEL},
{" remove ", " Pending removal:", &ps_removecount, PS_LEVEL}, {" remove ", " Pending removal:", &ps_removecount, PS_LEVEL},
{} {0}
}; };
perfstatrow_t misc_calls_rows[] = { perfstatrow_t misc_calls_rows[] = {
{"lmhook", "Lua mobj hooks: ", &ps_lua_mobjhooks, PS_LEVEL}, {"lmhook", "Lua mobj hooks: ", &ps_lua_mobjhooks, PS_LEVEL},
{"chkpos", "P_CheckPosition:", &ps_checkposition_calls, PS_LEVEL}, {"chkpos", "P_CheckPosition:", &ps_checkposition_calls, PS_LEVEL},
{} {0}
}; };
// Sample collection status for averaging. // Sample collection status for averaging.
+3 -4
View File
@@ -219,9 +219,8 @@ static void Get_masterserver_rules(boolean checkfirst)
if (HMS_fetch_rules(rules, sizeof rules)) if (HMS_fetch_rules(rules, sizeof rules))
{ {
Lock_state(); Lock_state();
if (MSRules) Z_Free(MSRules);
free(MSRules); MSRules = Z_StrDup(rules);
MSRules = strdup(rules);
if (MSRegistered == true) if (MSRegistered == true)
{ {
@@ -508,7 +507,7 @@ char *GetMasterServerRules(void)
char *rules; char *rules;
Lock_state(); Lock_state();
rules = MSRules ? strdup(MSRules) : NULL; rules = MSRules ? Z_StrDup(MSRules) : NULL;
Unlock_state(); Unlock_state();
return rules; return rules;
+4 -4
View File
@@ -5977,7 +5977,7 @@ void A_Boss7Chase(void *thing)
if (actor->flags2 & MF2_FRET) if (actor->flags2 & MF2_FRET)
{ {
P_SetMobjState(actor, S_BLACKEGG_DESTROYPLAT1); P_SetMobjState(actor, S_BLACKEGG_DESTROYPLAT1);
S_StartSound(NULL, sfx_s3k53); S_StartSound(0, sfx_s3k53);
actor->flags2 &= ~MF2_FRET; actor->flags2 &= ~MF2_FRET;
return; return;
} }
@@ -6011,7 +6011,7 @@ void A_Boss7Chase(void *thing)
{ {
// Punch him! // Punch him!
P_SetMobjState(actor, actor->info->meleestate); P_SetMobjState(actor, actor->info->meleestate);
S_StartSound(NULL, sfx_begrnd); // warning sound S_StartSound(0, sfx_begrnd); // warning sound
return; return;
} }
} }
@@ -6057,7 +6057,7 @@ void A_Boss7Chase(void *thing)
case 2: // Homing Missile case 2: // Homing Missile
A_FaceTarget(actor); A_FaceTarget(actor);
P_SetMobjState(actor, actor->info->missilestate); P_SetMobjState(actor, actor->info->missilestate);
S_StartSound(NULL, sfx_beflap); S_StartSound(0, sfx_beflap);
break; break;
} }
@@ -10739,7 +10739,7 @@ void A_BrakChase(void *thing)
{ {
actor->reactiontime--; actor->reactiontime--;
if (actor->reactiontime == 0 && actor->type == MT_CYBRAKDEMON) if (actor->reactiontime == 0 && actor->type == MT_CYBRAKDEMON)
S_StartSound(NULL, sfx_bewar1 + P_RandomKey(4)); S_StartSound(0, sfx_bewar1 + P_RandomKey(4));
} }
// modify target threshold // modify target threshold
+1
View File
@@ -2420,6 +2420,7 @@ boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 da
{ {
player->kartstuff[k_sneakertimer] = 0; player->kartstuff[k_sneakertimer] = 0;
K_SpinPlayer(player, source, 1, inflictor, false); K_SpinPlayer(player, source, 1, inflictor, false);
damage = player->mo->health - 1;
P_RingDamage(player, inflictor, source); P_RingDamage(player, inflictor, source);
P_PlayerRingBurst(player, 5); P_PlayerRingBurst(player, 5);
+18 -19
View File
@@ -335,7 +335,7 @@ static boolean P_SetPrecipMobjState(precipmobj_t *mobj, statenum_t state)
mobj->tics = st->tics; mobj->tics = st->tics;
mobj->sprite = st->sprite; mobj->sprite = st->sprite;
mobj->frame = st->frame; mobj->frame = st->frame;
//mobj->anim_duration = (UINT16)st->var2; // only used if FF_ANIMATE is set mobj->anim_duration = (UINT16)st->var2; // only used if FF_ANIMATE is set
return true; return true;
} }
@@ -3606,10 +3606,10 @@ static void P_CalculatePrecipFloor(precipmobj_t *mobj)
// Just the identification of a precip thinker. The thinker // Just the identification of a precip thinker. The thinker
// should never actually be called! // should never actually be called!
// //
FUNCNORETURN void P_NullPrecipThinker(precipmobj_t *mobj) void P_NullPrecipThinker(precipmobj_t *mobj)
{ {
(void)mobj; (void)mobj;
I_Error("P_NullPrecipThinker should not be called"); I_Assert("P_NullPrecipThinker should not be called" == 0);
} }
boolean P_PrecipThinker(precipmobj_t *mobj) boolean P_PrecipThinker(precipmobj_t *mobj)
@@ -3620,7 +3620,7 @@ boolean P_PrecipThinker(precipmobj_t *mobj)
mobj->lastThink = leveltime; mobj->lastThink = leveltime;
R_ResetPrecipitationMobjInterpolationState(mobj); R_ResetPrecipitationMobjInterpolationState(mobj);
//P_CycleStateAnimation((mobj_t *)mobj); // if we ever want animated precip, readd a specific function which does not need casting P_CycleStateAnimation((mobj_t *)mobj);
if (mobj->state == &states[S_RAINRETURN]) if (mobj->state == &states[S_RAINRETURN])
{ {
@@ -4012,7 +4012,7 @@ static void P_Boss3Thinker(mobj_t *mobj)
if ((UINT32)mobj->extravalue1 + TICRATE*2 < leveltime) if ((UINT32)mobj->extravalue1 + TICRATE*2 < leveltime)
{ {
mobj->extravalue1 = (INT32)leveltime; mobj->extravalue1 = (INT32)leveltime;
S_StartSound(NULL, sfx_buzz1); S_StartSound(0, sfx_buzz1);
} }
// If in the center, check to make sure // If in the center, check to make sure
@@ -4631,7 +4631,7 @@ static void P_Boss7Thinker(mobj_t *mobj)
if (mobj->health > 0) if (mobj->health > 0)
mobj->health--; mobj->health--;
S_StartSound(NULL, (mobj->health) ? sfx_behurt : sfx_bedie2); S_StartSound(0, (mobj->health) ? sfx_behurt : sfx_bedie2);
mobj->reactiontime /= 3; mobj->reactiontime /= 3;
@@ -4670,7 +4670,7 @@ static void P_Boss7Thinker(mobj_t *mobj)
INT32 i; INT32 i;
mobj->state->nextstate = mobj->info->painstate; // Reset mobj->state->nextstate = mobj->info->painstate; // Reset
S_StartSound(NULL, sfx_bedeen); S_StartSound(0, sfx_bedeen);
for (i = 0; i < MAXPLAYERS; i++) for (i = 0; i < MAXPLAYERS; i++)
{ {
@@ -4694,7 +4694,7 @@ static void P_Boss7Thinker(mobj_t *mobj)
mobj->state->nextstate = mobj->info->spawnstate; mobj->state->nextstate = mobj->info->spawnstate;
// Laugh // Laugh
S_StartSound(NULL, sfx_bewar1 + P_RandomKey(4)); S_StartSound(0, sfx_bewar1 + P_RandomKey(4));
} }
} }
} }
@@ -4714,7 +4714,7 @@ static void P_Boss7Thinker(mobj_t *mobj)
var2 = 2*TICRATE + (80<<16); var2 = 2*TICRATE + (80<<16);
A_LobShot(mobj); A_LobShot(mobj);
S_StartSound(NULL, sfx_begoop); S_StartSound(0, sfx_begoop);
} }
} }
else if (mobj->state == &states[S_BLACKEGG_SHOOT2]) else if (mobj->state == &states[S_BLACKEGG_SHOOT2])
@@ -4738,7 +4738,7 @@ static void P_Boss7Thinker(mobj_t *mobj)
S_StopSound(missile); S_StopSound(missile);
if (leveltime & 1) if (leveltime & 1)
S_StartSound(NULL, sfx_beshot); S_StartSound(0, sfx_beshot);
} }
else if (mobj->state == &states[S_BLACKEGG_JUMP1] && mobj->tics == 1) else if (mobj->state == &states[S_BLACKEGG_JUMP1] && mobj->tics == 1)
{ {
@@ -4871,7 +4871,7 @@ static void P_Boss7Thinker(mobj_t *mobj)
fixed_t x,y,z; fixed_t x,y,z;
mobj_t *mo2; mobj_t *mo2;
S_StartSound(NULL, sfx_befall); S_StartSound(0, sfx_befall);
z = mobj->floorz; z = mobj->floorz;
for (j = 0; j < 2; j++) for (j = 0; j < 2; j++)
@@ -4910,13 +4910,13 @@ static void P_Boss7Thinker(mobj_t *mobj)
P_DamageMobj(players[i].mo, mobj, mobj, 1); P_DamageMobj(players[i].mo, mobj, mobj, 1);
// Laugh // Laugh
S_StartSound(NULL, sfx_bewar1 + P_RandomKey(4)); S_StartSound(0, sfx_bewar1 + P_RandomKey(4));
} }
P_SetMobjState(mobj, mobj->info->spawnstate); P_SetMobjState(mobj, mobj->info->spawnstate);
} }
else if (mobj->state == &states[mobj->info->deathstate] && mobj->tics == mobj->state->tics) else if (mobj->state == &states[mobj->info->deathstate] && mobj->tics == mobj->state->tics)
S_StartSound(NULL, sfx_bedie1 + (P_RandomFixed() & 1)); S_StartSound(0, sfx_bedie1 + (P_RandomFixed() & 1));
} }
// Metal Sonic battle boss // Metal Sonic battle boss
@@ -6986,7 +6986,7 @@ static boolean P_MobjDeadThink(mobj_t *mobj)
fixed_t ns; fixed_t ns;
mobj_t *mo2; mobj_t *mo2;
i = P_RandomByte(); // grrrrrr i = P_RandomByte();
z = mobj->subsector->sector->floorheight + ((P_RandomByte()&63)*FRACUNIT); z = mobj->subsector->sector->floorheight + ((P_RandomByte()&63)*FRACUNIT);
for (j = 0; j < 2; j++) for (j = 0; j < 2; j++)
@@ -10034,7 +10034,7 @@ static precipmobj_t *P_SpawnPrecipMobj(fixed_t x, fixed_t y, fixed_t z, mobjtype
mobj->x = x; mobj->x = x;
mobj->y = y; mobj->y = y;
//mobj->flags = info->flags; mobj->flags = info->flags;
// do not set the state with P_SetMobjState, // do not set the state with P_SetMobjState,
// because action routines can not be called yet // because action routines can not be called yet
@@ -10044,7 +10044,7 @@ static precipmobj_t *P_SpawnPrecipMobj(fixed_t x, fixed_t y, fixed_t z, mobjtype
mobj->tics = st->tics; mobj->tics = st->tics;
mobj->sprite = st->sprite; mobj->sprite = st->sprite;
mobj->frame = st->frame; // FF_FRAMEMASK for frame, and other bits.. mobj->frame = st->frame; // FF_FRAMEMASK for frame, and other bits..
//mobj->anim_duration = (UINT16)st->var2; // only used if FF_ANIMATE is set mobj->anim_duration = (UINT16)st->var2; // only used if FF_ANIMATE is set
// set subsector and/or block links // set subsector and/or block links
P_SetPrecipitationThingPosition(mobj); P_SetPrecipitationThingPosition(mobj);
@@ -10711,7 +10711,7 @@ void P_SpawnPlayer(INT32 playernum)
// the dead body mobj retains the skin through the 'spritedef' override). // the dead body mobj retains the skin through the 'spritedef' override).
mobj->skin = &skins[p->skin]; mobj->skin = &skins[p->skin];
mobj->localskin = (p->localskin ? K_GetPlayerSkin(p) : NULL); mobj->localskin = (p->localskin ? K_GetPlayerSkin(p) : 0);
mobj->skinlocal = p->skinlocal; mobj->skinlocal = p->skinlocal;
mobj->health = p->health; mobj->health = p->health;
@@ -12354,9 +12354,8 @@ mobj_t *P_SPMAngle(mobj_t *source, mobjtype_t type, angle_t angle, UINT8 allowai
// //
void P_FlashPal(player_t *pl, UINT16 type, UINT16 duration) void P_FlashPal(player_t *pl, UINT16 type, UINT16 duration)
{ {
if (!pl || cv_reducevfx.value) // no palette flashing with reducevfx if (!pl)
return; return;
pl->flashcount = duration; pl->flashcount = duration;
pl->flashpal = type; pl->flashpal = type;
} }
+5 -2
View File
@@ -444,10 +444,12 @@ typedef struct precipmobj_s
// More drawing info: to determine current sprite. // More drawing info: to determine current sprite.
spritenum_t sprite; // used to find patch_t and flip value spritenum_t sprite; // used to find patch_t and flip value
UINT32 frame; // frame number, plus bits see p_pspr.h UINT32 frame; // frame number, plus bits see p_pspr.h
//UINT16 anim_duration; // for FF_ANIMATE states UINT16 anim_duration; // for FF_ANIMATE states
INT16 lightlevel; // Add to sector lightlevel, -255 - 255 INT16 lightlevel; // Add to sector lightlevel, -255 - 255
struct mprecipsecnode_s *touching_sectorlist; // a linked list of sectors where this object appears
struct subsector_s *subsector; // Subsector the mobj resides in. struct subsector_s *subsector; // Subsector the mobj resides in.
// The closest interval over all contacted sectors (or things). // The closest interval over all contacted sectors (or things).
@@ -456,10 +458,11 @@ typedef struct precipmobj_s
// Momentums, used to update position. // Momentums, used to update position.
fixed_t momx, momy, momz; fixed_t momx, momy, momz;
precipflag_t precipflags; fixed_t precipflags; // fixed_t so it uses the same spot as "pmomz" even as we use precipflags_t for it
state_t *state; state_t *state;
INT32 tics; // state tic counter INT32 tics; // state tic counter
UINT32 flags; // flags from mobjinfo tables
tic_t lastThink; tic_t lastThink;
} precipmobj_t; } precipmobj_t;
+2 -1
View File
@@ -1385,7 +1385,8 @@ static void Polyobj_rotateThings(polyobj_t *po, vector2_t origin, angle_t delta,
if (mo->player) if (mo->player)
{ {
P_ForceLocalAngle(mo->player, P_GetLocalAngle(mo->player) + delta); angle_t localangle = P_GetLocalAngle(mo->player);
P_ForceLocalAngle(mo->player, localangle + delta);
} }
} }
} }
+5 -3
View File
@@ -320,7 +320,9 @@ void P_AddGradesForMare(INT16 i, UINT8 mare, char *gtext)
*/ */
void P_DeleteGrades(INT16 i) void P_DeleteGrades(INT16 i)
{ {
Z_Free(mapheaderinfo[i]->grades); if (mapheaderinfo[i]->grades)
Z_Free(mapheaderinfo[i]->grades);
mapheaderinfo[i]->grades = NULL; mapheaderinfo[i]->grades = NULL;
mapheaderinfo[i]->numGradedMares = 0; mapheaderinfo[i]->numGradedMares = 0;
} }
@@ -1020,7 +1022,7 @@ void P_WriteThings(lumpnum_t lumpnum)
size_t i, length; size_t i, length;
mapthing_t *mt; mapthing_t *mt;
UINT8 *data; UINT8 *data;
savebuffer_t save = {}; savebuffer_t save = {0};
INT16 temp; INT16 temp;
data = W_CacheLumpNum(lumpnum, PU_LEVEL); data = W_CacheLumpNum(lumpnum, PU_LEVEL);
@@ -1164,7 +1166,7 @@ static void P_LoadLineDefs2(void)
for (; i--; ld++) for (; i--; ld++)
{ {
ld->frontsector = sides[ld->sidenum[0]].sector; //e6y: Can't be -1 here ld->frontsector = sides[ld->sidenum[0]].sector; //e6y: Can't be -1 here
ld->backsector = ld->sidenum[1] != 0xffff ? sides[ld->sidenum[1]].sector : NULL; ld->backsector = ld->sidenum[1] != 0xffff ? sides[ld->sidenum[1]].sector : 0;
// Repeat count for midtexture // Repeat count for midtexture
if ((ld->flags & ML_EFFECT5) && (ld->sidenum[1] != 0xffff)) if ((ld->flags & ML_EFFECT5) && (ld->sidenum[1] != 0xffff))
+24 -20
View File
@@ -1702,7 +1702,7 @@ void P_SwitchWeather(INT32 weathernum)
precipmobj->type = type; // proper set the type precipmobj->type = type; // proper set the type
precipmobj->info = &mobjinfo[type]; precipmobj->info = &mobjinfo[type];
//precipmobj->flags = mobjinfo[type].flags; precipmobj->flags = mobjinfo[type].flags;
st = &states[mobjinfo[type].spawnstate+z]; st = &states[mobjinfo[type].spawnstate+z];
@@ -3161,6 +3161,11 @@ void P_ProcessSpecialSector(player_t *player, sector_t *sector, sector_t *rovers
INT32 section1, section2, section3, section4; INT32 section1, section2, section3, section4;
INT32 special; INT32 special;
section1 = GETSECSPECIAL(sector->special, 1);
section2 = GETSECSPECIAL(sector->special, 2);
section3 = GETSECSPECIAL(sector->special, 3);
section4 = GETSECSPECIAL(sector->special, 4);
// Ignore spectators // Ignore spectators
if (player->spectator) if (player->spectator)
return; return;
@@ -3171,11 +3176,6 @@ void P_ProcessSpecialSector(player_t *player, sector_t *sector, sector_t *rovers
if (player->playerstate == PST_DEAD) if (player->playerstate == PST_DEAD)
return; return;
section1 = GETSECSPECIAL(sector->special, 1);
section2 = GETSECSPECIAL(sector->special, 2);
section3 = GETSECSPECIAL(sector->special, 3);
section4 = GETSECSPECIAL(sector->special, 4);
// Conveyor stuff // Conveyor stuff
if (section3 == 2 || section3 == 4) if (section3 == 2 || section3 == 4)
player->onconveyor = section3; player->onconveyor = section3;
@@ -4381,6 +4381,8 @@ static void P_PlayerOnSpecial3DFloor(player_t *player, sector_t *sector)
} }
} }
#define VDOORSPEED (FRACUNIT*2)
// //
// P_RunSpecialSectorCheck // P_RunSpecialSectorCheck
// //
@@ -4510,7 +4512,9 @@ void P_UpdateSpecials(void)
{ {
anim_t *anim; anim_t *anim;
INT32 i; INT32 i;
INT32 pic;
size_t j; size_t j;
levelflat_t *foundflats; // for flat animation levelflat_t *foundflats; // for flat animation
// LEVEL TIMER // LEVEL TIMER
@@ -4528,11 +4532,9 @@ void P_UpdateSpecials(void)
{ {
for (i = 0; i < anim->numpics; i++) for (i = 0; i < anim->numpics; i++)
{ {
pic = anim->basepic + ((leveltime/anim->speed + i) % anim->numpics);
if (anim->istexture) if (anim->istexture)
{ texturetranslation[anim->basepic+i] = pic;
texturetranslation[anim->basepic+i] = anim->basepic +
((leveltime/anim->speed + i) % anim->numpics);
}
} }
} }
@@ -4577,8 +4579,8 @@ static inline void P_AddFFloorToList(sector_t *sec, ffloor_t *ffloor)
if (!sec->ffloors) if (!sec->ffloors)
{ {
sec->ffloors = ffloor; sec->ffloors = ffloor;
ffloor->next = NULL; ffloor->next = 0;
ffloor->prev = NULL; ffloor->prev = 0;
return; return;
} }
@@ -4586,7 +4588,7 @@ static inline void P_AddFFloorToList(sector_t *sec, ffloor_t *ffloor)
rover->next = ffloor; rover->next = ffloor;
ffloor->prev = rover; ffloor->prev = rover;
ffloor->next = NULL; ffloor->next = 0;
} }
/** Adds a 3Dfloor. /** Adds a 3Dfloor.
@@ -4627,8 +4629,8 @@ static ffloor_t *P_AddFakeFloor(sector_t *sec, sector_t *sec2, line_t *master, f
if (sec2->numattached == 0) if (sec2->numattached == 0)
{ {
sec2->attached = Z_Malloc(sizeof(*sec2->attached) * sec2->maxattached, PU_STATIC, NULL); sec2->attached = Z_Malloc(sizeof (*sec2->attached) * sec2->maxattached, PU_STATIC, NULL);
sec2->attachedsolid = Z_Malloc(sizeof(*sec2->attachedsolid) * sec2->maxattached, PU_STATIC, NULL); sec2->attachedsolid = Z_Malloc(sizeof (*sec2->attachedsolid) * sec2->maxattached, PU_STATIC, NULL);
sec2->attached[0] = sec - sectors; sec2->attached[0] = sec - sectors;
sec2->numattached = 1; sec2->numattached = 1;
sec2->attachedsolid[0] = (flags & FF_SOLID); sec2->attachedsolid[0] = (flags & FF_SOLID);
@@ -4642,8 +4644,8 @@ static ffloor_t *P_AddFakeFloor(sector_t *sec, sector_t *sec2, line_t *master, f
if (sec2->numattached >= sec2->maxattached) if (sec2->numattached >= sec2->maxattached)
{ {
sec2->maxattached *= 2; sec2->maxattached *= 2;
sec2->attached = Z_Realloc(sec2->attached, sizeof(*sec2->attached) * sec2->maxattached, PU_STATIC, NULL); sec2->attached = Z_Realloc(sec2->attached, sizeof (*sec2->attached) * sec2->maxattached, PU_STATIC, NULL);
sec2->attachedsolid = Z_Realloc(sec2->attachedsolid, sizeof(*sec2->attachedsolid) * sec2->maxattached, PU_STATIC, NULL); sec2->attachedsolid = Z_Realloc(sec2->attachedsolid, sizeof (*sec2->attachedsolid) * sec2->maxattached, PU_STATIC, NULL);
} }
sec2->attached[sec2->numattached] = sec - sectors; sec2->attached[sec2->numattached] = sec - sectors;
sec2->attachedsolid[sec2->numattached] = (flags & FF_SOLID); sec2->attachedsolid[sec2->numattached] = (flags & FF_SOLID);
@@ -4651,7 +4653,7 @@ static ffloor_t *P_AddFakeFloor(sector_t *sec, sector_t *sec2, line_t *master, f
} }
// Add the floor // Add the floor
ffloor = Z_Calloc(sizeof(*ffloor), PU_LEVEL, NULL); ffloor = Z_Calloc(sizeof (*ffloor), PU_LEVEL, NULL);
ffloor->secnum = sec2 - sectors; ffloor->secnum = sec2 - sectors;
ffloor->target = sec; ffloor->target = sec;
ffloor->bottomheight = &sec2->floorheight; ffloor->bottomheight = &sec2->floorheight;
@@ -5466,6 +5468,7 @@ void P_SpawnSpecials(INT32 fromnetsave, boolean reloadinggamestate)
break; break;
case 10: // Vertical culling plane for sprites and FOFs case 10: // Vertical culling plane for sprites and FOFs
sec = sides[*lines[i].sidenum].sector - sectors;
for (s = -1; (s = P_FindSectorFromLineTag(lines + i, s)) >= 0 ;) for (s = -1; (s = P_FindSectorFromLineTag(lines + i, s)) >= 0 ;)
sectors[s].cullheight = &lines[i]; // This allows it to change in realtime! sectors[s].cullheight = &lines[i]; // This allows it to change in realtime!
break; break;
@@ -5986,7 +5989,7 @@ void P_SpawnSpecials(INT32 fromnetsave, boolean reloadinggamestate)
if (!virt) if (!virt)
virt = vres_GetMap(lastloadedmaplumpnum); virt = vres_GetMap(lastloadedmaplumpnum);
data = (UINT8*)vres_Find(virt, "SIDEDEFS")->data; data = (UINT8*) vres_Find(virt, "SIDEDEFS")->data;
for (b = 0; b < (INT16)numsides; b++) for (b = 0; b < (INT16)numsides; b++)
{ {
@@ -6218,7 +6221,8 @@ void P_SpawnSpecials(INT32 fromnetsave, boolean reloadinggamestate)
// Allocate each list // Allocate each list
for (i = 0; i < numsectors; i++) for (i = 0; i < numsectors; i++)
Z_Free(secthinkers[i].thinkers); if(secthinkers[i].thinkers)
Z_Free(secthinkers[i].thinkers);
Z_Free(secthinkers); Z_Free(secthinkers);
+3 -4
View File
@@ -728,12 +728,11 @@ void P_Ticker(boolean run)
if (cv_recordmultiplayerdemos.value) if (cv_recordmultiplayerdemos.value)
{ {
const INT32 axis = JoyAxis(AXISLOOKBACK, 1);
if (demo.savemode == DSM_NOTSAVING || demo.savemode == DSM_WILLAUTOSAVE) if (demo.savemode == DSM_NOTSAVING || demo.savemode == DSM_WILLAUTOSAVE)
{ if (demo.savebutton && demo.savebutton + 3*TICRATE < leveltime && (InputDown(gc_lookback, 1) || (cv_usejoystick[0].value && axis > 0)))
const INT32 axis = cv_usejoystick[0].value ? JoyAxis(AXISLOOKBACK, 1) : -1;
if (demo.savebutton && demo.savebutton + 3*TICRATE < leveltime && (InputDown(gc_lookback, 1) || (axis > 0)))
demo.savemode = DSM_TITLEENTRY; demo.savemode = DSM_TITLEENTRY;
}
// if there are no players left at all, stop demo recording // if there are no players left at all, stop demo recording
// Demos that that dont have any players crash during playback, which can happen with dedicated servers // Demos that that dont have any players crash during playback, which can happen with dedicated servers
+9 -8
View File
@@ -16,14 +16,14 @@
#include "doomdef.h" #include "doomdef.h"
#ifdef __GNUG__
#pragma interface
#endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#ifdef __GNUG__
#pragma interface
#endif
extern tic_t leveltime; extern tic_t leveltime;
// Called by G_Ticker. Carries out all thinking of enemies and players. // Called by G_Ticker. Carries out all thinking of enemies and players.
@@ -42,13 +42,14 @@ mobj_t *P_SetTarget2(mobj_t **mo, mobj_t *target
#endif #endif
); );
#ifdef __cplusplus
}
#endif
#ifdef PARANOIA #ifdef PARANOIA
#define P_SetTarget(...) P_SetTarget2(__VA_ARGS__, __FILE__, __LINE__) #define P_SetTarget(...) P_SetTarget2(__VA_ARGS__, __FILE__, __LINE__)
#else #else
#define P_SetTarget P_SetTarget2 #define P_SetTarget P_SetTarget2
#endif #endif
#ifdef __cplusplus
} // extern "C"
#endif
#endif #endif
+12 -1
View File
@@ -1822,6 +1822,7 @@ void P_DoJumpShield(player_t *player)
player->pflags &= ~PF_JUMPED; player->pflags &= ~PF_JUMPED;
//P_DoJump(player, false); //P_DoJump(player, false);
player->pflags &= ~PF_JUMPED;
player->secondjump = 0; player->secondjump = 0;
player->jumping = 0; player->jumping = 0;
player->pflags |= PF_THOKKED; player->pflags |= PF_THOKKED;
@@ -1893,6 +1894,7 @@ static void P_3dMovement(player_t *player)
ticcmd_t *cmd; ticcmd_t *cmd;
angle_t movepushangle, movepushsideangle; // Analog angle_t movepushangle, movepushsideangle; // Analog
fixed_t movepushforward = 0, movepushside = 0; fixed_t movepushforward = 0, movepushside = 0;
angle_t dangle; // replaces old quadrants bits
boolean analogmove = false; boolean analogmove = false;
fixed_t oldMagnitude, newMagnitude; fixed_t oldMagnitude, newMagnitude;
vector3_t totalthrust; vector3_t totalthrust;
@@ -1950,6 +1952,15 @@ static void P_3dMovement(player_t *player)
// Calculates player's speed based on distance-of-a-line formula // Calculates player's speed based on distance-of-a-line formula
player->speed = R_PointToDist2(0, 0, player->rmomx, player->rmomy); player->speed = R_PointToDist2(0, 0, player->rmomx, player->rmomy);
// Monster Iestyn - 04-11-13
// Quadrants are stupid, excessive and broken, let's do this a much simpler way!
// Get delta angle from rmom angle and player angle first
dangle = R_PointToAngle2(0,0, player->rmomx, player->rmomy) - player->mo->angle;
if (dangle > ANGLE_180) //flip to keep to one side
{
dangle = InvAngle(dangle);
}
// When sliding, don't allow forward/back // When sliding, don't allow forward/back
if (player->pflags & PF_SLIDING) if (player->pflags & PF_SLIDING)
cmd->forwardmove = 0; cmd->forwardmove = 0;
@@ -4453,7 +4464,7 @@ static INT32 Quaketilt(player_t *player)
lowb = FixedMul(lowb, player->mo->scale); lowb = FixedMul(lowb, player->mo->scale);
moma = FixedMul(FixedDiv(delta, ANGLE_90), tilt); moma = FixedMul(FixedDiv(delta, ANGLE_90), tilt);
speed = abs(player->mo->momx + player->mo->momy); speed = abs( player->mo->momx + player->mo->momy );
if (speed < lowb) if (speed < lowb)
{ {
+2
View File
@@ -14,6 +14,8 @@
#include "doomdef.h" #include "doomdef.h"
#include "g_game.h" #include "g_game.h"
#include <algorithm>
#include "r_fps.h" #include "r_fps.h"
#include "r_local.h" #include "r_local.h"
#include "r_state.h" #include "r_state.h"
+2 -1
View File
@@ -1720,7 +1720,8 @@ void R_InitData(void)
void R_ClearTextureNumCache(boolean btell) void R_ClearTextureNumCache(boolean btell)
{ {
Z_Free(tidcache); if (tidcache)
Z_Free(tidcache);
tidcache = NULL; tidcache = NULL;
if (btell) if (btell)
CONS_Debug(DBG_SETUP, "Fun Fact: There are %d textures used in this map.\n", tidcachelen); CONS_Debug(DBG_SETUP, "Fun Fact: There are %d textures used in this map.\n", tidcachelen);
+13 -9
View File
@@ -925,11 +925,11 @@ void R_ExecuteSetViewSize(void)
viewheight = vid.height; viewheight = vid.height;
if (splitscreen) if (splitscreen)
{
viewheight >>= 1; viewheight >>= 1;
if (splitscreen > 1) if (splitscreen > 1)
viewwidth >>= 1; {
viewwidth >>= 1;
} }
centerx = viewwidth/2; centerx = viewwidth/2;
@@ -956,9 +956,13 @@ void R_ExecuteSetViewSize(void)
screenheightarray[i] = (INT16)viewheight; screenheightarray[i] = (INT16)viewheight;
} }
Z_Free(ds_su); if (ds_su)
Z_Free(ds_sv); Z_Free(ds_su);
Z_Free(ds_sz); if (ds_sv)
Z_Free(ds_sv);
if (ds_sz)
Z_Free(ds_sz);
ds_su = ds_sv = ds_sz = NULL; ds_su = ds_sv = ds_sz = NULL;
memset(scalelight, 0xFF, sizeof(scalelight)); memset(scalelight, 0xFF, sizeof(scalelight));
@@ -1014,8 +1018,8 @@ static void R_InitViewMapping(void)
for (INT32 i = 0; i < j; i++) for (INT32 i = 0; i < j; i++)
{ {
fixed_t dy = abs(i - viewheight*8) << FRACBITS; fixed_t dy = (i - viewheight*8)<<FRACBITS;
dy = FixedMul(dy, fovtan); dy = FixedMul(abs(dy), fovtan);
yslopetab[i] = FixedDiv(centerx*FRACUNIT, dy); yslopetab[i] = FixedDiv(centerx*FRACUNIT, dy);
} }
} }
@@ -1083,7 +1087,7 @@ subsector_t *R_IsPointInSubsector(fixed_t x, fixed_t y)
ret = &subsectors[nodenum & ~NF_SUBSECTOR]; ret = &subsectors[nodenum & ~NF_SUBSECTOR];
for (i = 0; i < ret->numlines; i++) for (i = 0; i < ret->numlines; i++)
if (P_PointOnLineSide(x, y, segs[ret->firstline + i].linedef) != segs[ret->firstline + i].side) if (P_PointOnLineSide(x, y, segs[ret->firstline + i].linedef) != segs[ret->firstline + i].side)
return NULL; return 0;
return ret; return ret;
} }
Loaded 100 of 125 files, more files were not shown because too many files have changed in this diff. Show more