Merge branch 'cmake'

Building.md

@@ -0,0 +1,195 @@
+The Wipeout rewrite supports two different platform-backends:
+[SDL2](https://github.com/libsdl-org/SDL) and
+[Sokol](https://github.com/floooh/sokol).
+The only difference in features is that the SDL2 backend supports game
+controllers (joysticks, gamepads), while the Sokol backend does not.
+The Sokol backend is also only supported on macOS, Linux, Windows and Emscripten.
+
+## Building For Your Platform
+
+This project requires [CMake](https://cmake.org) to build and platform-specific
+libraries to run.
+Consult the following sections for how to acquire them for your platform:
+
+## *NIX
+
+Building on *NIX should be as simple as installing CMake, GLEW, and the
+necessary platform libraries from your package manager.
+For brevity, this guide assumes that the necessary development tools (i.e. a C
+complier, make) have already been installed.
+The SDL2 platform should only require the `sdl2` library and headers, whilst the
+Sokol platform requires the library/headers for:
+
+- `X11`
+- `Xi`
+- `Xcursor`
+- `ALSA`
+
+The following snippets list the specific package manager invocations for
+popluar *NIX OSs:
+
+**Debian/Ubuntu**
+
+```sh
+apt install cmake libglew-dev
+# For SDL2
+apt install libsdl2-dev
+# For Sokol
+apt install libx11-dev libxcursor-dev libxi-dev libasound2-dev
+```
+
+**Fedora**
+
+```sh
+dnf install cmake glew-devel
+# For SDL2
+dnf install SDL2-devel
+# For Sokol
+dnf install libx11-devel libxcursor-devel libxi-devel alsa-lib-devel
+```
+
+**Arch Linux**
+
+```sh
+pacman -S cmake glew
+# For SDL2
+pacman -S sdl2
+# For Sokol
+pacman install libx11 libxcursor libxi alsa-lib
+```
+
+**OpenSUSE**
+
+```sh
+zypper install cmake glew-devel
+# For SDL2
+zypper install SDL2-devel
+# For Sokol
+zypper install libx11-devel libxcursor-devel libxi-devel alsa-lib-devel
+```
+
+**FreeBSD**
+
+```sh
+pkg install cmake sdl2
+```
+
+**OpenBSD**
+
+```sh
+pkg_add cmake sdl2
+```
+
+Note that the Sokol platform is not supported on the BSDs, since the Sokol
+headers themselves do not support these Operating Systems.
+
+With the packages installed, you can now setup and build:
+
+```sh
+cmake -S path/to/wipeout-rewrite -B path/to/build-dir
+cmake --build path/to/build-dir
+```
+
+## macOS
+
+Currently only the SDL2 platform works.
+macOS is very picky about the GLSL shader version when compiling with Sokol and
+OpenGL3.3; it shouldn't be too difficult to get it working, but will probably
+require a bunch of `#ifdefs` for SDL and WASM.
+Pull-requests welcome!
+
+It is recommended to use [Homebrew](https://brew.sh) to fetch the required
+software, other solutions (e.g. MacPorts) may work but have not been tested.
+Using homebrew, you can install the required software with the following:
+
+```sh
+brew install cmake
+# For SDL2
+brew install sdl2
+# Nothing extra needed for Sokol
+```
+
+With the packages installed, you can now setup and build:
+
+```sh
+cmake -S path/to/wipeout-rewrite -B path/to/build-dir \
+	-DCMAKE_PREFIX_PATH="$(brew --prefix sdl2)"
+cmake --build path/to/build-dir
+```
+
+## Windows
+
+### clang-cl
+
+Building natively on Windows requires a more complicated setup. The source code
+relies on GCC extensions that are not supported by `msvc`, which requires the
+use of `clang-cl`.
+The simplest way to get a build environment with `clang-cl` is to download and
+install [Visual Studio](https://visualstudio.microsoft.com/downloads/) (2022 at
+the time of writing) with the "Desktop development with C++" option selected.
+Also make sure to select "Clang C++ compiler for Windows" in "Individual
+Components" if it hasn't been already.
+
+The next step is to acquire development versions of SDL2 and GLEW.
+The easiest way is to install [vcpkg](https://vcpkg.io) and let Visual Studio's
+integration build and install it for you.
+Follow the [vcpkg "Getting Started" guide](https://vcpkg.io/en/getting-started)
+and integrate it with Visual Studio.
+
+Finally, open Visual Studio, select "Open a local folder", and navigate to the
+directory where you have cloned this repo.
+Visual Studio should automatically configure itself to build with CMake, and
+build the necessary libraries using vcpkg.
+Since this repository contains a `CMakeSettings.json` file, there should already
+be CMake configurations listed in the menubar dropdown.
+When adding a new configuration, make sure to use the `clang_cl` toolsets.
+Select the config you want from the list and build using `F7`, the build
+artifacts should be under `path\to\wipeout-rewrite\build`.
+
+### MSYS2
+
+Building with [MSYS2](https://www.msys2.org/) is sightly easier but still
+involves a bit of configuration.
+Download and install MSYS2 using the installer, and enter a MSYS2 environment
+using the start menu. For this guide we're using the `UCRT` environment, but the
+others work just as well.
+
+Install the following packages using `pacman`:
+
+```sh
+pacman -S mingw-w64-ucrt-x86_64-{toolchain,cmake,SDL2,glew}
+```
+
+With the packages installed, you can now setup and build:
+
+```sh
+cmake -S path/to/wipeout-rewrite -B path/to/build-dir
+cmake --build path/to/build-dir
+```
+
+## Emscripten
+
+Download and install the [Emscripten SDK](https://emscripten.org/docs/getting_started/downloads.html),
+so that `emcc` and `emcmake` is in your path.
+Linux users may find it easier to install using their distro's package manager
+if it is available.
+Note that only the Sokol platform will work for WebAssembly builds, so make sure
+to select it at compile time using `-DPLATFORM=Sokol`.
+
+With the SDK installed, you can now setup and build:
+
+```sh
+emcmake cmake -S path/to/wipeout-rewrite -B path/to/build-dir
+emcmake cmake --build path/to/build-dir
+```
+
+## Build Flags
+
+The following is a table for project specific build flags using CMake:
+
+| Flag             | Description                                                     | Options                                                                              | Default                                                                                     |
+|------------------|-----------------------------------------------------------------|--------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
+| `PLATFORM`       | The platform to build for.                                      | `SDL2`, `Sokol`                                                                      | `SDL2`                                                                                      |
+| `RENDERER`       | Graphics renderer.                                              | `GL` for OpenGL 3, `GLES2` for OpenGL ES 2, `Software` for a pure software renderer. | `GL`                                                                                        |
+| `USE_GLVND`      | Link against the OpenGL Vendor Neutral Dispatch libraries.      | `On`, `Off`                                                                          | `On`, falling back to `Off` if the libraries aren't found or an OpenGL renderer isn't used. |
+| `MINIMAL_BUNDLE` | Do not include the music/intro video when building for the web. | `On`, `Off`                                                                          | `Off`                                                                                       |

CMakeLists.txt

@@ -0,0 +1,211 @@
+cmake_minimum_required(VERSION 3.13 FATAL_ERROR)
+project(wipeout-rewrite)
+
+include(GNUInstallDirs)
+include(CMakeDependentOption)
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
+
+if("${CMAKE_SYSTEM_NAME}" STREQUAL "Emscripten")
+	set(EMSCRIPTEN true)
+endif()
+
+set(platform_options "SDL2" "Sokol")
+set(PLATFORM "SDL2" CACHE STRING "Graphics platform to handle input/output")
+set_property(CACHE PLATFORM PROPERTY STRINGS "${platform_options}")
+if(NOT PLATFORM IN_LIST platform_options)
+	message(FATAL_ERROR "PLATFORM must be one of ${platform_options}")
+endif()
+
+set(renderer_options "GL" "GLES2" "SOFTWARE")
+set(gl_renderers "GL" "GLES2")
+set(RENDERER "GL" CACHE STRING "Graphics rendering backend")
+set_property(CACHE RENDERER PROPERTY STRINGS "${renderer_options}")
+if(NOT RENDERER IN_LIST renderer_options)
+	message(FATAL_ERROR "RENDERER must be one of ${renderer_options}")
+endif()
+if(RENDERER IN_LIST gl_renderers)
+	set(using_gl true)
+endif()
+
+cmake_dependent_option(USE_GLVND "Link against modern GLVND ABIs" OFF "using_gl;LINUX" ON)
+cmake_dependent_option(MINIMAL_BUNDLE "Do not include music/movies for web builds" OFF "EMSCRIPTEN" OFF)
+
+find_package(OpenGL)
+find_package(GLEW)
+find_package(SDL2)
+
+set(common_src
+	src/wipeout/camera.c
+	src/wipeout/camera.h
+	src/wipeout/droid.c
+	src/wipeout/droid.h
+	src/wipeout/game.c
+	src/wipeout/game.h
+	src/wipeout/hud.c
+	src/wipeout/hud.h
+	src/wipeout/image.c
+	src/wipeout/image.h
+	src/wipeout/ingame_menus.c
+	src/wipeout/ingame_menus.h
+	src/wipeout/intro.c
+	src/wipeout/intro.h
+	src/wipeout/main_menu.c
+	src/wipeout/main_menu.h
+	src/wipeout/menu.c
+	src/wipeout/menu.h
+	src/wipeout/object.c
+	src/wipeout/object.h
+	src/wipeout/particle.c
+	src/wipeout/particle.h
+	src/wipeout/race.c
+	src/wipeout/race.h
+	src/wipeout/scene.c
+	src/wipeout/scene.h
+	src/wipeout/sfx.c
+	src/wipeout/sfx.h
+	src/wipeout/ship.c
+	src/wipeout/ship.h
+	src/wipeout/ship_ai.c
+	src/wipeout/ship_ai.h
+	src/wipeout/ship_player.c
+	src/wipeout/ship_player.h
+	src/wipeout/title.c
+	src/wipeout/title.h
+	src/wipeout/track.c
+	src/wipeout/track.h
+	src/wipeout/ui.c
+	src/wipeout/ui.h
+	src/wipeout/weapon.c
+	src/wipeout/weapon.h
+	src/input.c
+	src/input.h
+	src/mem.c
+	src/mem.h
+	src/platform.h
+	src/render.h
+	src/system.c
+	src/system.h
+	src/types.c
+	src/types.h
+	src/utils.c
+	src/utils.h
+
+	packaging/windows/wipeout.exe.manifest
+	packaging/windows/wipeout.rc
+)
+
+add_executable(wipeout WIN32 ${common_src})
+set_property(TARGET wipeout PROPERTY C_STANDARD 11)
+target_include_directories(wipeout PRIVATE src)
+target_include_directories(wipeout SYSTEM PRIVATE src/libs)
+target_compile_options(wipeout PRIVATE
+	$<$<CXX_COMPILER_ID:MSVC>:/W4>
+	$<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-Wall -Wextra>
+)
+
+if(WIN32)
+	target_compile_definitions(wipeout PRIVATE
+		"NOMINMAX"
+		"_USE_MATH_DEFINES"
+		"_CRT_SECURE_NO_WARNINGS"
+	)
+elseif(APPLE)
+	target_compile_definitions(wipeout PRIVATE
+		"_THREAD_SAFE"
+		"GL_SILENCE_DEPRECATION"
+	)
+	target_link_libraries(wipeout PUBLIC "-framework Foundation")
+	set_source_files_properties(src/platform_sokol.c PROPERTIES COMPILE_FLAGS "-x objective-c")
+	if("${PLATFORM}" STREQUAL Sokol)
+		target_link_libraries(wipeout PUBLIC
+			"-framework Cocoa"
+			"-framework QuartzCore"
+			"-framework AudioToolbox"
+		)
+	endif()
+elseif(EMSCRIPTEN)
+	# Emscripten's CMake modules don't define targets like the standard
+	# ones do, so we define them ourselves here.
+	add_library(GLEW::GLEW INTERFACE IMPORTED)
+	add_library(OpenGL::GL INTERFACE IMPORTED)
+	if (NOT TARGET SDL2::Main)
+		add_library(SDL2::Main INTERFACE IMPORTED)
+	endif()
+	set_target_properties(OpenGL::GL PROPERTIES 
+		IMPORTED_LIBNAME "GL"
+	)
+	set_target_properties(GLEW::GLEW PROPERTIES
+		IMPORTED_LIBNAME "GLEW"
+	)
+	set_target_properties(SDL2::Main PROPERTIES
+		IMPORTED_LIBNAME "SDL2"
+		INTERFACE_COMPILE_OPTIONS "SHELL:-s USE_SDL=2"
+		INTERFACE_LINK_LIBRARIES  "SHELL:-s USE_SDL=2"
+	)
+
+	target_link_options(wipeout PRIVATE
+		"SHELL:-s ALLOW_MEMORY_GROWTH=1"
+		"SHELL:-s ENVIRONMENT=web"
+		"SHELL:-s FORCE_FILESYSTEM"
+		"SHELL:--preload-file ${CMAKE_SOURCE_DIR}/wipeout/@/wipeout"
+	)
+	if(MINIMAL_BUNDLE)
+		target_link_options(wipeout PRIVATE
+			"SHELL:--exclude-file ${CMAKE_SOURCE_DIR}/wipeout/music"
+			"SHELL:--exclude-file ${CMAKE_SOURCE_DIR}/intro.mpeg"
+		)
+	endif()
+
+	configure_file("${CMAKE_SOURCE_DIR}/src/wasm-index.html" "game.html" COPYONLY)
+elseif(UNIX)
+	target_link_libraries(wipeout PUBLIC m)
+	if (PLATFORM STREQUAL "Sokol" AND LINUX)
+		find_package(Threads REQUIRED)
+		find_package(X11 REQUIRED)
+		find_package(ALSA REQUIRED)
+		target_link_libraries(wipeout PUBLIC
+			X11::X11
+			X11::Xcursor
+			Threads::Threads
+			X11::Xi
+			dl
+			ALSA::ALSA
+		)
+	endif()
+endif()
+
+if(using_gl)
+	target_compile_definitions(wipeout PRIVATE "RENDERER_GL")
+	target_sources(wipeout PRIVATE src/render_gl.c)
+
+	target_include_directories(wipeout PUBLIC ${OPENGL_INCLUDE_DIR})
+	if (USE_GLES2)
+		target_compile_definitions(wipeout PRIVATE "USE_GLES2")
+		if (TARGET OpenGL::GLES2)
+			target_link_libraries(wipeout PUBLIC OpenGL::GLES2)
+		endif()
+	endif()
+
+	if(USE_GLVND AND TARGET OpenGL::OpenGL)
+		target_link_libraries(wipeout PUBLIC OpenGL::OpenGL)
+	else()
+		target_link_libraries(wipeout PUBLIC OpenGL::GL)
+	endif()
+
+	if(NOT APPLE)
+		target_include_directories(wipeout PRIVATE ${GLEW_INCLUDE_DIRS})
+		target_link_libraries(wipeout PRIVATE GLEW::GLEW)
+	endif()
+elseif("${RENDERER}" STREQUAL "SOFTWARE")
+	target_compile_definitions(wipeout PRIVATE "RENDERER_SOFTWARE")
+	target_sources(wipeout PRIVATE src/render_software.c)
+endif()
+
+if("${PLATFORM}" STREQUAL SDL2)
+	target_sources(wipeout PRIVATE src/platform_sdl.c)
+	target_link_libraries(wipeout PUBLIC SDL2::Main)
+elseif("${PLATFORM}" STREQUAL Sokol)
+	target_sources(wipeout PRIVATE src/platform_sokol.c)
+endif()
+
+install(TARGETS wipeout)

CMakeSettings.json

@@ -0,0 +1,71 @@
+{
+  "configurations": [
+    {
+      "name": "x64-Clang-Debug",
+      "generator": "Ninja",
+      "configurationType": "Debug",
+      "buildRoot": "${projectDir}\\build\\${name}",
+      "installRoot": "${projectDir}install\\${name}",
+      "cmakeCommandArgs": "",
+      "buildCommandArgs": "",
+      "ctestCommandArgs": "",
+      "inheritEnvironments": [ "clang_cl_x64_x64" ],
+      "intelliSenseMode": "windows-clang-x64"
+    },
+    {
+      "name": "x64-Clang-Release",
+      "generator": "Ninja",
+      "configurationType": "RelWithDebInfo",
+      "buildRoot": "${projectDir}\\build\\${name}",
+      "installRoot": "${projectDir}install\\${name}",
+      "cmakeCommandArgs": "",
+      "buildCommandArgs": "",
+      "ctestCommandArgs": "",
+      "inheritEnvironments": [ "clang_cl_x64_x64" ],
+    },
+    {
+      "name": "x86-Clang-Debug",
+      "generator": "Ninja",
+      "configurationType": "Debug",
+      "buildRoot": "${projectDir}\\build\\${name}",
+      "installRoot": "${projectDir}install\\${name}",
+      "cmakeCommandArgs": "",
+      "buildCommandArgs": "",
+      "ctestCommandArgs": "",
+      "inheritEnvironments": [ "clang_cl_x86" ]
+    },
+    {
+      "name": "x86-Clang-Release",
+      "generator": "Ninja",
+      "configurationType": "RelWithDebInfo",
+      "buildRoot": "${projectDir}\\build\\${name}",
+      "installRoot": "${projectDir}install\\${name}",
+      "cmakeCommandArgs": "",
+      "buildCommandArgs": "",
+      "ctestCommandArgs": "",
+      "inheritEnvironments": [ "clang_cl_x86" ]
+    },
+    {
+      "name": "arm64-Clang-Debug",
+      "generator": "Ninja",
+      "configurationType": "Debug",
+      "buildRoot": "${projectDir}\\build\\${name}",
+      "installRoot": "${projectDir}install\\${name}",
+      "cmakeCommandArgs": "",
+      "buildCommandArgs": "",
+      "ctestCommandArgs": "",
+      "inheritEnvironments": [ "clang_cl_arm64_x64" ]
+    },
+    {
+      "name": "arm64-Clang-Release",
+      "generator": "Ninja",
+      "configurationType": "RelWithDebInfo",
+      "buildRoot": "${projectDir}\\build\\${name}",
+      "installRoot": "${projectDir}install\\${name}",
+      "cmakeCommandArgs": "",
+      "buildCommandArgs": "",
+      "ctestCommandArgs": "",
+      "inheritEnvironments": [ "clang_cl_arm64_x64" ]
+    }
+  ]
+}

README.md

@@ -6,72 +6,11 @@ Play here: https://phoboslab.org/wipegame/
 
 More info in my blog: https://phoboslab.org/log/2023/08/rewriting-wipeout
 
-
 ⚠️ Work in progress. Expect bugs.
 
-
 ## Building
 
-The game currently supports two different platform-backends: [SDL2](https://github.com/libsdl-org/SDL) and [Sokol](https://github.com/floooh/sokol). The only difference in features is that the SDL2 backend supports game controllers (joysticks, gamepads), while the Sokol backend does not.
+See [Building.md](Building.md) for more info.
-
-
-### Linux
-
-#### Ubuntu
-
-```
-# for SDL2 backend
-apt install libsdl2-dev libglew-dev
-make sdl
-```
-
-```
-# for Sokol backend
-apt install libx11-dev libxcursor-dev libxi-dev libasound2-dev
-make sokol
-```
-
-#### Fedora
-
-```
-# for SDL2 backend
-dnf install SDL2-devel glew-devel
-make sdl
-```
-
-```
-# for Sokol backend
-dnf install libX11-devel libXi-devel alsa-lib-devel glew-devel libXcursor-devel
-make sokol
-```
-
-### macOS
-
-Currently only the SDL2 backend works. macOS is very picky about the GLSL shader version when compiling with Sokol and OpenGL3.3; it shouldn't be too difficult to get it working, but will probably require a bunch of `#ifdefs` for SDL and WASM. PRs welcome!
-
-```
-brew install sdl2 glew
-make sdl
-```
-
-### Windows
-
-In theory both backends should work on Windows, but the Makefile is missing the proper compiler flags. Please send a PR!
-
-_todo_
-
-
-### WASM
-
-Install [emscripten](https://emscripten.org/) and activate emsdk, so that `emcc` is in your `PATH`. The WASM version automatically
-selects the Sokol backend. I'm not sure what needs to be done to make the SDL2 backend work with WASM.
-
-```
-make wasm
-```
-
-This builds the minimal version (no music, no intro) as well as the full version.
-
 
 ### Flags
 

cmake/FindSDL2.cmake

@@ -0,0 +1,388 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+#  Copyright 2019 Amine Ben Hassouna <amine.benhassouna@gmail.com>
+#  Copyright 2000-2019 Kitware, Inc. and Contributors
+#  All rights reserved.
+
+#  Redistribution and use in source and binary forms, with or without
+#  modification, are permitted provided that the following conditions
+#  are met:
+
+#  * Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+
+#  * Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+
+#  * Neither the name of Kitware, Inc. nor the names of Contributors
+#    may be used to endorse or promote products derived from this
+#    software without specific prior written permission.
+
+#  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+#  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+#  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+#  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+#  HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+#  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+#  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+#  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+#  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+#  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+#  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#[=======================================================================[.rst:
+FindSDL2
+--------
+
+Locate SDL2 library
+
+This module defines the following 'IMPORTED' targets:
+
+::
+
+  SDL2::Core
+    The SDL2 library, if found.
+    Libraries should link to SDL2::Core
+
+  SDL2::Main
+    The SDL2main library, if found.
+    Applications should link to SDL2::Main instead of SDL2::Core
+
+
+
+This module will set the following variables in your project:
+
+::
+
+  SDL2_LIBRARIES, the name of the library to link against
+  SDL2_INCLUDE_DIRS, where to find SDL.h
+  SDL2_FOUND, if false, do not try to link to SDL2
+  SDL2MAIN_FOUND, if false, do not try to link to SDL2main
+  SDL2_VERSION_STRING, human-readable string containing the version of SDL2
+
+
+
+This module responds to the following cache variables:
+
+::
+
+  SDL2_PATH
+    Set a custom SDL2 Library path (default: empty)
+
+  SDL2_NO_DEFAULT_PATH
+    Disable search SDL2 Library in default path.
+      If SDL2_PATH (default: ON)
+      Else (default: OFF)
+
+  SDL2_INCLUDE_DIR
+    SDL2 headers path.
+
+  SDL2_LIBRARY
+    SDL2 Library (.dll, .so, .a, etc) path.
+
+  SDL2MAIN_LIBRAY
+    SDL2main Library (.a) path.
+
+  SDL2_BUILDING_LIBRARY
+    This flag is useful only when linking to SDL2_LIBRARIES insead of
+    SDL2::Main. It is required only when building a library that links to
+    SDL2_LIBRARIES, because only applications need main() (No need to also
+    link to SDL2main).
+    If this flag is defined, then no SDL2main will be added to SDL2_LIBRARIES
+    and no SDL2::Main target will be created.
+
+
+Don't forget to include SDLmain.h and SDLmain.m in your project for the
+OS X framework based version. (Other versions link to -lSDL2main which
+this module will try to find on your behalf.) Also for OS X, this
+module will automatically add the -framework Cocoa on your behalf.
+
+
+Additional Note: If you see an empty SDL2_LIBRARY in your project
+configuration, it means CMake did not find your SDL2 library
+(SDL2.dll, libsdl2.so, SDL2.framework, etc). Set SDL2_LIBRARY to point
+to your SDL2 library, and  configure again. Similarly, if you see an
+empty SDL2MAIN_LIBRARY, you should set this value as appropriate. These
+values are used to generate the final SDL2_LIBRARIES variable and the
+SDL2::Core and SDL2::Main targets, but when these values are unset,
+SDL2_LIBRARIES, SDL2::Core and SDL2::Main does not get created.
+
+
+$SDL2DIR is an environment variable that would correspond to the
+./configure --prefix=$SDL2DIR used in building SDL2.  l.e.galup 9-20-02
+
+
+
+Created by Amine Ben Hassouna:
+  Adapt FindSDL.cmake to SDL2 (FindSDL2.cmake).
+  Add cache variables for more flexibility:
+    SDL2_PATH, SDL2_NO_DEFAULT_PATH (for details, see doc above).
+  Mark 'Threads' as a required dependency for non-OSX systems.
+  Modernize the FindSDL2.cmake module by creating specific targets:
+    SDL2::Core and SDL2::Main (for details, see doc above).
+
+
+Original FindSDL.cmake module:
+  Modified by Eric Wing.  Added code to assist with automated building
+  by using environmental variables and providing a more
+  controlled/consistent search behavior.  Added new modifications to
+  recognize OS X frameworks and additional Unix paths (FreeBSD, etc).
+  Also corrected the header search path to follow "proper" SDL
+  guidelines.  Added a search for SDLmain which is needed by some
+  platforms.  Added a search for threads which is needed by some
+  platforms.  Added needed compile switches for MinGW.
+
+On OSX, this will prefer the Framework version (if found) over others.
+People will have to manually change the cache value of SDL2_LIBRARY to
+override this selection or set the SDL2_PATH variable or the CMake
+environment CMAKE_INCLUDE_PATH to modify the search paths.
+
+Note that the header path has changed from SDL/SDL.h to just SDL.h
+This needed to change because "proper" SDL convention is #include
+"SDL.h", not <SDL/SDL.h>.  This is done for portability reasons
+because not all systems place things in SDL/ (see FreeBSD).
+#]=======================================================================]
+
+# Define options for searching SDL2 Library in a custom path
+
+set(SDL2_PATH "" CACHE STRING "Custom SDL2 Library path")
+
+set(_SDL2_NO_DEFAULT_PATH OFF)
+if(SDL2_PATH)
+    set(_SDL2_NO_DEFAULT_PATH ON)
+endif()
+
+set(SDL2_NO_DEFAULT_PATH ${_SDL2_NO_DEFAULT_PATH}
+        CACHE BOOL "Disable search SDL2 Library in default path")
+unset(_SDL2_NO_DEFAULT_PATH)
+
+set(SDL2_NO_DEFAULT_PATH_CMD)
+if(SDL2_NO_DEFAULT_PATH)
+    set(SDL2_NO_DEFAULT_PATH_CMD NO_DEFAULT_PATH)
+endif()
+
+# Search for the SDL2 include directory
+find_path(SDL2_INCLUDE_DIR SDL.h
+        HINTS
+        ENV SDL2DIR
+        ${SDL2_NO_DEFAULT_PATH_CMD}
+        PATH_SUFFIXES SDL2
+        # path suffixes to search inside ENV{SDL2DIR}
+        include/SDL2 include
+        PATHS ${SDL2_PATH}
+        DOC "Where the SDL2 headers can be found"
+        )
+
+set(SDL2_INCLUDE_DIRS "${SDL2_INCLUDE_DIR}")
+
+if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+    set(VC_LIB_PATH_SUFFIX lib/x64)
+else()
+    set(VC_LIB_PATH_SUFFIX lib/x86)
+endif()
+
+# SDL-2.0 is the name used by FreeBSD ports...
+# don't confuse it for the version number.
+find_library(SDL2_LIBRARY
+        NAMES SDL2 SDL-2.0
+        HINTS
+        ENV SDL2DIR
+        ${SDL2_NO_DEFAULT_PATH_CMD}
+        PATH_SUFFIXES lib ${VC_LIB_PATH_SUFFIX}
+        PATHS ${SDL2_PATH}
+        DOC "Where the SDL2 Library can be found"
+        )
+
+set(SDL2_LIBRARIES "${SDL2_LIBRARY}")
+
+if(NOT SDL2_BUILDING_LIBRARY)
+    if(NOT SDL2_INCLUDE_DIR MATCHES ".framework")
+        # Non-OS X framework versions expect you to also dynamically link to
+        # SDL2main. This is mainly for Windows and OS X. Other (Unix) platforms
+        # seem to provide SDL2main for compatibility even though they don't
+        # necessarily need it.
+
+        if(SDL2_PATH)
+            set(SDL2MAIN_LIBRARY_PATHS "${SDL2_PATH}")
+        endif()
+
+        if(NOT SDL2_NO_DEFAULT_PATH)
+            set(SDL2MAIN_LIBRARY_PATHS
+                    /sw
+                    /opt/local
+                    /opt/csw
+                    /opt
+                    "${SDL2MAIN_LIBRARY_PATHS}"
+                    )
+        endif()
+
+        find_library(SDL2MAIN_LIBRARY
+                NAMES SDL2main
+                HINTS
+                ENV SDL2DIR
+                ${SDL2_NO_DEFAULT_PATH_CMD}
+                PATH_SUFFIXES lib ${VC_LIB_PATH_SUFFIX}
+                PATHS ${SDL2MAIN_LIBRARY_PATHS}
+                DOC "Where the SDL2main library can be found"
+                )
+        unset(SDL2MAIN_LIBRARY_PATHS)
+    endif()
+endif()
+
+# SDL2 may require threads on your system.
+# The Apple build may not need an explicit flag because one of the
+# frameworks may already provide it.
+# But for non-OSX systems, I will use the CMake Threads package.
+if(NOT APPLE)
+    find_package(Threads QUIET)
+    if(NOT Threads_FOUND)
+        set(SDL2_THREADS_NOT_FOUND "Could NOT find Threads (Threads is required by SDL2).")
+        if(SDL2_FIND_REQUIRED)
+            message(FATAL_ERROR ${SDL2_THREADS_NOT_FOUND})
+        else()
+            if(NOT SDL2_FIND_QUIETLY)
+                message(STATUS ${SDL2_THREADS_NOT_FOUND})
+            endif()
+            return()
+        endif()
+        unset(SDL2_THREADS_NOT_FOUND)
+    endif()
+endif()
+
+# MinGW needs an additional link flag, -mwindows
+# It's total link flags should look like -lmingw32 -lSDL2main -lSDL2 -mwindows
+if(MINGW)
+    set(MINGW32_LIBRARY mingw32 "-mwindows" CACHE STRING "link flags for MinGW")
+endif()
+
+if(SDL2_LIBRARY)
+    # For SDL2main
+    if(SDL2MAIN_LIBRARY AND NOT SDL2_BUILDING_LIBRARY)
+        list(FIND SDL2_LIBRARIES "${SDL2MAIN_LIBRARY}" _SDL2_MAIN_INDEX)
+        if(_SDL2_MAIN_INDEX EQUAL -1)
+            set(SDL2_LIBRARIES "${SDL2MAIN_LIBRARY}" ${SDL2_LIBRARIES})
+        endif()
+        unset(_SDL2_MAIN_INDEX)
+    endif()
+
+    # For OS X, SDL2 uses Cocoa as a backend so it must link to Cocoa.
+    # CMake doesn't display the -framework Cocoa string in the UI even
+    # though it actually is there if I modify a pre-used variable.
+    # I think it has something to do with the CACHE STRING.
+    # So I use a temporary variable until the end so I can set the
+    # "real" variable in one-shot.
+    if(APPLE)
+        set(SDL2_LIBRARIES ${SDL2_LIBRARIES} -framework Cocoa)
+    endif()
+
+    # For threads, as mentioned Apple doesn't need this.
+    # In fact, there seems to be a problem if I used the Threads package
+    # and try using this line, so I'm just skipping it entirely for OS X.
+    if(NOT APPLE)
+        set(SDL2_LIBRARIES ${SDL2_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
+    endif()
+
+    # For MinGW library
+    if(MINGW)
+        set(SDL2_LIBRARIES ${MINGW32_LIBRARY} ${SDL2_LIBRARIES})
+    endif()
+
+endif()
+
+# Read SDL2 version
+if(SDL2_INCLUDE_DIR AND EXISTS "${SDL2_INCLUDE_DIR}/SDL_version.h")
+    file(STRINGS "${SDL2_INCLUDE_DIR}/SDL_version.h" SDL2_VERSION_MAJOR_LINE REGEX "^#define[ \t]+SDL_MAJOR_VERSION[ \t]+[0-9]+$")
+    file(STRINGS "${SDL2_INCLUDE_DIR}/SDL_version.h" SDL2_VERSION_MINOR_LINE REGEX "^#define[ \t]+SDL_MINOR_VERSION[ \t]+[0-9]+$")
+    file(STRINGS "${SDL2_INCLUDE_DIR}/SDL_version.h" SDL2_VERSION_PATCH_LINE REGEX "^#define[ \t]+SDL_PATCHLEVEL[ \t]+[0-9]+$")
+    string(REGEX REPLACE "^#define[ \t]+SDL_MAJOR_VERSION[ \t]+([0-9]+)$" "\\1" SDL2_VERSION_MAJOR "${SDL2_VERSION_MAJOR_LINE}")
+    string(REGEX REPLACE "^#define[ \t]+SDL_MINOR_VERSION[ \t]+([0-9]+)$" "\\1" SDL2_VERSION_MINOR "${SDL2_VERSION_MINOR_LINE}")
+    string(REGEX REPLACE "^#define[ \t]+SDL_PATCHLEVEL[ \t]+([0-9]+)$" "\\1" SDL2_VERSION_PATCH "${SDL2_VERSION_PATCH_LINE}")
+    set(SDL2_VERSION_STRING ${SDL2_VERSION_MAJOR}.${SDL2_VERSION_MINOR}.${SDL2_VERSION_PATCH})
+    unset(SDL2_VERSION_MAJOR_LINE)
+    unset(SDL2_VERSION_MINOR_LINE)
+    unset(SDL2_VERSION_PATCH_LINE)
+    unset(SDL2_VERSION_MAJOR)
+    unset(SDL2_VERSION_MINOR)
+    unset(SDL2_VERSION_PATCH)
+endif()
+
+include(FindPackageHandleStandardArgs)
+
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(SDL2
+        REQUIRED_VARS SDL2_LIBRARY SDL2_INCLUDE_DIR
+        VERSION_VAR SDL2_VERSION_STRING)
+
+if(SDL2MAIN_LIBRARY)
+    FIND_PACKAGE_HANDLE_STANDARD_ARGS(SDL2main
+            REQUIRED_VARS SDL2MAIN_LIBRARY SDL2_INCLUDE_DIR
+            VERSION_VAR SDL2_VERSION_STRING)
+endif()
+
+
+mark_as_advanced(SDL2_PATH
+        SDL2_NO_DEFAULT_PATH
+        SDL2_LIBRARY
+        SDL2MAIN_LIBRARY
+        SDL2_INCLUDE_DIR
+        SDL2_BUILDING_LIBRARY)
+
+
+# SDL2:: targets (SDL2::Core and SDL2::Main)
+if(SDL2_FOUND)
+
+    # SDL2::Core target
+    if(SDL2_LIBRARY AND NOT TARGET SDL2::Core)
+        add_library(SDL2::Core UNKNOWN IMPORTED)
+        set_target_properties(SDL2::Core PROPERTIES
+                IMPORTED_LOCATION "${SDL2_LIBRARY}"
+                INTERFACE_INCLUDE_DIRECTORIES "${SDL2_INCLUDE_DIR}")
+
+        if(APPLE)
+            # For OS X, SDL2 uses Cocoa as a backend so it must link to Cocoa.
+            # For more details, please see above.
+            set_property(TARGET SDL2::Core APPEND PROPERTY
+                    INTERFACE_LINK_OPTIONS -framework Cocoa)
+        else()
+            # For threads, as mentioned Apple doesn't need this.
+            # For more details, please see above.
+            set_property(TARGET SDL2::Core APPEND PROPERTY
+                    INTERFACE_LINK_LIBRARIES Threads::Threads)
+        endif()
+    endif()
+
+    # SDL2::Main target
+    # Applications should link to SDL2::Main instead of SDL2::Core
+    # For more details, please see above.
+    if(NOT SDL2_BUILDING_LIBRARY AND NOT TARGET SDL2::Main)
+
+        if(SDL2_INCLUDE_DIR MATCHES ".framework" OR NOT SDL2MAIN_LIBRARY)
+            add_library(SDL2::Main INTERFACE IMPORTED)
+            set_property(TARGET SDL2::Main PROPERTY
+                    INTERFACE_LINK_LIBRARIES SDL2::Core)
+        elseif(SDL2MAIN_LIBRARY)
+            # MinGW requires that the mingw32 library is specified before the
+            # libSDL2main.a static library when linking.
+            # The SDL2::MainInternal target is used internally to make sure that
+            # CMake respects this condition.
+            add_library(SDL2::MainInternal UNKNOWN IMPORTED)
+            set_property(TARGET SDL2::MainInternal PROPERTY
+                    IMPORTED_LOCATION "${SDL2MAIN_LIBRARY}")
+            set_property(TARGET SDL2::MainInternal PROPERTY
+                    INTERFACE_LINK_LIBRARIES SDL2::Core)
+
+            add_library(SDL2::Main INTERFACE IMPORTED)
+
+            if(MINGW)
+                # MinGW needs an additional link flag '-mwindows' and link to mingw32
+                set_property(TARGET SDL2::Main PROPERTY
+                        INTERFACE_LINK_LIBRARIES "mingw32" "-mwindows")
+            endif()
+
+            set_property(TARGET SDL2::Main APPEND PROPERTY
+                    INTERFACE_LINK_LIBRARIES SDL2::MainInternal)
+        endif()
+
+    endif()
+endif()

packaging/windows/wipeout.exe.manifest

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
+	<asmv3:application>
+		<asmv3:windowsSettings>
+			<dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true/pm</dpiAware>
+		</asmv3:windowsSettings>
+	</asmv3:application>
+</assembly>

packaging/windows/wipeout.rc

@@ -0,0 +1,3 @@
+#define MANIFEST_RESOURCE_ID 1
+MANIFEST_RESOURCE_ID RT_MANIFEST "wipeout.exe.manifest"
+IDI_ICON1 ICON DISCARDABLE "wipeout.ico"

src/input.c

@@ -159,16 +159,16 @@ static void *capture_user;
 static int32_t mouse_x;
 static int32_t mouse_y;
 
-void input_init() {
+void input_init(void) {
 	input_unbind_all(INPUT_LAYER_SYSTEM);
 	input_unbind_all(INPUT_LAYER_USER);
 }
 
-void input_cleanup() {
+void input_cleanup(void) {
 
 }
 
-void input_clear() {
+void input_clear(void) {
 	clear(actions_pressed);
 	clear(actions_released);
 }
@@ -274,7 +274,7 @@ bool input_released(uint8_t action) {
 	return actions_released[action];
 }
 
-vec2_t input_mouse_pos() {
+vec2_t input_mouse_pos(void) {
 	return vec2(mouse_x, mouse_y);
 }
 

src/input.h

@@ -156,9 +156,9 @@ typedef enum {
 typedef void(*input_capture_callback_t)
 	(void *user, button_t button, int32_t ascii_char);
 
-void input_init();
+void input_init(void);
-void input_cleanup();
+void input_cleanup(void);
-void input_clear();
+void input_clear(void);
 
 void input_bind(input_layer_t layer, button_t button, uint8_t action);
 void input_unbind(input_layer_t layer,button_t button);
@@ -175,7 +175,7 @@ void input_capture(input_capture_callback_t cb, void *user);
 float input_state(uint8_t action);
 bool input_pressed(uint8_t action);
 bool input_released(uint8_t action);
-vec2_t input_mouse_pos();
+vec2_t input_mouse_pos(void);
 
 button_t input_name_to_button(const char *name);
 const char *input_button_to_name(button_t button);

src/libs/sokol_time.h

@@ -61,6 +61,8 @@
         The main purpose of this function is to remove jitter/inaccuracies from
         measured frame times, and instead use the display refresh rate as
         frame duration.
+        NOTE: for more robust frame timing, consider using the
+        sokol_app.h function sapp_frame_duration()
 
     Use the following functions to convert a duration in ticks into
     useful time units:
@@ -77,7 +79,7 @@
 
     Windows:        QueryPerformanceFrequency() / QueryPerformanceCounter()
     MacOS/iOS:      mach_absolute_time()
-    emscripten:     performance.now()
+    emscripten:     emscripten_get_now()
     Linux+others:   clock_gettime(CLOCK_MONOTONIC)
 
     zlib/libpng license
@@ -199,19 +201,13 @@ static _stm_state_t _stm;
     see https://gist.github.com/jspohr/3dc4f00033d79ec5bdaf67bc46c813e3
 */
 #if defined(_WIN32) || (defined(__APPLE__) && defined(__MACH__))
-_SOKOL_PRIVATE int64_t int64_muldiv(int64_t value, int64_t numer, int64_t denom) {
+_SOKOL_PRIVATE int64_t _stm_int64_muldiv(int64_t value, int64_t numer, int64_t denom) {
     int64_t q = value / denom;
     int64_t r = value % denom;
     return q * numer + r * numer / denom;
 }
 #endif
 
-#if defined(__EMSCRIPTEN__)
-EM_JS(double, stm_js_perfnow, (void), {
-    return performance.now();
-});
-#endif
-
 SOKOL_API_IMPL void stm_setup(void) {
     memset(&_stm, 0, sizeof(_stm));
     _stm.initialized = 0xABCDABCD;
@@ -222,7 +218,7 @@ SOKOL_API_IMPL void stm_setup(void) {
         mach_timebase_info(&_stm.timebase);
         _stm.start = mach_absolute_time();
     #elif defined(__EMSCRIPTEN__)
-        _stm.start = stm_js_perfnow();
+        _stm.start = emscripten_get_now();
     #else
         struct timespec ts;
         clock_gettime(CLOCK_MONOTONIC, &ts);
@@ -236,13 +232,12 @@ SOKOL_API_IMPL uint64_t stm_now(void) {
     #if defined(_WIN32)
         LARGE_INTEGER qpc_t;
         QueryPerformanceCounter(&qpc_t);
-        now = (uint64_t) int64_muldiv(qpc_t.QuadPart - _stm.start.QuadPart, 1000000000, _stm.freq.QuadPart);
+        now = (uint64_t) _stm_int64_muldiv(qpc_t.QuadPart - _stm.start.QuadPart, 1000000000, _stm.freq.QuadPart);
     #elif defined(__APPLE__) && defined(__MACH__)
         const uint64_t mach_now = mach_absolute_time() - _stm.start;
-        now = (uint64_t) int64_muldiv((int64_t)mach_now, (int64_t)_stm.timebase.numer, (int64_t)_stm.timebase.denom);
+        now = (uint64_t) _stm_int64_muldiv((int64_t)mach_now, (int64_t)_stm.timebase.numer, (int64_t)_stm.timebase.denom);
     #elif defined(__EMSCRIPTEN__)
-        double js_now = stm_js_perfnow() - _stm.start;
+        double js_now = emscripten_get_now() - _stm.start;
-        SOKOL_ASSERT(js_now >= 0.0);
         now = (uint64_t) (js_now * 1000000.0);
     #else
         struct timespec ts;

src/mem.c

@@ -18,7 +18,7 @@ static uint32_t temp_objects_len;
 // These allocations persist for many frames. The allocator level is reset
 // whenever we load a new race track or menu in game_set_scene()
 
-void *mem_mark() {
+void *mem_mark(void) {
 	return &hunk[bump_len];
 }
 
@@ -76,6 +76,6 @@ void mem_temp_free(void *p) {
 	temp_len = remaining_max;
 }
 
-void mem_temp_check() {
+void mem_temp_check(void) {
 	error_if(temp_len != 0, "Temp memory not free: %d object(s)", temp_objects_len);
 }

src/mem.h

@@ -7,11 +7,11 @@
 #define MEM_HUNK_BYTES (4 * 1024 * 1024)
 
 void *mem_bump(uint32_t size);
-void *mem_mark();
+void *mem_mark(void);
 void mem_reset(void *p);
 
 void *mem_temp_alloc(uint32_t size);
 void mem_temp_free(void *p);
-void mem_temp_check();
+void mem_temp_check(void);
 
 #endif

src/platform.h

@@ -3,10 +3,10 @@
 
 #include "types.h"
 
-void platform_exit();
+void platform_exit(void);
-vec2i_t platform_screen_size();
+vec2i_t platform_screen_size(void);
-double platform_now();
+double platform_now(void);
-bool platform_get_fullscreen();
+bool platform_get_fullscreen(void);
 void platform_set_fullscreen(bool fullscreen);
 void platform_set_audio_mix_cb(void (*cb)(float *buffer, uint32_t len));
 

src/platform_sdl.c

@@ -48,11 +48,11 @@ uint8_t platform_sdl_axis_map[] = {
 };
 
 
-void platform_exit() {
+void platform_exit(void) {
 	wants_to_exit = true;
 }
 
-SDL_GameController *platform_find_gamepad() {
+SDL_GameController *platform_find_gamepad(void) {
 	for (int i = 0; i < SDL_NumJoysticks(); i++) {
 		if (SDL_IsGameController(i)) {
 			return SDL_GameControllerOpen(i);
@@ -63,7 +63,7 @@ SDL_GameController *platform_find_gamepad() {
 }
 
 
-void platform_pump_events() {
+void platform_pump_events(void) {
 	SDL_Event ev;
 	while (SDL_PollEvent(&ev)) {
 		// Detect ALT+Enter press to toggle fullscreen
@@ -188,12 +188,12 @@ void platform_pump_events() {
 	}
 }
 
-double platform_now() {
+double platform_now(void) {
 	uint64_t perf_counter = SDL_GetPerformanceCounter();
 	return (double)perf_counter / (double)perf_freq;
 }
 
-bool platform_get_fullscreen() {
+bool platform_get_fullscreen(void) {
 	return SDL_GetWindowFlags(window) & SDL_WINDOW_FULLSCREEN;
 }
 
@@ -251,7 +251,7 @@ uint32_t platform_store_userdata(const char *name, void *bytes, int32_t len) {
 	#define PLATFORM_WINDOW_FLAGS SDL_WINDOW_OPENGL
 	SDL_GLContext platform_gl;
 
-	void platform_video_init() {
+	void platform_video_init(void) {
 		#if defined(USE_GLES2)
 			SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
 			SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
@@ -262,19 +262,19 @@ uint32_t platform_store_userdata(const char *name, void *bytes, int32_t len) {
 		SDL_GL_SetSwapInterval(1);
 	}
 
-	void platform_prepare_frame() {
+	void platform_prepare_frame(void) {
 		// nothing
 	}
 
-	void platform_video_cleanup() {
+	void platform_video_cleanup(void) {
 		SDL_GL_DeleteContext(platform_gl);
 	}
 
-	void platform_end_frame() {
+	void platform_end_frame(void) {
 		SDL_GL_SwapWindow(window);
 	}
 
-	vec2i_t platform_screen_size() {
+	vec2i_t platform_screen_size(void) {
 		int width, height;
 		SDL_GL_GetDrawableSize(window, &width, &height);
 		return vec2i(width, height);
@@ -291,18 +291,18 @@ uint32_t platform_store_userdata(const char *name, void *bytes, int32_t len) {
 	static vec2i_t screen_size = vec2i(0, 0);
 
 
-	void platform_video_init() {
+	void platform_video_init(void) {
 		renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
 	}
 
-	void platform_video_cleanup() {
+	void platform_video_cleanup(void) {
 		if (screenbuffer) {
 			SDL_DestroyTexture(screenbuffer);
 		}
 		SDL_DestroyRenderer(renderer);
 	}
 
-	void platform_prepare_frame() {
+	void platform_prepare_frame(void) {
 		if (screen_size.x != screenbuffer_size.x || screen_size.y != screenbuffer_size.y) {
 			if (screenbuffer) {
 				SDL_DestroyTexture(screenbuffer);
@@ -313,7 +313,7 @@ uint32_t platform_store_userdata(const char *name, void *bytes, int32_t len) {
 		SDL_LockTexture(screenbuffer, NULL, &screenbuffer_pixels, &screenbuffer_pitch);
 	}
 
-	void platform_end_frame() {
+	void platform_end_frame(void) {
 		screenbuffer_pixels = NULL;
 		SDL_UnlockTexture(screenbuffer);
 		SDL_RenderCopy(renderer, screenbuffer, NULL, NULL);
@@ -325,7 +325,7 @@ uint32_t platform_store_userdata(const char *name, void *bytes, int32_t len) {
 		return screenbuffer_pixels;
 	}
 
-	vec2i_t platform_screen_size() {
+	vec2i_t platform_screen_size(void) {
 		int width, height;
 		SDL_GetWindowSize(window, &width, &height);
 

src/platform_sokol.c

@@ -5,7 +5,7 @@
 
 #if defined(RENDERER_GL)
 	#ifdef __EMSCRIPTEN__
-		#define SOKOL_GLES2
+		#define SOKOL_GLES3
 	#else
 		#define SOKOL_GLCORE33
 	#endif
@@ -14,9 +14,9 @@
 #endif
 
 #define SOKOL_IMPL
-#include "libs/sokol_audio.h"
+#include <sokol_audio.h>
-#include "libs/sokol_time.h"
+#include <sokol_time.h>
-#include "libs/sokol_app.h"
+#include <sokol_app.h>
 #include "input.h"
 
 // FIXME: we should figure out the actual path where the executabe resides,
@@ -161,15 +161,15 @@ static const uint8_t keyboard_map[] = {
 
 static void (*audio_callback)(float *buffer, uint32_t len) = NULL;
 
-void platform_exit() {
+void platform_exit(void) {
 	sapp_quit();
 }
 
-vec2i_t platform_screen_size() {
+vec2i_t platform_screen_size(void) {
 	return vec2i(sapp_width(), sapp_height());
 }
 
-double platform_now() {
+double platform_now(void) {
 	return stm_sec(stm_now());
 }
 

src/render.h

@@ -28,18 +28,18 @@ typedef enum {
 extern uint16_t RENDER_NO_TEXTURE;
 
 void render_init(vec2i_t screen_size);
-void render_cleanup();
+void render_cleanup(void);
 
 void render_set_screen_size(vec2i_t size);
 void render_set_resolution(render_resolution_t res);
 void render_set_post_effect(render_post_effect_t post);
-vec2i_t render_size();
+vec2i_t render_size(void);
 
-void render_frame_prepare();
+void render_frame_prepare(void);
-void render_frame_end();
+void render_frame_end(void);
 
 void render_set_view(vec3_t pos, vec3_t angles);
-void render_set_view_2d();
+void render_set_view_2d(void);
 void render_set_model_mat(mat4_t *m);
 void render_set_depth_write(bool enabled);
 void render_set_depth_test(bool enabled);
@@ -57,7 +57,7 @@ void render_push_2d_tile(vec2i_t pos, vec2i_t uv_offset, vec2i_t uv_size, vec2i_
 uint16_t render_texture_create(uint32_t width, uint32_t height, rgba_t *pixels);
 vec2i_t render_texture_size(uint16_t texture_index);
 void render_texture_replace_pixels(int16_t texture_index, rgba_t *pixels);
-uint16_t render_textures_len();
+uint16_t render_textures_len(void);
 void render_textures_reset(uint16_t len);
 void render_textures_dump(const char *path);
 

src/render_gl.c

@@ -11,23 +11,19 @@
 // Linux
 #elif defined(__unix__)
 	#include <GL/glew.h>
-#elif defined(__MSYS__)
+	
-	#include <GL/glew.h>
+// Windows
-// WINDOWS
+#elif defined(WIN32)
-#else
 	#include <windows.h>
 
 	#define GL3_PROTOTYPES 1
-	#include <glew.h>
+	#include <GL/glew.h>
-	#pragma comment(lib, "glew32.lib")
+	#include <GL/gl.h>
-
-	#include <gl/GL.h>
-	#pragma comment(lib, "opengl32.lib")
 #endif
 
 
 
-#include "libs/stb_image_write.h"
+#include <stb_image_write.h>
 
 #include "system.h"
 #include "render.h"
@@ -137,7 +133,7 @@ static const char * const SHADER_GAME_VS = SHADER_SOURCE(
 	uniform vec2 fade;
 	uniform float time;
 	
-	void main() {
+	void main(void) {
 		gl_Position = projection * view * model * vec4(pos, 1.0);
 		gl_Position.xy += screen.xy * gl_Position.w;
 		v_color = color;
@@ -154,7 +150,7 @@ static const char * const SHADER_GAME_FS = SHADER_SOURCE(
 	varying vec2 v_uv;
 	uniform sampler2D texture;
 
-	void main() {
+	void main(void) {
 		vec4 tex_color = texture2D(texture, v_uv);
 		vec4 color = tex_color * v_color;
 		if (color.a == 0.0) {
@@ -184,7 +180,7 @@ typedef struct {
 	} attribute;
 } prg_game_t;
 
-prg_game_t *shader_game_init() {
+prg_game_t *shader_game_init(void) {
 	prg_game_t *s = mem_bump(sizeof(prg_game_t));
 	
 	s->program = create_program(SHADER_GAME_VS, SHADER_GAME_FS);
@@ -228,7 +224,7 @@ static const char * const SHADER_POST_VS = SHADER_SOURCE(
 	uniform vec2 screen_size;
 	uniform float time;
 	
-	void main() {
+	void main(void) {
 		gl_Position = projection * vec4(pos, 1.0);
 		v_uv = uv;
 	}
@@ -240,7 +236,7 @@ static const char * const SHADER_POST_FS_DEFAULT = SHADER_SOURCE(
 	uniform sampler2D texture;
 	uniform vec2 screen_size;
 
-	void main() {
+	void main(void) {
 		gl_FragColor = texture2D(texture, v_uv);
 	}
 );
@@ -332,14 +328,14 @@ void shader_post_general_init(prg_post_t *s) {
 	bind_va_f(s->attribute.uv, vertex_t, uv, 0);
 }
 
-prg_post_t *shader_post_default_init() {
+prg_post_t *shader_post_default_init(void) {
 	prg_post_t *s = mem_bump(sizeof(prg_post_t));
 	s->program = create_program(SHADER_POST_VS, SHADER_POST_FS_DEFAULT);	
 	shader_post_general_init(s);
 	return s;
 }
 
-prg_post_t *shader_post_crt_init() {
+prg_post_t *shader_post_crt_init(void) {
 	prg_post_t *s = mem_bump(sizeof(prg_post_t));
 	s->program = create_program(SHADER_POST_VS, SHADER_POST_FS_CRT);	
 	shader_post_general_init(s);
@@ -383,7 +379,7 @@ prg_post_t *prg_post;
 prg_post_t *prg_post_effects[NUM_RENDER_POST_EFFCTS] = {};
 
 
-static void render_flush();
+static void render_flush(void);
 
 
 // static void gl_message_callback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const void *userParam) {
@@ -464,7 +460,7 @@ void render_init(vec2i_t screen_size) {
 	render_set_screen_size(screen_size);
 }
 
-void render_cleanup() {
+void render_cleanup(void) {
 	// TODO
 }
 
@@ -572,11 +568,11 @@ void render_set_post_effect(render_post_effect_t post) {
 	prg_post = prg_post_effects[post];
 }
 
-vec2i_t render_size() {
+vec2i_t render_size(void) {
 	return backbuffer_size;
 }
 
-void render_frame_prepare() {
+void render_frame_prepare(void) {
 	use_program(prg_game);
 	glBindFramebuffer(GL_FRAMEBUFFER, backbuffer);
 	glViewport(0, 0, backbuffer_size.x, backbuffer_size.y);
@@ -591,7 +587,7 @@ void render_frame_prepare() {
 	glEnable(GL_DEPTH_TEST); 
 }
 
-void render_frame_end() {
+void render_frame_end(void) {
 	render_flush();
 
 	use_program(prg_post);
@@ -625,7 +621,7 @@ void render_frame_end() {
 	render_flush();
 }
 
-void render_flush() {
+void render_flush(void) {
 	if (tris_len == 0) {
 		return;
 	}
@@ -662,7 +658,7 @@ void render_set_view(vec3_t pos, vec3_t angles) {
 	glUniform2f(prg_game->uniform.fade, RENDER_FADEOUT_NEAR, RENDER_FADEOUT_FAR);
 }
 
-void render_set_view_2d() {
+void render_set_view_2d(void) {
 	render_flush();
 	render_set_depth_test(false);
 	render_set_depth_write(false);
@@ -959,7 +955,7 @@ void render_texture_replace_pixels(int16_t texture_index, rgba_t *pixels) {
 	glTexSubImage2D(GL_TEXTURE_2D, 0, t->offset.x, t->offset.y, t->size.x, t->size.y, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
 }
 
-uint16_t render_textures_len() {
+uint16_t render_textures_len(void) {
 	return textures_len;
 }
 

src/render_software.c

@@ -43,7 +43,7 @@ void render_init(vec2i_t screen_size) {
 	RENDER_NO_TEXTURE = render_texture_create(2, 2, white_pixels);
 }
 
-void render_cleanup() {}
+void render_cleanup(void) {}
 
 void render_set_screen_size(vec2i_t size) {
 	screen_size = size;
@@ -63,12 +63,12 @@ void render_set_screen_size(vec2i_t size) {
 void render_set_resolution(render_resolution_t res) {}
 void render_set_post_effect(render_post_effect_t post) {}
 
-vec2i_t render_size() {
+vec2i_t render_size(void) {
 	return screen_size;
 }
 
 
-void render_frame_prepare() {
+void render_frame_prepare(void) {
 	screen_buffer = platform_get_screenbuffer(&screen_pitch);
 	screen_ppr = screen_pitch / sizeof(rgba_t);
 
@@ -80,7 +80,7 @@ void render_frame_prepare() {
 	}
 }
 
-void render_frame_end() {}
+void render_frame_end(void) {}
 
 void render_set_view(vec3_t pos, vec3_t angles) {
 	view_mat = mat4_identity();
@@ -92,7 +92,7 @@ void render_set_view(vec3_t pos, vec3_t angles) {
 	render_set_model_mat(&mat4_identity());
 }
 
-void render_set_view_2d() {
+void render_set_view_2d(void) {
 	float near = -1;
 	float far = 1;
 	float left = 0;
@@ -227,7 +227,7 @@ void render_texture_replace_pixels(int16_t texture_index, rgba_t *pixels) {
 	// memcpy(t->pixels, pixels, t->size.x * t->size.y * sizeof(rgba_t));
 }
 
-uint16_t render_textures_len() {
+uint16_t render_textures_len(void) {
 	return textures_len;
 }
 

src/system.c

@@ -13,23 +13,23 @@ static double time_scale = 1.0;
 static double tick_last;
 static double cycle_time = 0;
 
-void system_init() {
+void system_init(void) {
 	time_real = platform_now();
 	input_init();
 	render_init(platform_screen_size());
 	game_init();
 }
 
-void system_cleanup() {
+void system_cleanup(void) {
 	render_cleanup();
 	input_cleanup();
 }
 
-void system_exit() {
+void system_exit(void) {
 	platform_exit();
 }
 
-void system_update() {
+void system_update(void) {
 	double time_real_now = platform_now();
 	double real_delta = time_real_now - time_real;
 	time_real = time_real_now;
@@ -52,7 +52,7 @@ void system_update() {
 	mem_temp_check();
 }
 
-void system_reset_cycle_time() {
+void system_reset_cycle_time(void) {
 	cycle_time = 0;
 }
 
@@ -60,7 +60,7 @@ void system_resize(vec2i_t size) {
 	render_set_screen_size(size);
 }
 
-double system_time_scale_get() {
+double system_time_scale_get(void) {
 	return time_scale;
 }
 
@@ -68,14 +68,14 @@ void system_time_scale_set(double scale) {
 	time_scale = scale;
 }
 
-double system_tick() {
+double system_tick(void) {
 	return tick_last;
 }
 
-double system_time() {
+double system_time(void) {
 	return time_scaled;
 }
 
-double system_cycle_time() {
+double system_cycle_time(void) {
 	return cycle_time;
 }

src/system.h

@@ -7,17 +7,17 @@
 #define SYSTEM_WINDOW_WIDTH 1280
 #define SYSTEM_WINDOW_HEIGHT 720
 
-void system_init();
+void system_init(void);
-void system_update();
+void system_update(void);
-void system_cleanup();
+void system_cleanup(void);
-void system_exit();
+void system_exit(void);
 void system_resize(vec2i_t size);
 
-double system_time();
+double system_time(void);
-double system_tick();
+double system_tick(void);
-double system_cycle_time();
+double system_cycle_time(void);
-void system_reset_cycle_time();
+void system_reset_cycle_time(void);
-double system_time_scale_get();
+double system_time_scale_get(void);
 void system_time_scale_set(double ts);
 
 #endif

src/utils.h

@@ -4,6 +4,12 @@
 #include <string.h>
 #include "types.h"
 
+#ifdef WIN32
+	#undef min
+	#undef max
+	#undef near
+	#undef far
+#endif
 
 #if !defined(offsetof)
 	#define offsetof(TYPE, ELEMENT) ((size_t)&(((TYPE *)0)->ELEMENT))

src/wipeout/droid.c

@@ -17,7 +17,7 @@
 
 static Object *droid_model;
 
-void droid_load() {
+void droid_load(void) {
 	texture_list_t droid_textures = image_get_compressed_textures("wipeout/common/rescu.cmp");
 	droid_model = objects_load("wipeout/common/rescu.prm", droid_textures);
 }

src/wipeout/droid.h

@@ -29,7 +29,7 @@ typedef struct droid_t {
 
 void droid_draw(droid_t *droid);
 
-void droid_load();
+void droid_load(void);
 void droid_init(droid_t *droid, ship_t *ship);
 void droid_update(droid_t *droid, ship_t *ship);
 void droid_update_intro(droid_t *droid, ship_t *ship);

src/wipeout/game.c

@@ -487,8 +487,8 @@ game_t g = {0};
 
 
 struct {
-	void (*init)();
+	void (*init)(void);
-	void (*update)();
+	void (*update)(void);
 } game_scenes[] = {
 	[GAME_SCENE_INTRO] = {intro_init, intro_update},
 	[GAME_SCENE_TITLE] = {title_init, title_update},
@@ -501,8 +501,7 @@ static game_scene_t scene_next = GAME_SCENE_NONE;
 static int global_textures_len = 0;
 static void *global_mem_mark = 0;
 
-void game_init() {
+void game_init(void) {
-	
 	uint32_t size;
 	save_t *save_file = (save_t *)platform_load_userdata("save.dat", &size);
 	if (save_file) {
@@ -589,7 +588,7 @@ void game_set_scene(game_scene_t scene) {
 	scene_next = scene;
 }
 
-void game_reset_championship() {
+void game_reset_championship(void) {
 	for (int i = 0; i < len(g.championship_ranks); i++) {
 		g.championship_ranks[i].points = 0;
 		g.championship_ranks[i].pilot = i;
@@ -597,7 +596,7 @@ void game_reset_championship() {
 	g.lives = NUM_LIVES;
 }
 
-void game_update() {
+void game_update(void) {
 	double frame_start_time = platform_now();
 
 	int sh = render_size().y;

src/wipeout/game.h

@@ -262,9 +262,9 @@ extern const game_def_t def;
 extern game_t g;
 extern save_t save;
 
-void game_init();
+void game_init(void);
 void game_set_scene(game_scene_t scene);
-void game_reset_championship();
+void game_reset_championship(void);
-void game_update();
+void game_update(void);
 
 #endif

src/wipeout/hud.c

@@ -50,7 +50,7 @@ const struct {
 
 static uint16_t speedo_facia_texture;
 
-void hud_load() {
+void hud_load(void) {
 	speedo_facia_texture = image_get_texture("wipeout/textures/speedo.tim");
 	target_reticle = image_get_texture_semi_trans("wipeout/textures/target2.tim");
 	weapon_icon_textures = image_get_compressed_textures("wipeout/common/wicons.cmp");

src/wipeout/hud.h

@@ -3,7 +3,7 @@
 
 #include "ship.h"
 
-void hud_load();
+void hud_load(void);
 void hud_draw(ship_t *ship);
 
 #endif

src/wipeout/image.c

@@ -17,7 +17,7 @@
 
 
 #define STB_IMAGE_WRITE_IMPLEMENTATION
-#include "../libs/stb_image_write.h"
+#include <stb_image_write.h>
 
 
 #define TIM_TYPE_PALETTED_4_BPP 0x08

src/wipeout/ingame_menus.c

@@ -19,7 +19,7 @@ static void page_hall_of_fame_init(menu_t * menu);
 static texture_list_t pilot_portraits;
 static menu_t *ingame_menu;
 
-void ingame_menus_load() {
+void ingame_menus_load(void) {
 	pilot_portraits = image_get_compressed_textures(def.pilots[g.pilot].portrait);
 	ingame_menu = mem_bump(sizeof(menu_t));
 }
@@ -86,7 +86,7 @@ static void button_music(menu_t *menu, int data) {
 	menu_page_add_button(page, 0, "RANDOM", button_music_random);
 }
 
-menu_t *pause_menu_init() {
+menu_t *pause_menu_init(void) {
 	sfx_play(SFX_MENU_SELECT);
 	menu_reset(ingame_menu);
 
@@ -103,7 +103,7 @@ menu_t *pause_menu_init() {
 // -----------------------------------------------------------------------------
 // Game Over
 
-menu_t *game_over_menu_init() {
+menu_t *game_over_menu_init(void) {
 	sfx_play(SFX_MENU_SELECT);
 	menu_reset(ingame_menu);
 
@@ -187,7 +187,7 @@ static void page_race_stats_draw(menu_t *menu, int data) {
 	pos.y += 12;
 }
 
-menu_t *race_stats_menu_init() {
+menu_t *race_stats_menu_init(void) {
 	sfx_play(SFX_MENU_SELECT);
 	menu_reset(ingame_menu);
 	

src/wipeout/ingame_menus.h

@@ -3,11 +3,11 @@
 
 #include "menu.h"
 
-void ingame_menus_load();
+void ingame_menus_load(void);
 
-menu_t *pause_menu_init();
+menu_t *pause_menu_init(void);
-menu_t *game_over_menu_init();
+menu_t *game_over_menu_init(void);
-menu_t *race_stats_menu_init();
+menu_t *race_stats_menu_init(void);
 menu_t *text_scroll_menu_init(char * const *lines, int len);
 
 #endif

src/wipeout/intro.c

@@ -19,7 +19,7 @@ void *realloc_dummmy(void *p, size_t sz) {
 #define PLM_MALLOC mem_bump
 #define PLM_FREE free_dummmy
 #define PLM_REALLOC realloc_dummmy
-#include "../libs/pl_mpeg.h"
+#include <pl_mpeg.h>
 
 #define INTRO_AUDIO_BUFFER_LEN (64 * 1024)
 
@@ -33,9 +33,9 @@ static int audio_buffer_write_pos;
 static void video_cb(plm_t *plm, plm_frame_t *frame, void *user);
 static void audio_cb(plm_t *plm, plm_samples_t *samples, void *user);
 static void audio_mix(float *samples, uint32_t len);
-static void intro_end();
+static void intro_end(void);
 
-void intro_init() {
+void intro_init(void) {
 	plm = plm_create_with_filename("wipeout/intro.mpeg");
 	if (!plm) {
 		intro_end();
@@ -62,12 +62,12 @@ void intro_init() {
 	audio_buffer_write_pos = 0;
 }
 
-static void intro_end() {
+static void intro_end(void) {
 	sfx_set_external_mix_cb(NULL);
 	game_set_scene(GAME_SCENE_TITLE);
 }
 
-void intro_update() {
+void intro_update(void) {
 	if (!plm) {
 		return;
 	}

src/wipeout/intro.h

@@ -1,8 +1,8 @@
 #ifndef INTRO_H
 #define INTRO_H
 
-void intro_init();
+void intro_init(void);
-void intro_update();
+void intro_update(void);
-void intro_cleanup();
+void intro_cleanup(void);
 
 #endif

src/wipeout/main_menu.c

@@ -512,7 +512,7 @@ static void objects_unpack_imp(Object **dest_array, int len, Object *src) {
 }
 
 
-void main_menu_init() {
+void main_menu_init(void) {
 	g.is_attract_mode = false;
 
 	main_menu = mem_bump(sizeof(menu_t));
@@ -532,7 +532,7 @@ void main_menu_init() {
 	page_main_init(main_menu);
 }
 
-void main_menu_update() {
+void main_menu_update(void) {
 	render_set_view_2d();
 	render_push_2d(vec2i(0, 0), render_size(), rgba(128, 128, 128, 255), background);
 

src/wipeout/main_menu.h

@@ -1,7 +1,7 @@
 #ifndef MAIN_MENU_H
 #define MAIN_MENU_H
 
-void main_menu_init();
+void main_menu_init(void);
-void main_menu_update();
+void main_menu_update(void);
 
 #endif

src/wipeout/menu.c

@@ -7,7 +7,7 @@
 #include "ui.h"
 #include "sfx.h"
 
-bool blink() {
+bool blink(void) {
 	// blink 30 times per second
 	return fmod(system_cycle_time(), 1.0/15.0) < 1.0/30.0;
 }

src/wipeout/particle.c

@@ -10,17 +10,17 @@ static particle_t *particles;
 static int particles_active = 0;
 static texture_list_t particle_textures;
 
-void particles_load() {
+void particles_load(void) {
 	particles = mem_bump(sizeof(particle_t) * PARTICLES_MAX);
 	particle_textures = image_get_compressed_textures("wipeout/common/effects.cmp");
 	particles_init();
 }
 
-void particles_init() {
+void particles_init(void) {
 	particles_active = 0;
 }
 
-void particles_update() {
+void particles_update(void) {
 	for (int i = 0; i < particles_active; i++) {
 		particle_t *p = &particles[i];
 
@@ -33,7 +33,7 @@ void particles_update() {
 	}
 }
 
-void particles_draw() {
+void particles_draw(void) {
 	if (particles_active == 0) {
 		return;
 	}

src/wipeout/particle.h

@@ -23,10 +23,10 @@ typedef struct particle_t {
 	uint16_t texture;
 } particle_t;
 
-void particles_load();
+void particles_load(void);
-void particles_init();
+void particles_init(void);
 void particles_spawn(vec3_t position, uint16_t type, vec3_t velocity, int size);
-void particles_draw();
+void particles_draw(void);
-void particles_update();
+void particles_update(void);
 
 #endif

src/wipeout/race.c

@@ -29,7 +29,7 @@ static bool has_show_credits = false;
 static float attract_start_time;
 static menu_t *active_menu = NULL;
 
-void race_init() {
+void race_init(void) {
 	ingame_menus_load();
 	menu_is_scroll_text = false;
 
@@ -67,7 +67,7 @@ void race_init() {
 	is_paused = false;
 }
 
-void race_update() {
+void race_update(void) {
 	if (is_paused) {
 		if (!active_menu) {
 			active_menu = pause_menu_init();
@@ -131,7 +131,7 @@ void race_update() {
 	}
 }
 
-void race_start() {
+void race_start(void) {
 	active_menu = NULL;
 	sfx_reset();
 	scene_init();
@@ -157,7 +157,7 @@ void race_start() {
 	g.race_time = 0;
 }
 
-void race_restart() {
+void race_restart(void) {
 	race_unpause();
 
 	if (g.race_type == RACE_TYPE_CHAMPIONSHIP) {
@@ -176,7 +176,7 @@ static bool sort_points_compare(pilot_points_t *pa, pilot_points_t *pb) {
 	return (pa->points < pb->points);
 }
 
-void race_end() {
+void race_end(void) {
 	race_release_control();
 
 	g.race_position = g.ships[g.pilot].position_rank;
@@ -222,7 +222,7 @@ void race_end() {
 	active_menu = race_stats_menu_init();
 }
 
-void race_next() {
+void race_next(void) {
 	int next_circut = g.circut + 1;
 
 	// Championship complete
@@ -259,7 +259,7 @@ void race_next() {
 	}
 }
 
-void race_release_control() {
+void race_release_control(void) {
 	flags_rm(g.ships[g.pilot].flags, SHIP_RACING);
 	g.ships[g.pilot].remote_thrust_max = 3160;
 	g.ships[g.pilot].remote_thrust_mag = 32;
@@ -267,12 +267,12 @@ void race_release_control() {
 	g.camera.update_func = camera_update_attract_random;
 }
 
-void race_pause() {
+void race_pause(void) {
 	sfx_pause();
 	is_paused = true;
 }
 
-void race_unpause() {
+void race_unpause(void) {
 	sfx_unpause();
 	is_paused = false;
 	active_menu = NULL;

src/wipeout/race.h

@@ -1,14 +1,14 @@
 #ifndef RACE_H
 #define RACE_H
 
-void race_init();
+void race_init(void);
-void race_update();
+void race_update(void);
-void race_start();
+void race_start(void);
-void race_restart();
+void race_restart(void);
-void race_pause();
+void race_pause(void);
-void race_unpause();
+void race_unpause(void);
-void race_end();
+void race_end(void);
-void race_next();
+void race_next(void);
-void race_release_control();
+void race_release_control(void);
 
 #endif

src/wipeout/scene.c

@@ -47,7 +47,7 @@ static struct {
 
 void scene_pulsate_red_light(Object *obj);
 void scene_move_oil_pump(Object *obj);
-void scene_update_aurora_borealis();
+void scene_update_aurora_borealis(void);
 
 void scene_load(const char *base_path, float sky_y_offset) {
 	texture_list_t scene_textures = image_get_compressed_textures(get_path(base_path, "scene.cmp"));
@@ -93,14 +93,14 @@ void scene_load(const char *base_path, float sky_y_offset) {
 	aurora_borealis.enabled = false;
 }
 
-void scene_init() {
+void scene_init(void) {
 	scene_set_start_booms(0);
 	for (int i = 0; i < stands_len; i++) {
 		stands[i].sfx = sfx_reserve_loop(SFX_CROWD);
 	}
 }
 
-void scene_update() {
+void scene_update(void) {
 	for (int i = 0; i < red_lights_len; i++) {
 		scene_pulsate_red_light(red_lights[i]);
 	}
@@ -198,7 +198,7 @@ void scene_move_oil_pump(Object *pump) {
 	mat4_set_yaw_pitch_roll(&pump->mat, vec3(sin(system_cycle_time() * 0.125 * M_PI * 2), 0, 0));
 }
 
-void scene_init_aurora_borealis() {
+void scene_init_aurora_borealis(void) {
 	aurora_borealis.enabled = true;
 	clear(aurora_borealis.grey_coords);
 
@@ -236,7 +236,7 @@ void scene_init_aurora_borealis() {
 	}
 }
 
-void scene_update_aurora_borealis() {
+void scene_update_aurora_borealis(void) {
 	float phase = system_time() / 30.0;
 	for (int i = 0; i < 80; i++) {
 		int16_t *coords = aurora_borealis.coords[i];

src/wipeout/scene.h

@@ -6,10 +6,9 @@
 
 void scene_load(const char *path, float sky_y_offset);
 void scene_draw(camera_t *camera);
-void scene_init();
+void scene_init(void);
 void scene_set_start_booms(int num_lights);
-void scene_init_aurora_borealis();
+void scene_init_aurora_borealis(void);
-void scene_update();
+void scene_update(void);
-void scene_draw();
 
 #endif

src/wipeout/sfx.c

@@ -7,7 +7,7 @@
 
 #define QOA_IMPLEMENTATION
 #define QOA_NO_STDIO
-#include "../libs/qoa.h"
+#include <qoa.h>
 
 typedef struct {
 	int16_t *samples;
@@ -50,7 +50,7 @@ static sfx_t *nodes;
 static music_decoder_t *music;
 static void (*external_mix_cb)(float *, uint32_t len) = NULL;
 
-void sfx_load() {
+void sfx_load(void) {
 	// Init decode buffer for music
 	uint32_t channels = 2;
 	music = mem_bump(sizeof(music_decoder_t));
@@ -118,7 +118,7 @@ void sfx_load() {
 	platform_set_audio_mix_cb(sfx_stero_mix);
 }
 
-void sfx_reset() {
+void sfx_reset(void) {
 	for (int i = 0; i < SFX_MAX; i++) {
 		if (flags_is(nodes[i].flags, SFX_LOOP)) {
 			flags_set(nodes[i].flags, SFX_NONE);
@@ -126,7 +126,7 @@ void sfx_reset() {
 	}
 }
 
-void sfx_unpause() {
+void sfx_unpause(void) {
 	for (int i = 0; i < SFX_MAX; i++) {
 		if (flags_is(nodes[i].flags, SFX_LOOP_PAUSE)) {
 			flags_rm(nodes[i].flags, SFX_LOOP_PAUSE);
@@ -135,7 +135,7 @@ void sfx_unpause() {
 	}
 }
 
-void sfx_pause() {
+void sfx_pause(void) {
 	for (int i = 0; i < SFX_MAX; i++) {
 		if (flags_is(nodes[i].flags, SFX_PLAY | SFX_LOOP)) {
 			flags_rm(nodes[i].flags, SFX_PLAY);
@@ -227,7 +227,7 @@ void sfx_set_position(sfx_t *sfx, vec3_t pos, vec3_t vel, float volume) {
 
 // Music
 
-uint32_t sfx_music_decode_frame() {
+uint32_t sfx_music_decode_frame(void) {
 	if (!music->file) {
 		return 0;
 	}
@@ -240,7 +240,7 @@ uint32_t sfx_music_decode_frame() {
 	return frame_len;
 }
 
-void sfx_music_rewind() {
+void sfx_music_rewind(void) {
 	fseek(music->file, music->first_frame_pos, SEEK_SET);
 	music->sample_data_len = 0;
 	music->sample_data_pos = 0;

src/wipeout/sfx.h

@@ -58,12 +58,12 @@ typedef struct {
 #define SFX_MAX 64
 #define SFX_MAX_ACTIVE 16
 
-void sfx_load();
+void sfx_load(void);
 void sfx_stero_mix(float *buffer, uint32_t len);
 void sfx_set_external_mix_cb(void (*cb)(float *, uint32_t len));
-void sfx_reset();
+void sfx_reset(void);
-void sfx_pause();
+void sfx_pause(void);
-void sfx_unpause();
+void sfx_unpause(void);
 
 sfx_t *sfx_play(sfx_source_t source_index);
 sfx_t *sfx_play_at(sfx_source_t source_index, vec3_t pos, vec3_t vel, float volume);
@@ -77,9 +77,9 @@ typedef enum {
 	SFX_MUSIC_LOOP
 } sfx_music_mode_t;
 
-void sfx_music_next();
+void sfx_music_next(void);
 void sfx_music_play(uint32_t index);
 void sfx_music_mode(sfx_music_mode_t);
-void sfx_music_pause();
+void sfx_music_pause(void);
 
 #endif

src/wipeout/ship.c

@@ -16,7 +16,7 @@
 #include "race.h"
 #include "sfx.h"
 
-void ships_load() {
+void ships_load(void) {
 	texture_list_t ship_textures = image_get_compressed_textures("wipeout/common/allsh.cmp");
 	Object *ship_models = objects_load("wipeout/common/allsh.prm", ship_textures);
 
@@ -120,7 +120,7 @@ static inline bool sort_rank_compare(pilot_points_t *pa, pilot_points_t *pb) {
 	}
 }
 
-void ships_update() {
+void ships_update(void) {
 	if (g.race_type == RACE_TYPE_TIME_TRIAL) {
 		ship_update(&g.ships[g.pilot]);
 	}
@@ -145,7 +145,7 @@ void ships_update() {
 
 
 
-void ships_draw() {
+void ships_draw(void) {
 	// Ship models
 	for (int i = 0; i < len(g.ships); i++) {
 		if (

src/wipeout/ship.h

@@ -146,10 +146,10 @@ typedef struct ship_t {
 	sfx_t *sfx_shield;
 } ship_t;
 
-void ships_load();
+void ships_load(void);
 void ships_init(section_t *section);
-void ships_draw();
+void ships_draw(void);
-void ships_update();
+void ships_update(void);
 
 void ship_init(ship_t *self, section_t *section, int pilot, int position);
 void ship_init_exhaust_plume(ship_t *self);

src/wipeout/title.c

@@ -11,13 +11,13 @@ static uint16_t title_image;
 static float start_time;
 static bool has_shown_attract = false;
 
-void title_init() {
+void title_init(void) {
 	title_image = image_get_texture("wipeout/textures/wiptitle.tim");
 	start_time = system_time();
 	sfx_music_mode(SFX_MUSIC_RANDOM);
 }
 
-void title_update() {
+void title_update(void) {
 	render_set_view_2d();
 	render_push_2d(vec2i(0, 0), render_size(), rgba(128, 128, 128, 255), title_image);
 	ui_draw_text_centered("PRESS ENTER", ui_scaled_pos(UI_POS_BOTTOM | UI_POS_CENTER, vec2i(0, -40)), UI_SIZE_8, UI_COLOR_DEFAULT);

src/wipeout/title.h

@@ -1,8 +1,8 @@
 #ifndef TITLE_H
 #define TITLE_H
 
-void title_init();
+void title_init(void);
-void title_update();
+void title_update(void);
-void title_cleanup();
+void title_cleanup(void);
 
 #endif

src/wipeout/track.c

@@ -282,7 +282,7 @@ void track_draw(camera_t *camera) {
 	}
 }
 
-void track_cycle_pickups() {
+void track_cycle_pickups(void) {
 	float pickup_cycle_time = 1.5 * system_cycle_time();
 
 	for (int i = 0; i < g.track.pickups_len; i++) {

src/wipeout/track.h

@@ -91,6 +91,6 @@ section_t *track_nearest_section(vec3_t pos, section_t *section, float *distance
 struct camera_t;
 void track_draw(struct camera_t *camera);
 
-void track_cycle_pickups();
+void track_cycle_pickups(void);
 
 #endif

src/wipeout/ui.c

@@ -55,7 +55,7 @@ char_set_t char_set[UI_SIZE_MAX] = {
 
 uint16_t icon_textures[UI_ICON_MAX];
 
-void ui_load() {
+void ui_load(void) {
 	texture_list_t tl = image_get_compressed_textures("wipeout/textures/drfonts.cmp");
 	char_set[UI_SIZE_16].texture   = texture_from_list(tl, 0);
 	char_set[UI_SIZE_12].texture   = texture_from_list(tl, 1);
@@ -68,7 +68,7 @@ void ui_load() {
 	icon_textures[UI_ICON_STAR]    = texture_from_list(tl, 9);
 }
 
-int ui_get_scale() {
+int ui_get_scale(void) {
 	return ui_scale;
 }
 
@@ -81,7 +81,7 @@ vec2i_t ui_scaled(vec2i_t v) {
 	return vec2i(v.x * ui_scale, v.y * ui_scale);
 }
 
-vec2i_t ui_scaled_screen() {
+vec2i_t ui_scaled_screen(void) {
 	return vec2i_mulf(render_size(), ui_scale);
 }
 

src/wipeout/ui.h

@@ -32,13 +32,13 @@ typedef enum {
 	UI_POS_BOTTOM = 1 << 5,
 } ui_pos_t;
 
-void ui_load();
+void ui_load(void);
-void ui_cleanup();
+void ui_cleanup(void);
 
-int ui_get_scale();
+int ui_get_scale(void);
 void ui_set_scale(int scale);
 vec2i_t ui_scaled(vec2i_t v);
-vec2i_t ui_scaled_screen();
+vec2i_t ui_scaled_screen(void);
 vec2i_t ui_scaled_pos(ui_pos_t anchor, vec2i_t offset);
 
 int ui_char_width(char c, ui_text_size_t size);

src/wipeout/weapon.c

@@ -74,7 +74,7 @@ void weapon_fire_turbo(ship_t *ship);
 
 void invert_shield_polys(Object *shield);
 
-void weapons_load() {
+void weapons_load(void) {
 	weapons = mem_bump(sizeof(weapon_t) * WEAPONS_MAX);
 	weapon_assets.reticle = image_get_texture("wipeout/textures/target2.tim");
 
@@ -106,7 +106,7 @@ void weapons_load() {
 	weapons_init();
 }
 
-void weapons_init() {
+void weapons_init(void) {
 	weapons_active = 0;
 }
 
@@ -160,7 +160,7 @@ void weapons_fire_delayed(ship_t *ship, int weapon_type) {
 
 bool weapon_collides_with_track(weapon_t *self);
 
-void weapons_update() {
+void weapons_update(void) {
 	for (int i = 0; i < weapons_active; i++) {
 		weapon_t *weapon = &weapons[i];
 		
@@ -214,7 +214,7 @@ void weapons_update() {
 	}
 }
 
-void weapons_draw() {
+void weapons_draw(void) {
 	mat4_t mat = mat4_identity();
 	for (int i = 0; i < weapons_active; i++) {
 		weapon_t *weapon = &weapons[i];

src/wipeout/weapon.h

@@ -40,12 +40,12 @@
 #define WEAPON_CLASS_PROJECTILE 2
 
 
-void weapons_load();
+void weapons_load(void);
-void weapons_init();
+void weapons_init(void);
 void weapons_fire(ship_t *ship, int weapon_type);
 void weapons_fire_delayed(ship_t *ship, int weapon_type);
-void weapons_update();
+void weapons_update(void);
-void weapons_draw();
+void weapons_draw(void);
 int weapon_get_random_type(int type_class);
 
 #endif

vcpkg.json

@@ -0,0 +1,15 @@
+{
+  "name": "wipeout-rewrite",
+  "version-string": "1.0.0",
+  "builtin-baseline": "0fa8459cf3a7caca7adc58f992bc32ff13630684",
+  "dependencies": [
+    {
+      "name": "sdl2",
+      "version>=": "2.26.5"
+    },
+    {
+      "name": "glew",
+      "version>=": "2.2.0#3"
+    }
+  ]
+}