Merge branch 'port' of https://github.com/fgsfdsfgs/perfect_dark into port-debugger

maybe it'll help figuring out some of the gameplay bugs

.github/workflows/c-cpp.yml

@@ -2,7 +2,7 @@ name: C/C++ CI
 
 on:
   push:
-    branches: [ "port" ]
+    branches: [ "port", "port-debugger" ]
   pull_request:
     branches: [ "port" ]
   workflow_dispatch:
@@ -268,7 +268,7 @@ jobs:
     runs-on: ubuntu-latest
     needs: [build-x86_64-linux]
     container:
-      image: ghcr.io/flathub-infra/flatpak-github-actions:freedesktop-25.08
+      image: bilelmoussaoui/flatpak-github-actions:freedesktop-23.08
       options: --privileged
     steps:
     - uses: actions/checkout@v4
@@ -279,16 +279,23 @@ jobs:
 
     - uses: flatpak/flatpak-github-actions/flatpak-builder@v6
       with:
-        bundle: io.github.perfect_dark_pc_port.perfect_dark.flatpak
-        manifest-path: dist/linux/io.github.perfect_dark_pc_port.perfect_dark.yaml
+        bundle: io.github.fgsfdsfgs.perfect_dark.flatpak
+        manifest-path: dist/linux/io.github.fgsfdsfgs.perfect_dark.yaml
         cache-key: flatpak-builder-${{ github.sha }}
         upload-artifact: false
 
+    # - name: Build Flatpak bundle
+    #   run: |
+    #     cd dist/linux/
+    #     flatpak-builder build --force-clean io.github.fgsfdsfgs.perfect_dark.yaml
+    #     flatpak build-export export build
+    #     flatpak build-bundle export io.github.fgsfdsfgs.perfect_dark.flatpak io.github.fgsfdsfgs.perfect_dark
+
     - name: Upload artifact
       uses: actions/upload-artifact@v4
       with:
-        name: io.github.perfect_dark_pc_port.perfect_dark.flatpak
-        path: io.github.perfect_dark_pc_port.perfect_dark.flatpak
+        name: io.github.fgsfdsfgs.perfect_dark.flatpak
+        path: io.github.fgsfdsfgs.perfect_dark.flatpak
         retention-days: 0
 
 
@@ -316,7 +323,7 @@ jobs:
           zip -r ../ci-release/pd-i686-windows.zip pd-i686-windows
           zip -r ../ci-release/pd-x86_64-windows.zip pd-x86_64-windows
           zip -r ../ci-release/pd-arm64-nswitch.zip pd-arm64-nswitch
-          mv io.github.perfect_dark_pc_port.perfect_dark.flatpak/io.github.perfect_dark_pc_port.perfect_dark.flatpak ../ci-release/
+          mv io.github.fgsfdsfgs.perfect_dark.flatpak/io.github.fgsfdsfgs.perfect_dark.flatpak ../ci-release/
           popd
           git tag --force ci-dev-build port
           git push --force origin ci-dev-build

CMakeLists.txt

@@ -21,7 +21,6 @@ set(CMAKE_C_STANDARD 11)
 set(CMAKE_C_EXTENSIONS OFF)
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_EXTENSIONS OFF)
-set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
 # On first build set the build type to RelWithDebInfo if it's not already set
 if (NOT EXISTS ${CMAKE_BINARY_DIR}/CMakeCache.txt)
@@ -161,6 +160,7 @@ include_directories("${CMAKE_BINARY_DIR}/src/generated/${ROMID}")
 include_directories("${CMAKE_SOURCE_DIR}/src/lib/ultra/audio")
 include_directories("${CMAKE_SOURCE_DIR}/port/include")
 include_directories("${CMAKE_BINARY_DIR}/port/include")
+include_directories("${CMAKE_SOURCE_DIR}/port/src/imgui")
 
 # Set Release optimization to -Og until I fix the -O2 issues
 if(NOT (CMAKE_BUILD_TYPE STREQUAL "Debug"))
@@ -188,7 +188,6 @@ add_compile_options(
   -Wno-unused-but-set-variable
   -Wno-unused-value
   -Wno-unused-variable
-  -fdiagnostics-color=always
 )
 
 # C specific flags

README.md

@@ -98,7 +98,7 @@ Controls can be rebound in `pd.ini`. Default control scheme is as follows:
 | Aim mode         | RMB/Z                  | LT                       | R Trigger                 |
 | Use / Cancel     | E                      | N/A                      | B                         |
 | Use / Accept     | N/A                    | A                        | A                         |
-| Crouch cycle     | N/A                    | LS Click                 | `0x80000000` (Extra)      |
+| Crouch cycle     | N/A                    | L3                       | `0x80000000` (Extra)      |
 | Half-Crouch      | Shift                  | N/A                      | `0x40000000` (Extra)      |
 | Full-Crouch      | Control                | N/A                      | `0x20000000` (Extra)      |
 | Reload           | R                      | X                        | X `(0x40)`                |
@@ -205,7 +205,7 @@ It might be possible to build and run the game on platforms that are not specifi
 * Ryan Dwyer for the above, additional help, and `pd-extract`;
 * doomhack for the only other publicly available [PD porting effort](https://github.com/doomhack/perfect_dark) I could find;
 * [sm64-port](https://github.com/sm64-port/sm64-port) authors for the audio mixer and some other changes;
-* [Ship of Harkinian team](https://github.com/Kenix3/libultraship/tree/main/src/fast), Emill and MaikelChan for the libultraship version of fast3d that this port uses;
+* [Ship of Harkinian team](https://github.com/Kenix3/libultraship/tree/main/src/graphic/Fast3D), Emill and MaikelChan for the libultraship version of fast3d that this port uses;
 * lieff for [minimp3](https://github.com/lieff/minimp3);
 * Mouse Injector and 1964GEPD authors for some of the 60FPS- and mouselook-related fixes;
 * Raf for the 64-bit port;

dist/linux/io.github.fgsfdsfgs.perfect_dark.desktop

@@ -1,8 +1,8 @@
 [Desktop Entry]
 Name=Perfect Dark
 Comment=Modern source port of Perfect Dark
-Exec=io.github.perfect_dark_pc_port.perfect_dark.sh
-Icon=io.github.perfect_dark_pc_port.perfect_dark
+Exec=io.github.fgsfdsfgs.perfect_dark.sh
+Icon=io.github.fgsfdsfgs.perfect_dark
 Terminal=false
 Type=Application
 Categories=Game;ActionGame;

dist/linux/io.github.fgsfdsfgs.perfect_dark.metainfo.xml

@@ -1,12 +1,12 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <component type="desktop-application">
-  <id>io.github.perfect_dark_pc_port.perfect_dark</id>
+  <id>io.github.fgsfdsfgs.perfect_dark</id>
   <name>Perfect Dark</name>
-  <developer id="io.github.perfect_dark_pc_port.perfect_dark">
+  <developer id="io.github.fgsfdsfgs.perfect_dark">
     <name>Perfect Dark Contributors</name>
     <url>https://github.com/fgsfdsfgs/perfect_dark/graphs/contributors</url>
   </developer>
-  <launchable type="desktop-id">io.github.perfect_dark_pc_port.perfect_dark.desktop</launchable>
+  <launchable type="desktop-id">io.github.fgsfdsfgs.perfect_dark.desktop</launchable>
   <summary>Modern cross-platform port of Perfect Dark</summary>
   <metadata_license>CC0-1.0</metadata_license>
   <project_license>MIT</project_license>
@@ -17,9 +17,8 @@
   <!--
   <screenshots>
     <screenshot type="default">
-      <image type="source"></image>
-      <caption>Screenshot</caption>
-    </screenshot>
+      <image type="source">https://gitlab.com/fpiesche/dxx-rebirth-assets/-/raw/c6e7e79eebe92905f84f07a635ffab5122a94bd1/d1x/screenshots/retromode.png</image>
+      <caption>"Retro mode": the default graphics setup, like the original game but in high resolution</caption>
   <screenshots>
   -->
   <categories>

dist/linux/io.github.fgsfdsfgs.perfect_dark.yaml

@@ -1,8 +1,8 @@
-app-id: io.github.perfect_dark_pc_port.perfect_dark
+app-id: io.github.fgsfdsfgs.perfect_dark
 runtime: org.freedesktop.Platform
-runtime-version: "25.08"
+runtime-version: "23.08"
 sdk: org.freedesktop.Sdk
-command: io.github.perfect_dark_pc_port.perfect_dark.sh
+command: io.github.fgsfdsfgs.perfect_dark.sh
 
 finish-args:
   - --device=all
@@ -24,13 +24,13 @@ modules:
       - type: file
         path: bin/pd.pal.x86_64
       - type: file
-        path: io.github.perfect_dark_pc_port.perfect_dark.sh
+        path: io.github.fgsfdsfgs.perfect_dark.sh
       - type: file
-        path: io.github.perfect_dark_pc_port.perfect_dark.png
+        path: io.github.fgsfdsfgs.perfect_dark.png
       - type: file
-        path: io.github.perfect_dark_pc_port.perfect_dark.metainfo.xml
+        path: io.github.fgsfdsfgs.perfect_dark.metainfo.xml
       - type: file
-        path: io.github.perfect_dark_pc_port.perfect_dark.desktop
+        path: io.github.fgsfdsfgs.perfect_dark.desktop
     build-commands: []
     post-install:
       # Install the binaries

include/PR/os_libc.h

@@ -98,7 +98,10 @@ extern void     bzero(void *, size_t);
 
 #ifdef PLATFORM_N64
 extern int		sprintf(char *s, const char *fmt, ...);
+#else
+#include <stdio.h>
 #endif
+
 extern void		osSyncPrintf(const char *fmt, ...);
 
 

port/fast3d/gfx_api.h

@@ -45,10 +45,8 @@ void gfx_run(Gfx* commands);
 void gfx_end_frame(void);
 void gfx_set_target_fps(int);
 void gfx_set_texture_filter(enum FilteringMode mode);
-void gfx_set_mipmap_filter(enum MipmapFilteringMode mode);
 void gfx_texture_cache_clear(void);
 void gfx_texture_cache_delete(const uint8_t *orig_addr);
-void gfx_texture_cache_delete_range(const uint8_t *start, const uint8_t *end);
 int gfx_create_framebuffer(uint32_t width, uint32_t height, int upscale, int autoresize);
 void gfx_resize_framebuffer(int fb, uint32_t width, uint32_t height, int upscale, int autoresize);
 void gfx_set_framebuffer(int fb, float noise_scale) ;

port/fast3d/gfx_opengl.cpp

@@ -54,9 +54,7 @@ static uint32_t frame_count;
 static std::vector<Framebuffer> framebuffers;
 static size_t current_framebuffer;
 static float current_noise_scale;
-static int current_anisotropy_level;
 static FilteringMode current_filter_mode = FILTER_LINEAR;
-static MipmapFilteringMode current_mipmap_filter_mode = MIPMAP_LINEAR;
 static bool current_textures_linear_filter[2] = {false, false};
 
 static int gl_glsl_version = 130;
@@ -694,11 +692,8 @@ static void gfx_opengl_select_texture(int tile, GLuint texture_id, bool linear_f
     current_textures_linear_filter[tile] = linear_filter;
 }
 
-static void gfx_opengl_upload_texture(const uint8_t* rgba32_buf, uint32_t width, uint32_t height, bool gen_mipmaps) {
+static void gfx_opengl_upload_texture(const uint8_t* rgba32_buf, uint32_t width, uint32_t height) {
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, rgba32_buf);
-	if (gen_mipmaps || current_filter_mode == FILTER_THREE_POINT) {
-		glGenerateMipmap(GL_TEXTURE_2D);
-	}
 }
 
 static uint32_t gfx_cm_to_opengl(uint32_t val) {
@@ -715,27 +710,11 @@ static uint32_t gfx_cm_to_opengl(uint32_t val) {
     return 0;
 }
 
-static void gfx_opengl_set_sampler_parameters(int tile, bool linear_filter, uint32_t cms, uint32_t cmt, bool mipmaps) {
-    const GLint min_filters[3][3] = {
-        // MIPMAP_DISABLED   MIPMAP_NEAREST               MIPMAP_LINEAR
-        {  GL_NEAREST,       GL_NEAREST_MIPMAP_NEAREST,   GL_NEAREST_MIPMAP_LINEAR  }, // FILTER_NONE
-        {  GL_LINEAR,        GL_LINEAR_MIPMAP_NEAREST,    GL_LINEAR_MIPMAP_LINEAR   }, // FILTER_BILINEAR
-        {  GL_NEAREST,       GL_NEAREST,                  GL_NEAREST                }, // FILTER_THREE_POINT
-    };
-
-    mipmaps = mipmaps && (current_mipmap_filter_mode != MIPMAP_DISABLED);
-    const int mip_idx = mipmaps ? current_mipmap_filter_mode : 0;
-    const GLint min_filter = linear_filter ? min_filters[current_filter_mode][mip_idx] : GL_NEAREST;
-    const GLint max_filter = linear_filter && (current_filter_mode == FILTER_LINEAR) ? GL_LINEAR : GL_NEAREST;
-
+static void gfx_opengl_set_sampler_parameters(int tile, bool linear_filter, uint32_t cms, uint32_t cmt) {
+    const GLint filter = linear_filter && (current_filter_mode == FILTER_LINEAR) ? GL_LINEAR : GL_NEAREST;
     glActiveTexture(GL_TEXTURE0 + tile);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, min_filter);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, max_filter);
-
-    if (mipmaps) {
-        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY, current_anisotropy_level);
-    }
-
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, gfx_cm_to_opengl(cms));
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, gfx_cm_to_opengl(cmt));
 }
@@ -1265,21 +1244,7 @@ FilteringMode gfx_opengl_get_texture_filter(void) {
     return current_filter_mode;
 }
 
-void gfx_opengl_set_mipmap_filter(MipmapFilteringMode mode) {
-    current_mipmap_filter_mode = mode;
-}
-
-static int gfx_opengl_get_max_anisotropy_level() {
-	GLfloat max_aniso_level;
-	glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY, &max_aniso_level);
-	return (int)max_aniso_level;
-}
-
-static void gfx_opengl_set_anisotropy_level(int level) {
-	current_anisotropy_level = level;
-}
-
-struct GfxRenderingAPI gfx_opengl_api = {
+struct GfxRenderingAPI gfx_opengl_api = { 
     gfx_opengl_get_name,
     gfx_opengl_get_max_texture_size,
     gfx_opengl_get_clip_parameters,
@@ -1314,8 +1279,5 @@ struct GfxRenderingAPI gfx_opengl_api = {
     gfx_opengl_select_texture_fb,
     gfx_opengl_delete_texture,
     gfx_opengl_set_texture_filter,
-    gfx_opengl_get_texture_filter,
-    gfx_opengl_set_mipmap_filter,
-    gfx_opengl_set_anisotropy_level,
-    gfx_opengl_get_max_anisotropy_level
+    gfx_opengl_get_texture_filter
 };

port/fast3d/gfx_pc.cpp

@@ -551,7 +551,7 @@ static bool gfx_texture_cache_lookup(int i, const TextureCacheKey& key) {
     node->second.lru_location = gfx_texture_cache.lru.insert(gfx_texture_cache.lru.end(), { it });
 
     gfx_rapi->select_texture(i, texture_id, false);
-    gfx_rapi->set_sampler_parameters(i, false, 0, 0, rdp.tex_lod);
+    gfx_rapi->set_sampler_parameters(i, false, 0, 0);
     *n = node;
     return false;
 }
@@ -585,30 +585,8 @@ void gfx_texture_cache_delete(const uint8_t* orig_addr) {
     }
 }
 
-void gfx_texture_cache_delete_range(const uint8_t* start, const uint8_t* end) {
-    gfx_flush();
-
-    for (int i = 0; i < 2; ++i) {
-        if (rendering_state.textures[i]
-                && rendering_state.textures[i]->first.texture_addr >= start
-                && rendering_state.textures[i]->first.texture_addr < end) {
-            rdp.textures_changed[i] = true;
-            rendering_state.textures[i] = nullptr;
-        }
-    }
-
-    for (auto it = gfx_texture_cache.map.begin(); it != gfx_texture_cache.map.end(); ) {
-        if (it->first.texture_addr >= start && it->first.texture_addr < end) {
-            gfx_texture_cache.lru.erase(it->second.lru_location);
-            gfx_texture_cache.free_texture_ids.push_back(it->second.texture_id);
-            it = gfx_texture_cache.map.erase(it);
-        } else {
-            ++it;
-        }
-    }
-}
-
-static void import_texture_rgba16(int tile, const LoadedTexture& loaded_texture, bool gen_mipmaps) {
+static void import_texture_rgba16(int tile, const LoadedTexture& loaded_texture, bool importReplacement) {
+    const RawTexMetadata* metadata = &loaded_texture.raw_tex_metadata;
     const uint8_t* addr = loaded_texture.addr;
     const uint32_t size_bytes = loaded_texture.size_bytes;
     const uint32_t full_image_line_size_bytes =
@@ -634,11 +612,11 @@ static void import_texture_rgba16(int tile, const LoadedTexture& loaded_texture,
     const uint32_t width = rdp.texture_tile[tile].line_size_bytes / 2;
     const uint32_t height = size_bytes / rdp.texture_tile[tile].line_size_bytes;
 
-	gfx_rapi->upload_texture(tex_upload_buffer, width, height, gen_mipmaps);
+    gfx_rapi->upload_texture(tex_upload_buffer, width, height);
     // DumpTexture(loaded_texture.otr_path, rgba32_buf, width, height);
 }
 
-static void import_texture_rgba32(int tile, const LoadedTexture& loaded_texture, bool gen_mipmaps) {
+static void import_texture_rgba32(int tile, const LoadedTexture& loaded_texture, bool importReplacement) {
     const RawTexMetadata* metadata = &loaded_texture.raw_tex_metadata;
     const uint8_t* addr = loaded_texture.addr;
     const uint32_t size_bytes = loaded_texture.size_bytes;
@@ -655,11 +633,11 @@ static void import_texture_rgba32(int tile, const LoadedTexture& loaded_texture,
 
     const uint32_t width = rdp.texture_tile[tile].line_size_bytes / 2;
     const uint32_t height = (size_bytes / 2) / rdp.texture_tile[tile].line_size_bytes;
-	gfx_rapi->upload_texture(tex_upload_buffer, width, height, gen_mipmaps);
+    gfx_rapi->upload_texture(tex_upload_buffer, width, height);
     // DumpTexture(loaded_texture.otr_path, addr, width, height);
 }
 
-static void import_texture_ia4(int tile, const LoadedTexture& loaded_texture, bool gen_mipmaps) {
+static void import_texture_ia4(int tile, const LoadedTexture& loaded_texture, bool importReplacement) {
     const RawTexMetadata* metadata = &loaded_texture.raw_tex_metadata;
     const uint8_t* addr = loaded_texture.addr;
     const uint32_t size_bytes = loaded_texture.size_bytes;
@@ -684,11 +662,11 @@ static void import_texture_ia4(int tile, const LoadedTexture& loaded_texture, bo
     const uint32_t width = rdp.texture_tile[tile].line_size_bytes * 2;
     const uint32_t height = size_bytes / rdp.texture_tile[tile].line_size_bytes;
 
-	gfx_rapi->upload_texture(tex_upload_buffer, width, height, gen_mipmaps);
+    gfx_rapi->upload_texture(tex_upload_buffer, width, height);
     // DumpTexture(loaded_texture.otr_path, rgba32_buf, width, height);
 }
 
-static void import_texture_ia8(int tile, const LoadedTexture& loaded_texture, bool gen_mipmaps) {
+static void import_texture_ia8(int tile, const LoadedTexture& loaded_texture, bool importReplacement) {
     const RawTexMetadata* metadata = &loaded_texture.raw_tex_metadata;
     const uint8_t* addr = loaded_texture.addr;
     const uint32_t size_bytes = loaded_texture.size_bytes;
@@ -710,11 +688,11 @@ static void import_texture_ia8(int tile, const LoadedTexture& loaded_texture, bo
     const uint32_t width = rdp.texture_tile[tile].line_size_bytes;
     const uint32_t height = size_bytes / rdp.texture_tile[tile].line_size_bytes;
 
-	gfx_rapi->upload_texture(tex_upload_buffer, width, height, gen_mipmaps);
+    gfx_rapi->upload_texture(tex_upload_buffer, width, height);
     // DumpTexture(loaded_texture.otr_path, rgba32_buf, width, height);
 }
 
-static void import_texture_ia16(int tile, const LoadedTexture& loaded_texture, bool gen_mipmaps) {
+static void import_texture_ia16(int tile, const LoadedTexture& loaded_texture, bool importReplacement) {
     const RawTexMetadata* metadata = &loaded_texture.raw_tex_metadata;
     const uint8_t* addr = loaded_texture.addr;
     const uint32_t size_bytes = loaded_texture.size_bytes;
@@ -736,11 +714,11 @@ static void import_texture_ia16(int tile, const LoadedTexture& loaded_texture, b
     const uint32_t width = rdp.texture_tile[tile].line_size_bytes / 2;
     const uint32_t height = size_bytes / rdp.texture_tile[tile].line_size_bytes;
 
-	gfx_rapi->upload_texture(tex_upload_buffer, width, height, gen_mipmaps);
+    gfx_rapi->upload_texture(tex_upload_buffer, width, height);
     // DumpTexture(loaded_texture.otr_path, rgba32_buf, width, height);
 }
 
-static void import_texture_i4(int tile, const LoadedTexture& loaded_texture, bool gen_mipmaps) {
+static void import_texture_i4(int tile, const LoadedTexture& loaded_texture, bool importReplacement) {
     const RawTexMetadata* metadata = &loaded_texture.raw_tex_metadata;
     const uint8_t* addr = loaded_texture.addr;
     const uint32_t size_bytes = loaded_texture.size_bytes;
@@ -763,11 +741,11 @@ static void import_texture_i4(int tile, const LoadedTexture& loaded_texture, boo
     const uint32_t width = rdp.texture_tile[tile].line_size_bytes * 2;
     const uint32_t height = size_bytes / rdp.texture_tile[tile].line_size_bytes;
 
-	gfx_rapi->upload_texture(tex_upload_buffer, width, height, gen_mipmaps);
+    gfx_rapi->upload_texture(tex_upload_buffer, width, height);
     // DumpTexture(loaded_texture.otr_path, rgba32_buf, width, height);
 }
 
-static void import_texture_i8(int tile, const LoadedTexture& loaded_texture, bool gen_mipmaps) {
+static void import_texture_i8(int tile, const LoadedTexture& loaded_texture, bool importReplacement) {
     const RawTexMetadata* metadata = &loaded_texture.raw_tex_metadata;
     const uint8_t* addr = loaded_texture.addr;
     const uint32_t size_bytes = loaded_texture.size_bytes;
@@ -788,7 +766,7 @@ static void import_texture_i8(int tile, const LoadedTexture& loaded_texture, boo
     const uint32_t width = rdp.texture_tile[tile].line_size_bytes;
     const uint32_t height = size_bytes / rdp.texture_tile[tile].line_size_bytes;
 
-	gfx_rapi->upload_texture(tex_upload_buffer, width, height, gen_mipmaps);
+    gfx_rapi->upload_texture(tex_upload_buffer, width, height);
     // DumpTexture(loaded_texture.otr_path, rgba32_buf, width, height);
 }
 
@@ -813,8 +791,8 @@ static inline void palette_to_rgba32(const uint16_t palentry, uint8_t *rgba32_bu
     }
 }
 
-static void import_texture_ci4(int tile, const LoadedTexture& loaded_texture, bool gen_mipmaps) {
-	const RawTexMetadata* metadata = &loaded_texture.raw_tex_metadata;
+static void import_texture_ci4(int tile, const LoadedTexture& loaded_texture, bool importReplacement) {
+    const RawTexMetadata* metadata = &loaded_texture.raw_tex_metadata;
     const uint8_t* addr = loaded_texture.addr;
     const uint32_t size_bytes = loaded_texture.size_bytes;
     const uint32_t full_image_line_size_bytes =
@@ -838,11 +816,11 @@ static void import_texture_ci4(int tile, const LoadedTexture& loaded_texture, bo
     const uint32_t width = result_line_size * 2;
     const uint32_t height = size_bytes / result_line_size;
 
-	gfx_rapi->upload_texture(tex_upload_buffer, width, height, gen_mipmaps);
+    gfx_rapi->upload_texture(tex_upload_buffer, width, height);
 }
 
-static void import_texture_ci8(int tile, const LoadedTexture& loaded_texture, bool gen_mipmaps) {
-	const RawTexMetadata* metadata = &loaded_texture.raw_tex_metadata;
+static void import_texture_ci8(int tile, const LoadedTexture& loaded_texture, bool importReplacement) {
+    const RawTexMetadata* metadata = &loaded_texture.raw_tex_metadata;
     const uint8_t* addr = loaded_texture.addr;
     const uint32_t size_bytes = loaded_texture.size_bytes;
     const uint32_t full_image_line_size_bytes =
@@ -864,7 +842,8 @@ static void import_texture_ci8(int tile, const LoadedTexture& loaded_texture, bo
     const uint32_t width = result_line_size;
     const uint32_t height = size_bytes / result_line_size;
 
-	gfx_rapi->upload_texture(tex_upload_buffer, width, height, gen_mipmaps);
+    gfx_rapi->upload_texture(tex_upload_buffer, width, height);
+    // DumpTexture(loaded_texture.otr_path, rgba32_buf, width, height);
 }
 
 static void import_texture(int i, int tile, bool importReplacement) {
@@ -906,35 +885,35 @@ static void import_texture(int i, int tile, bool importReplacement) {
 
     if (fmt == G_IM_FMT_RGBA) {
         if (siz == G_IM_SIZ_16b) {
-            import_texture_rgba16(tile, loaded_texture, rdp.tex_lod);
+            import_texture_rgba16(tile, loaded_texture, importReplacement);
         } else if (siz == G_IM_SIZ_32b) {
-            import_texture_rgba32(tile, loaded_texture, rdp.tex_lod);
+            import_texture_rgba32(tile, loaded_texture, importReplacement);
         } else {
             sysFatalError("Bad size for RGBA texture in tile %d: %02x", tile, siz);
         }
     } else if (fmt == G_IM_FMT_IA) {
         if (siz == G_IM_SIZ_4b) {
-            import_texture_ia4(tile, loaded_texture, rdp.tex_lod);
+            import_texture_ia4(tile, loaded_texture, importReplacement);
         } else if (siz == G_IM_SIZ_8b) {
-            import_texture_ia8(tile, loaded_texture, rdp.tex_lod);
+            import_texture_ia8(tile, loaded_texture, importReplacement);
         } else if (siz == G_IM_SIZ_16b) {
-            import_texture_ia16(tile, loaded_texture, rdp.tex_lod);
+            import_texture_ia16(tile, loaded_texture, importReplacement);
         } else {
             sysFatalError("Bad size for IA texture in tile %d: %02x", tile, siz);
         }
     } else if (fmt == G_IM_FMT_CI) {
         if (siz == G_IM_SIZ_4b) {
-            import_texture_ci4(tile, loaded_texture, rdp.tex_lod);
+            import_texture_ci4(tile, loaded_texture, importReplacement);
         } else if (siz == G_IM_SIZ_8b) {
-            import_texture_ci8(tile, loaded_texture, rdp.tex_lod);
+            import_texture_ci8(tile, loaded_texture, importReplacement);
         } else {
             sysFatalError("Bad size for CI texture in tile %d: %02x", tile, siz);
         }
     } else if (fmt == G_IM_FMT_I) {
         if (siz == G_IM_SIZ_4b) {
-            import_texture_i4(tile, loaded_texture, rdp.tex_lod);
+            import_texture_i4(tile, loaded_texture, importReplacement);
         } else if (siz == G_IM_SIZ_8b) {
-            import_texture_i8(tile, loaded_texture, rdp.tex_lod);
+            import_texture_i8(tile, loaded_texture, importReplacement);
         } else {
             sysFatalError("Bad size for I texture in tile %d: %02x", tile, siz);
         }
@@ -1404,7 +1383,7 @@ static void gfx_sp_tri1(uint8_t vtx1_idx, uint8_t vtx2_idx, uint8_t vtx3_idx, bo
                 if (linear_filter != rendering_state.textures[i]->second.linear_filter ||
                     cms != rendering_state.textures[i]->second.cms || cmt != rendering_state.textures[i]->second.cmt) {
                     gfx_flush();
-                    gfx_rapi->set_sampler_parameters(i, linear_filter, cms, cmt, rdp.tex_lod);
+                    gfx_rapi->set_sampler_parameters(i, linear_filter, cms, cmt);
                     rendering_state.textures[i]->second.linear_filter = linear_filter;
                     rendering_state.textures[i]->second.cms = cms;
                     rendering_state.textures[i]->second.cmt = cmt;
@@ -1662,18 +1641,11 @@ static void gfx_sp_extra_geometry_mode(uint32_t clear, uint32_t set) {
 
 static void gfx_adjust_viewport_or_scissor(XYWidthHeight* area, bool preserve_aspect = false) {
     // HACK: assume all target framebuffers have the same aspect
-    // Use floor/ceil to ensure scissor fully contains the logical region
-    // and prevents sub-pixel gaps at viewport edges
-    float x1 = area->x * RATIO_X;
-    float y1 = (SCREEN_HEIGHT - area->y) * RATIO_Y;
-    float x2 = (area->x + area->width) * RATIO_X;
-    float y2 = (SCREEN_HEIGHT - area->y + area->height) * RATIO_Y;
-    
-    area->x = std::floor(x1);
-    area->y = std::floor(y1);
-    area->width = std::ceil(x2) - area->x;
-    area->height = std::ceil(y2) - area->y;
-    
+    area->width *= RATIO_X;
+    area->x *= RATIO_X;
+    area->height *= RATIO_Y;
+    area->y = SCREEN_HEIGHT - area->y;
+    area->y *= RATIO_Y;
     if (preserve_aspect) {
         // preserve native aspect ratio
         const float ratio = gfx_current_native_aspect / gfx_current_dimensions.aspect_ratio;
@@ -2720,7 +2692,7 @@ extern "C" void gfx_set_target_fps(int fps) {
     gfx_wapi->set_target_fps(fps);
 }
 
-extern "C" void reset_texture_state() {
+extern "C" void gfx_set_texture_filter(enum FilteringMode mode) {
     gfx_texture_cache_clear();
     if (rendering_state.shader_program) {
         gfx_rapi->unload_shader(rendering_state.shader_program);
@@ -2729,18 +2701,9 @@ extern "C" void reset_texture_state() {
     gfx_rapi->clear_shaders();
     color_combiner_pool.clear();
     prev_combiner = color_combiner_pool.end();
-}
-
-extern "C" void gfx_set_texture_filter(enum FilteringMode mode) {
-    reset_texture_state();
     gfx_rapi->set_texture_filter(mode);
 }
 
-extern "C" void gfx_set_mipmap_filter(enum MipmapFilteringMode mode) {
-    reset_texture_state();
-    gfx_rapi->set_mipmap_filter(mode);
-}
-
 extern "C" int gfx_create_framebuffer(uint32_t width, uint32_t height, int upscale, int autoresize) {
     int fb = gfx_rapi->create_framebuffer();
     gfx_resize_framebuffer(fb, width, height, upscale, autoresize);

port/fast3d/gfx_rendering_api.h

@@ -13,7 +13,6 @@ struct GfxClipParameters {
 };
 
 enum FilteringMode { FILTER_NONE, FILTER_LINEAR, FILTER_THREE_POINT };
-enum MipmapFilteringMode { MIPMAP_DISABLED, MIPMAP_NEAREST, MIPMAP_LINEAR };
 
 struct GfxRenderingAPI {
     const char* (*get_name)(void);
@@ -27,8 +26,8 @@ struct GfxRenderingAPI {
     void (*clear_shaders)(void);
     uint32_t (*new_texture)(void);
     void (*select_texture)(int tile, uint32_t texture_id, bool linear_filter);
-    void (*upload_texture)(const uint8_t* rgba32_buf, uint32_t width, uint32_t height, bool gen_mipmaps);
-    void (*set_sampler_parameters)(int sampler, bool linear_filter, uint32_t cms, uint32_t cmt, bool mipmaps);
+    void (*upload_texture)(const uint8_t* rgba32_buf, uint32_t width, uint32_t height);
+    void (*set_sampler_parameters)(int sampler, bool linear_filter, uint32_t cms, uint32_t cmt);
     void (*set_depth_mode)(bool depth_test, bool depth_update, bool depth_compare, bool depth_source_prim, uint16_t zmode);
     void (*set_depth_range)(float znear, float zfar);
     void (*set_viewport)(int x, int y, int width, int height);
@@ -53,9 +52,6 @@ struct GfxRenderingAPI {
     void (*delete_texture)(uint32_t texID);
     void (*set_texture_filter)(enum FilteringMode mode);
     enum FilteringMode (*get_texture_filter)(void);
-    void (*set_mipmap_filter)(enum MipmapFilteringMode mode);
-	void (*set_anisotropy_level)(int);
-	int (*get_max_anisotropy_level)(void);
 };
 
 #endif

port/fast3d/gfx_sdl2.cpp

@@ -108,8 +108,8 @@ static void gfx_sdl_init(const struct GfxWindowInitSettings *set) {
     int posY = set->y;
     int display_in_use = SDL_GetWindowDisplayIndex(wnd);
     if (display_in_use < 0) { // Fallback to default if out of bounds
-        posX = SDL_WINDOWPOS_UNDEFINED;
-        posY = SDL_WINDOWPOS_UNDEFINED;
+        posX = 100;
+        posY = 100;
     }
 
     if (set->centered) {

port/fast3d/glad/glad.c

@@ -1,6 +1,6 @@
 /*
 
-    OpenGL, OpenGL ES loader generated by glad 0.1.36 on Wed Oct  8 13:10:56 2025.
+    OpenGL, OpenGL ES loader generated by glad 0.1.36 on Wed Nov 20 09:57:47 2024.
 
     Language/Generator: C/C++
     Specification: gl
@@ -10,7 +10,6 @@
         GL_APPLE_framebuffer_multisample,
         GL_ARB_depth_clamp,
         GL_ARB_framebuffer_object,
-        GL_ARB_texture_filter_anisotropic,
         GL_ARB_texture_mirror_clamp_to_edge,
         GL_ARB_vertex_array_object,
         GL_EXT_depth_clamp,
@@ -18,7 +17,6 @@
         GL_EXT_framebuffer_multisample,
         GL_EXT_framebuffer_object,
         GL_EXT_gpu_shader4,
-        GL_EXT_texture_filter_anisotropic,
         GL_EXT_texture_mirror_clamp_to_edge,
         GL_KHR_debug,
         GL_NV_depth_clamp,
@@ -29,9 +27,9 @@
     Reproducible: False
 
     Commandline:
-        --profile="core" --api="gl=4.1,gles2=3.0" --generator="c" --spec="gl" --no-loader --local-files --extensions="GL_APPLE_framebuffer_multisample,GL_ARB_depth_clamp,GL_ARB_framebuffer_object,GL_ARB_texture_filter_anisotropic,GL_ARB_texture_mirror_clamp_to_edge,GL_ARB_vertex_array_object,GL_EXT_depth_clamp,GL_EXT_framebuffer_blit,GL_EXT_framebuffer_multisample,GL_EXT_framebuffer_object,GL_EXT_gpu_shader4,GL_EXT_texture_filter_anisotropic,GL_EXT_texture_mirror_clamp_to_edge,GL_KHR_debug,GL_NV_depth_clamp,GL_NV_framebuffer_multisample"
+        --profile="core" --api="gl=4.1,gles2=3.0" --generator="c" --spec="gl" --no-loader --local-files --extensions="GL_APPLE_framebuffer_multisample,GL_ARB_depth_clamp,GL_ARB_framebuffer_object,GL_ARB_texture_mirror_clamp_to_edge,GL_ARB_vertex_array_object,GL_EXT_depth_clamp,GL_EXT_framebuffer_blit,GL_EXT_framebuffer_multisample,GL_EXT_framebuffer_object,GL_EXT_gpu_shader4,GL_EXT_texture_mirror_clamp_to_edge,GL_KHR_debug,GL_NV_depth_clamp,GL_NV_framebuffer_multisample"
     Online:
-        https://glad.dav1d.de/#profile=core&language=c&specification=gl&api=gl%3D4.1&api=gles2%3D3.0&extensions=GL_APPLE_framebuffer_multisample&extensions=GL_ARB_depth_clamp&extensions=GL_ARB_framebuffer_object&extensions=GL_ARB_texture_filter_anisotropic&extensions=GL_ARB_texture_mirror_clamp_to_edge&extensions=GL_ARB_vertex_array_object&extensions=GL_EXT_depth_clamp&extensions=GL_EXT_framebuffer_blit&extensions=GL_EXT_framebuffer_multisample&extensions=GL_EXT_framebuffer_object&extensions=GL_EXT_gpu_shader4&extensions=GL_EXT_texture_filter_anisotropic&extensions=GL_EXT_texture_mirror_clamp_to_edge&extensions=GL_KHR_debug&extensions=GL_NV_depth_clamp&extensions=GL_NV_framebuffer_multisample
+        https://glad.dav1d.de/#profile=core&language=c&specification=gl&api=gl%3D4.1&api=gles2%3D3.0&extensions=GL_APPLE_framebuffer_multisample&extensions=GL_ARB_depth_clamp&extensions=GL_ARB_framebuffer_object&extensions=GL_ARB_texture_mirror_clamp_to_edge&extensions=GL_ARB_vertex_array_object&extensions=GL_EXT_depth_clamp&extensions=GL_EXT_framebuffer_blit&extensions=GL_EXT_framebuffer_multisample&extensions=GL_EXT_framebuffer_object&extensions=GL_EXT_gpu_shader4&extensions=GL_EXT_texture_mirror_clamp_to_edge&extensions=GL_KHR_debug&extensions=GL_NV_depth_clamp&extensions=GL_NV_framebuffer_multisample
 */
 
 #include <stdio.h>
@@ -670,7 +668,6 @@ PFNGLWAITSYNCPROC glad_glWaitSync = NULL;
 int GLAD_GL_APPLE_framebuffer_multisample = 0;
 int GLAD_GL_ARB_depth_clamp = 0;
 int GLAD_GL_ARB_framebuffer_object = 0;
-int GLAD_GL_ARB_texture_filter_anisotropic = 0;
 int GLAD_GL_ARB_texture_mirror_clamp_to_edge = 0;
 int GLAD_GL_ARB_vertex_array_object = 0;
 int GLAD_GL_EXT_depth_clamp = 0;
@@ -678,7 +675,6 @@ int GLAD_GL_EXT_framebuffer_blit = 0;
 int GLAD_GL_EXT_framebuffer_multisample = 0;
 int GLAD_GL_EXT_framebuffer_object = 0;
 int GLAD_GL_EXT_gpu_shader4 = 0;
-int GLAD_GL_EXT_texture_filter_anisotropic = 0;
 int GLAD_GL_EXT_texture_mirror_clamp_to_edge = 0;
 int GLAD_GL_KHR_debug = 0;
 int GLAD_GL_NV_depth_clamp = 0;
@@ -1439,14 +1435,12 @@ static int find_extensionsGL(void) {
 	if (!get_exts()) return 0;
 	GLAD_GL_ARB_depth_clamp = has_ext("GL_ARB_depth_clamp");
 	GLAD_GL_ARB_framebuffer_object = has_ext("GL_ARB_framebuffer_object");
-	GLAD_GL_ARB_texture_filter_anisotropic = has_ext("GL_ARB_texture_filter_anisotropic");
 	GLAD_GL_ARB_texture_mirror_clamp_to_edge = has_ext("GL_ARB_texture_mirror_clamp_to_edge");
 	GLAD_GL_ARB_vertex_array_object = has_ext("GL_ARB_vertex_array_object");
 	GLAD_GL_EXT_framebuffer_blit = has_ext("GL_EXT_framebuffer_blit");
 	GLAD_GL_EXT_framebuffer_multisample = has_ext("GL_EXT_framebuffer_multisample");
 	GLAD_GL_EXT_framebuffer_object = has_ext("GL_EXT_framebuffer_object");
 	GLAD_GL_EXT_gpu_shader4 = has_ext("GL_EXT_gpu_shader4");
-	GLAD_GL_EXT_texture_filter_anisotropic = has_ext("GL_EXT_texture_filter_anisotropic");
 	GLAD_GL_KHR_debug = has_ext("GL_KHR_debug");
 	GLAD_GL_NV_depth_clamp = has_ext("GL_NV_depth_clamp");
 	free_exts();
@@ -1806,7 +1800,6 @@ static int find_extensionsGLES2(void) {
 	if (!get_exts()) return 0;
 	GLAD_GL_APPLE_framebuffer_multisample = has_ext("GL_APPLE_framebuffer_multisample");
 	GLAD_GL_EXT_depth_clamp = has_ext("GL_EXT_depth_clamp");
-	GLAD_GL_EXT_texture_filter_anisotropic = has_ext("GL_EXT_texture_filter_anisotropic");
 	GLAD_GL_EXT_texture_mirror_clamp_to_edge = has_ext("GL_EXT_texture_mirror_clamp_to_edge");
 	GLAD_GL_KHR_debug = has_ext("GL_KHR_debug");
 	GLAD_GL_NV_framebuffer_multisample = has_ext("GL_NV_framebuffer_multisample");

port/fast3d/glad/glad.h

@@ -1,6 +1,6 @@
 /*
 
-    OpenGL, OpenGL ES loader generated by glad 0.1.36 on Wed Oct  8 13:10:56 2025.
+    OpenGL, OpenGL ES loader generated by glad 0.1.36 on Wed Nov 20 09:57:47 2024.
 
     Language/Generator: C/C++
     Specification: gl
@@ -10,7 +10,6 @@
         GL_APPLE_framebuffer_multisample,
         GL_ARB_depth_clamp,
         GL_ARB_framebuffer_object,
-        GL_ARB_texture_filter_anisotropic,
         GL_ARB_texture_mirror_clamp_to_edge,
         GL_ARB_vertex_array_object,
         GL_EXT_depth_clamp,
@@ -18,7 +17,6 @@
         GL_EXT_framebuffer_multisample,
         GL_EXT_framebuffer_object,
         GL_EXT_gpu_shader4,
-        GL_EXT_texture_filter_anisotropic,
         GL_EXT_texture_mirror_clamp_to_edge,
         GL_KHR_debug,
         GL_NV_depth_clamp,
@@ -29,9 +27,9 @@
     Reproducible: False
 
     Commandline:
-        --profile="core" --api="gl=4.1,gles2=3.0" --generator="c" --spec="gl" --no-loader --local-files --extensions="GL_APPLE_framebuffer_multisample,GL_ARB_depth_clamp,GL_ARB_framebuffer_object,GL_ARB_texture_filter_anisotropic,GL_ARB_texture_mirror_clamp_to_edge,GL_ARB_vertex_array_object,GL_EXT_depth_clamp,GL_EXT_framebuffer_blit,GL_EXT_framebuffer_multisample,GL_EXT_framebuffer_object,GL_EXT_gpu_shader4,GL_EXT_texture_filter_anisotropic,GL_EXT_texture_mirror_clamp_to_edge,GL_KHR_debug,GL_NV_depth_clamp,GL_NV_framebuffer_multisample"
+        --profile="core" --api="gl=4.1,gles2=3.0" --generator="c" --spec="gl" --no-loader --local-files --extensions="GL_APPLE_framebuffer_multisample,GL_ARB_depth_clamp,GL_ARB_framebuffer_object,GL_ARB_texture_mirror_clamp_to_edge,GL_ARB_vertex_array_object,GL_EXT_depth_clamp,GL_EXT_framebuffer_blit,GL_EXT_framebuffer_multisample,GL_EXT_framebuffer_object,GL_EXT_gpu_shader4,GL_EXT_texture_mirror_clamp_to_edge,GL_KHR_debug,GL_NV_depth_clamp,GL_NV_framebuffer_multisample"
     Online:
-        https://glad.dav1d.de/#profile=core&language=c&specification=gl&api=gl%3D4.1&api=gles2%3D3.0&extensions=GL_APPLE_framebuffer_multisample&extensions=GL_ARB_depth_clamp&extensions=GL_ARB_framebuffer_object&extensions=GL_ARB_texture_filter_anisotropic&extensions=GL_ARB_texture_mirror_clamp_to_edge&extensions=GL_ARB_vertex_array_object&extensions=GL_EXT_depth_clamp&extensions=GL_EXT_framebuffer_blit&extensions=GL_EXT_framebuffer_multisample&extensions=GL_EXT_framebuffer_object&extensions=GL_EXT_gpu_shader4&extensions=GL_EXT_texture_filter_anisotropic&extensions=GL_EXT_texture_mirror_clamp_to_edge&extensions=GL_KHR_debug&extensions=GL_NV_depth_clamp&extensions=GL_NV_framebuffer_multisample
+        https://glad.dav1d.de/#profile=core&language=c&specification=gl&api=gl%3D4.1&api=gles2%3D3.0&extensions=GL_APPLE_framebuffer_multisample&extensions=GL_ARB_depth_clamp&extensions=GL_ARB_framebuffer_object&extensions=GL_ARB_texture_mirror_clamp_to_edge&extensions=GL_ARB_vertex_array_object&extensions=GL_EXT_depth_clamp&extensions=GL_EXT_framebuffer_blit&extensions=GL_EXT_framebuffer_multisample&extensions=GL_EXT_framebuffer_object&extensions=GL_EXT_gpu_shader4&extensions=GL_EXT_texture_mirror_clamp_to_edge&extensions=GL_KHR_debug&extensions=GL_NV_depth_clamp&extensions=GL_NV_framebuffer_multisample
 */
 
 
@@ -2723,8 +2721,6 @@ GLAPI PFNGLGETINTERNALFORMATIVPROC glad_glGetInternalformativ;
 #define glGetInternalformativ glad_glGetInternalformativ
 #endif
 #define GL_INDEX 0x8222
-#define GL_TEXTURE_MAX_ANISOTROPY 0x84FE
-#define GL_MAX_TEXTURE_MAX_ANISOTROPY 0x84FF
 #define GL_MIRROR_CLAMP_TO_EDGE 0x8743
 #define GL_READ_FRAMEBUFFER_EXT 0x8CA8
 #define GL_DRAW_FRAMEBUFFER_EXT 0x8CA9
@@ -2812,8 +2808,6 @@ GLAPI PFNGLGETINTERNALFORMATIVPROC glad_glGetInternalformativ;
 #define GL_MIN_PROGRAM_TEXEL_OFFSET_EXT 0x8904
 #define GL_MAX_PROGRAM_TEXEL_OFFSET_EXT 0x8905
 #define GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT 0x88FD
-#define GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE
-#define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF
 #define GL_DEBUG_OUTPUT_SYNCHRONOUS 0x8242
 #define GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH 0x8243
 #define GL_DEBUG_CALLBACK_FUNCTION 0x8244
@@ -2916,10 +2910,6 @@ GLAPI int GLAD_GL_ARB_depth_clamp;
 #define GL_ARB_framebuffer_object 1
 GLAPI int GLAD_GL_ARB_framebuffer_object;
 #endif
-#ifndef GL_ARB_texture_filter_anisotropic
-#define GL_ARB_texture_filter_anisotropic 1
-GLAPI int GLAD_GL_ARB_texture_filter_anisotropic;
-#endif
 #ifndef GL_ARB_texture_mirror_clamp_to_edge
 #define GL_ARB_texture_mirror_clamp_to_edge 1
 GLAPI int GLAD_GL_ARB_texture_mirror_clamp_to_edge;
@@ -3103,10 +3093,6 @@ typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIUIVEXTPROC)(GLuint index, GLenum pn
 GLAPI PFNGLGETVERTEXATTRIBIUIVEXTPROC glad_glGetVertexAttribIuivEXT;
 #define glGetVertexAttribIuivEXT glad_glGetVertexAttribIuivEXT
 #endif
-#ifndef GL_EXT_texture_filter_anisotropic
-#define GL_EXT_texture_filter_anisotropic 1
-GLAPI int GLAD_GL_EXT_texture_filter_anisotropic;
-#endif
 #ifndef GL_KHR_debug
 #define GL_KHR_debug 1
 GLAPI int GLAD_GL_KHR_debug;
@@ -3195,10 +3181,6 @@ GLAPI PFNGLRESOLVEMULTISAMPLEFRAMEBUFFERAPPLEPROC glad_glResolveMultisampleFrame
 #define GL_EXT_depth_clamp 1
 GLAPI int GLAD_GL_EXT_depth_clamp;
 #endif
-#ifndef GL_EXT_texture_filter_anisotropic
-#define GL_EXT_texture_filter_anisotropic 1
-GLAPI int GLAD_GL_EXT_texture_filter_anisotropic;
-#endif
 #ifndef GL_EXT_texture_mirror_clamp_to_edge
 #define GL_EXT_texture_mirror_clamp_to_edge 1
 GLAPI int GLAD_GL_EXT_texture_mirror_clamp_to_edge;

port/include/debugger.h

@@ -0,0 +1,21 @@
+#ifndef _IN_DEBUGGER_H
+#define _IN_DEBUGGER_H
+
+#include <PR/ultratypes.h>
+#include <PR/gbi.h>
+
+extern s32 g_DebuggerActive;
+extern s32 g_DebuggerTimePasses;
+extern s32 g_DebuggerFrameAdvance;
+
+void debuggerInit(void);
+void debuggerProcessEvent(void *event);
+
+void debuggerStartFrame(void);
+void debuggerFrame(void);
+void debuggerEndFrame(void);
+
+void debuggerUpdatePropInfo(s32 clear);
+Gfx *debuggerDrawPropInfo(Gfx *gdl);
+
+#endif

port/include/video.h

@@ -39,8 +39,6 @@ s32 videoGetCenterWindow(void);
 void videoSetCenterWindow(s32 center);
 u32 videoGetTextureFilter(void);
 s32 videoGetTextureFilter2D(void);
-u32 videoGetAnisotropicFilter(void);
-u32 videoGetMaxAnisotropyLevel(void);
 s32 videoGetDetailTextures(void);
 s32 videoGetDisplayModeIndex(void);
 s32 videoGetDisplayMode(displaymode *out, const s32 index);
@@ -49,25 +47,21 @@ s32 videoGetVsync(void);
 s32 videoGetFramerateLimit(void);
 s32 videoGetDisplayFPS(void);
 s32 videoGetMSAA(void);
-f32 videoGetGlareBrightness(void);
-f32 videoGetOverexposureScale(void);
 
 f32 videoGetAverageFPS(void);
+f64 videoGetLastRenderTime(void);
 
 void videoSetWindowOffset(s32 x, s32 y);
 void videoSetFullscreen(s32 fs);
 void videoSetFullscreenMode(s32 mode);
 void videoSetTextureFilter(u32 filter);
 void videoSetTextureFilter2D(s32 filter);
-void videoSetAnisotropicFilter(u32 filter);
 void videoSetDetailTextures(s32 detail);
 void videoSetDisplayMode(const s32 index);
 void videoSetVsync(const s32 vsync);
 void videoSetFramerateLimit(const s32 limit);
 void videoSetDisplayFPS(const s32 displayfps);
 void videoSetMSAA(const s32 msaa);
-void videoSetGlareBrightness(f32 bright);
-void videoSetOverexposureScale(f32 scale);
 
 s32 videoCreateFramebuffer(u32 w, u32 h, s32 upscale, s32 autoresize);
 void videoSetFramebuffer(s32 target);
@@ -78,7 +72,6 @@ s32 videoFramebuffersSupported(void);
 
 void videoResetTextureCache(void);
 void videoFreeCachedTexture(const void *texptr);
-void videoFreeCachedTextures(const void *start, const void *end);
 
 void videoShutdown(void);
 

port/src/debugger.cpp

@@ -0,0 +1,905 @@
+#include <string>
+#include <SDL.h>
+#include "imgui/imgui.h"
+#include "imgui/backends/imgui_impl_sdlrenderer2.h"
+#include "imgui/backends/imgui_impl_sdl2.h"
+
+extern "C"
+{
+
+#include <PR/ultratypes.h>
+#include <PR/gbi.h>
+#include <gbiex.h>
+#include "data.h"
+#include "bss.h"
+#include "constants.h"
+#include "game/stagetable.h"
+#include "game/chr.h"
+#include "game/chraction.h"
+#include "game/bg.h"
+#include "game/player.h"
+#include "game/propobj.h"
+#include "game/prop.h"
+#include "game/sight.h"
+#include "game/game_1531a0.h"
+#include "lib/memp.h"
+#include "lib/mema.h"
+#include "lib/vi.h"
+#include "lib/lib_17ce0.h"
+#include "video.h"
+#include "input.h"
+#include "system.h"
+#include "utils.h"
+#include "romdata.h"
+
+#undef bool
+#undef true
+#undef false
+
+s32 g_DebuggerActive = FALSE;
+s32 g_DebuggerTimePasses = TRUE;
+s32 g_DebuggerFrameAdvance = 0;
+
+u32 memaGetSize(void);
+
+}
+
+static SDL_Window *dbgwin = nullptr;
+static SDL_Renderer *dbgren = nullptr;
+
+static char xstr[64] = "0";
+static char ystr[64] = "0";
+static char zstr[64] = "0";
+static char gotostr[64] = "";
+
+static bool advanceHeld = false;
+
+static s32 propFilter = 0;
+static s32 objFilter = 0;
+
+static const char *propTypes[9];
+static const char *objTypes[0x3c];
+
+static bool expandLatch = false;
+static bool expandValue = false;
+
+static bool showPropInfo = false;
+static bool showActiveProps = true;
+
+static void *focusPtr = nullptr;
+
+static struct prop *lookatprop = nullptr;
+static struct hitthing lookathit;
+static bool lookathitset;
+
+static inline const char *fmtCoord(const coord& crd)
+{
+	static char tmp[128];
+	snprintf(tmp, sizeof(tmp), "(%.2f, %.2f, %.2f)", crd.x, crd.y, crd.z);
+	return tmp;
+}
+
+#define DEF_ACT_NAME(x) case x: return #x;
+
+static inline const char *fmtActionType(s8 at)
+{
+	switch (at) {
+		DEF_ACT_NAME(ACT_INIT            )
+		DEF_ACT_NAME(ACT_STAND           )
+		DEF_ACT_NAME(ACT_KNEEL           )
+		DEF_ACT_NAME(ACT_ANIM            )
+		DEF_ACT_NAME(ACT_DIE             )
+		DEF_ACT_NAME(ACT_DEAD            )
+		DEF_ACT_NAME(ACT_ARGH            )
+		DEF_ACT_NAME(ACT_PREARGH         )
+		DEF_ACT_NAME(ACT_ATTACK          )
+		DEF_ACT_NAME(ACT_ATTACKWALK      )
+		DEF_ACT_NAME(ACT_ATTACKROLL      )
+		DEF_ACT_NAME(ACT_SIDESTEP        )
+		DEF_ACT_NAME(ACT_JUMPOUT         )
+		DEF_ACT_NAME(ACT_RUNPOS          )
+		DEF_ACT_NAME(ACT_PATROL          )
+		DEF_ACT_NAME(ACT_GOPOS           )
+		DEF_ACT_NAME(ACT_SURRENDER       )
+		DEF_ACT_NAME(ACT_LOOKATTARGET    )
+		DEF_ACT_NAME(ACT_SURPRISED       )
+		DEF_ACT_NAME(ACT_STARTALARM      )
+		DEF_ACT_NAME(ACT_THROWGRENADE    )
+		DEF_ACT_NAME(ACT_TURNDIR         )
+		DEF_ACT_NAME(ACT_TEST            )
+		DEF_ACT_NAME(ACT_BONDINTRO       )
+		DEF_ACT_NAME(ACT_BONDDIE         )
+		DEF_ACT_NAME(ACT_BONDMULTI       )
+		DEF_ACT_NAME(ACT_NULL            )
+		DEF_ACT_NAME(ACT_BOT_ATTACKSTAND )
+		DEF_ACT_NAME(ACT_BOT_ATTACKKNEEL )
+		DEF_ACT_NAME(ACT_BOT_ATTACKSTRAFE)
+		DEF_ACT_NAME(ACT_DRUGGEDDROP     )
+		DEF_ACT_NAME(ACT_DRUGGEDKO       )
+		DEF_ACT_NAME(ACT_DRUGGEDCOMINGUP )
+		DEF_ACT_NAME(ACT_ATTACKAMOUNT    )
+		DEF_ACT_NAME(ACT_ROBOTATTACK     )
+		DEF_ACT_NAME(ACT_SKJUMP          )
+		DEF_ACT_NAME(ACT_PUNCH           )
+		DEF_ACT_NAME(ACT_CUTFIRE         )
+		default: return "ACT";
+	}
+}
+
+static inline const char *fmtPropType(u8 at)
+{
+	switch (at) {
+		DEF_ACT_NAME(PROPTYPE_OBJ)
+		DEF_ACT_NAME(PROPTYPE_DOOR)
+		DEF_ACT_NAME(PROPTYPE_CHR)
+		DEF_ACT_NAME(PROPTYPE_WEAPON)
+		DEF_ACT_NAME(PROPTYPE_EYESPY)
+		DEF_ACT_NAME(PROPTYPE_PLAYER)
+		DEF_ACT_NAME(PROPTYPE_EXPLOSION)
+		DEF_ACT_NAME(PROPTYPE_SMOKE)
+		default: return "Prop";
+	}
+}
+
+static inline const char *fmtObjType(u8 at)
+{
+	switch (at) {
+		DEF_ACT_NAME(OBJTYPE_DOOR              )
+		DEF_ACT_NAME(OBJTYPE_DOORSCALE         )
+		DEF_ACT_NAME(OBJTYPE_BASIC             )
+		DEF_ACT_NAME(OBJTYPE_KEY               )
+		DEF_ACT_NAME(OBJTYPE_ALARM             )
+		DEF_ACT_NAME(OBJTYPE_CCTV              )
+		DEF_ACT_NAME(OBJTYPE_AMMOCRATE         )
+		DEF_ACT_NAME(OBJTYPE_WEAPON            )
+		DEF_ACT_NAME(OBJTYPE_CHR               )
+		DEF_ACT_NAME(OBJTYPE_SINGLEMONITOR     )
+		DEF_ACT_NAME(OBJTYPE_MULTIMONITOR      )
+		DEF_ACT_NAME(OBJTYPE_HANGINGMONITORS   )
+		DEF_ACT_NAME(OBJTYPE_AUTOGUN           )
+		DEF_ACT_NAME(OBJTYPE_LINKGUNS          )
+		DEF_ACT_NAME(OBJTYPE_DEBRIS            )
+		DEF_ACT_NAME(OBJTYPE_10                )
+		DEF_ACT_NAME(OBJTYPE_HAT               )
+		DEF_ACT_NAME(OBJTYPE_GRENADEPROB       )
+		DEF_ACT_NAME(OBJTYPE_LINKLIFTDOOR      )
+		DEF_ACT_NAME(OBJTYPE_MULTIAMMOCRATE    )
+		DEF_ACT_NAME(OBJTYPE_SHIELD            )
+		DEF_ACT_NAME(OBJTYPE_TAG               )
+		DEF_ACT_NAME(OBJTYPE_BEGINOBJECTIVE    )
+		DEF_ACT_NAME(OBJTYPE_ENDOBJECTIVE      )
+		DEF_ACT_NAME(OBJECTIVETYPE_DESTROYOBJ  )
+		DEF_ACT_NAME(OBJECTIVETYPE_COMPFLAGS   )
+		DEF_ACT_NAME(OBJECTIVETYPE_FAILFLAGS   )
+		DEF_ACT_NAME(OBJECTIVETYPE_COLLECTOBJ  )
+		DEF_ACT_NAME(OBJECTIVETYPE_THROWOBJ    )
+		DEF_ACT_NAME(OBJECTIVETYPE_HOLOGRAPH   )
+		DEF_ACT_NAME(OBJECTIVETYPE_1F          )
+		DEF_ACT_NAME(OBJECTIVETYPE_ENTERROOM   )
+		DEF_ACT_NAME(OBJECTIVETYPE_THROWINROOM )
+		DEF_ACT_NAME(OBJTYPE_22                )
+		DEF_ACT_NAME(OBJTYPE_BRIEFING          )
+		DEF_ACT_NAME(OBJTYPE_GASBOTTLE         )
+		DEF_ACT_NAME(OBJTYPE_RENAMEOBJ         )
+		DEF_ACT_NAME(OBJTYPE_PADLOCKEDDOOR     )
+		DEF_ACT_NAME(OBJTYPE_TRUCK             )
+		DEF_ACT_NAME(OBJTYPE_HELI              )
+		DEF_ACT_NAME(OBJTYPE_29                )
+		DEF_ACT_NAME(OBJTYPE_GLASS             )
+		DEF_ACT_NAME(OBJTYPE_SAFE              )
+		DEF_ACT_NAME(OBJTYPE_SAFEITEM          )
+		DEF_ACT_NAME(OBJTYPE_TANK              )
+		DEF_ACT_NAME(OBJTYPE_CAMERAPOS         )
+		DEF_ACT_NAME(OBJTYPE_TINTEDGLASS       )
+		DEF_ACT_NAME(OBJTYPE_LIFT              )
+		DEF_ACT_NAME(OBJTYPE_CONDITIONALSCENERY)
+		DEF_ACT_NAME(OBJTYPE_BLOCKEDPATH       )
+		DEF_ACT_NAME(OBJTYPE_HOVERBIKE         )
+		DEF_ACT_NAME(OBJTYPE_END               )
+		DEF_ACT_NAME(OBJTYPE_HOVERPROP         )
+		DEF_ACT_NAME(OBJTYPE_FAN               )
+		DEF_ACT_NAME(OBJTYPE_HOVERCAR          )
+		DEF_ACT_NAME(OBJTYPE_PADEFFECT         )
+		DEF_ACT_NAME(OBJTYPE_CHOPPER           )
+		DEF_ACT_NAME(OBJTYPE_MINE              )
+		DEF_ACT_NAME(OBJTYPE_ESCASTEP          )
+		default: return "Obj";
+	}
+}
+
+#undef DEF_ACT_NAME
+
+extern "C" void debuggerInit(void)
+{
+	SDL_Window *parent = (SDL_Window *)videoGetWindowHandle();
+
+	int px = 0;
+	int py = 0;
+	int pw = 0;
+	int ph = 0;
+	// in windowed mode put the debugger to the right of the window
+	if ((SDL_GetWindowFlags(parent) & SDL_WINDOW_FULLSCREEN_DESKTOP) == 0) {
+		SDL_GetWindowPosition(parent, &px, &py);
+		SDL_GetWindowSize(parent, &pw, &ph);
+	}
+
+	const Uint32 winflags = SDL_WINDOW_RESIZABLE;
+	dbgwin = SDL_CreateWindow("Debugger", px + pw + 4, py, 320, ph, winflags);
+	if (!dbgwin) {
+		sysLogPrintf(LOG_ERROR, "DBG: could not create SDL window: %s", SDL_GetError());
+		return;
+	}
+
+	// can't trust any hardware accelerated windows to live in harmony with our main window, so force SW
+	dbgren = SDL_CreateRenderer(dbgwin, -1, SDL_RENDERER_SOFTWARE);
+	if (!dbgren) {
+		sysLogPrintf(LOG_ERROR, "DBG: could not create SDL renderer: %s", SDL_GetError());
+		return;
+	}
+
+	IMGUI_CHECKVERSION();
+	ImGui::CreateContext();
+
+	ImGuiIO& io = ImGui::GetIO();
+	io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
+	io.IniFilename = nullptr;
+
+	ImGui::StyleColorsDark();
+
+	ImGui_ImplSDL2_InitForSDLRenderer(dbgwin, dbgren);
+	ImGui_ImplSDLRenderer2_Init(dbgren);
+
+	propTypes[0] = "NONE";
+	for (s32 i = 1; i < ARRAYCOUNT(propTypes); ++i) {
+		propTypes[i] = fmtPropType(i);
+	}
+
+	objTypes[0] = "NONE";
+	for (s32 i = 1; i < ARRAYCOUNT(objTypes); ++i) {
+		objTypes[i] = fmtObjType(i);
+	}
+
+	g_DebuggerActive = TRUE;
+}
+
+static inline void debuggerHotKey(const s32 key, const bool pressed)
+{
+	switch (key) {
+		case SDLK_F1:
+			if (pressed)
+				g_DebuggerTimePasses ^= 1;
+			break;
+		case SDLK_F2:
+			if (pressed)
+				g_DebuggerFrameAdvance = 1;
+			break;
+		case SDLK_F3:
+			if (pressed)
+				g_DebuggerFrameAdvance = 5;
+			break;
+		case SDLK_F4:
+			advanceHeld = pressed;
+			break;
+		case SDLK_F5:
+			if (pressed) {
+				if (g_TickRateDiv <= 1) {
+					g_TickRateDiv = 2;
+				} else {
+					g_TickRateDiv = 1;
+				}
+			}
+			break;
+		case SDLK_F6:
+			if (pressed) {
+				g_TickRateDiv++;
+				if (g_TickRateDiv > 5) {
+					g_TickRateDiv = 0;
+				}
+			}
+			break;
+		default:
+			break;
+	}
+}
+
+extern "C" void debuggerProcessEvent(void *data)
+{
+	if (g_DebuggerActive) {
+		SDL_Event *e = (SDL_Event *)data;
+		if (e->type == SDL_KEYDOWN || e->type == SDL_KEYUP) {
+			debuggerHotKey(e->key.keysym.sym, e->type == SDL_KEYDOWN);
+		} else if (e->type == SDL_MOUSEBUTTONDOWN || e->type == SDL_MOUSEBUTTONUP) {
+			if (SDL_GetMouseFocus() != dbgwin || SDL_GetWindowID(dbgwin) != e->button.windowID) {
+				return;
+			}
+		} else if (e->type == SDL_MOUSEMOTION) {
+			if (SDL_GetMouseFocus() != dbgwin || SDL_GetWindowID(dbgwin) != e->motion.windowID) {
+				return;
+			}
+		} else if (e->type == SDL_MOUSEWHEEL) {
+			if (SDL_GetMouseFocus() != dbgwin || SDL_GetWindowID(dbgwin) != e->wheel.windowID) {
+				return;
+			}
+		}
+		ImGui_ImplSDL2_ProcessEvent(e);
+	}
+}
+
+extern "C" void debuggerStartFrame(void)
+{
+	ImGui_ImplSDLRenderer2_NewFrame();
+	ImGui_ImplSDL2_NewFrame();
+	ImGui::NewFrame();
+}
+
+static inline bool debuggerGetSurfaceInfo(struct hitthing *hit)
+{
+	struct coord endpos;
+	endpos.x = g_Vars.currentplayer->cam_pos.x + g_Vars.currentplayer->cam_look.x * 10000.f;
+	endpos.y = g_Vars.currentplayer->cam_pos.y + g_Vars.currentplayer->cam_look.y * 10000.f;
+	endpos.z = g_Vars.currentplayer->cam_pos.z + g_Vars.currentplayer->cam_look.z * 10000.f;
+
+	// get what rooms the LOS goes through
+	RoomNum outrooms[17], tmprooms[8], srcrooms[2];
+	srcrooms[0] = g_Vars.currentplayer->cam_room;
+	srcrooms[1] = -1;
+	outrooms[16] = -1;
+	portal00018148(&g_Vars.currentplayer->cam_pos, &endpos, srcrooms, tmprooms, outrooms, 16);
+
+	// no prop was hit; check for bg hits
+	for (s32 i = 0; outrooms[i] != -1; ++i) {
+		if (bgTestHitInRoom(&g_Vars.currentplayer->cam_pos, &endpos, outrooms[i], hit)) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+extern "C" void debuggerUpdatePropInfo(s32 clear)
+{
+	if (showPropInfo) {
+		if (clear) {
+			lookatprop = nullptr;
+			lookathitset = false;
+		} else {
+			lookatprop = propFindAimingAt(HAND_RIGHT, false, FINDPROPCONTEXT_QUERY);
+			if (!lookatprop) {
+				// if we aren't looking at a prop, try to get the surface we're looking at
+				lookathitset = debuggerGetSurfaceInfo(&lookathit);
+			} else {
+				lookathitset = false;
+			}
+		}
+	} else {
+		lookatprop = nullptr;
+		lookathitset = false;
+	}
+}
+
+static inline void debuggerTeleportPlayer(struct coord& crd)
+{
+	sysLogPrintf(LOG_NOTE, "DBG: teleporting player 1 to (%.2f, %.2f, %.2f)", crd.x, crd.y, crd.z);
+
+	if (!g_Vars.players[0] || !g_Vars.players[0]->prop) {
+		sysLogPrintf(LOG_NOTE, "DBG: no player 1 or player 1 has no prop");
+		return;
+	}
+
+	struct chrdata *playerchr = g_Vars.players[0]->prop->chr;
+	if (!playerchr) {
+		sysLogPrintf(LOG_NOTE, "DBG: player 1 has no chr");
+		return;
+	}
+
+	RoomNum inrooms[9] = { -1 };
+	RoomNum aboverooms[9] = { -1 };
+
+	bgFindRoomsByPos(&crd, inrooms, aboverooms, 8, NULL);
+
+	RoomNum *rooms = NULL;
+	if (inrooms[0] != -1) {
+		rooms = inrooms;
+	} else if (aboverooms[0] != -1) {
+		rooms = aboverooms;
+	}
+
+	if (rooms) {
+		const u32 old = playerchr->hidden;
+		playerchr->hidden |= CHRHFLAG_WARPONSCREEN;
+		chrMoveToPos(playerchr, &crd, rooms, g_Vars.players[0]->vv_theta, true);
+		if ((old & CHRHFLAG_WARPONSCREEN) == 0) {
+			playerchr->hidden &= ~CHRHFLAG_WARPONSCREEN;
+		}
+	} else {
+		sysLogPrintf(LOG_NOTE, "DBG: could not find any rooms at teleport destination");
+	}
+}
+
+static inline void debuggerKillChr(struct chrdata *chr)
+{
+	struct coord dmgdir = { 0.f, 0.f, 0.f };
+	chrDamageByImpact(chr, 10000.f, &dmgdir, nullptr, nullptr, HITPART_GENERAL);
+}
+
+static inline void debuggerKillPlayer(void)
+{
+	sysLogPrintf(LOG_NOTE, "DBG: killing player 1");
+
+	if (!g_Vars.players[0] || !g_Vars.players[0]->prop) {
+		sysLogPrintf(LOG_NOTE, "DBG: no player 1 or player 1 has no prop");
+		return;
+	}
+
+	struct chrdata *playerchr = g_Vars.players[0]->prop->chr;
+	if (!playerchr) {
+		sysLogPrintf(LOG_NOTE, "DBG: player 1 has no chr");
+		return;
+	}
+
+	debuggerKillChr(playerchr);
+}
+
+static inline void debuggerHealPlayer(void)
+{
+	sysLogPrintf(LOG_NOTE, "DBG: healing player 1");
+
+	if (!g_Vars.players[0] || !g_Vars.players[0]->prop) {
+		sysLogPrintf(LOG_NOTE, "DBG: no player 1 or player 1 has no prop");
+		return;
+	}
+
+	player *prev = g_Vars.currentplayer;
+	g_Vars.currentplayer = g_Vars.players[0];
+	playerDisplayHealth();
+	g_Vars.currentplayer->bondhealth = 1.f;
+	g_Vars.currentplayer = prev;
+}
+
+static inline void describeHand(hand *hand)
+{
+	ImGui::Text("Gun num:  %02x", hand->gset.weaponnum);
+	ImGui::Text("Gun func: %02x", hand->gset.weaponfunc);
+	ImGui::Text("Aim pos: %s", fmtCoord(hand->aimpos));
+	ImGui::Text("Hit pos: %s", fmtCoord(hand->hitpos));
+}
+
+static inline std::string& describeRoomList(RoomNum *rooms, s32 maxRooms, std::string& out)
+{
+	for (s32 i = 0; i < maxRooms && rooms[i] >= 0; ++i) {
+		out += strFmt("%03x ", rooms[i]);
+	}
+	return out;
+}
+
+static inline void describeProjectile(projectile *prj)
+{
+	ImGui::Text("Drop type: %04x", (u16)prj->droptype);
+	ImGui::Text("Flags: %08x", prj->flags);
+	ImGui::Text("Vel: %s", fmtCoord(prj->speed));
+}
+
+static inline void describeObj(defaultobj *obj)
+{
+	ImGui::Text("Type: %s (%02x)", fmtObjType(obj->type), obj->type);
+	ImGui::Text("Model: %04x", (u16)obj->modelnum);
+	ImGui::Text("Pad: %04x", (u16)obj->pad);
+	ImGui::Text("Flags 1: %08x", obj->flags);
+	ImGui::Text("Flags 2: %08x", obj->flags2);
+	ImGui::Text("Flags 3: %08x", obj->flags3);
+	ImGui::Text("Hidden 1: %08x", obj->hidden);
+	ImGui::Text("Hidden 2: %02x", obj->hidden2);
+
+	if ((obj->hidden & OBJHFLAG_PROJECTILE) && obj->projectile) {
+		if (ImGui::TreeNode(strFmt("Projectile (%p)", obj->projectile))) {
+			describeProjectile(obj->projectile);
+			ImGui::TreePop();
+		}
+	}
+}
+
+static inline void describeWeapon(weaponobj *wpn)
+{
+	ImGui::Text("Gun num:  %02x", wpn->weaponnum);
+	ImGui::Text("Gun func: %02x", wpn->gunfunc);
+	ImGui::Text("Fade out timer (60hz): %d", wpn->fadeouttimer60);
+	ImGui::Text("Timer (240hz): %d", wpn->timer240);
+}
+
+static inline void describeProp(prop *prop);
+
+static inline void describeChr(chrdata *chr)
+{
+	ImGui::Text("Number: %04x", (u16)chr->chrnum);
+	ImGui::Text("Flags 1: %08x", chr->flags);
+	ImGui::Text("Flags 2: %08x", chr->flags2);
+	ImGui::Text("Hidden 1: %08x", chr->hidden);
+	ImGui::Text("Hidden 2: %04x", chr->hidden2);
+	ImGui::Text("Chr flags: %08x", chr->chrflags);
+	ImGui::Text("Damage: %.3f", chr->damage);
+	ImGui::Text("Shield: %.3f", chr->cshield);
+	ImGui::Text("Body: %04x", (u16)chr->bodynum);
+	ImGui::Text("Head: %02x", (u8)chr->headnum);
+	ImGui::Text("Team: %02x", chr->team);
+	ImGui::Text("Tude: %02x", chr->tude);
+	ImGui::Text("Action: %s (%02x)", fmtActionType(chr->actiontype), (u8)chr->actiontype);
+
+	ImGui::Separator();
+
+	if (chr->weapons_held[HAND_RIGHT]) {
+		if (ImGui::TreeNode(strFmt("Right hand prop (%p)", chr->weapons_held[HAND_RIGHT]))) {
+			describeProp(chr->weapons_held[HAND_RIGHT]);
+			ImGui::TreePop();
+		}
+	}
+	if (chr->weapons_held[HAND_LEFT]) {
+		if (ImGui::TreeNode(strFmt("Left hand prop (%p)", chr->weapons_held[HAND_LEFT]))) {
+			describeProp(chr->weapons_held[HAND_LEFT]);
+			ImGui::TreePop();
+		}
+	}
+	if (chr->weapons_held[2]) {
+		if (ImGui::TreeNode(strFmt("Hat prop (%p)", chr->weapons_held[2]))) {
+			describeProp(chr->weapons_held[2]);
+			ImGui::TreePop();
+		}
+	}
+
+	ImGui::SeparatorText("Controls");
+
+	if (ImGui::Button("Kill")) {
+		debuggerKillChr(chr);
+	}
+
+	ImGui::SameLine();
+
+	if (ImGui::Button("Heal")) {
+		chr->damage = 0.f;
+	}
+
+	ImGui::SameLine();
+
+	if (ImGui::Button("Sleep")) {
+		chr->sleep = 127;
+	}
+
+	ImGui::SameLine();
+
+	if (ImGui::Button("Wake")) {
+		chr->sleep = 0;
+	}
+
+	// line break
+
+	if (ImGui::Button("Drop guns")) {
+		chrDropItemsForOwnerReap(chr);
+	}
+}
+
+static inline void describeProp(prop *prop)
+{
+	ImGui::Text(prop->active ? "Active" : "Inactive");
+	ImGui::Text("Type: %s (%02x)", fmtPropType(prop->type), prop->type);
+	ImGui::Text("Flags: %02x", prop->flags);
+	ImGui::Text("Pos: %s", fmtCoord(prop->pos));
+
+	std::string roomstr = "";
+	ImGui::Text("Rooms: %s", describeRoomList(prop->rooms, ARRAYCOUNT(prop->rooms), roomstr).c_str());
+
+	if (prop->obj) {
+		if (expandLatch) {
+			ImGui::SetNextItemOpen(expandValue);
+		}
+		if (ImGui::TreeNode(strFmt("%s (%p)", fmtObjType(prop->obj->type), prop->obj))) {
+			describeObj(prop->obj);
+			ImGui::TreePop();
+		}
+	}
+
+	if ((prop->type == PROPTYPE_CHR || prop->type == PROPTYPE_PLAYER || prop->type == PROPTYPE_EYESPY) && prop->chr) {
+		if (expandLatch) {
+			ImGui::SetNextItemOpen(expandValue);
+		}
+		if (ImGui::TreeNode(strFmt("Chr (%p)", prop->chr))) {
+			describeChr(prop->chr);
+			ImGui::TreePop();
+		}
+	} else if (prop->type == PROPTYPE_WEAPON && prop->weapon) {
+		if (expandLatch) {
+			ImGui::SetNextItemOpen(expandValue);
+		}
+		if (ImGui::TreeNode(strFmt("Weapon (%p)", prop->weapon))) {
+			describeWeapon(prop->weapon);
+			ImGui::TreePop();
+		}
+	}
+}
+
+static inline void describePlayer(player *plr)
+{
+	ImGui::Text("Cam pos: %s", fmtCoord(plr->cam_pos));
+	ImGui::Text("Cam look: %s", fmtCoord(plr->cam_look));
+	ImGui::Text("Cam room: %03x", (u32)plr->cam_room);
+
+	ImGui::Separator();
+
+	ImGui::Text("Health: %.3f", plr->bondhealth);
+	ImGui::Text("Shield: %.3f", plr->apparentarmour);
+
+	ImGui::Separator();
+
+	if (plr->prop) {
+		if (ImGui::TreeNode(strFmt("Prop (%p)", plr->prop))) {
+			describeProp(plr->prop);
+			ImGui::TreePop();
+		}
+	}
+
+	ImGui::Separator();
+
+	if (ImGui::TreeNode("Right hand")) {
+		describeHand(&plr->hands[HAND_RIGHT]);
+		ImGui::TreePop();
+	}
+	if (ImGui::TreeNode("Left hand")) {
+		describeHand(&plr->hands[HAND_LEFT]);
+		ImGui::TreePop();
+	}
+}
+
+extern "C" void debuggerFrame(void)
+{
+	if (!g_DebuggerActive) {
+		return;
+	}
+
+	if (advanceHeld) {
+		g_DebuggerFrameAdvance = 1;
+	}
+
+	expandLatch = false;
+
+	ImGuiIO& io = ImGui::GetIO();
+
+	ImGui::SetNextWindowPos(ImVec2(0.f, 0.f));
+	ImGui::SetNextWindowSize(io.DisplaySize);
+	ImGui::Begin("Debugger", nullptr, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoTitleBar);
+
+	if (ImGui::CollapsingHeader("Debug")) {
+		ImGui::SeparatorText("Player");
+
+		ImGui::PushItemWidth(56.f);
+		ImGui::InputText("X", xstr, IM_ARRAYSIZE(xstr) - 1, ImGuiInputTextFlags_CharsNoBlank | ImGuiInputTextFlags_CharsDecimal);
+		ImGui::SameLine();
+		ImGui::InputText("Y", ystr, IM_ARRAYSIZE(ystr) - 1, ImGuiInputTextFlags_CharsNoBlank | ImGuiInputTextFlags_CharsDecimal);
+		ImGui::SameLine();
+		ImGui::InputText("Z", zstr, IM_ARRAYSIZE(zstr) - 1, ImGuiInputTextFlags_CharsNoBlank | ImGuiInputTextFlags_CharsDecimal);
+		ImGui::SameLine();
+		ImGui::PopItemWidth();
+		if (ImGui::Button("Warp")) {
+			struct coord crd;
+			crd.x = std::atof(xstr);
+			crd.y = std::atof(ystr);
+			crd.z = std::atof(zstr);
+			debuggerTeleportPlayer(crd);
+		}
+
+		if (ImGui::Button("Kill")) {
+			debuggerKillPlayer();
+		}
+		ImGui::SameLine();
+		if (ImGui::Button("Heal")) {
+			debuggerHealPlayer();
+		}
+
+		ImGui::SeparatorText("Time");
+
+		bool timePasses = (g_DebuggerTimePasses != 0);
+		if (ImGui::Checkbox("Time passes", &timePasses)) {
+			g_DebuggerTimePasses = (s32)timePasses;
+		}
+
+		s32 framediv = g_TickRateDiv;
+		if (ImGui::InputInt("Tickrate", &framediv, 1, 2)) {
+			if (framediv >= 0 && framediv < 60) {
+				g_TickRateDiv = framediv;
+				g_Vars.mininc60 = framediv;
+			}
+		}
+
+		if (ImGui::Button("+1 frame")) {
+			g_DebuggerFrameAdvance = 1;
+		}
+		ImGui::SameLine();
+		if (ImGui::Button("+5 frames")) {
+			g_DebuggerFrameAdvance = 5;
+		}
+		ImGui::SameLine();
+		if (ImGui::Button("+10 frames")) {
+			g_DebuggerFrameAdvance = 10;
+		}
+
+		ImGui::SeparatorText("Other");
+	}
+
+	if (ImGui::CollapsingHeader("Time")) {
+		ImGui::Text("Level Frame#: %d", g_Vars.lvframenum);
+		ImGui::Text("Level Tick (60hz): %d", g_Vars.lvframe60);
+		ImGui::Text("Level Tick (240hz): %d", g_Vars.lvframe240);
+		ImGui::Separator();
+		ImGui::Text("Frame Time (60hz): %.2f", g_Vars.diffframe60f);
+		ImGui::Text("Frame Time (240hz): %.2f", g_Vars.diffframe240f);
+		ImGui::Separator();
+		ImGui::Text("Lost Time (60hz): %d", g_Vars.lostframetime60t);
+		ImGui::Text("Lost Time (240hz): %d", g_Vars.lostframetime240t);
+	}
+
+	if (ImGui::CollapsingHeader("Players")) {
+		for (s32 i = 0; i < ARRAYCOUNT(g_Vars.players); ++i) {
+			auto plr = g_Vars.players[i];
+			if (plr) {
+				if (ImGui::TreeNode(strFmt("Player %d (%p)###Player%p", i + 1, plr, plr))) {
+					describePlayer(plr);
+					ImGui::TreePop();
+				}
+			}
+		}
+	}
+
+	if (g_Vars.activeprops && g_Vars.activeprops != g_Vars.activepropstail) {
+		if (ImGui::CollapsingHeader("Props")) {
+			ImGui::Text("Visible: %d", g_Vars.numonscreenprops);
+
+			ImGui::Separator();
+
+			ImGui::Checkbox("Active props only", &showActiveProps);
+
+			ImGui::Combo("Filter prop", &propFilter, propTypes, ARRAYCOUNT(propTypes));
+			ImGui::Combo("Filter obj", &objFilter, objTypes, ARRAYCOUNT(objTypes));
+
+			if (ImGui::Button("Expand all")) {
+				expandLatch = true;
+				expandValue = true;
+			}
+			ImGui::SameLine();
+			if (ImGui::Button("Close all")) {
+				expandLatch = true;
+				expandValue = false;
+			}
+
+			ImGui::Separator();
+
+			auto showProp = [&](struct prop *prop) {
+				if (prop && (!propFilter || propFilter == prop->type)) {
+					if (!objFilter || (prop->obj && prop->obj->type == objFilter)) {
+						const bool focus = (focusPtr && ((void *)prop == focusPtr || (void *)prop->obj == focusPtr));
+						if (expandLatch) {
+							ImGui::SetNextItemOpen(expandValue);
+						} else if (focus) {
+							ImGui::SetNextItemOpen(true);
+							focusPtr = nullptr;
+						}
+						if (ImGui::TreeNode(strFmt("%s (%p)###Prop%p", fmtPropType(prop->type), prop, prop))) {
+							if (focus) {
+								ImGui::SetScrollHereY();
+							}
+							describeProp(prop);
+							ImGui::TreePop();
+						}
+					}
+				}
+			};
+
+			if (showActiveProps) {
+				// show the active props list
+				struct prop *prop;
+				struct prop *next;
+				bool done;
+				prop = g_Vars.activeprops;
+				do {
+					next = prop->next;
+					done = next == g_Vars.pausedprops;
+					showProp(prop);
+					prop = next;
+				} while (!done);
+			} else {
+				// show all props
+				for (s32 i = 0; i < g_Vars.maxprops; ++i) {
+					struct prop *prop = &g_Vars.props[i];
+					showProp(prop);
+				}
+			}
+		}
+	}
+
+	if (g_ChrSlots && g_NumChrSlots) {
+		if (ImGui::CollapsingHeader("Characters")) {
+			ImGui::Text("Count: %d/%d", g_NumChrs, g_NumChrSlots);
+			ImGui::Separator();
+			for (s32 i = 0; i < g_NumChrSlots; ++i) {
+				if (g_ChrSlots[i].chrnum >= 0) {
+					if (ImGui::TreeNode(strFmt("Slot %3d: %04x (%p)", i, g_ChrSlots[i].chrnum, &g_ChrSlots[i]))) {
+						describeChr(&g_ChrSlots[i]);
+						if (g_ChrSlots[i].prop && ImGui::TreeNode(strFmt("Prop (%p)##chr", g_ChrSlots[i].prop))) {
+							describeProp(g_ChrSlots[i].prop);
+							ImGui::TreePop();
+						}
+						ImGui::TreePop();
+					}
+				}
+			}
+		}
+	}
+
+	if (ImGui::CollapsingHeader("Stage")) {
+		ImGui::Text("Number: %02x", g_Vars.stagenum);
+		ImGui::Text("Index:  %02x", g_StageIndex);
+		ImGui::Text("Setup:  %s", romdataFileGetName(g_Stages[g_StageIndex].setupfileid));
+		ImGui::Text("Room count: %d", g_Vars.roomcount);
+		if (g_Rooms && ImGui::TreeNode("Rooms")) {
+			ImGui::Separator();
+			for (s32 i = 1; i < g_Vars.roomcount; ++i) {
+				if (ImGui::TreeNode(strFmt("Room %03x", i))) {
+					ImGui::Text("Loaded: %d", g_Rooms[i].loaded240);
+					ImGui::Text("Flags: %04x", g_Rooms[i].flags);
+					ImGui::Text("Portals: %d", g_Rooms[i].numportals);
+					ImGui::Text("Centre: %s", fmtCoord(g_Rooms[i].centre));
+					ImGui::TreePop();
+				}
+			}
+			ImGui::TreePop();
+		}
+	}
+
+	if (ImGui::CollapsingHeader("Memory")) {
+		ImGui::Text("Mema size: %uk", memaGetSize() / 1024);
+		ImGui::Spacing();
+		if (ImGui::TreeNode("Memp state")) {
+			if (ImGui::BeginTable("MemaTab", 3)) {
+				ImGui::TableNextColumn();
+				ImGui::Text("Pool");
+				ImGui::TableNextColumn();
+				ImGui::Text("Onboard");
+				ImGui::TableNextColumn();
+				ImGui::Text("Expansion");
+				for (u8 i = MEMPOOL_STAGE; i <= MEMPOOL_PERMANENT; i += 2) {
+					ImGui::TableNextRow();
+					ImGui::TableNextColumn();
+					ImGui::Text((i == MEMPOOL_STAGE) ? "Stage" : "Permanent");
+					ImGui::TableNextColumn();
+					ImGui::Text("%uk/%uk", mempGetPoolFree(i, MEMBANK_ONBOARD) / 1024, mempGetPoolSize(i, MEMBANK_ONBOARD) / 1024);
+					ImGui::TableNextColumn();
+					ImGui::Text("%uk/%uk", mempGetPoolFree(i, MEMBANK_EXPANSION) / 1024, mempGetPoolSize(i, MEMBANK_EXPANSION) / 1024);
+				}
+				ImGui::EndTable();
+			}
+			ImGui::TreePop();
+		}
+	}
+
+	if ((showPropInfo = ImGui::CollapsingHeader("Looking at"))) {
+		if (lookatprop) {
+			ImGui::Text("Looking at prop");
+			describeProp(lookatprop);
+		} else if (lookathitset) {
+			ImGui::Text("Looking at surface");
+			ImGui::Text("Hit pos: %s", fmtCoord(lookathit.pos));
+			ImGui::Text("Texture: %04x", lookathit.texturenum);
+		} else {
+			ImGui::Text("Looking at nothing");
+		}
+	}
+
+	ImGui::End();
+}
+
+extern "C" void debuggerEndFrame(void)
+{
+	ImGui::Render();
+	ImGuiIO& io = ImGui::GetIO();
+	SDL_RenderSetScale(dbgren, io.DisplayFramebufferScale.x, io.DisplayFramebufferScale.y);
+	SDL_SetRenderDrawColor(dbgren, 0, 0, 0, 255);
+	SDL_RenderClear(dbgren);
+	ImGui_ImplSDLRenderer2_RenderDrawData(ImGui::GetDrawData());
+	SDL_RenderPresent(dbgren);
+}

port/src/fs.c

@@ -114,7 +114,7 @@ s32 fsInit(void)
 		if (!portable) {
 			if (fsFileSize("./" DEFAULT_BASEDIR_NAME) >= 0) {
 				path = "./" DEFAULT_BASEDIR_NAME;
-			} else if (fsFileSize("$H/" DEFAULT_BASEDIR_NAME) >= 0) {
+			} else if (fsFileSize("$H/" DEFAULT_BASEDIR_NAME)) {
 				path = "$H/" DEFAULT_BASEDIR_NAME;
 			}
 		}

port/src/imgui/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2023 Omar Cornut
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

port/src/imgui/backends/imgui_impl_sdl2.h

@@ -0,0 +1,46 @@
+// dear imgui: Platform Backend for SDL2
+// This needs to be used along with a Renderer (e.g. DirectX11, OpenGL3, Vulkan..)
+// (Info: SDL2 is a cross-platform general purpose library for handling windows, inputs, graphics context creation, etc.)
+
+// Implemented features:
+//  [X] Platform: Clipboard support.
+//  [X] Platform: Mouse support. Can discriminate Mouse/TouchScreen.
+//  [X] Platform: Keyboard support. Since 1.87 we are using the io.AddKeyEvent() function. Pass ImGuiKey values to all key functions e.g. ImGui::IsKeyPressed(ImGuiKey_Space). [Legacy SDL_SCANCODE_* values will also be supported unless IMGUI_DISABLE_OBSOLETE_KEYIO is set]
+//  [X] Platform: Gamepad support. Enabled with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
+//  [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'.
+//  [X] Platform: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
+// Missing features:
+//  [ ] Platform: Multi-viewport + Minimized windows seems to break mouse wheel events (at least under Windows).
+//  [x] Platform: Basic IME support. App needs to call 'SDL_SetHint(SDL_HINT_IME_SHOW_UI, "1");' before SDL_CreateWindow()!.
+
+// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
+// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
+// Learn about Dear ImGui:
+// - FAQ                  https://dearimgui.com/faq
+// - Getting Started      https://dearimgui.com/getting-started
+// - Documentation        https://dearimgui.com/docs (same as your local docs/ folder).
+// - Introduction, links and more at the top of imgui.cpp
+
+#pragma once
+#include "imgui.h"      // IMGUI_IMPL_API
+#ifndef IMGUI_DISABLE
+
+struct SDL_Window;
+struct SDL_Renderer;
+typedef union SDL_Event SDL_Event;
+
+IMGUI_IMPL_API bool     ImGui_ImplSDL2_InitForOpenGL(SDL_Window* window, void* sdl_gl_context);
+IMGUI_IMPL_API bool     ImGui_ImplSDL2_InitForVulkan(SDL_Window* window);
+IMGUI_IMPL_API bool     ImGui_ImplSDL2_InitForD3D(SDL_Window* window);
+IMGUI_IMPL_API bool     ImGui_ImplSDL2_InitForMetal(SDL_Window* window);
+IMGUI_IMPL_API bool     ImGui_ImplSDL2_InitForSDLRenderer(SDL_Window* window, SDL_Renderer* renderer);
+IMGUI_IMPL_API bool     ImGui_ImplSDL2_InitForOther(SDL_Window* window);
+IMGUI_IMPL_API void     ImGui_ImplSDL2_Shutdown();
+IMGUI_IMPL_API void     ImGui_ImplSDL2_NewFrame();
+IMGUI_IMPL_API bool     ImGui_ImplSDL2_ProcessEvent(const SDL_Event* event);
+
+#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+static inline void ImGui_ImplSDL2_NewFrame(SDL_Window*) { ImGui_ImplSDL2_NewFrame(); } // 1.84: removed unnecessary parameter
+#endif
+
+#endif // #ifndef IMGUI_DISABLE

port/src/imgui/backends/imgui_impl_sdlrenderer2.cpp

@@ -0,0 +1,268 @@
+// dear imgui: Renderer Backend for SDL_Renderer for SDL2
+// (Requires: SDL 2.0.17+)
+
+// Note how SDL_Renderer is an _optional_ component of SDL2.
+// For a multi-platform app consider using e.g. SDL+DirectX on Windows and SDL+OpenGL on Linux/OSX.
+// If your application will want to render any non trivial amount of graphics other than UI,
+// please be aware that SDL_Renderer currently offers a limited graphic API to the end-user and
+// it might be difficult to step out of those boundaries.
+
+// Implemented features:
+//  [X] Renderer: User texture binding. Use 'SDL_Texture*' as ImTextureID. Read the FAQ about ImTextureID!
+//  [X] Renderer: Large meshes support (64k+ vertices) with 16-bit indices.
+// Missing features:
+//  [ ] Renderer: Multi-viewport support (multiple windows).
+
+// You can copy and use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
+// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
+// Learn about Dear ImGui:
+// - FAQ                  https://dearimgui.com/faq
+// - Getting Started      https://dearimgui.com/getting-started
+// - Documentation        https://dearimgui.com/docs (same as your local docs/ folder).
+// - Introduction, links and more at the top of imgui.cpp
+
+// CHANGELOG
+//  2023-05-30: Renamed imgui_impl_sdlrenderer.h/.cpp to imgui_impl_sdlrenderer2.h/.cpp to accommodate for upcoming SDL3.
+//  2022-10-11: Using 'nullptr' instead of 'NULL' as per our switch to C++11.
+//  2021-12-21: Update SDL_RenderGeometryRaw() format to work with SDL 2.0.19.
+//  2021-12-03: Added support for large mesh (64K+ vertices), enable ImGuiBackendFlags_RendererHasVtxOffset flag.
+//  2021-10-06: Backup and restore modified ClipRect/Viewport.
+//  2021-09-21: Initial version.
+
+#include "imgui.h"
+#ifndef IMGUI_DISABLE
+#include "imgui_impl_sdlrenderer2.h"
+#include <stdint.h>     // intptr_t
+
+// Clang warnings with -Weverything
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wsign-conversion"    // warning: implicit conversion changes signedness
+#endif
+
+// SDL
+#include <SDL.h>
+#if !SDL_VERSION_ATLEAST(2,0,17)
+#error This backend requires SDL 2.0.17+ because of SDL_RenderGeometry() function
+#endif
+
+// SDL_Renderer data
+struct ImGui_ImplSDLRenderer2_Data
+{
+    SDL_Renderer*   SDLRenderer;
+    SDL_Texture*    FontTexture;
+    ImGui_ImplSDLRenderer2_Data() { memset((void*)this, 0, sizeof(*this)); }
+};
+
+// Backend data stored in io.BackendRendererUserData to allow support for multiple Dear ImGui contexts
+// It is STRONGLY preferred that you use docking branch with multi-viewports (== single Dear ImGui context + multiple windows) instead of multiple Dear ImGui contexts.
+static ImGui_ImplSDLRenderer2_Data* ImGui_ImplSDLRenderer2_GetBackendData()
+{
+    return ImGui::GetCurrentContext() ? (ImGui_ImplSDLRenderer2_Data*)ImGui::GetIO().BackendRendererUserData : nullptr;
+}
+
+// Functions
+bool ImGui_ImplSDLRenderer2_Init(SDL_Renderer* renderer)
+{
+    ImGuiIO& io = ImGui::GetIO();
+    IM_ASSERT(io.BackendRendererUserData == nullptr && "Already initialized a renderer backend!");
+    IM_ASSERT(renderer != nullptr && "SDL_Renderer not initialized!");
+
+    // Setup backend capabilities flags
+    ImGui_ImplSDLRenderer2_Data* bd = IM_NEW(ImGui_ImplSDLRenderer2_Data)();
+    io.BackendRendererUserData = (void*)bd;
+    io.BackendRendererName = "imgui_impl_sdlrenderer2";
+    io.BackendFlags |= ImGuiBackendFlags_RendererHasVtxOffset;  // We can honor the ImDrawCmd::VtxOffset field, allowing for large meshes.
+
+    bd->SDLRenderer = renderer;
+
+    return true;
+}
+
+void ImGui_ImplSDLRenderer2_Shutdown()
+{
+    ImGui_ImplSDLRenderer2_Data* bd = ImGui_ImplSDLRenderer2_GetBackendData();
+    IM_ASSERT(bd != nullptr && "No renderer backend to shutdown, or already shutdown?");
+    ImGuiIO& io = ImGui::GetIO();
+
+    ImGui_ImplSDLRenderer2_DestroyDeviceObjects();
+
+    io.BackendRendererName = nullptr;
+    io.BackendRendererUserData = nullptr;
+    io.BackendFlags &= ~ImGuiBackendFlags_RendererHasVtxOffset;
+    IM_DELETE(bd);
+}
+
+static void ImGui_ImplSDLRenderer2_SetupRenderState()
+{
+	ImGui_ImplSDLRenderer2_Data* bd = ImGui_ImplSDLRenderer2_GetBackendData();
+
+	// Clear out any viewports and cliprect set by the user
+    // FIXME: Technically speaking there are lots of other things we could backup/setup/restore during our render process.
+	SDL_RenderSetViewport(bd->SDLRenderer, nullptr);
+	SDL_RenderSetClipRect(bd->SDLRenderer, nullptr);
+}
+
+void ImGui_ImplSDLRenderer2_NewFrame()
+{
+    ImGui_ImplSDLRenderer2_Data* bd = ImGui_ImplSDLRenderer2_GetBackendData();
+    IM_ASSERT(bd != nullptr && "Did you call ImGui_ImplSDLRenderer2_Init()?");
+
+    if (!bd->FontTexture)
+        ImGui_ImplSDLRenderer2_CreateDeviceObjects();
+}
+
+void ImGui_ImplSDLRenderer2_RenderDrawData(ImDrawData* draw_data)
+{
+	ImGui_ImplSDLRenderer2_Data* bd = ImGui_ImplSDLRenderer2_GetBackendData();
+
+	// If there's a scale factor set by the user, use that instead
+    // If the user has specified a scale factor to SDL_Renderer already via SDL_RenderSetScale(), SDL will scale whatever we pass
+    // to SDL_RenderGeometryRaw() by that scale factor. In that case we don't want to be also scaling it ourselves here.
+    float rsx = 1.0f;
+	float rsy = 1.0f;
+	SDL_RenderGetScale(bd->SDLRenderer, &rsx, &rsy);
+    ImVec2 render_scale;
+	render_scale.x = (rsx == 1.0f) ? draw_data->FramebufferScale.x : 1.0f;
+	render_scale.y = (rsy == 1.0f) ? draw_data->FramebufferScale.y : 1.0f;
+
+	// Avoid rendering when minimized, scale coordinates for retina displays (screen coordinates != framebuffer coordinates)
+	int fb_width = (int)(draw_data->DisplaySize.x * render_scale.x);
+	int fb_height = (int)(draw_data->DisplaySize.y * render_scale.y);
+	if (fb_width == 0 || fb_height == 0)
+		return;
+
+    // Backup SDL_Renderer state that will be modified to restore it afterwards
+    struct BackupSDLRendererState
+    {
+        SDL_Rect    Viewport;
+        bool        ClipEnabled;
+        SDL_Rect    ClipRect;
+    };
+    BackupSDLRendererState old = {};
+    old.ClipEnabled = SDL_RenderIsClipEnabled(bd->SDLRenderer) == SDL_TRUE;
+    SDL_RenderGetViewport(bd->SDLRenderer, &old.Viewport);
+    SDL_RenderGetClipRect(bd->SDLRenderer, &old.ClipRect);
+
+	// Will project scissor/clipping rectangles into framebuffer space
+	ImVec2 clip_off = draw_data->DisplayPos;         // (0,0) unless using multi-viewports
+	ImVec2 clip_scale = render_scale;
+
+    // Render command lists
+    ImGui_ImplSDLRenderer2_SetupRenderState();
+    for (int n = 0; n < draw_data->CmdListsCount; n++)
+    {
+        const ImDrawList* cmd_list = draw_data->CmdLists[n];
+        const ImDrawVert* vtx_buffer = cmd_list->VtxBuffer.Data;
+        const ImDrawIdx* idx_buffer = cmd_list->IdxBuffer.Data;
+
+        for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++)
+        {
+            const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i];
+            if (pcmd->UserCallback)
+            {
+                // User callback, registered via ImDrawList::AddCallback()
+                // (ImDrawCallback_ResetRenderState is a special callback value used by the user to request the renderer to reset render state.)
+                if (pcmd->UserCallback == ImDrawCallback_ResetRenderState)
+                    ImGui_ImplSDLRenderer2_SetupRenderState();
+                else
+                    pcmd->UserCallback(cmd_list, pcmd);
+            }
+            else
+            {
+                // Project scissor/clipping rectangles into framebuffer space
+                ImVec2 clip_min((pcmd->ClipRect.x - clip_off.x) * clip_scale.x, (pcmd->ClipRect.y - clip_off.y) * clip_scale.y);
+                ImVec2 clip_max((pcmd->ClipRect.z - clip_off.x) * clip_scale.x, (pcmd->ClipRect.w - clip_off.y) * clip_scale.y);
+                if (clip_min.x < 0.0f) { clip_min.x = 0.0f; }
+                if (clip_min.y < 0.0f) { clip_min.y = 0.0f; }
+                if (clip_max.x > (float)fb_width) { clip_max.x = (float)fb_width; }
+                if (clip_max.y > (float)fb_height) { clip_max.y = (float)fb_height; }
+                if (clip_max.x <= clip_min.x || clip_max.y <= clip_min.y)
+                    continue;
+
+                SDL_Rect r = { (int)(clip_min.x), (int)(clip_min.y), (int)(clip_max.x - clip_min.x), (int)(clip_max.y - clip_min.y) };
+                SDL_RenderSetClipRect(bd->SDLRenderer, &r);
+
+                const float* xy = (const float*)(const void*)((const char*)(vtx_buffer + pcmd->VtxOffset) + IM_OFFSETOF(ImDrawVert, pos));
+                const float* uv = (const float*)(const void*)((const char*)(vtx_buffer + pcmd->VtxOffset) + IM_OFFSETOF(ImDrawVert, uv));
+#if SDL_VERSION_ATLEAST(2,0,19)
+                const SDL_Color* color = (const SDL_Color*)(const void*)((const char*)(vtx_buffer + pcmd->VtxOffset) + IM_OFFSETOF(ImDrawVert, col)); // SDL 2.0.19+
+#else
+                const int* color = (const int*)(const void*)((const char*)(vtx_buffer + pcmd->VtxOffset) + IM_OFFSETOF(ImDrawVert, col)); // SDL 2.0.17 and 2.0.18
+#endif
+
+                // Bind texture, Draw
+				SDL_Texture* tex = (SDL_Texture*)pcmd->GetTexID();
+                SDL_RenderGeometryRaw(bd->SDLRenderer, tex,
+                    xy, (int)sizeof(ImDrawVert),
+                    color, (int)sizeof(ImDrawVert),
+                    uv, (int)sizeof(ImDrawVert),
+                    cmd_list->VtxBuffer.Size - pcmd->VtxOffset,
+                    idx_buffer + pcmd->IdxOffset, pcmd->ElemCount, sizeof(ImDrawIdx));
+            }
+        }
+    }
+
+    // Restore modified SDL_Renderer state
+    SDL_RenderSetViewport(bd->SDLRenderer, &old.Viewport);
+    SDL_RenderSetClipRect(bd->SDLRenderer, old.ClipEnabled ? &old.ClipRect : nullptr);
+}
+
+// Called by Init/NewFrame/Shutdown
+bool ImGui_ImplSDLRenderer2_CreateFontsTexture()
+{
+    ImGuiIO& io = ImGui::GetIO();
+    ImGui_ImplSDLRenderer2_Data* bd = ImGui_ImplSDLRenderer2_GetBackendData();
+
+    // Build texture atlas
+    unsigned char* pixels;
+    int width, height;
+    io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);   // Load as RGBA 32-bit (75% of the memory is wasted, but default font is so small) because it is more likely to be compatible with user's existing shaders. If your ImTextureId represent a higher-level concept than just a GL texture id, consider calling GetTexDataAsAlpha8() instead to save on GPU memory.
+
+    // Upload texture to graphics system
+    // (Bilinear sampling is required by default. Set 'io.Fonts->Flags |= ImFontAtlasFlags_NoBakedLines' or 'style.AntiAliasedLinesUseTex = false' to allow point/nearest sampling)
+    bd->FontTexture = SDL_CreateTexture(bd->SDLRenderer, SDL_PIXELFORMAT_ABGR8888, SDL_TEXTUREACCESS_STATIC, width, height);
+    if (bd->FontTexture == nullptr)
+    {
+        SDL_Log("error creating texture");
+        return false;
+    }
+    SDL_UpdateTexture(bd->FontTexture, nullptr, pixels, 4 * width);
+    SDL_SetTextureBlendMode(bd->FontTexture, SDL_BLENDMODE_BLEND);
+    SDL_SetTextureScaleMode(bd->FontTexture, SDL_ScaleModeLinear);
+
+    // Store our identifier
+    io.Fonts->SetTexID((ImTextureID)(intptr_t)bd->FontTexture);
+
+    return true;
+}
+
+void ImGui_ImplSDLRenderer2_DestroyFontsTexture()
+{
+    ImGuiIO& io = ImGui::GetIO();
+    ImGui_ImplSDLRenderer2_Data* bd = ImGui_ImplSDLRenderer2_GetBackendData();
+    if (bd->FontTexture)
+    {
+        io.Fonts->SetTexID(0);
+        SDL_DestroyTexture(bd->FontTexture);
+        bd->FontTexture = nullptr;
+    }
+}
+
+bool ImGui_ImplSDLRenderer2_CreateDeviceObjects()
+{
+    return ImGui_ImplSDLRenderer2_CreateFontsTexture();
+}
+
+void ImGui_ImplSDLRenderer2_DestroyDeviceObjects()
+{
+    ImGui_ImplSDLRenderer2_DestroyFontsTexture();
+}
+
+//-----------------------------------------------------------------------------
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
+#endif // #ifndef IMGUI_DISABLE

port/src/imgui/backends/imgui_impl_sdlrenderer2.h

@@ -0,0 +1,41 @@
+// dear imgui: Renderer Backend for SDL_Renderer for SDL2
+// (Requires: SDL 2.0.17+)
+
+// Note how SDL_Renderer is an _optional_ component of SDL2.
+// For a multi-platform app consider using e.g. SDL+DirectX on Windows and SDL+OpenGL on Linux/OSX.
+// If your application will want to render any non trivial amount of graphics other than UI,
+// please be aware that SDL_Renderer currently offers a limited graphic API to the end-user and
+// it might be difficult to step out of those boundaries.
+
+// Implemented features:
+//  [X] Renderer: User texture binding. Use 'SDL_Texture*' as ImTextureID. Read the FAQ about ImTextureID!
+//  [X] Renderer: Large meshes support (64k+ vertices) with 16-bit indices.
+// Missing features:
+//  [ ] Renderer: Multi-viewport support (multiple windows).
+
+// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
+// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
+// Learn about Dear ImGui:
+// - FAQ                  https://dearimgui.com/faq
+// - Getting Started      https://dearimgui.com/getting-started
+// - Documentation        https://dearimgui.com/docs (same as your local docs/ folder).
+// - Introduction, links and more at the top of imgui.cpp
+
+#pragma once
+#ifndef IMGUI_DISABLE
+#include "imgui.h"      // IMGUI_IMPL_API
+
+struct SDL_Renderer;
+
+IMGUI_IMPL_API bool     ImGui_ImplSDLRenderer2_Init(SDL_Renderer* renderer);
+IMGUI_IMPL_API void     ImGui_ImplSDLRenderer2_Shutdown();
+IMGUI_IMPL_API void     ImGui_ImplSDLRenderer2_NewFrame();
+IMGUI_IMPL_API void     ImGui_ImplSDLRenderer2_RenderDrawData(ImDrawData* draw_data);
+
+// Called by Init/NewFrame/Shutdown
+IMGUI_IMPL_API bool     ImGui_ImplSDLRenderer2_CreateFontsTexture();
+IMGUI_IMPL_API void     ImGui_ImplSDLRenderer2_DestroyFontsTexture();
+IMGUI_IMPL_API bool     ImGui_ImplSDLRenderer2_CreateDeviceObjects();
+IMGUI_IMPL_API void     ImGui_ImplSDLRenderer2_DestroyDeviceObjects();
+
+#endif // #ifndef IMGUI_DISABLE

port/src/imgui/imconfig.h

@@ -0,0 +1,129 @@
+//-----------------------------------------------------------------------------
+// DEAR IMGUI COMPILE-TIME OPTIONS
+// Runtime options (clipboard callbacks, enabling various features, etc.) can generally be set via the ImGuiIO structure.
+// You can use ImGui::SetAllocatorFunctions() before calling ImGui::CreateContext() to rewire memory allocation functions.
+//-----------------------------------------------------------------------------
+// A) You may edit imconfig.h (and not overwrite it when updating Dear ImGui, or maintain a patch/rebased branch with your modifications to it)
+// B) or '#define IMGUI_USER_CONFIG "my_imgui_config.h"' in your project and then add directives in your own file without touching this template.
+//-----------------------------------------------------------------------------
+// You need to make sure that configuration settings are defined consistently _everywhere_ Dear ImGui is used, which include the imgui*.cpp
+// files but also _any_ of your code that uses Dear ImGui. This is because some compile-time options have an affect on data structures.
+// Defining those options in imconfig.h will ensure every compilation unit gets to see the same data structure layouts.
+// Call IMGUI_CHECKVERSION() from your .cpp file to verify that the data structures your files are using are matching the ones imgui.cpp is using.
+//-----------------------------------------------------------------------------
+
+#pragma once
+
+//---- Define assertion handler. Defaults to calling assert().
+// If your macro uses multiple statements, make sure is enclosed in a 'do { .. } while (0)' block so it can be used as a single statement.
+//#define IM_ASSERT(_EXPR)  MyAssert(_EXPR)
+//#define IM_ASSERT(_EXPR)  ((void)(_EXPR))     // Disable asserts
+
+//---- Define attributes of all API symbols declarations, e.g. for DLL under Windows
+// Using Dear ImGui via a shared library is not recommended, because of function call overhead and because we don't guarantee backward nor forward ABI compatibility.
+// DLL users: heaps and globals are not shared across DLL boundaries! You will need to call SetCurrentContext() + SetAllocatorFunctions()
+// for each static/DLL boundary you are calling from. Read "Context and Memory Allocators" section of imgui.cpp for more details.
+//#define IMGUI_API __declspec( dllexport )
+//#define IMGUI_API __declspec( dllimport )
+
+//---- Don't define obsolete functions/enums/behaviors. Consider enabling from time to time after updating to clean your code of obsolete function/names.
+//#define IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+//#define IMGUI_DISABLE_OBSOLETE_KEYIO                      // 1.87: disable legacy io.KeyMap[]+io.KeysDown[] in favor io.AddKeyEvent(). This will be folded into IMGUI_DISABLE_OBSOLETE_FUNCTIONS in a few versions.
+
+//---- Disable all of Dear ImGui or don't implement standard windows/tools.
+// It is very strongly recommended to NOT disable the demo windows and debug tool during development. They are extremely useful in day to day work. Please read comments in imgui_demo.cpp.
+//#define IMGUI_DISABLE                                     // Disable everything: all headers and source files will be empty.
+//#define IMGUI_DISABLE_DEMO_WINDOWS                        // Disable demo windows: ShowDemoWindow()/ShowStyleEditor() will be empty.
+//#define IMGUI_DISABLE_DEBUG_TOOLS                         // Disable metrics/debugger and other debug tools: ShowMetricsWindow(), ShowDebugLogWindow() and ShowIDStackToolWindow() will be empty.
+
+//---- Don't implement some functions to reduce linkage requirements.
+//#define IMGUI_DISABLE_WIN32_DEFAULT_CLIPBOARD_FUNCTIONS   // [Win32] Don't implement default clipboard handler. Won't use and link with OpenClipboard/GetClipboardData/CloseClipboard etc. (user32.lib/.a, kernel32.lib/.a)
+//#define IMGUI_ENABLE_WIN32_DEFAULT_IME_FUNCTIONS          // [Win32] [Default with Visual Studio] Implement default IME handler (require imm32.lib/.a, auto-link for Visual Studio, -limm32 on command-line for MinGW)
+//#define IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCTIONS         // [Win32] [Default with non-Visual Studio compilers] Don't implement default IME handler (won't require imm32.lib/.a)
+//#define IMGUI_DISABLE_WIN32_FUNCTIONS                     // [Win32] Won't use and link with any Win32 function (clipboard, IME).
+//#define IMGUI_ENABLE_OSX_DEFAULT_CLIPBOARD_FUNCTIONS      // [OSX] Implement default OSX clipboard handler (need to link with '-framework ApplicationServices', this is why this is not the default).
+//#define IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS            // Don't implement ImFormatString/ImFormatStringV so you can implement them yourself (e.g. if you don't want to link with vsnprintf)
+//#define IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS              // Don't implement ImFabs/ImSqrt/ImPow/ImFmod/ImCos/ImSin/ImAcos/ImAtan2 so you can implement them yourself.
+//#define IMGUI_DISABLE_FILE_FUNCTIONS                      // Don't implement ImFileOpen/ImFileClose/ImFileRead/ImFileWrite and ImFileHandle at all (replace them with dummies)
+//#define IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS              // Don't implement ImFileOpen/ImFileClose/ImFileRead/ImFileWrite and ImFileHandle so you can implement them yourself if you don't want to link with fopen/fclose/fread/fwrite. This will also disable the LogToTTY() function.
+//#define IMGUI_DISABLE_DEFAULT_ALLOCATORS                  // Don't implement default allocators calling malloc()/free() to avoid linking with them. You will need to call ImGui::SetAllocatorFunctions().
+//#define IMGUI_DISABLE_SSE                                 // Disable use of SSE intrinsics even if available
+
+//---- Include imgui_user.h at the end of imgui.h as a convenience
+//#define IMGUI_INCLUDE_IMGUI_USER_H
+
+//---- Pack colors to BGRA8 instead of RGBA8 (to avoid converting from one to another)
+//#define IMGUI_USE_BGRA_PACKED_COLOR
+
+//---- Use 32-bit for ImWchar (default is 16-bit) to support unicode planes 1-16. (e.g. point beyond 0xFFFF like emoticons, dingbats, symbols, shapes, ancient languages, etc...)
+//#define IMGUI_USE_WCHAR32
+
+//---- Avoid multiple STB libraries implementations, or redefine path/filenames to prioritize another version
+// By default the embedded implementations are declared static and not available outside of Dear ImGui sources files.
+//#define IMGUI_STB_TRUETYPE_FILENAME   "my_folder/stb_truetype.h"
+//#define IMGUI_STB_RECT_PACK_FILENAME  "my_folder/stb_rect_pack.h"
+//#define IMGUI_STB_SPRINTF_FILENAME    "my_folder/stb_sprintf.h"    // only used if IMGUI_USE_STB_SPRINTF is defined.
+//#define IMGUI_DISABLE_STB_TRUETYPE_IMPLEMENTATION
+//#define IMGUI_DISABLE_STB_RECT_PACK_IMPLEMENTATION
+//#define IMGUI_DISABLE_STB_SPRINTF_IMPLEMENTATION                   // only disabled if IMGUI_USE_STB_SPRINTF is defined.
+
+//---- Use stb_sprintf.h for a faster implementation of vsnprintf instead of the one from libc (unless IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS is defined)
+// Compatibility checks of arguments and formats done by clang and GCC will be disabled in order to support the extra formats provided by stb_sprintf.h.
+//#define IMGUI_USE_STB_SPRINTF
+
+//---- Use FreeType to build and rasterize the font atlas (instead of stb_truetype which is embedded by default in Dear ImGui)
+// Requires FreeType headers to be available in the include path. Requires program to be compiled with 'misc/freetype/imgui_freetype.cpp' (in this repository) + the FreeType library (not provided).
+// On Windows you may use vcpkg with 'vcpkg install freetype --triplet=x64-windows' + 'vcpkg integrate install'.
+//#define IMGUI_ENABLE_FREETYPE
+
+//---- Use FreeType+lunasvg library to render OpenType SVG fonts (SVGinOT)
+// Requires lunasvg headers to be available in the include path + program to be linked with the lunasvg library (not provided).
+// Only works in combination with IMGUI_ENABLE_FREETYPE.
+// (implementation is based on Freetype's rsvg-port.c which is licensed under CeCILL-C Free Software License Agreement)
+//#define IMGUI_ENABLE_FREETYPE_LUNASVG
+
+//---- Use stb_truetype to build and rasterize the font atlas (default)
+// The only purpose of this define is if you want force compilation of the stb_truetype backend ALONG with the FreeType backend.
+//#define IMGUI_ENABLE_STB_TRUETYPE
+
+//---- Define constructor and implicit cast operators to convert back<>forth between your math types and ImVec2/ImVec4.
+// This will be inlined as part of ImVec2 and ImVec4 class declarations.
+/*
+#define IM_VEC2_CLASS_EXTRA                                                     \
+        constexpr ImVec2(const MyVec2& f) : x(f.x), y(f.y) {}                   \
+        operator MyVec2() const { return MyVec2(x,y); }
+
+#define IM_VEC4_CLASS_EXTRA                                                     \
+        constexpr ImVec4(const MyVec4& f) : x(f.x), y(f.y), z(f.z), w(f.w) {}   \
+        operator MyVec4() const { return MyVec4(x,y,z,w); }
+*/
+//---- ...Or use Dear ImGui's own very basic math operators.
+//#define IMGUI_DEFINE_MATH_OPERATORS
+
+//---- Use 32-bit vertex indices (default is 16-bit) is one way to allow large meshes with more than 64K vertices.
+// Your renderer backend will need to support it (most example renderer backends support both 16/32-bit indices).
+// Another way to allow large meshes while keeping 16-bit indices is to handle ImDrawCmd::VtxOffset in your renderer.
+// Read about ImGuiBackendFlags_RendererHasVtxOffset for details.
+//#define ImDrawIdx unsigned int
+
+//---- Override ImDrawCallback signature (will need to modify renderer backends accordingly)
+//struct ImDrawList;
+//struct ImDrawCmd;
+//typedef void (*MyImDrawCallback)(const ImDrawList* draw_list, const ImDrawCmd* cmd, void* my_renderer_user_data);
+//#define ImDrawCallback MyImDrawCallback
+
+//---- Debug Tools: Macro to break in Debugger (we provide a default implementation of this in the codebase)
+// (use 'Metrics->Tools->Item Picker' to pick widgets with the mouse and break into them for easy debugging.)
+//#define IM_DEBUG_BREAK  IM_ASSERT(0)
+//#define IM_DEBUG_BREAK  __debugbreak()
+
+//---- Debug Tools: Enable slower asserts
+//#define IMGUI_DEBUG_PARANOID
+
+//---- Tip: You can add extra functions within the ImGui:: namespace from anywhere (e.g. your own sources/header files)
+/*
+namespace ImGui
+{
+    void MyFunction(const char* name, MyMatrix44* mtx);
+}
+*/

port/src/imgui/imstb_rectpack.h

@@ -0,0 +1,627 @@
+// [DEAR IMGUI]
+// This is a slightly modified version of stb_rect_pack.h 1.01.
+// Grep for [DEAR IMGUI] to find the changes.
+// 
+// stb_rect_pack.h - v1.01 - public domain - rectangle packing
+// Sean Barrett 2014
+//
+// Useful for e.g. packing rectangular textures into an atlas.
+// Does not do rotation.
+//
+// Before #including,
+//
+//    #define STB_RECT_PACK_IMPLEMENTATION
+//
+// in the file that you want to have the implementation.
+//
+// Not necessarily the awesomest packing method, but better than
+// the totally naive one in stb_truetype (which is primarily what
+// this is meant to replace).
+//
+// Has only had a few tests run, may have issues.
+//
+// More docs to come.
+//
+// No memory allocations; uses qsort() and assert() from stdlib.
+// Can override those by defining STBRP_SORT and STBRP_ASSERT.
+//
+// This library currently uses the Skyline Bottom-Left algorithm.
+//
+// Please note: better rectangle packers are welcome! Please
+// implement them to the same API, but with a different init
+// function.
+//
+// Credits
+//
+//  Library
+//    Sean Barrett
+//  Minor features
+//    Martins Mozeiko
+//    github:IntellectualKitty
+//
+//  Bugfixes / warning fixes
+//    Jeremy Jaussaud
+//    Fabian Giesen
+//
+// Version history:
+//
+//     1.01  (2021-07-11)  always use large rect mode, expose STBRP__MAXVAL in public section
+//     1.00  (2019-02-25)  avoid small space waste; gracefully fail too-wide rectangles
+//     0.99  (2019-02-07)  warning fixes
+//     0.11  (2017-03-03)  return packing success/fail result
+//     0.10  (2016-10-25)  remove cast-away-const to avoid warnings
+//     0.09  (2016-08-27)  fix compiler warnings
+//     0.08  (2015-09-13)  really fix bug with empty rects (w=0 or h=0)
+//     0.07  (2015-09-13)  fix bug with empty rects (w=0 or h=0)
+//     0.06  (2015-04-15)  added STBRP_SORT to allow replacing qsort
+//     0.05:  added STBRP_ASSERT to allow replacing assert
+//     0.04:  fixed minor bug in STBRP_LARGE_RECTS support
+//     0.01:  initial release
+//
+// LICENSE
+//
+//   See end of file for license information.
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//       INCLUDE SECTION
+//
+
+#ifndef STB_INCLUDE_STB_RECT_PACK_H
+#define STB_INCLUDE_STB_RECT_PACK_H
+
+#define STB_RECT_PACK_VERSION  1
+
+#ifdef STBRP_STATIC
+#define STBRP_DEF static
+#else
+#define STBRP_DEF extern
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct stbrp_context stbrp_context;
+typedef struct stbrp_node    stbrp_node;
+typedef struct stbrp_rect    stbrp_rect;
+
+typedef int            stbrp_coord;
+
+#define STBRP__MAXVAL  0x7fffffff
+// Mostly for internal use, but this is the maximum supported coordinate value.
+
+STBRP_DEF int stbrp_pack_rects (stbrp_context *context, stbrp_rect *rects, int num_rects);
+// Assign packed locations to rectangles. The rectangles are of type
+// 'stbrp_rect' defined below, stored in the array 'rects', and there
+// are 'num_rects' many of them.
+//
+// Rectangles which are successfully packed have the 'was_packed' flag
+// set to a non-zero value and 'x' and 'y' store the minimum location
+// on each axis (i.e. bottom-left in cartesian coordinates, top-left
+// if you imagine y increasing downwards). Rectangles which do not fit
+// have the 'was_packed' flag set to 0.
+//
+// You should not try to access the 'rects' array from another thread
+// while this function is running, as the function temporarily reorders
+// the array while it executes.
+//
+// To pack into another rectangle, you need to call stbrp_init_target
+// again. To continue packing into the same rectangle, you can call
+// this function again. Calling this multiple times with multiple rect
+// arrays will probably produce worse packing results than calling it
+// a single time with the full rectangle array, but the option is
+// available.
+//
+// The function returns 1 if all of the rectangles were successfully
+// packed and 0 otherwise.
+
+struct stbrp_rect
+{
+   // reserved for your use:
+   int            id;
+
+   // input:
+   stbrp_coord    w, h;
+
+   // output:
+   stbrp_coord    x, y;
+   int            was_packed;  // non-zero if valid packing
+
+}; // 16 bytes, nominally
+
+
+STBRP_DEF void stbrp_init_target (stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes);
+// Initialize a rectangle packer to:
+//    pack a rectangle that is 'width' by 'height' in dimensions
+//    using temporary storage provided by the array 'nodes', which is 'num_nodes' long
+//
+// You must call this function every time you start packing into a new target.
+//
+// There is no "shutdown" function. The 'nodes' memory must stay valid for
+// the following stbrp_pack_rects() call (or calls), but can be freed after
+// the call (or calls) finish.
+//
+// Note: to guarantee best results, either:
+//       1. make sure 'num_nodes' >= 'width'
+//   or  2. call stbrp_allow_out_of_mem() defined below with 'allow_out_of_mem = 1'
+//
+// If you don't do either of the above things, widths will be quantized to multiples
+// of small integers to guarantee the algorithm doesn't run out of temporary storage.
+//
+// If you do #2, then the non-quantized algorithm will be used, but the algorithm
+// may run out of temporary storage and be unable to pack some rectangles.
+
+STBRP_DEF void stbrp_setup_allow_out_of_mem (stbrp_context *context, int allow_out_of_mem);
+// Optionally call this function after init but before doing any packing to
+// change the handling of the out-of-temp-memory scenario, described above.
+// If you call init again, this will be reset to the default (false).
+
+
+STBRP_DEF void stbrp_setup_heuristic (stbrp_context *context, int heuristic);
+// Optionally select which packing heuristic the library should use. Different
+// heuristics will produce better/worse results for different data sets.
+// If you call init again, this will be reset to the default.
+
+enum
+{
+   STBRP_HEURISTIC_Skyline_default=0,
+   STBRP_HEURISTIC_Skyline_BL_sortHeight = STBRP_HEURISTIC_Skyline_default,
+   STBRP_HEURISTIC_Skyline_BF_sortHeight
+};
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// the details of the following structures don't matter to you, but they must
+// be visible so you can handle the memory allocations for them
+
+struct stbrp_node
+{
+   stbrp_coord  x,y;
+   stbrp_node  *next;
+};
+
+struct stbrp_context
+{
+   int width;
+   int height;
+   int align;
+   int init_mode;
+   int heuristic;
+   int num_nodes;
+   stbrp_node *active_head;
+   stbrp_node *free_head;
+   stbrp_node extra[2]; // we allocate two extra nodes so optimal user-node-count is 'width' not 'width+2'
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//     IMPLEMENTATION SECTION
+//
+
+#ifdef STB_RECT_PACK_IMPLEMENTATION
+#ifndef STBRP_SORT
+#include <stdlib.h>
+#define STBRP_SORT qsort
+#endif
+
+#ifndef STBRP_ASSERT
+#include <assert.h>
+#define STBRP_ASSERT assert
+#endif
+
+#ifdef _MSC_VER
+#define STBRP__NOTUSED(v)  (void)(v)
+#define STBRP__CDECL       __cdecl
+#else
+#define STBRP__NOTUSED(v)  (void)sizeof(v)
+#define STBRP__CDECL
+#endif
+
+enum
+{
+   STBRP__INIT_skyline = 1
+};
+
+STBRP_DEF void stbrp_setup_heuristic(stbrp_context *context, int heuristic)
+{
+   switch (context->init_mode) {
+      case STBRP__INIT_skyline:
+         STBRP_ASSERT(heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight || heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight);
+         context->heuristic = heuristic;
+         break;
+      default:
+         STBRP_ASSERT(0);
+   }
+}
+
+STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context *context, int allow_out_of_mem)
+{
+   if (allow_out_of_mem)
+      // if it's ok to run out of memory, then don't bother aligning them;
+      // this gives better packing, but may fail due to OOM (even though
+      // the rectangles easily fit). @TODO a smarter approach would be to only
+      // quantize once we've hit OOM, then we could get rid of this parameter.
+      context->align = 1;
+   else {
+      // if it's not ok to run out of memory, then quantize the widths
+      // so that num_nodes is always enough nodes.
+      //
+      // I.e. num_nodes * align >= width
+      //                  align >= width / num_nodes
+      //                  align = ceil(width/num_nodes)
+
+      context->align = (context->width + context->num_nodes-1) / context->num_nodes;
+   }
+}
+
+STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes)
+{
+   int i;
+
+   for (i=0; i < num_nodes-1; ++i)
+      nodes[i].next = &nodes[i+1];
+   nodes[i].next = NULL;
+   context->init_mode = STBRP__INIT_skyline;
+   context->heuristic = STBRP_HEURISTIC_Skyline_default;
+   context->free_head = &nodes[0];
+   context->active_head = &context->extra[0];
+   context->width = width;
+   context->height = height;
+   context->num_nodes = num_nodes;
+   stbrp_setup_allow_out_of_mem(context, 0);
+
+   // node 0 is the full width, node 1 is the sentinel (lets us not store width explicitly)
+   context->extra[0].x = 0;
+   context->extra[0].y = 0;
+   context->extra[0].next = &context->extra[1];
+   context->extra[1].x = (stbrp_coord) width;
+   context->extra[1].y = (1<<30);
+   context->extra[1].next = NULL;
+}
+
+// find minimum y position if it starts at x1
+static int stbrp__skyline_find_min_y(stbrp_context *c, stbrp_node *first, int x0, int width, int *pwaste)
+{
+   stbrp_node *node = first;
+   int x1 = x0 + width;
+   int min_y, visited_width, waste_area;
+
+   STBRP__NOTUSED(c);
+
+   STBRP_ASSERT(first->x <= x0);
+
+   #if 0
+   // skip in case we're past the node
+   while (node->next->x <= x0)
+      ++node;
+   #else
+   STBRP_ASSERT(node->next->x > x0); // we ended up handling this in the caller for efficiency
+   #endif
+
+   STBRP_ASSERT(node->x <= x0);
+
+   min_y = 0;
+   waste_area = 0;
+   visited_width = 0;
+   while (node->x < x1) {
+      if (node->y > min_y) {
+         // raise min_y higher.
+         // we've accounted for all waste up to min_y,
+         // but we'll now add more waste for everything we've visted
+         waste_area += visited_width * (node->y - min_y);
+         min_y = node->y;
+         // the first time through, visited_width might be reduced
+         if (node->x < x0)
+            visited_width += node->next->x - x0;
+         else
+            visited_width += node->next->x - node->x;
+      } else {
+         // add waste area
+         int under_width = node->next->x - node->x;
+         if (under_width + visited_width > width)
+            under_width = width - visited_width;
+         waste_area += under_width * (min_y - node->y);
+         visited_width += under_width;
+      }
+      node = node->next;
+   }
+
+   *pwaste = waste_area;
+   return min_y;
+}
+
+typedef struct
+{
+   int x,y;
+   stbrp_node **prev_link;
+} stbrp__findresult;
+
+static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, int width, int height)
+{
+   int best_waste = (1<<30), best_x, best_y = (1 << 30);
+   stbrp__findresult fr;
+   stbrp_node **prev, *node, *tail, **best = NULL;
+
+   // align to multiple of c->align
+   width = (width + c->align - 1);
+   width -= width % c->align;
+   STBRP_ASSERT(width % c->align == 0);
+
+   // if it can't possibly fit, bail immediately
+   if (width > c->width || height > c->height) {
+      fr.prev_link = NULL;
+      fr.x = fr.y = 0;
+      return fr;
+   }
+
+   node = c->active_head;
+   prev = &c->active_head;
+   while (node->x + width <= c->width) {
+      int y,waste;
+      y = stbrp__skyline_find_min_y(c, node, node->x, width, &waste);
+      if (c->heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight) { // actually just want to test BL
+         // bottom left
+         if (y < best_y) {
+            best_y = y;
+            best = prev;
+         }
+      } else {
+         // best-fit
+         if (y + height <= c->height) {
+            // can only use it if it first vertically
+            if (y < best_y || (y == best_y && waste < best_waste)) {
+               best_y = y;
+               best_waste = waste;
+               best = prev;
+            }
+         }
+      }
+      prev = &node->next;
+      node = node->next;
+   }
+
+   best_x = (best == NULL) ? 0 : (*best)->x;
+
+   // if doing best-fit (BF), we also have to try aligning right edge to each node position
+   //
+   // e.g, if fitting
+   //
+   //     ____________________
+   //    |____________________|
+   //
+   //            into
+   //
+   //   |                         |
+   //   |             ____________|
+   //   |____________|
+   //
+   // then right-aligned reduces waste, but bottom-left BL is always chooses left-aligned
+   //
+   // This makes BF take about 2x the time
+
+   if (c->heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight) {
+      tail = c->active_head;
+      node = c->active_head;
+      prev = &c->active_head;
+      // find first node that's admissible
+      while (tail->x < width)
+         tail = tail->next;
+      while (tail) {
+         int xpos = tail->x - width;
+         int y,waste;
+         STBRP_ASSERT(xpos >= 0);
+         // find the left position that matches this
+         while (node->next->x <= xpos) {
+            prev = &node->next;
+            node = node->next;
+         }
+         STBRP_ASSERT(node->next->x > xpos && node->x <= xpos);
+         y = stbrp__skyline_find_min_y(c, node, xpos, width, &waste);
+         if (y + height <= c->height) {
+            if (y <= best_y) {
+               if (y < best_y || waste < best_waste || (waste==best_waste && xpos < best_x)) {
+                  best_x = xpos;
+                  //STBRP_ASSERT(y <= best_y); [DEAR IMGUI]
+                  best_y = y;
+                  best_waste = waste;
+                  best = prev;
+               }
+            }
+         }
+         tail = tail->next;
+      }
+   }
+
+   fr.prev_link = best;
+   fr.x = best_x;
+   fr.y = best_y;
+   return fr;
+}
+
+static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context *context, int width, int height)
+{
+   // find best position according to heuristic
+   stbrp__findresult res = stbrp__skyline_find_best_pos(context, width, height);
+   stbrp_node *node, *cur;
+
+   // bail if:
+   //    1. it failed
+   //    2. the best node doesn't fit (we don't always check this)
+   //    3. we're out of memory
+   if (res.prev_link == NULL || res.y + height > context->height || context->free_head == NULL) {
+      res.prev_link = NULL;
+      return res;
+   }
+
+   // on success, create new node
+   node = context->free_head;
+   node->x = (stbrp_coord) res.x;
+   node->y = (stbrp_coord) (res.y + height);
+
+   context->free_head = node->next;
+
+   // insert the new node into the right starting point, and
+   // let 'cur' point to the remaining nodes needing to be
+   // stiched back in
+
+   cur = *res.prev_link;
+   if (cur->x < res.x) {
+      // preserve the existing one, so start testing with the next one
+      stbrp_node *next = cur->next;
+      cur->next = node;
+      cur = next;
+   } else {
+      *res.prev_link = node;
+   }
+
+   // from here, traverse cur and free the nodes, until we get to one
+   // that shouldn't be freed
+   while (cur->next && cur->next->x <= res.x + width) {
+      stbrp_node *next = cur->next;
+      // move the current node to the free list
+      cur->next = context->free_head;
+      context->free_head = cur;
+      cur = next;
+   }
+
+   // stitch the list back in
+   node->next = cur;
+
+   if (cur->x < res.x + width)
+      cur->x = (stbrp_coord) (res.x + width);
+
+#ifdef _DEBUG
+   cur = context->active_head;
+   while (cur->x < context->width) {
+      STBRP_ASSERT(cur->x < cur->next->x);
+      cur = cur->next;
+   }
+   STBRP_ASSERT(cur->next == NULL);
+
+   {
+      int count=0;
+      cur = context->active_head;
+      while (cur) {
+         cur = cur->next;
+         ++count;
+      }
+      cur = context->free_head;
+      while (cur) {
+         cur = cur->next;
+         ++count;
+      }
+      STBRP_ASSERT(count == context->num_nodes+2);
+   }
+#endif
+
+   return res;
+}
+
+static int STBRP__CDECL rect_height_compare(const void *a, const void *b)
+{
+   const stbrp_rect *p = (const stbrp_rect *) a;
+   const stbrp_rect *q = (const stbrp_rect *) b;
+   if (p->h > q->h)
+      return -1;
+   if (p->h < q->h)
+      return  1;
+   return (p->w > q->w) ? -1 : (p->w < q->w);
+}
+
+static int STBRP__CDECL rect_original_order(const void *a, const void *b)
+{
+   const stbrp_rect *p = (const stbrp_rect *) a;
+   const stbrp_rect *q = (const stbrp_rect *) b;
+   return (p->was_packed < q->was_packed) ? -1 : (p->was_packed > q->was_packed);
+}
+
+STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects, int num_rects)
+{
+   int i, all_rects_packed = 1;
+
+   // we use the 'was_packed' field internally to allow sorting/unsorting
+   for (i=0; i < num_rects; ++i) {
+      rects[i].was_packed = i;
+   }
+
+   // sort according to heuristic
+   STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_height_compare);
+
+   for (i=0; i < num_rects; ++i) {
+      if (rects[i].w == 0 || rects[i].h == 0) {
+         rects[i].x = rects[i].y = 0;  // empty rect needs no space
+      } else {
+         stbrp__findresult fr = stbrp__skyline_pack_rectangle(context, rects[i].w, rects[i].h);
+         if (fr.prev_link) {
+            rects[i].x = (stbrp_coord) fr.x;
+            rects[i].y = (stbrp_coord) fr.y;
+         } else {
+            rects[i].x = rects[i].y = STBRP__MAXVAL;
+         }
+      }
+   }
+
+   // unsort
+   STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_original_order);
+
+   // set was_packed flags and all_rects_packed status
+   for (i=0; i < num_rects; ++i) {
+      rects[i].was_packed = !(rects[i].x == STBRP__MAXVAL && rects[i].y == STBRP__MAXVAL);
+      if (!rects[i].was_packed)
+         all_rects_packed = 0;
+   }
+
+   // return the all_rects_packed status
+   return all_rects_packed;
+}
+#endif
+
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------
+*/

port/src/input.c

@@ -10,6 +10,7 @@
 #include "config.h"
 #include "utils.h"
 #include "system.h"
+#include "debugger.h"
 #include "fs.h"
 
 #if !SDL_VERSION_ATLEAST(2, 0, 14)
@@ -75,7 +76,7 @@ static s32 connectedMask = 0;
 static s32 numJoysticks = 0;
 
 static s32 useHIDAPI = 1;
-static s32 useRawInput = 0;
+static s32 useRawInput = 1;
 
 static s32 mouseEnabled = 1;
 static s32 mouseX, mouseY;
@@ -195,7 +196,7 @@ void inputSetDefaultKeyBinds(s32 cidx, s32 n64mode)
 		{ CK_RTRIG,         VK_MOUSE_RIGHT,      SDL_SCANCODE_Z      },
 		{ CK_LTRIG,         SDL_SCANCODE_F,      SDL_SCANCODE_X      },
 		{ CK_ZTRIG,         VK_MOUSE_LEFT,       SDL_SCANCODE_SPACE  },
-		{ CK_START,         SDL_SCANCODE_TAB,    0                   },
+		{ CK_START,         SDL_SCANCODE_RETURN, SDL_SCANCODE_TAB    },
 		{ CK_DPAD_D,        SDL_SCANCODE_Q,      VK_MOUSE_MIDDLE     },
 		{ CK_DPAD_U,        0,                   0                   },
 		{ CK_Y,             VK_MOUSE_WHEEL_DN,   0                   },
@@ -209,9 +210,7 @@ void inputSetDefaultKeyBinds(s32 cidx, s32 n64mode)
 		{ CK_STICK_YNEG,    SDL_SCANCODE_DOWN,   0                   },
 		{ CK_STICK_YPOS,    SDL_SCANCODE_UP,     0                   },
 		{ CK_4000,          SDL_SCANCODE_LSHIFT, 0                   },
-		{ CK_2000,          SDL_SCANCODE_LCTRL,  0                   },
-		{ CK_ACCEPT,        SDL_SCANCODE_RETURN, SDL_SCANCODE_E      },
-		{ CK_CANCEL,        VK_MOUSE_RIGHT,      0                   },
+		{ CK_2000,          SDL_SCANCODE_LCTRL,  0                   }
 	};
 
 	static const u32 pcjoybinds[][2] = {
@@ -551,6 +550,8 @@ static int inputEventFilter(void *data, SDL_Event *event)
 			break;
 	}
 
+	debuggerProcessEvent(event);
+
 	return 0;
 }
 
@@ -695,7 +696,6 @@ s32 inputInit(void)
 		// the two hints below enable Rumble and Motion Sensor for PS4/5 pads connected via bluetooth
 		SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_PS4_RUMBLE, "1");
 		SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_PS5_RUMBLE, "1");
-		SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_STEAM, "1");
 #endif
 #if SDL_VERSION_ATLEAST(2, 23, 2)
 		SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_COMBINE_JOY_CONS, "1");
@@ -705,19 +705,11 @@ s32 inputInit(void)
 #endif
 #if SDL_VERSION_ATLEAST(2, 26, 0)
 		SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_WII, "1");
-#endif
-#if SDL_VERSION_ATLEAST(2, 30, 0)
-		SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_STEAMDECK, "1");
 #endif
 	}
 	if (useRawInput) {
 		SDL_SetHint(SDL_HINT_JOYSTICK_RAWINPUT, "1");
-#ifdef SDL_HINT_JOYSTICK_RAWINPUT_CORRELATE_XINPUT
 		SDL_SetHint(SDL_HINT_JOYSTICK_RAWINPUT_CORRELATE_XINPUT, "1");
-#elif defined(SDL_HINT_JOYSTICK_HIDAPI_CORRELATE_XINPUT)
-		// old name for SDL_HINT_JOYSTICK_RAWINPUT_CORRELATE_XINPUT before SDL2.0.16
-		SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_CORRELATE_XINPUT, "1");
-#endif
 	}
 
 	if (!SDL_WasInit(SDL_INIT_GAMECONTROLLER | SDL_INIT_HAPTIC)) {
@@ -756,9 +748,6 @@ s32 inputInit(void)
 
 	inputLoadBinds();
 
-	// Explicitly stop text input to prevent key events being swallowed on certain Wayland systems
-	inputStopTextInput();
-
 	return connectedMask;
 }
 
@@ -903,16 +892,27 @@ static inline void inputUpdateMouse(void)
 	mouseX = mx;
 	mouseY = my;
 
-	// if MLOCK_AUTO is enabled, disable cursor if mouse is unlocked
-	// and we haven't moved it for a few seconds
-	if (mouseLockMode == MLOCK_AUTO && !mouseLocked) {
-		if (abs(mouseDX) > CURSOR_HIDE_THRESHOLD || abs(mouseDY) > CURSOR_HIDE_THRESHOLD) {
-			if (!mouseShowCursor) {
-				inputMouseShowCursor(1);
-			}
-		} else if (sysGetMicroseconds() > mouseCursorTime) {
-			if (mouseShowCursor) {
-				inputMouseShowCursor(0);
+	const s32 mouseFocus = (SDL_GetMouseFocus() == videoGetWindowHandle());
+	if (!mouseFocus) {
+		mouseDX = 0;
+		mouseDY = 0;
+		mouseWheel = 0;
+		mouseButtons = 0;
+		if (!mouseShowCursor) {
+			inputMouseShowCursor(1);
+		}
+	} else {
+		// if MLOCK_AUTO is enabled, disable cursor if mouse is unlocked
+		// and we haven't moved it for a few seconds
+		if (mouseLockMode == MLOCK_AUTO && !mouseLocked) {
+			if (abs(mouseDX) > CURSOR_HIDE_THRESHOLD || abs(mouseDY) > CURSOR_HIDE_THRESHOLD) {
+				if (!mouseShowCursor) {
+					inputMouseShowCursor(1);
+				}
+			} else if (sysGetMicroseconds() > mouseCursorTime) {
+				if (mouseShowCursor) {
+					inputMouseShowCursor(0);
+				}
 			}
 		}
 	}
@@ -1255,24 +1255,26 @@ void inputMouseGetRawDelta(s32 *dx, s32 *dy)
 
 void inputMouseGetScaledDelta(f32* dx, f32* dy)
 {
-	f32 mdx = 0.f, mdy = 0.f;
-	if (mouseLocked) {
-		mdx = mouseDX * (0.022f / 3.5f) * mouseSensX;
-		mdy = mouseDY * (0.022f / 3.5f) * mouseSensY;
-	}
-	if (dx) *dx = mdx;
-	if (dy) *dy = mdy;
+		f32 mdx = 0.f, mdy = 0.f;
+
+		if (mouseLocked) {
+				mdx = mouseSensX * ((f32)mouseDX / 3.5f) * 0.022f;
+				mdy = mouseSensY * ((f32)mouseDY / 3.5f) * 0.022f;
+		}
+		if (dx) *dx = mdx;
+		if (dy) *dy = mdy;
 }
 
 void inputMouseGetAbsScaledDelta(f32* dx, f32* dy)
 {
-	f32 mdx = 0.f, mdy = 0.f;
-	if (mouseLocked) {
-		mdx = mouseDX * (0.022f / 3.5f) * fabsf(mouseSensX);
-		mdy = mouseDY * (0.022f / 3.5f) * fabsf(mouseSensY);
-	}
-	if (dx) *dx = mdx;
-	if (dy) *dy = mdy;
+		f32 mdx = 0.f, mdy = 0.f;
+
+		if (mouseLocked) {
+				mdx = fabsf(mouseSensX) * ((f32)mouseDX / 3.5f) * 0.022f;
+				mdy = fabsf(mouseSensY) * ((f32)mouseDY / 3.5f) * 0.022f;
+		}
+		if (dx) *dx = mdx;
+		if (dy) *dy = mdy;
 }
 
 void inputMouseGetSpeed(f32 *x, f32 *y)
@@ -1465,6 +1467,10 @@ s32 inputTextHandler(char *out, const u32 outSize, s32 *curCol, s32 oskCharsOnly
 		} else {
 			out[0] = '\0';
 		}
+	} else if (key == VK_RETURN) {
+		if (out[0] && *curCol) {
+			return 1;
+		}
 	} else if (key == VK_ESCAPE) {
 		return -1;
 	}
@@ -1517,8 +1523,8 @@ PD_CONSTRUCTOR static void inputConfigInit(void)
 {
 	configRegisterInt("Input.MouseEnabled", &mouseEnabled, 0, 1);
 	configRegisterInt("Input.MouseLockMode", &mouseLockMode, MLOCK_OFF, MLOCK_AUTO);
-	configRegisterFloat("Input.MouseSpeedX", &mouseSensX, -30.f, 30.f);
-	configRegisterFloat("Input.MouseSpeedY", &mouseSensY, -30.f, 30.f);
+	configRegisterFloat("Input.MouseSpeedX", &mouseSensX, -10.f, 10.f);
+	configRegisterFloat("Input.MouseSpeedY", &mouseSensY, -10.f, 10.f);
 	configRegisterInt("Input.FakeGamepads", &fakeControllers, 0, 4);
 	configRegisterInt("Input.FirstGamepadNum", &firstController, 0, 3);
 	configRegisterInt("Input.UseHIDAPI", &useHIDAPI, 0, 1);

port/src/main.c

@@ -16,6 +16,7 @@
 #include "config.h"
 #include "mod.h"
 #include "system.h"
+#include "debugger.h"
 #include "utils.h"
 
 u32 g_OsMemSize = 0;
@@ -108,6 +109,7 @@ int main(int argc, const char **argv)
 	inputInit();
 	audioInit();
 	romdataInit();
+	debuggerInit();
 
 	g_ValidGbcRomFound = romdataCheckGbcRom();
 
@@ -169,7 +171,6 @@ PD_CONSTRUCTOR static void gameConfigInit(void)
 	configRegisterInt("Game.SkipIntro", &g_SkipIntro, 0, 1);
 	configRegisterInt("Game.DisableMpDeathMusic", &g_MusicDisableMpDeath, 0, 1);
 	configRegisterInt("Game.GEMuzzleFlashes", &g_BgunGeMuzzleFlashes, 0, 1);
-	configRegisterInt("Game.MaxExplosions", &g_MaxExplosions, 6, 96);
 	for (s32 j = 0; j < MAX_PLAYERS; ++j) {
 		const s32 i = j + 1;
 		configRegisterFloat(strFmt("Game.Player%d.FovY", i), &g_PlayerExtCfg[j].fovy, 5.f, 175.f);
@@ -179,7 +180,6 @@ PD_CONSTRUCTOR static void gameConfigInit(void)
 		configRegisterFloat(strFmt("Game.Player%d.MouseAimSpeedY", i), &g_PlayerExtCfg[j].mouseaimspeedy, 0.f, 10.f);
 		configRegisterFloat(strFmt("Game.Player%d.RadialMenuSpeed", i), &g_PlayerExtCfg[j].radialmenuspeed, 0.f, 10.f);
 		configRegisterFloat(strFmt("Game.Player%d.CrosshairSway", i), &g_PlayerExtCfg[j].crosshairsway, 0.f, 10.f);
-		configRegisterFloat(strFmt("Game.Player%d.CrosshairEdgeBoundary", i), &g_PlayerExtCfg[j].crosshairedgeboundary, 0.0f, 1.0f);
 		configRegisterInt(strFmt("Game.Player%d.CrouchMode", i), &g_PlayerExtCfg[j].crouchmode, 0, CROUCHMODE_TOGGLE_ANALOG);
 		configRegisterInt(strFmt("Game.Player%d.ExtendedControls", i), &g_PlayerExtCfg[j].extcontrols, 0, 1);
 		configRegisterUInt(strFmt("Game.Player%d.CrosshairColour", i), &g_PlayerExtCfg[j].crosshaircolour, 0, 0xFFFFFFFF);

port/src/mod.c

@@ -420,7 +420,7 @@ s32 modTextureLoad(u16 num, void *dst, u32 dstSize)
 {
 	static s32 dirExists = -1;
 	if (dirExists < 0) {
-		dirExists = (fsFileSize(MOD_TEXTURES_DIR) >= 0);
+		dirExists = (fsFileSize(MOD_TEXTURES_DIR "/") >= 0);
 	}
 
 	if (!dirExists) {
@@ -442,7 +442,7 @@ void *modSequenceLoad(u16 num, u32 *outSize)
 {
 	static s32 dirExists = -1;
 	if (dirExists < 0) {
-		dirExists = (fsFileSize(MOD_SEQUENCES_DIR) >= 0);
+		dirExists = (fsFileSize(MOD_SEQUENCES_DIR "/") >= 0);
 	}
 
 	if (!dirExists) {
@@ -478,7 +478,7 @@ s32 modAnimationLoadDescriptor(u16 num, struct animtableentry *anim)
 {
 	static s32 dirExists = -1;
 	if (dirExists < 0) {
-		dirExists = (fsFileSize(MOD_ANIMATIONS_DIR) >= 0);
+		dirExists = (fsFileSize(MOD_ANIMATIONS_DIR "/") >= 0);
 	}
 
 	if (!dirExists) {

port/src/mpsetups.c

@@ -809,7 +809,7 @@ static MenuItemHandlerResult menuhandlerSetupSetDefault(s32 operation, struct me
 		s32 selected = g_Menus[g_MpPlayerNum].mpsetup.slotindex;
 		// clicked on "clear default"
 		if (selected == g_MpSetupFile.defaultsetup - 1) {
-			g_MpSetupFile.defaultsetup = 0;
+			g_MpSetupFile.defaultsetup = -1;
 			strcpy(g_LabelSetDefault, "Set Default\n");
 		} else {
 			g_MpSetupFile.defaultsetup = selected + 1;

port/src/optionsmenu.c

@@ -170,6 +170,8 @@ static MenuItemHandlerResult menuhandlerMouseSpeedX(s32 operation, struct menuit
 		inputMouseGetSpeed(&x, &y);
 		if (x < 0.f) {
 			data->slider.value = 0;
+		} else if (x > 10.f) {
+			data->slider.value = 1000;
 		} else {
 			data->slider.value = x * 100.f + 0.5f;
 		}
@@ -180,7 +182,6 @@ static MenuItemHandlerResult menuhandlerMouseSpeedX(s32 operation, struct menuit
 		break;
 	case MENUOP_GETSLIDERLABEL:
 		sprintf(data->slider.label, "%.2f", (f32)data->slider.value / 100.f);
-		break;
 	}
 
 	return 0;
@@ -195,6 +196,8 @@ static MenuItemHandlerResult menuhandlerMouseSpeedY(s32 operation, struct menuit
 		inputMouseGetSpeed(&x, &y);
 		if (y < 0.f) {
 			data->slider.value = 0;
+		} else if (y > 10.f) {
+			data->slider.value = 1000;
 		} else {
 			data->slider.value = y * 100.f + 0.5f;
 		}
@@ -205,7 +208,6 @@ static MenuItemHandlerResult menuhandlerMouseSpeedY(s32 operation, struct menuit
 		break;
 	case MENUOP_GETSLIDERLABEL:
 		sprintf(data->slider.label, "%.2f", (f32)data->slider.value / 100.f);
-		break;
 	}
 
 	return 0;
@@ -323,7 +325,7 @@ struct menuitem g_ExtendedMouseMenuItems[] = {
 		0,
 		MENUITEMFLAG_LITERAL_TEXT | MENUITEMFLAG_SLIDER_WIDE,
 		(uintptr_t)"Mouse Speed X",
-		3000,
+		1000,
 		menuhandlerMouseSpeedX,
 	},
 	{
@@ -331,7 +333,7 @@ struct menuitem g_ExtendedMouseMenuItems[] = {
 		0,
 		MENUITEMFLAG_LITERAL_TEXT | MENUITEMFLAG_SLIDER_WIDE,
 		(uintptr_t)"Mouse Speed Y",
-		3000,
+		1000,
 		menuhandlerMouseSpeedY,
 	},
 	{
@@ -908,20 +910,6 @@ static MenuItemHandlerResult menuhandlerTexFilter2D(s32 operation, struct menuit
 	return 0;
 }
 
-static MenuItemHandlerResult menuhandlerAnisotropicFiltering(s32 operation, struct menuitem *item, union handlerdata *data)
-{
-	switch (operation) {
-	case MENUOP_GETSLIDER:
-		data->slider.value = videoGetAnisotropicFilter();
-		break;
-	case MENUOP_SET:
-		videoSetAnisotropicFilter(data->slider.value);
-		break;
-	}
-
-	return 0;
-}
-
 static MenuItemHandlerResult menuhandlerDisplayFPS(s32 operation, struct menuitem *item, union handlerdata *data)
 {
 	switch (operation) {
@@ -1008,34 +996,6 @@ static MenuItemHandlerResult menuhandlerScreenShake(s32 operation, struct menuit
 	return 0;
 }
 
-static MenuItemHandlerResult menuhandlerGlareBrightness(s32 operation, struct menuitem *item, union handlerdata *data)
-{
-	switch (operation) {
-	case MENUOP_GETSLIDER:
-		data->slider.value = videoGetGlareBrightness() * 10.f + 0.5f;
-		break;
-	case MENUOP_SET:
-		videoSetGlareBrightness((f32)data->slider.value / 10.f);
-		break;
-	}
-
-	return 0;
-}
-
-static MenuItemHandlerResult menuhandlerOverexposureScale(s32 operation, struct menuitem *item, union handlerdata *data)
-{
-	switch (operation) {
-	case MENUOP_GETSLIDER:
-		data->slider.value = videoGetOverexposureScale() * 10.f + 0.5f;
-		break;
-	case MENUOP_SET:
-		videoSetOverexposureScale((f32)data->slider.value / 10.f);
-		break;
-	}
-
-	return 0;
-}
-
 struct menuitem g_ExtendedVideoMenuItems[] = {
 	{
 		MENUITEMTYPE_CHECKBOX,
@@ -1141,14 +1101,6 @@ struct menuitem g_ExtendedVideoMenuItems[] = {
 		0,
 		menuhandlerTexFilter2D,
 	},
-	{
-		MENUITEMTYPE_SLIDER,
-		0,
-		MENUITEMFLAG_LITERAL_TEXT | MENUITEMFLAG_SLIDER_WIDE,
-		(uintptr_t)"Anisotropic Filtering",
-		8,
-		menuhandlerAnisotropicFiltering,
-	},
 	{
 		MENUITEMTYPE_CHECKBOX,
 		0,
@@ -1197,30 +1149,6 @@ struct menuitem g_ExtendedVideoMenuItems[] = {
 		0,
 		NULL,
 	},
-	{
-		MENUITEMTYPE_SLIDER,
-		0,
-		MENUITEMFLAG_LITERAL_TEXT | MENUITEMFLAG_SLIDER_WIDE,
-		(uintptr_t)"Glare Brightness",
-		10,
-		menuhandlerGlareBrightness,
-	},
-	{
-		MENUITEMTYPE_SLIDER,
-		0,
-		MENUITEMFLAG_LITERAL_TEXT | MENUITEMFLAG_SLIDER_WIDE,
-		(uintptr_t)"Overexposure Scale",
-		10,
-		menuhandlerOverexposureScale,
-	},
-	{
-		MENUITEMTYPE_SEPARATOR,
-		0,
-		0,
-		0,
-		0,
-		NULL,
-	},
 	{
 		MENUITEMTYPE_SELECTABLE,
 		0,
@@ -1365,22 +1293,6 @@ static MenuItemHandlerResult menuhandlerCrosshairSway(s32 operation, struct menu
 	return 0;
 }
 
-static MenuItemHandlerResult menuhandlerCrosshairEdgeBoundary(s32 operation, struct menuitem* item, union handlerdata *data)
-{
-	switch (operation) {
-	case MENUOP_GETSLIDER:
-		data->slider.value = (s32)(g_PlayerExtCfg[g_ExtMenuPlayer].crosshairedgeboundary * 10.f + 0.5f);
-		break;
-	case MENUOP_SET:
-		g_PlayerExtCfg[g_ExtMenuPlayer].crosshairedgeboundary = (f32)data->slider.value / 10.f;
-		break;
-	case MENUOP_GETSLIDERLABEL:
-		sprintf(data->slider.label, "%d", (s32)data->slider.value);
-		break;
-	}
-	return 0;
-}
-
 static MenuItemHandlerResult menuhandlerCrosshairR(s32 operation, struct menuitem* item, union handlerdata* data)
 {
 	u32 newColor;
@@ -1602,14 +1514,6 @@ struct menuitem g_ExtendedGameMenuItems[] = {
 		20,
 		menuhandlerCrosshairSway,
 	},
-	{
-		MENUITEMTYPE_SLIDER,
-		0,
-		MENUITEMFLAG_LITERAL_TEXT | MENUITEMFLAG_SLIDER_WIDE,
-		(uintptr_t)"Crosshair Edge Deadzone",
-		10,
-		menuhandlerCrosshairEdgeBoundary,
-	},
 	{
 		MENUITEMTYPE_SLIDER,
 		0,
@@ -2021,22 +1925,3 @@ struct menudialogdef g_ExtendedMenuDialog = {
 	MENUDIALOGFLAG_LITERAL_TEXT,
 	NULL,
 };
-
-void updateMaxAnisotropyLevel()
-{
-	for (int i = 0; i < ARRAYCOUNT(g_ExtendedVideoMenuItems); ++i) {
-		struct menuitem *item = &g_ExtendedVideoMenuItems[i];
-		const char *text = menuResolveParam2Text(item);
-		
-		if (text && strstr(text, "Anisotropic Filtering") != NULL) {
-			item->param3 = videoGetMaxAnisotropyLevel();
-			break;
-		}
-	}
-
-}
-
-void optionsMenuInit()
-{
-	updateMaxAnisotropyLevel();
-}

port/src/pdmain.c

@@ -72,6 +72,7 @@
 #include "lib/str.h"
 #include "data.h"
 #include "types.h"
+#include "debugger.h"
 #include "system.h"
 
 extern u8 *g_MempHeap;
@@ -462,9 +463,6 @@ void mainLoop(void)
 		}
 
 		if (g_Vars.coopplayernum >= 0 || g_Vars.antiplayernum >= 0) {
-			if (g_MpSetup.chrslots & 0xfff0) {
-				g_MpSetup.storedbotbits = g_MpSetup.chrslots & 0xfff0;
-			}
 			g_MpSetup.chrslots = 0x03;
 			mpReset();
 		} else if (g_Vars.perfectbuddynum) {
@@ -536,6 +534,15 @@ void mainTick(void)
 		joyDebugJoy();
 		schedSetCrashEnable2(false);
 
+		if (g_DebuggerTimePasses) {
+			g_MainGameLogicEnabled = true;
+		} else {
+			g_MainGameLogicEnabled = (g_DebuggerFrameAdvance > 0);
+			if (g_MainGameLogicEnabled) {
+				--g_DebuggerFrameAdvance;
+			}
+		}
+
 		if (g_MainGameLogicEnabled) {
 			gdl = gdlstart = gfxGetMasterDisplayList();
 
@@ -573,11 +580,10 @@ void mainTick(void)
 		if (g_MainGameLogicEnabled) {
 			gfxSwapBuffers();
 			viUpdateMode();
+			rdpCreateTask(gdlstart, gdl, 0, (uintptr_t) &msg);
+			memaPrint();
+			profileSetMarker(PROFILE_MAINTICK_END);
 		}
-
-		rdpCreateTask(gdlstart, gdl, 0, (uintptr_t) &msg);
-		memaPrint();
-		profileSetMarker(PROFILE_MAINTICK_END);
 	}
 }
 

port/src/pdsched.c

@@ -25,6 +25,7 @@
 #include "audio.h"
 #include "input.h"
 #include "mixer.h"
+#include "debugger.h"
 
 /*
  * private typedefs and defines
@@ -239,6 +240,7 @@ void schedSubmitTask(OSSched *sc, OSScTask *t)
 
 void schedStartFrame(OSSched *sc)
 {
+	debuggerStartFrame();
 	videoStartFrame();
 }
 
@@ -288,6 +290,8 @@ void schedEndFrame(OSSched *sc)
 		viHandleRetrace();
 	}
 
+	debuggerFrame();
+
 	inputUpdate();
 
 	joyStartReadData(&g_PiMesgQueue);
@@ -297,6 +301,8 @@ void schedEndFrame(OSSched *sc)
 	sndHandleRetrace();
 	schedAudioFrame(sc);
 	schedRenderCrashPeriodically(sc->frameCount);
+
+	debuggerEndFrame();
 	videoEndFrame();
 
 	if (g_MainIsBooting == 0) {

port/src/video.c

@@ -45,19 +45,15 @@ static s32 vidFramerateLimit = 0;
 static s32 vidDisplayFPS = 0;
 static f32 vidDisplayFPSInterval = 1.f;
 static f32 vidAvgFPS = 0;
+static f64 vidLastRenderTime;
 
 static s32 vidNumModes = 1;
 static displaymode vidModeDefault;
 static displaymode *vidModes = &vidModeDefault;
 
-static f32 vidGlareBrightness = 1.f;
-static f32 vidOverexposureScale = 1.f;
-
 static s32 texFilter = FILTER_LINEAR;
 static s32 texFilter2D = true;
 static s32 texDetail = false;
-static s32 texMipmapFilter = MIPMAP_LINEAR;
-static u32 texAnisotropicFilter = 4;
 
 static u32 dlcount = 0;
 static u32 frames = 0;
@@ -67,7 +63,6 @@ static f64 fpsTime = 0.0;
 static s32 fpsNumFrames = 0;
 
 static s32 videoInitDisplayModes(void);
-void optionsMenuInit();
 
 s32 videoInit(void)
 {
@@ -105,9 +100,6 @@ s32 videoInit(void)
 	videoSetFramerateLimit(vidFramerateLimit);
 
 	gfx_set_texture_filter((enum FilteringMode)texFilter);
-	gfx_set_mipmap_filter((enum MipmapFilteringMode)texMipmapFilter);
-	videoSetAnisotropicFilter(texAnisotropicFilter);
-	optionsMenuInit();
 
 	initDone = true;
 	return 0;
@@ -147,17 +139,23 @@ void videoEndFrame(void)
 	const f64 flipTime = wmAPI->get_time();
 	accumDelta += flipTime - endTime;
 	endTime = flipTime;
+	vidLastRenderTime = endTime - startTime;
 
 	if (endTime >= fpsTime) {
 		char tmp[128];
 		vidAvgFPS = fpsNumFrames ? ((f64)fpsNumFrames / accumDelta) : 0.f;
 		fpsNumFrames = 0;
 		accumDelta = 0.0;
+		snprintf(tmp, sizeof(tmp), "fps %4.1f frt %lf frm %u", vidAvgFPS, vidLastRenderTime, frames);
+		wmAPI->set_window_title(tmp);
 		fpsTime = endTime + vidDisplayFPSInterval;
 	}
 }
 
-
+f64 videoGetLastRenderTime(void)
+{
+	return vidLastRenderTime;
+}
 
 f32 videoGetAverageFPS(void)
 {
@@ -371,31 +369,11 @@ u32 videoGetTextureFilter(void)
 	return texFilter;
 }
 
-u32 videoGetAnisotropicFilter()
-{
-	return texAnisotropicFilter;
-}
-
-u32 videoGetMaxAnisotropyLevel()
-{
-	return renderingAPI->get_max_anisotropy_level();
-}
-
 s32 videoGetDetailTextures(void)
 {
 	return texDetail;
 }
 
-f32 videoGetGlareBrightness(void)
-{
-	return vidGlareBrightness;
-}
-
-f32 videoGetOverexposureScale(void)
-{
-	return vidOverexposureScale;
-}
-
 void videoSetWindowOffset(s32 x, s32 y)
 {
 	gfx_current_game_window_viewport.x = x;
@@ -463,28 +441,12 @@ void videoSetTextureFilter2D(s32 filter)
 	texFilter2D = !!filter;
 }
 
-void videoSetAnisotropicFilter(u32 level)
-{
-	texAnisotropicFilter = level;
-	renderingAPI->set_anisotropy_level(level);
-}
-
 void videoSetDetailTextures(s32 detail)
 {
 	texDetail = !!detail;
 	gfx_detail_textures_enabled = (bool)texDetail;
 }
 
-void videoSetGlareBrightness(f32 bright)
-{
-	vidGlareBrightness = (bright < 0.f ? 0.f : (bright > 1.f ? 1.f : bright));
-}
-
-void videoSetOverexposureScale(f32 scale)
-{
-	vidOverexposureScale = (scale < 0.f ? 0.f : (scale > 1.f ? 1.f : scale));
-}
-
 s32 videoCreateFramebuffer(u32 w, u32 h, s32 upscale, s32 autoresize)
 {
 	return gfx_create_framebuffer(w, h, upscale, autoresize);
@@ -553,11 +515,6 @@ void videoFreeCachedTexture(const void *texptr)
 	gfx_texture_cache_delete(texptr);
 }
 
-void videoFreeCachedTextures(const void *start, const void *end)
-{
-	gfx_texture_cache_delete_range(start, end);
-}
-
 void videoShutdown(void)
 {
 	free(vidModes);
@@ -581,8 +538,4 @@ PD_CONSTRUCTOR static void videoConfigInit(void)
 	configRegisterInt("Video.TextureFilter", &texFilter, 0, 2);
 	configRegisterInt("Video.TextureFilter2D", &texFilter2D, 0, 1);
 	configRegisterInt("Video.DetailTextures", &texDetail, 0, 1);
-	configRegisterInt("Video.MipmapFilter", &texMipmapFilter, 0, 2);
-	configRegisterInt("Video.AnisotropicFilter", &texAnisotropicFilter, 0, 16);
-	configRegisterFloat("Video.GlareBrightness", &vidGlareBrightness, 0.f, 1.f);
-	configRegisterFloat("Video.OverexposureScale", &vidOverexposureScale, 0.f, 1.f);
 }

src/game/bg.c

@@ -15,7 +15,7 @@
 #include "game/sky.h"
 #include "game/stars.h"
 #include "game/dyntex.h"
-#include "game/artifact.h"
+#include "game/game_13c510.h"
 #include "game/game_1531a0.h"
 #include "game/gfxmemory.h"
 #include "game/gfxreplace.h"
@@ -135,9 +135,6 @@ s32 g_BgMostAttemptedDrawSlots = 0;
 s32 g_BgNumRoomLoadCandidates = 0;
 u16 g_BgFrameCount = 0xfffe;
 s32 g_BgNumPortalCameraCacheItems = 0;
-#ifndef PLATFORM_N64
-bool g_BgHitXluDisabled = false;
-#endif
 
 void bgUnpausePropsInRoom(u32 roomnum, bool tintedglassonly)
 {
@@ -4593,10 +4590,6 @@ bool bgTestHitInRoom(struct coord *frompos, struct coord *topos, s32 roomnum, st
 	numbatches = g_Rooms[roomnum].numvtxbatches;
 
 	for (i = 0; i < numbatches; batch++, i++) {
-#ifndef PLATFORM_N64
-		if (g_BgHitXluDisabled && batch->type == VTXBATCHTYPE_XLU)
-			continue;
-#endif
 		j = bg0f1612e4(&batch->bbmin, &batch->bbmax, &from, &dist, &sp94, &hitthing->pos);
 
 		if (j == 0) {
@@ -6424,10 +6417,6 @@ void bgCalculateGlaresForVisibleRooms(void)
 
 	g_NumRoomsWithGlares = 0;
 
-	// disable line-of-sight hits for transparent background
-	// surfaces before testing for light obstructions
-	g_BgHitXluDisabled = true;
-
 	if (!g_Vars.mplayerisrunning) {
 		for (i = 1; i < g_Vars.roomcount; i++) {
 			if (g_Rooms[i].flags & ROOMFLAG_ONSCREEN) {
@@ -6438,9 +6427,6 @@ void bgCalculateGlaresForVisibleRooms(void)
 			}
 		}
 	}
-
-	// re-enable background hits for transparent surfaces
-	g_BgHitXluDisabled = false;
 }
 
 #endif

src/game/bondgun.c

@@ -8477,7 +8477,7 @@ glabel var7f1aca90
 /*  f0a71e4:	100002d5 */ 	b	.L0f0a7d3c
 /*  f0a71e8:	8fbf0034 */ 	lw	$ra,0x34($sp)
 .L0f0a71ec:
-/*  f0a71ec:	0fc5d9ad */ 	jal	zbufSaveArtifactDepths
+/*  f0a71ec:	0fc5d9ad */ 	jal	zbufDrawArtifactsOffscreen
 /*  f0a71f0:	8fa4014c */ 	lw	$a0,0x14c($sp)
 /*  f0a71f4:	afa2014c */ 	sw	$v0,0x14c($sp)
 /*  f0a71f8:	0c002ca0 */ 	jal	viPrepareZbuf
@@ -9318,7 +9318,7 @@ glabel var7f1aca90
 /*  f0a71e4:	100002d5 */ 	b	.L0f0a7d3c
 /*  f0a71e8:	8fbf0034 */ 	lw	$ra,0x34($sp)
 .L0f0a71ec:
-/*  f0a71ec:	0fc5d9ad */ 	jal	zbufSaveArtifactDepths
+/*  f0a71ec:	0fc5d9ad */ 	jal	zbufDrawArtifactsOffscreen
 /*  f0a71f0:	8fa4014c */ 	lw	$a0,0x14c($sp)
 /*  f0a71f4:	afa2014c */ 	sw	$v0,0x14c($sp)
 /*  f0a71f8:	0c002ca0 */ 	jal	viPrepareZbuf
@@ -10159,7 +10159,7 @@ glabel var7f1aca90
 /*  f0a4f30:	100002cd */ 	beqz	$zero,.NB0f0a5a68
 /*  f0a4f34:	8fbf0034 */ 	lw	$ra,0x34($sp)
 .NB0f0a4f38:
-/*  f0a4f38:	0fc5c4d5 */ 	jal	zbufSaveArtifactDepths
+/*  f0a4f38:	0fc5c4d5 */ 	jal	zbufDrawArtifactsOffscreen
 /*  f0a4f3c:	8fa40144 */ 	lw	$a0,0x144($sp)
 /*  f0a4f40:	afa20144 */ 	sw	$v0,0x144($sp)
 /*  f0a4f44:	0c002d00 */ 	jal	viPrepareZbuf
@@ -10957,7 +10957,7 @@ void bgunRender(Gfx **gdlptr)
 	}
 
 #ifdef PLATFORM_N64 // TODO
-	gdl = zbufSaveArtifactDepths(gdl);
+	gdl = zbufDrawArtifactsOffscreen(gdl);
 #endif
 	gdl = viPrepareZbuf(gdl);
 	gdl = vi0000b1d0(gdl);

src/game/bondmove.c

@@ -329,11 +329,11 @@ void bmoveUpdateSpeedTheta(void)
 f32 bmoveGetSpeedVertaLimit(f32 value)
 {
 	if (value > 0) {
-		return (viGetFovY() * value * -0.7f) / PLAYER_DEFAULT_FOV;
+		return (viGetFovY() * value * -0.7f) / 60.0f;
 	}
 
 	if (value < 0) {
-		return (viGetFovY() * -value * 0.7f) / PLAYER_DEFAULT_FOV;
+		return (viGetFovY() * -value * 0.7f) / 60.0f;
 	}
 
 	return 0;
@@ -341,7 +341,7 @@ f32 bmoveGetSpeedVertaLimit(f32 value)
 
 void bmoveUpdateSpeedVerta(f32 value)
 {
-	f32 mult = viGetFovY() / PLAYER_DEFAULT_FOV;
+	f32 mult = viGetFovY() / 60.0f;
 	f32 limit = bmoveGetSpeedVertaLimit(value);
 
 	if (value > 0) {
@@ -384,11 +384,11 @@ void bmoveUpdateSpeedVerta(f32 value)
 f32 bmoveGetSpeedThetaControlLimit(f32 value)
 {
 	if (value > 0) {
-		return (viGetFovY() * value * -0.7f) / PLAYER_DEFAULT_FOV;
+		return (viGetFovY() * value * -0.7f) / 60.0f;
 	}
 
 	if (value < 0) {
-		return (viGetFovY() * -value * 0.7f) / PLAYER_DEFAULT_FOV;
+		return (viGetFovY() * -value * 0.7f) / 60.0f;
 	}
 
 	return 0;
@@ -396,7 +396,7 @@ f32 bmoveGetSpeedThetaControlLimit(f32 value)
 
 void bmoveUpdateSpeedThetaControl(f32 value)
 {
-	f32 mult = viGetFovY() / PLAYER_DEFAULT_FOV;
+	f32 mult = viGetFovY() / 60.0f;
 	f32 limit = bmoveGetSpeedThetaControlLimit(value);
 
 	if (value > 0) {
@@ -436,38 +436,6 @@ void bmoveUpdateSpeedThetaControl(f32 value)
 	}
 }
 
-/**
- * Apply crosshair swivel based on camera movement with input detection
- */
-static void bmoveApplyCrosshairSwivel(struct movedata *movedata, f32 mlookscale, f32 *x, f32 *y)
-{
-#ifdef PLATFORM_N64
-	*x = g_Vars.currentplayer->speedtheta * 0.3f + g_Vars.currentplayer->gunextraaimx;
-	*y = -g_Vars.currentplayer->speedverta * 0.1f + g_Vars.currentplayer->gunextraaimy;
-#else
-	f32 xscale, yscale;
-	bool mouse_active = (movedata->freelookdx || movedata->freelookdy);
-	bool joystick_active = (movedata->c1stickxraw != 0 || movedata->c1stickyraw != 0);
-	
-	if ((mouse_active) && joystick_active) {
-		// Mouse + joystick sway
-		xscale = PLAYER_EXTCFG().crosshairsway * 0.80f;  // 80% for precision+joystick sway
-		yscale = PLAYER_EXTCFG().crosshairsway * 0.80f;  // 80% for precision+joystick sway
-	} else if (mouse_active) {
-		// Mouse sway
-		xscale = PLAYER_EXTCFG().crosshairsway * 0.20f;  // 20% for mouse sway
-		yscale = PLAYER_EXTCFG().crosshairsway * 0.30f;  // 30% for mouse sway
-	} else {
-		// Joystick only or no input - full sway
-		xscale = yscale = PLAYER_EXTCFG().crosshairsway;
-	}
-	// Joystick x/y scaling
-	// 0.3f for x, 0.1f for y
-	*x = g_Vars.currentplayer->speedtheta * 0.3f * xscale + g_Vars.currentplayer->gunextraaimx;
-	*y = -g_Vars.currentplayer->speedverta * 0.1f * yscale + g_Vars.currentplayer->gunextraaimy;
-#endif
-}
-
 /**
  * Calculate the lookahead angle.
  *
@@ -1444,31 +1412,31 @@ void bmoveProcessInput(bool allowc1x, bool allowc1y, bool allowc1buttons, bool i
 					}
 
 #ifndef PLATFORM_N64
-					// Handle turning and looking (x/y) via mouselook when aiming
-					bool allowcross = allowmcross;
-					if (g_Vars.currentplayer->insightaimmode && allowcross && bgunGetWeaponNum(HAND_RIGHT) != WEAPON_HORIZONSCANNER) {
-						float edge_boundary = PLAYER_EXTCFG().crosshairedgeboundary;
-						if (g_Vars.currentplayer->swivelpos[0] > edge_boundary) {
-							movedata.aimturnrightspeed += (g_Vars.currentplayer->swivelpos[0] - edge_boundary) / (1.0f - edge_boundary);
-						} else if (g_Vars.currentplayer->swivelpos[0] < -edge_boundary) {
-							movedata.aimturnleftspeed += (g_Vars.currentplayer->swivelpos[0] + edge_boundary) / -(1.0f - edge_boundary);
+					// Handle turning and looking up/down via mouselook when aiming
+					if (g_Vars.currentplayer->insightaimmode && allowmcross && bgunGetWeaponNum(HAND_RIGHT) != WEAPON_HORIZONSCANNER) {
+						if (g_Vars.currentplayer->swivelpos[0] > 0.9f) {
+							movedata.aimturnrightspeed = (g_Vars.currentplayer->swivelpos[0] - 0.9f) / 0.1f;
+							movedata.aimturnleftspeed = 0.f;
+						} else if (g_Vars.currentplayer->swivelpos[0] < -0.9f) {
+							movedata.aimturnleftspeed = (g_Vars.currentplayer->swivelpos[0] - -0.9f) / -0.1f;
+							movedata.aimturnrightspeed = 0.f;
 						}
 						f32 vertaup = 0.f, vertadown = 0.f;
-						if (g_Vars.currentplayer->swivelpos[1] > edge_boundary) {
-							vertaup = (g_Vars.currentplayer->swivelpos[1] - edge_boundary) / (1.0f - edge_boundary);
-						} else if (g_Vars.currentplayer->swivelpos[1] < -edge_boundary) {
-							vertadown = (g_Vars.currentplayer->swivelpos[1] + edge_boundary) / -(1.0f - edge_boundary);
+						if (g_Vars.currentplayer->swivelpos[1] > 0.9f) {
+							vertaup = (g_Vars.currentplayer->swivelpos[1] - 0.9f) / 0.1f;
+						} else if (g_Vars.currentplayer->swivelpos[1] < -0.9f) {
+							vertadown = (g_Vars.currentplayer->swivelpos[1] - -0.9f) / -0.1f;
 						}
 						// Uninvert pitch if needed
 						if (movedata.invertpitch) {
-							movedata.speedvertaup += vertadown;
-							movedata.speedvertadown += vertaup;
+							movedata.speedvertaup = vertadown;
+							movedata.speedvertadown = vertaup;
 						} else {
-							movedata.speedvertaup += vertaup;
-							movedata.speedvertadown += vertadown;
+							movedata.speedvertaup = vertaup;
+							movedata.speedvertadown = vertadown;
 						}
 					} else {
-						// Reset mouse aim position when not aiming
+						// Reset mouse aim position when not mouse aiming
 						g_Vars.currentplayer->swivelpos[0] = 0.f;
 						g_Vars.currentplayer->swivelpos[1] = 0.f;
 					}
@@ -2064,7 +2032,7 @@ void bmoveProcessInput(bool allowc1x, bool allowc1y, bool allowc1buttons, bool i
 			}
 		} else {
 			if (movedata.cannaturalpitch) {
-				tmp = viGetFovY() / PLAYER_DEFAULT_FOV;
+				tmp = viGetFovY() / 60.0f;
 				fVar25 = movedata.analogpitch / 70.0f;
 
 				if (fVar25 > 1) {
@@ -2105,7 +2073,7 @@ void bmoveProcessInput(bool allowc1x, bool allowc1y, bool allowc1buttons, bool i
 	}
 
 	if (movedata.cannaturalturn) {
-		tmp = viGetFovY() / PLAYER_DEFAULT_FOV;
+		tmp = viGetFovY() / 60.0f;
 		fVar25 = movedata.analogturn / 70.0f;
 
 		if (fVar25 > 1) {
@@ -2218,8 +2186,15 @@ void bmoveProcessInput(bool allowc1x, bool allowc1y, bool allowc1buttons, bool i
 			x = g_Vars.currentplayer->speedtheta * 0.3f + g_Vars.currentplayer->gunextraaimx;
 			y = -g_Vars.currentplayer->speedverta * 0.1f + g_Vars.currentplayer->gunextraaimy;
 #else
-            // Crosshair swivel movement system
-			bmoveApplyCrosshairSwivel(&movedata, mlookscale, &x, &y);
+			f32 xscale, yscale;
+			if (movedata.freelookdx || movedata.freelookdy) {
+				xscale = PLAYER_EXTCFG().crosshairsway * 0.20f;
+				yscale = PLAYER_EXTCFG().crosshairsway * 0.30f;
+			} else {
+				xscale = yscale = PLAYER_EXTCFG().crosshairsway;
+			}
+			x = g_Vars.currentplayer->speedtheta * 0.3f * xscale + g_Vars.currentplayer->gunextraaimx;
+			y = -g_Vars.currentplayer->speedverta * 0.1f * yscale + g_Vars.currentplayer->gunextraaimy;
 #endif
 
 			bgunSwivelWithDamp(x, y, PAL ? 0.955f : 0.963f);
@@ -2415,6 +2390,14 @@ void bmoveTick(bool allowc1x, bool allowc1y, bool allowc1buttons, bool ignorec2)
 
 void bmoveUpdateVerta(void)
 {
+	while (g_Vars.currentplayer->vv_verta < -180) {
+		g_Vars.currentplayer->vv_verta += 360;
+	}
+
+	while (g_Vars.currentplayer->vv_verta >= 180) {
+		g_Vars.currentplayer->vv_verta -= 360;
+	}
+
 	if (g_Vars.currentplayer->vv_verta > 90) {
 		g_Vars.currentplayer->vv_verta = 90;
 	} else if (g_Vars.currentplayer->vv_verta < -90) {

src/game/bot.c

@@ -262,8 +262,7 @@ void botSpawn(struct chrdata *chr, u8 respawning)
 		func0f02e9a0(chr, 0);
 
 #ifndef PLATFORM_N64
-		if (g_Vars.normmplayerisrunning
-				&& (g_MpSetup.options & MPOPTION_SPAWNWITHWEAPON)
+		if ((g_MpSetup.options & MPOPTION_SPAWNWITHWEAPON)
 				&& g_MpSetup.weapons[0] != MPWEAPON_NONE
 				&& g_MpSetup.weapons[0] != MPWEAPON_DISABLED
 				&& g_MpSetup.weapons[0] != MPWEAPON_SHIELD) {

src/game/cheats.c

@@ -165,17 +165,6 @@ void cheatActivate(s32 cheat_id)
 		setCurrentPlayerNum(prevplayernum);
 		break;
 	case CHEAT_ALLGUNS:
-#ifndef PLATFORM_N64
-		// Give all guns to all players
-		prevplayernum = g_Vars.currentplayernum;
-
-		for (playernum = 0; playernum < PLAYERCOUNT(); playernum++) {
-			setCurrentPlayerNum(playernum);
-			invSetAllGuns(true);
-		}
-
-		setCurrentPlayerNum(prevplayernum);
-#else
 		// Give all guns if only one player playing
 		if (PLAYERCOUNT() == 1 && g_Vars.normmplayerisrunning == false) {
 			prevplayernum = g_Vars.currentplayernum;
@@ -187,7 +176,6 @@ void cheatActivate(s32 cheat_id)
 
 			setCurrentPlayerNum(prevplayernum);
 		}
-#endif
 		break;
 	}
 
@@ -215,16 +203,6 @@ void cheatDeactivate(s32 cheat_id)
 		setCurrentPlayerNum(prevplayernum);
 		break;
 	case CHEAT_ALLGUNS:
-#ifndef PLATFORM_N64
-		prevplayernum = g_Vars.currentplayernum;
-
-		for (playernum = 0; playernum < PLAYERCOUNT(); playernum++) {
-			setCurrentPlayerNum(playernum);
-			invSetAllGuns(false);
-		}
-
-		setCurrentPlayerNum(prevplayernum);
-#else
 		if (PLAYERCOUNT() == 1 && g_Vars.normmplayerisrunning == false) {
 			prevplayernum = g_Vars.currentplayernum;
 
@@ -235,7 +213,6 @@ void cheatDeactivate(s32 cheat_id)
 
 			setCurrentPlayerNum(prevplayernum);
 		}
-#endif
 		break;
 	}
 
@@ -332,7 +309,7 @@ MenuItemHandlerResult cheatCheckboxMenuHandler(s32 operation, struct menuitem *i
 			return false;
 		}
 
-		if (g_CheatsEnabledBank1 & (1 << (item->param - 32))) {
+		if (g_CheatsEnabledBank1 & (1 << item->param)) {
 			return true;
 		}
 
@@ -357,12 +334,11 @@ MenuItemHandlerResult cheatCheckboxMenuHandler(s32 operation, struct menuitem *i
 				}
 			} else {
 				// Bank 1
-				if (g_CheatsEnabledBank1 & (1 << (item->param - 32))) {
-				// We need to subtract 32 on lines like these to avoid undefined behavior, namely ensuring that all cheats are toggled correctly and regardless of build optimiaztion
+				if (g_CheatsEnabledBank1 & (1 << item->param)) {
 					if (1);
-					g_CheatsEnabledBank1 = g_CheatsEnabledBank1 & ~(1 << (item->param - 32));
+					g_CheatsEnabledBank1 = g_CheatsEnabledBank1 & ~(1 << item->param);
 				} else {
-					g_CheatsEnabledBank1 = g_CheatsEnabledBank1 | (1 << (item->param - 32));
+					g_CheatsEnabledBank1 = g_CheatsEnabledBank1 | 1 << item->param;
 				}
 			}
 		}

src/game/chr.c

@@ -4544,17 +4544,7 @@ void chrTestHit(struct prop *prop, struct shotdata *shotdata, bool isshooting, b
 
 			if (hitpart) {
 				if (chrGetShield(chr) > 0.0f) {
-#ifndef PLATFORM_N64
-					/**
-					 * var8005efc0 > 0.0f adds a padding to bbox hit detection
-					 * in modelTestBboxNodeForHit() that accounts for a character's
-					 * surrounding shield. We skip this step on PC when checking
-					 * line-of-sight hits to light artifacts because lights should
-					 * be visible through the transparent shield.
-					 */
-					if (g_BgHitXluDisabled == false)
-#endif
-						var8005efc0 = 10.0f / model->scale;
+					var8005efc0 = 10.0f / model->scale;
 				}
 
 				child = prop->child;

src/game/chraction.c

@@ -15336,17 +15336,21 @@ bool chrMoveToPos(struct chrdata *chr, struct coord *pos, RoomNum *rooms, f32 an
 		propDeregisterRooms(chr->prop);
 		roomsCopy(rooms2, chr->prop->rooms);
 		chr0f0220ac(chr);
-		modelSetRootPosition(chr->model, &pos2);
 
-		nodetype = chr->model->definition->rootnode->type;
-
-		if ((nodetype & 0xff) == MODELNODETYPE_CHRINFO) {
-			rwdata = modelGetNodeRwData(chr->model, chr->model->definition->rootnode);
-			rwdata->chrinfo.ground = ground;
+		if (chr->model) {
+			modelSetRootPosition(chr->model, &pos2);
+			nodetype = chr->model->definition->rootnode->type;
+			if ((nodetype & 0xff) == MODELNODETYPE_CHRINFO) {
+				rwdata = modelGetNodeRwData(chr->model, chr->model->definition->rootnode);
+				rwdata->chrinfo.ground = ground;
+			}
 		}
 
 		chr->chrflags |= CHRCFLAG_FORCETOGROUND;
-		chrSetLookAngle(chr, angle);
+
+		if (chr->model || chr->aibot) {
+			chrSetLookAngle(chr, angle);
+		}
 
 		if (chr->prop->type == PROPTYPE_PLAYER) {
 			player = g_Vars.players[playermgrGetPlayerNumByProp(chr->prop)];

src/game/chraicommands.c

@@ -2330,7 +2330,7 @@ bool aiGiveObjectToChr(void)
 			}
 #endif
 
-			something = propPickupByPlayer(obj->prop, 1);
+			something = propPickupByPlayer(obj->prop, 0);
 			propExecuteTickOperation(obj->prop, something);
 			playernum = playermgrGetPlayerNumByProp(chr->prop);
 			obj2->hidden = (playernum << 28) | (obj2->hidden & 0x0fffffff);

src/game/explosions.c

@@ -35,7 +35,7 @@
 #endif
 
 struct explosion *g_Explosions;
-s32 g_MaxExplosions = MAX_EXPLOSIONS_DEFAULT;
+s32 g_MaxExplosions;
 
 s32 g_ExplosionShakeTotalTimer = 0;
 s32 g_ExplosionShakeIntensityTimer = 0;

src/game/explosionsreset.c

@@ -14,6 +14,12 @@ void explosionsReset(void)
 	g_ExplosionShakeIntensityTimer = 0;
 	g_ExplosionDamageTxScale = 1;
 
+	g_MaxExplosions = MAX_EXPLOSIONS;
+
+	if (g_Vars.stagenum >= STAGE_TITLE) {
+		g_MaxExplosions = 0;
+	}
+
 	if (g_MaxExplosions == 0) {
 		g_Explosions = NULL;
 	} else {

src/game/explosionsstop.c

@@ -14,7 +14,7 @@ void explosionsStop(void)
 	viShake(0);
 
 	if (g_Explosions) {
-		for (i = 0; i < g_MaxExplosions; i++) {
+		for (i = 0; i < MAX_EXPLOSIONS; i++) {
 			if (g_Explosions[i].prop) {
 				propDelist(g_Explosions[i].prop);
 				propDisable(g_Explosions[i].prop);

src/game/filemgr.c

@@ -19,7 +19,6 @@
 #include "lib/str.h"
 #include "data.h"
 #include "types.h"
-#include "mpsetups.h"
 
 // bss
 struct fileguid g_FilemgrFileToCopy;
@@ -2733,10 +2732,6 @@ MenuItemHandlerResult filemgrChooseAgentListMenuHandler(s32 operation, struct me
 				g_GameFileGuid.fileid = file->fileid;
 				g_GameFileGuid.deviceserial = file->deviceserial;
 				filemgrSaveOrLoad(&g_GameFileGuid, FILEOP_LOAD_GAME, 0);
-
-				// load the setup file when loading the agent
-				mpsetupCopyAllFromPak();
-				mpsetupLoadCurrentFile();
 			}
 		}
 		break;

src/game/game_13c510.c

@@ -7,7 +7,7 @@
 #include "game/game_0b2150.h"
 #include "game/tex.h"
 #include "game/sky.h"
-#include "game/artifact.h"
+#include "game/game_13c510.h"
 #include "game/bg.h"
 #include "game/stagetable.h"
 #include "game/room.h"
@@ -21,73 +21,8 @@
 #include "lib/lib_17ce0.h"
 #include "game/player.h"
 #include "game/prop.h"
-#include "video.h"
 #endif
 
-/**
- * Artifacts are points of interest in the z-buffer.
- *
- * They correspond to:
- * - Individual circles in the lens flare effect from the sun.
- * - Individual corners of each light fixture's box.
- *
- * The game needs to do line of sight checks to these points. The collision
- * system would normally be used for line of sight checks, but it only works
- * with basic geometric volumes and also doesn't take into account the player's
- * gun. Instead, the checks are done by reading from the previous frame's
- * z-buffer.
- *
- * Typically, the z-buffer would be read by the scheduler after a graphics frame
- * is rendered, but this only works if the z-buffer is a complete image.
- * PD draws the scene, then clears the z-buffer before drawing the player's gun,
- * so the z-buffer at the end only contains the player's gun. To work around
- * this, the GPU is given commands to read the z-buffer as a texture and copy
- * depth values to a safe place before clearing it. Then once the frame is
- * rendered, the scheduler compares the saved depths with the current z-buffer
- * and updates the artifact, applying the minimum of the two depths.
- *
- * The scheduler maintains 3 arrays of artifacts, each referenced by indexes
- * which rotate between them.
- * - Artifacts are written by the main thread using the write index.
- *   The write and front indexes are then incremented.
- * - The same artifacts are updated by the scheduler using the pending index.
- *   The pending index is then updated.
- * - The artifacts are then rendered on a later frame using the front index.
- *
- * In each artifacts array, the first several slots are reserved for the sun
- * flare artifacts. The quantity depends on the number of suns in the stage
- * (Skedar Ruins has 3) and there are 8 artifacts per sun. The remaining slots
- * are used for light fixture corners. The array is big enough to handle at
- * least 90 lights on screen at a time.
- *
- * The initial state of the indexes are write=0, front=1, pending=0.
- * These are set in sched_reset_artifacts.
- *
- * The detailed workflow is:
- * - CPU: Light artifacts are determined and added to write artifacts (0) array
- * - CPU: Constructs the gdl in this order:
- *     - Render scene
- *     - Copy relevant parts of z-buffer to write depths (0) array
- *     - Clear z-buffer and render gun
- *     - Render artifacts by reading from front artifacts (1) array
- * - CPU: increments write (0 -> 1) and front (1 -> 2) indexes
- * - GPU: Executes above task. g_ArtifactDepths0 now contains depths, and is
- *       pointed to by pending.
- * - Scheduler: Reads the z-buffer, which at this point only contains the gun
- *       depth information, and updates the artifact with the minimum of the two
- * - Scheduler: Increments pending (0 -> 1)
- *
- * It appears that the front index should be initialised to 2 instead, so that
- * it's one frame behind the others rather than two frames behind.
- *
- * There's no doubt this went through several iterations before landing on this
- * implementation. It's likely that this was implemented using a single and full
- * z-buffer and it worked well until they decided to clear the z-buffer before
- * rendering the gun. There is evidence in zbuf.c that they allocated a second
- * z-buffer and swapped it. But when memory got too tight they had to change it
- * to this texture read method.
- */
-
 u8 *var800a41a0;
 u32 var800a41a4;
 u32 var800a41a8;
@@ -109,25 +44,11 @@ void artifactsTick(void)
 	schedIncrementFrontArtifacts();
 }
 
-u16 floatToN64Depth(f32 arg0)
+u16 func0f13c574(f32 arg0)
 {
-	/**
-	 * Method to convert a 32 bit floating point depth value to the
-	 * unsigned 16 bit integer format used by the zbuffer on the N64.
-	 * The argument arg0 represents z normalized to [0, 1] * 32704.0f.
-	 *
-	 * It works by converting the depth value to a large, unsigned 32 bit
-	 * integer before scaling back down to an unsigned 16 bit integer.
-	 * The scaling is done using bit shift operations on the most & least
-	 * significant bytes of the resulting 16 bit integer, likely because
-	 * bit shift operations are faster than division. The segmentation of
-	 * this calculation at values 0x3f800, 0x3f000, etc. is probably
-	 * intended to reduce z-fighting by adding more differentiation for
-	 * distant z values.
-	 */
 	u32 value = arg0 * 8.0f;
-	u32 left; // forms the most significant byte of the final u16
-	u32 right = value; // forms the least significant byte of the final u16
+	u32 left;
+	u32 right = value;
 
 	if (value > 0x3f800) {
 		right = value & 0x7ff;
@@ -166,7 +87,7 @@ u16 floatToN64Depth(f32 arg0)
 	return left << 13 | (right << 2);
 }
 
-s32 artifactsFloatToInt(f32 arg0)
+s32 func0f13c710(f32 arg0)
 {
 	if (arg0 > 0.0f) {
 		if (arg0 > 2147483520.0f) {
@@ -247,12 +168,6 @@ void artifactsCalculateGlaresForRoom(s32 roomnum)
 	struct coord *campos = &g_Vars.currentplayer->cam_pos;
 	struct artifact *artifact;
 
-#ifndef PLATFORM_N64
-	if (videoGetGlareBrightness() <= 0.f) {
-		return;
-	}
-#endif
-
 	if (g_Rooms[roomnum].gfxdata != NULL && g_Rooms[roomnum].loaded240) {
 		numlights = g_Rooms[roomnum].gfxdata->numlights;
 
@@ -317,8 +232,8 @@ void artifactsCalculateGlaresForRoom(s32 roomnum)
 
 					if (spdc[3] > 0.0001f) {
 						f20 = 1.0f / spdc[3];
-						x = artifactsFloatToInt(viewleft + (1.0f + spdc[0] * f20) * (viewwidth * 0.5f));
-						y = artifactsFloatToInt(viewtop + (1.0f - spdc[1] * f20) * (viewheight * 0.5f));
+						x = func0f13c710(viewleft + (1.0f + spdc[0] * f20) * (viewwidth * 0.5f));
+						y = func0f13c710(viewtop + (1.0f - spdc[1] * f20) * (viewheight * 0.5f));
 						f0 = (spdc[2] * f20 * 511.0f + 511.0f) * 32.0f;
 
 						if (f0 < 32576.0f) {
@@ -420,8 +335,8 @@ void artifactsCalculateGlaresForRoom(s32 roomnum)
 								f20 = -9999.0f;
 							}
 
-							xi = artifactsFloatToInt(viewleft + (1.0f + spdc[0] * f20) * (viewwidth * 0.5f));
-							yi = artifactsFloatToInt(viewtop + (1.0f - spdc[1] * f20) * (viewheight * 0.5f));
+							xi = func0f13c710(viewleft + (1.0f + spdc[0] * f20) * (viewwidth * 0.5f));
+							yi = func0f13c710(viewtop + (1.0f - spdc[1] * f20) * (viewheight * 0.5f));
 							f0 = (spdc[2] * f20 * 511.0f + 511.0f) * 32.0f;
 
 							if (g_ZbufPtr1
@@ -442,20 +357,14 @@ void artifactsCalculateGlaresForRoom(s32 roomnum)
 
 								if (index < MAX_ARTIFACTS) {
 #ifndef PLATFORM_N64
-									artifact->visiblelos = artifactTestLos(&spec, &g_BgRooms[roomnum].pos, xi, yi);
+									artifact->unk02 = artifactTestLos(&spec, &g_BgRooms[roomnum].pos, xi, yi);
 #endif
-									/**
-									 * the original game performs artifact depth comparison
-									 * using the N64 depth values divided by 4. This is
-									 * accomplished by bit shifting the N64 depth value
-									 * to the right using >> 2
-									 */
-									artifact->expecteddepth = floatToN64Depth(f0) >> 2;
-									artifact->zbufptr = &g_ZbufPtr1[viGetWidth() * yi + xi];
+									artifact->unk04 = func0f13c574(f0) >> 2;
+									artifact->unk08 = &g_ZbufPtr1[viGetWidth() * yi + xi];
 									artifact->light = &roomlights[i];
 									artifact->type = ARTIFACTTYPE_GLARE;
-									artifact->screenx = xi;
-									artifact->screeny = yi;
+									artifact->unk0c.u16_2 = xi;
+									artifact->unk0c.u16_1 = yi;
 								}
 							}
 						}
@@ -466,7 +375,7 @@ void artifactsCalculateGlaresForRoom(s32 roomnum)
 	}
 }
 
-u8 artifactsClamp(u8 arg0, u8 arg1)
+u8 func0f13d3c4(u8 arg0, u8 arg1)
 {
 	if (arg1 >= arg0 + 7) {
 		return arg0 + 7;
@@ -514,18 +423,18 @@ Gfx *artifactsRenderGlaresForRoom(Gfx *gdl, s32 roomnum)
 	u16 min;
 	u16 max;
 	f32 lightop_cur_frac;
-	s32 numgood;
+	s32 t2;
 	struct light *light;
 	u8 *s3;
 	s32 k;
 	s32 count;
-	u16 actualdepth;
+	u16 t4;
 	f32 add;
 	s32 l;
 	f32 brightness;
-	s32 tolerance;
+	s32 avg;
 	f32 f0;
-	s32 difference;
+	s32 v1;
 	s32 r;
 	s32 g;
 	s32 b;
@@ -539,13 +448,6 @@ Gfx *artifactsRenderGlaresForRoom(Gfx *gdl, s32 roomnum)
 	f32 f24;
 	bool extra;
 	f32 f26;
-#ifndef PLATFORM_N64
-	const f32 pfov = g_Vars.currentplayerstats ? PLAYER_DEFAULT_FOV : 60.f;
-	const f32 brightscale = videoGetGlareBrightness();
-	if (brightscale <= 0.f) {
-		return gdl;
-	}
-#endif
 
 	artifacts = schedGetFrontArtifacts();
 	lightop_cur_frac = roomGetLightOpCurFrac(roomnum);
@@ -558,12 +460,6 @@ Gfx *artifactsRenderGlaresForRoom(Gfx *gdl, s32 roomnum)
 		struct light *light2 = artifacts[i].light;
 		count = 0;
 
-		/**
-		 * light arifacts are created from several, closely spaced
-		 * textures that give the appearance of a dynamic light glare
-		 * as the character moves. Loop to count all the sub-artifacts
-		 * in this light.
-		 */
 		for (j = i; j < MAX_ARTIFACTS && artifacts[j].type == ARTIFACTTYPE_GLARE && artifacts[j].light == light2; j++) {
 			count++;
 		}
@@ -574,70 +470,52 @@ Gfx *artifactsRenderGlaresForRoom(Gfx *gdl, s32 roomnum)
 			if (roomnum == light->roomnum) {
 				lightindex = ((uintptr_t)light - (uintptr_t)g_BgLightsFileData) / sizeof(struct light);
 				s3 = &var800a41a0[lightindex * 3];
-				numgood = 0;
+				t2 = 0;
 				min = 0xffff;
 				max = 0;
 
-				/**
-				 * loop to determine the min & max depth of
-				 * the sub-artifacts composing this room light.
-				 */
 				for (k = i; k < i + count; k++) {
-					if (artifacts[k].expecteddepth > max) {
-						max = artifacts[k].expecteddepth;
+					if (artifacts[k].unk04 > max) {
+						max = artifacts[k].unk04;
 					}
 
-					if (artifacts[k].expecteddepth < min) {
-						min = artifacts[k].expecteddepth;
+					if (artifacts[k].unk04 < min) {
+						min = artifacts[k].unk04;
 					}
 				}
 
-				/**
-				 * Define a depth tolerance from the min & max
-				 * depths of sub-artifacts for a given light.
-				 * This will be used to determine which light
-				 * artifacts are visible when comparing depth
-				 * values of lights to other items rendered
-				 * on screen. Without this, the lights would
-				 * constantly flicker due to z-fighting caused
-				 * by the low precision of the N64 depth.
-				 */
-				tolerance = (max - min) >> 1;
+				avg = (max - min) >> 1;
 
-				if (tolerance < 25) {
-					tolerance = 25;
+				if (avg < 25) {
+					avg = 25;
 				}
 
 				for (k = i; k < i + count; k++) {
 #ifdef PLATFORM_N64
-					u16 expecteddepth;
-					actualdepth = (artifacts[k].actualdepth & 0xfffc) >> 2;
-					expecteddepth = artifacts[k].expecteddepth;
+					u16 tmp;
+					t4 = (artifacts[k].unk02 & 0xfffc) >> 2;
+					tmp = artifacts[k].unk04;
 
-					if (expecteddepth < actualdepth) {
-						difference = actualdepth - expecteddepth;
+					if (tmp < t4) {
+						v1 = t4 - tmp;
 					} else {
-						difference = expecteddepth - actualdepth;
+						v1 = tmp - t4;
 					}
 
-					if (difference <= tolerance) {
-						numgood++;
+					if (avg >= v1) {
+						t2++;
 					}
 #else
-					numgood += artifacts[k].visiblelos;
+					t2 += artifacts[k].unk02;
 #endif
 
 					artifacts[k].type = ARTIFACTTYPE_FREE;
 				}
 
-				s3[0] = artifactsClamp(s3[0], numgood * 2);
+				s3[0] = func0f13d3c4(s3[0], t2 * 2);
 
-				if (numgood > 0) {
-#ifndef PLATFORM_N64
-					brightness = viGetFovY() / pfov;
-#else
+				if (t2 > 0) {
 					brightness = viGetFovY() * 0.017453292f;
-#endif
 					add = cosf(brightness) / sinf(brightness) * 14.6f;
 
 					if (lightIsHealthy(roomnum, lightindex - g_Rooms[roomnum].gfxdata->lightsindex)) {
@@ -667,9 +545,6 @@ Gfx *artifactsRenderGlaresForRoom(Gfx *gdl, s32 roomnum)
 					}
 
 					f0 = s3[2] * (1.0f / 255.0f);
-#ifndef PLATFORM_N64
-					f0 *= (60.f / pfov);
-#endif
 
 					skySetOverexposure((s32) ((f32)f0 * r), (s32) ((f32)f0 * g), (s32) ((f32)f0 * b));
 
@@ -719,10 +594,6 @@ Gfx *artifactsRenderGlaresForRoom(Gfx *gdl, s32 roomnum)
 						alpha *= (s3[1] / 255.0f);
 						alpha *= (s3[0] / 8.0f);
 
-#ifndef PLATFORM_N64
-						alpha *= brightscale;
-#endif
-
 						if (USINGDEVICE(DEVICE_NIGHTVISION)) {
 							alpha *= lightop_cur_frac * 7.0f;
 						}

src/game/invreset.c

@@ -12,15 +12,11 @@ void invReset(void)
 {
 	s32 i;
 
-#ifndef PLATFORM_N64
-	g_Vars.currentplayer->equipallguns = cheatIsActive(CHEAT_ALLGUNS);
-#else
 	if (PLAYERCOUNT() == 1 && g_Vars.normmplayerisrunning == false) {
 		g_Vars.currentplayer->equipallguns = cheatIsActive(CHEAT_ALLGUNS);
 	} else {
 		g_Vars.currentplayer->equipallguns = false;
 	}
-#endif
 
 	for (i = 0; i != ARRAYCOUNT(g_Vars.currentplayer->gunheldarr); i++) {
 		g_Vars.currentplayer->gunheldarr[i].totaltime240_60 = -1;

src/game/lv.c

@@ -28,7 +28,7 @@
 #include "game/portal.h"
 #include "game/fmb.h"
 #include "game/sky.h"
-#include "game/artifact.h"
+#include "game/game_13c510.h"
 #include "game/game_1531a0.h"
 #include "game/zbuf.h"
 #include "game/challenge.h"
@@ -97,6 +97,7 @@
 #include "lib/vi.h"
 #include "types.h"
 #ifndef PLATFORM_N64
+#include "debugger.h"
 #include "video.h"
 #endif
 
@@ -299,6 +300,8 @@ void lvReset(s32 stagenum)
 
 	g_MiscAudioHandle = NULL;
 
+	debuggerUpdatePropInfo(true);
+
 	musicReset();
 	modelmgrSetLvResetting(true);
 	surfaceReset();
@@ -1246,6 +1249,7 @@ Gfx *lvRender(Gfx *gdl)
 #ifndef PLATFORM_N64
 				// glares calculated earlier on PC, before prop matrices turn into garbage
 				bgCalculateGlaresForVisibleRooms();
+				debuggerUpdatePropInfo(false);
 #endif
 
 				// Calculate lookingatprop

src/game/menu.c

@@ -147,33 +147,6 @@ s32 g_MouseDimmedMode = false;
 s32 g_MouseEndDeferredSlider = false;
 #endif
 
-s32 menuAlt1Pressed(s32 playerNum)
-{
-	const s32 rshoulderKey = VK_JOY1_RSHOULDER + playerNum * INPUT_MAX_CONTROLLER_BUTTONS;
-
-	if (playerNum == 0) {
-		return inputKeyJustPressed(VK_LCTRL) || inputKeyJustPressed(rshoulderKey);
-	}
-
-	return inputKeyJustPressed(rshoulderKey);
-}
-
-s32 menuAlt2Pressed(s32 playerNum)
-{
-	const s32 lshoulderKey = VK_JOY1_LSHOULDER + playerNum * INPUT_MAX_CONTROLLER_BUTTONS;
-
-	if (playerNum == 0) {
-		return inputKeyJustPressed(VK_LALT) || inputKeyJustPressed(lshoulderKey);
-	}
-
-	return inputKeyJustPressed(lshoulderKey);
-}
-
-s32 menuAltAnyPressed(s32 playerNum)
-{
-	return menuAlt1Pressed(playerNum) || menuAlt2Pressed(playerNum);
-}
-
 void menuPlaySound(s32 menusound)
 {
 	s32 sound = -1;
@@ -1928,10 +1901,6 @@ Gfx *menuRenderModel(Gfx *gdl, struct menumodel *menumodel, s32 modeltype)
 					totalfilelen += 0x4000;
 #endif
 
-#ifndef PLATFORM_N64
-					videoFreeCachedTextures(menumodel->allocstart, menumodel->allocstart + menumodel->alloclen);
-#endif
-
 					texInitPool(&texpool, menumodel->allocstart + totalfilelen, menumodel->alloclen - totalfilelen);
 
 					menumodel->headnum = headnum;
@@ -1964,10 +1933,6 @@ Gfx *menuRenderModel(Gfx *gdl, struct menumodel *menumodel, s32 modeltype)
 					totalfilelen = ALIGN64(fileGetInflatedSize(menumodel->newparams, LOADTYPE_MODEL)) + 0x4000;
 					if (1);
 
-#ifndef PLATFORM_N64
-					videoFreeCachedTextures(menumodel->allocstart, menumodel->allocstart + menumodel->alloclen);
-#endif
-
 					texInitPool(&texpool, &menumodel->allocstart[(u32)totalfilelen], menumodel->alloclen - totalfilelen);
 
 					menumodel->headnum = -1;
@@ -3616,8 +3581,8 @@ void func0f0f820c(struct menudialogdef *dialogdef, s32 root)
 
 	g_MpPlayerNum = prevplayernum;
 
-	g_MenuData.prevmenuroot = root;
-	g_MenuData.prevmenudialog = dialogdef;
+	g_MenuData.unk008 = root;
+	g_MenuData.unk00c = dialogdef;
 }
 
 void menuSetBackground(s32 bg)
@@ -3691,7 +3656,7 @@ void menuPushRootDialog(struct menudialogdef *dialogdef, s32 root)
 	g_Menus[g_MpPlayerNum].unk820 = 1;
 
 	g_MenuData.root = root;
-	g_MenuData.prevmenuroot = -1;
+	g_MenuData.unk008 = -1;
 	g_MenuData.unk5d5_02 = false;
 
 	if (root == MENUROOT_MAINMENU
@@ -4013,13 +3978,13 @@ void menuReset(void)
 	}
 
 	g_MenuData.unk668 = -1;
-	g_MenuData.prevmenudialog = 0;
-	g_MenuData.prevmenuroot = -1;
+	g_MenuData.unk00c = 0;
+	g_MenuData.unk008 = -1;
 	g_MenuData.count = 0;
 	g_MenuData.root = 0;
 	g_MenuData.unk010 = 0;
 	g_MenuData.bg = 0;
-	g_MenuData.isdialogopen = false;
+	g_MenuData.unk5d5_06 = false;
 	g_MenuData.nextbg = 255;
 	g_MenuData.bannernum = -1;
 
@@ -4614,9 +4579,6 @@ void dialogTick(struct menudialog *dialog, struct menuinputs *inputs, u32 tickfl
 		s32 adjustment = (s32)(inputs->yaxis * g_Vars.diffframe60freal / 20) - (s32)(inputs->updownheld * g_Vars.diffframe60freal);
 #else
 		s32 adjustment = inputs->yaxis * g_Vars.diffframe60 / 20 - inputs->updownheld * g_Vars.diffframe60;
-#endif
-#ifndef PLATFORM_N64
-		adjustment -= inputs->mousescroll * (LINEHEIGHT + 1);
 #endif
 		dialog->dstscroll += adjustment;
 

src/game/menuitem.c

@@ -1334,7 +1334,7 @@ Gfx *menuitemKeyboardRender(Gfx *gdl, struct menurendercontext *context)
 					// make the button yellow if it's active
 					if (g_MenuKeyboardPlayer == g_MpPlayerNum) {
 						textcolour = (textcolour & 0xff) | 0xffff0000;
-						kbtext = (char *)"ESC: OK";
+						kbtext = (char *)"ESC: CANCEL  ENTER: OK";
 					} else {
 						kbtext = (char *)"TYPE WITH KEYBOARD";
 					}
@@ -1531,14 +1531,6 @@ bool menuitemKeyboardTick(struct menuitem *item, struct menuinputs *inputs, u32
 
 		u8 maxlen = item->param == 0 ? 10 : item->param;
 #ifndef PLATFORM_N64
-		if (g_MenuKeyboardPlayer != g_MpPlayerNum && inputKeyJustPressed(VK_A + ('i' - 'a'))) {
-			inputClearLastKey();
-			inputClearLastTextChar();
-			g_MenuKeyboardPlayer = g_MpPlayerNum;
-			inputStartTextInput();
-			menuPlaySound(MENUSOUND_SELECT);
-		}
-
 		if (g_MenuKeyboardPlayer == g_MpPlayerNum) {
 			// match caps state to keyboard shift/caps if typing with keyboard
 			const u32 kmod = inputGetKeyModState();
@@ -1549,7 +1541,7 @@ bool menuitemKeyboardTick(struct menuitem *item, struct menuinputs *inputs, u32
 			// handle text input
 			s32 prevpos = strlen(kb->string);
 			s32 pos = prevpos;
-			s32 result = inputTextHandler(kb->string, maxlen + 1, &pos, true);
+			s32 result = inputTextHandler(kb->string, maxlen-1, &pos, true);
 			if (result == -1) {
 				// cancel
 				kb->row = 5;
@@ -3228,9 +3220,6 @@ bool menuitemScrollableTick(struct menuitem *item, struct menudialog *dialog, st
 		intval = intval + (s32)(((f32)inputs->updownheld + (f32)inputs->updownheld) * g_Vars.diffframe60freal);
 #else
 		intval += inputs->updownheld * 2 * g_Vars.diffframe60;
-#endif
-#ifndef PLATFORM_N64
-		intval += inputs->mousescroll * (LINEHEIGHT - 2) * 3;
 #endif
 		data->scrollable.scrolloffset += intval;
 
@@ -3754,9 +3743,6 @@ bool menuitemRankingTick(struct menuinputs *inputs, u32 tickflags, union menuite
 		intval = intval + (s32)(((f32)inputs->updownheld + (f32)inputs->updownheld) * g_Vars.diffframe60freal);
 #else
 		intval += inputs->updownheld * 2 * g_Vars.diffframe60;
-#endif
-#ifndef PLATFORM_N64
-		intval += inputs->mousescroll * (LINEHEIGHT - 1);
 #endif
 		data->ranking.scrolloffset += intval;
 
@@ -4052,9 +4038,6 @@ bool menuitemPlayerStatsTick(struct menuitem *item, struct menudialog *dialog, s
 		intval = intval + (s32)(((f32)inputs->updownheld + (f32)inputs->updownheld) * g_Vars.diffframe60freal);
 #else
 		intval += inputs->updownheld * 2 * g_Vars.diffframe60;
-#endif
-#ifndef PLATFORM_N64
-		intval += inputs->mousescroll * (LINEHEIGHT - 1);
 #endif
 		data->dropdown.scrolloffset += intval;
 

src/game/menutick.c

@@ -59,7 +59,7 @@ void menuTick(void)
 	s32 i;
 	s32 j;
 	s32 k;
-	s32 isdialogopen;
+	s32 sp344;
 	s32 sp340 = true;
 	s32 anyopen = false;
 
@@ -285,13 +285,7 @@ void menuTick(void)
 		var8006294c = 1;
 
 		if (g_MenuData.root == MENUROOT_MPSETUP || g_MenuData.root == MENUROOT_4MBMAINMENU) {
-			if (g_MenuData.prevmenuroot == -1) {
-#ifndef PLATFORM_N64
-				if (g_MpSetup.storedbotbits) {
-					g_MpSetup.chrslots |= g_MpSetup.storedbotbits;
-					g_MpSetup.storedbotbits = 0;
-				}
-#endif
+			if (g_MenuData.unk008 == -1) {
 				g_MpSetup.chrslots &= 0xfff0;
 			}
 
@@ -301,7 +295,7 @@ void menuTick(void)
 				if (g_Menus[i].curdialog) {
 					g_Menus[i].playernum = g_MpNumJoined++;
 
-					if (g_MenuData.prevmenuroot == -1) {
+					if (g_MenuData.unk008 == -1) {
 						g_MpSetup.chrslots |= (1 << i);
 					}
 				}
@@ -491,31 +485,31 @@ void menuTick(void)
 	}
 
 	g_MpPlayerNum = 0;
-	isdialogopen = false;
+	sp344 = false;
 
 	for (i = 0; i < ARRAYCOUNT(g_Menus); i++) {
 		if (g_Menus[i].curdialog) {
-			isdialogopen = true;
+			sp344 = true;
 		}
 	}
 
-	if ((g_MenuData.isdialogopen || g_MenuData.prevmenuroot != -1) && isdialogopen == false) {
+	if ((g_MenuData.unk5d5_06 || g_MenuData.unk008 != -1) && sp344 == false) {
 		if ((g_MenuData.root == MENUROOT_MPSETUP || g_MenuData.root == MENUROOT_4MBMAINMENU)
-				&& g_MenuData.prevmenuroot == -1) {
+				&& g_MenuData.unk008 == -1) {
 			if (g_Vars.mpsetupmenu == MPSETUPMENU_GENERAL) {
-				g_MenuData.prevmenuroot = MENUROOT_MAINMENU;
-				g_MenuData.prevmenudialog = IS4MB() ? &g_CiMenuViaPauseMenuDialog : &g_CiMenuViaPcMenuDialog;
+				g_MenuData.unk008 = MENUROOT_MAINMENU;
+				g_MenuData.unk00c = IS4MB() ? &g_CiMenuViaPauseMenuDialog : &g_CiMenuViaPcMenuDialog;
 			} else if (IS4MB()) {
-				g_MenuData.prevmenuroot = MENUROOT_4MBMAINMENU;
-				g_MenuData.prevmenudialog = &g_MainMenu4MbMenuDialog;
+				g_MenuData.unk008 = MENUROOT_4MBMAINMENU;
+				g_MenuData.unk00c = &g_MainMenu4MbMenuDialog;
 			} else {
-				g_MenuData.prevmenuroot = MENUROOT_MPSETUP;
-				g_MenuData.prevmenudialog = &g_CombatSimulatorMenuDialog;
+				g_MenuData.unk008 = MENUROOT_MPSETUP;
+				g_MenuData.unk00c = &g_CombatSimulatorMenuDialog;
 			}
 		}
 
-		if (g_MenuData.prevmenuroot != -1) {
-			if (g_MenuData.prevmenuroot == -5) {
+		if (g_MenuData.unk008 != -1) {
+			if (g_MenuData.unk008 == -5) {
 				// Match is beginning
 				mpStartMatch();
 				menuStop();
@@ -524,7 +518,7 @@ void menuTick(void)
 					bossfileSave();
 					g_Vars.modifiedfiles &= ~MODFILE_MPSETUP;
 				}
-			} else if (g_MenuData.prevmenuroot == -6) {
+			} else if (g_MenuData.unk008 == -6) {
 				// Match is ending
 				s32 playernum = 0;
 
@@ -547,17 +541,17 @@ void menuTick(void)
 								setCurrentPlayerNum(playernum);
 								endscreenPushCoop();
 								setCurrentPlayerNum(prevplayernum);
-								isdialogopen = true;
+								sp344 = true;
 							}
 						} else if (g_Vars.antiplayernum >= 0) {
 							s32 prevplayernum = g_Vars.currentplayernum;
 							setCurrentPlayerNum(playernum);
 							endscreenPushAnti();
 							setCurrentPlayerNum(prevplayernum);
-							isdialogopen = true;
+							sp344 = true;
 						} else {
 							mpPushEndscreenDialog(playernum, i);
-							isdialogopen = true;
+							sp344 = true;
 
 							if (g_PlayerConfigsArray[i].fileguid.fileid && g_PlayerConfigsArray[i].fileguid.deviceserial) {
 								func0f0fd548(i);
@@ -567,7 +561,7 @@ void menuTick(void)
 						playernum++;
 					}
 				}
-			} else if (g_MenuData.prevmenuroot == -7) {
+			} else if (g_MenuData.unk008 == -7) {
 				menuStop();
 				g_FileState = FILESTATE_CHANGINGAGENT;
 				gamefileLoadDefaults(&g_GameFile);
@@ -576,8 +570,8 @@ void menuTick(void)
 				musicQueueStopAllEvent();
 			} else {
 				bool startmusic = false;
-				menuPushRootDialog(g_MenuData.prevmenudialog, g_MenuData.prevmenuroot);
-				isdialogopen = true;
+				menuPushRootDialog(g_MenuData.unk00c, g_MenuData.unk008);
+				sp344 = true;
 
 				if (g_MenuData.root == MENUROOT_MPSETUP || g_MenuData.root == MENUROOT_4MBMAINMENU) {
 					startmusic = true;
@@ -603,8 +597,8 @@ void menuTick(void)
 				}
 			}
 
-			g_MenuData.prevmenudialog = NULL;
-			g_MenuData.prevmenuroot = -1;
+			g_MenuData.unk00c = NULL;
+			g_MenuData.unk008 = -1;
 		} else {
 			switch (g_MenuData.root) {
 			case MENUROOT_ENDSCREEN:
@@ -756,5 +750,5 @@ void menuTick(void)
 	}
 
 	g_ScaleX = 1;
-	g_MenuData.isdialogopen = isdialogopen ? true : false;
+	g_MenuData.unk5d5_06 = sp344 ? true : false;
 }

src/game/mplayer/mplayer.c

@@ -139,7 +139,6 @@ struct mpweapon g_MpWeapons[NUM_MPWEAPONS] = {
 	.extcontrols = true, \
 	.crosshaircolour = 0x00ff0028, \
 	.crosshairsize = 2, \
-	.crosshairedgeboundary = 0.7f, \
 	.crosshairhealth = CROSSHAIR_HEALTH_OFF, \
 	.usereloads = false, \
 }
@@ -601,7 +600,7 @@ void mpInit(bool resetplayers)
 	g_MpSetup.chrslots = 0;
 
 	for (i = 0; i < ARRAYCOUNT(g_Menus); i++) {
-		g_Menus[i].mpsetupext.showpresets = 1;
+		g_Menus[i].mpsetup.showpresets = 1;
 	}
 
 #ifndef PLATFORM_N64

src/game/mplayer/scenarios/capturethecase.inc

@@ -11,8 +11,6 @@
  * Players cannot score unless their briefcase is at the home base.
  */
 
-extern struct menudialogdef g_ExtGameOptionsMenuDialog;
-
 struct menuitem g_CtcOptionsMenuItems[] = {
 	{
 		MENUITEMTYPE_CHECKBOX,
@@ -62,6 +60,40 @@ struct menuitem g_CtcOptionsMenuItems[] = {
 		MPOPTION_NOAUTOAIM,
 		menuhandlerMpCheckboxOption,
 	},
+#ifndef PLATFORM_N64
+	{
+		MENUITEMTYPE_CHECKBOX,
+		0,
+		MENUITEMFLAG_LOCKABLEMINOR | MENUITEMFLAG_LITERAL_TEXT,
+		(uintptr_t)"Start Armed",
+		MPOPTION_SPAWNWITHWEAPON,
+		menuhandlerMpCheckboxOption,
+	},
+	{
+		MENUITEMTYPE_CHECKBOX,
+		0,
+		MENUITEMFLAG_LOCKABLEMINOR | MENUITEMFLAG_LITERAL_TEXT,
+		(uintptr_t)"No Drug Blur",
+		MPOPTION_NODRUGBLUR,
+		menuhandlerMpCheckboxOption,
+	},
+	{
+		MENUITEMTYPE_CHECKBOX,
+		0,
+		MENUITEMFLAG_LOCKABLEMINOR,
+		L_OPTIONS_257, // "Friendly Fire"
+		MPOPTION_FRIENDLYFIRE,
+		menuhandlerMpDisplayTeam,
+	},
+	{
+		MENUITEMTYPE_CHECKBOX,
+		0,
+		MENUITEMFLAG_LOCKABLEMINOR | MENUITEMFLAG_LITERAL_TEXT,
+		(uintptr_t)"No Player on Radar",
+		MPOPTION_NOPLAYERONRADAR,
+		menuhandlerMpCheckboxOption,
+	},
+#endif
 	{
 		MENUITEMTYPE_CHECKBOX,
 		0,
@@ -111,8 +143,7 @@ struct menudialogdef g_CtcOptionsMenuDialog = {
 	g_CtcOptionsMenuItems,
 	mpOptionsMenuDialog,
 	MENUDIALOGFLAG_MPLOCKABLE,
-	&g_ExtGameOptionsMenuDialog,
-//	NULL,
+	NULL,
 };
 
 struct weaponobj g_CtcTokenObj0;

src/game/mplayer/scenarios/combat.inc

@@ -6,8 +6,6 @@
  * There are no callback functions or special logic.
  */
 
-extern struct menudialogdef g_ExtGameOptionsMenuDialog;
-
 struct menuitem g_MpCombatOptionsMenuItems[] = {
 	{
 		MENUITEMTYPE_CHECKBOX,
@@ -57,6 +55,40 @@ struct menuitem g_MpCombatOptionsMenuItems[] = {
 		MPOPTION_NOAUTOAIM,
 		menuhandlerMpCheckboxOption,
 	},
+#ifndef PLATFORM_N64
+	{
+		MENUITEMTYPE_CHECKBOX,
+		0,
+		MENUITEMFLAG_LOCKABLEMINOR | MENUITEMFLAG_LITERAL_TEXT,
+		(uintptr_t)"Start Armed",
+		MPOPTION_SPAWNWITHWEAPON,
+		menuhandlerMpCheckboxOption,
+	},
+	{
+		MENUITEMTYPE_CHECKBOX,
+		0,
+		MENUITEMFLAG_LOCKABLEMINOR | MENUITEMFLAG_LITERAL_TEXT,
+		(uintptr_t)"No Drug Blur",
+		MPOPTION_NODRUGBLUR,
+		menuhandlerMpCheckboxOption,
+	},
+	{
+		MENUITEMTYPE_CHECKBOX,
+		0,
+		MENUITEMFLAG_LOCKABLEMINOR,
+		L_OPTIONS_257, // "Friendly Fire"
+		MPOPTION_FRIENDLYFIRE,
+		menuhandlerMpDisplayTeam,
+	},
+	{
+		MENUITEMTYPE_CHECKBOX,
+		0,
+		MENUITEMFLAG_LOCKABLEMINOR | MENUITEMFLAG_LITERAL_TEXT,
+		(uintptr_t)"No Player on Radar",
+		MPOPTION_NOPLAYERONRADAR,
+		menuhandlerMpCheckboxOption,
+	},
+#endif
 	{
 		MENUITEMTYPE_SEPARATOR,
 		0,
@@ -106,5 +138,5 @@ struct menudialogdef g_MpCombatOptionsMenuDialog = {
 	g_MpCombatOptionsMenuItems,
 	mpOptionsMenuDialog,
 	MENUDIALOGFLAG_MPLOCKABLE,
-	&g_ExtGameOptionsMenuDialog,
+	NULL,
 };

src/game/mplayer/scenarios/hackthatmac.inc

@@ -7,8 +7,6 @@
  * cannot use weapons while uplinking.
  */
 
-extern struct menudialogdef g_ExtGameOptionsMenuDialog;
-
 #define HTM_NUM_TERMINALS 1
 
 struct menuitem g_HtmOptionsMenuItems[] = {
@@ -60,6 +58,40 @@ struct menuitem g_HtmOptionsMenuItems[] = {
 		MPOPTION_NOAUTOAIM,
 		menuhandlerMpCheckboxOption,
 	},
+#ifndef PLATFORM_N64
+	{
+		MENUITEMTYPE_CHECKBOX,
+		0,
+		MENUITEMFLAG_LOCKABLEMINOR | MENUITEMFLAG_LITERAL_TEXT,
+		(uintptr_t)"Start Armed",
+		MPOPTION_SPAWNWITHWEAPON,
+		menuhandlerMpCheckboxOption,
+	},
+	{
+		MENUITEMTYPE_CHECKBOX,
+		0,
+		MENUITEMFLAG_LOCKABLEMINOR | MENUITEMFLAG_LITERAL_TEXT,
+		(uintptr_t)"No Drug Blur",
+		MPOPTION_NODRUGBLUR,
+		menuhandlerMpCheckboxOption,
+	},
+	{
+		MENUITEMTYPE_CHECKBOX,
+		0,
+		MENUITEMFLAG_LOCKABLEMINOR,
+		L_OPTIONS_257, // "Friendly Fire"
+		MPOPTION_FRIENDLYFIRE,
+		menuhandlerMpDisplayTeam,
+	},
+	{
+		MENUITEMTYPE_CHECKBOX,
+		0,
+		MENUITEMFLAG_LOCKABLEMINOR | MENUITEMFLAG_LITERAL_TEXT,
+		(uintptr_t)"No Player on Radar",
+		MPOPTION_NOPLAYERONRADAR,
+		menuhandlerMpCheckboxOption,
+	},
+#endif
 	{
 		MENUITEMTYPE_CHECKBOX,
 		0,
@@ -117,7 +149,7 @@ struct menudialogdef g_HtmOptionsMenuDialog = {
 	g_HtmOptionsMenuItems,
 	mpOptionsMenuDialog,
 	MENUDIALOGFLAG_MPLOCKABLE,
-	&g_ExtGameOptionsMenuDialog,
+	NULL,
 };
 
 struct weaponobj g_HtmUplinkObj;

src/game/mplayer/scenarios/holdthebriefcase.inc

@@ -9,8 +9,6 @@
  * slightly slower but still have full access to their weaponry.
  */
 
-extern struct menudialogdef g_ExtGameOptionsMenuDialog;
-
 struct menuitem g_HtbOptionsMenuItems[] = {
 	{
 		MENUITEMTYPE_CHECKBOX,
@@ -60,6 +58,40 @@ struct menuitem g_HtbOptionsMenuItems[] = {
 		MPOPTION_NOAUTOAIM,
 		menuhandlerMpCheckboxOption,
 	},
+#ifndef PLATFORM_N64
+	{
+		MENUITEMTYPE_CHECKBOX,
+		0,
+		MENUITEMFLAG_LOCKABLEMINOR | MENUITEMFLAG_LITERAL_TEXT,
+		(uintptr_t)"Start Armed",
+		MPOPTION_SPAWNWITHWEAPON,
+		menuhandlerMpCheckboxOption,
+	},
+	{
+		MENUITEMTYPE_CHECKBOX,
+		0,
+		MENUITEMFLAG_LOCKABLEMINOR | MENUITEMFLAG_LITERAL_TEXT,
+		(uintptr_t)"No Drug Blur",
+		MPOPTION_NODRUGBLUR,
+		menuhandlerMpCheckboxOption,
+	},
+	{
+		MENUITEMTYPE_CHECKBOX,
+		0,
+		MENUITEMFLAG_LOCKABLEMINOR,
+		L_OPTIONS_257, // "Friendly Fire"
+		MPOPTION_FRIENDLYFIRE,
+		menuhandlerMpDisplayTeam,
+	},
+	{
+		MENUITEMTYPE_CHECKBOX,
+		0,
+		MENUITEMFLAG_LOCKABLEMINOR | MENUITEMFLAG_LITERAL_TEXT,
+		(uintptr_t)"No Player on Radar",
+		MPOPTION_NOPLAYERONRADAR,
+		menuhandlerMpCheckboxOption,
+	},
+#endif
 	{
 		MENUITEMTYPE_CHECKBOX,
 		0,
@@ -117,7 +149,7 @@ struct menudialogdef g_HtbOptionsMenuDialog = {
 	g_HtbOptionsMenuItems,
 	mpOptionsMenuDialog,
 	MENUDIALOGFLAG_MPLOCKABLE,
-	&g_ExtGameOptionsMenuDialog,
+	NULL,
 };
 
 struct defaultobj *var800869ec = NULL;

src/game/mplayer/scenarios/kingofthehill.inc

@@ -13,8 +13,6 @@
  * Points are awarded to each player in the hill at the time that it is won.
  */
 
-extern struct menudialogdef g_ExtGameOptionsMenuDialog;
-
 MenuItemHandlerResult menuhandlerMpHillTime(s32 operation, struct menuitem *item, union handlerdata *data)
 {
 	switch (operation) {
@@ -81,6 +79,40 @@ struct menuitem g_KohOptionsMenuItems[] = {
 		MPOPTION_NOAUTOAIM,
 		menuhandlerMpCheckboxOption,
 	},
+#ifndef PLATFORM_N64
+	{
+		MENUITEMTYPE_CHECKBOX,
+		0,
+		MENUITEMFLAG_LOCKABLEMINOR | MENUITEMFLAG_LITERAL_TEXT,
+		(uintptr_t)"Start Armed",
+		MPOPTION_SPAWNWITHWEAPON,
+		menuhandlerMpCheckboxOption,
+	},
+	{
+		MENUITEMTYPE_CHECKBOX,
+		0,
+		MENUITEMFLAG_LOCKABLEMINOR | MENUITEMFLAG_LITERAL_TEXT,
+		(uintptr_t)"No Drug Blur",
+		MPOPTION_NODRUGBLUR,
+		menuhandlerMpCheckboxOption,
+	},
+	{
+		MENUITEMTYPE_CHECKBOX,
+		0,
+		MENUITEMFLAG_LOCKABLEMINOR,
+		L_OPTIONS_257, // "Friendly Fire"
+		MPOPTION_FRIENDLYFIRE,
+		menuhandlerMpDisplayTeam,
+	},
+	{
+		MENUITEMTYPE_CHECKBOX,
+		0,
+		MENUITEMFLAG_LOCKABLEMINOR | MENUITEMFLAG_LITERAL_TEXT,
+		(uintptr_t)"No Player on Radar",
+		MPOPTION_NOPLAYERONRADAR,
+		menuhandlerMpCheckboxOption,
+	},
+#endif
 	{
 		MENUITEMTYPE_CHECKBOX,
 		0,
@@ -146,7 +178,7 @@ struct menudialogdef g_KohOptionsMenuDialog = {
 	g_KohOptionsMenuItems,
 	mpOptionsMenuDialog,
 	MENUDIALOGFLAG_MPLOCKABLE,
-	&g_ExtGameOptionsMenuDialog,
+	NULL,
 };
 
 void kohReadSave(struct savebuffer *buffer, u8 version)

src/game/mplayer/scenarios/popacap.inc

@@ -7,8 +7,6 @@
  * chosen as the victim.
  */
 
-extern struct menudialogdef g_ExtGameOptionsMenuDialog;
-
 struct menuitem g_PacOptionsMenuItems[] = {
 	{
 		MENUITEMTYPE_CHECKBOX,
@@ -58,6 +56,40 @@ struct menuitem g_PacOptionsMenuItems[] = {
 		MPOPTION_NOAUTOAIM,
 		menuhandlerMpCheckboxOption,
 	},
+#ifndef PLATFORM_N64
+	{
+		MENUITEMTYPE_CHECKBOX,
+		0,
+		MENUITEMFLAG_LOCKABLEMINOR | MENUITEMFLAG_LITERAL_TEXT,
+		(uintptr_t)"Start Armed",
+		MPOPTION_SPAWNWITHWEAPON,
+		menuhandlerMpCheckboxOption,
+	},
+	{
+		MENUITEMTYPE_CHECKBOX,
+		0,
+		MENUITEMFLAG_LOCKABLEMINOR | MENUITEMFLAG_LITERAL_TEXT,
+		(uintptr_t)"No Drug Blur",
+		MPOPTION_NODRUGBLUR,
+		menuhandlerMpCheckboxOption,
+	},
+	{
+		MENUITEMTYPE_CHECKBOX,
+		0,
+		MENUITEMFLAG_LOCKABLEMINOR,
+		L_OPTIONS_257, // "Friendly Fire"
+		MPOPTION_FRIENDLYFIRE,
+		menuhandlerMpDisplayTeam,
+	},
+	{
+		MENUITEMTYPE_CHECKBOX,
+		0,
+		MENUITEMFLAG_LOCKABLEMINOR | MENUITEMFLAG_LITERAL_TEXT,
+		(uintptr_t)"No Player on Radar",
+		MPOPTION_NOPLAYERONRADAR,
+		menuhandlerMpCheckboxOption,
+	},
+#endif
 	{
 		MENUITEMTYPE_CHECKBOX,
 		0,
@@ -115,7 +147,7 @@ struct menudialogdef g_PacOptionsMenuDialog = {
 	g_PacOptionsMenuItems,
 	mpOptionsMenuDialog,
 	MENUDIALOGFLAG_MPLOCKABLE,
-	&g_ExtGameOptionsMenuDialog,
+	NULL,
 };
 
 void pacReset(void)

src/game/mplayer/setup.c

@@ -43,6 +43,33 @@ extern struct menudialogdef g_FilemgrErrorMenuDialog;
 extern s32 g_MpWeaponSetNum;
 #endif
 
+static inline s32 menuAlt1Pressed(s32 playerNum)
+{
+	const s32 rshoulderKey = VK_JOY1_RSHOULDER + playerNum * INPUT_MAX_CONTROLLER_BUTTONS;
+
+	if (playerNum == 0) {
+		return inputKeyJustPressed(VK_LCTRL) || inputKeyJustPressed(rshoulderKey);
+	}
+
+	return inputKeyJustPressed(rshoulderKey);
+}
+
+static inline s32 menuAlt2Pressed(s32 playerNum)
+{
+	const s32 lshoulderKey = VK_JOY1_LSHOULDER + playerNum * INPUT_MAX_CONTROLLER_BUTTONS;
+
+	if (playerNum == 0) {
+		return inputKeyJustPressed(VK_LALT) || inputKeyJustPressed(lshoulderKey);
+	}
+
+	return inputKeyJustPressed(lshoulderKey);
+}
+
+static inline s32 menuAltPressed(s32 playerNum)
+{
+	return menuAlt1Pressed(playerNum) || menuAlt2Pressed(playerNum);
+}
+
 MenuItemHandlerResult menuhandlerMpDropOut(s32 operation, struct menuitem *item, union handlerdata *data)
 {
 	if (operation == MENUOP_SET) {
@@ -2258,7 +2285,7 @@ MenuItemHandlerResult mpPlayerNameMenuHandler(s32 operation, struct menuitem *it
 
 MenuItemHandlerResult mpLoadSettingsMenuHandler(s32 operation, struct menuitem *item, union handlerdata *data)
 {
-	u8 presets = g_Menus[g_MpPlayerNum].mpsetupext.showpresets;
+	u8 presets = g_Menus[g_MpPlayerNum].mpsetup.showpresets;
 	s32 numpresets = mpGetNumUnlockedPresets()*presets;
 
 	switch (operation) {
@@ -2567,9 +2594,9 @@ MenuDialogHandlerResult menudialogMpSimulant(s32 operation, struct menudialogdef
 MenuDialogHandlerResult mpLoadSettingsDialogHandler(s32 operation, struct menudialogdef *dialogdef, union handlerdata *data)
 {
 	if (operation == MENUOP_TICK) {
-		if (menuAltAnyPressed(g_MpPlayerNum)) {
-			u8 presets = g_Menus[g_MpPlayerNum].mpsetupext.showpresets;
-			g_Menus[g_MpPlayerNum].mpsetupext.showpresets = 1 - presets;
+		if (menuAltPressed(g_MpPlayerNum)) {
+			u8 presets = g_Menus[g_MpPlayerNum].mpsetup.showpresets;
+			g_Menus[g_MpPlayerNum].mpsetup.showpresets = 1 - presets;
 		}
 	}
 }
@@ -5394,6 +5421,10 @@ MenuDialogHandlerResult menudialogCombatSimulator(s32 operation, struct menudial
 		g_Vars.waitingtojoin[1] = false;
 		g_Vars.waitingtojoin[2] = false;
 		g_Vars.waitingtojoin[3] = false;
+
+		// load the setup file when entering the Combat Simulator
+		mpsetupCopyAllFromPak();
+		mpsetupLoadCurrentFile();
 	}
 
 	if (g_Menus[g_MpPlayerNum].curdialog
@@ -6155,56 +6186,3 @@ void func0f17fcb0(s32 silent)
 		sndStart(var80095200, SFX_EXPLOSION_809A, NULL, -1, -1, -1, -1, -1);
 	}
 }
-
-struct menuitem g_MpExtGameOptionsMenuItems[] = {
-	{
-		MENUITEMTYPE_CHECKBOX,
-		0,
-		MENUITEMFLAG_LOCKABLEMINOR | MENUITEMFLAG_LITERAL_TEXT,
-		(uintptr_t)"Start Armed",
-		MPOPTION_SPAWNWITHWEAPON,
-		menuhandlerMpCheckboxOption,
-	},
-	{
-		MENUITEMTYPE_CHECKBOX,
-		0,
-		MENUITEMFLAG_LOCKABLEMINOR | MENUITEMFLAG_LITERAL_TEXT,
-		(uintptr_t)"No Drug Blur",
-		MPOPTION_NODRUGBLUR,
-		menuhandlerMpCheckboxOption,
-	},
-	{
-		MENUITEMTYPE_CHECKBOX,
-		0,
-		MENUITEMFLAG_LOCKABLEMINOR,
-		L_OPTIONS_257, // "Friendly Fire"
-		MPOPTION_FRIENDLYFIRE,
-		menuhandlerMpDisplayTeam,
-	},
-	{
-		MENUITEMTYPE_CHECKBOX,
-		0,
-		MENUITEMFLAG_LOCKABLEMINOR | MENUITEMFLAG_LITERAL_TEXT,
-		(uintptr_t)"No Player on Radar",
-		MPOPTION_NOPLAYERONRADAR,
-		menuhandlerMpCheckboxOption,
-	},
-	{
-		MENUITEMTYPE_CHECKBOX,
-		0,
-		MENUITEMFLAG_LOCKABLEMINOR | MENUITEMFLAG_LITERAL_TEXT,
-		(uintptr_t)"No Doors",
-		MPOPTION_NODOORS,
-		menuhandlerMpCheckboxOption,
-	},
-	{ MENUITEMTYPE_END },
-};
-
-struct menudialogdef g_ExtGameOptionsMenuDialog = {
-	MENUDIALOGTYPE_DEFAULT,
-	(uintptr_t) "More Options\n",
-	g_MpExtGameOptionsMenuItems,
-	NULL,
-	MENUDIALOGFLAG_LITERAL_TEXT,
-	NULL,
-};

src/game/pak.c

@@ -859,11 +859,6 @@ PakErr2 pakReadHeaderAtOffset(s8 device, u32 offset, struct pakfileheader *heade
 		return PAK_ERR2_BADOFFSET;
 	}
 
-	if (offset > g_Paks[device].pdnumbytes - sizeof(sp38)) {
-		// not enough bytes left for a header
-		return PAK_ERR2_BADOFFSET;
-	}
-
 	if (!pakRetrieveHeaderFromCache(device, blocknum, headerptr)) {
 		result = pakReadWriteBlock(device, PFS(device), g_Paks[device].pdnoteindex, 0, offset, sizeof(sp38), sp38);
 

src/game/player.c

@@ -71,9 +71,10 @@
 #include "data.h"
 #include "types.h"
 #ifndef PLATFORM_N64
+#include "platform.h"
 #include "video.h"
 #include "input.h"
-#include "platform.h"
+#include "debugger.h"
 #endif
 
 s32 g_DefaultWeapons[2];
@@ -1114,8 +1115,7 @@ void playerSpawn(void)
 				invGiveSingleWeapon(WEAPON_NIGHTVISION);
 			}
 
-			if (g_Vars.normmplayerisrunning
-					&& (g_MpSetup.options & MPOPTION_SPAWNWITHWEAPON)
+			if ((g_MpSetup.options & MPOPTION_SPAWNWITHWEAPON)
 					&& g_MpSetup.weapons[0] != MPWEAPON_NONE
 					&& g_MpSetup.weapons[0] != MPWEAPON_DISABLED
 					&& g_MpSetup.weapons[0] != MPWEAPON_SHIELD) {

src/game/prop.c

@@ -983,7 +983,7 @@ struct prop *shotCalculateHits(s32 handnum, bool isshooting, struct coord *gunpo
 bool shotTestLos(struct coord *gunpos2d, struct coord *gundir2d, struct coord *gunpos3d, struct coord *gundir3d, struct coord *endpos3d)
 {
 	struct prop **propptr;
-	struct hitthing hitthing;
+	struct hitthing sp664;
 	struct coord delta;
 	struct shotdata shotdata;
 	s32 i;
@@ -992,8 +992,6 @@ bool shotTestLos(struct coord *gunpos2d, struct coord *gundir2d, struct coord *g
 	RoomNum spb8[8];
 	RoomNum *roomsptr;
 	struct prop *prop;
-	s16 texturenum;
-	u32 surfacetype;
 
 	shotdata.gunpos3d.x = gunpos3d->x;
 	shotdata.gunpos3d.y = gunpos3d->y;
@@ -1042,11 +1040,11 @@ bool shotTestLos(struct coord *gunpos2d, struct coord *gundir2d, struct coord *g
 
 	// Check for BG hits first
 	for (i = 0; rooms[i] != -1; i++) {
-		if (bgTestHitInRoom(&shotdata.gunpos3d, endpos3d, rooms[i], &hitthing)) {
+		if (bgTestHitInRoom(&shotdata.gunpos3d, endpos3d, rooms[i], &sp664)) {
 			// check if it's far enough away from the end point
-			if (fabsf(hitthing.pos.x - endpos3d->x) >= 0.1f ||
-					fabsf(hitthing.pos.y - endpos3d->y) >= 0.1f ||
-					fabsf(hitthing.pos.z - endpos3d->z) >= 0.1f) {
+			if (fabsf(sp664.pos.x - endpos3d->x) >= 0.1f ||
+					fabsf(sp664.pos.y - endpos3d->y) >= 0.1f ||
+					fabsf(sp664.pos.z - endpos3d->z) >= 0.1f) {
 				return false;
 			}
 		}
@@ -1064,22 +1062,17 @@ bool shotTestLos(struct coord *gunpos2d, struct coord *gundir2d, struct coord *g
 		prop = *propptr;
 		if (prop) {
 			if (prop->type == PROPTYPE_CHR
-					|| (prop->type == PROPTYPE_PLAYER && prop->chr && (g_Vars.in_cutscene || playermgrGetPlayerNumByProp(prop) != g_Vars.currentplayernum
-						|| g_Vars.currentplayer->eyespy && g_Vars.currentplayer->eyespy->mode == EYESPYMODE_CAMSPY))) {
+					|| (prop->type == PROPTYPE_PLAYER && prop->chr && (g_Vars.in_cutscene || playermgrGetPlayerNumByProp(prop) != g_Vars.currentplayernum))) {
 				chrTestHit(prop, &shotdata, false, true);
-			} else if (prop->type == PROPTYPE_WEAPON || (prop->type == PROPTYPE_DOOR && ((struct doorobj *)prop->obj)->doortype != DOORTYPE_LASER)
+			} else if (prop->type == PROPTYPE_WEAPON || prop->type == PROPTYPE_DOOR
 					|| (prop->type == PROPTYPE_OBJ && prop->obj->type != OBJTYPE_GLASS && prop->obj->type != OBJTYPE_TINTEDGLASS)) {
 				objTestHit(prop, &shotdata);
 			}
 			if (shotdata.hits[0].prop) {
-				texturenum = (prop->type == PROPTYPE_CHR || prop->type == PROPTYPE_PLAYER) ? -1 : shotdata.hits[0].hitthing.texturenum;
-				surfacetype = (texturenum >= 0 && texturenum < NUM_TEXTURES) ? g_Textures[texturenum].surfacetype : SURFACETYPE_DEFAULT;
 				// ignore some glass parts and shields
-				if (shotdata.hits[0].slowsbullet && texturenum != 10000 &&
-				    surfacetype != SURFACETYPE_GLASS && surfacetype != SURFACETYPE_GLASSXLU) {
+				if (shotdata.hits[0].slowsbullet && shotdata.hits[0].hitthing.texturenum != 10000) {
 					return false;
 				}
-				shotdata.hits[0].prop = NULL;
 			}
 		}
 		propptr--;

src/game/propobj.c

@@ -77,6 +77,10 @@
 #include "textures.h"
 #include "types.h"
 #include "string.h"
+#ifndef PLATFORM_N64
+#include "system.h"
+#include "debugger.h"
+#endif
 
 void rng2SetSeed(u32 seed);
 
@@ -6703,6 +6707,10 @@ s32 projectileTick(struct defaultobj *obj, bool *embedded)
 						|| prop->pos.y < -20000.0f || prop->pos.y > 32000.0f
 						|| prop->pos.x < -32000.0f || prop->pos.x > 32000.0f
 						|| prop->pos.z < -32000.0f || prop->pos.z > 32000.0f) {
+					if (g_DebuggerActive) {
+						sysLogPrintf(LOG_WARNING, "DBG: prop %p (%02x) obj %p (%02x) at (%.2f, %.2f, %.2f) expired",
+							prop, prop->type, obj, obj->type, prop->pos.x, prop->pos.y, prop->pos.z);
+					}
 					obj->hidden |= OBJHFLAG_DELETING;
 				}
 
@@ -10885,6 +10893,16 @@ u32 objTick(struct prop *prop)
 	u32 padnum;
 	struct defaultobj *newparent;
 
+	if (g_DebuggerActive) {
+		if (obj->type != OBJTYPE_HOVERCAR && prop->pos.y <= -20000.f) {
+			if ((obj->hidden & OBJHFLAG_FALLOUT) == 0) {
+				sysLogPrintf(LOG_WARNING, "DBG: prop %p (%02x) obj %p (%02x) at (%.2f, %.2f, %.2f) fell out of world",
+					prop, prop->type, obj, obj->type, prop->pos.x, prop->pos.y, prop->pos.z);
+				obj->hidden |= OBJHFLAG_FALLOUT;
+			}
+		}
+	}
+
 	if (prop->timetoregen > 0) {
 		// Prop is taken/unavailable
 		regenning = true;
@@ -17201,12 +17219,6 @@ void currentPlayerQueuePickupWeaponHudmsg(u32 weaponnum, bool dual)
 {
 	char buffer[100] = "";
 
-	// Suppress pickup HUD during cutscenes
-	if (g_Vars.in_cutscene)
-	{
-		return;
-	}
-
 	weaponGetPickupText(buffer, weaponnum, dual);
 	hudmsgCreateWithFlags(buffer, HUDMSGTYPE_DEFAULT, HUDMSGFLAG_ONLYIFALIVE | HUDMSGFLAG_ALLOWDUPES);
 }
@@ -17223,13 +17235,6 @@ s32 propPickupByPlayer(struct prop *prop, bool showhudmsg)
 		return TICKOP_NONE;
 	}
 
-	// Suppress HUD pickup messages during cutscenes (e.g. items given at
-	// mission start via aiGiveObjectToChr)
-	if (g_Vars.in_cutscene)
-	{
-		showhudmsg = false;
-	}
-
 	switch (obj->type) {
 	case OBJTYPE_KEY:
 		if (g_Vars.in_cutscene == false) {

src/game/setup.c

@@ -1460,34 +1460,6 @@ void setupLoadFiles(s32 stagenum)
 	g_Vars.maxprops = numobjs + numchrs + extra + 40;
 }
 
-static void setupMarkLiftDoors()
-{
-	s32 index = 0;
-
-	struct defaultobj *obj = (struct defaultobj *)g_StageSetup.props;
-	while (obj->type != OBJTYPE_END) {
-		if (obj->type == OBJTYPE_LIFT) {
-			struct liftobj *lift = (struct liftobj *)obj;
-			for (int i = 0; i < ARRAYCOUNT(lift->doors); i++) {
-				if (lift->doors[i]) {
-					s32 doorindex = index + *(s32*)&lift->doors[i];
-					struct doorobj *door = (struct doorobj *)setupGetCmdByIndex(doorindex);
-					// we use this 'extra1' field here to mark the door, since its not used anywhere else
-					door->extra1 = 1;
-
-					if (door->sibling) {
-						s32 siblingidx = *(s32 *) &door->sibling + doorindex;
-						struct doorobj *sibling = (struct doorobj *) setupGetCmdByIndex(siblingidx);
-						sibling->extra1 = 1;
-					}
-				}
-			}
-		}
-		obj = (struct defaultobj *) ((u32 *) obj + setupGetCmdLength((u32 *) obj));
-		index++;
-	}
-}
-
 void setupCreateProps(s32 stagenum)
 {
 	s32 withchrs = !argFindByPrefix(1, "-nochr") && !argFindByPrefix(1, "-noprop");
@@ -1560,12 +1532,6 @@ void setupCreateProps(s32 stagenum)
 			botmgrRemoveAll();
 			index = 0;
 
-            bool nodoors = (g_MpSetup.options & MPOPTION_NODOORS) != 0;
-            
-			if (nodoors) {
-				setupMarkLiftDoors();
-			}
-
 			obj = (struct defaultobj *)g_StageSetup.props;
 
 			while (obj->type != OBJTYPE_END) {
@@ -1586,15 +1552,11 @@ void setupCreateProps(s32 stagenum)
 						bodyAllocateChr(stagenum, (struct packedchr *) obj, index);
 					}
 					break;
-				case OBJTYPE_DOOR: {
-					struct doorobj *door = (struct doorobj *) obj;
-					// dont skip doors that are locked or are lift doors
-					bool skipdoor = nodoors && g_Vars.normmplayerisrunning && door->keyflags == 0 && door->extra1 == 0;
-					if (!skipdoor && withobjs && (obj->flags2 & diffflag) == 0) {
-						setupCreateDoor(door, index);
+				case OBJTYPE_DOOR:
+					if (withobjs && (obj->flags2 & diffflag) == 0) {
+						setupCreateDoor((struct doorobj *)obj, index);
 					}
 					break;
-				}
 				case OBJTYPE_DOORSCALE:
 					{
 						struct doorscaleobj *scale = (struct doorscaleobj *)obj;

src/game/sight.c

@@ -1349,17 +1349,12 @@ Gfx *sightDrawZoom(Gfx *gdl, bool sighton, f32 crossx, f32 crossy)
 			viewbottom += 1;
 			viewtop += 1;
 		}
-		// Align box correctly for widescreen
-		const f32 leftx = sightGetAdjustedX(viewleft + marginleft);
-		const f32 rightx = sightGetAdjustedX(viewright - marginright);
-		#define BOXLEFT   leftx
-		#define BOXRIGHT  rightx
-#else
-		#define BOXLEFT   (viewleft + marginleft)
-		#define BOXRIGHT  (viewright - marginright)
 #endif
-		#define BOXBOTTOM (viewbottom - marginbottom)
-		#define BOXTOP    (viewtop + margintop)
+
+#define BOXLEFT   (viewleft + marginleft)
+#define BOXRIGHT  (viewright - marginright)
+#define BOXBOTTOM (viewbottom - marginbottom)
+#define BOXTOP    (viewtop + margintop)
 
 		if (cornerwidth > BOXRIGHT - BOXLEFT) {
 			cornerwidth = BOXRIGHT - BOXLEFT;

src/game/sky.c

@@ -17,7 +17,7 @@
 #ifndef PLATFORM_N64
 #include "video.h"
 #include "game/gfxmemory.h"
-#include "game/artifact.h"
+#include "game/game_13c510.h"
 #include "game/player.h"
 #endif
 
@@ -2518,11 +2518,11 @@ void skyCreateSunArtifact(struct artifact *artifact, s32 x, s32 y)
 		sunpos.x = env->suns[i].pos[0];
 		sunpos.y = env->suns[i].pos[1];
 		sunpos.z = env->suns[i].pos[2];
-		artifact->visiblelos = artifactTestLos(&sunpos, &zero, x, y) * 0xfffc;
+		artifact->unk02 = artifactTestLos(&sunpos, &zero, x, y) * 0xfffc;
 #endif
-		artifact->zbufptr = &g_ZbufPtr1[(s32)camGetScreenWidth() * y + x];
-		artifact->screenx = x;
-		artifact->screeny = y;
+		artifact->unk08 = &g_ZbufPtr1[(s32)camGetScreenWidth() * y + x];
+		artifact->unk0c.u16_2 = x;
+		artifact->unk0c.u16_1 = y;
 		artifact->type = ARTIFACTTYPE_CIRCLE;
 	}
 }
@@ -2533,13 +2533,7 @@ f32 skyGetArtifactGroupIntensityFrac(struct artifact *artifacts)
 	s32 i;
 
 	for (i = 0; i < 8; i++) {
-		const u16 test =
-#ifdef PLATFORM_N64
-			artifacts[i].actualdepth;
-#else
-			artifacts[i].visiblelos;
-#endif
-		if (artifacts[i].type == ARTIFACTTYPE_CIRCLE && test == 0xfffc) {
+		if (artifacts[i].type == ARTIFACTTYPE_CIRCLE && artifacts[i].unk02 == 0xfffc) {
 			sum += 0.125f;
 		}
 	}
@@ -3074,13 +3068,6 @@ Gfx *skyRenderArtifacts(Gfx *gdl)
 
 void skySetOverexposure(s32 r, s32 g, s32 b)
 {
-#ifndef PLATFORM_N64
-	const f32 scale = videoGetOverexposureScale();
-	r *= scale;
-	g *= scale;
-	b *= scale;
-#endif
-
 	g_Vars.currentplayer->overexposurered = sqrtf(g_Vars.currentplayer->overexposurered * g_Vars.currentplayer->overexposurered + r * r);
 	g_Vars.currentplayer->overexposuregreen = sqrtf(g_Vars.currentplayer->overexposuregreen * g_Vars.currentplayer->overexposuregreen + g * g);
 	g_Vars.currentplayer->overexposureblue = sqrtf(g_Vars.currentplayer->overexposureblue * g_Vars.currentplayer->overexposureblue + b * b);

src/game/training.c

@@ -1544,7 +1544,7 @@ bool frIsAmmoWasted(void)
 		}
 
 		// Check if there are any explosions
-		for (i = 0; i != g_MaxExplosions; i++) {
+		for (i = 0; i != MAX_EXPLOSIONS; i++) {
 			if (g_Explosions[i].prop) {
 				return false;
 			}

src/game/vtxstore.c

@@ -58,16 +58,14 @@ void vtxstoreFixRefs(void *find, void *replacement)
 			struct modeldef *modeldef = model->definition;
 			struct modelnode *node = modeldef->rootnode;
 			struct modelrodata_dl *rodata;
-			struct modelrwdata_dl *rwdata;
 
 			while (node) {
 				switch (node->type & 0xff) {
 				case MODELNODETYPE_DL:
 					rodata = &node->rodata->dl;
-					rwdata = (struct modelrwdata_dl *)&model->rwdatas[rodata->rwdataindex];
 
-					if (rwdata->vertices == find) {
-						rwdata->vertices = replacement;
+					if (model->rwdatas[rodata->rwdataindex] == (uintptr_t) find) {
+						model->rwdatas[rodata->rwdataindex] = (uintptr_t) replacement;
 					}
 					break;
 				case MODELNODETYPE_DISTANCE:

src/game/zbuf.c

@@ -177,31 +177,23 @@ u16 *zbufGetArtifactsCfb(s32 index)
 	return addr;
 }
 
-/**
- * This method is designed to save artifact depths
- * prior to drawing the hands and weapon on-screen
- * since drawing them requires clearing the zbuffer
- * to avoid clipping the gun model on floors and walls.
- *
- * TODO: determine if this works with the PC port
- */
-Gfx *zbufSaveArtifactDepths(Gfx *gdl)
+Gfx *zbufDrawArtifactsOffscreen(Gfx *gdl)
 {
 	struct artifact *artifacts = schedGetWriteArtifacts();
 	u32 stack;
-	u16 *zbuf = g_ZbufPtr1;
-	u32 numsamples = 0;
-	u16 *samples;
-	u16 *thissample;
-	u16 *zbufrow;
+	u16 *sp4c = g_ZbufPtr1;
+	u32 s4 = 0;
+	u16 *sp44;
+	u16 *s2;
+	u16 *image;
 	s32 i;
 
 	viGetBackBuffer();
-	samples = zbufGetArtifactsCfb(g_SchedWriteArtifactsIndex);
+	sp44 = zbufGetArtifactsCfb(g_SchedWriteArtifactsIndex);
 	g_SchedSpecialArtifactIndexes[g_SchedWriteArtifactsIndex] = 1;
 
 	gDPPipeSync(gdl++);
-	gDPSetColorImage(gdl++, G_IM_FMT_RGBA, G_IM_SIZ_16b, viGetBufWidth(), OS_PHYSICAL_TO_K0(samples));
+	gDPSetColorImage(gdl++, G_IM_FMT_RGBA, G_IM_SIZ_16b, viGetBufWidth(), OS_PHYSICAL_TO_K0(sp44));
 	gDPSetScissor(gdl++, G_SC_NON_INTERLACE, 0, 0, SCREEN_320, SCREEN_240);
 	gDPSetCycleType(gdl++, G_CYC_COPY);
 	gDPSetTile(gdl++, G_IM_FMT_RGBA, G_IM_SIZ_16b, 0, 0x0000, 5, 0, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
@@ -228,24 +220,24 @@ Gfx *zbufSaveArtifactDepths(Gfx *gdl)
 		if (1);
 
 		if (artifacts[i].type != ARTIFACTTYPE_FREE) {
-			thissample = &samples[numsamples];
-			zbufrow = &zbuf[artifacts[i].screeny * viGetWidth()];
+			s2 = &sp44[s4];
+			image = &sp4c[artifacts[i].unk0c.u16_1 * viGetWidth()];
 
 			gDPPipeSync(gdl++);
-			gDPSetTextureImage(gdl++, G_IM_FMT_RGBA, G_IM_SIZ_16b, SCREEN_320, zbufrow);
+			gDPSetTextureImage(gdl++, G_IM_FMT_RGBA, G_IM_SIZ_16b, SCREEN_320, image);
 			gDPLoadSync(gdl++);
 			gDPLoadBlock(gdl++, 5, 0, 0, viGetWidth() - 1, 0);
 			gDPPipeSync(gdl++);
 
 			gSPTextureRectangle(gdl++,
-					numsamples << 2, 0,
-					(numsamples + 3) << 2, 0,
-					G_TX_RENDERTILE, (artifacts[i].screenx * 32) + 16, 0x0010, 0x1000, 0);
+					s4 << 2, 0,
+					(s4 + 3) << 2, 0,
+					G_TX_RENDERTILE, (artifacts[i].unk0c.u16_2 * 32) + 16, 0x0010, 0x1000, 0);
 
-			artifacts[i].depthptr = thissample;
-			numsamples++;
+			artifacts[i].unk0c.u16p = s2;
+			s4++;
 
-			if (thissample);
+			if (s2);
 		}
 	}
 
@@ -259,7 +251,7 @@ Gfx *zbufSaveArtifactDepths(Gfx *gdl)
 	gDPSetTexturePersp(gdl++, G_TP_PERSP);
 	gDPSetColorDither(gdl++, G_CD_BAYER);
 
-	if (samples);
+	if (sp44);
 
 	return gdl;
 }

src/include/bss.h

@@ -295,7 +295,6 @@ extern s32 g_JpnMaxCacheItems;
 extern s32 var8009d370jf;
 #ifndef PLATFORM_N64
 extern bool g_ValidGbcRomFound;
-extern bool g_BgHitXluDisabled;
 #endif
 
 #endif

src/include/constants.h

@@ -18,6 +18,7 @@
 #define MAX_CHRSPERSQUADRON    16
 #define MAX_CHRSPERTEAM        32
 #define MAX_CHRWAYPOINTS       6
+#define MAX_EXPLOSIONS         6
 #define MAX_EYESPYDARTS        8
 #define MAX_MPCHRS             (MAX_PLAYERS + MAX_BOTS)
 #define MAX_MPPLAYERCONFIGS    (MAX_PLAYERS + 2)
@@ -27,7 +28,6 @@
 #define MAX_ROOMPROPLISTCHUNKS 256
 #define MAX_SQUADRONS          16
 #define MAX_TEAMS              8
-#define MAX_EXPLOSIONS_DEFAULT 6
 
 #define NUM_BOTDIFFS          6
 #define NUM_CYCLEABLE_WEAPONS 45
@@ -2898,7 +2898,6 @@
 #define MPOPTION_AUTORANDOMWEAPON_END   0x01000000
 #define MPOPTION_FRIENDLYFIRE           0x02000000
 #define MPOPTION_NOPLAYERONRADAR        0x04000000
-#define MPOPTION_NODOORS                0x08000000
 
 #define MPPAUSEMODE_UNPAUSED 0
 #define MPPAUSEMODE_PAUSED   1
@@ -3198,6 +3197,7 @@
 #define OBJHFLAG_BLOCKEDPATH        0x02000000
 #define OBJHFLAG_MOUNTED            0x04000000 // for hoverbike
 #define OBJHFLAG_GRABBED            0x08000000
+#define OBJHFLAG_FALLOUT            0x10000000
 
 // obj->hidden2
 #define OBJH2FLAG_HASOPA       0x01 // obj has opaque polygons (ie. most objects)

src/include/game/bg.h

@@ -22,7 +22,7 @@ void bgLoadFile(void *memaddr, u32 offset, u32 len);
 s32 bgGetStageIndex(s32 stagenum);
 f32 bgCalculatePortalSurfaceArea(s32 portal);
 u8 bgCalculatePortalAlpha(s32 portal);
-u32 not(u32 arg);
+u32 bgNot(u32 arg);
 u32 bgXorBabebabe(u32 value);
 void bgReset(s32 stagenum);
 void bgBuildTables(s32 stagenum);

src/include/game/game_13c510.h

@@ -6,10 +6,10 @@
 
 void artifactsClear(void);
 void artifactsTick(void);
-u16 floatToN64Depth(f32 arg0);
-s32 artifactsFloatToInt(f32 arg0);
+u16 func0f13c574(f32 arg0);
+s32 func0f13c710(f32 arg0);
 void artifactsCalculateGlaresForRoom(s32 roomnum);
-u8 artifactsClamp(u8 arg0, u8 arg1);
+u8 func0f13d3c4(u8 arg0, u8 arg1);
 Gfx *artifactsConfigureForGlares(Gfx *gdl);
 Gfx *artifactsUnconfigureForGlares(Gfx *gdl);
 Gfx *artifactsRenderGlaresForRoom(Gfx *gdl, s32 roomnum);

src/include/game/menu.h

@@ -113,10 +113,6 @@ MenuItemHandlerResult menuhandlerRepairPak(s32 operation, struct menuitem *item,
 MenuItemHandlerResult menuhandlerRetrySavePak(s32 operation, struct menuitem *item, union handlerdata *data);
 MenuItemHandlerResult menuhandlerWarnRepairPak(s32 operation, struct menuitem *item, union handlerdata *data);
 
-s32 menuAlt1Pressed(s32 playerNum);
-s32 menuAlt2Pressed(s32 playerNum);
-s32 menuAltAnyPressed(s32 playerNum);
-
 extern const char var7f1b2658[];
 extern const char var7f1b265c[];
 extern const char var7f1b2660[];

src/include/game/zbuf.h

@@ -10,6 +10,6 @@ void zbufAllocate(void);
 void zbufSwap(void);
 Gfx *zbufConfigureRdp(Gfx *gdl);
 Gfx *zbufClear(Gfx *gdl);
-Gfx *zbufSaveArtifactDepths(Gfx *gdl);
+Gfx *zbufDrawArtifactsOffscreen(Gfx *gdl);
 
 #endif

src/include/types.h

@@ -3494,19 +3494,17 @@ struct audioconfig {
 
 struct artifact {
 	u16 type;
-	u16 actualdepth;
-	u16 expecteddepth;
-	u16 *zbufptr;
-#ifndef PLATFORM_N64
-	u16 visiblelos;
-#endif
+	u16 unk02;
+	u16 unk04;
+	u16 unk06;
+	u16 *unk08;
 	union {
-		u16 *depthptr;
+		u16 *u16p;
 		struct {
-			u16 screeny;
-			u16 screenx;
+			u16 u16_1;
+			u16 u16_2;
 		};
-	};
+	} unk0c;
 	struct light *light;
 };
 
@@ -3776,11 +3774,8 @@ struct menudata_main {
 struct menudata_mpsetup {
 	u32 slotindex;
 	u32 slotcount;
-	u32 unke24;
-};
-
-struct menudata_mpsetup_ext {
 	u8 showpresets;
+	u32 unke24;
 };
 
 struct menudata_mppause {
@@ -3993,10 +3988,9 @@ struct menu {
 		struct menudata_filemgr fm;
 		struct menudata_main4mb main4mb;
 		struct menudata_training training;
-		struct menudata_mpsetup mpsetup;
 	};
 
-	struct menudata_mpsetup_ext mpsetupext;
+	struct menudata_mpsetup mpsetup;
 };
 
 struct gamefile {
@@ -4107,11 +4101,6 @@ struct mpsetup {
 	/*0x800acba0*/ u8 weapons[NUM_MPWEAPONSLOTS];
 	/*0x800acba6*/ u8 paused;
 	/*0x800acba8*/ struct fileguid fileguid;
-#ifndef PLATFORM_N64
-	// Used to restore the non-player bits of chrslots upon entering Combat
-	// Simulator, after playing Co-Op/Counter-Op with a human sim.
-	u16 storedbotbits;
-#endif
 };
 
 struct bossfile {
@@ -4796,8 +4785,8 @@ struct menudata_5d8 {
 struct menudata {
 	/*0x000*/ s32 count;
 	/*0x004*/ s32 root;
-	/*0x008*/ s32 prevmenuroot; // also a menuroot constant
-	/*0x00c*/ struct menudialogdef *prevmenudialog;
+	/*0x008*/ s32 unk008; // also a menuroot constant
+	/*0x00c*/ struct menudialogdef *unk00c;
 	/*0x010*/ f32 unk010;
 	/*0x014*/ u8 bg;
 	/*0x015*/ u8 nextbg;
@@ -4811,7 +4800,7 @@ struct menudata {
 	/*0x5d5*/ u8 usezbuf : 1;
 	/*0x5d5*/ u8 unk5d5_04 : 1;
 	/*0x5d5*/ u8 unk5d5_05 : 1;
-	/*0x5d5*/ u8 isdialogopen : 1;
+	/*0x5d5*/ u8 unk5d5_06 : 1;
 	/*0x5d5*/ u8 unk5d5_07 : 1;
 	/*0x5d5*/ u8 unk5d5_08 : 1;
 	/*0x5d8*/ struct menudata_5d8 unk5d8[12];
@@ -6165,7 +6154,6 @@ struct extplayerconfig {
 	s32 extcontrols;
 	u32 crosshaircolour;
 	u32 crosshairsize;
-	f32 crosshairedgeboundary;
 	s32 crosshairhealth;
 	s32 usereloads;
 };

src/lib/memp.c

@@ -294,7 +294,6 @@ u32 mempGetPoolFree(u8 poolnum, u32 bank)
 	return pool->rightpos - pool->leftpos;
 }
 
-#ifdef DEBUG
 u32 mempGetPoolSize(u8 poolnum, u32 bank)
 {
 	struct memorypool *pool;
@@ -307,7 +306,6 @@ u32 mempGetPoolSize(u8 poolnum, u32 bank)
 
 	return pool->rightpos - pool->start;
 }
-#endif
 
 #if VERSION < VERSION_NTSC_1_0
 void *mempAllocFromPackedWord(u32 word)

src/lib/sched.c

@@ -540,20 +540,20 @@ void schedUpdatePendingArtifacts(void)
 		struct artifact *artifact = &artifacts[i];
 
 		if (artifact->type != ARTIFACTTYPE_FREE) {
-			u16 *currdepthptr = artifact->zbufptr;
-			u16 currdepth = *currdepthptr;
+			u16 *unk08 = artifact->unk08;
+			u16 value08 = unk08[0];
 
 			if (g_SchedSpecialArtifactIndexes[g_SchedPendingArtifactsIndex] == 1) {
-				u16 *prevdepthptr = artifact->depthptr;
-				u16 prevdepth = *prevdepthptr;
+				u16 *unk0c = artifact->unk0c.u16p;
+				u16 value0c = unk0c[0];
 
-				if (currdepth < prevdepth) {
-					artifact->actualdepth = currdepth;
+				if (value0c > value08) {
+					artifact->unk02 = value08;
 				} else {
-					artifact->actualdepth = prevdepth;
+					artifact->unk02 = value0c;
 				}
 			} else {
-				artifact->actualdepth = currdepth;
+				artifact->unk02 = value08;
 			}
 		}
 	}