feat/greedy-meshing: added meson + build options

Revert "Initial Android Support"

meson.build

@@ -1,58 +1,48 @@
 project(
-  '4jcraft',
-  ['cpp', 'c'],
-  version: '0.1.0',
-  meson_version: '>= 1.3',
-  default_options: [
-    'cpp_std=c++23',
-    'warning_level=0',
-    'buildtype=debugoptimized', # for now
-    'unity=on', # merge source files per target
-    'unity_size=8', # TODO: mess around with this
-    'b_pch=true', # precompiled headers
-  ],
+    '4jcraft',
+    ['cpp', 'c'],
+    version: '0.1.0',
+    meson_version: '>= 1.3',
+    default_options: [
+        'cpp_std=c++23',
+        'warning_level=0',
+        'buildtype=debugoptimized', # for now
+        'unity=on', # merge source files per target
+        'unity_size=8', # TODO: mess around with this
+        'b_pch=true', # precompiled headers
+    ],
 )
 
 pymod = import('python')
 python = pymod.find_installation('python3', required: true)
 
 cc = meson.get_compiler('cpp')
-lib_dir = meson.current_source_dir() / 'thirdparty/lib' / host_machine.system() / host_machine.cpu()
-inc_dir = 'thirdparty/include' / host_machine.system()
 
 global_cpp_defs = [
-  '-DSPLIT_SAVES',
-  '-D_LARGE_WORLDS',
-  '-D_EXTENDED_ACHIEVEMENTS',
-  '-D_DEBUG_MENUS_ENABLED',
-  '-D_DEBUG',
-  '-D_FORTIFY_SOURCE=2',
-  '-DDEBUG',
+    '-DSPLIT_SAVES',
+    '-D_LARGE_WORLDS',
+    '-D_EXTENDED_ACHIEVEMENTS',
+    '-D_DEBUG_MENUS_ENABLED',
+    '-D_DEBUG',
+    '-D_FORTIFY_SOURCE=2',
+    '-DDEBUG',
 ]
 
-if host_machine.system() == 'linux' or host_machine.system() == 'android'
-  global_cpp_defs += ['-Dlinux', '-D__linux', '-D__linux__']
-endif
-
-if host_machine.system() == 'android'
-  global_cpp_defs += ['-D__android__']
+if host_machine.system() == 'linux'
+    global_cpp_defs += ['-Dlinux', '-D__linux', '-D__linux__']
 endif
 
 if get_option('renderer') == 'gles'
-  global_cpp_defs += ['-DGLES']
-  if host_machine.system() == 'android'
-    gl_dep = cc.find_library('GLESv3', required: true )
-  else
+    global_cpp_defs += ['-DGLES']
     gl_dep = dependency('glesv2', required: true)
-  endif
-  glu_dep = dependency('', required: false)
+    glu_dep = dependency('', required: false)
 else
-  gl_dep = dependency('gl', required: true)
-  glu_dep = dependency('glu', required: true)
+    gl_dep = dependency('gl', required: true)
+    glu_dep = dependency('glu', required: true)
 endif
 
 if get_option('enable_vsync')
-  global_cpp_defs += ['-DENABLE_VSYNC']
+    global_cpp_defs += ['-DENABLE_VSYNC']
 endif
 
 if get_option('classic_panorama')
@@ -60,40 +50,33 @@ if get_option('classic_panorama')
 endif
 
 if get_option('enable_frame_profiler')
-  global_cpp_defs += ['-DENABLE_FRAME_PROFILER']
+    global_cpp_defs += ['-DENABLE_FRAME_PROFILER']
+endif
+
+if get_option('enable_greedy_meshing')
+    global_cpp_defs += ['-DENABLE_GREEDY_MESHING']
 endif
 
 if get_option('ui_backend') == 'shiggy'
-  global_cpp_defs += ['-D_ENABLEIGGY']
+    global_cpp_defs += ['-D_ENABLEIGGY']
 endif
 
 if get_option('ui_backend') == 'java'
-  global_cpp_defs += '-DENABLE_JAVA_GUIS'
+    global_cpp_defs += '-DENABLE_JAVA_GUIS'
 endif
 
 add_project_arguments(global_cpp_defs, language: ['cpp', 'c'])
 
 global_cpp_args = [
-  '-Wshift-count-overflow',
-  '-pipe',
+    '-Wshift-count-overflow',
+    '-pipe',
 ]
 add_project_arguments(global_cpp_args, language: 'cpp')
 
-if host_machine.system() == 'android'
-  sdl2_dep = declare_dependency(
-    dependencies: cc.find_library('SDL2', dirs: lib_dir, required: true ), 
-    include_directories: inc_dir)
-else
-  sdl2_dep = dependency('sdl2')
-endif
+sdl2_dep = dependency('sdl2')
 thread_dep = dependency('threads')
 dl_dep = cc.find_library('dl', required: true)
-
-if host_machine.system() == 'android'
-  glm_dep  = declare_dependency(include_directories: inc_dir)
-else
-  glm_dep = dependency('glm')
-endif
+glm_dep = dependency('glm')
 
 stb = subproject('stb').get_variable('stb_inc')
 stb_dep = declare_dependency(include_directories: stb)
@@ -107,4 +90,4 @@ subdir('targets/platform')
 
 subdir('targets/resources')
 subdir('targets/minecraft')
-subdir('targets/app')
+subdir('targets/app')

meson.options

@@ -7,8 +7,8 @@ option(
 )
 
 option('classic_panorama',
-  type : 'boolean', 
-  value : false, 
+  type : 'boolean',
+  value : false,
   description : 'Enable classic java edition panorama (ui_backend=java ONLY).')
 
 option(
@@ -40,3 +40,10 @@ option(
   value: 'frustum',
   description: 'Occlusion culling mode. Off disables ALL CULLING (debug only!), Frustum disables offscreen rendering (default), BFS is experimental connectivity culling, hardware uses GPU queries.',
 )
+
+option(
+  'enable_greedy_meshing',
+  type: 'boolean',
+  value: true,
+  description: 'Enable greedy meshing for chunks and liquid tops.',
+)

scripts/android.txt

@@ -1,23 +0,0 @@
-[constants]
-ndk_home = 'set_path_to_you_ndk'
-ndk_api = 'set_api_ndk'
-
-[properties]
-skip_sanity_check = true
-
-[binaries]
-c = ndk_home / 'toolchains/llvm/prebuilt/linux-x86_64/bin/aarch64-linux-android' + ndk_api + '-clang'
-cpp = ndk_home / 'toolchains/llvm/prebuilt/linux-x86_64/bin/aarch64-linux-android' + ndk_api + '-clang++'
-ar = ndk_home / 'toolchains/llvm/prebuilt/linux-x86_64/bin/llvm-ar'
-strip = ndk_home / 'toolchains/llvm/prebuilt/linux-x86_64/bin/llvm-strip'
-sys_root = ndk_home / 'toolchains/llvm/prebuilt/linux-x86_64/sysroot'
-as      = ndk_home / 'toolchains/llvm/prebuilt/linux-x86_64/bin/llvm-as'
-ranlib  = ndk_home / 'toolchains/llvm/prebuilt/linux-x86_64/bin/llvm-ranlib'
-ld      = ndk_home / 'toolchains/llvm/prebuilt/linux-x86_64/bin/llvm-ld'
-pkg_config = 'false'
-
-[host_machine]
-system = 'android'
-cpu_family = 'arm'
-cpu = 'aarch64'
-endian = 'little'

targets/app/common/Game.cpp

@@ -73,13 +73,6 @@
 #include <utility>
 #include <vector>
 
-#ifdef __android__
-#include <android/log.h>
-
-#define TAG "4JCRAFT"
-#define AndroidPrintf(...) do { __android_log_print(ANDROID_LOG_DEBUG, TAG, __VA_ARGS__); printf( __VA_ARGS__); } while( 0 );
-#endif
-
 #include "platform/sdl2/Input.h"
 #include "app/common/src/Audio/SoundEngine.h"
 #include "app/common/src/Colours/ColourTable.h"
@@ -256,12 +249,8 @@ void Game::DebugPrintf(const char* szFormat, ...) {
     va_start(ap, szFormat);
     vsnprintf(buf, sizeof(buf), szFormat, ap);
     va_end(ap);
-#if defined(__android__)
-    AndroidPrintf("%s", buf);
-#else
     OutputDebugStringA(buf);
 #endif
-#endif
 }
 
 void Game::DebugPrintf(int user, const char* szFormat, ...) {
@@ -272,11 +261,7 @@ void Game::DebugPrintf(int user, const char* szFormat, ...) {
     va_start(ap, szFormat);
     vsnprintf(buf, sizeof(buf), szFormat, ap);
     va_end(ap);
-#if defined(__android__)
-    AndroidPrintf("%s", buf);
-#else
     OutputDebugStringA(buf);
-#endif
     if (user == USER_UI) {
         ui.logDebugString(buf);
     }

targets/app/common/src/UI/Controls/UIControl_MinecraftHorse.cpp

@@ -1,10 +1,6 @@
 #include "app/common/src/UI/Controls/UIControl_MinecraftHorse.h"
 
-#ifdef GLES
-#include <GLES3/gl3.h>
-#else
 #include <GL/gl.h>
-#endif
 
 #include <cmath>
 #include <memory>

targets/app/common/src/UI/Controls/UIControl_MinecraftPlayer.cpp

@@ -1,10 +1,6 @@
 #include "UIControl_MinecraftPlayer.h"
 
-#ifdef GLES
-#include <GLES3/gl3.h>
-#else
 #include <GL/gl.h>
-#endif
 
 #include <cmath>
 #include <memory>

targets/app/include/stubs.h

@@ -2,12 +2,8 @@
 
 #include <string>
 #ifdef __linux__
-#ifdef GLES
-#include <GLES3/gl3.h>
-#else
 #include <GL/gl.h>
 #include <GL/glu.h>
-#endif
 
 #undef GL_SMOOTH
 #undef GL_FLAT
@@ -170,13 +166,7 @@ public:
     static const int GL_FLAT = 0x1D00;
 #undef glShadeModel
 #define GL_SHADEMODEL_IS_FUNCTION
-    static void glShadeModel(int mode) { 
-#ifdef GLES
-        glShadeModel(mode);
-#else
-        ::glShadeModel(mode);
-#endif
-    }
+    static void glShadeModel(int mode) { ::glShadeModel(mode); }
 };
 #undef GL_ARRAY_BUFFER_ARB
 #undef GL_STREAM_DRAW_ARB

targets/app/linux/Iggy/gdraw/gdraw.c

@@ -2,16 +2,6 @@
 
 #include "gdraw.h"
 
-// Do we really really need gdraw for the java ui?
-#ifndef _ENABLEIGGY
-void gdraw_GL_BeginCustomDraw_4J(IggyCustomDrawCallbackRegion* region, F32* matrix) {}
-void gdraw_GL_CalculateCustomDraw_4J(IggyCustomDrawCallbackRegion* region, F32* matrix) {}
-void gdraw_GL_EndCustomDraw(IggyCustomDrawCallbackRegion* region) {}
-void gdraw_GL_SetTileOrigin(S32 vx, S32 vy, unsigned int framebuffer) {} 
-void gdraw_GL_WrappedTextureDestroy(GDrawTexture* handle) {}
-
-#else
-
 #include <GL/gl.h>
 #include <dlfcn.h>
 #include <stdbool.h>
@@ -848,4 +838,3 @@ void gdraw_GL_CalculateCustomDraw_4J(IggyCustomDrawCallbackRegion* region,
                                      F32* matrix) {
     gdraw_GetObjectSpaceMatrix(matrix, region->o2w, gdraw->projection, 0.0f, 0);
 }
-#endif

targets/app/linux/LinuxGL.cpp

@@ -11,14 +11,17 @@ extern C4JRender RenderManager;
 
 #ifdef GLES
 extern "C" {
-    void glTexGeni(GLenum, GLenum, GLint) {}
-}
+extern void glClearDepthf(float depth);
+void glClearDepth(double depth) { glClearDepthf((float)depth); }
+void glTexGeni(unsigned int, unsigned int, int) {}
 void glTexGenfv(unsigned int, unsigned int, const float*) {}
-void glTexCoordPointer(int, unsigned int, int) {}
-void glNormalPointer(unsigned int, int) {}
+void glTexCoordPointer(int, unsigned int, int, const void*) {}
+void glNormalPointer(unsigned int, int, const void*) {}
 void glColorPointer(int, unsigned int, int, const void*) {}
-void glVertexPointer(int, unsigned int, int) {}
-void glCallLists(int) {}
+void glVertexPointer(int, unsigned int, int, const void*) {}
+void glEndList(void) {}
+void glCallLists(int, unsigned int, const void*) {}
+}
 #endif
 
 inline int* getIntPtr(IntBuffer* buf) {
@@ -107,32 +110,14 @@ void glTexGen_4J(int, int, FloatBuffer*) {}
 #include <stdio.h>
 #include <string.h>
 
-#ifdef GLES
-static PFNGLGENQUERIESPROC _glGenQueriesARB = nullptr;
-static PFNGLBEGINQUERYPROC _glBeginQueryARB = nullptr;
-static PFNGLENDQUERYPROC _glEndQueryARB = nullptr;
-static PFNGLGETQUERYOBJECTUIVPROC _glGetQueryObjectuivARB = nullptr;
-static bool _queriesInitialized = false;
-#else
 static PFNGLGENQUERIESARBPROC _glGenQueriesARB = nullptr;
 static PFNGLBEGINQUERYARBPROC _glBeginQueryARB = nullptr;
 static PFNGLENDQUERYARBPROC _glEndQueryARB = nullptr;
 static PFNGLGETQUERYOBJECTUIVARBPROC _glGetQueryObjectuivARB = nullptr;
 static bool _queriesInitialized = false;
-#endif
 
 static void initQueryFuncs() {
     if (_queriesInitialized) return;
-#ifdef GLES
-    _queriesInitialized = true;
-    _glGenQueriesARB =
-        (PFNGLGENQUERIESPROC)dlsym(RTLD_DEFAULT, "glGenQueries");
-    _glBeginQueryARB =
-        (PFNGLBEGINQUERYPROC)dlsym(RTLD_DEFAULT, "glBeginQuery");
-    _glEndQueryARB = (PFNGLENDQUERYPROC)dlsym(RTLD_DEFAULT, "glEndQuery");
-    _glGetQueryObjectuivARB = (PFNGLGETQUERYOBJECTUIVPROC)dlsym(
-        RTLD_DEFAULT, "glGetQueryObjectuiv");
-#else
     _queriesInitialized = true;
     _glGenQueriesARB =
         (PFNGLGENQUERIESARBPROC)dlsym(RTLD_DEFAULT, "glGenQueriesARB");
@@ -141,7 +126,6 @@ static void initQueryFuncs() {
     _glEndQueryARB = (PFNGLENDQUERYARBPROC)dlsym(RTLD_DEFAULT, "glEndQueryARB");
     _glGetQueryObjectuivARB = (PFNGLGETQUERYOBJECTUIVARBPROC)dlsym(
         RTLD_DEFAULT, "glGetQueryObjectuivARB");
-#endif
 }
 
 void glGenQueriesARB_4J(IntBuffer* buf) {

targets/app/linux/Linux_UIController.cpp

@@ -1,8 +1,5 @@
-#ifdef GLES
-#include <GLES3/gl3.h>
-#else
 #include <GL/gl.h>
-#endif
+
 // GDraw GL backend for Linux
 #include "platform/sdl2/Render.h"
 #include "Linux_UIController.h"

targets/app/meson.build

@@ -29,7 +29,7 @@ platform_sources = run_command(
 ).stdout().strip().split('\n')
 
 # linux-specific files
-if host_machine.system() == 'linux' or host_machine.system() == 'android'
+if host_machine.system() == 'linux'
   platform_sources += run_command(
     'sh',
     '-c', 'find "'
@@ -69,27 +69,6 @@ endif
 
 platform_services_src = files('../platform/PlatformServices.cpp')
 
-if host_machine.system() == 'android'
-  client_dependencies += declare_dependency(dependencies: cc.find_library('log', required: true))
-endif
-
-if host_machine.system() == 'android'
-client = shared_library(
-  'MinecraftClient',
-  client_sources + platform_sources + platform_services_src + localisation[1],
-  include_directories: include_directories('include', '..'),
-  dependencies: client_dependencies,
-  cpp_args: global_cpp_args
-  + global_cpp_defs
-  + [
-    '-DUNICODE',
-    '-D_UNICODE',
-  ],
-  c_args: global_cpp_defs + ['-DUNICODE', '-D_UNICODE'],
-  install: true,
-  install_dir: '',
-)
-else
 client = executable(
   'Minecraft.Client',
   client_sources + platform_sources + platform_services_src + localisation[1],
@@ -105,7 +84,6 @@ client = executable(
   install: true,
   install_dir: '',
 )
-endif
 
 custom_target(
   'copy_assets_to_client',

targets/java/src/File.cpp

@@ -205,10 +205,7 @@ bool File::mkdirs() const {
         return false;
     }
 
-    // Previous behavior could return false even if the directory did not exist
-    // and was successfully created, at least this happens on Android
-    fs::create_directories(path, error);
-    return !error;
+    return fs::create_directories(path, error);
 }
 
 /*

targets/minecraft/client/Camera.cpp

@@ -1,10 +1,6 @@
 #include "Camera.h"
 
-#ifdef GLES
-#include <GLES3/gl3.h>
-#else
 #include <GL/gl.h>
-#endif
 #include <glm/glm.hpp>
 #include <math.h>
 #include <string.h>
@@ -13,7 +9,6 @@
 
 #include "MemoryTracker.h"
 #include "app/include/stubs.h"
-#include "platform/sdl2/Render.h"
 #include "java/FloatBuffer.h"
 #include "minecraft/world/entity/LivingEntity.h"
 #include "minecraft/world/entity/player/Player.h"

targets/minecraft/client/Lighting.cpp

@@ -1,10 +1,6 @@
 #include "Lighting.h"
 
-#ifdef GLES
-#include <GLES3/gl3.h>
-#else
 #include <GL/gl.h>
-#endif
 
 #include "platform/sdl2/Render.h"
 #include "app/include/stubs.h"

targets/minecraft/client/gui/GuiComponent.cpp

@@ -1,10 +1,6 @@
 #include "GuiComponent.h"
 
-#ifdef GLES
-#include <GLES3/gl3.h>
-#else
 #include <GL/gl.h>
-#endif
 #include <math.h>
 
 #include "platform/sdl2/Render.h"

targets/minecraft/client/gui/Minimap.cpp

@@ -1,10 +1,6 @@
 #include "Minimap.h"
 
-#ifdef GLES
-#include <GLES3/gl3.h>
-#else
 #include <GL/gl.h>
-#endif
 #include <math.h>
 #include <string.h>
 #include <wchar.h>

targets/minecraft/client/gui/achievement/AchievementPopup.cpp

@@ -1,10 +1,6 @@
 #include "AchievementPopup.h"
 
-#ifdef GLES
-#include <GLES3/gl3.h>
-#else
 #include <GL/gl.h>
-#endif
 
 #include "platform/sdl2/Render.h"
 #include "java/System.h"

targets/minecraft/client/gui/achievement/AchievementScreen.cpp

@@ -1,10 +1,6 @@
 #include "AchievementScreen.h"
 
-#ifdef GLES
-#include <GLES3/gl3.h>
-#else
 #include <GL/gl.h>
-#endif
 
 #include <string>
 #include <vector>

targets/minecraft/client/gui/inventory/BeaconScreen.cpp

@@ -1,10 +1,6 @@
 #include "BeaconScreen.h"
 
-#ifdef GLES
-#include <GLES3/gl3.h>
-#else
 #include <GL/gl.h>
-#endif
 
 #include <memory>
 #include <string>

targets/minecraft/client/gui/inventory/CreativeInventoryScreen.cpp

@@ -1,10 +1,6 @@
 #include "CreativeInventoryScreen.h"
 
-#ifdef GLES
-#include <GLES3/gl3.h>
-#else
 #include <GL/gl.h>
-#endif
 
 #include <algorithm>
 #include <string>

targets/minecraft/client/gui/inventory/RepairScreen.cpp

@@ -1,10 +1,6 @@
 #include "RepairScreen.h"
 
-#ifdef GLES
-#include <GLES3/gl3.h>
-#else
 #include <GL/gl.h>
-#endif
 
 #include <memory>
 #include <string>

targets/minecraft/client/model/ChestModel.cpp

@@ -1,10 +1,6 @@
 #include "ChestModel.h"
 
-#ifdef GLES
-#include <GLES3/gl3.h>
-#else
 #include <GL/gl.h>
-#endif
 
 #include "minecraft/client/model/geom/ModelPart.h"
 

targets/minecraft/client/model/geom/ModelPart.cpp

@@ -1,10 +1,6 @@
 #include "ModelPart.h"
 
-#ifdef GLES
-#include <GLES3/gl3.h>
-#else
 #include <GL/gl.h>
-#endif
 
 #include <numbers>
 

targets/minecraft/client/particle/FootstepParticle.cpp

@@ -1,10 +1,6 @@
 #include "FootstepParticle.h"
 
-#ifdef GLES
-#include <GLES3/gl3.h>
-#else
 #include <GL/gl.h>
-#endif
 
 #include <cmath>
 

targets/minecraft/client/particle/HugeExplosionParticle.cpp

@@ -1,10 +1,6 @@
 #include "HugeExplosionParticle.h"
 
-#ifdef GLES
-#include <GLES3/gl3.h>
-#else
 #include <GL/gl.h>
-#endif
 
 #include "platform/sdl2/Render.h"
 #include "app/common/App_enums.h"

targets/minecraft/client/particle/ParticleEngine.cpp

@@ -1,10 +1,6 @@
 #include "ParticleEngine.h"
 
-#ifdef GLES
-#include <GLES3/gl3.h>
-#else
 #include <GL/gl.h>
-#endif
 #include <math.h>
 
 #include <algorithm>

targets/minecraft/client/particle/TakeAnimationParticle.cpp

@@ -1,10 +1,6 @@
 #include "TakeAnimationParticle.h"
 
-#ifdef GLES
-#include <GLES3/gl3.h>
-#else
 #include <GL/gl.h>
-#endif
 
 #include <cmath>
 

targets/minecraft/client/renderer/Chunk.cpp

@@ -1,12 +1,9 @@
 #include "Chunk.h"
 
-#ifdef GLES
-#include <GLES3/gl3.h>
-#else
 #include <GL/gl.h>
-#endif
 #include <string.h>
 
+#include <cmath>
 #include <mutex>
 #include <unordered_map>
 #include <unordered_set>
@@ -16,15 +13,20 @@
 #include "LevelRenderer.h"
 #include "TileRenderer.h"
 #include "app/include/FrameProfiler.h"
+#include "app/linux/LinuxGame.h"
 #include "app/linux/Stubs/winapi_stubs.h"
+#include "minecraft/SharedConstants.h"
+#include "minecraft/client/renderer/GameRenderer.h"
 #include "minecraft/client/renderer/Tesselator.h"
 #include "minecraft/client/renderer/culling/Culler.h"
 #include "minecraft/client/renderer/tileentity/TileEntityRenderDispatcher.h"
+#include "minecraft/world/Icon.h"
 #include "minecraft/world/entity/Entity.h"
 #include "minecraft/world/level/Level.h"
 #include "minecraft/world/level/LevelSource.h"
 #include "minecraft/world/level/Region.h"
 #include "minecraft/world/level/chunk/LevelChunk.h"
+#include "minecraft/world/level/tile/LiquidTile.h"
 #include "minecraft/world/level/tile/Tile.h"
 #include "minecraft/world/level/tile/entity/TileEntity.h"
 #include "minecraft/world/phys/AABB.h"
@@ -174,11 +176,6 @@ void Chunk::setPos(int x, int y, int z) {
             levelRenderer->m_csDirtyChunks);
         unsigned char refCount =
             levelRenderer->incGlobalChunkRefCount(x, y, z, level);
-        if ((clipChunk->globalIdx >= 0) &&
-            ((size_t)clipChunk->globalIdx <
-             levelRenderer->m_globalClipChunks.size())) {
-            levelRenderer->m_globalClipChunks[clipChunk->globalIdx] = clipChunk;
-        }
         //	printf("\t\t [inc] refcount %d at %d, %d, %d\n",refCount,x,y,z);
 
         //	int idx = levelRenderer->getGlobalIndexForChunk(x, y, z, level);
@@ -228,15 +225,8 @@ void Chunk::makeCopyForRebuild(Chunk* source) {
     this->globalRenderableTileEntities = source->globalRenderableTileEntities;
     this->globalRenderableTileEntities_cs =
         source->globalRenderableTileEntities_cs;
-    this->buildContext = source->buildContext;
 }
 
-void Chunk::setBuildContext(const ChunkBuildContext& ctx) {
-    buildContext = ctx;
-}
-
-const ChunkBuildContext& Chunk::getBuildContext() const { return buildContext; }
-
 void Chunk::rebuild() {
     //	if (!dirty) return;
 
@@ -297,8 +287,8 @@ void Chunk::rebuild() {
 
     LevelSource* region =
         new Region(level, x0 - r, y0 - r, z0 - r, x1 + r, y1 + r, z1 + r, r);
-    TileRenderer* tileRenderer = new TileRenderer(
-        region, this->x, this->y, this->z, tileIds, &buildContext);
+    TileRenderer* tileRenderer =
+        new TileRenderer(region, this->x, this->y, this->z, tileIds);
 
     // AP - added a caching system for Chunk::rebuild to take advantage of
     // Basically we're storing of copy of the tileIDs array inside the region so
@@ -444,6 +434,88 @@ void Chunk::rebuild() {
     // 4J - optimisation ends
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
+    // Binary Mesh Greedy implementation
+    // https://gedge.ca/blog/2014-08-17-greedy-voxel-meshing/
+    // https://github.com/cgerikj/binary-greedy-meshing/tree/master
+    // https://0fps.net/2012/06/30/meshing-in-a-minecraft-game/
+    // also https://github.com/whleucka/voxel/blob/main/src/chunk/chunk_mesh.cpp
+    //                                                                 ^ real useful thanks
+    // also known as the "spongebob! why doesn't my AO work?"
+    int greedyEligibleCount = 0;
+    std::vector<uint8_t> greedyEligible(16 * 16 * 16, 0);
+    std::vector<uint8_t> greedyLiquidTop(16 * 16 * 16, 0);
+#if defined(ENABLE_GREEDY_MESHING)
+    {
+        const double greedyEps = 1e-6;
+        auto greedyIndex = [](int lx, int ly, int lz) {
+            return (ly << 8) | (lz << 4) | lx;
+        };
+
+        for (int z = z0; z < z1; z++) {
+            for (int x = x0; x < x1; x++) {
+                for (int y = y0; y < y1; y++) {
+                    int indexY = y;
+                    int offset = 0;
+                    if (indexY >= Level::COMPRESSED_CHUNK_SECTION_HEIGHT) {
+                        indexY -= Level::COMPRESSED_CHUNK_SECTION_HEIGHT;
+                        offset = Level::COMPRESSED_CHUNK_SECTION_TILES;
+                    }
+
+                    unsigned char tileId =
+                        tileIds[offset +
+                                (((x - x0) << 11) | ((z - z0) << 7) | indexY)];
+                    if (tileId == 0 || tileId == 0xff) continue;
+
+                    Tile* tile = Tile::tiles[tileId];
+                    if (tile == nullptr) continue;
+                    if (tile->getRenderLayer() != 0) continue;
+                    if (tile->getRenderShape() != Tile::SHAPE_BLOCK) continue;
+                    if (tile->isEntityTile()) continue;
+                    if (!tile->isSolidRender()) continue;
+                    if (Tile::transculent[tileId]) continue;
+                    if (tileId == Tile::grass_Id) continue;
+
+                    tile->updateShape(level, x, y, z, -1,
+                                      std::shared_ptr<TileEntity>());
+
+                    double x0s = tile->getShapeX0();
+                    double x1s = tile->getShapeX1();
+                    double y0s = tile->getShapeY0();
+                    double y1s = tile->getShapeY1();
+                    double z0s = tile->getShapeZ0();
+                    double z1s = tile->getShapeZ1();
+
+                    if (std::fabs(x0s) > greedyEps ||
+                        std::fabs(y0s) > greedyEps ||
+                        std::fabs(z0s) > greedyEps ||
+                        std::fabs(x1s - 1.0) > greedyEps ||
+                        std::fabs(y1s - 1.0) > greedyEps ||
+                        std::fabs(z1s - 1.0) > greedyEps)
+                        continue;
+
+                    bool ok = true;
+                    for (int face = 0; face < 6; face++) {
+                        if (tile->getTexture(level, x, y, z, face) == nullptr) {
+                            ok = false;
+                            break;
+                        }
+                    }
+                    if (!ok) continue;
+
+                    int lx = x - x0;
+                    int ly = y - y0;
+                    int lz = z - z0;
+                    greedyEligible[greedyIndex(lx, ly, lz)] = 1;
+                    greedyEligibleCount++;
+                }
+            }
+        }
+    }
+    tileRenderer->setWaterTopSkipMask(greedyLiquidTop.data());
+#else
+    tileRenderer->setWaterTopSkipMask(nullptr);
+#endif
+
     Tesselator::Bounds bounds;  // 4J MGH - added
     {
         // this was the old default clip bounds for the chunk, set in
@@ -459,8 +531,704 @@ void Chunk::rebuild() {
     for (int currentLayer = 0; currentLayer < 2; currentLayer++) {
         bool renderNextLayer = false;
         bool rendered = false;
+        // second part of the greedy mesh implementation
+        bool listStarted = false;
+        bool normalTessActive = false;
+        bool greedyTessActive = false;
+        int greedyMergedQuads = 0;
+        int greedyTilesEmitted = 0;
+        int greedyLiquidMergedQuads = 0;
+        int greedyLiquidTilesEmitted = 0;
 
-        bool started = false;
+        auto startListIfNeeded = [&]() {
+            if (listStarted) return;
+            listStarted = true;
+
+            glNewList(lists + currentLayer, GL_COMPILE);
+            glDepthMask(true);
+        };
+
+        auto beginNormal = [&]() {
+            if (normalTessActive) return;
+            startListIfNeeded();
+
+            t->useCompactVertices(true);
+            t->useTileUV(false);
+            t->begin();
+            t->offset((float)(-this->x), (float)(-this->y), (float)(-this->z));
+            normalTessActive = true;
+        };
+
+        auto endNormal = [&]() {
+            if (!normalTessActive) return;
+            t->end();
+            bounds.addBounds(t->bounds);
+            t->offset(0, 0, 0);
+            normalTessActive = false;
+        };
+
+        auto beginGreedy = [&]() {
+            if (greedyTessActive) return;
+            startListIfNeeded();
+
+            t->useCompactVertices(false);
+            t->useTileUV(true);
+            t->begin();
+            t->offset((float)(-this->x), (float)(-this->y), (float)(-this->z));
+            greedyTessActive = true;
+        };
+
+        auto endGreedy = [&]() {
+            if (!greedyTessActive) return;
+            t->end();
+            bounds.addBounds(t->bounds);
+            t->useTileUV(false);
+            t->offset(0, 0, 0);
+            greedyTessActive = false;
+        };
+
+        auto greedyIndex = [](int lx, int ly, int lz) {
+            return (ly << 8) | (lz << 4) | lx;
+        };
+
+        auto getTileIdLocal = [&](int lx, int ly, int lz) -> unsigned char {
+            int worldY = y0 + ly;
+            int indexY = worldY;
+            int offset = 0;
+            if (indexY >= Level::COMPRESSED_CHUNK_SECTION_HEIGHT) {
+                indexY -= Level::COMPRESSED_CHUNK_SECTION_HEIGHT;
+                offset = Level::COMPRESSED_CHUNK_SECTION_TILES;
+            }
+            return tileIds[offset +
+                           (((lx + 0) << 11) | ((lz + 0) << 7) | indexY)];
+        };
+        // bread taste better than key
+        auto computeFaceKey = [&](Tile* tile, int wx, int wy, int wz, int face,
+                                  uint32_t& colorKey, int& lightKey) {
+            int col = tile->getColor(level, wx, wy, wz);
+            float r = ((col >> 16) & 0xff) / 255.0f;
+            float g = ((col >> 8) & 0xff) / 255.0f;
+            float b = ((col) & 0xff) / 255.0f;
+
+
+            if (GameRenderer::anaglyph3d) {
+                // todo: this will DEF break anaglyph rendering
+                // do we still need it?????????
+            }
+
+            float shade = 1.0f;
+            switch (face) {
+                case 0:
+                    shade = 0.5f;
+                    break;
+                case 1:
+                    shade = 1.0f;
+                    break;
+                case 2:
+                case 3:
+                    shade = 0.8f;
+                    break;
+                case 4:
+                case 5:
+                    shade = 0.6f;
+                    break;
+                default:
+                    break;
+            }
+
+            r *= shade;
+            g *= shade;
+            b *= shade;
+
+            if (SharedConstants::TEXTURE_LIGHTING) {
+                int nx = wx, ny = wy, nz = wz;
+                if (face == 0) ny--;
+                if (face == 1) ny++;
+                if (face == 2) nz--;
+                if (face == 3) nz++;
+                if (face == 4) nx--;
+                if (face == 5) nx++;
+                lightKey = tileRenderer->getLightColor(tile, level, nx, ny, nz);
+            } else {
+                int nx = wx, ny = wy, nz = wz;
+                if (face == 0) ny--;
+                if (face == 1) ny++;
+                if (face == 2) nz--;
+                if (face == 3) nz++;
+                if (face == 4) nx--;
+                if (face == 5) nx++;
+                float br = tile->getBrightness(level, nx, ny, nz);
+                r *= br;
+                g *= br;
+                b *= br;
+                lightKey = 0;
+            }
+
+            auto clampByte = [](float v) -> uint8_t {
+                int iv = (int)(v * 255.0f + 0.5f);
+                if (iv < 0) iv = 0;
+                if (iv > 255) iv = 255;
+                return (uint8_t)iv;
+            };
+
+            colorKey =
+                (clampByte(r) << 16) | (clampByte(g) << 8) | (clampByte(b));
+        };
+
+        auto shadeAt = [&](Tile* tile, int ax, int ay, int az) {
+            return tileRenderer->getShadeBrightness(tile, level, ax, ay, az);
+        };
+
+        auto aoCorner = [&](float s1, float s2, float s3) {
+            if (s1 < 1.0f && s2 < 1.0f) return 0.2f;
+            return (s1 + s2 + s3) / 3.0f;
+        };
+
+        auto computeFaceAO = [&](Tile* tile, int wx, int wy, int wz, int face,
+                                 float outAo[4]) {
+            switch (face) {
+                case 0: {  // Down (y-1)
+                    float sW = shadeAt(tile, wx - 1, wy - 1, wz);
+                    float sE = shadeAt(tile, wx + 1, wy - 1, wz);
+                    float sN = shadeAt(tile, wx, wy - 1, wz - 1);
+                    float sS = shadeAt(tile, wx, wy - 1, wz + 1);
+                    float sWN = shadeAt(tile, wx - 1, wy - 1, wz - 1);
+                    float sWS = shadeAt(tile, wx - 1, wy - 1, wz + 1);
+                    float sEN = shadeAt(tile, wx + 1, wy - 1, wz - 1);
+                    float sES = shadeAt(tile, wx + 1, wy - 1, wz + 1);
+
+                    outAo[0] = aoCorner(sW, sS, sWS);
+                    outAo[1] = aoCorner(sW, sN, sWN);
+                    outAo[2] = aoCorner(sE, sN, sEN);
+                    outAo[3] = aoCorner(sE, sS, sES);
+                } break;
+                case 1: {  // Up (y+1)
+                    float sW = shadeAt(tile, wx - 1, wy + 1, wz);
+                    float sE = shadeAt(tile, wx + 1, wy + 1, wz);
+                    float sN = shadeAt(tile, wx, wy + 1, wz - 1);
+                    float sS = shadeAt(tile, wx, wy + 1, wz + 1);
+                    float sWN = shadeAt(tile, wx - 1, wy + 1, wz - 1);
+                    float sWS = shadeAt(tile, wx - 1, wy + 1, wz + 1);
+                    float sEN = shadeAt(tile, wx + 1, wy + 1, wz - 1);
+                    float sES = shadeAt(tile, wx + 1, wy + 1, wz + 1);
+
+                    outAo[0] = aoCorner(sE, sS, sES);
+                    outAo[1] = aoCorner(sE, sN, sEN);
+                    outAo[2] = aoCorner(sW, sN, sWN);
+                    outAo[3] = aoCorner(sW, sS, sWS);
+                } break;
+                case 2: {  // North (z-1)
+                    float sW = shadeAt(tile, wx - 1, wy, wz - 1);
+                    float sE = shadeAt(tile, wx + 1, wy, wz - 1);
+                    float sU = shadeAt(tile, wx, wy + 1, wz - 1);
+                    float sD = shadeAt(tile, wx, wy - 1, wz - 1);
+                    float sWU = shadeAt(tile, wx - 1, wy + 1, wz - 1);
+                    float sWD = shadeAt(tile, wx - 1, wy - 1, wz - 1);
+                    float sEU = shadeAt(tile, wx + 1, wy + 1, wz - 1);
+                    float sED = shadeAt(tile, wx + 1, wy - 1, wz - 1);
+
+                    outAo[0] = aoCorner(sW, sU, sWU);
+                    outAo[1] = aoCorner(sE, sU, sEU);
+                    outAo[2] = aoCorner(sE, sD, sED);
+                    outAo[3] = aoCorner(sW, sD, sWD);
+                } break;
+                case 3: {  // South (z+1)
+                    float sW = shadeAt(tile, wx - 1, wy, wz + 1);
+                    float sE = shadeAt(tile, wx + 1, wy, wz + 1);
+                    float sU = shadeAt(tile, wx, wy + 1, wz + 1);
+                    float sD = shadeAt(tile, wx, wy - 1, wz + 1);
+                    float sWU = shadeAt(tile, wx - 1, wy + 1, wz + 1);
+                    float sWD = shadeAt(tile, wx - 1, wy - 1, wz + 1);
+                    float sEU = shadeAt(tile, wx + 1, wy + 1, wz + 1);
+                    float sED = shadeAt(tile, wx + 1, wy - 1, wz + 1);
+
+                    outAo[0] = aoCorner(sW, sU, sWU);
+                    outAo[1] = aoCorner(sW, sD, sWD);
+                    outAo[2] = aoCorner(sE, sD, sED);
+                    outAo[3] = aoCorner(sE, sU, sEU);
+                } break;
+                case 4: {  // West (x-1)
+                    float sN = shadeAt(tile, wx - 1, wy, wz - 1);
+                    float sS = shadeAt(tile, wx - 1, wy, wz + 1);
+                    float sU = shadeAt(tile, wx - 1, wy + 1, wz);
+                    float sD = shadeAt(tile, wx - 1, wy - 1, wz);
+                    float sNU = shadeAt(tile, wx - 1, wy + 1, wz - 1);
+                    float sND = shadeAt(tile, wx - 1, wy - 1, wz - 1);
+                    float sSU = shadeAt(tile, wx - 1, wy + 1, wz + 1);
+                    float sSD = shadeAt(tile, wx - 1, wy - 1, wz + 1);
+
+                    outAo[0] = aoCorner(sS, sU, sSU);
+                    outAo[1] = aoCorner(sN, sU, sNU);
+                    outAo[2] = aoCorner(sN, sD, sND);
+                    outAo[3] = aoCorner(sS, sD, sSD);
+                } break;
+                case 5: {  // East (x+1)
+                    float sN = shadeAt(tile, wx + 1, wy, wz - 1);
+                    float sS = shadeAt(tile, wx + 1, wy, wz + 1);
+                    float sU = shadeAt(tile, wx + 1, wy + 1, wz);
+                    float sD = shadeAt(tile, wx + 1, wy - 1, wz);
+                    float sNU = shadeAt(tile, wx + 1, wy + 1, wz - 1);
+                    float sND = shadeAt(tile, wx + 1, wy - 1, wz - 1);
+                    float sSU = shadeAt(tile, wx + 1, wy + 1, wz + 1);
+                    float sSD = shadeAt(tile, wx + 1, wy - 1, wz + 1);
+
+                    outAo[0] = aoCorner(sS, sD, sSD);
+                    outAo[1] = aoCorner(sN, sD, sND);
+                    outAo[2] = aoCorner(sN, sU, sNU);
+                    outAo[3] = aoCorner(sS, sU, sSU);
+                } break;
+                default:
+                    outAo[0] = outAo[1] = outAo[2] = outAo[3] = 1.0f;
+                    break;
+            }
+        };
+
+        struct GreedyFaceKey {
+            Tile* tile;
+            Icon* tex;
+            uint32_t colorKey;
+            uint32_t aoKey;
+            int lightKey;
+            bool mipmap;
+            bool operator==(const GreedyFaceKey& other) const {
+                return tile == other.tile && tex == other.tex &&
+                       colorKey == other.colorKey && aoKey == other.aoKey &&
+                       lightKey == other.lightKey && mipmap == other.mipmap;
+            }
+        };
+
+        auto greedyMeshFace = [&](int face) {
+            const int U = 16;
+            const int V = 16;
+            std::vector<uint8_t> valid(U * V, 0);
+            std::vector<GreedyFaceKey> keys(U * V);
+            bool faceRendered = false;
+
+            for (int slice = 0; slice < 16; slice++) {
+                memset(valid.data(), 0, valid.size());
+
+                for (int v = 0; v < V; v++) {
+                    for (int u = 0; u < U; u++) {
+                        int lx = 0, ly = 0, lz = 0;
+                        switch (face) {
+                            case 0:
+                            case 1:
+                                lx = u;
+                                ly = slice;
+                                lz = v;
+                                break;
+                            case 2:
+                            case 3:
+                                lx = u;
+                                ly = v;
+                                lz = slice;
+                                break;
+                            case 4:
+                            case 5:
+                                lx = slice;
+                                ly = v;
+                                lz = u;
+                                break;
+                        }
+
+                        int idx = greedyIndex(lx, ly, lz);
+                        if (greedyEligible[idx] == 0) continue;
+
+                        int wx = x0 + lx;
+                        int wy = y0 + ly;
+                        int wz = z0 + lz;
+
+                        unsigned char tileId = getTileIdLocal(lx, ly, lz);
+                        if (tileId == 0 || tileId == 0xff) continue;
+
+                        Tile* tile = Tile::tiles[tileId];
+                        if (tile == nullptr) continue;
+                        if (tile->getRenderLayer() != currentLayer) continue;
+
+                        bool visible = false;
+                        if (face == 0)
+                            visible = tile->shouldRenderFace(level, wx, wy - 1,
+                                                             wz, 0);
+                        else if (face == 1)
+                            visible = tile->shouldRenderFace(level, wx, wy + 1,
+                                                             wz, 1);
+                        else if (face == 2)
+                            visible = tile->shouldRenderFace(level, wx, wy,
+                                                             wz - 1, 2);
+                        else if (face == 3)
+                            visible = tile->shouldRenderFace(level, wx, wy,
+                                                             wz + 1, 3);
+                        else if (face == 4)
+                            visible = tile->shouldRenderFace(level, wx - 1, wy,
+                                                             wz, 4);
+                        else if (face == 5)
+                            visible = tile->shouldRenderFace(level, wx + 1, wy,
+                                                             wz, 5);
+
+                        if (!visible) continue;
+
+                        Icon* tex = tile->getTexture(level, wx, wy, wz, face);
+                        if (tex == nullptr) continue;
+
+                        GreedyFaceKey key{};
+                        key.tile = tile;
+                        key.tex = tex;
+                        key.mipmap = Tile::mipmapEnable[tileId];
+
+                        uint32_t colorKey = 0;
+                        int lightKey = 0;
+                        computeFaceKey(tile, wx, wy, wz, face, colorKey,
+                                       lightKey);
+                        key.colorKey = colorKey;
+                        key.lightKey = lightKey;
+
+                        float ao[4];
+                        computeFaceAO(tile, wx, wy, wz, face, ao);
+                        auto aoByte = [](float v) -> uint32_t {
+                            int iv = (int)(v * 255.0f + 0.5f);
+                            if (iv < 0) iv = 0;
+                            if (iv > 255) iv = 255;
+                            return (uint32_t)iv;
+                        };
+                        key.aoKey = (aoByte(ao[0]) << 24) |
+                                    (aoByte(ao[1]) << 16) |
+                                    (aoByte(ao[2]) << 8) | aoByte(ao[3]);
+
+                        valid[u + v * U] = 1;
+                        keys[u + v * U] = key;
+                    }
+                }
+
+                for (int v = 0; v < V; v++) {
+                    for (int u = 0; u < U; u++) {
+                        int idx = u + v * U;
+                        if (!valid[idx]) continue;
+
+                        GreedyFaceKey key = keys[idx];
+
+                        int w = 1;
+                        while (u + w < U && valid[idx + w] &&
+                               keys[idx + w] == key) {
+                            w++;
+                        }
+
+                        int h = 1;
+                        bool done = false;
+                        while (v + h < V && !done) {
+                            for (int k = 0; k < w; k++) {
+                                int idx2 = (u + k) + (v + h) * U;
+                                if (!valid[idx2] || !(keys[idx2] == key)) {
+                                    done = true;
+                                    break;
+                                }
+                            }
+                            if (!done) h++;
+                        }
+
+                        for (int dv = 0; dv < h; dv++) {
+                            for (int du = 0; du < w; du++) {
+                                valid[(u + du) + (v + dv) * U] = 0;
+                            }
+                        }
+
+                        greedyMergedQuads++;
+                        greedyTilesEmitted += (w * h);
+
+                        beginGreedy();
+
+                        t->setMipmapEnable(key.mipmap);
+                        if (SharedConstants::TEXTURE_LIGHTING) {
+                            t->tex2(key.lightKey);
+                        }
+
+                        float rr = ((key.colorKey >> 16) & 0xff) / 255.0f;
+                        float gg = ((key.colorKey >> 8) & 0xff) / 255.0f;
+                        float bb = (key.colorKey & 0xff) / 255.0f;
+
+                        float ao1 = ((key.aoKey >> 24) & 0xff) / 255.0f;
+                        float ao2 = ((key.aoKey >> 16) & 0xff) / 255.0f;
+                        float ao3 = ((key.aoKey >> 8) & 0xff) / 255.0f;
+                        float ao4 = (key.aoKey & 0xff) / 255.0f;
+
+                        tileRenderer->setGreedyAO(
+                            rr, gg, bb, ao1, ao2, ao3, ao4,
+                            SharedConstants::TEXTURE_LIGHTING ? key.lightKey
+                                                              : 0);
+
+                        int baseX = 0, baseY = 0, baseZ = 0;
+                        switch (face) {
+                            case 0:
+                            case 1:
+                                baseX = x0 + u;
+                                baseY = y0 + slice;
+                                baseZ = z0 + v;
+                                tileRenderer->setShape(
+                                    0.0f, 0.0f, 0.0f, (float)w, 1.0f, (float)h);
+                                if (face == 0) {
+                                    t->normal(0.0f, -1.0f, 0.0f);
+                                    tileRenderer->renderFaceDown(
+                                        key.tile, baseX, baseY, baseZ, key.tex);
+                                } else {
+                                    t->normal(0.0f, 1.0f, 0.0f);
+                                    tileRenderer->renderFaceUp(
+                                        key.tile, baseX, baseY, baseZ, key.tex);
+                                }
+                                break;
+                            case 2:
+                            case 3:
+                                baseX = x0 + u;
+                                baseY = y0 + v;
+                                baseZ = z0 + slice;
+                                tileRenderer->setShape(
+                                    0.0f, 0.0f, 0.0f, (float)w, (float)h, 1.0f);
+                                if (face == 2) {
+                                    t->normal(0.0f, 0.0f, -1.0f);
+                                    tileRenderer->renderNorth(
+                                        key.tile, baseX, baseY, baseZ, key.tex);
+                                } else {
+                                    t->normal(0.0f, 0.0f, 1.0f);
+                                    tileRenderer->renderSouth(
+                                        key.tile, baseX, baseY, baseZ, key.tex);
+                                }
+                                break;
+                            case 4:
+                            case 5:
+                                baseX = x0 + slice;
+                                baseY = y0 + v;
+                                baseZ = z0 + u;
+                                tileRenderer->setShape(0.0f, 0.0f, 0.0f, 1.0f,
+                                                       (float)h, (float)w);
+                                if (face == 4) {
+                                    t->normal(-1.0f, 0.0f, 0.0f);
+                                    tileRenderer->renderWest(
+                                        key.tile, baseX, baseY, baseZ, key.tex);
+                                } else {
+                                    t->normal(1.0f, 0.0f, 0.0f);
+                                    tileRenderer->renderEast(
+                                        key.tile, baseX, baseY, baseZ, key.tex);
+                                }
+                                break;
+                        }
+                        // who the fuck at 4j named those functions.
+                        tileRenderer->setApplyAmbienceOcclusion(false);
+                        faceRendered = true;
+                    }
+                }
+            }
+
+            return faceRendered;
+        };
+
+        struct LiquidTopKey {
+            Tile* tile;
+            Icon* tex;
+            uint32_t colorKey;
+            int lightKey;
+            bool mipmap;
+            int heightQ;
+            float height;
+            bool operator==(const LiquidTopKey& other) const {
+                return tile == other.tile && tex == other.tex &&
+                       colorKey == other.colorKey &&
+                       lightKey == other.lightKey && mipmap == other.mipmap &&
+                       heightQ == other.heightQ;
+            }
+        };
+        // liquids & oceans are usually flat, so they can definitively benefit from having this optimization.
+        auto greedyMeshLiquidTop = [&]() {
+            const int U = 16;
+            const int V = 16;
+            bool faceRendered = false;
+            const float hEps = 1e-4f;
+
+            for (int ly = 0; ly < 16; ly++) {
+                std::vector<uint8_t> valid(U * V, 0);
+                std::vector<LiquidTopKey> keys(U * V);
+
+                for (int lz = 0; lz < V; lz++) {
+                    for (int lx = 0; lx < U; lx++) {
+                        unsigned char tileId = getTileIdLocal(lx, ly, lz);
+                        if (tileId == 0 || tileId == 0xff) continue;
+
+                        Tile* tile = Tile::tiles[tileId];
+                        if (tile == nullptr) continue;
+                        if (tile->getRenderShape() != Tile::SHAPE_WATER)
+                            continue;
+                        if (tile->getRenderLayer() != currentLayer) continue;
+
+                        int wx = x0 + lx;
+                        int wy = y0 + ly;
+                        int wz = z0 + lz;
+
+                        if (!tile->shouldRenderFace(level, wx, wy + 1, wz, 1))
+                            continue;
+
+                        if (LiquidTile::getSlopeAngle(level, wx, wy, wz,
+                                                      tile->material) > -999)
+                            continue;
+
+                        float h0 = tileRenderer->getWaterHeightAt(
+                            wx, wy, wz, tile->material);
+                        float h1 = tileRenderer->getWaterHeightAt(
+                            wx, wy, wz + 1, tile->material);
+                        float h2 = tileRenderer->getWaterHeightAt(
+                            wx + 1, wy, wz + 1, tile->material);
+                        float h3 = tileRenderer->getWaterHeightAt(
+                            wx + 1, wy, wz, tile->material);
+
+                        float hmin = h0;
+                        if (h1 < hmin) hmin = h1;
+                        if (h2 < hmin) hmin = h2;
+                        if (h3 < hmin) hmin = h3;
+                        float hmax = h0;
+                        if (h1 > hmax) hmax = h1;
+                        if (h2 > hmax) hmax = h2;
+                        if (h3 > hmax) hmax = h3;
+
+                        if (hmax - hmin > hEps) continue;
+
+                        float height = hmax - 0.001f;
+                        if (height < 0.0f) height = hmax;
+                        int heightQ = (int)(height * 4096.0f + 0.5f);
+
+                        int data = level->getData(wx, wy, wz);
+                        Icon* tex = tileRenderer->getTexture(tile, 1, data);
+                        if (tex == nullptr) continue;
+
+                        LiquidTopKey key{};
+                        key.tile = tile;
+                        key.tex = tex;
+                        key.mipmap = Tile::mipmapEnable[tileId];
+                        key.heightQ = heightQ;
+                        key.height = height;
+
+                        int col = tile->getColor(level, wx, wy, wz);
+                        float r = ((col >> 16) & 0xff) / 255.0f;
+                        float g = ((col >> 8) & 0xff) / 255.0f;
+                        float b = ((col) & 0xff) / 255.0f;
+
+                        if (GameRenderer::anaglyph3d) {
+                            float cr = (r * 30 + g * 59 + b * 11) / 100;
+                            float cg = (r * 30 + g * 70) / (100);
+                            float cb = (r * 30 + b * 70) / (100);
+                            r = cr;
+                            g = cg;
+                            b = cb;
+                        }
+
+                        if (SharedConstants::TEXTURE_LIGHTING) {
+                            key.lightKey = tileRenderer->getLightColor(
+                                tile, level, wx, wy, wz);
+                        } else {
+                            float br = tile->getBrightness(level, wx, wy, wz);
+                            r *= br;
+                            g *= br;
+                            b *= br;
+                            key.lightKey = 0;
+                        }
+
+                        auto clampByte = [](float v) -> uint8_t {
+                            int iv = (int)(v * 255.0f + 0.5f);
+                            if (iv < 0) iv = 0;
+                            if (iv > 255) iv = 255;
+                            return (uint8_t)iv;
+                        };
+                        key.colorKey = (clampByte(r) << 16) |
+                                       (clampByte(g) << 8) | (clampByte(b));
+
+                        valid[lx + lz * U] = 1;
+                        keys[lx + lz * U] = key;
+                    }
+                }
+
+                for (int v = 0; v < V; v++) {
+                    for (int u = 0; u < U; u++) {
+                        int idx = u + v * U;
+                        if (!valid[idx]) continue;
+
+                        LiquidTopKey key = keys[idx];
+
+                        int w = 1;
+                        while (u + w < U && valid[idx + w] &&
+                               keys[idx + w] == key) {
+                            w++;
+                        }
+
+                        int h = 1;
+                        bool done = false;
+                        while (v + h < V && !done) {
+                            for (int k = 0; k < w; k++) {
+                                int idx2 = (u + k) + (v + h) * U;
+                                if (!valid[idx2] || !(keys[idx2] == key)) {
+                                    done = true;
+                                    break;
+                                }
+                            }
+                            if (!done) h++;
+                        }
+
+                        for (int dv = 0; dv < h; dv++) {
+                            for (int du = 0; du < w; du++) {
+                                valid[(u + du) + (v + dv) * U] = 0;
+                            }
+                        }
+
+                        greedyLiquidMergedQuads++;
+                        greedyLiquidTilesEmitted += (w * h);
+
+                        beginGreedy();
+                        tileRenderer->setApplyAmbienceOcclusion(false);
+
+                        t->setMipmapEnable(key.mipmap);
+                        if (SharedConstants::TEXTURE_LIGHTING) {
+                            t->tex2(key.lightKey);
+                        }
+
+                        float rr = ((key.colorKey >> 16) & 0xff) / 255.0f;
+                        float gg = ((key.colorKey >> 8) & 0xff) / 255.0f;
+                        float bb = (key.colorKey & 0xff) / 255.0f;
+                        t->color(rr, gg, bb);
+
+                        int baseX = x0 + u;
+                        int baseY = y0 + ly;
+                        int baseZ = z0 + v;
+                        tileRenderer->setShape(0.0f, 0.0f, 0.0f, (float)w,
+                                               key.height, (float)h);
+                        t->normal(0.0f, 1.0f, 0.0f);
+                        tileRenderer->renderFaceUp(key.tile, baseX, baseY,
+                                                   baseZ, key.tex);
+
+                        for (int dv = 0; dv < h; dv++) {
+                            for (int du = 0; du < w; du++) {
+                                int lx = u + du;
+                                int lz = v + dv;
+                                int maskIdx = (ly << 8) | (lz << 4) | lx;
+                                greedyLiquidTop[maskIdx] = 1;
+                            }
+                        }
+
+                        faceRendered = true;
+                    }
+                }
+            }
+
+            return faceRendered;
+        };
+
+#if defined(ENABLE_GREEDY_MESHING)
+        rendered |= greedyMeshLiquidTop();
+
+        if (currentLayer == 0) {
+            tileRenderer->setApplyAmbienceOcclusion(false);
+            rendered |= greedyMeshFace(0);
+            rendered |= greedyMeshFace(1);
+            rendered |= greedyMeshFace(2);
+            rendered |= greedyMeshFace(3);
+            rendered |= greedyMeshFace(4);
+            rendered |= greedyMeshFace(5);
+        }
+        endGreedy();
+#endif
 
         // 4J - changed loop order here to leave y as the innermost loop for
         // better cache performance
@@ -486,17 +1254,6 @@ void Chunk::rebuild() {
                     //					int tileId =
                     // region->getTile(x,y,z);
                     if (tileId > 0) {
-                        if (!started) {
-                            started = true;
-
-                            glNewList(lists + currentLayer, GL_COMPILE);
-                            glDepthMask(true);            // 4J added
-                            t->useCompactVertices(true);  // 4J added
-                            t->begin();
-                            t->offset((float)(-this->x), (float)(-this->y),
-                                      (float)(-this->z));
-                        }
-
                         Tile* tile = Tile::tiles[tileId];
                         if (currentLayer == 0 && tile->isEntityTile()) {
                             std::shared_ptr<TileEntity> et =
@@ -511,6 +1268,19 @@ void Chunk::rebuild() {
                         if (renderLayer != currentLayer) {
                             renderNextLayer = true;
                         } else if (renderLayer == currentLayer) {
+#if defined(ENABLE_GREEDY_MESHING)
+                            if (currentLayer == 0) {
+                                int lx = x - x0;
+                                int ly = y - y0;
+                                int lz = z - z0;
+                                if (greedyEligible[greedyIndex(lx, ly, lz)] !=
+                                    0) {
+                                    continue;
+                                }
+                            }
+#endif
+
+                            beginNormal();
                             rendered |=
                                 tileRenderer->tesselateInWorld(tile, x, y, z);
                         }
@@ -519,12 +1289,14 @@ void Chunk::rebuild() {
             }
         }
 
-        if (started) {
-            t->end();
-            bounds.addBounds(t->bounds);  // 4J MGH - added
+#if defined(ENABLE_GREEDY_MESHING)
+        endGreedy();
+#endif
+        endNormal();
+
+        if (listStarted) {
             glEndList();
             t->useCompactVertices(false);  // 4J added
-            t->offset(0, 0, 0);
         } else {
             rendered = false;
         }
@@ -554,14 +1326,10 @@ void Chunk::rebuild() {
     bb = {bounds.boundingBox[0], bounds.boundingBox[1], bounds.boundingBox[2],
           bounds.boundingBox[3], bounds.boundingBox[4], bounds.boundingBox[5]};
 
+    uint64_t conn = computeConnectivity(tileIds);  // pass tileIds
     int globalIdx =
         levelRenderer->getGlobalIndexForChunk(this->x, this->y, this->z, level);
-#if defined(OCCLUSION_MODE_BFS)
-    uint64_t conn = computeConnectivity(tileIds);  // pass tileIds
     levelRenderer->setGlobalChunkConnectivity(globalIdx, conn);
-#else
-    levelRenderer->setGlobalChunkConnectivity(globalIdx, ~0ULL);
-#endif
 
     delete tileRenderer;
     delete region;
@@ -606,7 +1374,6 @@ float Chunk::squishedDistanceToSqr(std::shared_ptr<Entity> player) {
     return xd * xd + yd * yd + zd * zd;
 }
 
-#if defined(OCCLUSION_MODE_BFS)
 uint64_t Chunk::computeConnectivity(const uint8_t* tileIds) {
     const int W = 16;
     const int H = 16;
@@ -743,7 +1510,6 @@ uint64_t Chunk::computeConnectivity(const uint8_t* tileIds) {
 
     return result;
 }
-#endif
 void Chunk::reset() {
     if (assigned) {
         int oldKey = -1;
@@ -760,9 +1526,6 @@ void Chunk::reset() {
             //%d\n",refCount,x,y,z);
             if (refCount == 0 && oldKey != -1) {
                 retireRenderableTileEntities = true;
-                if ((size_t)oldKey < levelRenderer->m_globalClipChunks.size()) {
-                    levelRenderer->m_globalClipChunks[oldKey] = nullptr;
-                }
                 int lists = oldKey * 2;
                 if (lists >= 0) {
                     lists += levelRenderer->chunkLists;

targets/minecraft/client/renderer/Chunk.h

@@ -17,14 +17,6 @@ class Entity;
 class Chunk;
 class Culler;
 
-struct ChunkBuildContext {
-    int64_t nowMs = 0;
-    uint32_t batchId = 0;
-    uint16_t veryNearCount = 0;
-    bool onlyRebuild = false;
-    bool deferredAtomic = false;
-};
-
 class ClipChunk {
 public:
     Chunk* chunk;
@@ -65,9 +57,7 @@ public:
     int xm, ym, zm;
     AABB bb;
     ClipChunk* clipChunk;
-#if defined(OCCLUSION_MODE_BFS)
     uint64_t computeConnectivity(const uint8_t* tileIds);
-#endif
     int id;
     // public:
     //	std::vector<std::shared_ptr<TileEntity> > renderableTileEntities;
@@ -77,7 +67,6 @@ private:
     LevelRenderer::rteMap* globalRenderableTileEntities;
     std::mutex* globalRenderableTileEntities_cs;
     bool assigned;
-    ChunkBuildContext buildContext;
 
 public:
     Chunk(Level* level, LevelRenderer::rteMap& globalRenderableTileEntities,
@@ -95,8 +84,6 @@ private:
 
 public:
     void makeCopyForRebuild(Chunk* source);
-    void setBuildContext(const ChunkBuildContext& ctx);
-    const ChunkBuildContext& getBuildContext() const;
     void rebuild();
     float distanceToSqr(std::shared_ptr<Entity> player) const;
     float squishedDistanceToSqr(std::shared_ptr<Entity> player);

targets/minecraft/client/renderer/GameRenderer.cpp

@@ -6,18 +6,24 @@
 #include <cmath>
 #include <numbers>
 
+#include "platform/PlatformTypes.h"
+#include "platform/sdl2/Input.h"
+#include "platform/sdl2/Render.h"
 #include "BossMobGuiInfo.h"
 #include "Chunk.h"
 #include "ItemInHandRenderer.h"
 #include "LevelRenderer.h"
-#include "Tesselator.h"
 #include "app/common/App_enums.h"
+#include "platform/ShutdownManager.h"
 #include "app/common/src/Colours/ColourTable.h"
+#include "app/linux/LinuxGame.h"
+#include "app/linux/Stubs/winapi_stubs.h"
 #include "app/include/BufferedImage.h"
 #include "app/include/FrameProfiler.h"
 #include "app/include/stubs.h"
-#include "app/linux/LinuxGame.h"
-#include "app/linux/Stubs/winapi_stubs.h"
+#include "Tesselator.h"
+#include "minecraft/world/level/storage/ConsoleSaveFileIO/compression.h"
+
 #include "java/Class.h"
 #include "java/FloatBuffer.h"
 #include "java/JavaMath.h"
@@ -72,15 +78,10 @@
 #include "minecraft/world/level/chunk/SparseLightStorage.h"
 #include "minecraft/world/level/dimension/Dimension.h"
 #include "minecraft/world/level/material/Material.h"
-#include "minecraft/world/level/storage/ConsoleSaveFileIO/compression.h"
 #include "minecraft/world/level/tile/Tile.h"
 #include "minecraft/world/phys/AABB.h"
 #include "minecraft/world/phys/HitResult.h"
 #include "minecraft/world/phys/Vec3.h"
-#include "platform/PlatformTypes.h"
-#include "platform/ShutdownManager.h"
-#include "platform/sdl2/Input.h"
-#include "platform/sdl2/Render.h"
 
 bool GameRenderer::anaglyph3d = false;
 int GameRenderer::anaglyphPass = 0;
@@ -1114,7 +1115,6 @@ void GameRenderer::FinishedReassigning() { m_csDeleteStack.unlock(); }
 
 int GameRenderer::runUpdate(void* lpParam) {
     Minecraft* minecraft = Minecraft::GetInstance();
-    int64_t updatePassToken = 0;
     Tesselator::CreateNewThreadStorage(1024 * 1024);
     Compression::UseDefaultThreadStorage();
     RenderManager.InitialiseContext();
@@ -1150,10 +1150,8 @@ int GameRenderer::runUpdate(void* lpParam) {
         int count = 0;
         static const int MAX_DEFERRED_UPDATES = 10;
         bool shouldContinue = false;
-        const int64_t tickNowMs = ++updatePassToken;
         do {
-            shouldContinue =
-                minecraft->levelRenderer->updateDirtyChunks(tickNowMs);
+            shouldContinue = minecraft->levelRenderer->updateDirtyChunks();
             count++;
         } while (shouldContinue && count < MAX_DEFERRED_UPDATES);
 
@@ -1423,8 +1421,7 @@ void GameRenderer::renderLevel(float a, int64_t until) {
             int visibleWaterChunks =
                 levelRenderer->render(cameraEntity, 1, a, updateChunks);
 
-            RenderManager.StateSetBlendFunc(GL_SRC_ALPHA,
-                                            GL_ONE_MINUS_SRC_ALPHA);
+            RenderManager.StateSetBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
             if (visibleWaterChunks > 0) {
                 levelRenderer->render(

targets/minecraft/client/renderer/ItemInHandRenderer.cpp

@@ -1,10 +1,6 @@
 #include "ItemInHandRenderer.h"
 
-#ifdef GLES
-#include <GLES3/gl3.h>
-#else
 #include <GL/gl.h>
-#endif
 
 #include <cmath>
 #include <numbers>

targets/minecraft/client/renderer/LevelRenderer.cpp

@@ -1,34 +1,33 @@
 #include "LevelRenderer.h"
 
-#ifdef GLES
-#include <GLES3/gl3.h>
-#else
 #include <GL/gl.h>
-#endif
 #include <limits.h>
 #include <stdio.h>
 #include <string.h>
 
 #include <algorithm>
 #include <array>
-#include <atomic>
 #include <cmath>
 #include <mutex>
 #include <numbers>
 #include <ranges>
 #include <utility>
 
+#include "platform/PlatformTypes.h"
+#include "platform/sdl2/Input.h"
+#include "platform/sdl2/Render.h"
 #include "Chunk.h"
 #include "GameRenderer.h"
-#include "Tesselator.h"
 #include "app/common/App_enums.h"
 #include "app/common/src/Audio/SoundEngine.h"
 #include "app/common/src/Colours/ColourTable.h"
 #include "app/common/src/Console_Debug_enum.h"
+#include "app/linux/LinuxGame.h"
 #include "app/include/FrameProfiler.h"
 #include "app/include/MobSkinMemTextureProcessor.h"
 #include "app/include/stubs.h"
-#include "app/linux/LinuxGame.h"
+#include "Tesselator.h"
+#include "util/StringHelpers.h"
 #include "java/Class.h"
 #include "java/JavaMath.h"
 #include "java/Random.h"
@@ -108,19 +107,10 @@
 #include "minecraft/world/phys/AABB.h"
 #include "minecraft/world/phys/HitResult.h"
 #include "minecraft/world/phys/Vec3.h"
-#include "platform/PlatformTypes.h"
-#include "platform/sdl2/Input.h"
-#include "platform/sdl2/Render.h"
-#include "util/StringHelpers.h"
 
 class Icon;
 class ItemInstance;
 
-namespace {
-std::atomic<uint32_t> s_chunkBuildBatchCounter{0};
-std::atomic<int64_t> s_dirtyChunkPassToken{0};
-}  // namespace
-
 // #define DISABLE_SPU_CODE
 
 ResourceLocation LevelRenderer::MOON_LOCATION =
@@ -222,7 +212,6 @@ LevelRenderer::LevelRenderer(Minecraft* mc, Textures* textures) {
 
     dirtyChunkPresent = false;
     lastDirtyChunkFound = 0;
-    m_dirtyChunksRequireFullScan = false;
 
     this->mc = mc;
     this->textures = textures;
@@ -237,8 +226,6 @@ LevelRenderer::LevelRenderer(Minecraft* mc, Textures* textures) {
     globalChunkConnectivity = new uint64_t[getGlobalChunkCount()];
     memset(globalChunkConnectivity, 0xFF,
            getGlobalChunkCount() * sizeof(uint64_t));  // 0xFF >> Fully open
-    m_globalClipChunks =
-        std::vector<ClipChunk*>(getGlobalChunkCount(), nullptr);
 
     starList = MemoryTracker::genLists(4);
 
@@ -1708,14 +1695,7 @@ void LevelRenderer::renderAdvancedClouds(float alpha) {
     RenderManager.StateSetEnableViewportClipPlanes(false);
 }
 
-bool LevelRenderer::updateDirtyChunks(int64_t cachedNowMs) {
-    const int64_t nowMs =
-        (cachedNowMs >= 0)
-            ? cachedNowMs
-            : (s_dirtyChunkPassToken.fetch_add(1, std::memory_order_relaxed) +
-               1);
-    const uint32_t chunkBuildBatchId =
-        s_chunkBuildBatchCounter.fetch_add(1, std::memory_order_relaxed) + 1;
+bool LevelRenderer::updateDirtyChunks() {
 #if defined(_LARGE_WORLDS)
     struct NearestClipChunkSet {
         std::array<std::pair<ClipChunk*, int>, MAX_CONCURRENT_CHUNK_REBUILDS>
@@ -1756,7 +1736,6 @@ bool LevelRenderer::updateDirtyChunks(int64_t cachedNowMs) {
     ClipChunk* nearChunk = nullptr;  // Nearest chunk that is dirty
     int veryNearCount = 0;
     int minDistSq = 0x7fffffff;  // Distances to this chunk
-    bool onlyRebuild = false;
     std::unique_lock<std::recursive_mutex> dirtyChunksLock(m_csDirtyChunks);
 
     // Set a flag if we should only rebuild existing chunks, not create anything
@@ -1773,165 +1752,11 @@ bool LevelRenderer::updateDirtyChunks(int64_t cachedNowMs) {
         }
         throttle++;
         */
-        onlyRebuild = (memAlloc >= MAX_COMMANDBUFFER_ALLOCATIONS);
+        bool onlyRebuild = (memAlloc >= MAX_COMMANDBUFFER_ALLOCATIONS);
 
         // Move any dirty chunks stored in the lock free stack into global flags
         int index = 0;
 
-        bool hasNonStackDirtySignal = false;
-        std::vector<int> poppedDirtyIndices;
-
-        // We want to pop all the dirty chunk indices from the stack
-        auto evaluateSparseDirtyClipChunk = [&](ClipChunk* pClipChunk) {
-            if (pClipChunk == nullptr) return;
-            if (pClipChunk->globalIdx < 0) return;
-
-            unsigned char flags = globalChunkFlags[pClipChunk->globalIdx];
-            if (!(flags & CHUNK_FLAG_DIRTY)) return;
-
-            Chunk* candidateChunk = pClipChunk->chunk;
-            if ((candidateChunk == nullptr) ||
-                (candidateChunk->level == nullptr))
-                return;
-
-            int bestDistSq = INT_MAX;
-            int bestDistWeighted = INT_MAX;
-            bool hasRelevantPlayer = false;
-
-            for (int p = 0; p < XUSER_MAX_COUNT; ++p) {
-                std::shared_ptr<LocalPlayer> player = mc->localplayers[p];
-                if (player == nullptr) continue;
-                if (level[p] != candidateChunk->level) continue;
-
-                hasRelevantPlayer = true;
-                int xd = candidateChunk->xm - (int)player->x;
-                int yd = candidateChunk->ym - (int)player->y;
-                int zd = candidateChunk->zm - (int)player->z;
-                int distSq = xd * xd + yd * yd + zd * zd;
-                int distSqWeighted = xd * xd + yd * yd * 4 + zd * zd;
-
-                if (distSq < bestDistSq) bestDistSq = distSq;
-                if (distSqWeighted < bestDistWeighted)
-                    bestDistWeighted = distSqWeighted;
-            }
-
-            if (!hasRelevantPlayer) return;
-
-            if ((!onlyRebuild) || (flags & CHUNK_FLAG_COMPILED) ||
-                (bestDistSq < 20 * 20)) {
-#if defined(_LARGE_WORLDS)
-                bool isNearer = nearestClipChunks.wouldAccept(bestDistWeighted);
-#else
-                bool isNearer = bestDistWeighted < minDistSq;
-#endif
-
-#if defined(_CRITICAL_CHUNKS)
-                bool isCritical = (globalChunkFlags[pClipChunk->globalIdx] &
-                                   CHUNK_FLAG_CRITICAL) != 0;
-                if ((!veryNearCount && isNearer) ||
-                    ((bestDistSq < 20 * 20) && isCritical))
-#else
-                if (isNearer)
-#endif
-                {
-                    int chunkY = candidateChunk->y / CHUNK_SIZE;
-                    if ((chunkY >= 0) && (chunkY < CHUNK_Y_COUNT)) {
-                        LevelChunk* lc = candidateChunk->level->getChunkAt(
-                            candidateChunk->x, candidateChunk->z);
-                        if (!lc->isRenderChunkEmpty(chunkY * CHUNK_SIZE)) {
-                            nearChunk = pClipChunk;
-                            minDistSq = bestDistWeighted;
-#if defined(_LARGE_WORLDS)
-                            nearestClipChunks.insert(nearChunk, minDistSq);
-#endif
-                        } else {
-                            candidateChunk->clearDirty();
-                            globalChunkFlags[pClipChunk->globalIdx] |=
-                                CHUNK_FLAG_EMPTYBOTH;
-                        }
-                    }
-                }
-
-#if defined(_CRITICAL_CHUNKS)
-                if ((bestDistSq < 20 * 20) &&
-                    (globalChunkFlags[pClipChunk->globalIdx] &
-                     CHUNK_FLAG_CRITICAL))
-#else
-                if (bestDistSq < 20 * 20)
-#endif
-                {
-                    veryNearCount++;
-                }
-            }
-        };
-
-        auto evaluateDirtyClipChunkForPlayer = [&](ClipChunk* pClipChunk,
-                                                   int px, int py, int pz) {
-            if (pClipChunk == nullptr) return;
-            if (pClipChunk->globalIdx < 0) return;
-
-            unsigned char flags = globalChunkFlags[pClipChunk->globalIdx];
-            if (!(flags & CHUNK_FLAG_DIRTY)) return;
-
-            Chunk* candidateChunk = pClipChunk->chunk;
-            if ((candidateChunk == nullptr) ||
-                (candidateChunk->level == nullptr))
-                return;
-
-            int xd = candidateChunk->xm - px;
-            int yd = candidateChunk->ym - py;
-            int zd = candidateChunk->zm - pz;
-            int distSq = xd * xd + yd * yd + zd * zd;
-            int distSqWeighted = xd * xd + yd * yd * 4 + zd * zd;
-
-            if ((!onlyRebuild) || (flags & CHUNK_FLAG_COMPILED) ||
-                (distSq < 20 * 20)) {
-#if defined(_LARGE_WORLDS)
-                bool isNearer = nearestClipChunks.wouldAccept(distSqWeighted);
-#else
-                bool isNearer = distSqWeighted < minDistSq;
-#endif
-
-#if defined(_CRITICAL_CHUNKS)
-                if ((!veryNearCount && isNearer) ||
-                    (distSq < 20 * 20 &&
-                     (globalChunkFlags[pClipChunk->globalIdx] &
-                      CHUNK_FLAG_CRITICAL)))
-#else
-                if (isNearer)
-#endif
-                {
-                    int chunkY = candidateChunk->y / CHUNK_SIZE;
-                    if ((chunkY >= 0) && (chunkY < CHUNK_Y_COUNT)) {
-                        LevelChunk* lc = candidateChunk->level->getChunkAt(
-                            candidateChunk->x, candidateChunk->z);
-                        if (!lc->isRenderChunkEmpty(chunkY * CHUNK_SIZE)) {
-                            nearChunk = pClipChunk;
-                            minDistSq = distSqWeighted;
-#if defined(_LARGE_WORLDS)
-                            nearestClipChunks.insert(nearChunk, minDistSq);
-#endif
-                        } else {
-                            candidateChunk->clearDirty();
-                            globalChunkFlags[pClipChunk->globalIdx] |=
-                                CHUNK_FLAG_EMPTYBOTH;
-                        }
-                    }
-                }
-
-#if defined(_CRITICAL_CHUNKS)
-                if (distSq < 20 * 20 &&
-                    ((globalChunkFlags[pClipChunk->globalIdx] &
-                      CHUNK_FLAG_CRITICAL)))
-#else
-                if (distSq < 20 * 20)
-#endif
-                {
-                    veryNearCount++;
-                }
-            }
-        };
-
         do {
             // See comment on dirtyChunksLockFreeStack.Push() regarding details
             // of this casting/subtracting -2.
@@ -1946,10 +1771,7 @@ bool LevelRenderer::updateDirtyChunks(int64_t cachedNowMs) {
                     true;  // 1 is a special value passed to let this thread
                            // know that a chunk which isn't on this stack has
                            // been set to dirty
-            if (index == 1) {
-                hasNonStackDirtySignal = true;
-                m_dirtyChunksRequireFullScan = true;
-            } else if (index > 1) {
+            else if (index > 1) {
                 int i2 = index - 2;
                 if (i2 >= DIMENSION_OFFSETS[2]) {
                     i2 -= DIMENSION_OFFSETS[2];
@@ -1972,69 +1794,148 @@ bool LevelRenderer::updateDirtyChunks(int64_t cachedNowMs) {
 #endif
 
                 dirtyChunkPresent = true;
-                poppedDirtyIndices.push_back(index - 2);
             }
         } while (index);
 
         // Only bother searching round all the chunks if we have some dirty
         // chunk(s)
         if (dirtyChunkPresent) {
-            lastDirtyChunkFound = nowMs;
+            lastDirtyChunkFound = System::currentTimeMillis();
 
-            bool useSparsePath = (!m_dirtyChunksRequireFullScan) &&
-                                 (!hasNonStackDirtySignal) &&
-                                 (!poppedDirtyIndices.empty());
+            // Find nearest chunk that is dirty
+            for (int p = 0; p < XUSER_MAX_COUNT; p++) {
+                // It's possible that the localplayers member can be set to
+                // nullptr on the main thread when a player chooses to exit the
+                // game So take a reference to the player object now. As it is a
+                // shared_ptr it should live as long as we need it
+                std::shared_ptr<LocalPlayer> player = mc->localplayers[p];
+                if (player == nullptr) continue;
+                if (chunks[p].empty()) continue;
+                if (level[p] == nullptr) continue;
+                if (chunks[p].size() != xChunks * zChunks * CHUNK_Y_COUNT)
+                    continue;
+                int px = (int)player->x;
+                int py = (int)player->y;
+                int pz = (int)player->z;
 
-            if (useSparsePath) {
-                std::sort(poppedDirtyIndices.begin(), poppedDirtyIndices.end());
-                poppedDirtyIndices.erase(std::unique(poppedDirtyIndices.begin(),
-                                                     poppedDirtyIndices.end()),
-                                         poppedDirtyIndices.end());
+                //			app.DebugPrintf("!! %d %d %d, %d %d %d
+                //{%d,%d}
+                //",px,py,pz,stackChunkDirty,nonStackChunkDirty,onlyRebuild,
+                // xChunks, zChunks);
 
-                for (int dirtyIdx : poppedDirtyIndices) {
-                    if (dirtyIdx < 0) continue;
-                    if ((size_t)dirtyIdx >= m_globalClipChunks.size()) continue;
-                    evaluateSparseDirtyClipChunk(m_globalClipChunks[dirtyIdx]);
-                }
-            } else {
-                bool sawAnyDirtyFlag = false;
-                for (int p = 0; p < XUSER_MAX_COUNT; p++) {
-                    std::shared_ptr<LocalPlayer> player = mc->localplayers[p];
-                    if (player == nullptr) continue;
-                    if (chunks[p].empty()) continue;
-                    if (level[p] == nullptr) continue;
-                    if (chunks[p].size() != xChunks * zChunks * CHUNK_Y_COUNT)
-                        continue;
+                int considered = 0;
+                int wouldBeNearButEmpty = 0;
+                for (int x = 0; x < xChunks; x++) {
+                    for (int z = 0; z < zChunks; z++) {
+                        for (int y = 0; y < CHUNK_Y_COUNT; y++) {
+                            ClipChunk* pClipChunk =
+                                &chunks[p][(z * yChunks + y) * xChunks + x];
+                            // Get distance to this chunk - deliberately not
+                            // calling the chunk's method of doing this to avoid
+                            // overheads (passing entitie, type conversion etc.)
+                            // that this involves
+                            int xd = pClipChunk->xm - px;
+                            int yd = pClipChunk->ym - py;
+                            int zd = pClipChunk->zm - pz;
+                            int distSq = xd * xd + yd * yd + zd * zd;
+                            int distSqWeighted =
+                                xd * xd + yd * yd * 4 +
+                                zd * zd;  // Weighting against y to prioritise
+                                          // things in same x/z plane as player
+                                          // first
 
-                    const int px = (int)player->x;
-                    const int py = (int)player->y;
-                    const int pz = (int)player->z;
+                            if (globalChunkFlags[pClipChunk->globalIdx] &
+                                CHUNK_FLAG_DIRTY) {
+                                if ((!onlyRebuild) ||
+                                    globalChunkFlags[pClipChunk->globalIdx] &
+                                        CHUNK_FLAG_COMPILED ||
+                                    (distSq <
+                                     20 * 20))  // Always rebuild really near
+                                                // things or else building (say)
+                                                // at tower up into empty blocks
+                                                // when we are low on memory
+                                                // will not create render data
+                                {
+                                    considered++;
+                                    // Is this chunk nearer than our nearest?
+#if defined(_LARGE_WORLDS)
+                                    bool isNearer =
+                                        nearestClipChunks.wouldAccept(
+                                            distSqWeighted);
+#else
+                                    bool isNearer = distSqWeighted < minDistSq;
+#endif
 
-                    //			app.DebugPrintf("!! %d %d %d, %d %d %d
-                    //{%d,%d}
-                    //",px,py,pz,stackChunkDirty,nonStackChunkDirty,onlyRebuild,
-                    // xChunks, zChunks);
+#if defined(_CRITICAL_CHUNKS)
+                                    // AP - this will make sure that if a
+                                    // deferred grouping has started, only
+                                    // critical chunks go into that grouping,
+                                    // even if a non-critical chunk is closer.
+                                    if ((!veryNearCount && isNearer) ||
+                                        (distSq < 20 * 20 &&
+                                         (globalChunkFlags[pClipChunk
+                                                               ->globalIdx] &
+                                          CHUNK_FLAG_CRITICAL)))
+#else
+                                    if (isNearer)
+#endif
+                                    {
+                                        // At this point we've got a chunk that
+                                        // we would like to consider for
+                                        // rendering, at least based on its
+                                        // proximity to the player(s). Its
+                                        // *quite* quick to generate empty
+                                        // render data for render chunks, but if
+                                        // we let the rebuilding do that then
+                                        // the after rebuilding we will have to
+                                        // start searching for the next nearest
+                                        // chunk from scratch again. Instead,
+                                        // its better to detect empty chunks at
+                                        // this stage, flag them up as not dirty
+                                        // (and empty), and carry on. The
+                                        // levelchunk's isRenderChunkEmpty
+                                        // method can be quite optimal as it can
+                                        // make use of the chunk's data
+                                        // compression to detect emptiness
+                                        // without actually testing as many data
+                                        // items as uncompressed data would.
+                                        Chunk* chunk = pClipChunk->chunk;
+                                        LevelChunk* lc = level[p]->getChunkAt(
+                                            chunk->x, chunk->z);
+                                        if (!lc->isRenderChunkEmpty(y * 16)) {
+                                            nearChunk = pClipChunk;
+                                            minDistSq = distSqWeighted;
+#if defined(_LARGE_WORLDS)
+                                            nearestClipChunks.insert(nearChunk,
+                                                                     minDistSq);
+#endif
+                                        } else {
+                                            chunk->clearDirty();
+                                            globalChunkFlags[pClipChunk
+                                                                 ->globalIdx] |=
+                                                CHUNK_FLAG_EMPTYBOTH;
+                                            wouldBeNearButEmpty++;
+                                        }
+                                    }
 
-                    for (int x = 0; x < xChunks; x++) {
-                        for (int z = 0; z < zChunks; z++) {
-                            for (int y = 0; y < CHUNK_Y_COUNT; y++) {
-                                ClipChunk* pClipChunk =
-                                    &chunks[p][(z * yChunks + y) * xChunks + x];
-                                if (pClipChunk->globalIdx < 0) continue;
-                                if (globalChunkFlags[pClipChunk->globalIdx] &
-                                    CHUNK_FLAG_DIRTY) {
-                                    sawAnyDirtyFlag = true;
+#if defined(_CRITICAL_CHUNKS)
+                                    // AP - is the chunk near and also critical
+                                    if (distSq < 20 * 20 &&
+                                        ((globalChunkFlags[pClipChunk
+                                                               ->globalIdx] &
+                                          CHUNK_FLAG_CRITICAL)))
+#else
+                                    if (distSq < 20 * 20)
+#endif
+                                    {
+                                        veryNearCount++;
+                                    }
                                 }
-                                evaluateDirtyClipChunkForPlayer(pClipChunk, px,
-                                                                py, pz);
                             }
                         }
                     }
                 }
-
-                if (!sawAnyDirtyFlag) {
-                    m_dirtyChunksRequireFullScan = false;
-                }
+                //			app.DebugPrintf("[%d,%d,%d]\n",nearestClipChunks.empty(),considered,wouldBeNearButEmpty);
             }
         }
     }
@@ -2068,15 +1969,7 @@ bool LevelRenderer::updateDirtyChunks(int64_t cachedNowMs) {
                 // whilst we are doing this copy. The copy will then be
                 // guaranteed to be consistent whilst rebuilding takes place
                 // outside of that lock.
-                const ChunkBuildContext buildContext = {
-                    nowMs,
-                    chunkBuildBatchId,
-                    static_cast<uint16_t>(std::min(veryNearCount, 0xffff)),
-                    onlyRebuild,
-                    veryNearCount > 0,
-                };
                 permaChunk[index].makeCopyForRebuild(chunk);
-                permaChunk[index].setBuildContext(buildContext);
                 ++index;
             }
             dirtyChunksLock.unlock();
@@ -2167,15 +2060,7 @@ bool LevelRenderer::updateDirtyChunks(int64_t cachedNowMs) {
             // means that any chunks can't be repositioned whilst we are doing
             // this copy. The copy will then be guaranteed to be consistent
             // whilst rebuilding takes place outside of that lock.
-            const ChunkBuildContext buildContext = {
-                nowMs,
-                chunkBuildBatchId,
-                static_cast<uint16_t>(std::min(veryNearCount, 0xffff)),
-                onlyRebuild,
-                veryNearCount > 0,
-            };
             permaChunk.makeCopyForRebuild(chunk);
-            permaChunk.setBuildContext(buildContext);
             dirtyChunksLock.unlock();
         }
         //		static int64_t totalTime = 0;
@@ -2197,8 +2082,8 @@ bool LevelRenderer::updateDirtyChunks(int64_t cachedNowMs) {
         // Nothing to do - clear flags that there are things to process, unless
         // it's been a while since we found any dirty chunks in which case force
         // a check next time through
-        if ((nowMs - lastDirtyChunkFound) >
-            FORCE_DIRTY_CHUNK_CHECK_PERIOD_PASSES) {
+        if ((System::currentTimeMillis() - lastDirtyChunkFound) >
+            FORCE_DIRTY_CHUNK_CHECK_PERIOD_MS) {
             dirtyChunkPresent = true;
         } else {
             dirtyChunkPresent = false;
@@ -2434,12 +2319,6 @@ void LevelRenderer::setDirty(int x0, int y0, int z0, int x1, int y1, int z1,
     int _y1 = Mth::intFloorDiv(y1, CHUNK_SIZE);
     int _z1 = Mth::intFloorDiv(z1, CHUNK_XZSIZE);
 
-#if !defined(_CRITICAL_CHUNKS)
-    std::vector<intptr_t> pendingDirtyIndices;
-    pendingDirtyIndices.reserve(
-        ((_x1 - _x0 + 1) * (_y1 - _y0 + 1) * (_z1 - _z0 + 1)));
-#endif
-
     for (int x = _x0; x <= _x1; x++) {
         for (int y = _y0; y <= _y1; y++) {
             for (int z = _z0; z <= _z1; z++) {
@@ -2510,8 +2389,8 @@ void LevelRenderer::setDirty(int x0, int y0, int z0, int x1, int y1, int z1,
 
                     dirtyChunksLockFreeStack.Push((int*)(index));
 #else
-                    pendingDirtyIndices.push_back(
-                        (intptr_t)(uintptr_t)(index + 2));
+                    dirtyChunksLockFreeStack.Push(
+                        (int*)(intptr_t)(uintptr_t)(index + 2));
 #endif
                 }
                 //				setGlobalChunkFlag(x * 16, y *
@@ -2519,19 +2398,6 @@ void LevelRenderer::setDirty(int x0, int y0, int z0, int x1, int y1, int z1,
             }
         }
     }
-
-#if !defined(_CRITICAL_CHUNKS)
-    if (!pendingDirtyIndices.empty()) {
-        std::sort(pendingDirtyIndices.begin(), pendingDirtyIndices.end());
-        pendingDirtyIndices.erase(
-            std::unique(pendingDirtyIndices.begin(), pendingDirtyIndices.end()),
-            pendingDirtyIndices.end());
-
-        for (intptr_t encodedIndex : pendingDirtyIndices) {
-            dirtyChunksLockFreeStack.Push((int*)encodedIndex);
-        }
-    }
-#endif
 }
 
 void LevelRenderer::tileChanged(int x, int y, int z) {

targets/minecraft/client/renderer/LevelRenderer.h

@@ -1,15 +1,15 @@
 #pragma once
-#include "OffsettedRenderList.h"
 #include "app/include/NetTypes.h"
 #include "app/include/SkinBox.h"
 #include "app/include/XboxStubs.h"
+#include "OffsettedRenderList.h"
+#include "platform/C4JThread.h"
+#include "util/Definitions.h"
 #include "java/JavaIntHash.h"
 #include "minecraft/core/particles/ParticleTypes.h"
 #include "minecraft/world/level/Level.h"
 #include "minecraft/world/level/LevelListener.h"
 #include "minecraft/world/phys/AABB.h"
-#include "platform/C4JThread.h"
-#include "util/Definitions.h"
 
 class ClipChunk;
 class HitResult;
@@ -119,7 +119,7 @@ public:
     void renderClouds(float alpha);
     bool isInCloud(double x, double y, double z, float alpha);
     void renderAdvancedClouds(float alpha);
-    bool updateDirtyChunks(int64_t cachedNowMs = -1);
+    bool updateDirtyChunks();
 
 public:
     void renderHit(std::shared_ptr<Player> player, HitResult* h, int mode,
@@ -225,8 +225,6 @@ private:
     uint64_t getGlobalChunkConnectivity(int index);
     std::vector<ClipChunk*> m_bfsGrid;
     std::vector<uint8_t> m_bfsVisitedFaces[4];
-    std::vector<ClipChunk*> m_globalClipChunks;
-    bool m_dirtyChunksRequireFullScan;
     std::unordered_map<int, BlockDestructionProgress*> destroyingBlocks;
     Icon** breakingTextures;
 
@@ -357,7 +355,7 @@ public:
 
     bool dirtyChunkPresent;
     int64_t lastDirtyChunkFound;
-    static const int FORCE_DIRTY_CHUNK_CHECK_PERIOD_PASSES = 64;
+    static const int FORCE_DIRTY_CHUNK_CHECK_PERIOD_MS = 250;
 
 #if defined(_LARGE_WORLDS)
     static const int MAX_CONCURRENT_CHUNK_REBUILDS = 4;

targets/minecraft/client/renderer/Tesselator.cpp

@@ -1,10 +1,6 @@
 #include "Tesselator.h"
 
-#ifdef GLES
-#include <GLES3/gl3.h>
-#else
 #include <GL/gl.h>
-#endif
 
 #include <vector>
 
@@ -69,6 +65,7 @@ Tesselator::Tesselator(int size) {
     useCompactFormat360 = false;             // 4J added
     mipmapEnable = true;                     // 4J added
     useProjectedTexturePixelShader = false;  // 4J added
+    useTileUVEnabled = false;
 
     this->size = size;
 
@@ -114,7 +111,9 @@ void Tesselator::end() {
                 _array->data(),
                 useCompactFormat360
                     ? C4JRender::VERTEX_TYPE_COMPRESSED
-                    : C4JRender::VERTEX_TYPE_PF3_TF2_CB4_NB4_XW1,
+                    : (useTileUVEnabled
+                           ? C4JRender::VERTEX_TYPE_PF3_TF2_CB4_NB4_XW1_TILEUV
+                           : C4JRender::VERTEX_TYPE_PF3_TF2_CB4_NB4_XW1),
                 useProjectedTexturePixelShader
                     ? C4JRender::PIXEL_SHADER_TYPE_PROJECTION
                     : C4JRender::PIXEL_SHADER_TYPE_STANDARD);
@@ -142,7 +141,9 @@ void Tesselator::end() {
                     RenderManager.DrawVertices(
                         (C4JRender::ePrimitiveType)mode, vertexCount,
                         _array->data(),
-                        C4JRender::VERTEX_TYPE_PF3_TF2_CB4_NB4_XW1,
+                        useTileUVEnabled
+                            ? C4JRender::VERTEX_TYPE_PF3_TF2_CB4_NB4_XW1_TILEUV
+                            : C4JRender::VERTEX_TYPE_PF3_TF2_CB4_NB4_XW1,
                         C4JRender::PIXEL_SHADER_TYPE_STANDARD);
                 }
             }
@@ -181,6 +182,8 @@ void Tesselator::useCompactVertices(bool enable) {
     useCompactFormat360 = enable;
 }
 
+void Tesselator::useTileUV(bool enable) { useTileUVEnabled = enable; }
+
 bool Tesselator::getCompactVertices() { return useCompactFormat360; }
 
 bool Tesselator::setMipmapEnable(bool enable) {
@@ -604,4 +607,4 @@ void Tesselator::addOffset(float x, float y, float z) {
     zo += z;
 }
 
-bool Tesselator::hasMaxVertices() { return false; }
+bool Tesselator::hasMaxVertices() { return false; }

targets/minecraft/client/renderer/Tesselator.h

@@ -33,6 +33,7 @@ private:
     int p;
     bool useCompactFormat360;             // 4J - added
     bool useProjectedTexturePixelShader;  // 4J - added
+    bool useTileUVEnabled;
 public:
     int count;
 
@@ -125,6 +126,7 @@ public:
     void useCompactVertices(bool enable);   // 4J added
     bool getCompactVertices();              // AP added
     void useProjectedTexture(bool enable);  // 4J added
+    void useTileUV(bool enable);
     void tex(float u, float v);
     void tex2(int tex2);  // 4J - change brought forward from 1.8.2
     void color(float r, float g, float b);
@@ -143,4 +145,4 @@ public:
     bool setMipmapEnable(bool enable);  // 4J added
 
     bool hasMaxVertices();  // 4J Added
-};
+};

targets/minecraft/client/renderer/TileRenderer.cpp

@@ -1,10 +1,6 @@
 #include "TileRenderer.h"
 
-#ifdef GLES
-#include <GLES3/gl3.h>
-#else
 #include <GL/gl.h>
-#endif
 #include <assert.h>
 #include <stdint.h>
 #include <string.h>
@@ -13,7 +9,6 @@
 #include <cmath>
 #include <numbers>
 
-#include "Chunk.h"
 #include "EntityTileRenderer.h"
 #include "GameRenderer.h"
 #include "Tesselator.h"
@@ -80,6 +75,7 @@ void TileRenderer::_init() {
     xFlipTexture = false;
     noCulling = false;
     applyAmbienceOcclusion = false;
+    waterTopSkipMask = nullptr;
     setColor = true;
     northFlip = FLIP_NONE;
     southFlip = FLIP_NONE;
@@ -102,7 +98,6 @@ void TileRenderer::_init() {
     yMin = 0;
     zMin = 0;
     cache = nullptr;
-    buildContext = nullptr;
 }
 
 bool TileRenderer::isTranslucentAt(LevelSource* level, int x, int y, int z) {
@@ -206,8 +201,7 @@ int TileRenderer::getLightColor(Tile* tt, LevelSource* level, int x, int y,
 }
 
 TileRenderer::TileRenderer(LevelSource* level, int xMin, int yMin, int zMin,
-                           unsigned char* tileIds,
-                           const ChunkBuildContext* buildContext) {
+                           unsigned char* tileIds) {
     this->level = level;
     _init();
     this->xMin = xMin;
@@ -217,7 +211,6 @@ TileRenderer::TileRenderer(LevelSource* level, int xMin, int yMin, int zMin,
     this->yMin2 = yMin - 2;
     this->zMin2 = zMin - 2;
     this->tileIds = tileIds;
-    this->buildContext = buildContext;
     cache = new unsigned int[32 * 32 * 32];
     memset(cache, 0, 32 * 32 * 32 * sizeof(unsigned int));
 }
@@ -236,10 +229,6 @@ TileRenderer::TileRenderer() {
     _init();
 }
 
-void TileRenderer::setBuildContext(const ChunkBuildContext* buildContext) {
-    this->buildContext = buildContext;
-}
-
 void TileRenderer::setFixedTexture(Icon* fixedTexture) {
     this->fixedTexture = fixedTexture;
 }
@@ -248,6 +237,40 @@ void TileRenderer::clearFixedTexture() { this->fixedTexture = nullptr; }
 
 bool TileRenderer::hasFixedTexture() { return fixedTexture != nullptr; }
 
+void TileRenderer::setApplyAmbienceOcclusion(bool enabled) {
+    applyAmbienceOcclusion = enabled;
+}
+
+void TileRenderer::setWaterTopSkipMask(const uint8_t* mask) {
+    waterTopSkipMask = mask;
+}
+
+void TileRenderer::setGreedyAO(float baseR, float baseG, float baseB, float ao1,
+                               float ao2, float ao3, float ao4, int tex2) {
+    applyAmbienceOcclusion = true;
+
+    c1r = baseR * ao1;
+    c1g = baseG * ao1;
+    c1b = baseB * ao1;
+
+    c2r = baseR * ao2;
+    c2g = baseG * ao2;
+    c2b = baseB * ao2;
+
+    c3r = baseR * ao3;
+    c3g = baseG * ao3;
+    c3b = baseB * ao3;
+
+    c4r = baseR * ao4;
+    c4g = baseG * ao4;
+    c4b = baseB * ao4;
+
+    tc1 = tex2;
+    tc2 = tex2;
+    tc3 = tex2;
+    tc4 = tex2;
+}
+
 void TileRenderer::setShape(float x0, float y0, float z0, float x1, float y1,
                             float z1) {
     if (!fixedShape) {
@@ -4581,6 +4604,17 @@ bool TileRenderer::tesselateWaterInWorld(Tile* tt, int x, int y, int z) {
     float g = (col >> 8 & 0xff) / 255.0f;
     float b = (col & 0xff) / 255.0f;
     bool up = tt->shouldRenderFace(level, x, y + 1, z, 1);
+    if (waterTopSkipMask) {
+        int lx = x - xMin;
+        int ly = y - yMin;
+        int lz = z - zMin;
+        if ((unsigned)lx < 16 && (unsigned)ly < 16 && (unsigned)lz < 16) {
+            int idx = (ly << 8) | (lz << 4) | lx;
+            if (waterTopSkipMask[idx]) {
+                up = false;
+            }
+        }
+    }
     bool down = tt->shouldRenderFace(level, x, y - 1, z, 0);
     bool dirs[4];
     dirs[0] = tt->shouldRenderFace(level, x, y, z - 1, 2);
@@ -4788,6 +4822,10 @@ bool TileRenderer::tesselateWaterInWorld(Tile* tt, int x, int y, int z) {
     return changed;
 }
 
+float TileRenderer::getWaterHeightAt(int x, int y, int z, Material* m) {
+    return getWaterHeight(x, y, z, m);
+}
+
 float TileRenderer::getWaterHeight(int x, int y, int z, Material* m) {
     int count = 0;
     float h = 0;
@@ -5262,10 +5300,10 @@ bool TileRenderer::tesselateBlockInWorldWithAmbienceOcclusionTexLighting(
         ll0yZ = getShadeBrightness(tt, level, pX, pY, pZ + 1);
         llXy0 = getShadeBrightness(tt, level, pX + 1, pY, pZ);
 
-        bool llTransXy0 = isTranslucentAt(level, pX + 1, pY - 1, pZ);
-        bool llTransxy0 = isTranslucentAt(level, pX - 1, pY - 1, pZ);
-        bool llTrans0yZ = isTranslucentAt(level, pX, pY - 1, pZ + 1);
-        bool llTrans0yz = isTranslucentAt(level, pX, pY - 1, pZ - 1);
+        bool llTransXy0 = Tile::transculent[level->getTile(pX + 1, pY - 1, pZ)];
+        bool llTransxy0 = Tile::transculent[level->getTile(pX - 1, pY - 1, pZ)];
+        bool llTrans0yZ = Tile::transculent[level->getTile(pX, pY - 1, pZ + 1)];
+        bool llTrans0yz = Tile::transculent[level->getTile(pX, pY - 1, pZ - 1)];
 
         if (llTrans0yz || llTransxy0) {
             llxyz = getShadeBrightness(tt, level, pX - 1, pY, pZ - 1);
@@ -5354,10 +5392,10 @@ bool TileRenderer::tesselateBlockInWorldWithAmbienceOcclusionTexLighting(
         ll0Yz = getShadeBrightness(tt, level, pX, pY, pZ - 1);
         ll0YZ = getShadeBrightness(tt, level, pX, pY, pZ + 1);
 
-        bool llTransXY0 = isTranslucentAt(level, pX + 1, pY + 1, pZ);
-        bool llTransxY0 = isTranslucentAt(level, pX - 1, pY + 1, pZ);
-        bool llTrans0YZ = isTranslucentAt(level, pX, pY + 1, pZ + 1);
-        bool llTrans0Yz = isTranslucentAt(level, pX, pY + 1, pZ - 1);
+        bool llTransXY0 = Tile::transculent[level->getTile(pX + 1, pY + 1, pZ)];
+        bool llTransxY0 = Tile::transculent[level->getTile(pX - 1, pY + 1, pZ)];
+        bool llTrans0YZ = Tile::transculent[level->getTile(pX, pY + 1, pZ + 1)];
+        bool llTrans0Yz = Tile::transculent[level->getTile(pX, pY + 1, pZ - 1)];
 
         if (llTrans0Yz || llTransxY0) {
             llxYz = getShadeBrightness(tt, level, pX - 1, pY, pZ - 1);
@@ -5437,10 +5475,10 @@ bool TileRenderer::tesselateBlockInWorldWithAmbienceOcclusionTexLighting(
         cc0Yz = getLightColor(tt, level, pX, pY + 1, pZ);
         ccX0z = getLightColor(tt, level, pX + 1, pY, pZ);
 
-        bool llTransX0z = isTranslucentAt(level, pX + 1, pY, pZ - 1);
-        bool llTransx0z = isTranslucentAt(level, pX - 1, pY, pZ - 1);
-        bool llTrans0Yz = isTranslucentAt(level, pX, pY + 1, pZ - 1);
-        bool llTrans0yz = isTranslucentAt(level, pX, pY - 1, pZ - 1);
+        bool llTransX0z = Tile::transculent[level->getTile(pX + 1, pY, pZ - 1)];
+        bool llTransx0z = Tile::transculent[level->getTile(pX - 1, pY, pZ - 1)];
+        bool llTrans0Yz = Tile::transculent[level->getTile(pX, pY + 1, pZ - 1)];
+        bool llTrans0yz = Tile::transculent[level->getTile(pX, pY - 1, pZ - 1)];
 
         if (llTransx0z || llTrans0yz) {
             llxyz = getShadeBrightness(tt, level, pX - 1, pY - 1, pZ);
@@ -5605,10 +5643,10 @@ bool TileRenderer::tesselateBlockInWorldWithAmbienceOcclusionTexLighting(
         cc0yZ = getLightColor(tt, level, pX, pY - 1, pZ);
         cc0YZ = getLightColor(tt, level, pX, pY + 1, pZ);
 
-        bool llTransX0Z = isTranslucentAt(level, pX + 1, pY, pZ + 1);
-        bool llTransx0Z = isTranslucentAt(level, pX - 1, pY, pZ + 1);
-        bool llTrans0YZ = isTranslucentAt(level, pX, pY + 1, pZ + 1);
-        bool llTrans0yZ = isTranslucentAt(level, pX, pY - 1, pZ + 1);
+        bool llTransX0Z = Tile::transculent[level->getTile(pX + 1, pY, pZ + 1)];
+        bool llTransx0Z = Tile::transculent[level->getTile(pX - 1, pY, pZ + 1)];
+        bool llTrans0YZ = Tile::transculent[level->getTile(pX, pY + 1, pZ + 1)];
+        bool llTrans0yZ = Tile::transculent[level->getTile(pX, pY - 1, pZ + 1)];
 
         if (llTransx0Z || llTrans0yZ) {
             llxyZ = getShadeBrightness(tt, level, pX - 1, pY - 1, pZ);
@@ -5773,10 +5811,10 @@ bool TileRenderer::tesselateBlockInWorldWithAmbienceOcclusionTexLighting(
         ccx0Z = getLightColor(tt, level, pX, pY, pZ + 1);
         ccxY0 = getLightColor(tt, level, pX, pY + 1, pZ);
 
-        bool llTransxY0 = isTranslucentAt(level, pX - 1, pY + 1, pZ);
-        bool llTransxy0 = isTranslucentAt(level, pX - 1, pY - 1, pZ);
-        bool llTransx0z = isTranslucentAt(level, pX - 1, pY, pZ - 1);
-        bool llTransx0Z = isTranslucentAt(level, pX - 1, pY, pZ + 1);
+        bool llTransxY0 = Tile::transculent[level->getTile(pX - 1, pY + 1, pZ)];
+        bool llTransxy0 = Tile::transculent[level->getTile(pX - 1, pY - 1, pZ)];
+        bool llTransx0z = Tile::transculent[level->getTile(pX - 1, pY, pZ - 1)];
+        bool llTransx0Z = Tile::transculent[level->getTile(pX - 1, pY, pZ + 1)];
 
         if (llTransx0z || llTransxy0) {
             llxyz = getShadeBrightness(tt, level, pX, pY - 1, pZ - 1);
@@ -5937,10 +5975,10 @@ bool TileRenderer::tesselateBlockInWorldWithAmbienceOcclusionTexLighting(
         ccX0Z = getLightColor(tt, level, pX, pY, pZ + 1);
         ccXY0 = getLightColor(tt, level, pX, pY + 1, pZ);
 
-        bool llTransXY0 = isTranslucentAt(level, pX + 1, pY + 1, pZ);
-        bool llTransXy0 = isTranslucentAt(level, pX + 1, pY - 1, pZ);
-        bool llTransX0Z = isTranslucentAt(level, pX + 1, pY, pZ + 1);
-        bool llTransX0z = isTranslucentAt(level, pX + 1, pY, pZ - 1);
+        bool llTransXY0 = Tile::transculent[level->getTile(pX + 1, pY + 1, pZ)];
+        bool llTransXy0 = Tile::transculent[level->getTile(pX + 1, pY - 1, pZ)];
+        bool llTransX0Z = Tile::transculent[level->getTile(pX + 1, pY, pZ + 1)];
+        bool llTransX0z = Tile::transculent[level->getTile(pX + 1, pY, pZ - 1)];
 
         if (llTransXy0 || llTransX0z) {
             llXyz = getShadeBrightness(tt, level, pX, pY - 1, pZ - 1);

targets/minecraft/client/renderer/TileRenderer.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cstdint>
 #include <memory>
 #include <unordered_map>
 
@@ -30,7 +31,6 @@ class BeaconTile;
 class HopperTile;
 class Icon;
 class Minecraft;
-struct ChunkBuildContext;
 
 class TileRenderer {
     friend class FallingTileRenderer;
@@ -40,6 +40,7 @@ private:
     Icon* fixedTexture;
     bool xFlipTexture;
     bool noCulling;
+    const uint8_t* waterTopSkipMask;
 
 public:
     static bool fancy;
@@ -63,7 +64,6 @@ public:
     bool isTranslucentAt(LevelSource* level, int x, int y, int z);
     unsigned int* cache;
     unsigned char* tileIds;
-    const ChunkBuildContext* buildContext;
     static const unsigned int cache_getLightColor_valid = 0x80000000;
     static const unsigned int cache_isTranslucentAt_valid = 0x40000000;
     static const unsigned int cache_isSolidBlockingTile_valid = 0x20000000;
@@ -76,15 +76,17 @@ public:
 
 public:
     TileRenderer(LevelSource* level, int xMin, int yMin, int zMin,
-                 unsigned char* tileIds,
-                 const ChunkBuildContext* buildContext = nullptr);
+                 unsigned char* tileIds);
     TileRenderer(LevelSource* level);
     TileRenderer();
     ~TileRenderer();
-    void setBuildContext(const ChunkBuildContext* buildContext);
     void setFixedTexture(Icon* fixedTexture);
     void clearFixedTexture();
     bool hasFixedTexture();
+    void setApplyAmbienceOcclusion(bool enabled);
+    void setWaterTopSkipMask(const uint8_t* mask);
+    void setGreedyAO(float baseR, float baseG, float baseB, float ao1,
+                     float ao2, float ao3, float ao4, int tex2);
     void setShape(float x0, float y0, float z0, float x1, float y1, float z1);
     void setShape(Tile* tt);
     void setFixedShape(float x0, float y0, float z0, float x1, float y1,
@@ -192,6 +194,7 @@ public:
 
     void tesselateRowTexture(Tile* tt, int data, float x, float y, float z);
     bool tesselateWaterInWorld(Tile* tt, int x, int y, int z);
+    float getWaterHeightAt(int x, int y, int z, Material* m);
 
 private:
     float getWaterHeight(int x, int y, int z, Material* m);

targets/minecraft/client/renderer/culling/Frustum.cpp

@@ -1,10 +1,6 @@
 #include "Frustum.h"
 
-#ifdef GLES
-#include <GLES3/gl3.h>
-#else
 #include <GL/gl.h>
-#endif
 #include <string.h>
 
 #include <cmath>

targets/minecraft/client/renderer/entity/ItemFrameRenderer.cpp

@@ -1,8 +1,4 @@
-#ifdef GLES
-#include <GLES3/gl3.h>
-#else
 #include <GL/gl.h>
-#endif
 
 #include <string>
 

targets/minecraft/client/renderer/texture/Texture.h

@@ -1,11 +1,6 @@
 #pragma once
 
-#ifdef GLES
-#include <GLES3/gl3.h>
-#include <GLES2/gl2ext.h>
-#else
 #include <GL/gl.h>
-#endif
 
 #include <format>
 #include <string>
@@ -18,19 +13,12 @@ class BufferedImage;
 class Texture {
 public:
     static const int WM_WRAP = GL_REPEAT;
-#ifdef GLES
-    static const int WM_CLAMP = GL_CLAMP_TO_EDGE;
-#else
     static const int WM_CLAMP = GL_CLAMP;
-#endif
     static const int WM_MIRROR = 0;  // GL_MIRRORED_REPEAT;
 
     static const int TFMT_RGBA = GL_RGBA;
-#ifdef GLES
-    static const int TFMT_BGRA = GL_BGRA_EXT;
-#else
     static const int TFMT_BGRA = GL_BGRA;
-#endif
+
     static const int TFLT_NEAREST = GL_NEAREST;
     static const int TFLT_LINEAR = GL_LINEAR;
     static const int TFLT_LINEAR_MIP_NEAREST = 0;  // GL_LINEAR_MIPMAP_NEAREST;

targets/minecraft/client/skins/AbstractTexturePack.cpp

@@ -1,10 +1,6 @@
 #include "AbstractTexturePack.h"
 
-#ifdef GLES
-#include <GLES3/gl3.h>
-#else
 #include <GL/gl.h>
-#endif
 #include <wchar.h>
 
 #include <vector>

targets/minecraft/client/title/TitleScreen.cpp

@@ -4,7 +4,6 @@
 
 #include <cmath>
 #include <vector>
-#include <numbers> // for std::numbers
 
 #include "platform/sdl2/Render.h"
 #include "app/linux/LinuxGame.h"

targets/minecraft/meson.build

@@ -64,16 +64,8 @@ lib_minecraft = static_library('minecraft',
   cpp_args : global_cpp_args + global_cpp_defs,
 )
 
-_inc_dir = '../../' / inc_dir
-
 zlib_dep = dependency('zlib')
-if host_machine.system() == 'android'
-  crypto_dep = declare_dependency(
-    dependencies: cc.find_library('crypto', dirs: lib_dir, required: true ),
-    include_directories: _inc_dir)
-else
- crypto_dep = dependency('libcrypto')  # for MD5 in Hasher.cpp on Linux
-endif
+crypto_dep = dependency('libcrypto')  # for MD5 in Hasher.cpp on Linux
 
 minecraft_dep = declare_dependency(
   link_with : lib_minecraft,

targets/platform/IPlatformRenderer.h

@@ -11,6 +11,7 @@ public:
         VERTEX_TYPE_COMPRESSED,
         VERTEX_TYPE_PF3_TF2_CB4_NB4_XW1_LIT,
         VERTEX_TYPE_PF3_TF2_CB4_NB4_XW1_TEXGEN,
+        VERTEX_TYPE_PF3_TF2_CB4_NB4_XW1_TILEUV,
         VERTEX_TYPE_COUNT
     };
 

targets/platform/StdFileIO.h

@@ -75,18 +75,13 @@ public:
     }
 
     std::filesystem::path getBasePath() override {
-#if defined(__linux__) && !defined (__android__)
+#if defined(__linux__)
         char buf[4096];
         ssize_t len = readlink("/proc/self/exe", buf, sizeof(buf) - 1);
         if (len > 0) {
             buf[len] = '\0';
             return std::filesystem::path(buf).parent_path();
         }
-#elif defined(__android__)
-        // Because of the static init fiasco
-        // I need to set the path before loading the library
-        // I can only do this through ENV
-        return std::filesystem::path( getenv("MC_PATH") ); 
 #endif
         return std::filesystem::current_path();
     }

targets/platform/meson.build

@@ -1,5 +1,4 @@
 platform_inc = include_directories('.')
-_inc_dir = '../../' / inc_dir
 _threads = dependency('threads')
 
 lib_platform_core = static_library('platform_core',
@@ -15,39 +14,16 @@ platform_dep = declare_dependency(
 )
 
 # SDL2-based platform implementations (formerly 4J.* modules)
-if host_machine.system() == 'android'
-  _sdl2 = declare_dependency(
-  dependencies: cc.find_library('SDL2', dirs: lib_dir, required: true ), 
-  include_directories: _inc_dir)
-else
-  _sdl2 = dependency('sdl2')
-endif
+_sdl2 = dependency('sdl2')
 _defs = []
 
 if get_option('renderer') == 'gles'
-  if host_machine.system() == 'android'
-    _gl = cc.find_library('GLESv3', required: true )
-    _egl  = cc.find_library('EGL', required: true )
-  else
-    _gl = dependency('glesv2', required: true)
-  endif
+  _gl = dependency('glesv2', required: true)
   _defs += ['-DGLES']
 else
   _gl = dependency('gl', required: true)
 endif
 
-deps = [
-  _sdl2, 
-  _gl, 
-  _threads, 
-  glm_dep,
-  stb_dep,
-]
-
-if host_machine.system() == 'android'
-  deps += _egl
-endif
-
 sdl2_sources = files(
   'sdl2/Input.cpp',
   'sdl2/Profile.cpp',
@@ -59,7 +35,7 @@ sdl2_sources = files(
 lib_platform_sdl2 = static_library('platform_sdl2',
   sdl2_sources,
   include_directories: [platform_inc, include_directories('sdl2')],
-  dependencies: deps,
+  dependencies: [_sdl2, _gl, _threads, glm_dep, stb_dep],
   cpp_args: _defs + global_cpp_args + global_cpp_defs,
 )
 
@@ -68,7 +44,7 @@ lib_platform_sdl2 = static_library('platform_sdl2',
 render_dep = declare_dependency(
   link_with: lib_platform_sdl2,
   include_directories: [platform_inc, include_directories('sdl2')],
-  dependencies: deps,
+  dependencies: [_sdl2, _gl, _threads, glm_dep],
 )
 input_dep = render_dep
 profile_dep = render_dep

targets/platform/sdl2/Render.cpp

@@ -1,11 +1,11 @@
 #include "Render.h"
 
 #include "../PlatformTypes.h"
-#include <SDL2/SDL.h>
-#include <SDL2/SDL_error.h>
-#include <SDL2/SDL_events.h>
-#include <SDL2/SDL_stdinc.h>
-#include <SDL2/SDL_video.h>
+#include "SDL.h"
+#include "SDL_error.h"
+#include "SDL_events.h"
+#include "SDL_stdinc.h"
+#include "SDL_video.h"
 #include "gl3_loader.h"
 
 // undefine macros from header to avoid argument mismatch
@@ -41,11 +41,6 @@
 #include <dlfcn.h>
 #include <pthread.h>
 
-#ifdef __android__
-#include <android/log.h>
-#include <EGL/egl.h>
-#endif
-
 #include <cmath>
 #include <cstdio>
 #include <cstring>
@@ -56,12 +51,6 @@
 #include <utility>
 #include <vector>
 
- 
-#ifdef __android__
-#define fprintf(file, ...) ((void)__android_log_print(ANDROID_LOG_INFO, "4JRENDER", __VA_ARGS__))
-#define printf(...) ((void)__android_log_print(ANDROID_LOG_INFO, "4JRENDER", __VA_ARGS__))
-#endif
-
 C4JRender RenderManager;
 
 // MARK: Shaders
@@ -92,11 +81,6 @@ static const char* FRAG_SRC =
 // MARK: OpenGL state
 
 // Hello SDL and opengl 3.3
-#ifdef __android__
-static EGLDisplay s_eglDisplay = EGL_NO_DISPLAY;
-static EGLContext s_mainEglContext = EGL_NO_CONTEXT;
-static EGLSurface s_mainEglSurface = EGL_NO_SURFACE;
-#endif
 static SDL_Window* s_window = nullptr;
 static SDL_GLContext s_glContext = nullptr;
 static bool s_shouldClose = false;
@@ -110,14 +94,8 @@ static pthread_key_t s_glCtxKey;
 static pthread_once_t s_glCtxKeyOnce = PTHREAD_ONCE_INIT;
 static void makeGLCtxKey() { pthread_key_create(&s_glCtxKey, nullptr); }
 static const int MAX_SHARED_CTXS = 6;
-
-#ifdef __android__
-static EGLSurface s_sharedWins[MAX_SHARED_CTXS] = {};
-static EGLContext s_sharedCtxs[MAX_SHARED_CTXS] = {};
-#else
 static SDL_Window* s_sharedWins[MAX_SHARED_CTXS] = {};
 static SDL_GLContext s_sharedCtxs[MAX_SHARED_CTXS] = {};
-#endif
 static int s_sharedCtxCount = 0;
 static int s_nextSharedCtx = 0;
 static pthread_mutex_t s_sharedMtx = PTHREAD_MUTEX_INITIALIZER;
@@ -218,8 +196,7 @@ struct ShaderUniforms {
     GLint uFogDensity = -1, uFogColor = -1, uFogEnable = -1;
     GLint uLMTransform = -1, uUseLightmap = -1, uAlphaRef = -1;
     GLint uTex0 = -1, uTex1 = -1, uGlobalLM = -1;
-    GLint uUseTexture = -1;
-    GLint uInvGamma = -1;
+    GLint uUseTexture = -1, uUseTileUV = -1, uInvGamma = -1;
     GLint uChunkOffset = -1;
 
     void build(const char* vs, const char* fs) {
@@ -255,6 +232,7 @@ struct ShaderUniforms {
         L(uTex1);
         L(uGlobalLM);
         L(uUseTexture);
+        L(uUseTileUV);
         L(uInvGamma);
         L(uChunkOffset);
 #undef L
@@ -402,8 +380,8 @@ static void glShadowSetDepthTest(bool e) {
 }
 
 static void glShadowSetBlendFunc(GLint s, GLint d) {
-    if (!(s_gl_shadow_mask & SHADOW_BLEND_FUNC) ||
-        s_gl_state.blendSrc != s || s_gl_state.blendDst != d) {
+    if (!(s_gl_shadow_mask & SHADOW_BLEND_FUNC) || s_gl_state.blendSrc != s ||
+        s_gl_state.blendDst != d) {
         ::glBlendFunc(s, d);
         s_gl_state.blendSrc = s;
         s_gl_state.blendDst = d;
@@ -412,8 +390,7 @@ static void glShadowSetBlendFunc(GLint s, GLint d) {
 }
 
 static void glShadowSetDepthMask(GLboolean e) {
-    if (!(s_gl_shadow_mask & SHADOW_DEPTH_MASK) ||
-        s_gl_state.depthMask != e) {
+    if (!(s_gl_shadow_mask & SHADOW_DEPTH_MASK) || s_gl_state.depthMask != e) {
         ::glDepthMask(e);
         s_gl_state.depthMask = e;
         s_gl_shadow_mask |= SHADOW_DEPTH_MASK;
@@ -524,8 +501,7 @@ static void pushRenderState() {
             glUniform1f(s_shader.uFogStart, s_rs.fogStart);
             glUniform1f(s_shader.uFogEnd, s_rs.fogEnd);
             glUniform1f(s_shader.uFogDensity, s_rs.fogDensity);
-            glUniform4fv(s_shader.uFogColor, 1,
-                         glm::value_ptr(s_rs.fogColor));
+            glUniform4fv(s_shader.uFogColor, 1, glm::value_ptr(s_rs.fogColor));
             glUniform1i(s_shader.uFogEnable, s_rs.fogEnable ? 1 : 0);
         }
         if (s_rs_dirty_mask & DIRTY_TEXTURE) {
@@ -537,11 +513,9 @@ static void pushRenderState() {
         if (s_rs_dirty_mask & DIRTY_GAMMA)
             glUniform1f(s_shader.uInvGamma, 1.0f / s_rs.gamma);
         if (s_rs_dirty_mask & DIRTY_LMT)
-            glUniform4fv(s_shader.uLMTransform, 1,
-                         glm::value_ptr(s_rs.lmt));
+            glUniform4fv(s_shader.uLMTransform, 1, glm::value_ptr(s_rs.lmt));
         if (s_rs_dirty_mask & DIRTY_GLOBAL_LM)
-            glUniform2fv(s_shader.uGlobalLM, 1,
-                         glm::value_ptr(s_rs.globalLM));
+            glUniform2fv(s_shader.uGlobalLM, 1, glm::value_ptr(s_rs.globalLM));
         s_rs_dirty_mask = 0;
     }
     flushMatrices();
@@ -578,6 +552,7 @@ struct ChunkDrawCall {
     GLenum prim;
     GLint first;
     GLsizei count;
+    bool useTileUV;
 };
 
 struct ChunkBuffer {
@@ -669,9 +644,6 @@ void C4JRender::Initialise() {
     SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
     SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
     SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
-#ifdef __android__
-    SDL_SetHint(SDL_HINT_ORIENTATIONS, "LandscapeLeft LandscapeRight");
-#endif 
     Uint32 wf = SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE;
     if (s_fullscreen) wf |= SDL_WINDOW_FULLSCREEN_DESKTOP;
     s_window = SDL_CreateWindow("Minecraft Console Edition",
@@ -711,50 +683,16 @@ void C4JRender::Initialise() {
     s_mainThread = pthread_self();
     s_mainThreadSet = true;
     pthread_setspecific(s_glCtxKey, (void*)s_window);
-
-#ifdef __android__
-    s_eglDisplay = eglGetCurrentDisplay(); 
-
-    EGLint pb_atr[] = {
-        EGL_WIDTH, 1,
-        EGL_HEIGHT, 1,
-        EGL_NONE
-    };
-
-    EGLint cfg_id;
-    if (!eglQueryContext(s_eglDisplay, (EGLContext)s_glContext, EGL_CONFIG_ID, &cfg_id)) 
-    {
-        printf("BRUH\n");
-    }
-    
-    EGLConfig cfg;
-    EGLint cfgs;
-    EGLint atrs[] = { EGL_CONFIG_ID, cfg_id, EGL_NONE };
-
-    eglChooseConfig(s_eglDisplay, atrs, &cfg, 1, &cfgs);
-#endif
-
     SDL_GL_MakeCurrent(s_window, s_glContext);
     for (int i = 0; i < MAX_SHARED_CTXS; i++) {
         SDL_GL_SetAttribute(SDL_GL_SHARE_WITH_CURRENT_CONTEXT, 1);
-#ifndef __android__
         SDL_Window* w = SDL_CreateWindow("", SDL_WINDOWPOS_UNDEFINED,
                                          SDL_WINDOWPOS_UNDEFINED, 1, 1,
                                          SDL_WINDOW_HIDDEN | SDL_WINDOW_OPENGL);
         if (!w) break;
         SDL_GLContext ctx = SDL_GL_CreateContext(w);
-#else
-        EGLint ctx_atr[] = { EGL_CONTEXT_CLIENT_VERSION, 3, EGL_NONE };
-        EGLContext ctx = eglCreateContext(s_eglDisplay, cfg, (EGLContext)s_glContext, ctx_atr);
-        EGLSurface w = eglCreatePbufferSurface(s_eglDisplay, cfg, pb_atr);
-        if ( w == EGL_NO_SURFACE ) {
-            printf("EGL_NO_SURFACE: %d\n", eglGetError() );
-        }
-#endif
         if (!ctx) {
-#ifndef __android__
             SDL_DestroyWindow(w);
-#endif
             break;
         }
         s_sharedWins[s_sharedCtxCount] = w;
@@ -781,18 +719,10 @@ void C4JRender::InitialiseContext() {
     }
     void* cp = pthread_getspecific(s_glCtxKey);
     if (cp) {
-#ifdef __android__
-        EGLContext ctx = (EGLContext)cp;
-#else
         SDL_GLContext ctx = (SDL_GLContext)cp;
-#endif
         for (int i = 0; i < s_sharedCtxCount; i++)
             if (s_sharedCtxs[i] == ctx) {
-#ifdef __android__
-                eglMakeCurrent(s_eglDisplay, s_sharedWins[i], s_sharedWins[i], ctx );
-#else
                 SDL_GL_MakeCurrent(s_sharedWins[i], ctx);
-#endif
                 return;
             }
         return;
@@ -805,11 +735,7 @@ void C4JRender::InitialiseContext() {
     if (!shared) return;
     for (int i = 0; i < s_sharedCtxCount; i++)
         if (s_sharedCtxs[i] == shared)
-#ifdef __android__
-            eglMakeCurrent(s_eglDisplay, s_sharedWins[i],  s_sharedWins[i], shared );
-#else
             SDL_GL_MakeCurrent(s_sharedWins[i], shared);
-#endif
     pthread_setspecific(s_glCtxKey, (void*)shared);
 }
 
@@ -872,14 +798,8 @@ void C4JRender::Shutdown() {
         s_window = nullptr;
     }
     for (int i = 0; i < s_sharedCtxCount; i++) {
-#ifdef __android__
-        eglMakeCurrent(s_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
-        if (s_sharedCtxs[i]) eglDestroySurface(s_eglDisplay, s_sharedWins[i]);
-        if (s_sharedWins[i]) eglDestroyContext(s_eglDisplay, s_sharedCtxs[i]);
-#else
         if (s_sharedCtxs[i]) SDL_GL_DeleteContext(s_sharedCtxs[i]);
         if (s_sharedWins[i]) SDL_DestroyWindow(s_sharedWins[i]);
-#endif
     }
     SDL_Quit();
 }
@@ -970,13 +890,17 @@ void C4JRender::DrawVertices(ePrimitiveType ptype, int count, void* dataIn,
         int first = (int)(s_recVerts.size() / stride);
         s_recVerts.insert(s_recVerts.end(), (const uint8_t*)dataIn,
                           (const uint8_t*)dataIn + bytes);
-        s_recDraws.push_back({glMode, first, (GLsizei)count});
+        bool useTileUV = (vType == VERTEX_TYPE_PF3_TF2_CB4_NB4_XW1_TILEUV);
+        s_recDraws.push_back({glMode, first, (GLsizei)count, useTileUV});
         return;
     }
 
     pthread_mutex_lock(&s_glCallMtx);
     pushRenderState();
 
+    glUniform1i(s_shader.uUseTileUV,
+                (vType == VERTEX_TYPE_PF3_TF2_CB4_NB4_XW1_TILEUV) ? 1 : 0);
+
     glBindVertexArray(s_sVAO_std);
     glBindBuffer(GL_ARRAY_BUFFER, s_sVBO_std);
 
@@ -1096,7 +1020,10 @@ bool C4JRender::CBuffCall(int index, bool) {
     pushRenderState();
 
     glBindVertexArray(cb.vao);
-    for (const auto& dc : cb.draws) glDrawArrays(dc.prim, dc.first, dc.count);
+    for (const auto& dc : cb.draws) {
+        glUniform1i(s_shader.uUseTileUV, dc.useTileUV ? 1 : 0);
+        glDrawArrays(dc.prim, dc.first, dc.count);
+    }
     glBindVertexArray(0);
 
     pthread_mutex_unlock(&s_glCallMtx);
@@ -1172,7 +1099,7 @@ void C4JRender::Set_matrixDirty() {
     s_boundProgram = 0;
     s_rs_dirty_mask = 0xFFFFFFFF;
     s_gl_shadow_mask = 0;
-    s_normalMatDirty = true; // normal matrix dirt after iggy reset
+    s_normalMatDirty = true;  // normal matrix dirt after iggy reset
     s_matDirty = true;
     s_chunkOffsetValid = false;
     if (s_shader.prog) {
@@ -1209,9 +1136,7 @@ void C4JRender::StateSetDepthMask(bool e) {
     glShadowSetDepthMask(e ? GL_TRUE : GL_FALSE);
 }
 void C4JRender::StateSetBlendEnable(bool e) { glShadowSetBlend(e); }
-void C4JRender::StateSetBlendFunc(int s, int d) {
-    glShadowSetBlendFunc(s, d);
-}
+void C4JRender::StateSetBlendFunc(int s, int d) { glShadowSetBlendFunc(s, d); }
 void C4JRender::StateSetDepthFunc(int f) { ::glDepthFunc(f); }
 void C4JRender::StateSetFaceCull(bool e) { glShadowSetCull(e); }
 void C4JRender::StateSetFaceCullCW(bool e) {
@@ -1258,7 +1183,10 @@ void C4JRender::StateSetFogEnable(bool e) {
     }
 }
 void C4JRender::StateSetFogMode(int mode) {
-    int v = (mode == GL_LINEAR) ? 1 : (mode == GL_EXP) ? 2 : (mode == 0x0801) ? 3 : 0;
+    int v = (mode == GL_LINEAR) ? 1
+            : (mode == GL_EXP)  ? 2
+            : (mode == 0x0801)  ? 3
+                                : 0;
     if (s_rs.fogMode != v) {
         s_rs.fogMode = v;
         markDirty(DIRTY_FOG);
@@ -1380,9 +1308,9 @@ void C4JRender::TextureBindVertex(int idx, bool scaleLight) {
         s_rs.useLightmap = true;
         markDirty(DIRTY_TEXTURE);
     }
-    glm::vec4 newLmt =
-        scaleLight ? glm::vec4{1.f, 1.f, 8.f / 256.f, 8.f / 256.f}
-                   : glm::vec4{1.f, 1.f, 0.f, 0.f};
+    glm::vec4 newLmt = scaleLight
+                           ? glm::vec4{1.f, 1.f, 8.f / 256.f, 8.f / 256.f}
+                           : glm::vec4{1.f, 1.f, 0.f, 0.f};
     if (s_rs.lmt != newLmt) {
         s_rs.lmt = newLmt;
         markDirty(DIRTY_LMT);

targets/platform/sdl2/Render.h

@@ -2,12 +2,8 @@
 
 #include "gl3_loader.h"
 // NOTE: gl3_loader.h must be included before these two
-#ifdef GLES
-#include <GLES3/gl3.h>
-#else
 #include <GL/gl.h>
 #include <GL/glu.h>
-#endif
 
 #include <cstdint>
 #include <cstdlib>
@@ -390,34 +386,6 @@ extern C4JRender RenderManager;
 #define GL_TRIANGLE_STRIP 0x0005
 #endif
 
-// These constants do not exist on the GLES, 
-// so for now it is just stub
-#ifdef GLES
-
-#ifndef GL_COLOR_MATERIAL
-#define GL_COLOR_MATERIAL 0x0B57
-#endif
-#ifndef GL_RESCALE_NORMAL
-#define GL_RESCALE_NORMAL 0x803A
-#endif
-#ifndef GL_NORMALIZE
-#define GL_NORMALIZE 0x0BA1
-#endif
-#ifndef GL_POLYGON_OFFSET_LINE
-#define GL_POLYGON_OFFSET_LINE 0x2A02
-#endif
-#ifndef GL_AMBIENT_AND_DIFFUSE
-#define GL_AMBIENT_AND_DIFFUSE 0x1602
-#endif
-
-extern "C" {
-void glShadeModel(GLenum);
-void glColorMaterial(GLenum, GLenum);
-void glNormal3f(GLfloat, GLfloat, GLfloat);
-void glTexGeni(GLenum, GLenum, GLint);
-} 
-#endif
-
 // glCallList / display list macros
 #undef glNewList
 #define glNewList(_list, _mode) RenderManager.CBuffStart(_list)
@@ -758,7 +726,3 @@ void glGetQueryObjectu_4J_Helper(unsigned int id, unsigned int pname,
 #define glLight(a, b, c) glLight_4J(a, b, c)
 #define glLightModel(a, b) glLightModel_4J(a, b)
 #define glTexGen(a, b, c) glTexGen_4J(a, b, c)
-
-#ifdef GLES
-#define glClearDepth(a) glClearDepthf((float)a)
-#endif

targets/platform/sdl2/gl3_loader.h

@@ -2,13 +2,9 @@
 #ifndef GL_GLEXT_PROTOTYPES
 #define GL_GLEXT_PROTOTYPES 1
 #endif
-#ifdef GLES
-#include <GLES3/gl3.h>
-#include <GLES3/gl3ext.h>
-#else
 #include <GL/gl.h>
 #include <GL/glext.h>
-#endif
+#include <SDL2/SDL.h>
 
 #include <cstdio>
 #ifndef GL_ARRAY_BUFFER

targets/platform/sdl2/shaders/fragment.frag

@@ -1,22 +1,113 @@
-R"GLSL(
+R "GLSL(
 #version 330 core
 uniform sampler2D uTex0;
 uniform sampler2D uTex1;
-uniform int   uUseTexture;
-uniform int   uUseLightmap;
+uniform int uUseTexture;
+uniform int uUseTileUV;
+uniform int uUseLightmap;
 uniform float uAlphaRef;
-uniform vec4  uFogColor;
-uniform int   uFogEnable;
+uniform vec4 uFogColor;
+uniform int uFogEnable;
 uniform float uInvGamma;
 
-in  vec2  vUV0;
-in  vec2  vUV1;
-in  vec4  vColor;
-in  float vFogFactor;
-out vec4  oColor;
+in vec2 vUV0;
+in vec2 vUV1;
+in vec4 vColor;
+in vec3 vWorldPos;
+in float vFogFactor;
+out vec4 oColor;
 
 void main() {
-    vec4 texColor = (uUseTexture != 0) ? texture(uTex0, vUV0) : vec4(1.0);
+    vec2 uv = vUV0;
+    vec2 dUVdx = vec2(0.0);
+    vec2 dUVdy = vec2(0.0);
+    bool useGrad = false;
+    bool disableMipmap = false;
+
+    if (uUseTileUV != 0) {
+        vec2 baseUV = vUV0;
+        if (baseUV.x > 1.0) {
+            baseUV.x -= 1.0;
+            disableMipmap = true;
+        }
+        if (baseUV.y > 1.0) {
+            baseUV.y -= 1.0;
+            disableMipmap = true;
+        }
+
+        vec2 atlasSize = vec2(textureSize(uTex0, 0));
+        float tileSize = 16.0;
+        vec2 cell = floor(baseUV * atlasSize / tileSize);
+        vec2 uv0 = cell * tileSize / atlasSize;
+        vec2 cellSize = vec2(tileSize) / atlasSize;
+
+        vec3 dpdx = dFdx(vWorldPos);
+        vec3 dpdy = dFdy(vWorldPos);
+        vec3 n = normalize(cross(dpdx, dpdy));
+
+        vec3 uAxis;
+        vec3 vAxis;
+        if (abs(n.y) > abs(n.x) && abs(n.y) > abs(n.z)) {
+            uAxis = vec3(1.0, 0.0, 0.0);
+            vAxis = vec3(0.0, 0.0, 1.0);
+        } else if (abs(n.z) > abs(n.x)) {
+            uAxis = vec3(1.0, 0.0, 0.0);
+            vAxis = vec3(0.0, 1.0, 0.0);
+        } else {
+            uAxis = vec3(0.0, 0.0, 1.0);
+            vAxis = vec3(0.0, 1.0, 0.0);
+        }
+
+        float du = dot(vWorldPos, uAxis);
+        float dv = dot(vWorldPos, vAxis);
+
+        vec2 gradU = vec2(dot(dpdx, uAxis), dot(dpdy, uAxis));
+        vec2 gradV = vec2(dot(dpdx, vAxis), dot(dpdy, vAxis));
+        vec2 gradUx = vec2(dFdx(baseUV.x), dFdy(baseUV.x));
+        vec2 gradUy = vec2(dFdx(baseUV.y), dFdy(baseUV.y));
+
+        float corrUx = dot(gradUx, gradU);
+        float corrVx = dot(gradUx, gradV);
+        bool swap = abs(corrVx) > abs(corrUx);
+
+        float signU = swap ? corrVx : corrUx;
+        float corrUy = dot(gradUy, gradU);
+        float corrVy = dot(gradUy, gradV);
+        float signV = swap ? corrUy : corrVy;
+
+        float tu = swap ? dv : du;
+        float tv = swap ? du : dv;
+
+        float dtu_dx = swap ? dot(dpdx, vAxis) : dot(dpdx, uAxis);
+        float dtu_dy = swap ? dot(dpdy, vAxis) : dot(dpdy, uAxis);
+        float dtv_dx = swap ? dot(dpdx, uAxis) : dot(dpdx, vAxis);
+        float dtv_dy = swap ? dot(dpdy, uAxis) : dot(dpdy, vAxis);
+
+        if (signU < 0.0) {
+            tu = -tu;
+            dtu_dx = -dtu_dx;
+            dtu_dy = -dtu_dy;
+        }
+        if (signV < 0.0) {
+            tv = -tv;
+            dtv_dx = -dtv_dx;
+            dtv_dy = -dtv_dy;
+        }
+
+        uv = uv0 + fract(vec2(tu, tv)) * cellSize;
+        dUVdx = vec2(dtu_dx, dtv_dx) * cellSize;
+        dUVdy = vec2(dtu_dy, dtv_dy) * cellSize;
+        useGrad = true;
+    }
+
+    vec4 texColor = vec4(1.0);
+    if (uUseTexture != 0) {
+        if (useGrad) {
+            texColor = disableMipmap ? textureLod(uTex0, uv, 0.0) : textureGrad(uTex0, uv, dUVdx, dUVdy);
+        } else {
+            texColor = texture(uTex0, uv);
+        }
+    }
     vec4 c = texColor * vColor;
     if (c.a < uAlphaRef) discard;
     if (uUseLightmap != 0) c.rgb *= texture(uTex1, vUV1).rgb;
@@ -26,4 +117,5 @@ void main() {
 
     oColor = c;
 }
-)GLSL";
+) GLSL ";
+

targets/platform/sdl2/shaders/fragment_es.frag

@@ -1,25 +1,116 @@
-R"GLSL(
+R "GLSL(
 #version 300 es
 precision mediump float;
 precision mediump int;
 
 uniform sampler2D uTex0;
 uniform sampler2D uTex1;
-uniform int   uUseTexture;
-uniform int   uUseLightmap;
+uniform int uUseTexture;
+uniform int uUseTileUV;
+uniform int uUseLightmap;
 uniform float uAlphaRef;
-uniform vec4  uFogColor;
-uniform int   uFogEnable;
+uniform vec4 uFogColor;
+uniform int uFogEnable;
 uniform float uInvGamma;
 
-in  vec2  vUV0;
-in  vec2  vUV1;
-in  vec4  vColor;
-in  float vFogFactor;
-out vec4  oColor;
+in vec2 vUV0;
+in vec2 vUV1;
+in vec4 vColor;
+in vec3 vWorldPos;
+in float vFogFactor;
+out vec4 oColor;
 
 void main() {
-    vec4 texColor = (uUseTexture != 0) ? texture(uTex0, vUV0) : vec4(1.0);
+    vec2 uv = vUV0;
+    vec2 dUVdx = vec2(0.0);
+    vec2 dUVdy = vec2(0.0);
+    bool useGrad = false;
+    bool disableMipmap = false;
+
+    if (uUseTileUV != 0) {
+        vec2 baseUV = vUV0;
+        if (baseUV.x > 1.0) {
+            baseUV.x -= 1.0;
+            disableMipmap = true;
+        }
+        if (baseUV.y > 1.0) {
+            baseUV.y -= 1.0;
+            disableMipmap = true;
+        }
+
+        vec2 atlasSize = vec2(textureSize(uTex0, 0));
+        float tileSize = 16.0;
+        vec2 cell = floor(baseUV * atlasSize / tileSize);
+        vec2 uv0 = cell * tileSize / atlasSize;
+        vec2 cellSize = vec2(tileSize) / atlasSize;
+
+        vec3 dpdx = dFdx(vWorldPos);
+        vec3 dpdy = dFdy(vWorldPos);
+        vec3 n = normalize(cross(dpdx, dpdy));
+
+        vec3 uAxis;
+        vec3 vAxis;
+        if (abs(n.y) > abs(n.x) && abs(n.y) > abs(n.z)) {
+            uAxis = vec3(1.0, 0.0, 0.0);
+            vAxis = vec3(0.0, 0.0, 1.0);
+        } else if (abs(n.z) > abs(n.x)) {
+            uAxis = vec3(1.0, 0.0, 0.0);
+            vAxis = vec3(0.0, 1.0, 0.0);
+        } else {
+            uAxis = vec3(0.0, 0.0, 1.0);
+            vAxis = vec3(0.0, 1.0, 0.0);
+        }
+
+        float du = dot(vWorldPos, uAxis);
+        float dv = dot(vWorldPos, vAxis);
+
+        vec2 gradU = vec2(dot(dpdx, uAxis), dot(dpdy, uAxis));
+        vec2 gradV = vec2(dot(dpdx, vAxis), dot(dpdy, vAxis));
+        vec2 gradUx = vec2(dFdx(baseUV.x), dFdy(baseUV.x));
+        vec2 gradUy = vec2(dFdx(baseUV.y), dFdy(baseUV.y));
+
+        float corrUx = dot(gradUx, gradU);
+        float corrVx = dot(gradUx, gradV);
+        bool swap = abs(corrVx) > abs(corrUx);
+
+        float signU = swap ? corrVx : corrUx;
+        float corrUy = dot(gradUy, gradU);
+        float corrVy = dot(gradUy, gradV);
+        float signV = swap ? corrUy : corrVy;
+
+        float tu = swap ? dv : du;
+        float tv = swap ? du : dv;
+
+        float dtu_dx = swap ? dot(dpdx, vAxis) : dot(dpdx, uAxis);
+        float dtu_dy = swap ? dot(dpdy, vAxis) : dot(dpdy, uAxis);
+        float dtv_dx = swap ? dot(dpdx, uAxis) : dot(dpdx, vAxis);
+        float dtv_dy = swap ? dot(dpdy, uAxis) : dot(dpdy, vAxis);
+
+        if (signU < 0.0) {
+            tu = -tu;
+            dtu_dx = -dtu_dx;
+            dtu_dy = -dtu_dy;
+        }
+        if (signV < 0.0) {
+            tv = -tv;
+            dtv_dx = -dtv_dx;
+            dtv_dy = -dtv_dy;
+        }
+
+        uv = uv0 + fract(vec2(tu, tv)) * cellSize;
+        dUVdx = vec2(dtu_dx, dtv_dx) * cellSize;
+        dUVdy = vec2(dtu_dy, dtv_dy) * cellSize;
+        useGrad = true;
+    }
+
+    vec4 texColor = vec4(1.0);
+    if (uUseTexture != 0) {
+        if (useGrad) {
+            texColor = disableMipmap ? textureLod(uTex0, uv, 0.0) : textureGrad(uTex0, uv, dUVdx, dUVdy);
+        } else {
+            texColor = texture(uTex0, uv);
+        }
+    }
     vec4 c = texColor * vColor;
     if (c.a < uAlphaRef) discard;
     if (uUseLightmap != 0) c.rgb *= texture(uTex1, vUV1).rgb;
@@ -29,4 +120,5 @@ void main() {
 
     oColor = c;
 }
-)GLSL";
+) GLSL ";
+

targets/platform/sdl2/shaders/vertex.vert

@@ -1,40 +1,43 @@
-R"GLSL(
+R "GLSL(
 #version 330 core
-layout(location=0) in vec3  aPos;
-layout(location=1) in vec2  aUV0;
-layout(location=2) in vec4  aColor;
-layout(location=3) in vec3  aNormal;
-layout(location=4) in ivec2 aLMraw;
+layout(location = 0) in vec3 aPos;
+layout(location = 1) in vec2 aUV0;
+layout(location = 2) in vec4 aColor;
+layout(location = 3) in vec3 aNormal;
+layout(location = 4) in ivec2 aLMraw;
 
-uniform mat4  uMVP;
-uniform mat4  uMV;
-uniform mat3  uNormalMatrix;
+uniform mat4 uMVP;
+uniform mat4 uMV;
+uniform mat3 uNormalMatrix;
 uniform float uNormalSign;
-uniform mat4  uTexMat0;
-uniform vec4  uBaseColor;
-uniform int   uLighting;
-uniform vec3  uLight0Dir;
-uniform vec3  uLight1Dir;
-uniform vec3  uLightDiffuse;
-uniform vec3  uLightAmbient;
-uniform vec3  uChunkOffset;
-uniform int   uFogMode;
+uniform mat4 uTexMat0;
+uniform vec4 uBaseColor;
+uniform int uLighting;
+uniform vec3 uLight0Dir;
+uniform vec3 uLight1Dir;
+uniform vec3 uLightDiffuse;
+uniform vec3 uLightAmbient;
+uniform vec3 uChunkOffset;
+uniform int uFogMode;
 uniform float uFogStart;
 uniform float uFogEnd;
 uniform float uFogDensity;
-uniform vec4  uLMTransform;
-uniform vec2  uGlobalLM;
+uniform vec4 uLMTransform;
+uniform vec2 uGlobalLM;
 
-out vec2  vUV0;
-out vec2  vUV1;
-out vec4  vColor;
+out vec2 vUV0;
+out vec2 vUV1;
+out vec4 vColor;
+out vec3 vWorldPos;
 out float vFogFactor;
 
 void main() {
-    vec4 aPos4   = vec4(aPos + uChunkOffset, 1.0);
-    vec4 eyePos  = uMV  * aPos4;
-    gl_Position  = uMVP * aPos4;
-    vUV0 = (uTexMat0 * vec4(aUV0, 0.0, 1.0)).xy; 
+    vec3 worldPos = aPos + uChunkOffset;
+    vec4 aPos4 = vec4(worldPos, 1.0);
+    vec4 eyePos = uMV * aPos4;
+    gl_Position = uMVP * aPos4;
+    vUV0 = (uTexMat0 * vec4(aUV0, 0.0, 1.0)).xy;
+    vWorldPos = worldPos;
 
     vec2 lm = (aLMraw.x <= -500) ? uGlobalLM : vec2(aLMraw);
     vUV1 = (lm / 256.0) * uLMTransform.xy + uLMTransform.zw;
@@ -52,9 +55,13 @@ void main() {
     }
 
     float eDist = length(eyePos.xyz);
-    if      (uFogMode == 1) vFogFactor = clamp((uFogEnd - eDist) / max(uFogEnd - uFogStart, 1e-4), 0.0, 1.0);
+    if (uFogMode == 1) vFogFactor = clamp((uFogEnd - eDist) / max(uFogEnd - uFogStart, 1e-4), 0.0, 1.0);
     else if (uFogMode == 2) vFogFactor = clamp(exp(-uFogDensity * eDist), 0.0, 1.0);
-    else if (uFogMode == 3) { float d = uFogDensity * eDist; vFogFactor = clamp(exp(-d*d), 0.0, 1.0); }
-    else                    vFogFactor = 1.0;
+    else if (uFogMode == 3) {
+        float d = uFogDensity * eDist;
+        vFogFactor = clamp(exp(-d * d), 0.0, 1.0);
+    }
+    else vFogFactor = 1.0;
 }
-)GLSL";
+) GLSL ";
+

targets/platform/sdl2/shaders/vertex_es.vert

@@ -1,43 +1,46 @@
-R"GLSL(
+R "GLSL(
 #version 300 es
 precision highp float;
 precision highp int;
 
-layout(location=0) in vec3  aPos;
-layout(location=1) in vec2  aUV0;
-layout(location=2) in vec4  aColor;
-layout(location=3) in vec3  aNormal;
-layout(location=4) in ivec2 aLMraw;
+layout(location = 0) in vec3 aPos;
+layout(location = 1) in vec2 aUV0;
+layout(location = 2) in vec4 aColor;
+layout(location = 3) in vec3 aNormal;
+layout(location = 4) in ivec2 aLMraw;
 
-uniform mat4  uMVP;
-uniform mat4  uMV;
-uniform mat3  uNormalMatrix;
+uniform mat4 uMVP;
+uniform mat4 uMV;
+uniform mat3 uNormalMatrix;
 uniform float uNormalSign;
-uniform mat4  uTexMat0;
-uniform vec4  uBaseColor;
-uniform int   uLighting;
-uniform vec3  uLight0Dir;
-uniform vec3  uLight1Dir;
-uniform vec3  uLightDiffuse;
-uniform vec3  uLightAmbient;
-uniform vec3  uChunkOffset;
-uniform int   uFogMode;
+uniform mat4 uTexMat0;
+uniform vec4 uBaseColor;
+uniform int uLighting;
+uniform vec3 uLight0Dir;
+uniform vec3 uLight1Dir;
+uniform vec3 uLightDiffuse;
+uniform vec3 uLightAmbient;
+uniform vec3 uChunkOffset;
+uniform int uFogMode;
 uniform float uFogStart;
 uniform float uFogEnd;
 uniform float uFogDensity;
-uniform vec4  uLMTransform;
-uniform vec2  uGlobalLM;
+uniform vec4 uLMTransform;
+uniform vec2 uGlobalLM;
 
-out vec2  vUV0;
-out vec2  vUV1;
-out vec4  vColor;
+out vec2 vUV0;
+out vec2 vUV1;
+out vec4 vColor;
+out vec3 vWorldPos;
 out float vFogFactor;
 
 void main() {
-    vec4 aPos4   = vec4(aPos + uChunkOffset, 1.0);
-    vec4 eyePos  = uMV  * aPos4;
-    gl_Position  = uMVP * aPos4;
-    vUV0 = (uTexMat0 * vec4(aUV0, 0.0, 1.0)).xy; 
+    vec3 worldPos = aPos + uChunkOffset;
+    vec4 aPos4 = vec4(worldPos, 1.0);
+    vec4 eyePos = uMV * aPos4;
+    gl_Position = uMVP * aPos4;
+    vUV0 = (uTexMat0 * vec4(aUV0, 0.0, 1.0)).xy;
+    vWorldPos = worldPos;
 
     vec2 lm = (aLMraw.x <= -500) ? uGlobalLM : vec2(aLMraw);
     vUV1 = (lm / 256.0) * uLMTransform.xy + uLMTransform.zw;
@@ -55,9 +58,13 @@ void main() {
     }
 
     float eDist = length(eyePos.xyz);
-    if      (uFogMode == 1) vFogFactor = clamp((uFogEnd - eDist) / max(uFogEnd - uFogStart, 1e-4), 0.0, 1.0);
+    if (uFogMode == 1) vFogFactor = clamp((uFogEnd - eDist) / max(uFogEnd - uFogStart, 1e-4), 0.0, 1.0);
     else if (uFogMode == 2) vFogFactor = clamp(exp(-uFogDensity * eDist), 0.0, 1.0);
-    else if (uFogMode == 3) { float d = uFogDensity * eDist; vFogFactor = clamp(exp(-d*d), 0.0, 1.0); }
-    else                    vFogFactor = 1.0;
+    else if (uFogMode == 3) {
+        float d = uFogDensity * eDist;
+        vFogFactor = clamp(exp(-d * d), 0.0, 1.0);
+    }
+    else vFogFactor = 1.0;
 }
-)GLSL";
+) GLSL ";
+

thirdparty/include/android/SDL2/SDL.h

@@ -1,234 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL.h
- *
- *  Main include header for the SDL library
- */
-
-#ifndef SDL_h_
-#define SDL_h_
-
-#include "SDL_main.h"
-#include "SDL_stdinc.h"
-#include "SDL_assert.h"
-#include "SDL_atomic.h"
-#include "SDL_audio.h"
-#include "SDL_clipboard.h"
-#include "SDL_cpuinfo.h"
-#include "SDL_endian.h"
-#include "SDL_error.h"
-#include "SDL_events.h"
-#include "SDL_filesystem.h"
-#include "SDL_gamecontroller.h"
-#include "SDL_guid.h"
-#include "SDL_haptic.h"
-#include "SDL_hidapi.h"
-#include "SDL_hints.h"
-#include "SDL_joystick.h"
-#include "SDL_loadso.h"
-#include "SDL_log.h"
-#include "SDL_messagebox.h"
-#include "SDL_metal.h"
-#include "SDL_mutex.h"
-#include "SDL_power.h"
-#include "SDL_render.h"
-#include "SDL_rwops.h"
-#include "SDL_sensor.h"
-#include "SDL_shape.h"
-#include "SDL_system.h"
-#include "SDL_thread.h"
-#include "SDL_timer.h"
-#include "SDL_version.h"
-#include "SDL_video.h"
-#include "SDL_locale.h"
-#include "SDL_misc.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* WIKI CATEGORY: Init */
-
-/* As of version 0.5, SDL is loaded dynamically into the application */
-
-/**
- *  \name SDL_INIT_*
- *
- *  These are the flags which may be passed to SDL_Init().  You should
- *  specify the subsystems which you will be using in your application.
- */
-/* @{ */
-#define SDL_INIT_TIMER          0x00000001u
-#define SDL_INIT_AUDIO          0x00000010u
-#define SDL_INIT_VIDEO          0x00000020u  /**< SDL_INIT_VIDEO implies SDL_INIT_EVENTS */
-#define SDL_INIT_JOYSTICK       0x00000200u  /**< SDL_INIT_JOYSTICK implies SDL_INIT_EVENTS */
-#define SDL_INIT_HAPTIC         0x00001000u
-#define SDL_INIT_GAMECONTROLLER 0x00002000u  /**< SDL_INIT_GAMECONTROLLER implies SDL_INIT_JOYSTICK */
-#define SDL_INIT_EVENTS         0x00004000u
-#define SDL_INIT_SENSOR         0x00008000u
-#define SDL_INIT_NOPARACHUTE    0x00100000u  /**< compatibility; this flag is ignored. */
-#define SDL_INIT_EVERYTHING ( \
-                SDL_INIT_TIMER | SDL_INIT_AUDIO | SDL_INIT_VIDEO | SDL_INIT_EVENTS | \
-                SDL_INIT_JOYSTICK | SDL_INIT_HAPTIC | SDL_INIT_GAMECONTROLLER | SDL_INIT_SENSOR \
-            )
-/* @} */
-
-/**
- * Initialize the SDL library.
- *
- * SDL_Init() simply forwards to calling SDL_InitSubSystem(). Therefore, the
- * two may be used interchangeably. Though for readability of your code
- * SDL_InitSubSystem() might be preferred.
- *
- * The file I/O (for example: SDL_RWFromFile) and threading (SDL_CreateThread)
- * subsystems are initialized by default. Message boxes
- * (SDL_ShowSimpleMessageBox) also attempt to work without initializing the
- * video subsystem, in hopes of being useful in showing an error dialog when
- * SDL_Init fails. You must specifically initialize other subsystems if you
- * use them in your application.
- *
- * Logging (such as SDL_Log) works without initialization, too.
- *
- * `flags` may be any of the following OR'd together:
- *
- * - `SDL_INIT_TIMER`: timer subsystem
- * - `SDL_INIT_AUDIO`: audio subsystem
- * - `SDL_INIT_VIDEO`: video subsystem; automatically initializes the events
- *   subsystem
- * - `SDL_INIT_JOYSTICK`: joystick subsystem; automatically initializes the
- *   events subsystem
- * - `SDL_INIT_HAPTIC`: haptic (force feedback) subsystem
- * - `SDL_INIT_GAMECONTROLLER`: controller subsystem; automatically
- *   initializes the joystick subsystem
- * - `SDL_INIT_EVENTS`: events subsystem
- * - `SDL_INIT_EVERYTHING`: all of the above subsystems
- * - `SDL_INIT_NOPARACHUTE`: compatibility; this flag is ignored
- *
- * Subsystem initialization is ref-counted, you must call SDL_QuitSubSystem()
- * for each SDL_InitSubSystem() to correctly shutdown a subsystem manually (or
- * call SDL_Quit() to force shutdown). If a subsystem is already loaded then
- * this call will increase the ref-count and return.
- *
- * \param flags subsystem initialization flags.
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_InitSubSystem
- * \sa SDL_Quit
- * \sa SDL_SetMainReady
- * \sa SDL_WasInit
- */
-extern DECLSPEC int SDLCALL SDL_Init(Uint32 flags);
-
-/**
- * Compatibility function to initialize the SDL library.
- *
- * In SDL2, this function and SDL_Init() are interchangeable.
- *
- * \param flags any of the flags used by SDL_Init(); see SDL_Init for details.
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Init
- * \sa SDL_Quit
- * \sa SDL_QuitSubSystem
- */
-extern DECLSPEC int SDLCALL SDL_InitSubSystem(Uint32 flags);
-
-/**
- * Shut down specific SDL subsystems.
- *
- * If you start a subsystem using a call to that subsystem's init function
- * (for example SDL_VideoInit()) instead of SDL_Init() or SDL_InitSubSystem(),
- * SDL_QuitSubSystem() and SDL_WasInit() will not work. You will need to use
- * that subsystem's quit function (SDL_VideoQuit()) directly instead. But
- * generally, you should not be using those functions directly anyhow; use
- * SDL_Init() instead.
- *
- * You still need to call SDL_Quit() even if you close all open subsystems
- * with SDL_QuitSubSystem().
- *
- * \param flags any of the flags used by SDL_Init(); see SDL_Init for details.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_InitSubSystem
- * \sa SDL_Quit
- */
-extern DECLSPEC void SDLCALL SDL_QuitSubSystem(Uint32 flags);
-
-/**
- * Get a mask of the specified subsystems which are currently initialized.
- *
- * \param flags any of the flags used by SDL_Init(); see SDL_Init for details.
- * \returns a mask of all initialized subsystems if `flags` is 0, otherwise it
- *          returns the initialization status of the specified subsystems.
- *
- *          The return value does not include SDL_INIT_NOPARACHUTE.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Init
- * \sa SDL_InitSubSystem
- */
-extern DECLSPEC Uint32 SDLCALL SDL_WasInit(Uint32 flags);
-
-/**
- * Clean up all initialized subsystems.
- *
- * You should call this function even if you have already shutdown each
- * initialized subsystem with SDL_QuitSubSystem(). It is safe to call this
- * function even in the case of errors in initialization.
- *
- * If you start a subsystem using a call to that subsystem's init function
- * (for example SDL_VideoInit()) instead of SDL_Init() or SDL_InitSubSystem(),
- * then you must use that subsystem's quit function (SDL_VideoQuit()) to shut
- * it down before calling SDL_Quit(). But generally, you should not be using
- * those functions directly anyhow; use SDL_Init() instead.
- *
- * You can use this function with atexit() to ensure that it is run when your
- * application is shutdown, but it is not wise to do this from a library or
- * other dynamically loaded code.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Init
- * \sa SDL_QuitSubSystem
- */
-extern DECLSPEC void SDLCALL SDL_Quit(void);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */

thirdparty/include/android/SDL2/SDL_assert.h

@@ -1,324 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_assert_h_
-#define SDL_assert_h_
-
-#include "SDL_stdinc.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef SDL_ASSERT_LEVEL
-#ifdef SDL_DEFAULT_ASSERT_LEVEL
-#define SDL_ASSERT_LEVEL SDL_DEFAULT_ASSERT_LEVEL
-#elif defined(_DEBUG) || defined(DEBUG) || \
-      (defined(__GNUC__) && !defined(__OPTIMIZE__))
-#define SDL_ASSERT_LEVEL 2
-#else
-#define SDL_ASSERT_LEVEL 1
-#endif
-#endif /* SDL_ASSERT_LEVEL */
-
-/*
-These are macros and not first class functions so that the debugger breaks
-on the assertion line and not in some random guts of SDL, and so each
-assert can have unique static variables associated with it.
-*/
-
-#if defined(_MSC_VER)
-/* Don't include intrin.h here because it contains C++ code */
-    extern void __cdecl __debugbreak(void);
-    #define SDL_TriggerBreakpoint() __debugbreak()
-#elif _SDL_HAS_BUILTIN(__builtin_debugtrap)
-    #define SDL_TriggerBreakpoint() __builtin_debugtrap()
-#elif ( (!defined(__NACL__)) && ((defined(__GNUC__) || defined(__clang__)) && (defined(__i386__) || defined(__x86_64__))) )
-    #define SDL_TriggerBreakpoint() __asm__ __volatile__ ( "int $3\n\t" )
-#elif (defined(__GNUC__) || defined(__clang__)) && defined(__riscv)
-    #define SDL_TriggerBreakpoint() __asm__ __volatile__ ( "ebreak\n\t" )
-#elif ( defined(__APPLE__) && (defined(__arm64__) || defined(__aarch64__)) )  /* this might work on other ARM targets, but this is a known quantity... */
-    #define SDL_TriggerBreakpoint() __asm__ __volatile__ ( "brk #22\n\t" )
-#elif defined(__APPLE__) && defined(__arm__)
-    #define SDL_TriggerBreakpoint() __asm__ __volatile__ ( "bkpt #22\n\t" )
-#elif defined(_WIN32) && ((defined(__GNUC__) || defined(__clang__)) && (defined(__arm64__) || defined(__aarch64__)) )
-    #define SDL_TriggerBreakpoint() __asm__ __volatile__ ( "brk #0xF000\n\t" )
-#elif defined(__386__) && defined(__WATCOMC__)
-    #define SDL_TriggerBreakpoint() { _asm { int 0x03 } }
-#elif defined(HAVE_SIGNAL_H) && !defined(__WATCOMC__)
-    #include <signal.h>
-    #define SDL_TriggerBreakpoint() raise(SIGTRAP)
-#else
-    /* How do we trigger breakpoints on this platform? */
-    #define SDL_TriggerBreakpoint()
-#endif
-
-#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 supports __func__ as a standard. */
-#   define SDL_FUNCTION __func__
-#elif ((defined(__GNUC__) && (__GNUC__ >= 2)) || defined(_MSC_VER) || defined (__WATCOMC__))
-#   define SDL_FUNCTION __FUNCTION__
-#else
-#   define SDL_FUNCTION "???"
-#endif
-#define SDL_FILE    __FILE__
-#define SDL_LINE    __LINE__
-
-/*
-sizeof (x) makes the compiler still parse the expression even without
-assertions enabled, so the code is always checked at compile time, but
-doesn't actually generate code for it, so there are no side effects or
-expensive checks at run time, just the constant size of what x WOULD be,
-which presumably gets optimized out as unused.
-This also solves the problem of...
-
-    int somevalue = blah();
-    SDL_assert(somevalue == 1);
-
-...which would cause compiles to complain that somevalue is unused if we
-disable assertions.
-*/
-
-/* "while (0,0)" fools Microsoft's compiler's /W4 warning level into thinking
-    this condition isn't constant. And looks like an owl's face! */
-#ifdef _MSC_VER  /* stupid /W4 warnings. */
-#define SDL_NULL_WHILE_LOOP_CONDITION (0,0)
-#else
-#define SDL_NULL_WHILE_LOOP_CONDITION (0)
-#endif
-
-#define SDL_disabled_assert(condition) \
-    do { (void) sizeof ((condition)); } while (SDL_NULL_WHILE_LOOP_CONDITION)
-
-typedef enum
-{
-    SDL_ASSERTION_RETRY,  /**< Retry the assert immediately. */
-    SDL_ASSERTION_BREAK,  /**< Make the debugger trigger a breakpoint. */
-    SDL_ASSERTION_ABORT,  /**< Terminate the program. */
-    SDL_ASSERTION_IGNORE,  /**< Ignore the assert. */
-    SDL_ASSERTION_ALWAYS_IGNORE  /**< Ignore the assert from now on. */
-} SDL_AssertState;
-
-typedef struct SDL_AssertData
-{
-    int always_ignore;
-    unsigned int trigger_count;
-    const char *condition;
-    const char *filename;
-    int linenum;
-    const char *function;
-    const struct SDL_AssertData *next;
-} SDL_AssertData;
-
-/* Never call this directly. Use the SDL_assert* macros. */
-extern DECLSPEC SDL_AssertState SDLCALL SDL_ReportAssertion(SDL_AssertData *,
-                                                            const char *,
-                                                            const char *, int)
-#if defined(__clang__)
-#if __has_feature(attribute_analyzer_noreturn)
-/* this tells Clang's static analysis that we're a custom assert function,
-   and that the analyzer should assume the condition was always true past this
-   SDL_assert test. */
-   __attribute__((analyzer_noreturn))
-#endif
-#endif
-;
-
-/* the do {} while(0) avoids dangling else problems:
-    if (x) SDL_assert(y); else blah();
-       ... without the do/while, the "else" could attach to this macro's "if".
-   We try to handle just the minimum we need here in a macro...the loop,
-   the static vars, and break points. The heavy lifting is handled in
-   SDL_ReportAssertion(), in SDL_assert.c.
-*/
-#define SDL_enabled_assert(condition) \
-    do { \
-        while ( !(condition) ) { \
-            static struct SDL_AssertData sdl_assert_data = { 0, 0, #condition, NULL, 0, NULL, NULL }; \
-            const SDL_AssertState sdl_assert_state = SDL_ReportAssertion(&sdl_assert_data, SDL_FUNCTION, SDL_FILE, SDL_LINE); \
-            if (sdl_assert_state == SDL_ASSERTION_RETRY) { \
-                continue; /* go again. */ \
-            } else if (sdl_assert_state == SDL_ASSERTION_BREAK) { \
-                SDL_TriggerBreakpoint(); \
-            } \
-            break; /* not retrying. */ \
-        } \
-    } while (SDL_NULL_WHILE_LOOP_CONDITION)
-
-/* Enable various levels of assertions. */
-#if SDL_ASSERT_LEVEL == 0   /* assertions disabled */
-#   define SDL_assert(condition) SDL_disabled_assert(condition)
-#   define SDL_assert_release(condition) SDL_disabled_assert(condition)
-#   define SDL_assert_paranoid(condition) SDL_disabled_assert(condition)
-#elif SDL_ASSERT_LEVEL == 1  /* release settings. */
-#   define SDL_assert(condition) SDL_disabled_assert(condition)
-#   define SDL_assert_release(condition) SDL_enabled_assert(condition)
-#   define SDL_assert_paranoid(condition) SDL_disabled_assert(condition)
-#elif SDL_ASSERT_LEVEL == 2  /* normal settings. */
-#   define SDL_assert(condition) SDL_enabled_assert(condition)
-#   define SDL_assert_release(condition) SDL_enabled_assert(condition)
-#   define SDL_assert_paranoid(condition) SDL_disabled_assert(condition)
-#elif SDL_ASSERT_LEVEL == 3  /* paranoid settings. */
-#   define SDL_assert(condition) SDL_enabled_assert(condition)
-#   define SDL_assert_release(condition) SDL_enabled_assert(condition)
-#   define SDL_assert_paranoid(condition) SDL_enabled_assert(condition)
-#else
-#   error Unknown assertion level.
-#endif
-
-/* this assertion is never disabled at any level. */
-#define SDL_assert_always(condition) SDL_enabled_assert(condition)
-
-
-/**
- * A callback that fires when an SDL assertion fails.
- *
- * \param data a pointer to the SDL_AssertData structure corresponding to the
- *             current assertion.
- * \param userdata what was passed as `userdata` to SDL_SetAssertionHandler().
- * \returns an SDL_AssertState value indicating how to handle the failure.
- */
-typedef SDL_AssertState (SDLCALL *SDL_AssertionHandler)(
-                                 const SDL_AssertData* data, void* userdata);
-
-/**
- * Set an application-defined assertion handler.
- *
- * This function allows an application to show its own assertion UI and/or
- * force the response to an assertion failure. If the application doesn't
- * provide this, SDL will try to do the right thing, popping up a
- * system-specific GUI dialog, and probably minimizing any fullscreen windows.
- *
- * This callback may fire from any thread, but it runs wrapped in a mutex, so
- * it will only fire from one thread at a time.
- *
- * This callback is NOT reset to SDL's internal handler upon SDL_Quit()!
- *
- * \param handler the SDL_AssertionHandler function to call when an assertion
- *                fails or NULL for the default handler.
- * \param userdata a pointer that is passed to `handler`.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetAssertionHandler
- */
-extern DECLSPEC void SDLCALL SDL_SetAssertionHandler(
-                                            SDL_AssertionHandler handler,
-                                            void *userdata);
-
-/**
- * Get the default assertion handler.
- *
- * This returns the function pointer that is called by default when an
- * assertion is triggered. This is an internal function provided by SDL, that
- * is used for assertions when SDL_SetAssertionHandler() hasn't been used to
- * provide a different function.
- *
- * \returns the default SDL_AssertionHandler that is called when an assert
- *          triggers.
- *
- * \since This function is available since SDL 2.0.2.
- *
- * \sa SDL_GetAssertionHandler
- */
-extern DECLSPEC SDL_AssertionHandler SDLCALL SDL_GetDefaultAssertionHandler(void);
-
-/**
- * Get the current assertion handler.
- *
- * This returns the function pointer that is called when an assertion is
- * triggered. This is either the value last passed to
- * SDL_SetAssertionHandler(), or if no application-specified function is set,
- * is equivalent to calling SDL_GetDefaultAssertionHandler().
- *
- * The parameter `puserdata` is a pointer to a void*, which will store the
- * "userdata" pointer that was passed to SDL_SetAssertionHandler(). This value
- * will always be NULL for the default handler. If you don't care about this
- * data, it is safe to pass a NULL pointer to this function to ignore it.
- *
- * \param puserdata pointer which is filled with the "userdata" pointer that
- *                  was passed to SDL_SetAssertionHandler().
- * \returns the SDL_AssertionHandler that is called when an assert triggers.
- *
- * \since This function is available since SDL 2.0.2.
- *
- * \sa SDL_SetAssertionHandler
- */
-extern DECLSPEC SDL_AssertionHandler SDLCALL SDL_GetAssertionHandler(void **puserdata);
-
-/**
- * Get a list of all assertion failures.
- *
- * This function gets all assertions triggered since the last call to
- * SDL_ResetAssertionReport(), or the start of the program.
- *
- * The proper way to examine this data looks something like this:
- *
- * ```c
- * const SDL_AssertData *item = SDL_GetAssertionReport();
- * while (item) {
- *    printf("'%s', %s (%s:%d), triggered %u times, always ignore: %s.\\n",
- *           item->condition, item->function, item->filename,
- *           item->linenum, item->trigger_count,
- *           item->always_ignore ? "yes" : "no");
- *    item = item->next;
- * }
- * ```
- *
- * \returns a list of all failed assertions or NULL if the list is empty. This
- *          memory should not be modified or freed by the application.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_ResetAssertionReport
- */
-extern DECLSPEC const SDL_AssertData * SDLCALL SDL_GetAssertionReport(void);
-
-/**
- * Clear the list of all assertion failures.
- *
- * This function will clear the list of all assertions triggered up to that
- * point. Immediately following this call, SDL_GetAssertionReport will return
- * no items. In addition, any previously-triggered assertions will be reset to
- * a trigger_count of zero, and their always_ignore state will be false.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetAssertionReport
- */
-extern DECLSPEC void SDLCALL SDL_ResetAssertionReport(void);
-
-
-/* these had wrong naming conventions until 2.0.4. Please update your app! */
-#define SDL_assert_state SDL_AssertState
-#define SDL_assert_data SDL_AssertData
-
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_assert_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */

thirdparty/include/android/SDL2/SDL_atomic.h

@@ -1,408 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- * # CategoryAtomic
- *
- * Atomic operations.
- *
- * IMPORTANT: If you are not an expert in concurrent lockless programming, you
- * should not be using any functions in this file. You should be protecting
- * your data structures with full mutexes instead.
- *
- * ***Seriously, here be dragons!***
- *
- * You can find out a little more about lockless programming and the subtle
- * issues that can arise here:
- * https://learn.microsoft.com/en-us/windows/win32/dxtecharts/lockless-programming
- *
- * There's also lots of good information here:
- *
- * - https://www.1024cores.net/home/lock-free-algorithms
- * - https://preshing.com/
- *
- * These operations may or may not actually be implemented using processor
- * specific atomic operations. When possible they are implemented as true
- * processor specific atomic operations. When that is not possible the are
- * implemented using locks that *do* use the available atomic operations.
- *
- * All of the atomic operations that modify memory are full memory barriers.
- */
-
-#ifndef SDL_atomic_h_
-#define SDL_atomic_h_
-
-#include "SDL_stdinc.h"
-#include "SDL_platform.h"
-
-#include "begin_code.h"
-
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * \name SDL AtomicLock
- *
- * The atomic locks are efficient spinlocks using CPU instructions,
- * but are vulnerable to starvation and can spin forever if a thread
- * holding a lock has been terminated.  For this reason you should
- * minimize the code executed inside an atomic lock and never do
- * expensive things like API or system calls while holding them.
- *
- * The atomic locks are not safe to lock recursively.
- *
- * Porting Note:
- * The spin lock functions and type are required and can not be
- * emulated because they are used in the atomic emulation code.
- */
-/* @{ */
-
-typedef int SDL_SpinLock;
-
-/**
- * Try to lock a spin lock by setting it to a non-zero value.
- *
- * ***Please note that spinlocks are dangerous if you don't know what you're
- * doing. Please be careful using any sort of spinlock!***
- *
- * \param lock a pointer to a lock variable.
- * \returns SDL_TRUE if the lock succeeded, SDL_FALSE if the lock is already
- *          held.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_AtomicLock
- * \sa SDL_AtomicUnlock
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_AtomicTryLock(SDL_SpinLock *lock);
-
-/**
- * Lock a spin lock by setting it to a non-zero value.
- *
- * ***Please note that spinlocks are dangerous if you don't know what you're
- * doing. Please be careful using any sort of spinlock!***
- *
- * \param lock a pointer to a lock variable.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_AtomicTryLock
- * \sa SDL_AtomicUnlock
- */
-extern DECLSPEC void SDLCALL SDL_AtomicLock(SDL_SpinLock *lock);
-
-/**
- * Unlock a spin lock by setting it to 0.
- *
- * Always returns immediately.
- *
- * ***Please note that spinlocks are dangerous if you don't know what you're
- * doing. Please be careful using any sort of spinlock!***
- *
- * \param lock a pointer to a lock variable.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_AtomicLock
- * \sa SDL_AtomicTryLock
- */
-extern DECLSPEC void SDLCALL SDL_AtomicUnlock(SDL_SpinLock *lock);
-
-/* @} *//* SDL AtomicLock */
-
-
-/**
- * The compiler barrier prevents the compiler from reordering
- * reads and writes to globally visible variables across the call.
- */
-#if defined(_MSC_VER) && (_MSC_VER > 1200) && !defined(__clang__)
-void _ReadWriteBarrier(void);
-#pragma intrinsic(_ReadWriteBarrier)
-#define SDL_CompilerBarrier()   _ReadWriteBarrier()
-#elif (defined(__GNUC__) && !defined(__EMSCRIPTEN__)) || (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x5120))
-/* This is correct for all CPUs when using GCC or Solaris Studio 12.1+. */
-#define SDL_CompilerBarrier()   __asm__ __volatile__ ("" : : : "memory")
-#elif defined(__WATCOMC__)
-extern __inline void SDL_CompilerBarrier(void);
-#pragma aux SDL_CompilerBarrier = "" parm [] modify exact [];
-#else
-#define SDL_CompilerBarrier()   \
-{ SDL_SpinLock _tmp = 0; SDL_AtomicLock(&_tmp); SDL_AtomicUnlock(&_tmp); }
-#endif
-
-/**
- * Memory barriers are designed to prevent reads and writes from being
- * reordered by the compiler and being seen out of order on multi-core CPUs.
- *
- * A typical pattern would be for thread A to write some data and a flag, and
- * for thread B to read the flag and get the data. In this case you would
- * insert a release barrier between writing the data and the flag,
- * guaranteeing that the data write completes no later than the flag is
- * written, and you would insert an acquire barrier between reading the flag
- * and reading the data, to ensure that all the reads associated with the flag
- * have completed.
- *
- * In this pattern you should always see a release barrier paired with an
- * acquire barrier and you should gate the data reads/writes with a single
- * flag variable.
- *
- * For more information on these semantics, take a look at the blog post:
- * http://preshing.com/20120913/acquire-and-release-semantics
- *
- * \since This function is available since SDL 2.0.6.
- */
-extern DECLSPEC void SDLCALL SDL_MemoryBarrierReleaseFunction(void);
-extern DECLSPEC void SDLCALL SDL_MemoryBarrierAcquireFunction(void);
-
-#if defined(__GNUC__) && (defined(__powerpc__) || defined(__ppc__))
-#define SDL_MemoryBarrierRelease()   __asm__ __volatile__ ("lwsync" : : : "memory")
-#define SDL_MemoryBarrierAcquire()   __asm__ __volatile__ ("lwsync" : : : "memory")
-#elif defined(__GNUC__) && defined(__aarch64__)
-#define SDL_MemoryBarrierRelease()   __asm__ __volatile__ ("dmb ish" : : : "memory")
-#define SDL_MemoryBarrierAcquire()   __asm__ __volatile__ ("dmb ish" : : : "memory")
-#elif defined(__GNUC__) && defined(__arm__)
-#if 0 /* defined(__LINUX__) || defined(__ANDROID__) */
-/* Information from:
-   https://chromium.googlesource.com/chromium/chromium/+/trunk/base/atomicops_internals_arm_gcc.h#19
-
-   The Linux kernel provides a helper function which provides the right code for a memory barrier,
-   hard-coded at address 0xffff0fa0
-*/
-typedef void (*SDL_KernelMemoryBarrierFunc)();
-#define SDL_MemoryBarrierRelease()	((SDL_KernelMemoryBarrierFunc)0xffff0fa0)()
-#define SDL_MemoryBarrierAcquire()	((SDL_KernelMemoryBarrierFunc)0xffff0fa0)()
-#elif 0 /* defined(__QNXNTO__) */
-#include <sys/cpuinline.h>
-
-#define SDL_MemoryBarrierRelease()   __cpu_membarrier()
-#define SDL_MemoryBarrierAcquire()   __cpu_membarrier()
-#else
-#if defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7EM__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__) || defined(__ARM_ARCH_8A__)
-#define SDL_MemoryBarrierRelease()   __asm__ __volatile__ ("dmb ish" : : : "memory")
-#define SDL_MemoryBarrierAcquire()   __asm__ __volatile__ ("dmb ish" : : : "memory")
-#elif defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6T2__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__)
-#ifdef __thumb__
-/* The mcr instruction isn't available in thumb mode, use real functions */
-#define SDL_MEMORY_BARRIER_USES_FUNCTION
-#define SDL_MemoryBarrierRelease()   SDL_MemoryBarrierReleaseFunction()
-#define SDL_MemoryBarrierAcquire()   SDL_MemoryBarrierAcquireFunction()
-#else
-#define SDL_MemoryBarrierRelease()   __asm__ __volatile__ ("mcr p15, 0, %0, c7, c10, 5" : : "r"(0) : "memory")
-#define SDL_MemoryBarrierAcquire()   __asm__ __volatile__ ("mcr p15, 0, %0, c7, c10, 5" : : "r"(0) : "memory")
-#endif /* __thumb__ */
-#else
-#define SDL_MemoryBarrierRelease()   __asm__ __volatile__ ("" : : : "memory")
-#define SDL_MemoryBarrierAcquire()   __asm__ __volatile__ ("" : : : "memory")
-#endif /* __LINUX__ || __ANDROID__ */
-#endif /* __GNUC__ && __arm__ */
-#else
-#if (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x5120))
-/* This is correct for all CPUs on Solaris when using Solaris Studio 12.1+. */
-#include <mbarrier.h>
-#define SDL_MemoryBarrierRelease()  __machine_rel_barrier()
-#define SDL_MemoryBarrierAcquire()  __machine_acq_barrier()
-#else
-/* This is correct for the x86 and x64 CPUs, and we'll expand this over time. */
-#define SDL_MemoryBarrierRelease()  SDL_CompilerBarrier()
-#define SDL_MemoryBarrierAcquire()  SDL_CompilerBarrier()
-#endif
-#endif
-
-/* "REP NOP" is PAUSE, coded for tools that don't know it by that name. */
-#if (defined(__GNUC__) || defined(__clang__)) && (defined(__i386__) || defined(__x86_64__))
-    #define SDL_CPUPauseInstruction() __asm__ __volatile__("pause\n")  /* Some assemblers can't do REP NOP, so go with PAUSE. */
-#elif (defined(__arm__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7) || defined(__aarch64__)
-    #define SDL_CPUPauseInstruction() __asm__ __volatile__("yield" ::: "memory")
-#elif (defined(__powerpc__) || defined(__powerpc64__))
-    #define SDL_CPUPauseInstruction() __asm__ __volatile__("or 27,27,27");
-#elif defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64))
-    #define SDL_CPUPauseInstruction() _mm_pause()  /* this is actually "rep nop" and not a SIMD instruction. No inline asm in MSVC x86-64! */
-#elif defined(_MSC_VER) && (defined(_M_ARM) || defined(_M_ARM64))
-    #define SDL_CPUPauseInstruction() __yield()
-#elif defined(__WATCOMC__) && defined(__386__)
-    extern __inline void SDL_CPUPauseInstruction(void);
-    #pragma aux SDL_CPUPauseInstruction = ".686p" ".xmm2" "pause"
-#else
-    #define SDL_CPUPauseInstruction()
-#endif
-
-
-/**
- * A type representing an atomic integer value.
- *
- * It is a struct so people don't accidentally use numeric operations on it.
- */
-typedef struct SDL_atomic_t {
-    int value;
-} SDL_atomic_t;
-
-/**
- * Set an atomic variable to a new value if it is currently an old value.
- *
- * ***Note: If you don't know what this function is for, you shouldn't use
- * it!***
- *
- * \param a a pointer to an SDL_atomic_t variable to be modified.
- * \param oldval the old value.
- * \param newval the new value.
- * \returns SDL_TRUE if the atomic variable was set, SDL_FALSE otherwise.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_AtomicCASPtr
- * \sa SDL_AtomicGet
- * \sa SDL_AtomicSet
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_AtomicCAS(SDL_atomic_t *a, int oldval, int newval);
-
-/**
- * Set an atomic variable to a value.
- *
- * This function also acts as a full memory barrier.
- *
- * ***Note: If you don't know what this function is for, you shouldn't use
- * it!***
- *
- * \param a a pointer to an SDL_atomic_t variable to be modified.
- * \param v the desired value.
- * \returns the previous value of the atomic variable.
- *
- * \since This function is available since SDL 2.0.2.
- *
- * \sa SDL_AtomicGet
- */
-extern DECLSPEC int SDLCALL SDL_AtomicSet(SDL_atomic_t *a, int v);
-
-/**
- * Get the value of an atomic variable.
- *
- * ***Note: If you don't know what this function is for, you shouldn't use
- * it!***
- *
- * \param a a pointer to an SDL_atomic_t variable.
- * \returns the current value of an atomic variable.
- *
- * \since This function is available since SDL 2.0.2.
- *
- * \sa SDL_AtomicSet
- */
-extern DECLSPEC int SDLCALL SDL_AtomicGet(SDL_atomic_t *a);
-
-/**
- * Add to an atomic variable.
- *
- * This function also acts as a full memory barrier.
- *
- * ***Note: If you don't know what this function is for, you shouldn't use
- * it!***
- *
- * \param a a pointer to an SDL_atomic_t variable to be modified.
- * \param v the desired value to add.
- * \returns the previous value of the atomic variable.
- *
- * \since This function is available since SDL 2.0.2.
- *
- * \sa SDL_AtomicDecRef
- * \sa SDL_AtomicIncRef
- */
-extern DECLSPEC int SDLCALL SDL_AtomicAdd(SDL_atomic_t *a, int v);
-
-/**
- * \brief Increment an atomic variable used as a reference count.
- */
-#ifndef SDL_AtomicIncRef
-#define SDL_AtomicIncRef(a)    SDL_AtomicAdd(a, 1)
-#endif
-
-/**
- * \brief Decrement an atomic variable used as a reference count.
- *
- * \return SDL_TRUE if the variable reached zero after decrementing,
- *         SDL_FALSE otherwise
- */
-#ifndef SDL_AtomicDecRef
-#define SDL_AtomicDecRef(a)    (SDL_AtomicAdd(a, -1) == 1)
-#endif
-
-/**
- * Set a pointer to a new value if it is currently an old value.
- *
- * ***Note: If you don't know what this function is for, you shouldn't use
- * it!***
- *
- * \param a a pointer to a pointer.
- * \param oldval the old pointer value.
- * \param newval the new pointer value.
- * \returns SDL_TRUE if the pointer was set, SDL_FALSE otherwise.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_AtomicCAS
- * \sa SDL_AtomicGetPtr
- * \sa SDL_AtomicSetPtr
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_AtomicCASPtr(void **a, void *oldval, void *newval);
-
-/**
- * Set a pointer to a value atomically.
- *
- * ***Note: If you don't know what this function is for, you shouldn't use
- * it!***
- *
- * \param a a pointer to a pointer.
- * \param v the desired pointer value.
- * \returns the previous value of the pointer.
- *
- * \since This function is available since SDL 2.0.2.
- *
- * \sa SDL_AtomicCASPtr
- * \sa SDL_AtomicGetPtr
- */
-extern DECLSPEC void* SDLCALL SDL_AtomicSetPtr(void **a, void* v);
-
-/**
- * Get the value of a pointer atomically.
- *
- * ***Note: If you don't know what this function is for, you shouldn't use
- * it!***
- *
- * \param a a pointer to a pointer.
- * \returns the current value of a pointer.
- *
- * \since This function is available since SDL 2.0.2.
- *
- * \sa SDL_AtomicCASPtr
- * \sa SDL_AtomicSetPtr
- */
-extern DECLSPEC void* SDLCALL SDL_AtomicGetPtr(void **a);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-
-#include "close_code.h"
-
-#endif /* SDL_atomic_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */

thirdparty/include/android/SDL2/SDL_bits.h

@@ -1,132 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- * # CategoryBits
- *
- * Functions for fiddling with bits and bitmasks.
- */
-
-#ifndef SDL_bits_h_
-#define SDL_bits_h_
-
-#include "SDL_stdinc.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- *  \file SDL_bits.h
- */
-
-/**
- *  Get the index of the most significant bit. Result is undefined when called
- *  with 0. This operation can also be stated as "count leading zeroes" and
- *  "log base 2".
- *
- *  \return the index of the most significant bit, or -1 if the value is 0.
- */
-#if defined(__WATCOMC__) && defined(__386__)
-extern __inline int _SDL_bsr_watcom(Uint32);
-#pragma aux _SDL_bsr_watcom = \
-    "bsr eax, eax" \
-    parm [eax] nomemory \
-    value [eax] \
-    modify exact [eax] nomemory;
-#endif
-
-/**
- * Use this function to get the index of the most significant (set) bit in a
- *
- * \param x the number to find the MSB of.
- * \returns the index of the most significant bit of x, or -1 if x is 0.
- */
-SDL_FORCE_INLINE int
-SDL_MostSignificantBitIndex32(Uint32 x)
-{
-#if defined(__GNUC__) && (__GNUC__ >= 4 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
-    /* Count Leading Zeroes builtin in GCC.
-     * http://gcc.gnu.org/onlinedocs/gcc-4.3.4/gcc/Other-Builtins.html
-     */
-    if (x == 0) {
-        return -1;
-    }
-    return 31 - __builtin_clz(x);
-#elif defined(__WATCOMC__) && defined(__386__)
-    if (x == 0) {
-        return -1;
-    }
-    return _SDL_bsr_watcom(x);
-#elif defined(_MSC_VER)
-    unsigned long index;
-    if (_BitScanReverse(&index, x)) {
-        return index;
-    }
-    return -1;
-#else
-    /* Based off of Bit Twiddling Hacks by Sean Eron Anderson
-     * <seander@cs.stanford.edu>, released in the public domain.
-     * http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog
-     */
-    const Uint32 b[] = {0x2, 0xC, 0xF0, 0xFF00, 0xFFFF0000};
-    const int    S[] = {1, 2, 4, 8, 16};
-
-    int msbIndex = 0;
-    int i;
-
-    if (x == 0) {
-        return -1;
-    }
-
-    for (i = 4; i >= 0; i--)
-    {
-        if (x & b[i])
-        {
-            x >>= S[i];
-            msbIndex |= S[i];
-        }
-    }
-
-    return msbIndex;
-#endif
-}
-
-SDL_FORCE_INLINE SDL_bool
-SDL_HasExactlyOneBitSet32(Uint32 x)
-{
-    if (x && !(x & (x - 1))) {
-        return SDL_TRUE;
-    }
-    return SDL_FALSE;
-}
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_bits_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */

thirdparty/include/android/SDL2/SDL_blendmode.h

@@ -1,199 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- * # CategoryBlendmode
- *
- * Header file declaring the SDL_BlendMode enumeration
- */
-
-#ifndef SDL_blendmode_h_
-#define SDL_blendmode_h_
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * The blend mode used in SDL_RenderCopy() and drawing operations.
- */
-typedef enum SDL_BlendMode
-{
-    SDL_BLENDMODE_NONE = 0x00000000,     /**< no blending
-                                              dstRGBA = srcRGBA */
-    SDL_BLENDMODE_BLEND = 0x00000001,    /**< alpha blending
-                                              dstRGB = (srcRGB * srcA) + (dstRGB * (1-srcA))
-                                              dstA = srcA + (dstA * (1-srcA)) */
-    SDL_BLENDMODE_ADD = 0x00000002,      /**< additive blending
-                                              dstRGB = (srcRGB * srcA) + dstRGB
-                                              dstA = dstA */
-    SDL_BLENDMODE_MOD = 0x00000004,      /**< color modulate
-                                              dstRGB = srcRGB * dstRGB
-                                              dstA = dstA */
-    SDL_BLENDMODE_MUL = 0x00000008,      /**< color multiply
-                                              dstRGB = (srcRGB * dstRGB) + (dstRGB * (1-srcA))
-                                              dstA = dstA */
-    SDL_BLENDMODE_INVALID = 0x7FFFFFFF
-
-    /* Additional custom blend modes can be returned by SDL_ComposeCustomBlendMode() */
-
-} SDL_BlendMode;
-
-/**
- * The blend operation used when combining source and destination pixel
- * components
- */
-typedef enum SDL_BlendOperation
-{
-    SDL_BLENDOPERATION_ADD              = 0x1,  /**< dst + src: supported by all renderers */
-    SDL_BLENDOPERATION_SUBTRACT         = 0x2,  /**< src - dst : supported by D3D9, D3D11, OpenGL, OpenGLES */
-    SDL_BLENDOPERATION_REV_SUBTRACT     = 0x3,  /**< dst - src : supported by D3D9, D3D11, OpenGL, OpenGLES */
-    SDL_BLENDOPERATION_MINIMUM          = 0x4,  /**< min(dst, src) : supported by D3D9, D3D11 */
-    SDL_BLENDOPERATION_MAXIMUM          = 0x5   /**< max(dst, src) : supported by D3D9, D3D11 */
-} SDL_BlendOperation;
-
-/**
- * The normalized factor used to multiply pixel components
- */
-typedef enum SDL_BlendFactor
-{
-    SDL_BLENDFACTOR_ZERO                = 0x1,  /**< 0, 0, 0, 0 */
-    SDL_BLENDFACTOR_ONE                 = 0x2,  /**< 1, 1, 1, 1 */
-    SDL_BLENDFACTOR_SRC_COLOR           = 0x3,  /**< srcR, srcG, srcB, srcA */
-    SDL_BLENDFACTOR_ONE_MINUS_SRC_COLOR = 0x4,  /**< 1-srcR, 1-srcG, 1-srcB, 1-srcA */
-    SDL_BLENDFACTOR_SRC_ALPHA           = 0x5,  /**< srcA, srcA, srcA, srcA */
-    SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA = 0x6,  /**< 1-srcA, 1-srcA, 1-srcA, 1-srcA */
-    SDL_BLENDFACTOR_DST_COLOR           = 0x7,  /**< dstR, dstG, dstB, dstA */
-    SDL_BLENDFACTOR_ONE_MINUS_DST_COLOR = 0x8,  /**< 1-dstR, 1-dstG, 1-dstB, 1-dstA */
-    SDL_BLENDFACTOR_DST_ALPHA           = 0x9,  /**< dstA, dstA, dstA, dstA */
-    SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA = 0xA   /**< 1-dstA, 1-dstA, 1-dstA, 1-dstA */
-} SDL_BlendFactor;
-
-/**
- * Compose a custom blend mode for renderers.
- *
- * The functions SDL_SetRenderDrawBlendMode and SDL_SetTextureBlendMode accept
- * the SDL_BlendMode returned by this function if the renderer supports it.
- *
- * A blend mode controls how the pixels from a drawing operation (source) get
- * combined with the pixels from the render target (destination). First, the
- * components of the source and destination pixels get multiplied with their
- * blend factors. Then, the blend operation takes the two products and
- * calculates the result that will get stored in the render target.
- *
- * Expressed in pseudocode, it would look like this:
- *
- * ```c
- * dstRGB = colorOperation(srcRGB * srcColorFactor, dstRGB * dstColorFactor);
- * dstA = alphaOperation(srcA * srcAlphaFactor, dstA * dstAlphaFactor);
- * ```
- *
- * Where the functions `colorOperation(src, dst)` and `alphaOperation(src,
- * dst)` can return one of the following:
- *
- * - `src + dst`
- * - `src - dst`
- * - `dst - src`
- * - `min(src, dst)`
- * - `max(src, dst)`
- *
- * The red, green, and blue components are always multiplied with the first,
- * second, and third components of the SDL_BlendFactor, respectively. The
- * fourth component is not used.
- *
- * The alpha component is always multiplied with the fourth component of the
- * SDL_BlendFactor. The other components are not used in the alpha
- * calculation.
- *
- * Support for these blend modes varies for each renderer. To check if a
- * specific SDL_BlendMode is supported, create a renderer and pass it to
- * either SDL_SetRenderDrawBlendMode or SDL_SetTextureBlendMode. They will
- * return with an error if the blend mode is not supported.
- *
- * This list describes the support of custom blend modes for each renderer in
- * SDL 2.0.6. All renderers support the four blend modes listed in the
- * SDL_BlendMode enumeration.
- *
- * - **direct3d**: Supports all operations with all factors. However, some
- *   factors produce unexpected results with `SDL_BLENDOPERATION_MINIMUM` and
- *   `SDL_BLENDOPERATION_MAXIMUM`.
- * - **direct3d11**: Same as Direct3D 9.
- * - **opengl**: Supports the `SDL_BLENDOPERATION_ADD` operation with all
- *   factors. OpenGL versions 1.1, 1.2, and 1.3 do not work correctly with SDL
- *   2.0.6.
- * - **opengles**: Supports the `SDL_BLENDOPERATION_ADD` operation with all
- *   factors. Color and alpha factors need to be the same. OpenGL ES 1
- *   implementation specific: May also support `SDL_BLENDOPERATION_SUBTRACT`
- *   and `SDL_BLENDOPERATION_REV_SUBTRACT`. May support color and alpha
- *   operations being different from each other. May support color and alpha
- *   factors being different from each other.
- * - **opengles2**: Supports the `SDL_BLENDOPERATION_ADD`,
- *   `SDL_BLENDOPERATION_SUBTRACT`, `SDL_BLENDOPERATION_REV_SUBTRACT`
- *   operations with all factors.
- * - **psp**: No custom blend mode support.
- * - **software**: No custom blend mode support.
- *
- * Some renderers do not provide an alpha component for the default render
- * target. The `SDL_BLENDFACTOR_DST_ALPHA` and
- * `SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA` factors do not have an effect in this
- * case.
- *
- * \param srcColorFactor the SDL_BlendFactor applied to the red, green, and
- *                       blue components of the source pixels.
- * \param dstColorFactor the SDL_BlendFactor applied to the red, green, and
- *                       blue components of the destination pixels.
- * \param colorOperation the SDL_BlendOperation used to combine the red,
- *                       green, and blue components of the source and
- *                       destination pixels.
- * \param srcAlphaFactor the SDL_BlendFactor applied to the alpha component of
- *                       the source pixels.
- * \param dstAlphaFactor the SDL_BlendFactor applied to the alpha component of
- *                       the destination pixels.
- * \param alphaOperation the SDL_BlendOperation used to combine the alpha
- *                       component of the source and destination pixels.
- * \returns an SDL_BlendMode that represents the chosen factors and
- *          operations.
- *
- * \since This function is available since SDL 2.0.6.
- *
- * \sa SDL_SetRenderDrawBlendMode
- * \sa SDL_GetRenderDrawBlendMode
- * \sa SDL_SetTextureBlendMode
- * \sa SDL_GetTextureBlendMode
- */
-extern DECLSPEC SDL_BlendMode SDLCALL SDL_ComposeCustomBlendMode(SDL_BlendFactor srcColorFactor,
-                                                                 SDL_BlendFactor dstColorFactor,
-                                                                 SDL_BlendOperation colorOperation,
-                                                                 SDL_BlendFactor srcAlphaFactor,
-                                                                 SDL_BlendFactor dstAlphaFactor,
-                                                                 SDL_BlendOperation alphaOperation);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_blendmode_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */

thirdparty/include/android/SDL2/SDL_clipboard.h

@@ -1,141 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- * # CategoryClipboard
- *
- * Include file for SDL clipboard handling
- */
-
-#ifndef SDL_clipboard_h_
-#define SDL_clipboard_h_
-
-#include "SDL_stdinc.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Function prototypes */
-
-/**
- * Put UTF-8 text into the clipboard.
- *
- * \param text the text to store in the clipboard.
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetClipboardText
- * \sa SDL_HasClipboardText
- */
-extern DECLSPEC int SDLCALL SDL_SetClipboardText(const char *text);
-
-/**
- * Get UTF-8 text from the clipboard, which must be freed with SDL_free().
- *
- * This functions returns empty string if there was not enough memory left for
- * a copy of the clipboard's content.
- *
- * \returns the clipboard text on success or an empty string on failure; call
- *          SDL_GetError() for more information. Caller must call SDL_free()
- *          on the returned pointer when done with it (even if there was an
- *          error).
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_HasClipboardText
- * \sa SDL_SetClipboardText
- */
-extern DECLSPEC char * SDLCALL SDL_GetClipboardText(void);
-
-/**
- * Query whether the clipboard exists and contains a non-empty text string.
- *
- * \returns SDL_TRUE if the clipboard has text, or SDL_FALSE if it does not.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetClipboardText
- * \sa SDL_SetClipboardText
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasClipboardText(void);
-
-/**
- * Put UTF-8 text into the primary selection.
- *
- * \param text the text to store in the primary selection.
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.26.0.
- *
- * \sa SDL_GetPrimarySelectionText
- * \sa SDL_HasPrimarySelectionText
- */
-extern DECLSPEC int SDLCALL SDL_SetPrimarySelectionText(const char *text);
-
-/**
- * Get UTF-8 text from the primary selection, which must be freed with
- * SDL_free().
- *
- * This functions returns empty string if there was not enough memory left for
- * a copy of the primary selection's content.
- *
- * \returns the primary selection text on success or an empty string on
- *          failure; call SDL_GetError() for more information. Caller must
- *          call SDL_free() on the returned pointer when done with it (even if
- *          there was an error).
- *
- * \since This function is available since SDL 2.26.0.
- *
- * \sa SDL_HasPrimarySelectionText
- * \sa SDL_SetPrimarySelectionText
- */
-extern DECLSPEC char * SDLCALL SDL_GetPrimarySelectionText(void);
-
-/**
- * Query whether the primary selection exists and contains a non-empty text
- * string.
- *
- * \returns SDL_TRUE if the primary selection has text, or SDL_FALSE if it
- *          does not.
- *
- * \since This function is available since SDL 2.26.0.
- *
- * \sa SDL_GetPrimarySelectionText
- * \sa SDL_SetPrimarySelectionText
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasPrimarySelectionText(void);
-
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_clipboard_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */

thirdparty/include/android/SDL2/SDL_config.h

@@ -1,59 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_config_h_
-#define SDL_config_h_
-
-#include "SDL_platform.h"
-
-/* WIKI CATEGORY: - */
-
-/* Add any platform that doesn't build using the configure system. */
-#if defined(__WIN32__)
-#include "SDL_config_windows.h"
-#elif defined(__WINRT__)
-#include "SDL_config_winrt.h"
-#elif defined(__WINGDK__)
-#include "SDL_config_wingdk.h"
-#elif defined(__XBOXONE__) || defined(__XBOXSERIES__)
-#include "SDL_config_xbox.h"
-#elif defined(__MACOSX__)
-#include "SDL_config_macosx.h"
-#elif defined(__IPHONEOS__)
-#include "SDL_config_iphoneos.h"
-#elif defined(__ANDROID__)
-#include "SDL_config_android.h"
-#elif defined(__OS2__)
-#include "SDL_config_os2.h"
-#elif defined(__EMSCRIPTEN__)
-#include "SDL_config_emscripten.h"
-#elif defined(__NGAGE__)
-#include "SDL_config_ngage.h"
-#else
-/* This is a minimal configuration just to get SDL running on new platforms. */
-#include "SDL_config_minimal.h"
-#endif /* platform config */
-
-#ifdef USING_GENERATED_CONFIG_H
-#error Wrong SDL_config.h, check your include path?
-#endif
-
-#endif /* SDL_config_h_ */

thirdparty/include/android/SDL2/SDL_config.h.cmake

@@ -1,571 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_config_h_
-#define SDL_config_h_
-
-/**
- *  \file SDL_config.h.in
- *
- *  This is a set of defines to configure the SDL features
- */
-
-/* General platform specific identifiers */
-#include "SDL_platform.h"
-
-/* C language features */
-#cmakedefine const @HAVE_CONST@
-#cmakedefine inline @HAVE_INLINE@
-#cmakedefine volatile @HAVE_VOLATILE@
-
-/* C datatypes */
-/* Define SIZEOF_VOIDP for 64/32 architectures */
-#if defined(__LP64__) || defined(_LP64) || defined(_WIN64)
-#define SIZEOF_VOIDP 8
-#else
-#define SIZEOF_VOIDP 4
-#endif
-
-#cmakedefine HAVE_GCC_ATOMICS @HAVE_GCC_ATOMICS@
-#cmakedefine HAVE_GCC_SYNC_LOCK_TEST_AND_SET @HAVE_GCC_SYNC_LOCK_TEST_AND_SET@
-
-/* Comment this if you want to build without any C library requirements */
-#cmakedefine HAVE_LIBC 1
-#ifdef HAVE_LIBC
-
-/* Useful headers */
-#cmakedefine STDC_HEADERS 1
-#cmakedefine HAVE_ALLOCA_H 1
-#cmakedefine HAVE_CTYPE_H 1
-#cmakedefine HAVE_FLOAT_H 1
-#cmakedefine HAVE_ICONV_H 1
-#cmakedefine HAVE_INTTYPES_H 1
-#cmakedefine HAVE_LIMITS_H 1
-#cmakedefine HAVE_MALLOC_H 1
-#cmakedefine HAVE_MATH_H 1
-#cmakedefine HAVE_MEMORY_H 1
-#cmakedefine HAVE_SIGNAL_H 1
-#cmakedefine HAVE_STDARG_H 1
-#cmakedefine HAVE_STDDEF_H 1
-#cmakedefine HAVE_STDINT_H 1
-#cmakedefine HAVE_STDIO_H 1
-#cmakedefine HAVE_STDLIB_H 1
-#cmakedefine HAVE_STRINGS_H 1
-#cmakedefine HAVE_STRING_H 1
-#cmakedefine HAVE_SYS_TYPES_H 1
-#cmakedefine HAVE_WCHAR_H 1
-#cmakedefine HAVE_LINUX_INPUT_H 1
-#cmakedefine HAVE_PTHREAD_NP_H 1
-#cmakedefine HAVE_LIBUNWIND_H 1
-
-/* C library functions */
-#cmakedefine HAVE_DLOPEN 1
-#cmakedefine HAVE_MALLOC 1
-#cmakedefine HAVE_CALLOC 1
-#cmakedefine HAVE_REALLOC 1
-#cmakedefine HAVE_FREE 1
-#cmakedefine HAVE_ALLOCA 1
-#ifndef __WIN32__ /* Don't use C runtime versions of these on Windows */
-#cmakedefine HAVE_GETENV 1
-#cmakedefine HAVE_SETENV 1
-#cmakedefine HAVE_PUTENV 1
-#cmakedefine HAVE_UNSETENV 1
-#endif
-#cmakedefine HAVE_QSORT 1
-#cmakedefine HAVE_BSEARCH 1
-#cmakedefine HAVE_ABS 1
-#cmakedefine HAVE_BCOPY 1
-#cmakedefine HAVE_MEMSET 1
-#cmakedefine HAVE_MEMCPY 1
-#cmakedefine HAVE_MEMMOVE 1
-#cmakedefine HAVE_MEMCMP 1
-#cmakedefine HAVE_WCSLEN 1
-#cmakedefine HAVE_WCSLCPY 1
-#cmakedefine HAVE_WCSLCAT 1
-#cmakedefine HAVE__WCSDUP 1
-#cmakedefine HAVE_WCSDUP 1
-#cmakedefine HAVE_WCSSTR 1
-#cmakedefine HAVE_WCSCMP 1
-#cmakedefine HAVE_WCSNCMP 1
-#cmakedefine HAVE_WCSCASECMP 1
-#cmakedefine HAVE__WCSICMP 1
-#cmakedefine HAVE_WCSNCASECMP 1
-#cmakedefine HAVE__WCSNICMP 1
-#cmakedefine HAVE_STRLEN 1
-#cmakedefine HAVE_STRLCPY 1
-#cmakedefine HAVE_STRLCAT 1
-#cmakedefine HAVE__STRREV 1
-#cmakedefine HAVE__STRUPR 1
-#cmakedefine HAVE__STRLWR 1
-#cmakedefine HAVE_INDEX 1
-#cmakedefine HAVE_RINDEX 1
-#cmakedefine HAVE_STRCHR 1
-#cmakedefine HAVE_STRRCHR 1
-#cmakedefine HAVE_STRSTR 1
-#cmakedefine HAVE_STRTOK_R 1
-#cmakedefine HAVE_ITOA 1
-#cmakedefine HAVE__LTOA 1
-#cmakedefine HAVE__UITOA 1
-#cmakedefine HAVE__ULTOA 1
-#cmakedefine HAVE_STRTOL 1
-#cmakedefine HAVE_STRTOUL 1
-#cmakedefine HAVE__I64TOA 1
-#cmakedefine HAVE__UI64TOA 1
-#cmakedefine HAVE_STRTOLL 1
-#cmakedefine HAVE_STRTOULL 1
-#cmakedefine HAVE_STRTOD 1
-#cmakedefine HAVE_ATOI 1
-#cmakedefine HAVE_ATOF 1
-#cmakedefine HAVE_STRCMP 1
-#cmakedefine HAVE_STRNCMP 1
-#cmakedefine HAVE__STRICMP 1
-#cmakedefine HAVE_STRCASECMP 1
-#cmakedefine HAVE__STRNICMP 1
-#cmakedefine HAVE_STRNCASECMP 1
-#cmakedefine HAVE_STRCASESTR 1
-#cmakedefine HAVE_SSCANF 1
-#cmakedefine HAVE_VSSCANF 1
-#cmakedefine HAVE_VSNPRINTF 1
-#cmakedefine HAVE_M_PI 1
-#cmakedefine HAVE_ACOS 1
-#cmakedefine HAVE_ACOSF 1
-#cmakedefine HAVE_ASIN 1
-#cmakedefine HAVE_ASINF 1
-#cmakedefine HAVE_ATAN 1
-#cmakedefine HAVE_ATANF 1
-#cmakedefine HAVE_ATAN2 1
-#cmakedefine HAVE_ATAN2F 1
-#cmakedefine HAVE_CEIL 1
-#cmakedefine HAVE_CEILF 1
-#cmakedefine HAVE_COPYSIGN 1
-#cmakedefine HAVE_COPYSIGNF 1
-#cmakedefine HAVE_COS 1
-#cmakedefine HAVE_COSF 1
-#cmakedefine HAVE_EXP 1
-#cmakedefine HAVE_EXPF 1
-#cmakedefine HAVE_FABS 1
-#cmakedefine HAVE_FABSF 1
-#cmakedefine HAVE_FLOOR 1
-#cmakedefine HAVE_FLOORF 1
-#cmakedefine HAVE_FMOD 1
-#cmakedefine HAVE_FMODF 1
-#cmakedefine HAVE_LOG 1
-#cmakedefine HAVE_LOGF 1
-#cmakedefine HAVE_LOG10 1
-#cmakedefine HAVE_LOG10F 1
-#cmakedefine HAVE_LROUND 1
-#cmakedefine HAVE_LROUNDF 1
-#cmakedefine HAVE_POW 1
-#cmakedefine HAVE_POWF 1
-#cmakedefine HAVE_ROUND 1
-#cmakedefine HAVE_ROUNDF 1
-#cmakedefine HAVE_SCALBN 1
-#cmakedefine HAVE_SCALBNF 1
-#cmakedefine HAVE_SIN 1
-#cmakedefine HAVE_SINF 1
-#cmakedefine HAVE_SQRT 1
-#cmakedefine HAVE_SQRTF 1
-#cmakedefine HAVE_TAN 1
-#cmakedefine HAVE_TANF 1
-#cmakedefine HAVE_TRUNC 1
-#cmakedefine HAVE_TRUNCF 1
-#cmakedefine HAVE_FOPEN64 1
-#cmakedefine HAVE_FSEEKO 1
-#cmakedefine HAVE_FSEEKO64 1
-#cmakedefine HAVE_MEMFD_CREATE 1
-#cmakedefine HAVE_POSIX_FALLOCATE 1
-#cmakedefine HAVE_SIGACTION 1
-#cmakedefine HAVE_SIGTIMEDWAIT 1
-#cmakedefine HAVE_SA_SIGACTION 1
-#cmakedefine HAVE_SETJMP 1
-#cmakedefine HAVE_NANOSLEEP 1
-#cmakedefine HAVE_SYSCONF 1
-#cmakedefine HAVE_SYSCTLBYNAME 1
-#cmakedefine HAVE_CLOCK_GETTIME 1
-#cmakedefine HAVE_GETPAGESIZE 1
-#cmakedefine HAVE_MPROTECT 1
-#cmakedefine HAVE_ICONV 1
-#cmakedefine SDL_USE_LIBICONV 1
-#cmakedefine HAVE_PTHREAD_SETNAME_NP 1
-#cmakedefine HAVE_PTHREAD_SET_NAME_NP 1
-#cmakedefine HAVE_SEM_TIMEDWAIT 1
-#cmakedefine HAVE_GETAUXVAL 1
-#cmakedefine HAVE_ELF_AUX_INFO 1
-#cmakedefine HAVE_POLL 1
-#cmakedefine HAVE__EXIT 1
-
-#else
-#cmakedefine HAVE_STDARG_H 1
-#cmakedefine HAVE_STDDEF_H 1
-#cmakedefine HAVE_STDINT_H 1
-#cmakedefine HAVE_FLOAT_H 1
-#endif /* HAVE_LIBC */
-
-#cmakedefine HAVE_ALTIVEC_H 1
-#cmakedefine HAVE_DBUS_DBUS_H 1
-#cmakedefine HAVE_FCITX 1
-#cmakedefine HAVE_IBUS_IBUS_H 1
-#cmakedefine HAVE_SYS_INOTIFY_H 1
-#cmakedefine HAVE_INOTIFY_INIT 1
-#cmakedefine HAVE_INOTIFY_INIT1 1
-#cmakedefine HAVE_INOTIFY 1
-#cmakedefine HAVE_LIBUSB 1
-#cmakedefine HAVE_O_CLOEXEC 1
-
-/* Apple platforms might be building universal binaries, where Intel builds
-   can use immintrin.h but other architectures can't. */
-#ifdef __APPLE__
-#  if defined(__has_include) && (defined(__i386__) || defined(__x86_64))
-#    if __has_include(<immintrin.h>)
-#       define HAVE_IMMINTRIN_H 1
-#    endif
-#  endif
-#else  /* non-Apple platforms can use the normal CMake check for this. */
-#cmakedefine HAVE_IMMINTRIN_H 1
-#endif
-
-#cmakedefine HAVE_LIBUDEV_H 1
-#cmakedefine HAVE_LIBSAMPLERATE_H 1
-#cmakedefine HAVE_LIBDECOR_H 1
-
-#cmakedefine HAVE_D3D_H @HAVE_D3D_H@
-#cmakedefine HAVE_D3D11_H @HAVE_D3D11_H@
-#cmakedefine HAVE_D3D12_H @HAVE_D3D12_H@
-#cmakedefine HAVE_DDRAW_H @HAVE_DDRAW_H@
-#cmakedefine HAVE_DSOUND_H @HAVE_DSOUND_H@
-#cmakedefine HAVE_DINPUT_H @HAVE_DINPUT_H@
-#cmakedefine HAVE_XINPUT_H @HAVE_XINPUT_H@
-#cmakedefine HAVE_WINDOWS_GAMING_INPUT_H @HAVE_WINDOWS_GAMING_INPUT_H@
-#cmakedefine HAVE_DXGI_H @HAVE_DXGI_H@
-
-#cmakedefine HAVE_MMDEVICEAPI_H @HAVE_MMDEVICEAPI_H@
-#cmakedefine HAVE_AUDIOCLIENT_H @HAVE_AUDIOCLIENT_H@
-#cmakedefine HAVE_TPCSHRD_H @HAVE_TPCSHRD_H@
-#cmakedefine HAVE_SENSORSAPI_H @HAVE_SENSORSAPI_H@
-#cmakedefine HAVE_ROAPI_H @HAVE_ROAPI_H@
-#cmakedefine HAVE_SHELLSCALINGAPI_H @HAVE_SHELLSCALINGAPI_H@
-
-#cmakedefine USE_POSIX_SPAWN @USE_POSIX_SPAWN@
-
-/* SDL internal assertion support */
-#if @SDL_DEFAULT_ASSERT_LEVEL_CONFIGURED@
-#cmakedefine SDL_DEFAULT_ASSERT_LEVEL @SDL_DEFAULT_ASSERT_LEVEL@
-#endif
-
-/* Allow disabling of core subsystems */
-#cmakedefine SDL_ATOMIC_DISABLED @SDL_ATOMIC_DISABLED@
-#cmakedefine SDL_AUDIO_DISABLED @SDL_AUDIO_DISABLED@
-#cmakedefine SDL_CPUINFO_DISABLED @SDL_CPUINFO_DISABLED@
-#cmakedefine SDL_EVENTS_DISABLED @SDL_EVENTS_DISABLED@
-#cmakedefine SDL_FILE_DISABLED @SDL_FILE_DISABLED@
-#cmakedefine SDL_JOYSTICK_DISABLED @SDL_JOYSTICK_DISABLED@
-#cmakedefine SDL_HAPTIC_DISABLED @SDL_HAPTIC_DISABLED@
-#cmakedefine SDL_HIDAPI_DISABLED @SDL_HIDAPI_DISABLED@
-#cmakedefine SDL_SENSOR_DISABLED @SDL_SENSOR_DISABLED@
-#cmakedefine SDL_LOADSO_DISABLED @SDL_LOADSO_DISABLED@
-#cmakedefine SDL_RENDER_DISABLED @SDL_RENDER_DISABLED@
-#cmakedefine SDL_THREADS_DISABLED @SDL_THREADS_DISABLED@
-#cmakedefine SDL_TIMERS_DISABLED @SDL_TIMERS_DISABLED@
-#cmakedefine SDL_VIDEO_DISABLED @SDL_VIDEO_DISABLED@
-#cmakedefine SDL_POWER_DISABLED @SDL_POWER_DISABLED@
-#cmakedefine SDL_FILESYSTEM_DISABLED @SDL_FILESYSTEM_DISABLED@
-#cmakedefine SDL_LOCALE_DISABLED @SDL_LOCALE_DISABLED@
-#cmakedefine SDL_MISC_DISABLED @SDL_MISC_DISABLED@
-
-/* Enable various audio drivers */
-#cmakedefine SDL_AUDIO_DRIVER_ALSA @SDL_AUDIO_DRIVER_ALSA@
-#cmakedefine SDL_AUDIO_DRIVER_ALSA_DYNAMIC @SDL_AUDIO_DRIVER_ALSA_DYNAMIC@
-#cmakedefine SDL_AUDIO_DRIVER_ANDROID @SDL_AUDIO_DRIVER_ANDROID@
-#cmakedefine SDL_AUDIO_DRIVER_OPENSLES @SDL_AUDIO_DRIVER_OPENSLES@
-#cmakedefine SDL_AUDIO_DRIVER_AAUDIO @SDL_AUDIO_DRIVER_AAUDIO@
-#cmakedefine SDL_AUDIO_DRIVER_ARTS @SDL_AUDIO_DRIVER_ARTS@
-#cmakedefine SDL_AUDIO_DRIVER_ARTS_DYNAMIC @SDL_AUDIO_DRIVER_ARTS_DYNAMIC@
-#cmakedefine SDL_AUDIO_DRIVER_COREAUDIO @SDL_AUDIO_DRIVER_COREAUDIO@
-#cmakedefine SDL_AUDIO_DRIVER_DISK @SDL_AUDIO_DRIVER_DISK@
-#cmakedefine SDL_AUDIO_DRIVER_DSOUND @SDL_AUDIO_DRIVER_DSOUND@
-#cmakedefine SDL_AUDIO_DRIVER_DUMMY @SDL_AUDIO_DRIVER_DUMMY@
-#cmakedefine SDL_AUDIO_DRIVER_EMSCRIPTEN @SDL_AUDIO_DRIVER_EMSCRIPTEN@
-#cmakedefine SDL_AUDIO_DRIVER_ESD @SDL_AUDIO_DRIVER_ESD@
-#cmakedefine SDL_AUDIO_DRIVER_ESD_DYNAMIC @SDL_AUDIO_DRIVER_ESD_DYNAMIC@
-#cmakedefine SDL_AUDIO_DRIVER_FUSIONSOUND @SDL_AUDIO_DRIVER_FUSIONSOUND@
-#cmakedefine SDL_AUDIO_DRIVER_FUSIONSOUND_DYNAMIC @SDL_AUDIO_DRIVER_FUSIONSOUND_DYNAMIC@
-#cmakedefine SDL_AUDIO_DRIVER_HAIKU @SDL_AUDIO_DRIVER_HAIKU@
-#cmakedefine SDL_AUDIO_DRIVER_JACK @SDL_AUDIO_DRIVER_JACK@
-#cmakedefine SDL_AUDIO_DRIVER_JACK_DYNAMIC @SDL_AUDIO_DRIVER_JACK_DYNAMIC@
-#cmakedefine SDL_AUDIO_DRIVER_NAS @SDL_AUDIO_DRIVER_NAS@
-#cmakedefine SDL_AUDIO_DRIVER_NAS_DYNAMIC @SDL_AUDIO_DRIVER_NAS_DYNAMIC@
-#cmakedefine SDL_AUDIO_DRIVER_NETBSD @SDL_AUDIO_DRIVER_NETBSD@
-#cmakedefine SDL_AUDIO_DRIVER_OSS @SDL_AUDIO_DRIVER_OSS@
-#cmakedefine SDL_AUDIO_DRIVER_PAUDIO @SDL_AUDIO_DRIVER_PAUDIO@
-#cmakedefine SDL_AUDIO_DRIVER_PIPEWIRE @SDL_AUDIO_DRIVER_PIPEWIRE@
-#cmakedefine SDL_AUDIO_DRIVER_PIPEWIRE_DYNAMIC @SDL_AUDIO_DRIVER_PIPEWIRE_DYNAMIC@
-#cmakedefine SDL_AUDIO_DRIVER_PULSEAUDIO @SDL_AUDIO_DRIVER_PULSEAUDIO@
-#cmakedefine SDL_AUDIO_DRIVER_PULSEAUDIO_DYNAMIC @SDL_AUDIO_DRIVER_PULSEAUDIO_DYNAMIC@
-#cmakedefine SDL_AUDIO_DRIVER_QSA @SDL_AUDIO_DRIVER_QSA@
-#cmakedefine SDL_AUDIO_DRIVER_SNDIO @SDL_AUDIO_DRIVER_SNDIO@
-#cmakedefine SDL_AUDIO_DRIVER_SNDIO_DYNAMIC @SDL_AUDIO_DRIVER_SNDIO_DYNAMIC@
-#cmakedefine SDL_AUDIO_DRIVER_SUNAUDIO @SDL_AUDIO_DRIVER_SUNAUDIO@
-#cmakedefine SDL_AUDIO_DRIVER_WASAPI @SDL_AUDIO_DRIVER_WASAPI@
-#cmakedefine SDL_AUDIO_DRIVER_WINMM @SDL_AUDIO_DRIVER_WINMM@
-#cmakedefine SDL_AUDIO_DRIVER_OS2 @SDL_AUDIO_DRIVER_OS2@
-#cmakedefine SDL_AUDIO_DRIVER_VITA @SDL_AUDIO_DRIVER_VITA@
-#cmakedefine SDL_AUDIO_DRIVER_PSP @SDL_AUDIO_DRIVER_PSP@
-#cmakedefine SDL_AUDIO_DRIVER_PS2 @SDL_AUDIO_DRIVER_PS2@
-#cmakedefine SDL_AUDIO_DRIVER_N3DS @SDL_AUDIO_DRIVER_N3DS@
-
-/* Enable various input drivers */
-#cmakedefine SDL_INPUT_LINUXEV @SDL_INPUT_LINUXEV@
-#cmakedefine SDL_INPUT_LINUXKD @SDL_INPUT_LINUXKD@
-#cmakedefine SDL_INPUT_FBSDKBIO @SDL_INPUT_FBSDKBIO@
-#cmakedefine SDL_INPUT_WSCONS @SDL_INPUT_WSCONS@
-#cmakedefine SDL_JOYSTICK_ANDROID @SDL_JOYSTICK_ANDROID@
-#cmakedefine SDL_JOYSTICK_HAIKU @SDL_JOYSTICK_HAIKU@
-#cmakedefine SDL_JOYSTICK_WGI @SDL_JOYSTICK_WGI@
-#cmakedefine SDL_JOYSTICK_DINPUT @SDL_JOYSTICK_DINPUT@
-#cmakedefine SDL_JOYSTICK_XINPUT @SDL_JOYSTICK_XINPUT@
-#cmakedefine SDL_JOYSTICK_DUMMY @SDL_JOYSTICK_DUMMY@
-#cmakedefine SDL_JOYSTICK_IOKIT @SDL_JOYSTICK_IOKIT@
-#cmakedefine SDL_JOYSTICK_MFI @SDL_JOYSTICK_MFI@
-#cmakedefine SDL_JOYSTICK_LINUX @SDL_JOYSTICK_LINUX@
-#cmakedefine SDL_JOYSTICK_OS2 @SDL_JOYSTICK_OS2@
-#cmakedefine SDL_JOYSTICK_USBHID @SDL_JOYSTICK_USBHID@
-#cmakedefine SDL_HAVE_MACHINE_JOYSTICK_H @SDL_HAVE_MACHINE_JOYSTICK_H@
-#cmakedefine SDL_JOYSTICK_HIDAPI @SDL_JOYSTICK_HIDAPI@
-#cmakedefine SDL_JOYSTICK_RAWINPUT @SDL_JOYSTICK_RAWINPUT@
-#cmakedefine SDL_JOYSTICK_EMSCRIPTEN @SDL_JOYSTICK_EMSCRIPTEN@
-#cmakedefine SDL_JOYSTICK_VIRTUAL @SDL_JOYSTICK_VIRTUAL@
-#cmakedefine SDL_JOYSTICK_VITA @SDL_JOYSTICK_VITA@
-#cmakedefine SDL_JOYSTICK_PSP @SDL_JOYSTICK_PSP@
-#cmakedefine SDL_JOYSTICK_PS2 @SDL_JOYSTICK_PS2@
-#cmakedefine SDL_JOYSTICK_N3DS @SDL_JOYSTICK_N3DS@
-#cmakedefine SDL_HAPTIC_DUMMY @SDL_HAPTIC_DUMMY@
-#cmakedefine SDL_HAPTIC_LINUX @SDL_HAPTIC_LINUX@
-#cmakedefine SDL_HAPTIC_IOKIT @SDL_HAPTIC_IOKIT@
-#cmakedefine SDL_HAPTIC_DINPUT @SDL_HAPTIC_DINPUT@
-#cmakedefine SDL_HAPTIC_XINPUT @SDL_HAPTIC_XINPUT@
-#cmakedefine SDL_HAPTIC_ANDROID @SDL_HAPTIC_ANDROID@
-#cmakedefine SDL_LIBUSB_DYNAMIC @SDL_LIBUSB_DYNAMIC@
-#cmakedefine SDL_UDEV_DYNAMIC @SDL_UDEV_DYNAMIC@
-
-/* Enable various sensor drivers */
-#cmakedefine SDL_SENSOR_ANDROID @SDL_SENSOR_ANDROID@
-#cmakedefine SDL_SENSOR_COREMOTION @SDL_SENSOR_COREMOTION@
-#cmakedefine SDL_SENSOR_WINDOWS @SDL_SENSOR_WINDOWS@
-#cmakedefine SDL_SENSOR_DUMMY @SDL_SENSOR_DUMMY@
-#cmakedefine SDL_SENSOR_VITA @SDL_SENSOR_VITA@
-#cmakedefine SDL_SENSOR_N3DS @SDL_SENSOR_N3DS@
-
-/* Enable various shared object loading systems */
-#cmakedefine SDL_LOADSO_DLOPEN @SDL_LOADSO_DLOPEN@
-#cmakedefine SDL_LOADSO_DUMMY @SDL_LOADSO_DUMMY@
-#cmakedefine SDL_LOADSO_LDG @SDL_LOADSO_LDG@
-#cmakedefine SDL_LOADSO_WINDOWS @SDL_LOADSO_WINDOWS@
-#cmakedefine SDL_LOADSO_OS2 @SDL_LOADSO_OS2@
-
-/* Enable various threading systems */
-#cmakedefine SDL_THREAD_GENERIC_COND_SUFFIX @SDL_THREAD_GENERIC_COND_SUFFIX@
-#cmakedefine SDL_THREAD_PTHREAD @SDL_THREAD_PTHREAD@
-#cmakedefine SDL_THREAD_PTHREAD_RECURSIVE_MUTEX @SDL_THREAD_PTHREAD_RECURSIVE_MUTEX@
-#cmakedefine SDL_THREAD_PTHREAD_RECURSIVE_MUTEX_NP @SDL_THREAD_PTHREAD_RECURSIVE_MUTEX_NP@
-#cmakedefine SDL_THREAD_WINDOWS @SDL_THREAD_WINDOWS@
-#cmakedefine SDL_THREAD_OS2 @SDL_THREAD_OS2@
-#cmakedefine SDL_THREAD_VITA @SDL_THREAD_VITA@
-#cmakedefine SDL_THREAD_PSP @SDL_THREAD_PSP@
-#cmakedefine SDL_THREAD_PS2 @SDL_THREAD_PS2@
-#cmakedefine SDL_THREAD_N3DS @SDL_THREAD_N3DS@
-
-/* Enable various timer systems */
-#cmakedefine SDL_TIMER_HAIKU @SDL_TIMER_HAIKU@
-#cmakedefine SDL_TIMER_DUMMY @SDL_TIMER_DUMMY@
-#cmakedefine SDL_TIMER_UNIX @SDL_TIMER_UNIX@
-#cmakedefine SDL_TIMER_WINDOWS @SDL_TIMER_WINDOWS@
-#cmakedefine SDL_TIMER_OS2 @SDL_TIMER_OS2@
-#cmakedefine SDL_TIMER_VITA @SDL_TIMER_VITA@
-#cmakedefine SDL_TIMER_PSP @SDL_TIMER_PSP@
-#cmakedefine SDL_TIMER_PS2 @SDL_TIMER_PS2@
-#cmakedefine SDL_TIMER_N3DS @SDL_TIMER_N3DS@
-
-/* Enable various video drivers */
-#cmakedefine SDL_VIDEO_DRIVER_ANDROID @SDL_VIDEO_DRIVER_ANDROID@
-#cmakedefine SDL_VIDEO_DRIVER_EMSCRIPTEN @SDL_VIDEO_DRIVER_EMSCRIPTEN@
-#cmakedefine SDL_VIDEO_DRIVER_HAIKU @SDL_VIDEO_DRIVER_HAIKU@
-#cmakedefine SDL_VIDEO_DRIVER_COCOA @SDL_VIDEO_DRIVER_COCOA@
-#cmakedefine SDL_VIDEO_DRIVER_UIKIT @SDL_VIDEO_DRIVER_UIKIT@
-#cmakedefine SDL_VIDEO_DRIVER_DIRECTFB @SDL_VIDEO_DRIVER_DIRECTFB@
-#cmakedefine SDL_VIDEO_DRIVER_DIRECTFB_DYNAMIC @SDL_VIDEO_DRIVER_DIRECTFB_DYNAMIC@
-#cmakedefine SDL_VIDEO_DRIVER_DUMMY @SDL_VIDEO_DRIVER_DUMMY@
-#cmakedefine SDL_VIDEO_DRIVER_OFFSCREEN @SDL_VIDEO_DRIVER_OFFSCREEN@
-#cmakedefine SDL_VIDEO_DRIVER_WINDOWS @SDL_VIDEO_DRIVER_WINDOWS@
-#cmakedefine SDL_VIDEO_DRIVER_WINRT @SDL_VIDEO_DRIVER_WINRT@
-#cmakedefine SDL_VIDEO_DRIVER_WAYLAND @SDL_VIDEO_DRIVER_WAYLAND@
-#cmakedefine SDL_VIDEO_DRIVER_RPI @SDL_VIDEO_DRIVER_RPI@
-#cmakedefine SDL_VIDEO_DRIVER_VIVANTE @SDL_VIDEO_DRIVER_VIVANTE@
-#cmakedefine SDL_VIDEO_DRIVER_VIVANTE_VDK @SDL_VIDEO_DRIVER_VIVANTE_VDK@
-#cmakedefine SDL_VIDEO_DRIVER_OS2 @SDL_VIDEO_DRIVER_OS2@
-#cmakedefine SDL_VIDEO_DRIVER_QNX @SDL_VIDEO_DRIVER_QNX@
-#cmakedefine SDL_VIDEO_DRIVER_RISCOS @SDL_VIDEO_DRIVER_RISCOS@
-#cmakedefine SDL_VIDEO_DRIVER_PSP @SDL_VIDEO_DRIVER_PSP@
-#cmakedefine SDL_VIDEO_DRIVER_PS2 @SDL_VIDEO_DRIVER_PS2@
-
-#cmakedefine SDL_VIDEO_DRIVER_KMSDRM @SDL_VIDEO_DRIVER_KMSDRM@
-#cmakedefine SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC @SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC@
-#cmakedefine SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC_GBM @SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC_GBM@
-
-#cmakedefine SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH @SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH@
-#cmakedefine SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC @SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC@
-#cmakedefine SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_EGL @SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_EGL@
-#cmakedefine SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_CURSOR @SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_CURSOR@
-#cmakedefine SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_XKBCOMMON @SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_XKBCOMMON@
-#cmakedefine SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_LIBDECOR @SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_LIBDECOR@
-
-#cmakedefine SDL_VIDEO_DRIVER_X11 @SDL_VIDEO_DRIVER_X11@
-#cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC @SDL_VIDEO_DRIVER_X11_DYNAMIC@
-#cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT @SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT@
-#cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XCURSOR @SDL_VIDEO_DRIVER_X11_DYNAMIC_XCURSOR@
-#cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XINPUT2 @SDL_VIDEO_DRIVER_X11_DYNAMIC_XINPUT2@
-#cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XFIXES @SDL_VIDEO_DRIVER_X11_DYNAMIC_XFIXES@
-#cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR @SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR@
-#cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XSS @SDL_VIDEO_DRIVER_X11_DYNAMIC_XSS@
-#cmakedefine SDL_VIDEO_DRIVER_X11_XCURSOR @SDL_VIDEO_DRIVER_X11_XCURSOR@
-#cmakedefine SDL_VIDEO_DRIVER_X11_XDBE @SDL_VIDEO_DRIVER_X11_XDBE@
-#cmakedefine SDL_VIDEO_DRIVER_X11_XINPUT2 @SDL_VIDEO_DRIVER_X11_XINPUT2@
-#cmakedefine SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH @SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH@
-#cmakedefine SDL_VIDEO_DRIVER_X11_XFIXES @SDL_VIDEO_DRIVER_X11_XFIXES@
-#cmakedefine SDL_VIDEO_DRIVER_X11_XRANDR @SDL_VIDEO_DRIVER_X11_XRANDR@
-#cmakedefine SDL_VIDEO_DRIVER_X11_XSCRNSAVER @SDL_VIDEO_DRIVER_X11_XSCRNSAVER@
-#cmakedefine SDL_VIDEO_DRIVER_X11_XSHAPE @SDL_VIDEO_DRIVER_X11_XSHAPE@
-#cmakedefine SDL_VIDEO_DRIVER_X11_SUPPORTS_GENERIC_EVENTS @SDL_VIDEO_DRIVER_X11_SUPPORTS_GENERIC_EVENTS@
-#cmakedefine SDL_VIDEO_DRIVER_X11_HAS_XKBKEYCODETOKEYSYM @SDL_VIDEO_DRIVER_X11_HAS_XKBKEYCODETOKEYSYM@
-#cmakedefine SDL_VIDEO_DRIVER_VITA @SDL_VIDEO_DRIVER_VITA@
-#cmakedefine SDL_VIDEO_DRIVER_N3DS @SDL_VIDEO_DRIVER_N3DS@
-
-#cmakedefine SDL_VIDEO_RENDER_D3D @SDL_VIDEO_RENDER_D3D@
-#cmakedefine SDL_VIDEO_RENDER_D3D11 @SDL_VIDEO_RENDER_D3D11@
-#cmakedefine SDL_VIDEO_RENDER_D3D12 @SDL_VIDEO_RENDER_D3D12@
-#cmakedefine SDL_VIDEO_RENDER_OGL @SDL_VIDEO_RENDER_OGL@
-#cmakedefine SDL_VIDEO_RENDER_OGL_ES @SDL_VIDEO_RENDER_OGL_ES@
-#cmakedefine SDL_VIDEO_RENDER_OGL_ES2 @SDL_VIDEO_RENDER_OGL_ES2@
-#cmakedefine SDL_VIDEO_RENDER_DIRECTFB @SDL_VIDEO_RENDER_DIRECTFB@
-#cmakedefine SDL_VIDEO_RENDER_METAL @SDL_VIDEO_RENDER_METAL@
-#cmakedefine SDL_VIDEO_RENDER_VITA_GXM @SDL_VIDEO_RENDER_VITA_GXM@
-#cmakedefine SDL_VIDEO_RENDER_PS2 @SDL_VIDEO_RENDER_PS2@
-#cmakedefine SDL_VIDEO_RENDER_PSP @SDL_VIDEO_RENDER_PSP@
-
-/* Enable OpenGL support */
-#cmakedefine SDL_VIDEO_OPENGL @SDL_VIDEO_OPENGL@
-#cmakedefine SDL_VIDEO_OPENGL_ES @SDL_VIDEO_OPENGL_ES@
-#cmakedefine SDL_VIDEO_OPENGL_ES2 @SDL_VIDEO_OPENGL_ES2@
-#cmakedefine SDL_VIDEO_OPENGL_BGL @SDL_VIDEO_OPENGL_BGL@
-#cmakedefine SDL_VIDEO_OPENGL_CGL @SDL_VIDEO_OPENGL_CGL@
-#cmakedefine SDL_VIDEO_OPENGL_GLX @SDL_VIDEO_OPENGL_GLX@
-#cmakedefine SDL_VIDEO_OPENGL_WGL @SDL_VIDEO_OPENGL_WGL@
-#cmakedefine SDL_VIDEO_OPENGL_EGL @SDL_VIDEO_OPENGL_EGL@
-#cmakedefine SDL_VIDEO_OPENGL_OSMESA @SDL_VIDEO_OPENGL_OSMESA@
-#cmakedefine SDL_VIDEO_OPENGL_OSMESA_DYNAMIC @SDL_VIDEO_OPENGL_OSMESA_DYNAMIC@
-
-/* Enable Vulkan support */
-#cmakedefine SDL_VIDEO_VULKAN @SDL_VIDEO_VULKAN@
-
-/* Enable Metal support */
-#cmakedefine SDL_VIDEO_METAL @SDL_VIDEO_METAL@
-
-/* Enable system power support */
-#cmakedefine SDL_POWER_ANDROID @SDL_POWER_ANDROID@
-#cmakedefine SDL_POWER_LINUX @SDL_POWER_LINUX@
-#cmakedefine SDL_POWER_WINDOWS @SDL_POWER_WINDOWS@
-#cmakedefine SDL_POWER_WINRT @SDL_POWER_WINRT@
-#cmakedefine SDL_POWER_MACOSX @SDL_POWER_MACOSX@
-#cmakedefine SDL_POWER_UIKIT @SDL_POWER_UIKIT@
-#cmakedefine SDL_POWER_HAIKU @SDL_POWER_HAIKU@
-#cmakedefine SDL_POWER_EMSCRIPTEN @SDL_POWER_EMSCRIPTEN@
-#cmakedefine SDL_POWER_HARDWIRED @SDL_POWER_HARDWIRED@
-#cmakedefine SDL_POWER_VITA @SDL_POWER_VITA@
-#cmakedefine SDL_POWER_PSP @SDL_POWER_PSP@
-#cmakedefine SDL_POWER_N3DS @SDL_POWER_N3DS@
-
-/* Enable system filesystem support */
-#cmakedefine SDL_FILESYSTEM_ANDROID @SDL_FILESYSTEM_ANDROID@
-#cmakedefine SDL_FILESYSTEM_HAIKU @SDL_FILESYSTEM_HAIKU@
-#cmakedefine SDL_FILESYSTEM_COCOA @SDL_FILESYSTEM_COCOA@
-#cmakedefine SDL_FILESYSTEM_DUMMY @SDL_FILESYSTEM_DUMMY@
-#cmakedefine SDL_FILESYSTEM_RISCOS @SDL_FILESYSTEM_RISCOS@
-#cmakedefine SDL_FILESYSTEM_UNIX @SDL_FILESYSTEM_UNIX@
-#cmakedefine SDL_FILESYSTEM_WINDOWS @SDL_FILESYSTEM_WINDOWS@
-#cmakedefine SDL_FILESYSTEM_EMSCRIPTEN @SDL_FILESYSTEM_EMSCRIPTEN@
-#cmakedefine SDL_FILESYSTEM_OS2 @SDL_FILESYSTEM_OS2@
-#cmakedefine SDL_FILESYSTEM_VITA @SDL_FILESYSTEM_VITA@
-#cmakedefine SDL_FILESYSTEM_PSP @SDL_FILESYSTEM_PSP@
-#cmakedefine SDL_FILESYSTEM_PS2 @SDL_FILESYSTEM_PS2@
-#cmakedefine SDL_FILESYSTEM_N3DS @SDL_FILESYSTEM_N3DS@
-
-/* Enable misc subsystem */
-#cmakedefine SDL_MISC_DUMMY @SDL_MISC_DUMMY@
-
-/* Enable locale subsystem */
-#cmakedefine SDL_LOCALE_DUMMY @SDL_LOCALE_DUMMY@
-
-/* Enable assembly routines */
-#cmakedefine SDL_ALTIVEC_BLITTERS @SDL_ALTIVEC_BLITTERS@
-#cmakedefine SDL_ARM_SIMD_BLITTERS @SDL_ARM_SIMD_BLITTERS@
-#cmakedefine SDL_ARM_NEON_BLITTERS @SDL_ARM_NEON_BLITTERS@
-
-/* Whether SDL_DYNAMIC_API needs dlopen */
-#cmakedefine DYNAPI_NEEDS_DLOPEN @DYNAPI_NEEDS_DLOPEN@
-
-/* Enable dynamic libsamplerate support */
-#cmakedefine SDL_LIBSAMPLERATE_DYNAMIC @SDL_LIBSAMPLERATE_DYNAMIC@
-
-/* Enable ime support */
-#cmakedefine SDL_USE_IME @SDL_USE_IME@
-
-/* Platform specific definitions */
-#cmakedefine SDL_IPHONE_KEYBOARD @SDL_IPHONE_KEYBOARD@
-#cmakedefine SDL_IPHONE_LAUNCHSCREEN @SDL_IPHONE_LAUNCHSCREEN@
-
-#cmakedefine SDL_VIDEO_VITA_PIB @SDL_VIDEO_VITA_PIB@
-#cmakedefine SDL_VIDEO_VITA_PVR @SDL_VIDEO_VITA_PVR@
-#cmakedefine SDL_VIDEO_VITA_PVR_OGL @SDL_VIDEO_VITA_PVR_OGL@
-
-#cmakedefine SDL_HAVE_LIBDECOR_GET_MIN_MAX @SDL_HAVE_LIBDECOR_GET_MIN_MAX@
-
-#if !defined(HAVE_STDINT_H) && !defined(_STDINT_H_)
-/* Most everything except Visual Studio 2008 and earlier has stdint.h now */
-#if defined(_MSC_VER) && (_MSC_VER < 1600)
-typedef signed __int8 int8_t;
-typedef unsigned __int8 uint8_t;
-typedef signed __int16 int16_t;
-typedef unsigned __int16 uint16_t;
-typedef signed __int32 int32_t;
-typedef unsigned __int32 uint32_t;
-typedef signed __int64 int64_t;
-typedef unsigned __int64 uint64_t;
-#ifndef _UINTPTR_T_DEFINED
-#ifdef  _WIN64
-typedef unsigned __int64 uintptr_t;
-#else
-typedef unsigned int uintptr_t;
-#endif
-#define _UINTPTR_T_DEFINED
-#endif
-#endif /* Visual Studio 2008 */
-#endif /* !_STDINT_H_ && !HAVE_STDINT_H */
-
-#endif /* SDL_config_h_ */

thirdparty/include/android/SDL2/SDL_config.h.in

@@ -1,500 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_config_h_
-#define SDL_config_h_
-
-/**
- *  \file SDL_config.h.in
- *
- *  This is a set of defines to configure the SDL features
- */
-
-/* General platform specific identifiers */
-#include "SDL_platform.h"
-
-/* Make sure that this isn't included by Visual C++ */
-#ifdef _MSC_VER
-#error You should run git checkout -f include/SDL_config.h
-#endif
-
-/* C language features */
-#undef const
-#undef inline
-#undef volatile
-
-/* C datatypes */
-#if defined(__LP64__) || defined(_LP64) || defined(_WIN64)
-#define SIZEOF_VOIDP 8
-#else
-#define SIZEOF_VOIDP 4
-#endif
-
-#undef HAVE_GCC_ATOMICS
-#undef HAVE_GCC_SYNC_LOCK_TEST_AND_SET
-
-/* Comment this if you want to build without any C library requirements */
-#undef HAVE_LIBC
-#ifdef HAVE_LIBC
-
-/* Useful headers */
-#undef STDC_HEADERS
-#undef HAVE_ALLOCA_H
-#undef HAVE_CTYPE_H
-#undef HAVE_FLOAT_H
-#undef HAVE_ICONV_H
-#undef HAVE_INTTYPES_H
-#undef HAVE_LIMITS_H
-#undef HAVE_MALLOC_H
-#undef HAVE_MATH_H
-#undef HAVE_MEMORY_H
-#undef HAVE_SIGNAL_H
-#undef HAVE_STDARG_H
-#undef HAVE_STDINT_H
-#undef HAVE_STDIO_H
-#undef HAVE_STDLIB_H
-#undef HAVE_STRINGS_H
-#undef HAVE_STRING_H
-#undef HAVE_SYS_TYPES_H
-#undef HAVE_WCHAR_H
-#undef HAVE_LINUX_INPUT_H
-#undef HAVE_PTHREAD_NP_H
-#undef HAVE_LIBUNWIND_H
-
-/* C library functions */
-#undef HAVE_DLOPEN
-#undef HAVE_MALLOC
-#undef HAVE_CALLOC
-#undef HAVE_REALLOC
-#undef HAVE_FREE
-#undef HAVE_ALLOCA
-#ifndef __WIN32__ /* Don't use C runtime versions of these on Windows */
-#undef HAVE_GETENV
-#undef HAVE_SETENV
-#undef HAVE_PUTENV
-#undef HAVE_UNSETENV
-#endif
-#undef HAVE_QSORT
-#undef HAVE_BSEARCH
-#undef HAVE_ABS
-#undef HAVE_BCOPY
-#undef HAVE_MEMSET
-#undef HAVE_MEMCPY
-#undef HAVE_MEMMOVE
-#undef HAVE_MEMCMP
-#undef HAVE_WCSLEN
-#undef HAVE_WCSLCPY
-#undef HAVE_WCSLCAT
-#undef HAVE__WCSDUP
-#undef HAVE_WCSDUP
-#undef HAVE_WCSSTR
-#undef HAVE_WCSCMP
-#undef HAVE_WCSNCMP
-#undef HAVE_WCSCASECMP
-#undef HAVE__WCSICMP
-#undef HAVE_WCSNCASECMP
-#undef HAVE__WCSNICMP
-#undef HAVE_STRLEN
-#undef HAVE_STRLCPY
-#undef HAVE_STRLCAT
-#undef HAVE__STRREV
-#undef HAVE__STRUPR
-#undef HAVE__STRLWR
-#undef HAVE_INDEX
-#undef HAVE_RINDEX
-#undef HAVE_STRCHR
-#undef HAVE_STRRCHR
-#undef HAVE_STRSTR
-#undef HAVE_STRTOK_R
-#undef HAVE_ITOA
-#undef HAVE__LTOA
-#undef HAVE__UITOA
-#undef HAVE__ULTOA
-#undef HAVE_STRTOL
-#undef HAVE_STRTOUL
-#undef HAVE__I64TOA
-#undef HAVE__UI64TOA
-#undef HAVE_STRTOLL
-#undef HAVE_STRTOULL
-#undef HAVE_STRTOD
-#undef HAVE_ATOI
-#undef HAVE_ATOF
-#undef HAVE_STRCMP
-#undef HAVE_STRNCMP
-#undef HAVE__STRICMP
-#undef HAVE_STRCASECMP
-#undef HAVE__STRNICMP
-#undef HAVE_STRNCASECMP
-#undef HAVE_STRCASESTR
-#undef HAVE_SSCANF
-#undef HAVE_VSSCANF
-#undef HAVE_SNPRINTF
-#undef HAVE_VSNPRINTF
-#undef HAVE_M_PI
-#undef HAVE_ACOS
-#undef HAVE_ACOSF
-#undef HAVE_ASIN
-#undef HAVE_ASINF
-#undef HAVE_ATAN
-#undef HAVE_ATANF
-#undef HAVE_ATAN2
-#undef HAVE_ATAN2F
-#undef HAVE_CEIL
-#undef HAVE_CEILF
-#undef HAVE_COPYSIGN
-#undef HAVE_COPYSIGNF
-#undef HAVE_COS
-#undef HAVE_COSF
-#undef HAVE_EXP
-#undef HAVE_EXPF
-#undef HAVE_FABS
-#undef HAVE_FABSF
-#undef HAVE_FLOOR
-#undef HAVE_FLOORF
-#undef HAVE_FMOD
-#undef HAVE_FMODF
-#undef HAVE_LOG
-#undef HAVE_LOGF
-#undef HAVE_LOG10
-#undef HAVE_LOG10F
-#undef HAVE_LROUND
-#undef HAVE_LROUNDF
-#undef HAVE_POW
-#undef HAVE_POWF
-#undef HAVE_ROUND
-#undef HAVE_ROUNDF
-#undef HAVE_SCALBN
-#undef HAVE_SCALBNF
-#undef HAVE_SIN
-#undef HAVE_SINF
-#undef HAVE_SQRT
-#undef HAVE_SQRTF
-#undef HAVE_TAN
-#undef HAVE_TANF
-#undef HAVE_TRUNC
-#undef HAVE_TRUNCF
-#undef HAVE_FOPEN64
-#undef HAVE_FSEEKO
-#undef HAVE_FSEEKO64
-#undef HAVE_SIGACTION
-#undef HAVE_SIGTIMEDWAIT
-#undef HAVE_SA_SIGACTION
-#undef HAVE_SETJMP
-#undef HAVE_NANOSLEEP
-#undef HAVE_SYSCONF
-#undef HAVE_SYSCTLBYNAME
-#undef HAVE_CLOCK_GETTIME
-#undef HAVE_GETPAGESIZE
-#undef HAVE_MPROTECT
-#undef HAVE_ICONV
-#undef SDL_USE_LIBICONV
-#undef HAVE_PTHREAD_SETNAME_NP
-#undef HAVE_PTHREAD_SET_NAME_NP
-#undef HAVE_SEM_TIMEDWAIT
-#undef HAVE_GETAUXVAL
-#undef HAVE_ELF_AUX_INFO
-#undef HAVE_POLL
-#undef HAVE_MEMFD_CREATE
-#undef HAVE_POSIX_FALLOCATE
-#undef HAVE__EXIT
-
-#else
-
-#define HAVE_STDARG_H 1
-#define HAVE_STDDEF_H 1
-#define HAVE_STDINT_H 1
-#endif /* HAVE_LIBC */
-
-#undef HAVE_O_CLOEXEC
-#undef HAVE_ALTIVEC_H
-#undef HAVE_DBUS_DBUS_H
-#undef HAVE_FCITX
-#undef HAVE_SYS_INOTIFY_H
-#undef HAVE_INOTIFY_INIT
-#undef HAVE_INOTIFY_INIT1
-#undef HAVE_INOTIFY
-#undef HAVE_IBUS_IBUS_H
-#undef HAVE_IMMINTRIN_H
-#undef HAVE_LIBUDEV_H
-#undef HAVE_LIBUSB
-#undef HAVE_LIBSAMPLERATE_H
-#undef HAVE_LIBDECOR_H
-#undef HAVE_LSXINTRIN_H
-#undef HAVE_LASXINTRIN_H
-
-#undef HAVE_DDRAW_H
-#undef HAVE_DINPUT_H
-#undef HAVE_DSOUND_H
-#undef HAVE_DXGI_H
-#undef HAVE_WINDOWS_GAMING_INPUT_H
-#undef HAVE_XINPUT_H
-
-#undef HAVE_MMDEVICEAPI_H
-#undef HAVE_AUDIOCLIENT_H
-#undef HAVE_TPCSHRD_H
-#undef HAVE_SENSORSAPI_H
-#undef HAVE_ROAPI_H
-#undef HAVE_SHELLSCALINGAPI_H
-
-/* SDL internal assertion support */
-#undef SDL_DEFAULT_ASSERT_LEVEL
-
-/* Allow disabling of core subsystems */
-#undef SDL_ATOMIC_DISABLED
-#undef SDL_AUDIO_DISABLED
-#undef SDL_CPUINFO_DISABLED
-#undef SDL_EVENTS_DISABLED
-#undef SDL_FILE_DISABLED
-#undef SDL_JOYSTICK_DISABLED
-#undef SDL_HAPTIC_DISABLED
-#undef SDL_HIDAPI_DISABLED
-#undef SDL_SENSOR_DISABLED
-#undef SDL_LOADSO_DISABLED
-#undef SDL_RENDER_DISABLED
-#undef SDL_THREADS_DISABLED
-#undef SDL_TIMERS_DISABLED
-#undef SDL_VIDEO_DISABLED
-#undef SDL_POWER_DISABLED
-#undef SDL_FILESYSTEM_DISABLED
-#undef SDL_LOCALE_DISABLED
-#undef SDL_MISC_DISABLED
-
-/* Enable various audio drivers */
-#undef SDL_AUDIO_DRIVER_AAUDIO
-#undef SDL_AUDIO_DRIVER_ALSA
-#undef SDL_AUDIO_DRIVER_ALSA_DYNAMIC
-#undef SDL_AUDIO_DRIVER_ANDROID
-#undef SDL_AUDIO_DRIVER_ARTS
-#undef SDL_AUDIO_DRIVER_ARTS_DYNAMIC
-#undef SDL_AUDIO_DRIVER_COREAUDIO
-#undef SDL_AUDIO_DRIVER_DISK
-#undef SDL_AUDIO_DRIVER_DSOUND
-#undef SDL_AUDIO_DRIVER_DUMMY
-#undef SDL_AUDIO_DRIVER_EMSCRIPTEN
-#undef SDL_AUDIO_DRIVER_ESD
-#undef SDL_AUDIO_DRIVER_ESD_DYNAMIC
-#undef SDL_AUDIO_DRIVER_FUSIONSOUND
-#undef SDL_AUDIO_DRIVER_FUSIONSOUND_DYNAMIC
-#undef SDL_AUDIO_DRIVER_HAIKU
-#undef SDL_AUDIO_DRIVER_JACK
-#undef SDL_AUDIO_DRIVER_JACK_DYNAMIC
-#undef SDL_AUDIO_DRIVER_NACL
-#undef SDL_AUDIO_DRIVER_NAS
-#undef SDL_AUDIO_DRIVER_NAS_DYNAMIC
-#undef SDL_AUDIO_DRIVER_NETBSD
-#undef SDL_AUDIO_DRIVER_OPENSLES
-#undef SDL_AUDIO_DRIVER_OSS
-#undef SDL_AUDIO_DRIVER_PAUDIO
-#undef SDL_AUDIO_DRIVER_PIPEWIRE
-#undef SDL_AUDIO_DRIVER_PIPEWIRE_DYNAMIC
-#undef SDL_AUDIO_DRIVER_PULSEAUDIO
-#undef SDL_AUDIO_DRIVER_PULSEAUDIO_DYNAMIC
-#undef SDL_AUDIO_DRIVER_QSA
-#undef SDL_AUDIO_DRIVER_SNDIO
-#undef SDL_AUDIO_DRIVER_SNDIO_DYNAMIC
-#undef SDL_AUDIO_DRIVER_SUNAUDIO
-#undef SDL_AUDIO_DRIVER_WASAPI
-#undef SDL_AUDIO_DRIVER_WINMM
-#undef SDL_AUDIO_DRIVER_OS2
-
-/* Enable various input drivers */
-#undef SDL_INPUT_LINUXEV
-#undef SDL_INPUT_FBSDKBIO
-#undef SDL_INPUT_LINUXKD
-#undef SDL_INPUT_WSCONS
-#undef SDL_JOYSTICK_HAIKU
-#undef SDL_JOYSTICK_DINPUT
-#undef SDL_JOYSTICK_WGI
-#undef SDL_JOYSTICK_XINPUT
-#undef SDL_JOYSTICK_DUMMY
-#undef SDL_JOYSTICK_IOKIT
-#undef SDL_JOYSTICK_MFI
-#undef SDL_JOYSTICK_LINUX
-#undef SDL_JOYSTICK_ANDROID
-#undef SDL_JOYSTICK_OS2
-#undef SDL_JOYSTICK_USBHID
-#undef SDL_HAVE_MACHINE_JOYSTICK_H
-#undef SDL_JOYSTICK_HIDAPI
-#undef SDL_JOYSTICK_RAWINPUT
-#undef SDL_JOYSTICK_EMSCRIPTEN
-#undef SDL_JOYSTICK_VIRTUAL
-#undef SDL_HAPTIC_DUMMY
-#undef SDL_HAPTIC_ANDROID
-#undef SDL_HAPTIC_LINUX
-#undef SDL_HAPTIC_IOKIT
-#undef SDL_HAPTIC_DINPUT
-#undef SDL_HAPTIC_XINPUT
-
-/* Enable various sensor drivers */
-#undef SDL_SENSOR_ANDROID
-#undef SDL_SENSOR_COREMOTION
-#undef SDL_SENSOR_WINDOWS
-#undef SDL_SENSOR_DUMMY
-
-/* Enable various shared object loading systems */
-#undef SDL_LOADSO_DLOPEN
-#undef SDL_LOADSO_DUMMY
-#undef SDL_LOADSO_LDG
-#undef SDL_LOADSO_WINDOWS
-#undef SDL_LOADSO_OS2
-
-/* Enable various threading systems */
-#undef SDL_THREAD_GENERIC_COND_SUFFIX
-#undef SDL_THREAD_PTHREAD
-#undef SDL_THREAD_PTHREAD_RECURSIVE_MUTEX
-#undef SDL_THREAD_PTHREAD_RECURSIVE_MUTEX_NP
-#undef SDL_THREAD_WINDOWS
-#undef SDL_THREAD_OS2
-
-/* Enable various timer systems */
-#undef SDL_TIMER_HAIKU
-#undef SDL_TIMER_DUMMY
-#undef SDL_TIMER_UNIX
-#undef SDL_TIMER_WINDOWS
-#undef SDL_TIMER_OS2
-
-/* Enable various video drivers */
-#undef SDL_VIDEO_DRIVER_HAIKU
-#undef SDL_VIDEO_DRIVER_COCOA
-#undef SDL_VIDEO_DRIVER_DIRECTFB
-#undef SDL_VIDEO_DRIVER_DIRECTFB_DYNAMIC
-#undef SDL_VIDEO_DRIVER_DUMMY
-#undef SDL_VIDEO_DRIVER_WINDOWS
-#undef SDL_VIDEO_DRIVER_WAYLAND
-#undef SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH
-#undef SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC
-#undef SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_EGL
-#undef SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_CURSOR
-#undef SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_XKBCOMMON
-#undef SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_LIBDECOR
-#undef SDL_VIDEO_DRIVER_X11
-#undef SDL_VIDEO_DRIVER_RPI
-#undef SDL_VIDEO_DRIVER_KMSDRM
-#undef SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC
-#undef SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC_GBM
-#undef SDL_VIDEO_DRIVER_ANDROID
-#undef SDL_VIDEO_DRIVER_EMSCRIPTEN
-#undef SDL_VIDEO_DRIVER_OFFSCREEN
-#undef SDL_VIDEO_DRIVER_X11_DYNAMIC
-#undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT
-#undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XCURSOR
-#undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XINPUT2
-#undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XFIXES
-#undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR
-#undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XSS
-#undef SDL_VIDEO_DRIVER_X11_XCURSOR
-#undef SDL_VIDEO_DRIVER_X11_XDBE
-#undef SDL_VIDEO_DRIVER_X11_XINPUT2
-#undef SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH
-#undef SDL_VIDEO_DRIVER_X11_XFIXES
-#undef SDL_VIDEO_DRIVER_X11_XRANDR
-#undef SDL_VIDEO_DRIVER_X11_XSCRNSAVER
-#undef SDL_VIDEO_DRIVER_X11_XSHAPE
-#undef SDL_VIDEO_DRIVER_X11_SUPPORTS_GENERIC_EVENTS
-#undef SDL_VIDEO_DRIVER_X11_HAS_XKBKEYCODETOKEYSYM
-#undef SDL_VIDEO_DRIVER_NACL
-#undef SDL_VIDEO_DRIVER_VIVANTE
-#undef SDL_VIDEO_DRIVER_VIVANTE_VDK
-#undef SDL_VIDEO_DRIVER_OS2
-#undef SDL_VIDEO_DRIVER_QNX
-#undef SDL_VIDEO_DRIVER_RISCOS
-
-#undef SDL_VIDEO_RENDER_D3D
-#undef SDL_VIDEO_RENDER_D3D11
-#undef SDL_VIDEO_RENDER_D3D12
-#undef SDL_VIDEO_RENDER_OGL
-#undef SDL_VIDEO_RENDER_OGL_ES
-#undef SDL_VIDEO_RENDER_OGL_ES2
-#undef SDL_VIDEO_RENDER_DIRECTFB
-#undef SDL_VIDEO_RENDER_METAL
-
-/* Enable OpenGL support */
-#undef SDL_VIDEO_OPENGL
-#undef SDL_VIDEO_OPENGL_ES
-#undef SDL_VIDEO_OPENGL_ES2
-#undef SDL_VIDEO_OPENGL_BGL
-#undef SDL_VIDEO_OPENGL_CGL
-#undef SDL_VIDEO_OPENGL_EGL
-#undef SDL_VIDEO_OPENGL_GLX
-#undef SDL_VIDEO_OPENGL_WGL
-#undef SDL_VIDEO_OPENGL_OSMESA
-#undef SDL_VIDEO_OPENGL_OSMESA_DYNAMIC
-
-/* Enable Vulkan support */
-#undef SDL_VIDEO_VULKAN
-
-/* Enable Metal support */
-#undef SDL_VIDEO_METAL
-
-/* Enable system power support */
-#undef SDL_POWER_LINUX
-#undef SDL_POWER_WINDOWS
-#undef SDL_POWER_MACOSX
-#undef SDL_POWER_HAIKU
-#undef SDL_POWER_ANDROID
-#undef SDL_POWER_EMSCRIPTEN
-#undef SDL_POWER_HARDWIRED
-
-/* Enable system filesystem support */
-#undef SDL_FILESYSTEM_ANDROID
-#undef SDL_FILESYSTEM_HAIKU
-#undef SDL_FILESYSTEM_COCOA
-#undef SDL_FILESYSTEM_DUMMY
-#undef SDL_FILESYSTEM_RISCOS
-#undef SDL_FILESYSTEM_UNIX
-#undef SDL_FILESYSTEM_WINDOWS
-#undef SDL_FILESYSTEM_NACL
-#undef SDL_FILESYSTEM_EMSCRIPTEN
-#undef SDL_FILESYSTEM_OS2
-#undef SDL_FILESYSTEM_VITA
-#undef SDL_FILESYSTEM_PSP
-#undef SDL_FILESYSTEM_PS2
-
-/* Enable misc subsystem */
-#undef SDL_MISC_DUMMY
-
-/* Enable locale subsystem */
-#undef SDL_LOCALE_DUMMY
-
-/* Enable assembly routines */
-#undef SDL_ALTIVEC_BLITTERS
-#undef SDL_ARM_SIMD_BLITTERS
-#undef SDL_ARM_NEON_BLITTERS
-
-/* Whether SDL_DYNAMIC_API needs dlopen() */
-#undef DYNAPI_NEEDS_DLOPEN
-
-/* Enable ime support */
-#undef SDL_USE_IME
-
-/* Enable dynamic udev support */
-#undef SDL_UDEV_DYNAMIC
-
-/* Enable dynamic libusb support */
-#undef SDL_LIBUSB_DYNAMIC
-
-/* Enable dynamic libsamplerate support */
-#undef SDL_LIBSAMPLERATE_DYNAMIC
-
-/* Libdecor get min/max content size functions */
-#undef SDL_HAVE_LIBDECOR_GET_MIN_MAX
-
-#endif /* SDL_config_h_ */

thirdparty/include/android/SDL2/SDL_config_android.h

@@ -1,194 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_config_android_h_
-#define SDL_config_android_h_
-#define SDL_config_h_
-
-#include "SDL_platform.h"
-
-/**
- *  \file SDL_config_android.h
- *
- *  This is a configuration that can be used to build SDL for Android
- */
-
-#include <stdarg.h>
-
-#define HAVE_GCC_ATOMICS    1
-
-#define STDC_HEADERS    1
-#define HAVE_ALLOCA_H       1
-#define HAVE_CTYPE_H    1
-#define HAVE_INTTYPES_H 1
-#define HAVE_LIMITS_H   1
-#define HAVE_MATH_H 1
-#define HAVE_SIGNAL_H 1
-#define HAVE_STDINT_H   1
-#define HAVE_STDIO_H    1
-#define HAVE_STRING_H   1
-#define HAVE_SYS_TYPES_H    1
-
-/* C library functions */
-#define HAVE_DLOPEN 1
-#define HAVE_MALLOC 1
-#define HAVE_CALLOC 1
-#define HAVE_REALLOC    1
-#define HAVE_FREE   1
-#define HAVE_ALLOCA 1
-#define HAVE_GETENV 1
-#define HAVE_SETENV 1
-#define HAVE_PUTENV 1
-#define HAVE_SETENV 1
-#define HAVE_UNSETENV   1
-#define HAVE_QSORT  1
-#define HAVE_BSEARCH 1
-#define HAVE_ABS    1
-#define HAVE_BCOPY  1
-#define HAVE_MEMSET 1
-#define HAVE_MEMCPY 1
-#define HAVE_MEMMOVE    1
-#define HAVE_MEMCMP 1
-#define HAVE_STRLEN 1
-#define HAVE_STRLCPY    1
-#define HAVE_STRLCAT    1
-#define HAVE_STRCHR 1
-#define HAVE_STRRCHR    1
-#define HAVE_STRSTR 1
-#define HAVE_STRTOK_R 1
-#define HAVE_STRTOL 1
-#define HAVE_STRTOUL    1
-#define HAVE_STRTOLL    1
-#define HAVE_STRTOULL   1
-#define HAVE_STRTOD 1
-#define HAVE_ATOI   1
-#define HAVE_ATOF 1
-#define HAVE_STRCMP 1
-#define HAVE_STRNCMP    1
-#define HAVE_STRCASECMP 1
-#define HAVE_STRNCASECMP 1
-#define HAVE_STRCASESTR 1
-#define HAVE_VSSCANF 1
-#define HAVE_VSNPRINTF  1
-#define HAVE_ACOS   1
-#define HAVE_ACOSF  1
-#define HAVE_ASIN   1
-#define HAVE_ASINF  1
-#define HAVE_ATAN   1
-#define HAVE_ATANF  1
-#define HAVE_ATAN2  1
-#define HAVE_ATAN2F 1
-#define HAVE_CEIL   1
-#define HAVE_CEILF  1
-#define HAVE_COPYSIGN   1
-#define HAVE_COPYSIGNF  1
-#define HAVE_COS    1
-#define HAVE_COSF   1
-#define HAVE_EXP    1
-#define HAVE_EXPF   1
-#define HAVE_FABS   1
-#define HAVE_FABSF  1
-#define HAVE_FLOOR  1
-#define HAVE_FLOORF 1
-#define HAVE_FMOD   1
-#define HAVE_FMODF  1
-#define HAVE_LOG    1
-#define HAVE_LOGF   1
-#define HAVE_LOG10  1
-#define HAVE_LOG10F 1
-#define HAVE_LROUND 1
-#define HAVE_LROUNDF 1
-#define HAVE_POW    1
-#define HAVE_POWF   1
-#define HAVE_ROUND  1
-#define HAVE_ROUNDF 1
-#define HAVE_SCALBN 1
-#define HAVE_SCALBNF    1
-#define HAVE_SIN    1
-#define HAVE_SINF   1
-#define HAVE_SQRT   1
-#define HAVE_SQRTF  1
-#define HAVE_TAN    1
-#define HAVE_TANF   1
-#define HAVE_TRUNC    1
-#define HAVE_TRUNCF   1
-#define HAVE_SIGACTION 1
-#define HAVE_SETJMP 1
-#define HAVE_NANOSLEEP  1
-#define HAVE_SYSCONF    1
-#define HAVE_CLOCK_GETTIME  1
-
-#ifdef __LP64__
-#define SIZEOF_VOIDP 8
-#else
-#define SIZEOF_VOIDP 4
-#endif
-
-/* Enable various audio drivers */
-#define SDL_AUDIO_DRIVER_ANDROID    1
-#define SDL_AUDIO_DRIVER_OPENSLES   1
-#define SDL_AUDIO_DRIVER_AAUDIO     1
-#define SDL_AUDIO_DRIVER_DUMMY  1
-
-/* Enable various input drivers */
-#define SDL_JOYSTICK_ANDROID    1
-#define SDL_JOYSTICK_HIDAPI     1
-#define SDL_JOYSTICK_VIRTUAL    1
-#define SDL_HAPTIC_ANDROID  1
-
-/* Enable sensor driver */
-#define SDL_SENSOR_ANDROID  1
-
-/* Enable various shared object loading systems */
-#define SDL_LOADSO_DLOPEN   1
-
-/* Enable various threading systems */
-#define SDL_THREAD_PTHREAD  1
-#define SDL_THREAD_PTHREAD_RECURSIVE_MUTEX  1
-
-/* Enable various timer systems */
-#define SDL_TIMER_UNIX  1
-
-/* Enable various video drivers */
-#define SDL_VIDEO_DRIVER_ANDROID 1
-
-/* Enable OpenGL ES */
-#define SDL_VIDEO_OPENGL_ES 1
-#define SDL_VIDEO_OPENGL_ES2 1
-#define SDL_VIDEO_OPENGL_EGL 1
-#define SDL_VIDEO_RENDER_OGL_ES 1
-#define SDL_VIDEO_RENDER_OGL_ES2    1
-
-/* Enable Vulkan support */
-/* Android does not support Vulkan in native code using the "armeabi" ABI. */
-#if defined(__ARM_ARCH) && __ARM_ARCH < 7
-#define SDL_VIDEO_VULKAN 0
-#else
-#define SDL_VIDEO_VULKAN 1
-#endif
-
-/* Enable system power support */
-#define SDL_POWER_ANDROID 1
-
-/* Enable the filesystem driver */
-#define SDL_FILESYSTEM_ANDROID   1
-
-#endif /* SDL_config_android_h_ */

thirdparty/include/android/SDL2/SDL_config_emscripten.h

@@ -1,218 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef _SDL_config_emscripten_h_
-#define _SDL_config_emscripten_h_
-
-#include "SDL_platform.h"
-
-/**
- *  \file SDL_config_emscripten.h
- *
- *  This is a configuration that can be used to build SDL for Emscripten.
- */
-
-#ifdef __LP64__
-#define SIZEOF_VOIDP 8
-#else
-#define SIZEOF_VOIDP 4
-#endif
-#define HAVE_GCC_ATOMICS 1
-
-/* Useful headers */
-#define STDC_HEADERS 1
-#define HAVE_ALLOCA_H 1
-#define HAVE_CTYPE_H 1
-#define HAVE_ICONV_H 1
-#define HAVE_INTTYPES_H 1
-#define HAVE_LIMITS_H 1
-#define HAVE_MALLOC_H 1
-#define HAVE_MATH_H 1
-#define HAVE_MEMORY_H 1
-#define HAVE_SIGNAL_H 1
-#define HAVE_STDARG_H 1
-#define HAVE_STDINT_H 1
-#define HAVE_STDIO_H 1
-#define HAVE_STDLIB_H 1
-#define HAVE_STRINGS_H 1
-#define HAVE_STRING_H 1
-#define HAVE_SYS_TYPES_H 1
-#define HAVE_WCHAR_H 1
-
-/* C library functions */
-#define HAVE_DLOPEN 1
-#define HAVE_MALLOC 1
-#define HAVE_CALLOC 1
-#define HAVE_REALLOC 1
-#define HAVE_FREE 1
-#define HAVE_ALLOCA 1
-#define HAVE_GETENV 1
-#define HAVE_SETENV 1
-#define HAVE_PUTENV 1
-#define HAVE_UNSETENV 1
-#define HAVE_QSORT 1
-#define HAVE_BSEARCH 1
-#define HAVE_ABS 1
-#define HAVE_BCOPY 1
-#define HAVE_MEMSET 1
-#define HAVE_MEMCPY 1
-#define HAVE_MEMMOVE 1
-#define HAVE_MEMCMP 1
-#define HAVE_WCSLEN 1
-#define HAVE_WCSDUP 1
-#define HAVE_WCSSTR 1
-#define HAVE_WCSCMP 1
-#define HAVE_WCSNCMP 1
-#define HAVE_WCSCASECMP 1
-#define HAVE_WCSNCASECMP 1
-#define HAVE_STRLEN 1
-#define HAVE_STRLCPY 1
-#define HAVE_STRLCAT 1
-#define HAVE_STRCHR 1
-#define HAVE_STRRCHR 1
-#define HAVE_STRSTR 1
-#define HAVE_STRTOK_R 1
-#define HAVE_STRTOL 1
-#define HAVE_STRTOUL 1
-#define HAVE_STRTOLL 1
-#define HAVE_STRTOULL 1
-#define HAVE_STRTOD 1
-#define HAVE_ATOI 1
-#define HAVE_ATOF 1
-#define HAVE_STRCMP 1
-#define HAVE_STRNCMP 1
-#define HAVE_STRCASECMP 1
-#define HAVE_STRNCASECMP 1
-#define HAVE_SSCANF 1
-#define HAVE_VSSCANF 1
-#define HAVE_VSNPRINTF 1
-#define HAVE_M_PI 1
-#define HAVE_ACOS 1
-#define HAVE_ACOSF 1
-#define HAVE_ASIN 1
-#define HAVE_ASINF 1
-#define HAVE_ATAN 1
-#define HAVE_ATANF 1
-#define HAVE_ATAN2 1
-#define HAVE_ATAN2F 1
-#define HAVE_CEIL 1
-#define HAVE_CEILF 1
-#define HAVE_COPYSIGN 1
-#define HAVE_COPYSIGNF 1
-#define HAVE_COS 1
-#define HAVE_COSF 1
-#define HAVE_EXP 1
-#define HAVE_EXPF 1
-#define HAVE_FABS 1
-#define HAVE_FABSF 1
-#define HAVE_FLOOR 1
-#define HAVE_FLOORF 1
-#define HAVE_FMOD 1
-#define HAVE_FMODF 1
-#define HAVE_LOG 1
-#define HAVE_LOGF 1
-#define HAVE_LOG10 1
-#define HAVE_LOG10F 1
-#define HAVE_LROUND 1
-#define HAVE_LROUNDF 1
-#define HAVE_POW 1
-#define HAVE_POWF 1
-#define HAVE_ROUND  1
-#define HAVE_ROUNDF 1
-#define HAVE_SCALBN 1
-#define HAVE_SCALBNF 1
-#define HAVE_SIN 1
-#define HAVE_SINF 1
-#define HAVE_SQRT 1
-#define HAVE_SQRTF 1
-#define HAVE_TAN 1
-#define HAVE_TANF 1
-#define HAVE_TRUNC 1
-#define HAVE_TRUNCF 1
-#define HAVE_FSEEKO 1
-#define HAVE_FSEEKO64 1
-#define HAVE_SIGACTION 1
-#define HAVE_SA_SIGACTION 1
-#define HAVE_SETJMP 1
-#define HAVE_NANOSLEEP 1
-#define HAVE_SYSCONF 1
-#define HAVE_CLOCK_GETTIME 1
-/* #undef HAVE_GETPAGESIZE */
-#define HAVE_MPROTECT 1
-#define HAVE_ICONV 1
-
-/* SDL internal assertion support */
-/* #undef SDL_DEFAULT_ASSERT_LEVEL */
-
-#define SDL_CPUINFO_DISABLED 1
-#define SDL_HAPTIC_DISABLED 1
-#define SDL_HIDAPI_DISABLED 1
-#ifndef __EMSCRIPTEN_PTHREADS__
-#define SDL_THREADS_DISABLED 1
-#endif
-
-/* Enable various audio drivers */
-#define SDL_AUDIO_DRIVER_DISK 1
-#define SDL_AUDIO_DRIVER_DUMMY 1
-#define SDL_AUDIO_DRIVER_EMSCRIPTEN 1
-
-/* Enable various input drivers */
-#define SDL_JOYSTICK_EMSCRIPTEN 1
-
-/* Enable various sensor drivers */
-#define SDL_SENSOR_DUMMY 1
-
-/* Enable various shared object loading systems */
-#define SDL_LOADSO_DLOPEN 1
-
-/* Enable various threading systems */
-#ifdef __EMSCRIPTEN_PTHREADS__
-#define SDL_THREAD_PTHREAD 1
-#define SDL_THREAD_PTHREAD_RECURSIVE_MUTEX 1
-#endif
-
-/* Enable various timer systems */
-#define SDL_TIMER_UNIX 1
-
-/* Enable various video drivers */
-#define SDL_VIDEO_DRIVER_EMSCRIPTEN 1
-
-#define SDL_VIDEO_RENDER_OGL_ES2 1
-
-/* Enable OpenGL support */
-/* #undef SDL_VIDEO_OPENGL */
-/* #undef SDL_VIDEO_OPENGL_ES */
-#define SDL_VIDEO_OPENGL_ES2 1
-/* #undef SDL_VIDEO_OPENGL_BGL */
-/* #undef SDL_VIDEO_OPENGL_CGL */
-/* #undef SDL_VIDEO_OPENGL_GLX */
-/* #undef SDL_VIDEO_OPENGL_WGL */
-#define SDL_VIDEO_OPENGL_EGL 1
-/* #undef SDL_VIDEO_OPENGL_OSMESA */
-/* #undef SDL_VIDEO_OPENGL_OSMESA_DYNAMIC */
-
-/* Enable system power support */
-#define SDL_POWER_EMSCRIPTEN 1
-
-/* Enable system filesystem support */
-#define SDL_FILESYSTEM_EMSCRIPTEN 1
-
-#endif /* _SDL_config_emscripten_h_ */

thirdparty/include/android/SDL2/SDL_config_iphoneos.h

@@ -1,217 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_config_iphoneos_h_
-#define SDL_config_iphoneos_h_
-#define SDL_config_h_
-
-#include "SDL_platform.h"
-
-#ifdef __LP64__
-#define SIZEOF_VOIDP 8
-#else
-#define SIZEOF_VOIDP 4
-#endif
-
-#define HAVE_GCC_ATOMICS    1
-
-#define STDC_HEADERS    1
-#define HAVE_ALLOCA_H       1
-#define HAVE_CTYPE_H    1
-#define HAVE_INTTYPES_H 1
-#define HAVE_LIMITS_H   1
-#define HAVE_MATH_H 1
-#define HAVE_SIGNAL_H   1
-#define HAVE_STDINT_H   1
-#define HAVE_STDIO_H    1
-#define HAVE_STRING_H   1
-#define HAVE_SYS_TYPES_H    1
-/* The libunwind functions are only available on x86 */
-/* #undef HAVE_LIBUNWIND_H */
-
-/* C library functions */
-#define HAVE_DLOPEN 1
-#define HAVE_MALLOC 1
-#define HAVE_CALLOC 1
-#define HAVE_REALLOC    1
-#define HAVE_FREE   1
-#define HAVE_ALLOCA 1
-#define HAVE_GETENV 1
-#define HAVE_SETENV 1
-#define HAVE_PUTENV 1
-#define HAVE_SETENV 1
-#define HAVE_UNSETENV   1
-#define HAVE_QSORT  1
-#define HAVE_BSEARCH 1
-#define HAVE_ABS    1
-#define HAVE_BCOPY  1
-#define HAVE_MEMSET 1
-#define HAVE_MEMCPY 1
-#define HAVE_MEMMOVE    1
-#define HAVE_MEMCMP 1
-#define HAVE_STRLEN 1
-#define HAVE_STRLCPY    1
-#define HAVE_STRLCAT    1
-#define HAVE_STRCHR 1
-#define HAVE_STRRCHR    1
-#define HAVE_STRSTR 1
-#define HAVE_STRTOK_R 1
-#define HAVE_STRTOL 1
-#define HAVE_STRTOUL    1
-#define HAVE_STRTOLL    1
-#define HAVE_STRTOULL   1
-#define HAVE_STRTOD 1
-#define HAVE_ATOI   1
-#define HAVE_ATOF   1
-#define HAVE_STRCMP 1
-#define HAVE_STRNCMP    1
-#define HAVE_STRCASECMP 1
-#define HAVE_STRNCASECMP 1
-#define HAVE_STRCASESTR 1
-#define HAVE_VSSCANF 1
-#define HAVE_VSNPRINTF  1
-#define HAVE_M_PI   1
-#define HAVE_ACOS   1
-#define HAVE_ACOSF  1
-#define HAVE_ASIN   1
-#define HAVE_ASINF  1
-#define HAVE_ATAN   1
-#define HAVE_ATANF  1
-#define HAVE_ATAN2  1
-#define HAVE_ATAN2F 1
-#define HAVE_CEIL   1
-#define HAVE_CEILF  1
-#define HAVE_COPYSIGN   1
-#define HAVE_COPYSIGNF  1
-#define HAVE_COS    1
-#define HAVE_COSF   1
-#define HAVE_EXP    1
-#define HAVE_EXPF   1
-#define HAVE_FABS   1
-#define HAVE_FABSF  1
-#define HAVE_FLOOR  1
-#define HAVE_FLOORF 1
-#define HAVE_FMOD   1
-#define HAVE_FMODF  1
-#define HAVE_LOG    1
-#define HAVE_LOGF   1
-#define HAVE_LOG10  1
-#define HAVE_LOG10F 1
-#define HAVE_LROUND 1
-#define HAVE_LROUNDF 1
-#define HAVE_POW    1
-#define HAVE_POWF   1
-#define HAVE_ROUND  1
-#define HAVE_ROUNDF 1
-#define HAVE_SCALBN 1
-#define HAVE_SCALBNF    1
-#define HAVE_SIN    1
-#define HAVE_SINF   1
-#define HAVE_SQRT   1
-#define HAVE_SQRTF  1
-#define HAVE_TAN    1
-#define HAVE_TANF   1
-#define HAVE_TRUNC  1
-#define HAVE_TRUNCF 1
-#define HAVE_SIGACTION  1
-#define HAVE_SETJMP 1
-#define HAVE_NANOSLEEP  1
-#define HAVE_SYSCONF    1
-#define HAVE_SYSCTLBYNAME 1
-#define HAVE_O_CLOEXEC 1
-
-/* enable iPhone version of Core Audio driver */
-#define SDL_AUDIO_DRIVER_COREAUDIO 1
-/* Enable the dummy audio driver (src/audio/dummy/\*.c) */
-#define SDL_AUDIO_DRIVER_DUMMY  1
-
-/* Enable the stub haptic driver (src/haptic/dummy/\*.c) */
-#define SDL_HAPTIC_DUMMY 1
-
-/* Enable joystick support */
-/* Only enable HIDAPI support if you want to support Steam Controllers on iOS and tvOS */
-/*#define SDL_JOYSTICK_HIDAPI 1*/
-#define SDL_JOYSTICK_MFI 1
-#define SDL_JOYSTICK_VIRTUAL    1
-
-#ifdef __TVOS__
-#define SDL_SENSOR_DUMMY    1
-#else
-/* Enable the CoreMotion sensor driver */
-#define SDL_SENSOR_COREMOTION   1
-#endif
-
-/* Enable Unix style SO loading */
-#define SDL_LOADSO_DLOPEN 1
-
-/* Enable various threading systems */
-#define SDL_THREAD_PTHREAD  1
-#define SDL_THREAD_PTHREAD_RECURSIVE_MUTEX  1
-
-/* Enable various timer systems */
-#define SDL_TIMER_UNIX  1
-
-/* Supported video drivers */
-#define SDL_VIDEO_DRIVER_UIKIT  1
-#define SDL_VIDEO_DRIVER_DUMMY  1
-
-/* Enable OpenGL ES */
-#if !TARGET_OS_MACCATALYST
-#define SDL_VIDEO_OPENGL_ES2 1
-#define SDL_VIDEO_OPENGL_ES 1
-#define SDL_VIDEO_RENDER_OGL_ES 1
-#define SDL_VIDEO_RENDER_OGL_ES2    1
-#endif
-
-/* Metal supported on 64-bit devices running iOS 8.0 and tvOS 9.0 and newer
-   Also supported in simulator from iOS 13.0 and tvOS 13.0
- */
-#if (TARGET_OS_SIMULATOR && ((__IPHONE_OS_VERSION_MIN_REQUIRED >= 130000) || (__TV_OS_VERSION_MIN_REQUIRED >= 130000))) || (!TARGET_CPU_ARM && ((__IPHONE_OS_VERSION_MIN_REQUIRED >= 80000) || (__TV_OS_VERSION_MIN_REQUIRED >= 90000)))
-#define SDL_PLATFORM_SUPPORTS_METAL	1
-#else
-#define SDL_PLATFORM_SUPPORTS_METAL	0
-#endif
-
-#if SDL_PLATFORM_SUPPORTS_METAL
-#define SDL_VIDEO_RENDER_METAL  1
-#endif
-
-#if SDL_PLATFORM_SUPPORTS_METAL
-#define SDL_VIDEO_VULKAN 1
-#endif
-
-#if SDL_PLATFORM_SUPPORTS_METAL
-#define SDL_VIDEO_METAL 1
-#endif
-
-/* Enable system power support */
-#define SDL_POWER_UIKIT 1
-
-/* enable iPhone keyboard support */
-#define SDL_IPHONE_KEYBOARD 1
-
-/* enable iOS extended launch screen */
-#define SDL_IPHONE_LAUNCHSCREEN 1
-
-/* enable filesystem support */
-#define SDL_FILESYSTEM_COCOA   1
-
-#endif /* SDL_config_iphoneos_h_ */

thirdparty/include/android/SDL2/SDL_config_macosx.h

@@ -1,277 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_config_macosx_h_
-#define SDL_config_macosx_h_
-#define SDL_config_h_
-
-#include "SDL_platform.h"
-
-/* This gets us MAC_OS_X_VERSION_MIN_REQUIRED... */
-#include <AvailabilityMacros.h>
-
-/* This is a set of defines to configure the SDL features */
-
-#ifdef __LP64__
-    #define SIZEOF_VOIDP 8
-#else
-    #define SIZEOF_VOIDP 4
-#endif
-
-/* Useful headers */
-#define STDC_HEADERS    1
-#define HAVE_ALLOCA_H       1
-#define HAVE_CTYPE_H    1
-#define HAVE_FLOAT_H    1
-#define HAVE_INTTYPES_H 1
-#define HAVE_LIMITS_H   1
-#define HAVE_MATH_H 1
-#define HAVE_SIGNAL_H   1
-#define HAVE_STDINT_H   1
-#define HAVE_STDIO_H    1
-#define HAVE_STRING_H   1
-#define HAVE_SYS_TYPES_H    1
-#define HAVE_LIBUNWIND_H    1
-
-/* C library functions */
-#define HAVE_DLOPEN 1
-#define HAVE_MALLOC 1
-#define HAVE_CALLOC 1
-#define HAVE_REALLOC    1
-#define HAVE_FREE   1
-#define HAVE_ALLOCA 1
-#define HAVE_GETENV 1
-#define HAVE_SETENV 1
-#define HAVE_PUTENV 1
-#define HAVE_UNSETENV   1
-#define HAVE_QSORT  1
-#define HAVE_BSEARCH 1
-#define HAVE_ABS    1
-#define HAVE_BCOPY  1
-#define HAVE_MEMSET 1
-#define HAVE_MEMCPY 1
-#define HAVE_MEMMOVE    1
-#define HAVE_MEMCMP 1
-#define HAVE_STRLEN 1
-#define HAVE_STRLCPY    1
-#define HAVE_STRLCAT    1
-#define HAVE_STRCHR 1
-#define HAVE_STRRCHR    1
-#define HAVE_STRSTR 1
-#define HAVE_STRTOK_R 1
-#define HAVE_STRTOL 1
-#define HAVE_STRTOUL    1
-#define HAVE_STRTOLL    1
-#define HAVE_STRTOULL   1
-#define HAVE_STRTOD 1
-#define HAVE_ATOI   1
-#define HAVE_ATOF   1
-#define HAVE_STRCMP 1
-#define HAVE_STRNCMP    1
-#define HAVE_STRCASECMP 1
-#define HAVE_STRNCASECMP 1
-#define HAVE_STRCASESTR 1
-#define HAVE_VSSCANF 1
-#define HAVE_VSNPRINTF  1
-#define HAVE_M_PI   1
-#define HAVE_ACOS   1
-#define HAVE_ACOSF  1
-#define HAVE_ASIN   1
-#define HAVE_ASINF  1
-#define HAVE_ATAN   1
-#define HAVE_ATANF  1
-#define HAVE_ATAN2  1
-#define HAVE_ATAN2F 1
-#define HAVE_CEIL   1
-#define HAVE_CEILF  1
-#define HAVE_COPYSIGN   1
-#define HAVE_COPYSIGNF  1
-#define HAVE_COS    1
-#define HAVE_COSF   1
-#define HAVE_EXP    1
-#define HAVE_EXPF   1
-#define HAVE_FABS   1
-#define HAVE_FABSF  1
-#define HAVE_FLOOR  1
-#define HAVE_FLOORF 1
-#define HAVE_FMOD   1
-#define HAVE_FMODF  1
-#define HAVE_LOG    1
-#define HAVE_LOGF   1
-#define HAVE_LOG10  1
-#define HAVE_LOG10F 1
-#define HAVE_LROUND 1
-#define HAVE_LROUNDF 1
-#define HAVE_POW    1
-#define HAVE_POWF   1
-#define HAVE_ROUND  1
-#define HAVE_ROUNDF 1
-#define HAVE_SCALBN 1
-#define HAVE_SCALBNF    1
-#define HAVE_SIN    1
-#define HAVE_SINF   1
-#define HAVE_SQRT   1
-#define HAVE_SQRTF  1
-#define HAVE_TAN    1
-#define HAVE_TANF   1
-#define HAVE_TRUNC    1
-#define HAVE_TRUNCF   1
-#define HAVE_SIGACTION  1
-#define HAVE_SETJMP 1
-#define HAVE_NANOSLEEP  1
-#define HAVE_SYSCONF    1
-#define HAVE_SYSCTLBYNAME 1
-
-#if defined(__has_include) && (defined(__i386__) || defined(__x86_64))
-# if __has_include(<immintrin.h>)
-#   define HAVE_IMMINTRIN_H 1
-# endif
-#endif
-
-#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1070)
-#define HAVE_O_CLOEXEC 1
-#endif
-
-#define HAVE_GCC_ATOMICS 1
-
-/* Enable various audio drivers */
-#define SDL_AUDIO_DRIVER_COREAUDIO  1
-#define SDL_AUDIO_DRIVER_DISK   1
-#define SDL_AUDIO_DRIVER_DUMMY  1
-
-/* Enable various input drivers */
-#define SDL_JOYSTICK_HIDAPI 1
-#define SDL_JOYSTICK_IOKIT  1
-#define SDL_JOYSTICK_VIRTUAL    1
-#define SDL_HAPTIC_IOKIT    1
-
-/* The MFI controller support requires ARC Objective C runtime */
-#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1080 && !defined(__i386__)
-#define SDL_JOYSTICK_MFI 1
-#endif
-
-/* Enable the dummy sensor driver */
-#define SDL_SENSOR_DUMMY  1
-
-/* Enable various shared object loading systems */
-#define SDL_LOADSO_DLOPEN   1
-
-/* Enable various threading systems */
-#define SDL_THREAD_PTHREAD  1
-#define SDL_THREAD_PTHREAD_RECURSIVE_MUTEX  1
-
-/* Enable various timer systems */
-#define SDL_TIMER_UNIX  1
-
-/* Enable various video drivers */
-#define SDL_VIDEO_DRIVER_COCOA  1
-#define SDL_VIDEO_DRIVER_DUMMY  1
-#undef SDL_VIDEO_DRIVER_X11
-#define SDL_VIDEO_DRIVER_X11_DYNAMIC "/opt/X11/lib/libX11.6.dylib"
-#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT "/opt/X11/lib/libXext.6.dylib"
-#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XINPUT2 "/opt/X11/lib/libXi.6.dylib"
-#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR "/opt/X11/lib/libXrandr.2.dylib"
-#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XSS "/opt/X11/lib/libXss.1.dylib"
-#define SDL_VIDEO_DRIVER_X11_XDBE 1
-#define SDL_VIDEO_DRIVER_X11_XRANDR 1
-#define SDL_VIDEO_DRIVER_X11_XSCRNSAVER 1
-#define SDL_VIDEO_DRIVER_X11_XSHAPE 1
-#define SDL_VIDEO_DRIVER_X11_HAS_XKBKEYCODETOKEYSYM 1
-
-#ifdef MAC_OS_X_VERSION_10_8
-/*
- * No matter the versions targeted, this is the 10.8 or later SDK, so you have
- *  to use the external Xquartz, which is a more modern Xlib. Previous SDKs
- *  used an older Xlib.
- */
-#define SDL_VIDEO_DRIVER_X11_XINPUT2 1
-#define SDL_VIDEO_DRIVER_X11_SUPPORTS_GENERIC_EVENTS 1
-#endif
-
-#ifndef SDL_VIDEO_RENDER_OGL
-#define SDL_VIDEO_RENDER_OGL    1
-#endif
-
-#ifndef SDL_VIDEO_RENDER_OGL_ES2
-#define SDL_VIDEO_RENDER_OGL_ES2 1
-#endif
-
-/* Metal only supported on 64-bit architectures with 10.11+ */
-#if TARGET_RT_64_BIT && (MAC_OS_X_VERSION_MAX_ALLOWED >= 101100)
-#define SDL_PLATFORM_SUPPORTS_METAL    1
-#else
-#define SDL_PLATFORM_SUPPORTS_METAL    0
-#endif
-
-#ifndef SDL_VIDEO_RENDER_METAL
-#if SDL_PLATFORM_SUPPORTS_METAL
-#define SDL_VIDEO_RENDER_METAL    1
-#else
-#define SDL_VIDEO_RENDER_METAL    0
-#endif
-#endif
-
-/* Enable OpenGL support */
-#ifndef SDL_VIDEO_OPENGL
-#define SDL_VIDEO_OPENGL    1
-#endif
-#ifndef SDL_VIDEO_OPENGL_ES2
-#define SDL_VIDEO_OPENGL_ES2    1
-#endif
-#ifndef SDL_VIDEO_OPENGL_EGL
-#define SDL_VIDEO_OPENGL_EGL    1
-#endif
-#ifndef SDL_VIDEO_OPENGL_CGL
-#define SDL_VIDEO_OPENGL_CGL    1
-#endif
-#ifndef SDL_VIDEO_OPENGL_GLX
-#define SDL_VIDEO_OPENGL_GLX    1
-#endif
-
-/* Enable Vulkan and Metal support */
-#ifndef SDL_VIDEO_VULKAN
-#if SDL_PLATFORM_SUPPORTS_METAL
-#define SDL_VIDEO_VULKAN 1
-#else
-#define SDL_VIDEO_VULKAN 0
-#endif
-#endif
-
-#ifndef SDL_VIDEO_METAL
-#if SDL_PLATFORM_SUPPORTS_METAL
-#define SDL_VIDEO_METAL 1
-#else
-#define SDL_VIDEO_METAL 0
-#endif
-#endif
-
-/* Enable system power support */
-#define SDL_POWER_MACOSX 1
-
-/* enable filesystem support */
-#define SDL_FILESYSTEM_COCOA   1
-
-/* Enable assembly routines */
-#ifdef __ppc__
-#define SDL_ALTIVEC_BLITTERS    1
-#endif
-
-#endif /* SDL_config_macosx_h_ */

thirdparty/include/android/SDL2/SDL_config_minimal.h

@@ -1,95 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_config_minimal_h_
-#define SDL_config_minimal_h_
-#define SDL_config_h_
-
-#include "SDL_platform.h"
-
-/**
- *  \file SDL_config_minimal.h
- *
- *  This is the minimal configuration that can be used to build SDL.
- */
-
-#define HAVE_STDARG_H   1
-#define HAVE_STDDEF_H   1
-
-#if !defined(HAVE_STDINT_H) && !defined(_STDINT_H_)
-/* Most everything except Visual Studio 2008 and earlier has stdint.h now */
-#if defined(_MSC_VER) && (_MSC_VER < 1600)
-typedef signed __int8 int8_t;
-typedef unsigned __int8 uint8_t;
-typedef signed __int16 int16_t;
-typedef unsigned __int16 uint16_t;
-typedef signed __int32 int32_t;
-typedef unsigned __int32 uint32_t;
-typedef signed __int64 int64_t;
-typedef unsigned __int64 uint64_t;
-#ifndef _UINTPTR_T_DEFINED
-#ifdef  _WIN64
-typedef unsigned __int64 uintptr_t;
-#else
-typedef unsigned int uintptr_t;
-#endif
-#define _UINTPTR_T_DEFINED
-#endif
-#else
-#define HAVE_STDINT_H 1
-#endif /* Visual Studio 2008 */
-#endif /* !_STDINT_H_ && !HAVE_STDINT_H */
-
-#ifdef __GNUC__
-#define HAVE_GCC_SYNC_LOCK_TEST_AND_SET 1
-#endif
-
-/* Enable the dummy audio driver (src/audio/dummy/\*.c) */
-#define SDL_AUDIO_DRIVER_DUMMY  1
-
-/* Enable the stub joystick driver (src/joystick/dummy/\*.c) */
-#define SDL_JOYSTICK_DISABLED   1
-
-/* Enable the stub haptic driver (src/haptic/dummy/\*.c) */
-#define SDL_HAPTIC_DISABLED 1
-
-/* Enable the stub HIDAPI */
-#define SDL_HIDAPI_DISABLED 1
-
-/* Enable the stub sensor driver (src/sensor/dummy/\*.c) */
-#define SDL_SENSOR_DISABLED 1
-
-/* Enable the stub shared object loader (src/loadso/dummy/\*.c) */
-#define SDL_LOADSO_DISABLED 1
-
-/* Enable the stub thread support (src/thread/generic/\*.c) */
-#define SDL_THREADS_DISABLED    1
-
-/* Enable the stub timer support (src/timer/dummy/\*.c) */
-#define SDL_TIMERS_DISABLED 1
-
-/* Enable the dummy video driver (src/video/dummy/\*.c) */
-#define SDL_VIDEO_DRIVER_DUMMY  1
-
-/* Enable the dummy filesystem driver (src/filesystem/dummy/\*.c) */
-#define SDL_FILESYSTEM_DUMMY  1
-
-#endif /* SDL_config_minimal_h_ */

thirdparty/include/android/SDL2/SDL_config_ngage.h

@@ -1,89 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_config_ngage_h_
-#define SDL_config_ngage_h_
-#define SDL_config_h_
-
-#include "SDL_platform.h"
-
-typedef signed char        int8_t;
-typedef unsigned char      uint8_t;
-typedef signed short       int16_t;
-typedef unsigned short     uint16_t;
-typedef signed int         int32_t;
-typedef unsigned int       uint32_t;
-typedef signed long long   int64_t;
-typedef unsigned long long uint64_t;
-typedef unsigned long      uintptr_t;
-
-#define HAVE_STDARG_H    1
-#define HAVE_STDDEF_H    1
-#define HAVE_STDIO_H     1
-#define HAVE_STDLIB_H    1
-#define HAVE_MATH_H      1
-#define HAVE_CEIL        1
-#define HAVE_COPYSIGN    1
-#define HAVE_COS         1
-#define HAVE_EXP         1
-#define HAVE_FABS        1
-#define HAVE_FLOOR       1
-#define HAVE_LOG         1
-#define HAVE_LOG10       1
-#define HAVE_SCALBN      1
-#define HAVE_SIN         1
-#define HAVE_SQRT        1
-#define HAVE_TAN         1
-#define HAVE_MALLOC      1
-#define SDL_MAIN_NEEDED  1
-#define LACKS_SYS_MMAN_H 1
-
-/* Enable the N-Gage thread support (src/thread/ngage/\*.c) */
-#define SDL_THREAD_NGAGE 1
-
-/* Enable the N-Gage timer support (src/timer/ngage/\*.c) */
-#define SDL_TIMER_NGAGE  1
-
-/* Enable the N-Gage video driver (src/video/ngage/\*.c) */
-#define SDL_VIDEO_DRIVER_NGAGE 1
-
-/* Enable the dummy audio driver (src/audio/dummy/\*.c) */
-#define SDL_AUDIO_DRIVER_DUMMY  1
-
-/* Enable the stub joystick driver (src/joystick/dummy/\*.c) */
-#define SDL_JOYSTICK_DISABLED   1
-
-/* Enable the stub haptic driver (src/haptic/dummy/\*.c) */
-#define SDL_HAPTIC_DISABLED 1
-
-/* Enable the stub HIDAPI */
-#define SDL_HIDAPI_DISABLED 1
-
-/* Enable the stub sensor driver (src/sensor/dummy/\*.c) */
-#define SDL_SENSOR_DISABLED 1
-
-/* Enable the stub shared object loader (src/loadso/dummy/\*.c) */
-#define SDL_LOADSO_DISABLED 1
-
-/* Enable the dummy filesystem driver (src/filesystem/dummy/\*.c) */
-#define SDL_FILESYSTEM_DUMMY 1
-
-#endif /* SDL_config_ngage_h_ */

thirdparty/include/android/SDL2/SDL_config_os2.h

@@ -1,204 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_config_os2_h_
-#define SDL_config_os2_h_
-#define SDL_config_h_
-
-#include "SDL_platform.h"
-
-#define SIZEOF_VOIDP 4
-
-#define SDL_AUDIO_DRIVER_DUMMY 1
-#define SDL_AUDIO_DRIVER_DISK 1
-#define SDL_AUDIO_DRIVER_OS2 1
-
-#define SDL_POWER_DISABLED  1
-#define SDL_HAPTIC_DISABLED 1
-
-#define SDL_SENSOR_DUMMY 1
-#define SDL_VIDEO_DRIVER_DUMMY 1
-#define SDL_VIDEO_DRIVER_OS2 1
-#define SDL_JOYSTICK_OS2 1
-#ifndef HAVE_LIBUSB_H  /* see Makefile */
-#define SDL_HIDAPI_DISABLED 1
-/*#undef SDL_JOYSTICK_HIDAPI */
-#else
-#define SDL_JOYSTICK_HIDAPI 1
-#define HAVE_LIBUSB 1
-/* dynamically loaded libusb-1.0 dll: */
-#define SDL_LIBUSB_DYNAMIC "usb100.dll"
-#endif
-#define SDL_JOYSTICK_VIRTUAL 1
-
-/* Enable OpenGL support */
-/* #undef SDL_VIDEO_OPENGL */
-
-#define SDL_THREAD_OS2 1
-#define SDL_LOADSO_OS2 1
-#define SDL_TIMER_OS2 1
-#define SDL_FILESYSTEM_OS2 1
-
-/* use libsamplerate for audio rate conversion. */
-/*#define HAVE_LIBSAMPLERATE_H 1 */
-
-/* Enable dynamic libsamplerate support */
-#define SDL_LIBSAMPLERATE_DYNAMIC "SAMPRATE.DLL"
-
-#define HAVE_LIBC 1
-
-#define HAVE_STDARG_H 1
-#define HAVE_STDDEF_H 1
-#define HAVE_STDINT_H 1
-
-#define HAVE_SYS_TYPES_H 1
-#define HAVE_STDIO_H 1
-#define STDC_HEADERS 1
-#define HAVE_STDLIB_H 1
-#define HAVE_MALLOC_H 1
-#define HAVE_MEMORY_H 1
-#define HAVE_STRING_H 1
-#define HAVE_STRINGS_H 1
-#define HAVE_WCHAR_H 1
-#define HAVE_INTTYPES_H 1
-#define HAVE_LIMITS_H 1
-#define HAVE_CTYPE_H 1
-#define HAVE_MATH_H 1
-#define HAVE_FLOAT_H 1
-#define HAVE_SIGNAL_H 1
-
-#if 0 /* see Makefile */
-#define HAVE_ICONV 1
-#define HAVE_ICONV_H 1
-#endif
-
-/* #undef HAVE_DLOPEN */
-#define HAVE_MALLOC 1
-#define HAVE_CALLOC 1
-#define HAVE_REALLOC 1
-#define HAVE_FREE 1
-#if defined(__WATCOMC__)
-#define HAVE__FSEEKI64 1
-#define HAVE__FTELLI64 1
-#endif
-#define HAVE_ALLOCA 1
-#define HAVE_GETENV 1
-#define HAVE_SETENV 1
-#define HAVE_PUTENV 1
-/* OpenWatcom requires specific calling conventions for qsort and bsearch */
-#ifndef __WATCOMC__
-#define HAVE_QSORT 1
-#define HAVE_BSEARCH 1
-#endif
-#define HAVE_ABS 1
-#define HAVE_BCOPY 1
-#define HAVE_MEMSET 1
-#define HAVE_MEMCPY 1
-#define HAVE_MEMMOVE 1
-#define HAVE_MEMCMP 1
-#define HAVE_WCSCMP 1
-#define HAVE__WCSICMP 1
-#define HAVE__WCSNICMP 1
-#define HAVE_WCSLEN 1
-#define HAVE_WCSLCPY 1
-#define HAVE_WCSLCAT 1
-/* #undef HAVE_WCSDUP */
-#define HAVE__WCSDUP 1
-#define HAVE_WCSSTR 1
-#define HAVE_WCSCMP 1
-#define HAVE_WCSNCMP 1
-#define HAVE_STRLEN 1
-#define HAVE_STRLCPY 1
-#define HAVE_STRLCAT 1
-#define HAVE__STRREV 1
-#define HAVE__STRUPR 1
-#define HAVE__STRLWR 1
-/* #undef HAVE_INDEX */
-/* #undef HAVE_RINDEX */
-#define HAVE_STRCHR 1
-#define HAVE_STRRCHR 1
-#define HAVE_STRSTR 1
-/* #undef HAVE_STRTOK_R */
-#define HAVE_ITOA 1
-#define HAVE__LTOA 1
-#define HAVE__ULTOA 1
-#define HAVE_STRTOL 1
-#define HAVE_STRTOUL 1
-#define HAVE__I64TOA 1
-#define HAVE__UI64TOA 1
-#define HAVE_STRTOLL 1
-#define HAVE_STRTOULL 1
-#define HAVE_STRTOD 1
-#define HAVE_ATOI 1
-#define HAVE_ATOF 1
-#define HAVE_STRCMP 1
-#define HAVE_STRNCMP 1
-#define HAVE_STRICMP 1
-#define HAVE_STRCASECMP 1
-#define HAVE_STRNCASECMP 1
-#define HAVE_SSCANF  1
-#define HAVE_VSSCANF 1
-#define HAVE_SNPRINTF 1
-#define HAVE_VSNPRINTF 1
-#define HAVE_SETJMP 1
-#define HAVE_ACOS 1
-/* #undef HAVE_ACOSF */
-#define HAVE_ASIN 1
-/* #undef HAVE_ASINF */
-#define HAVE_ATAN 1
-#define HAVE_ATAN2 1
-/* #undef HAVE_ATAN2F */
-#define HAVE_CEIL 1
-/* #undef HAVE_CEILF */
-/* #undef HAVE_COPYSIGN */
-/* #undef HAVE_COPYSIGNF */
-#define HAVE_COS 1
-/* #undef HAVE_COSF */
-#define HAVE_EXP 1
-/* #undef HAVE_EXPF */
-#define HAVE_FABS 1
-/* #undef HAVE_FABSF */
-#define HAVE_FLOOR 1
-/* #undef HAVE_FLOORF */
-#define HAVE_FMOD 1
-/* #undef HAVE_FMODF */
-#define HAVE_LOG 1
-/* #undef HAVE_LOGF */
-#define HAVE_LOG10 1
-/* #undef HAVE_LOG10F */
-#define HAVE_POW 1
-/* #undef HAVE_POWF */
-#define HAVE_SIN 1
-/* #undef HAVE_SINF */
-/* #undef HAVE_SCALBN */
-/* #undef HAVE_SCALBNF */
-#define HAVE_SQRT 1
-/* #undef HAVE_SQRTF */
-#define HAVE_TAN 1
-/* #undef HAVE_TANF */
-/* #undef HAVE_TRUNC */
-/* #undef HAVE_TRUNCF */
-/* #undef HAVE_LROUND */
-/* #undef HAVE_LROUNDF */
-/* #undef HAVE_ROUND */
-/* #undef HAVE_ROUNDF */
-
-#endif /* SDL_config_os2_h_ */

thirdparty/include/android/SDL2/SDL_config_pandora.h

@@ -1,141 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_config_pandora_h_
-#define SDL_config_pandora_h_
-#define SDL_config_h_
-
-/* This is a set of defines to configure the SDL features */
-
-/* General platform specific identifiers */
-#include "SDL_platform.h"
-
-#ifdef __LP64__
-#define SIZEOF_VOIDP 8
-#else
-#define SIZEOF_VOIDP 4
-#endif
-
-#define SDL_BYTEORDER 1234
-
-#define STDC_HEADERS 1
-#define HAVE_ALLOCA_H 1
-#define HAVE_CTYPE_H 1
-#define HAVE_ICONV_H 1
-#define HAVE_INTTYPES_H 1
-#define HAVE_LIMITS_H 1
-#define HAVE_MALLOC_H 1
-#define HAVE_MATH_H 1
-#define HAVE_MEMORY_H 1
-#define HAVE_SIGNAL_H 1
-#define HAVE_STDARG_H 1
-#define HAVE_STDINT_H 1
-#define HAVE_STDIO_H 1
-#define HAVE_STDLIB_H 1
-#define HAVE_STRINGS_H 1
-#define HAVE_STRING_H 1
-#define HAVE_SYS_TYPES_H 1
-
-#define HAVE_DLOPEN 1
-#define HAVE_MALLOC 1
-#define HAVE_CALLOC 1
-#define HAVE_REALLOC 1
-#define HAVE_FREE 1
-#define HAVE_ALLOCA 1
-#define HAVE_GETENV 1
-#define HAVE_SETENV 1
-#define HAVE_PUTENV 1
-#define HAVE_UNSETENV 1
-#define HAVE_QSORT 1
-#define HAVE_BSEARCH 1
-#define HAVE_ABS 1
-#define HAVE_BCOPY 1
-#define HAVE_MEMSET 1
-#define HAVE_MEMCPY 1
-#define HAVE_MEMMOVE 1
-#define HAVE_STRLEN 1
-#define HAVE_STRCHR 1
-#define HAVE_STRRCHR 1
-#define HAVE_STRSTR 1
-#define HAVE_STRTOL 1
-#define HAVE_STRTOUL 1
-#define HAVE_STRTOLL 1
-#define HAVE_STRTOULL 1
-#define HAVE_ATOI 1
-#define HAVE_ATOF 1
-#define HAVE_STRCMP 1
-#define HAVE_STRNCMP 1
-#define HAVE_STRCASECMP 1
-#define HAVE_STRNCASECMP 1
-#define HAVE_VSSCANF 1
-#define HAVE_VSNPRINTF 1
-#define HAVE_M_PI 1
-#define HAVE_CEIL 1
-#define HAVE_COPYSIGN 1
-#define HAVE_COS 1
-#define HAVE_COSF 1
-#define HAVE_EXP 1
-#define HAVE_FABS 1
-#define HAVE_FLOOR 1
-#define HAVE_LOG 1
-#define HAVE_LOG10 1
-#define HAVE_LROUND 1
-#define HAVE_LROUNDF 1
-#define HAVE_ROUND 1
-#define HAVE_ROUNDF 1
-#define HAVE_SCALBN 1
-#define HAVE_SIN 1
-#define HAVE_SINF 1
-#define HAVE_SQRT 1
-#define HAVE_SQRTF 1
-#define HAVE_TAN 1
-#define HAVE_TANF 1
-#define HAVE_TRUNC 1
-#define HAVE_TRUNCF 1
-#define HAVE_SIGACTION 1
-#define HAVE_SETJMP 1
-#define HAVE_NANOSLEEP 1
-
-#define SDL_AUDIO_DRIVER_DUMMY 1
-#define SDL_AUDIO_DRIVER_OSS 1
-
-#define SDL_INPUT_LINUXEV 1
-#define SDL_JOYSTICK_LINUX 1
-#define SDL_JOYSTICK_VIRTUAL 1
-#define SDL_HAPTIC_LINUX 1
-
-#define SDL_SENSOR_DUMMY 1
-
-#define SDL_LOADSO_DLOPEN 1
-
-#define SDL_THREAD_PTHREAD 1
-#define SDL_THREAD_PTHREAD_RECURSIVE_MUTEX_NP 1
-
-#define SDL_TIMER_UNIX 1
-#define SDL_FILESYSTEM_UNIX 1
-
-#define SDL_VIDEO_DRIVER_DUMMY 1
-#define SDL_VIDEO_DRIVER_X11 1
-#define SDL_VIDEO_DRIVER_PANDORA 1
-#define SDL_VIDEO_RENDER_OGL_ES 1
-#define SDL_VIDEO_OPENGL_ES 1
-
-#endif /* SDL_config_pandora_h_ */

thirdparty/include/android/SDL2/SDL_config_windows.h

@@ -1,333 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_config_windows_h_
-#define SDL_config_windows_h_
-#define SDL_config_h_
-
-#include "SDL_platform.h"
-
-/* winsdkver.h defines _WIN32_MAXVER for SDK version detection. It is present since at least the Windows 7 SDK,
- * but out of caution we'll only use it if the compiler supports __has_include() to confirm its presence.
- * If your compiler doesn't support __has_include() but you have winsdkver.h, define HAVE_WINSDKVER_H.  */
-#if !defined(HAVE_WINSDKVER_H) && defined(__has_include)
-#if __has_include(<winsdkver.h>)
-#define HAVE_WINSDKVER_H 1
-#endif
-#endif
-
-#ifdef HAVE_WINSDKVER_H
-#include <winsdkver.h>
-#endif
-
-/* sdkddkver.h defines more specific SDK version numbers. This is needed because older versions of the
- * Windows 10 SDK have broken declarations for the C API for DirectX 12. */
-#if !defined(HAVE_SDKDDKVER_H) && defined(__has_include)
-#if __has_include(<sdkddkver.h>)
-#define HAVE_SDKDDKVER_H 1
-#endif
-#endif
-
-#ifdef HAVE_SDKDDKVER_H
-#include <sdkddkver.h>
-#endif
-
-/* This is a set of defines to configure the SDL features */
-
-#if !defined(HAVE_STDINT_H) && !defined(_STDINT_H_)
-/* Most everything except Visual Studio 2008 and earlier has stdint.h now */
-#if defined(_MSC_VER) && (_MSC_VER < 1600)
-typedef signed __int8 int8_t;
-typedef unsigned __int8 uint8_t;
-typedef signed __int16 int16_t;
-typedef unsigned __int16 uint16_t;
-typedef signed __int32 int32_t;
-typedef unsigned __int32 uint32_t;
-typedef signed __int64 int64_t;
-typedef unsigned __int64 uint64_t;
-#ifndef _UINTPTR_T_DEFINED
-#ifdef  _WIN64
-typedef unsigned __int64 uintptr_t;
-#else
-typedef unsigned int uintptr_t;
-#endif
-#define _UINTPTR_T_DEFINED
-#endif
-#else
-#define HAVE_STDINT_H 1
-#endif /* Visual Studio 2008 */
-#endif /* !_STDINT_H_ && !HAVE_STDINT_H */
-
-#ifdef _WIN64
-# define SIZEOF_VOIDP 8
-#else
-# define SIZEOF_VOIDP 4
-#endif
-
-#ifdef __clang__
-# define HAVE_GCC_ATOMICS 1
-#endif
-
-#define HAVE_DDRAW_H 1
-#define HAVE_DINPUT_H 1
-#define HAVE_DSOUND_H 1
-#ifndef __WATCOMC__
-#define HAVE_DXGI_H 1
-#define HAVE_XINPUT_H 1
-#if defined(_WIN32_MAXVER) && _WIN32_MAXVER >= 0x0A00  /* Windows 10 SDK */
-#define HAVE_WINDOWS_GAMING_INPUT_H 1
-#endif
-#if defined(_WIN32_MAXVER) && _WIN32_MAXVER >= 0x0602  /* Windows 8 SDK */
-#define HAVE_D3D11_H 1
-#define HAVE_ROAPI_H 1
-#endif
-#if defined(__has_include)
-#if __has_include(<d3d12.h>) && __has_include(<d3d12sdklayers.h>)
-#define HAVE_D3D12_H 1
-#endif
-#endif
-#if defined(_WIN32_MAXVER) && _WIN32_MAXVER >= 0x0603  /* Windows 8.1 SDK */
-#define HAVE_SHELLSCALINGAPI_H 1
-#endif
-#define HAVE_MMDEVICEAPI_H 1
-#define HAVE_AUDIOCLIENT_H 1
-#define HAVE_TPCSHRD_H 1
-#define HAVE_SENSORSAPI_H 1
-#endif
-#if (defined(_M_IX86) || defined(_M_X64) || defined(_M_AMD64)) && (defined(_MSC_VER) && _MSC_VER >= 1600)
-#define HAVE_IMMINTRIN_H 1
-#elif defined(__has_include) && (defined(__i386__) || defined(__x86_64))
-# if __has_include(<immintrin.h>)
-#   define HAVE_IMMINTRIN_H 1
-# endif
-#endif
-
-/* This is disabled by default to avoid C runtime dependencies and manifest requirements */
-#ifdef HAVE_LIBC
-/* Useful headers */
-#define STDC_HEADERS 1
-#define HAVE_CTYPE_H 1
-#define HAVE_FLOAT_H 1
-#define HAVE_LIMITS_H 1
-#define HAVE_MATH_H 1
-#define HAVE_SIGNAL_H 1
-#define HAVE_STDIO_H 1
-#define HAVE_STRING_H 1
-
-/* C library functions */
-#define HAVE_MALLOC 1
-#define HAVE_CALLOC 1
-#define HAVE_REALLOC 1
-#define HAVE_FREE 1
-#define HAVE_ALLOCA 1
-/* OpenWatcom requires specific calling conventions for qsort and bsearch */
-#ifndef __WATCOMC__
-#define HAVE_QSORT 1
-#define HAVE_BSEARCH 1
-#endif
-#define HAVE_ABS 1
-#define HAVE_MEMSET 1
-#define HAVE_MEMCPY 1
-#define HAVE_MEMMOVE 1
-#define HAVE_MEMCMP 1
-#define HAVE_STRLEN 1
-#define HAVE__STRREV 1
-/* These functions have security warnings, so we won't use them */
-/* #undef HAVE__STRUPR */
-/* #undef HAVE__STRLWR */
-#define HAVE_STRCHR 1
-#define HAVE_STRRCHR 1
-#define HAVE_STRSTR 1
-/* #undef HAVE_STRTOK_R */
-/* These functions have security warnings, so we won't use them */
-/* #undef HAVE__LTOA */
-/* #undef HAVE__ULTOA */
-#define HAVE_STRTOL 1
-#define HAVE_STRTOUL 1
-#define HAVE_STRTOD 1
-#define HAVE_ATOI 1
-#define HAVE_ATOF 1
-#define HAVE_STRCMP 1
-#define HAVE_STRNCMP 1
-#define HAVE__STRICMP 1
-#define HAVE__STRNICMP 1
-#define HAVE__WCSICMP 1
-#define HAVE__WCSNICMP 1
-#define HAVE__WCSDUP 1
-#define HAVE_ACOS   1
-#define HAVE_ASIN   1
-#define HAVE_ATAN   1
-#define HAVE_ATAN2  1
-#define HAVE_CEIL   1
-#define HAVE_COS    1
-#define HAVE_EXP    1
-#define HAVE_FABS   1
-#define HAVE_FLOOR  1
-#define HAVE_FMOD   1
-#define HAVE_LOG    1
-#define HAVE_LOG10  1
-#define HAVE_POW    1
-#define HAVE_SIN    1
-#define HAVE_SQRT   1
-#define HAVE_TAN    1
-#ifndef __WATCOMC__
-#define HAVE_ACOSF  1
-#define HAVE_ASINF  1
-#define HAVE_ATANF  1
-#define HAVE_ATAN2F 1
-#define HAVE_CEILF  1
-#define HAVE__COPYSIGN 1
-#define HAVE_COSF   1
-#define HAVE_EXPF   1
-#define HAVE_FABSF  1
-#define HAVE_FLOORF 1
-#define HAVE_FMODF  1
-#define HAVE_LOGF   1
-#define HAVE_LOG10F 1
-#define HAVE_POWF   1
-#define HAVE_SINF   1
-#define HAVE_SQRTF  1
-#define HAVE_TANF   1
-#endif
-#if defined(_MSC_VER)
-/* These functions were added with the VC++ 2013 C runtime library */
-#if _MSC_VER >= 1800
-#define HAVE_STRTOLL 1
-#define HAVE_STRTOULL 1
-#define HAVE_VSSCANF 1
-#define HAVE_LROUND 1
-#define HAVE_LROUNDF 1
-#define HAVE_ROUND 1
-#define HAVE_ROUNDF 1
-#define HAVE_SCALBN 1
-#define HAVE_SCALBNF 1
-#define HAVE_TRUNC  1
-#define HAVE_TRUNCF 1
-#endif
-/* This function is available with at least the VC++ 2008 C runtime library */
-#if _MSC_VER >= 1400
-#define HAVE__FSEEKI64 1
-#endif
-#ifdef _USE_MATH_DEFINES
-#define HAVE_M_PI 1
-#endif
-#elif defined(__WATCOMC__)
-#define HAVE__FSEEKI64 1
-#define HAVE_STRTOLL 1
-#define HAVE_STRTOULL 1
-#define HAVE_VSSCANF 1
-#define HAVE_ROUND 1
-#define HAVE_SCALBN 1
-#define HAVE_TRUNC  1
-#else
-#define HAVE_M_PI 1
-#endif
-#else
-#define HAVE_STDARG_H   1
-#define HAVE_STDDEF_H   1
-#endif
-
-/* Enable various audio drivers */
-#if defined(HAVE_MMDEVICEAPI_H) && defined(HAVE_AUDIOCLIENT_H)
-#define SDL_AUDIO_DRIVER_WASAPI 1
-#endif
-#define SDL_AUDIO_DRIVER_DSOUND 1
-#define SDL_AUDIO_DRIVER_WINMM  1
-#define SDL_AUDIO_DRIVER_DISK   1
-#define SDL_AUDIO_DRIVER_DUMMY  1
-
-/* Enable various input drivers */
-#define SDL_JOYSTICK_DINPUT 1
-#define SDL_JOYSTICK_HIDAPI 1
-#ifndef __WINRT__
-#define SDL_JOYSTICK_RAWINPUT   1
-#endif
-#define SDL_JOYSTICK_VIRTUAL    1
-#ifdef HAVE_WINDOWS_GAMING_INPUT_H
-#define SDL_JOYSTICK_WGI    1
-#endif
-#define SDL_JOYSTICK_XINPUT 1
-#define SDL_HAPTIC_DINPUT   1
-#define SDL_HAPTIC_XINPUT   1
-
-/* Enable the sensor driver */
-#ifdef HAVE_SENSORSAPI_H
-#define SDL_SENSOR_WINDOWS  1
-#else
-#define SDL_SENSOR_DUMMY    1
-#endif
-
-/* Enable various shared object loading systems */
-#define SDL_LOADSO_WINDOWS  1
-
-/* Enable various threading systems */
-#define SDL_THREAD_GENERIC_COND_SUFFIX 1
-#define SDL_THREAD_WINDOWS  1
-
-/* Enable various timer systems */
-#define SDL_TIMER_WINDOWS   1
-
-/* Enable various video drivers */
-#define SDL_VIDEO_DRIVER_DUMMY  1
-#define SDL_VIDEO_DRIVER_WINDOWS    1
-
-#ifndef SDL_VIDEO_RENDER_D3D
-#define SDL_VIDEO_RENDER_D3D    1
-#endif
-#if !defined(SDL_VIDEO_RENDER_D3D11) && defined(HAVE_D3D11_H)
-#define SDL_VIDEO_RENDER_D3D11  1
-#endif
-#if !defined(SDL_VIDEO_RENDER_D3D12) && defined(HAVE_D3D12_H)
-#define SDL_VIDEO_RENDER_D3D12  1
-#endif
-
-/* Enable OpenGL support */
-#ifndef SDL_VIDEO_OPENGL
-#define SDL_VIDEO_OPENGL    1
-#endif
-#ifndef SDL_VIDEO_OPENGL_WGL
-#define SDL_VIDEO_OPENGL_WGL    1
-#endif
-#ifndef SDL_VIDEO_RENDER_OGL
-#define SDL_VIDEO_RENDER_OGL    1
-#endif
-#ifndef SDL_VIDEO_RENDER_OGL_ES2
-#define SDL_VIDEO_RENDER_OGL_ES2    1
-#endif
-#ifndef SDL_VIDEO_OPENGL_ES2
-#define SDL_VIDEO_OPENGL_ES2    1
-#endif
-#ifndef SDL_VIDEO_OPENGL_EGL
-#define SDL_VIDEO_OPENGL_EGL    1
-#endif
-
-/* Enable Vulkan support */
-#define SDL_VIDEO_VULKAN 1
-
-/* Enable system power support */
-#define SDL_POWER_WINDOWS 1
-
-/* Enable filesystem support */
-#define SDL_FILESYSTEM_WINDOWS  1
-
-#endif /* SDL_config_windows_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */

thirdparty/include/android/SDL2/SDL_config_wingdk.h

@@ -1,253 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_config_wingdk_h_
-#define SDL_config_wingdk_h_
-#define SDL_config_h_
-
-#include "SDL_platform.h"
-
-/* Windows GDK does not need Windows SDK version checks because it requires
- * a recent version of the Windows 10 SDK. */
-
-/* GDK only supports 64-bit */
-# define SIZEOF_VOIDP 8
-
-#ifdef __clang__
-# define HAVE_GCC_ATOMICS 1
-#endif
-
-#define HAVE_DDRAW_H 1
-#define HAVE_DINPUT_H 1
-#define HAVE_DSOUND_H 1
-/* No SDK version checks needed for these because the SDK has to be new. */
-#define HAVE_DXGI_H 1
-#define HAVE_XINPUT_H 1
-#define HAVE_WINDOWS_GAMING_INPUT_H 1
-#define HAVE_D3D11_H 1
-#define HAVE_ROAPI_H 1
-#define HAVE_D3D12_H 1
-#define HAVE_SHELLSCALINGAPI_H 1
-#define HAVE_MMDEVICEAPI_H 1
-#define HAVE_AUDIOCLIENT_H 1
-#define HAVE_TPCSHRD_H 1
-#define HAVE_SENSORSAPI_H 1
-#if (defined(_M_IX86) || defined(_M_X64) || defined(_M_AMD64)) && (defined(_MSC_VER) && _MSC_VER >= 1600)
-#define HAVE_IMMINTRIN_H 1
-#elif defined(__has_include) && (defined(__i386__) || defined(__x86_64))
-# if __has_include(<immintrin.h>)
-#   define HAVE_IMMINTRIN_H 1
-# endif
-#endif
-
-/* This is disabled by default to avoid C runtime dependencies and manifest requirements */
-#ifdef HAVE_LIBC
-/* Useful headers */
-#define STDC_HEADERS 1
-#define HAVE_CTYPE_H 1
-#define HAVE_FLOAT_H 1
-#define HAVE_LIMITS_H 1
-#define HAVE_MATH_H 1
-#define HAVE_SIGNAL_H 1
-#define HAVE_STDINT_H 1
-#define HAVE_STDIO_H 1
-#define HAVE_STRING_H 1
-
-/* C library functions */
-#define HAVE_MALLOC 1
-#define HAVE_CALLOC 1
-#define HAVE_REALLOC 1
-#define HAVE_FREE 1
-#define HAVE_ALLOCA 1
-#define HAVE_QSORT 1
-#define HAVE_BSEARCH 1
-#define HAVE_ABS 1
-#define HAVE_MEMSET 1
-#define HAVE_MEMCPY 1
-#define HAVE_MEMMOVE 1
-#define HAVE_MEMCMP 1
-#define HAVE_STRLEN 1
-#define HAVE__STRREV 1
-/* These functions have security warnings, so we won't use them */
-/* #undef HAVE__STRUPR */
-/* #undef HAVE__STRLWR */
-#define HAVE_STRCHR 1
-#define HAVE_STRRCHR 1
-#define HAVE_STRSTR 1
-/* #undef HAVE_STRTOK_R */
-/* These functions have security warnings, so we won't use them */
-/* #undef HAVE__LTOA */
-/* #undef HAVE__ULTOA */
-#define HAVE_STRTOL 1
-#define HAVE_STRTOUL 1
-#define HAVE_STRTOD 1
-#define HAVE_ATOI 1
-#define HAVE_ATOF 1
-#define HAVE_STRCMP 1
-#define HAVE_STRNCMP 1
-#define HAVE__STRICMP 1
-#define HAVE__STRNICMP 1
-#define HAVE__WCSICMP 1
-#define HAVE__WCSNICMP 1
-#define HAVE__WCSDUP 1
-#define HAVE_ACOS   1
-#define HAVE_ASIN   1
-#define HAVE_ATAN   1
-#define HAVE_ATAN2  1
-#define HAVE_CEIL   1
-#define HAVE_COS    1
-#define HAVE_EXP    1
-#define HAVE_FABS   1
-#define HAVE_FLOOR  1
-#define HAVE_FMOD   1
-#define HAVE_LOG    1
-#define HAVE_LOG10  1
-#define HAVE_POW    1
-#define HAVE_SIN    1
-#define HAVE_SQRT   1
-#define HAVE_TAN    1
-#define HAVE_ACOSF  1
-#define HAVE_ASINF  1
-#define HAVE_ATANF  1
-#define HAVE_ATAN2F 1
-#define HAVE_CEILF  1
-#define HAVE__COPYSIGN 1
-#define HAVE_COSF   1
-#define HAVE_EXPF   1
-#define HAVE_FABSF  1
-#define HAVE_FLOORF 1
-#define HAVE_FMODF  1
-#define HAVE_LOGF   1
-#define HAVE_LOG10F 1
-#define HAVE_POWF   1
-#define HAVE_SINF   1
-#define HAVE_SQRTF  1
-#define HAVE_TANF   1
-#if defined(_MSC_VER)
-/* These functions were added with the VC++ 2013 C runtime library */
-#define HAVE_STRTOLL 1
-#define HAVE_STRTOULL 1
-#define HAVE_VSSCANF 1
-#define HAVE_LROUND 1
-#define HAVE_LROUNDF 1
-#define HAVE_ROUND 1
-#define HAVE_ROUNDF 1
-#define HAVE_SCALBN 1
-#define HAVE_SCALBNF 1
-#define HAVE_TRUNC  1
-#define HAVE_TRUNCF 1
-#define HAVE__FSEEKI64 1
-#ifdef _USE_MATH_DEFINES
-#define HAVE_M_PI 1
-#endif
-#else
-#define HAVE_M_PI 1
-#endif
-#else
-#define HAVE_STDARG_H   1
-#define HAVE_STDDEF_H   1
-#define HAVE_STDINT_H   1
-#endif
-
-/* Enable various audio drivers */
-#if defined(HAVE_MMDEVICEAPI_H) && defined(HAVE_AUDIOCLIENT_H)
-#define SDL_AUDIO_DRIVER_WASAPI 1
-#endif
-#define SDL_AUDIO_DRIVER_DSOUND 1
-#define SDL_AUDIO_DRIVER_WINMM  1
-#define SDL_AUDIO_DRIVER_DISK   1
-#define SDL_AUDIO_DRIVER_DUMMY  1
-
-/* Enable various input drivers */
-#define SDL_JOYSTICK_DINPUT 1
-#define SDL_JOYSTICK_HIDAPI 1
-#define SDL_JOYSTICK_RAWINPUT   1
-#define SDL_JOYSTICK_VIRTUAL    1
-#ifdef HAVE_WINDOWS_GAMING_INPUT_H
-#define SDL_JOYSTICK_WGI    1
-#endif
-#define SDL_JOYSTICK_XINPUT 1
-#define SDL_HAPTIC_DINPUT   1
-#define SDL_HAPTIC_XINPUT   1
-
-/* Enable the sensor driver */
-#ifdef HAVE_SENSORSAPI_H
-#define SDL_SENSOR_WINDOWS  1
-#else
-#define SDL_SENSOR_DUMMY    1
-#endif
-
-/* Enable various shared object loading systems */
-#define SDL_LOADSO_WINDOWS  1
-
-/* Enable various threading systems */
-#define SDL_THREAD_GENERIC_COND_SUFFIX 1
-#define SDL_THREAD_WINDOWS  1
-
-/* Enable various timer systems */
-#define SDL_TIMER_WINDOWS   1
-
-/* Enable various video drivers */
-#define SDL_VIDEO_DRIVER_DUMMY  1
-#define SDL_VIDEO_DRIVER_WINDOWS    1
-
-#ifndef SDL_VIDEO_RENDER_D3D
-#define SDL_VIDEO_RENDER_D3D    1
-#endif
-#if !defined(SDL_VIDEO_RENDER_D3D11) && defined(HAVE_D3D11_H)
-#define SDL_VIDEO_RENDER_D3D11  1
-#endif
-#if !defined(SDL_VIDEO_RENDER_D3D12) && defined(HAVE_D3D12_H)
-#define SDL_VIDEO_RENDER_D3D12  1
-#endif
-
-/* Enable OpenGL support */
-#ifndef SDL_VIDEO_OPENGL
-#define SDL_VIDEO_OPENGL    1
-#endif
-#ifndef SDL_VIDEO_OPENGL_WGL
-#define SDL_VIDEO_OPENGL_WGL    1
-#endif
-#ifndef SDL_VIDEO_RENDER_OGL
-#define SDL_VIDEO_RENDER_OGL    1
-#endif
-#ifndef SDL_VIDEO_RENDER_OGL_ES2
-#define SDL_VIDEO_RENDER_OGL_ES2    1
-#endif
-#ifndef SDL_VIDEO_OPENGL_ES2
-#define SDL_VIDEO_OPENGL_ES2    1
-#endif
-#ifndef SDL_VIDEO_OPENGL_EGL
-#define SDL_VIDEO_OPENGL_EGL    1
-#endif
-
-/* Enable Vulkan support */
-#define SDL_VIDEO_VULKAN 1
-
-/* Enable system power support */
-#define SDL_POWER_WINDOWS 1
-
-/* Enable filesystem support */
-#define SDL_FILESYSTEM_WINDOWS  1
-
-#endif /* SDL_config_wingdk_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */

thirdparty/include/android/SDL2/SDL_config_winrt.h

@@ -1,220 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_config_winrt_h_
-#define SDL_config_winrt_h_
-#define SDL_config_h_
-
-#include "SDL_platform.h"
-
-/* Make sure the Windows SDK's NTDDI_VERSION macro gets defined.  This is used
-   by SDL to determine which version of the Windows SDK is being used.
-*/
-#include <sdkddkver.h>
-
-/* Define possibly-undefined NTDDI values (used when compiling SDL against
-   older versions of the Windows SDK.
-*/
-#ifndef NTDDI_WINBLUE
-#define NTDDI_WINBLUE 0x06030000
-#endif
-#ifndef NTDDI_WIN10
-#define NTDDI_WIN10 0x0A000000
-#endif
-
-/* This is a set of defines to configure the SDL features */
-
-#ifdef _WIN64
-# define SIZEOF_VOIDP 8
-#else
-# define SIZEOF_VOIDP 4
-#endif
-
-#ifdef __clang__
-# define HAVE_GCC_ATOMICS 1
-#endif
-
-/* Useful headers */
-#define HAVE_DXGI_H 1
-#if !SDL_WINAPI_FAMILY_PHONE
-#define HAVE_XINPUT_H 1
-#endif
-
-#define HAVE_MMDEVICEAPI_H 1
-#define HAVE_AUDIOCLIENT_H 1
-#define HAVE_TPCSHRD_H 1
-
-#define HAVE_LIBC 1
-#define STDC_HEADERS 1
-#define HAVE_CTYPE_H 1
-#define HAVE_FLOAT_H 1
-#define HAVE_LIMITS_H 1
-#define HAVE_MATH_H 1
-#define HAVE_SIGNAL_H 1
-#define HAVE_STDINT_H 1
-#define HAVE_STDIO_H 1
-#define HAVE_STRING_H 1
-
-/* C library functions */
-#define HAVE_MALLOC 1
-#define HAVE_CALLOC 1
-#define HAVE_REALLOC 1
-#define HAVE_FREE 1
-#define HAVE_ALLOCA 1
-#define HAVE_QSORT 1
-#define HAVE_BSEARCH 1
-#define HAVE_ABS 1
-#define HAVE_MEMSET 1
-#define HAVE_MEMCPY 1
-#define HAVE_MEMMOVE 1
-#define HAVE_MEMCMP 1
-#define HAVE_STRLEN 1
-#define HAVE__STRREV 1
-#define HAVE__STRUPR 1
-#define HAVE_STRCHR 1
-#define HAVE_STRRCHR 1
-#define HAVE_STRSTR 1
-#define HAVE_STRTOL 1
-#define HAVE_STRTOUL 1
-/* #undef HAVE_STRTOLL */
-/* #undef HAVE_STRTOULL */
-#define HAVE_STRTOD 1
-#define HAVE_ATOI 1
-#define HAVE_ATOF 1
-#define HAVE_STRCMP 1
-#define HAVE_STRNCMP 1
-#define HAVE__STRICMP 1
-#define HAVE__STRNICMP 1
-#define HAVE_VSNPRINTF 1
-/* TODO, WinRT: consider using ??_s versions of the following */
-/* #undef HAVE__STRLWR */
-/* #undef HAVE_ITOA */
-/* #undef HAVE__LTOA */
-/* #undef HAVE__ULTOA */
-/* #undef HAVE_SSCANF */
-#define HAVE_M_PI 1
-#define HAVE_ACOS   1
-#define HAVE_ACOSF  1
-#define HAVE_ASIN   1
-#define HAVE_ASINF  1
-#define HAVE_ATAN   1
-#define HAVE_ATANF  1
-#define HAVE_ATAN2  1
-#define HAVE_ATAN2F 1
-#define HAVE_CEIL   1
-#define HAVE_CEILF  1
-#define HAVE__COPYSIGN 1
-#define HAVE_COS    1
-#define HAVE_COSF   1
-#define HAVE_EXP    1
-#define HAVE_EXPF   1
-#define HAVE_FABS   1
-#define HAVE_FABSF  1
-#define HAVE_FLOOR  1
-#define HAVE_FLOORF 1
-#define HAVE_FMOD   1
-#define HAVE_FMODF  1
-#define HAVE_LOG    1
-#define HAVE_LOGF   1
-#define HAVE_LOG10  1
-#define HAVE_LOG10F 1
-#define HAVE_LROUND 1
-#define HAVE_LROUNDF 1
-#define HAVE_POW    1
-#define HAVE_POWF   1
-#define HAVE_ROUND 1
-#define HAVE_ROUNDF 1
-#define HAVE__SCALB 1
-#define HAVE_SIN    1
-#define HAVE_SINF   1
-#define HAVE_SQRT   1
-#define HAVE_SQRTF  1
-#define HAVE_TAN    1
-#define HAVE_TANF   1
-#define HAVE_TRUNC  1
-#define HAVE_TRUNCF 1
-#define HAVE__FSEEKI64 1
-
-#define HAVE_ROAPI_H  1
-
-/* Enable various audio drivers */
-#define SDL_AUDIO_DRIVER_WASAPI 1
-#define SDL_AUDIO_DRIVER_DISK   1
-#define SDL_AUDIO_DRIVER_DUMMY  1
-
-/* Enable various input drivers */
-#if SDL_WINAPI_FAMILY_PHONE
-#define SDL_JOYSTICK_DISABLED 1
-#define SDL_HAPTIC_DISABLED 1
-#else
-#define SDL_JOYSTICK_VIRTUAL    1
-#if (NTDDI_VERSION >= NTDDI_WIN10)
-#define SDL_JOYSTICK_WGI    1
-#define SDL_HAPTIC_DISABLED 1
-#else
-#define SDL_JOYSTICK_XINPUT 1
-#define SDL_HAPTIC_XINPUT   1
-#endif /* WIN10 */
-#endif
-
-/* WinRT doesn't have HIDAPI available */
-#define SDL_HIDAPI_DISABLED    1
-
-/* Enable the dummy sensor driver */
-#define SDL_SENSOR_DUMMY  1
-
-/* Enable various shared object loading systems */
-#define SDL_LOADSO_WINDOWS  1
-
-/* Enable various threading systems */
-#if (NTDDI_VERSION >= NTDDI_WINBLUE)
-#define SDL_THREAD_GENERIC_COND_SUFFIX 1
-#define SDL_THREAD_WINDOWS  1
-#else
-/* WinRT on Windows 8.0 and Windows Phone 8.0 don't support CreateThread() */
-#define SDL_THREAD_STDCPP   1
-#endif
-
-/* Enable various timer systems */
-#define SDL_TIMER_WINDOWS   1
-
-/* Enable various video drivers */
-#define SDL_VIDEO_DRIVER_WINRT  1
-#define SDL_VIDEO_DRIVER_DUMMY  1
-
-/* Enable OpenGL ES 2.0 (via a modified ANGLE library) */
-#define SDL_VIDEO_OPENGL_ES2 1
-#define SDL_VIDEO_OPENGL_EGL 1
-
-/* Enable appropriate renderer(s) */
-#define SDL_VIDEO_RENDER_D3D11  1
-
-/* Disable D3D12 as it's not implemented for WinRT */
-/* #undef SDL_VIDEO_RENDER_D3D12 */
-
-#ifdef SDL_VIDEO_OPENGL_ES2
-#define SDL_VIDEO_RENDER_OGL_ES2 1
-#endif
-
-/* Enable system power support */
-#define SDL_POWER_WINRT 1
-
-#endif /* SDL_config_winrt_h_ */

thirdparty/include/android/SDL2/SDL_config_xbox.h

@@ -1,240 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_config_wingdk_h_
-#define SDL_config_wingdk_h_
-#define SDL_config_h_
-
-#include "SDL_platform.h"
-
-/* Windows GDK does not need Windows SDK version checks because it requires
- * a recent version of the Windows 10 SDK. */
-
-/* GDK only supports 64-bit */
-# define SIZEOF_VOIDP 8
-
-#ifdef __clang__
-# define HAVE_GCC_ATOMICS 1
-#endif
-
-/*#define HAVE_DDRAW_H 1*/
-/*#define HAVE_DINPUT_H 1*/
-/*#define HAVE_DSOUND_H 1*/
-/* No SDK version checks needed for these because the SDK has to be new. */
-/* #define HAVE_DXGI_H 1 */
-#define HAVE_XINPUT_H 1
-/*#define HAVE_WINDOWS_GAMING_INPUT_H 1*/
-/*#define HAVE_D3D11_H 1*/
-/*#define HAVE_ROAPI_H 1*/
-#define HAVE_D3D12_H 1
-/*#define HAVE_SHELLSCALINGAPI_H 1*/
-#define HAVE_MMDEVICEAPI_H 1
-#define HAVE_AUDIOCLIENT_H 1
-/*#define HAVE_TPCSHRD_H  1*/
-/*#define HAVE_SENSORSAPI_H 1*/
-#if (defined(_M_IX86) || defined(_M_X64) || defined(_M_AMD64)) && (defined(_MSC_VER) && _MSC_VER >= 1600)
-#define HAVE_IMMINTRIN_H 1
-#elif defined(__has_include) && (defined(__i386__) || defined(__x86_64))
-# if __has_include(<immintrin.h>)
-#   define HAVE_IMMINTRIN_H 1
-# endif
-#endif
-
-/* This is disabled by default to avoid C runtime dependencies and manifest requirements */
-#ifdef HAVE_LIBC
-/* Useful headers */
-#define STDC_HEADERS 1
-#define HAVE_CTYPE_H 1
-#define HAVE_FLOAT_H 1
-#define HAVE_LIMITS_H 1
-#define HAVE_MATH_H 1
-#define HAVE_SIGNAL_H 1
-#define HAVE_STDINT_H 1
-#define HAVE_STDIO_H 1
-#define HAVE_STRING_H 1
-
-/* C library functions */
-#define HAVE_MALLOC 1
-#define HAVE_CALLOC 1
-#define HAVE_REALLOC 1
-#define HAVE_FREE 1
-#define HAVE_ALLOCA 1
-#define HAVE_QSORT 1
-#define HAVE_BSEARCH 1
-#define HAVE_ABS 1
-#define HAVE_MEMSET 1
-#define HAVE_MEMCPY 1
-#define HAVE_MEMMOVE 1
-#define HAVE_MEMCMP 1
-#define HAVE_STRLEN 1
-#define HAVE__STRREV 1
-/* These functions have security warnings, so we won't use them */
-/* #undef HAVE__STRUPR */
-/* #undef HAVE__STRLWR */
-#define HAVE_STRCHR 1
-#define HAVE_STRRCHR 1
-#define HAVE_STRSTR 1
-/* #undef HAVE_STRTOK_R */
-/* These functions have security warnings, so we won't use them */
-/* #undef HAVE__LTOA */
-/* #undef HAVE__ULTOA */
-#define HAVE_STRTOL 1
-#define HAVE_STRTOUL 1
-#define HAVE_STRTOD 1
-#define HAVE_ATOI 1
-#define HAVE_ATOF 1
-#define HAVE_STRCMP 1
-#define HAVE_STRNCMP 1
-#define HAVE__STRICMP 1
-#define HAVE__STRNICMP 1
-#define HAVE__WCSICMP 1
-#define HAVE__WCSNICMP 1
-#define HAVE__WCSDUP 1
-#define HAVE_ACOS   1
-#define HAVE_ASIN   1
-#define HAVE_ATAN   1
-#define HAVE_ATAN2  1
-#define HAVE_CEIL   1
-#define HAVE_COS    1
-#define HAVE_EXP    1
-#define HAVE_FABS   1
-#define HAVE_FLOOR  1
-#define HAVE_FMOD   1
-#define HAVE_LOG    1
-#define HAVE_LOG10  1
-#define HAVE_POW    1
-#define HAVE_SIN    1
-#define HAVE_SQRT   1
-#define HAVE_TAN    1
-#define HAVE_ACOSF  1
-#define HAVE_ASINF  1
-#define HAVE_ATANF  1
-#define HAVE_ATAN2F 1
-#define HAVE_CEILF  1
-#define HAVE__COPYSIGN 1
-#define HAVE_COSF   1
-#define HAVE_EXPF   1
-#define HAVE_FABSF  1
-#define HAVE_FLOORF 1
-#define HAVE_FMODF  1
-#define HAVE_LOGF   1
-#define HAVE_LOG10F 1
-#define HAVE_POWF   1
-#define HAVE_SINF   1
-#define HAVE_SQRTF  1
-#define HAVE_TANF   1
-#if defined(_MSC_VER)
-/* These functions were added with the VC++ 2013 C runtime library */
-#define HAVE_STRTOLL 1
-#define HAVE_STRTOULL 1
-#define HAVE_VSSCANF 1
-#define HAVE_LROUND 1
-#define HAVE_LROUNDF 1
-#define HAVE_ROUND 1
-#define HAVE_ROUNDF 1
-#define HAVE_SCALBN 1
-#define HAVE_SCALBNF 1
-#define HAVE_TRUNC  1
-#define HAVE_TRUNCF 1
-#define HAVE__FSEEKI64 1
-#ifdef _USE_MATH_DEFINES
-#define HAVE_M_PI 1
-#endif
-#else
-#define HAVE_M_PI 1
-#endif
-#else
-#define HAVE_STDARG_H   1
-#define HAVE_STDDEF_H   1
-#define HAVE_STDINT_H   1
-#endif
-
-/* Enable various audio drivers */
-#if defined(HAVE_MMDEVICEAPI_H) && defined(HAVE_AUDIOCLIENT_H)
-#define SDL_AUDIO_DRIVER_WASAPI 1
-#endif
-/*#define SDL_AUDIO_DRIVER_DSOUND 1*/
-/*#define SDL_AUDIO_DRIVER_WINMM  1*/
-#define SDL_AUDIO_DRIVER_DISK   1
-#define SDL_AUDIO_DRIVER_DUMMY  1
-
-/* Enable various input drivers */
-/*#define SDL_JOYSTICK_DINPUT 1*/
-/*#define SDL_JOYSTICK_HIDAPI 1*/
-/*#define SDL_JOYSTICK_RAWINPUT   1*/
-#define SDL_JOYSTICK_VIRTUAL    1
-#ifdef HAVE_WINDOWS_GAMING_INPUT_H
-#define SDL_JOYSTICK_WGI    1
-#endif
-#define SDL_JOYSTICK_XINPUT 1
-/*#define SDL_HAPTIC_DINPUT   1*/
-#define SDL_HAPTIC_XINPUT   1
-
-/* Enable the sensor driver */
-#ifdef HAVE_SENSORSAPI_H
-#define SDL_SENSOR_WINDOWS  1
-#else
-#define SDL_SENSOR_DUMMY    1
-#endif
-
-/* Enable various shared object loading systems */
-#define SDL_LOADSO_WINDOWS  1
-
-/* Enable various threading systems */
-#define SDL_THREAD_GENERIC_COND_SUFFIX 1
-#define SDL_THREAD_WINDOWS  1
-
-/* Enable various timer systems */
-#define SDL_TIMER_WINDOWS   1
-
-/* Enable various video drivers */
-#define SDL_VIDEO_DRIVER_DUMMY  1
-#define SDL_VIDEO_DRIVER_WINDOWS    1
-
-#if !defined(SDL_VIDEO_RENDER_D3D12) && defined(HAVE_D3D12_H)
-#define SDL_VIDEO_RENDER_D3D12  1
-#endif
-
-/* Enable OpenGL support */
-#ifndef SDL_VIDEO_OPENGL
-#define SDL_VIDEO_OPENGL    1
-#endif
-#ifndef SDL_VIDEO_OPENGL_WGL
-#define SDL_VIDEO_OPENGL_WGL    1
-#endif
-#ifndef SDL_VIDEO_RENDER_OGL
-#define SDL_VIDEO_RENDER_OGL    1
-#endif
-
-/* Enable system power support */
-/*#define SDL_POWER_WINDOWS 1*/
-#define SDL_POWER_HARDWIRED 1
-
-/* Enable filesystem support */
-/* #define SDL_FILESYSTEM_WINDOWS 1*/
-#define SDL_FILESYSTEM_XBOX 1
-
-/* Disable IME as not supported yet (TODO: Xbox IME?) */
-#define SDL_DISABLE_WINDOWS_IME 1
-
-#endif /* SDL_config_wingdk_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */

thirdparty/include/android/SDL2/SDL_copying.h

@@ -1,20 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/

thirdparty/include/android/SDL2/SDL_cpuinfo.h

@@ -1,601 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/* WIKI CATEGORY: CPUInfo */
-
-/**
- * # CategoryCPUInfo
- *
- * CPU feature detection for SDL.
- *
- * These functions are largely concerned with reporting if the system has
- * access to various SIMD instruction sets, but also has other important info
- * to share, such as number of logical CPU cores.
- */
-
-#ifndef SDL_cpuinfo_h_
-#define SDL_cpuinfo_h_
-
-#include "SDL_stdinc.h"
-
-/* Need to do this here because intrin.h has C++ code in it */
-/* Visual Studio 2005 has a bug where intrin.h conflicts with winnt.h */
-#if defined(_MSC_VER) && (_MSC_VER >= 1500) && (defined(_M_IX86) || defined(_M_X64))
-/* As of Clang 11, '_m_prefetchw' is conflicting with the winnt.h's version,
-   so we define the needed '_m_prefetch' here as a pseudo-header, until the issue is fixed. */
-#if defined(__clang__) &&  !_SDL_HAS_BUILTIN(_m_prefetch)
-#ifndef __PRFCHWINTRIN_H
-#define __PRFCHWINTRIN_H
-static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_m_prefetch(void *__P)
-{
-  __builtin_prefetch(__P, 0, 3 /* _MM_HINT_T0 */);
-}
-#endif /* __PRFCHWINTRIN_H */
-#endif /* __clang__ */
-
-#include <intrin.h>
-#ifndef _WIN64
-#ifndef __MMX__
-#define __MMX__
-#endif
-/*
-#ifndef __3dNOW__
-#define __3dNOW__
-#endif
-*/
-#endif
-#ifndef __SSE__
-#define __SSE__
-#endif
-#ifndef __SSE2__
-#define __SSE2__
-#endif
-#ifndef __SSE3__
-#define __SSE3__
-#endif
-#elif defined(__MINGW64_VERSION_MAJOR)
-#include <intrin.h>
-#if !defined(SDL_DISABLE_ARM_NEON_H) && defined(__ARM_NEON)
-#  include <arm_neon.h>
-#endif
-#else
-/* altivec.h redefining bool causes a number of problems, see bugs 3993 and 4392, so you need to explicitly define SDL_ENABLE_ALTIVEC_H to have it included. */
-#if defined(HAVE_ALTIVEC_H) && defined(__ALTIVEC__) && !defined(__APPLE_ALTIVEC__) && defined(SDL_ENABLE_ALTIVEC_H)
-#include <altivec.h>
-#endif
-#if !defined(SDL_DISABLE_ARM_NEON_H)
-#  if defined(__ARM_NEON)
-#    include <arm_neon.h>
-#  elif defined(__WINDOWS__) || defined(__WINRT__) || defined(__GDK__)
-/* Visual Studio doesn't define __ARM_ARCH, but _M_ARM (if set, always 7), and _M_ARM64 (if set, always 1). */
-#    if defined(_M_ARM)
-#      include <armintr.h>
-#      include <arm_neon.h>
-#      define __ARM_NEON 1 /* Set __ARM_NEON so that it can be used elsewhere, at compile time */
-#    endif
-#    if defined (_M_ARM64)
-#      include <arm64intr.h>
-#      include <arm64_neon.h>
-#      define __ARM_NEON 1 /* Set __ARM_NEON so that it can be used elsewhere, at compile time */
-#      define __ARM_ARCH 8
-#    endif
-#  endif
-#endif
-#endif /* compiler version */
-
-#if defined(__3dNOW__) && !defined(SDL_DISABLE_MM3DNOW_H)
-#include <mm3dnow.h>
-#endif
-#if defined(__loongarch_sx) && !defined(SDL_DISABLE_LSX_H)
-#include <lsxintrin.h>
-#define __LSX__
-#endif
-#if defined(__loongarch_asx) && !defined(SDL_DISABLE_LASX_H)
-#include <lasxintrin.h>
-#define __LASX__
-#endif
-#if defined(HAVE_IMMINTRIN_H) && !defined(SDL_DISABLE_IMMINTRIN_H) && \
-   (defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || defined(_M_IX86))
-#include <immintrin.h>
-#else
-#if defined(__MMX__) && !defined(SDL_DISABLE_MMINTRIN_H)
-#include <mmintrin.h>
-#endif
-#if defined(__SSE__) && !defined(SDL_DISABLE_XMMINTRIN_H)
-#include <xmmintrin.h>
-#endif
-#if defined(__SSE2__) && !defined(SDL_DISABLE_EMMINTRIN_H)
-#include <emmintrin.h>
-#endif
-#if defined(__SSE3__) && !defined(SDL_DISABLE_PMMINTRIN_H)
-#include <pmmintrin.h>
-#endif
-#endif /* HAVE_IMMINTRIN_H */
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* This is a guess for the cacheline size used for padding.
- * Most x86 processors have a 64 byte cache line.
- * The 64-bit PowerPC processors have a 128 byte cache line.
- * We'll use the larger value to be generally safe.
- */
-#define SDL_CACHELINE_SIZE  128
-
-/**
- * Get the number of CPU cores available.
- *
- * \returns the total number of logical CPU cores. On CPUs that include
- *          technologies such as hyperthreading, the number of logical cores
- *          may be more than the number of physical cores.
- *
- * \since This function is available since SDL 2.0.0.
- */
-extern DECLSPEC int SDLCALL SDL_GetCPUCount(void);
-
-/**
- * Determine the L1 cache line size of the CPU.
- *
- * This is useful for determining multi-threaded structure padding or SIMD
- * prefetch sizes.
- *
- * \returns the L1 cache line size of the CPU, in bytes.
- *
- * \since This function is available since SDL 2.0.0.
- */
-extern DECLSPEC int SDLCALL SDL_GetCPUCacheLineSize(void);
-
-/**
- * Determine whether the CPU has the RDTSC instruction.
- *
- * This always returns false on CPUs that aren't using Intel instruction sets.
- *
- * \returns SDL_TRUE if the CPU has the RDTSC instruction or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Has3DNow
- * \sa SDL_HasAltiVec
- * \sa SDL_HasAVX
- * \sa SDL_HasAVX2
- * \sa SDL_HasMMX
- * \sa SDL_HasSSE
- * \sa SDL_HasSSE2
- * \sa SDL_HasSSE3
- * \sa SDL_HasSSE41
- * \sa SDL_HasSSE42
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasRDTSC(void);
-
-/**
- * Determine whether the CPU has AltiVec features.
- *
- * This always returns false on CPUs that aren't using PowerPC instruction
- * sets.
- *
- * \returns SDL_TRUE if the CPU has AltiVec features or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Has3DNow
- * \sa SDL_HasAVX
- * \sa SDL_HasAVX2
- * \sa SDL_HasMMX
- * \sa SDL_HasRDTSC
- * \sa SDL_HasSSE
- * \sa SDL_HasSSE2
- * \sa SDL_HasSSE3
- * \sa SDL_HasSSE41
- * \sa SDL_HasSSE42
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasAltiVec(void);
-
-/**
- * Determine whether the CPU has MMX features.
- *
- * This always returns false on CPUs that aren't using Intel instruction sets.
- *
- * \returns SDL_TRUE if the CPU has MMX features or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Has3DNow
- * \sa SDL_HasAltiVec
- * \sa SDL_HasAVX
- * \sa SDL_HasAVX2
- * \sa SDL_HasRDTSC
- * \sa SDL_HasSSE
- * \sa SDL_HasSSE2
- * \sa SDL_HasSSE3
- * \sa SDL_HasSSE41
- * \sa SDL_HasSSE42
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasMMX(void);
-
-/**
- * Determine whether the CPU has 3DNow! features.
- *
- * This always returns false on CPUs that aren't using AMD instruction sets.
- *
- * \returns SDL_TRUE if the CPU has 3DNow! features or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_HasAltiVec
- * \sa SDL_HasAVX
- * \sa SDL_HasAVX2
- * \sa SDL_HasMMX
- * \sa SDL_HasRDTSC
- * \sa SDL_HasSSE
- * \sa SDL_HasSSE2
- * \sa SDL_HasSSE3
- * \sa SDL_HasSSE41
- * \sa SDL_HasSSE42
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_Has3DNow(void);
-
-/**
- * Determine whether the CPU has SSE features.
- *
- * This always returns false on CPUs that aren't using Intel instruction sets.
- *
- * \returns SDL_TRUE if the CPU has SSE features or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Has3DNow
- * \sa SDL_HasAltiVec
- * \sa SDL_HasAVX
- * \sa SDL_HasAVX2
- * \sa SDL_HasMMX
- * \sa SDL_HasRDTSC
- * \sa SDL_HasSSE2
- * \sa SDL_HasSSE3
- * \sa SDL_HasSSE41
- * \sa SDL_HasSSE42
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasSSE(void);
-
-/**
- * Determine whether the CPU has SSE2 features.
- *
- * This always returns false on CPUs that aren't using Intel instruction sets.
- *
- * \returns SDL_TRUE if the CPU has SSE2 features or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Has3DNow
- * \sa SDL_HasAltiVec
- * \sa SDL_HasAVX
- * \sa SDL_HasAVX2
- * \sa SDL_HasMMX
- * \sa SDL_HasRDTSC
- * \sa SDL_HasSSE
- * \sa SDL_HasSSE3
- * \sa SDL_HasSSE41
- * \sa SDL_HasSSE42
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasSSE2(void);
-
-/**
- * Determine whether the CPU has SSE3 features.
- *
- * This always returns false on CPUs that aren't using Intel instruction sets.
- *
- * \returns SDL_TRUE if the CPU has SSE3 features or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Has3DNow
- * \sa SDL_HasAltiVec
- * \sa SDL_HasAVX
- * \sa SDL_HasAVX2
- * \sa SDL_HasMMX
- * \sa SDL_HasRDTSC
- * \sa SDL_HasSSE
- * \sa SDL_HasSSE2
- * \sa SDL_HasSSE41
- * \sa SDL_HasSSE42
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasSSE3(void);
-
-/**
- * Determine whether the CPU has SSE4.1 features.
- *
- * This always returns false on CPUs that aren't using Intel instruction sets.
- *
- * \returns SDL_TRUE if the CPU has SSE4.1 features or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Has3DNow
- * \sa SDL_HasAltiVec
- * \sa SDL_HasAVX
- * \sa SDL_HasAVX2
- * \sa SDL_HasMMX
- * \sa SDL_HasRDTSC
- * \sa SDL_HasSSE
- * \sa SDL_HasSSE2
- * \sa SDL_HasSSE3
- * \sa SDL_HasSSE42
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasSSE41(void);
-
-/**
- * Determine whether the CPU has SSE4.2 features.
- *
- * This always returns false on CPUs that aren't using Intel instruction sets.
- *
- * \returns SDL_TRUE if the CPU has SSE4.2 features or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Has3DNow
- * \sa SDL_HasAltiVec
- * \sa SDL_HasAVX
- * \sa SDL_HasAVX2
- * \sa SDL_HasMMX
- * \sa SDL_HasRDTSC
- * \sa SDL_HasSSE
- * \sa SDL_HasSSE2
- * \sa SDL_HasSSE3
- * \sa SDL_HasSSE41
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasSSE42(void);
-
-/**
- * Determine whether the CPU has AVX features.
- *
- * This always returns false on CPUs that aren't using Intel instruction sets.
- *
- * \returns SDL_TRUE if the CPU has AVX features or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.2.
- *
- * \sa SDL_Has3DNow
- * \sa SDL_HasAltiVec
- * \sa SDL_HasAVX2
- * \sa SDL_HasMMX
- * \sa SDL_HasRDTSC
- * \sa SDL_HasSSE
- * \sa SDL_HasSSE2
- * \sa SDL_HasSSE3
- * \sa SDL_HasSSE41
- * \sa SDL_HasSSE42
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasAVX(void);
-
-/**
- * Determine whether the CPU has AVX2 features.
- *
- * This always returns false on CPUs that aren't using Intel instruction sets.
- *
- * \returns SDL_TRUE if the CPU has AVX2 features or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.4.
- *
- * \sa SDL_Has3DNow
- * \sa SDL_HasAltiVec
- * \sa SDL_HasAVX
- * \sa SDL_HasMMX
- * \sa SDL_HasRDTSC
- * \sa SDL_HasSSE
- * \sa SDL_HasSSE2
- * \sa SDL_HasSSE3
- * \sa SDL_HasSSE41
- * \sa SDL_HasSSE42
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasAVX2(void);
-
-/**
- * Determine whether the CPU has AVX-512F (foundation) features.
- *
- * This always returns false on CPUs that aren't using Intel instruction sets.
- *
- * \returns SDL_TRUE if the CPU has AVX-512F features or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.9.
- *
- * \sa SDL_HasAVX
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasAVX512F(void);
-
-/**
- * Determine whether the CPU has ARM SIMD (ARMv6) features.
- *
- * This is different from ARM NEON, which is a different instruction set.
- *
- * This always returns false on CPUs that aren't using ARM instruction sets.
- *
- * \returns SDL_TRUE if the CPU has ARM SIMD features or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.12.
- *
- * \sa SDL_HasNEON
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasARMSIMD(void);
-
-/**
- * Determine whether the CPU has NEON (ARM SIMD) features.
- *
- * This always returns false on CPUs that aren't using ARM instruction sets.
- *
- * \returns SDL_TRUE if the CPU has ARM NEON features or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.6.
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasNEON(void);
-
-/**
- * Determine whether the CPU has LSX (LOONGARCH SIMD) features.
- *
- * This always returns false on CPUs that aren't using LOONGARCH instruction
- * sets.
- *
- * \returns SDL_TRUE if the CPU has LOONGARCH LSX features or SDL_FALSE if
- *          not.
- *
- * \since This function is available since SDL 2.24.0.
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasLSX(void);
-
-/**
- * Determine whether the CPU has LASX (LOONGARCH SIMD) features.
- *
- * This always returns false on CPUs that aren't using LOONGARCH instruction
- * sets.
- *
- * \returns SDL_TRUE if the CPU has LOONGARCH LASX features or SDL_FALSE if
- *          not.
- *
- * \since This function is available since SDL 2.24.0.
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasLASX(void);
-
-/**
- * Get the amount of RAM configured in the system.
- *
- * \returns the amount of RAM configured in the system in MiB.
- *
- * \since This function is available since SDL 2.0.1.
- */
-extern DECLSPEC int SDLCALL SDL_GetSystemRAM(void);
-
-/**
- * Report the alignment this system needs for SIMD allocations.
- *
- * This will return the minimum number of bytes to which a pointer must be
- * aligned to be compatible with SIMD instructions on the current machine. For
- * example, if the machine supports SSE only, it will return 16, but if it
- * supports AVX-512F, it'll return 64 (etc). This only reports values for
- * instruction sets SDL knows about, so if your SDL build doesn't have
- * SDL_HasAVX512F(), then it might return 16 for the SSE support it sees and
- * not 64 for the AVX-512 instructions that exist but SDL doesn't know about.
- * Plan accordingly.
- *
- * \returns the alignment in bytes needed for available, known SIMD
- *          instructions.
- *
- * \since This function is available since SDL 2.0.10.
- */
-extern DECLSPEC size_t SDLCALL SDL_SIMDGetAlignment(void);
-
-/**
- * Allocate memory in a SIMD-friendly way.
- *
- * This will allocate a block of memory that is suitable for use with SIMD
- * instructions. Specifically, it will be properly aligned and padded for the
- * system's supported vector instructions.
- *
- * The memory returned will be padded such that it is safe to read or write an
- * incomplete vector at the end of the memory block. This can be useful so you
- * don't have to drop back to a scalar fallback at the end of your SIMD
- * processing loop to deal with the final elements without overflowing the
- * allocated buffer.
- *
- * You must free this memory with SDL_FreeSIMD(), not free() or SDL_free() or
- * delete[], etc.
- *
- * Note that SDL will only deal with SIMD instruction sets it is aware of; for
- * example, SDL 2.0.8 knows that SSE wants 16-byte vectors (SDL_HasSSE()), and
- * AVX2 wants 32 bytes (SDL_HasAVX2()), but doesn't know that AVX-512 wants
- * 64. To be clear: if you can't decide to use an instruction set with an
- * SDL_Has*() function, don't use that instruction set with memory allocated
- * through here.
- *
- * SDL_AllocSIMD(0) will return a non-NULL pointer, assuming the system isn't
- * out of memory, but you are not allowed to dereference it (because you only
- * own zero bytes of that buffer).
- *
- * \param len The length, in bytes, of the block to allocate. The actual
- *            allocated block might be larger due to padding, etc.
- * \returns a pointer to the newly-allocated block, NULL if out of memory.
- *
- * \since This function is available since SDL 2.0.10.
- *
- * \sa SDL_SIMDGetAlignment
- * \sa SDL_SIMDRealloc
- * \sa SDL_SIMDFree
- */
-extern DECLSPEC void * SDLCALL SDL_SIMDAlloc(const size_t len);
-
-/**
- * Reallocate memory obtained from SDL_SIMDAlloc
- *
- * It is not valid to use this function on a pointer from anything but
- * SDL_SIMDAlloc(). It can't be used on pointers from malloc, realloc,
- * SDL_malloc, memalign, new[], etc.
- *
- * \param mem The pointer obtained from SDL_SIMDAlloc. This function also
- *            accepts NULL, at which point this function is the same as
- *            calling SDL_SIMDAlloc with a NULL pointer.
- * \param len The length, in bytes, of the block to allocated. The actual
- *            allocated block might be larger due to padding, etc. Passing 0
- *            will return a non-NULL pointer, assuming the system isn't out of
- *            memory.
- * \returns a pointer to the newly-reallocated block, NULL if out of memory.
- *
- * \since This function is available since SDL 2.0.14.
- *
- * \sa SDL_SIMDGetAlignment
- * \sa SDL_SIMDAlloc
- * \sa SDL_SIMDFree
- */
-extern DECLSPEC void * SDLCALL SDL_SIMDRealloc(void *mem, const size_t len);
-
-/**
- * Deallocate memory obtained from SDL_SIMDAlloc
- *
- * It is not valid to use this function on a pointer from anything but
- * SDL_SIMDAlloc() or SDL_SIMDRealloc(). It can't be used on pointers from
- * malloc, realloc, SDL_malloc, memalign, new[], etc.
- *
- * However, SDL_SIMDFree(NULL) is a legal no-op.
- *
- * The memory pointed to by `ptr` is no longer valid for access upon return,
- * and may be returned to the system or reused by a future allocation. The
- * pointer passed to this function is no longer safe to dereference once this
- * function returns, and should be discarded.
- *
- * \param ptr The pointer, returned from SDL_SIMDAlloc or SDL_SIMDRealloc, to
- *            deallocate. NULL is a legal no-op.
- *
- * \since This function is available since SDL 2.0.10.
- *
- * \sa SDL_SIMDAlloc
- * \sa SDL_SIMDRealloc
- */
-extern DECLSPEC void SDLCALL SDL_SIMDFree(void *ptr);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_cpuinfo_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */

thirdparty/include/android/SDL2/SDL_endian.h

@@ -1,396 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- * # CategoryEndian
- *
- * Functions for reading and writing endian-specific values
- */
-
-#ifndef SDL_endian_h_
-#define SDL_endian_h_
-
-#include "SDL_stdinc.h"
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1400)
-/* As of Clang 11, '_m_prefetchw' is conflicting with the winnt.h's version,
-   so we define the needed '_m_prefetch' here as a pseudo-header, until the issue is fixed. */
-#if defined(__clang__) &&  !_SDL_HAS_BUILTIN(_m_prefetch)
-#ifndef __PRFCHWINTRIN_H
-#define __PRFCHWINTRIN_H
-static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_m_prefetch(void *__P)
-{
-  __builtin_prefetch(__P, 0, 3 /* _MM_HINT_T0 */);
-}
-#endif /* __PRFCHWINTRIN_H */
-#endif /* __clang__ */
-
-#include <intrin.h>
-#endif
-
-/**
- *  \name The two types of endianness
- */
-/* @{ */
-#define SDL_LIL_ENDIAN  1234
-#define SDL_BIG_ENDIAN  4321
-/* @} */
-
-#ifndef SDL_BYTEORDER           /* Not defined in SDL_config.h? */
-#ifdef __linux__
-#include <endian.h>
-#define SDL_BYTEORDER  __BYTE_ORDER
-#elif defined(__sun) && defined(__SVR4)  /* Solaris */
-#include <sys/byteorder.h>
-#if defined(_LITTLE_ENDIAN)
-#define SDL_BYTEORDER   SDL_LIL_ENDIAN
-#elif defined(_BIG_ENDIAN)
-#define SDL_BYTEORDER   SDL_BIG_ENDIAN
-#else
-#error Unsupported endianness
-#endif
-#elif defined(__OpenBSD__) || defined(__DragonFly__)
-#include <endian.h>
-#define SDL_BYTEORDER  BYTE_ORDER
-#elif defined(__FreeBSD__) || defined(__NetBSD__)
-#include <sys/endian.h>
-#define SDL_BYTEORDER  BYTE_ORDER
-/* predefs from newer gcc and clang versions: */
-#elif defined(__ORDER_LITTLE_ENDIAN__) && defined(__ORDER_BIG_ENDIAN__) && defined(__BYTE_ORDER__)
-#if (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
-#define SDL_BYTEORDER   SDL_LIL_ENDIAN
-#elif (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
-#define SDL_BYTEORDER   SDL_BIG_ENDIAN
-#else
-#error Unsupported endianness
-#endif /**/
-#else
-#if defined(__hppa__) || \
-    defined(__m68k__) || defined(mc68000) || defined(_M_M68K) || \
-    (defined(__MIPS__) && defined(__MIPSEB__)) || \
-    defined(__ppc__) || defined(__POWERPC__) || defined(__powerpc__) || defined(__PPC__) || \
-    defined(__sparc__) || defined(__sparc)
-#define SDL_BYTEORDER   SDL_BIG_ENDIAN
-#else
-#define SDL_BYTEORDER   SDL_LIL_ENDIAN
-#endif
-#endif /* __linux__ */
-#endif /* !SDL_BYTEORDER */
-
-#ifndef SDL_FLOATWORDORDER           /* Not defined in SDL_config.h? */
-/* predefs from newer gcc versions: */
-#if defined(__ORDER_LITTLE_ENDIAN__) && defined(__ORDER_BIG_ENDIAN__) && defined(__FLOAT_WORD_ORDER__)
-#if (__FLOAT_WORD_ORDER__ == __ORDER_LITTLE_ENDIAN__)
-#define SDL_FLOATWORDORDER   SDL_LIL_ENDIAN
-#elif (__FLOAT_WORD_ORDER__ == __ORDER_BIG_ENDIAN__)
-#define SDL_FLOATWORDORDER   SDL_BIG_ENDIAN
-#else
-#error Unsupported endianness
-#endif /**/
-#elif defined(__MAVERICK__)
-/* For Maverick, float words are always little-endian. */
-#define SDL_FLOATWORDORDER   SDL_LIL_ENDIAN
-#elif (defined(__arm__) || defined(__thumb__)) && !defined(__VFP_FP__) && !defined(__ARM_EABI__)
-/* For FPA, float words are always big-endian. */
-#define SDL_FLOATWORDORDER   SDL_BIG_ENDIAN
-#else
-/* By default, assume that floats words follow the memory system mode. */
-#define SDL_FLOATWORDORDER   SDL_BYTEORDER
-#endif /* __FLOAT_WORD_ORDER__ */
-#endif /* !SDL_FLOATWORDORDER */
-
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- *  \file SDL_endian.h
- */
-
-/* various modern compilers may have builtin swap */
-#if defined(__GNUC__) || defined(__clang__)
-#   define HAS_BUILTIN_BSWAP16 (_SDL_HAS_BUILTIN(__builtin_bswap16)) || \
-        (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8))
-#   define HAS_BUILTIN_BSWAP32 (_SDL_HAS_BUILTIN(__builtin_bswap32)) || \
-        (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
-#   define HAS_BUILTIN_BSWAP64 (_SDL_HAS_BUILTIN(__builtin_bswap64)) || \
-        (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
-
-    /* this one is broken */
-#   define HAS_BROKEN_BSWAP (__GNUC__ == 2 && __GNUC_MINOR__ <= 95)
-#else
-#   define HAS_BUILTIN_BSWAP16 0
-#   define HAS_BUILTIN_BSWAP32 0
-#   define HAS_BUILTIN_BSWAP64 0
-#   define HAS_BROKEN_BSWAP 0
-#endif
-
-#if HAS_BUILTIN_BSWAP16
-#define SDL_Swap16(x) __builtin_bswap16(x)
-#elif (defined(_MSC_VER) && (_MSC_VER >= 1400)) && !defined(__ICL)
-#pragma intrinsic(_byteswap_ushort)
-#define SDL_Swap16(x) _byteswap_ushort(x)
-#elif defined(__i386__) && !HAS_BROKEN_BSWAP
-SDL_FORCE_INLINE Uint16
-SDL_Swap16(Uint16 x)
-{
-  __asm__("xchgb %b0,%h0": "=q"(x):"0"(x));
-    return x;
-}
-#elif defined(__x86_64__)
-SDL_FORCE_INLINE Uint16
-SDL_Swap16(Uint16 x)
-{
-  __asm__("xchgb %b0,%h0": "=Q"(x):"0"(x));
-    return x;
-}
-#elif (defined(__powerpc__) || defined(__ppc__))
-SDL_FORCE_INLINE Uint16
-SDL_Swap16(Uint16 x)
-{
-    int result;
-
-  __asm__("rlwimi %0,%2,8,16,23": "=&r"(result):"0"(x >> 8), "r"(x));
-    return (Uint16)result;
-}
-#elif (defined(__m68k__) && !defined(__mcoldfire__))
-SDL_FORCE_INLINE Uint16
-SDL_Swap16(Uint16 x)
-{
-  __asm__("rorw #8,%0": "=d"(x): "0"(x):"cc");
-    return x;
-}
-#elif defined(__WATCOMC__) && defined(__386__)
-extern __inline Uint16 SDL_Swap16(Uint16);
-#pragma aux SDL_Swap16 = \
-  "xchg al, ah" \
-  parm   [ax]   \
-  modify [ax];
-#else
-
-/**
- * Use this function to swap the byte order of a 16-bit value.
- *
- * \param x the value to be swapped.
- * \returns the swapped value.
- *
- * \sa SDL_SwapBE16
- * \sa SDL_SwapLE16
- */
-SDL_FORCE_INLINE Uint16
-SDL_Swap16(Uint16 x)
-{
-    return SDL_static_cast(Uint16, ((x << 8) | (x >> 8)));
-}
-#endif
-
-#if HAS_BUILTIN_BSWAP32
-#define SDL_Swap32(x) __builtin_bswap32(x)
-#elif (defined(_MSC_VER) && (_MSC_VER >= 1400)) && !defined(__ICL)
-#pragma intrinsic(_byteswap_ulong)
-#define SDL_Swap32(x) _byteswap_ulong(x)
-#elif defined(__i386__) && !HAS_BROKEN_BSWAP
-SDL_FORCE_INLINE Uint32
-SDL_Swap32(Uint32 x)
-{
-  __asm__("bswap %0": "=r"(x):"0"(x));
-    return x;
-}
-#elif defined(__x86_64__)
-SDL_FORCE_INLINE Uint32
-SDL_Swap32(Uint32 x)
-{
-  __asm__("bswapl %0": "=r"(x):"0"(x));
-    return x;
-}
-#elif (defined(__powerpc__) || defined(__ppc__))
-SDL_FORCE_INLINE Uint32
-SDL_Swap32(Uint32 x)
-{
-    Uint32 result;
-
-  __asm__("rlwimi %0,%2,24,16,23": "=&r"(result): "0" (x>>24),  "r"(x));
-  __asm__("rlwimi %0,%2,8,8,15"  : "=&r"(result): "0" (result), "r"(x));
-  __asm__("rlwimi %0,%2,24,0,7"  : "=&r"(result): "0" (result), "r"(x));
-    return result;
-}
-#elif (defined(__m68k__) && !defined(__mcoldfire__))
-SDL_FORCE_INLINE Uint32
-SDL_Swap32(Uint32 x)
-{
-  __asm__("rorw #8,%0\n\tswap %0\n\trorw #8,%0": "=d"(x): "0"(x):"cc");
-    return x;
-}
-#elif defined(__WATCOMC__) && defined(__386__)
-extern __inline Uint32 SDL_Swap32(Uint32);
-#pragma aux SDL_Swap32 = \
-  "bswap eax"  \
-  parm   [eax] \
-  modify [eax];
-#else
-
-/**
- * Use this function to swap the byte order of a 32-bit value.
- *
- * \param x the value to be swapped.
- * \returns the swapped value.
- *
- * \sa SDL_SwapBE32
- * \sa SDL_SwapLE32
- */
-SDL_FORCE_INLINE Uint32
-SDL_Swap32(Uint32 x)
-{
-    return SDL_static_cast(Uint32, ((x << 24) | ((x << 8) & 0x00FF0000) |
-                                    ((x >> 8) & 0x0000FF00) | (x >> 24)));
-}
-#endif
-
-#if HAS_BUILTIN_BSWAP64
-#define SDL_Swap64(x) __builtin_bswap64(x)
-#elif (defined(_MSC_VER) && (_MSC_VER >= 1400)) && !defined(__ICL)
-#pragma intrinsic(_byteswap_uint64)
-#define SDL_Swap64(x) _byteswap_uint64(x)
-#elif defined(__i386__) && !HAS_BROKEN_BSWAP
-SDL_FORCE_INLINE Uint64
-SDL_Swap64(Uint64 x)
-{
-    union {
-        struct {
-            Uint32 a, b;
-        } s;
-        Uint64 u;
-    } v;
-    v.u = x;
-  __asm__("bswapl %0 ; bswapl %1 ; xchgl %0,%1"
-          : "=r"(v.s.a), "=r"(v.s.b)
-          : "0" (v.s.a),  "1"(v.s.b));
-    return v.u;
-}
-#elif defined(__x86_64__)
-SDL_FORCE_INLINE Uint64
-SDL_Swap64(Uint64 x)
-{
-  __asm__("bswapq %0": "=r"(x):"0"(x));
-    return x;
-}
-#elif defined(__WATCOMC__) && defined(__386__)
-extern __inline Uint64 SDL_Swap64(Uint64);
-#pragma aux SDL_Swap64 = \
-  "bswap eax"     \
-  "bswap edx"     \
-  "xchg eax,edx"  \
-  parm [eax edx]  \
-  modify [eax edx];
-#else
-
-/**
- * Use this function to swap the byte order of a 64-bit value.
- *
- * \param x the value to be swapped.
- * \returns the swapped value.
- *
- * \sa SDL_SwapBE64
- * \sa SDL_SwapLE64
- */
-SDL_FORCE_INLINE Uint64
-SDL_Swap64(Uint64 x)
-{
-    Uint32 hi, lo;
-
-    /* Separate into high and low 32-bit values and swap them */
-    lo = SDL_static_cast(Uint32, x & 0xFFFFFFFF);
-    x >>= 32;
-    hi = SDL_static_cast(Uint32, x & 0xFFFFFFFF);
-    x = SDL_Swap32(lo);
-    x <<= 32;
-    x |= SDL_Swap32(hi);
-    return (x);
-}
-#endif
-
-
-/**
- * Use this function to swap the byte order of a floating point value.
- *
- * \param x the value to be swapped.
- * \returns the swapped value.
- *
- * \sa SDL_SwapFloatBE
- * \sa SDL_SwapFloatLE
- */
-SDL_FORCE_INLINE float
-SDL_SwapFloat(float x)
-{
-    union {
-        float f;
-        Uint32 ui32;
-    } swapper;
-    swapper.f = x;
-    swapper.ui32 = SDL_Swap32(swapper.ui32);
-    return swapper.f;
-}
-
-/* remove extra macros */
-#undef HAS_BROKEN_BSWAP
-#undef HAS_BUILTIN_BSWAP16
-#undef HAS_BUILTIN_BSWAP32
-#undef HAS_BUILTIN_BSWAP64
-
-/**
- *  \name Swap to native
- *  Byteswap item from the specified endianness to the native endianness.
- */
-/* @{ */
-#if SDL_BYTEORDER == SDL_LIL_ENDIAN
-#define SDL_SwapLE16(X)     (X)
-#define SDL_SwapLE32(X)     (X)
-#define SDL_SwapLE64(X)     (X)
-#define SDL_SwapFloatLE(X)  (X)
-#define SDL_SwapBE16(X)     SDL_Swap16(X)
-#define SDL_SwapBE32(X)     SDL_Swap32(X)
-#define SDL_SwapBE64(X)     SDL_Swap64(X)
-#define SDL_SwapFloatBE(X)  SDL_SwapFloat(X)
-#else
-#define SDL_SwapLE16(X)     SDL_Swap16(X)
-#define SDL_SwapLE32(X)     SDL_Swap32(X)
-#define SDL_SwapLE64(X)     SDL_Swap64(X)
-#define SDL_SwapFloatLE(X)  SDL_SwapFloat(X)
-#define SDL_SwapBE16(X)     (X)
-#define SDL_SwapBE32(X)     (X)
-#define SDL_SwapBE64(X)     (X)
-#define SDL_SwapFloatBE(X)  (X)
-#endif
-/* @} *//* Swap to native */
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_endian_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */

thirdparty/include/android/SDL2/SDL_error.h

@@ -1,163 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- * # CategoryError
- *
- * Simple error message routines for SDL.
- */
-
-#ifndef SDL_error_h_
-#define SDL_error_h_
-
-#include "SDL_stdinc.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Public functions */
-
-
-/**
- * Set the SDL error message for the current thread.
- *
- * Calling this function will replace any previous error message that was set.
- *
- * This function always returns -1, since SDL frequently uses -1 to signify an
- * failing result, leading to this idiom:
- *
- * ```c
- * if (error_code) {
- *     return SDL_SetError("This operation has failed: %d", error_code);
- * }
- * ```
- *
- * \param fmt a printf()-style message format string.
- * \param ... additional parameters matching % tokens in the `fmt` string, if
- *            any.
- * \returns always -1.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_ClearError
- * \sa SDL_GetError
- */
-extern DECLSPEC int SDLCALL SDL_SetError(SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(1);
-
-/**
- * Retrieve a message about the last error that occurred on the current
- * thread.
- *
- * It is possible for multiple errors to occur before calling SDL_GetError().
- * Only the last error is returned.
- *
- * The message is only applicable when an SDL function has signaled an error.
- * You must check the return values of SDL function calls to determine when to
- * appropriately call SDL_GetError(). You should *not* use the results of
- * SDL_GetError() to decide if an error has occurred! Sometimes SDL will set
- * an error string even when reporting success.
- *
- * SDL will *not* clear the error string for successful API calls. You *must*
- * check return values for failure cases before you can assume the error
- * string applies.
- *
- * Error strings are set per-thread, so an error set in a different thread
- * will not interfere with the current thread's operation.
- *
- * The returned string is internally allocated and must not be freed by the
- * application.
- *
- * \returns a message with information about the specific error that occurred,
- *          or an empty string if there hasn't been an error message set since
- *          the last call to SDL_ClearError(). The message is only applicable
- *          when an SDL function has signaled an error. You must check the
- *          return values of SDL function calls to determine when to
- *          appropriately call SDL_GetError().
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_ClearError
- * \sa SDL_SetError
- */
-extern DECLSPEC const char *SDLCALL SDL_GetError(void);
-
-/**
- * Get the last error message that was set for the current thread.
- *
- * This allows the caller to copy the error string into a provided buffer, but
- * otherwise operates exactly the same as SDL_GetError().
- *
- * \param errstr A buffer to fill with the last error message that was set for
- *               the current thread.
- * \param maxlen The size of the buffer pointed to by the errstr parameter.
- * \returns the pointer passed in as the `errstr` parameter.
- *
- * \since This function is available since SDL 2.0.14.
- *
- * \sa SDL_GetError
- */
-extern DECLSPEC char * SDLCALL SDL_GetErrorMsg(char *errstr, int maxlen);
-
-/**
- * Clear any previous error message for this thread.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetError
- * \sa SDL_SetError
- */
-extern DECLSPEC void SDLCALL SDL_ClearError(void);
-
-/**
- *  \name Internal error functions
- *
- *  \internal
- *  Private error reporting function - used internally.
- */
-/* @{ */
-#define SDL_OutOfMemory()   SDL_Error(SDL_ENOMEM)
-#define SDL_Unsupported()   SDL_Error(SDL_UNSUPPORTED)
-#define SDL_InvalidParamError(param)    SDL_SetError("Parameter '%s' is invalid", (param))
-typedef enum
-{
-    SDL_ENOMEM,
-    SDL_EFREAD,
-    SDL_EFWRITE,
-    SDL_EFSEEK,
-    SDL_UNSUPPORTED,
-    SDL_LASTERROR
-} SDL_errorcode;
-/* SDL_Error() unconditionally returns -1. */
-extern DECLSPEC int SDLCALL SDL_Error(SDL_errorcode code);
-/* @} *//* Internal error functions */
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_error_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */

thirdparty/include/android/SDL2/SDL_filesystem.h

@@ -1,149 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- * # CategoryFilesystem
- *
- * Include file for filesystem SDL API functions
- */
-
-#ifndef SDL_filesystem_h_
-#define SDL_filesystem_h_
-
-#include "SDL_stdinc.h"
-
-#include "begin_code.h"
-
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * Get the directory where the application was run from.
- *
- * This is not necessarily a fast call, so you should call this once near
- * startup and save the string if you need it.
- *
- * **Mac OS X and iOS Specific Functionality**: If the application is in a
- * ".app" bundle, this function returns the Resource directory (e.g.
- * MyApp.app/Contents/Resources/). This behaviour can be overridden by adding
- * a property to the Info.plist file. Adding a string key with the name
- * SDL_FILESYSTEM_BASE_DIR_TYPE with a supported value will change the
- * behaviour.
- *
- * Supported values for the SDL_FILESYSTEM_BASE_DIR_TYPE property (Given an
- * application in /Applications/SDLApp/MyApp.app):
- *
- * - `resource`: bundle resource directory (the default). For example:
- *   `/Applications/SDLApp/MyApp.app/Contents/Resources`
- * - `bundle`: the Bundle directory. For example:
- *   `/Applications/SDLApp/MyApp.app/`
- * - `parent`: the containing directory of the bundle. For example:
- *   `/Applications/SDLApp/`
- *
- * **Nintendo 3DS Specific Functionality**: This function returns "romfs"
- * directory of the application as it is uncommon to store resources outside
- * the executable. As such it is not a writable directory.
- *
- * The returned path is guaranteed to end with a path separator ('\\' on
- * Windows, '/' on most other platforms).
- *
- * The pointer returned is owned by the caller. Please call SDL_free() on the
- * pointer when done with it.
- *
- * \returns an absolute path in UTF-8 encoding to the application data
- *          directory. NULL will be returned on error or when the platform
- *          doesn't implement this functionality, call SDL_GetError() for more
- *          information.
- *
- * \since This function is available since SDL 2.0.1.
- *
- * \sa SDL_GetPrefPath
- */
-extern DECLSPEC char *SDLCALL SDL_GetBasePath(void);
-
-/**
- * Get the user-and-app-specific path where files can be written.
- *
- * Get the "pref dir". This is meant to be where users can write personal
- * files (preferences and save games, etc) that are specific to your
- * application. This directory is unique per user, per application.
- *
- * This function will decide the appropriate location in the native
- * filesystem, create the directory if necessary, and return a string of the
- * absolute path to the directory in UTF-8 encoding.
- *
- * On Windows, the string might look like:
- *
- * `C:\\Users\\bob\\AppData\\Roaming\\My Company\\My Program Name\\`
- *
- * On Linux, the string might look like:
- *
- * `/home/bob/.local/share/My Program Name/`
- *
- * On Mac OS X, the string might look like:
- *
- * `/Users/bob/Library/Application Support/My Program Name/`
- *
- * You should assume the path returned by this function is the only safe place
- * to write files (and that SDL_GetBasePath(), while it might be writable, or
- * even the parent of the returned path, isn't where you should be writing
- * things).
- *
- * Both the org and app strings may become part of a directory name, so please
- * follow these rules:
- *
- * - Try to use the same org string (_including case-sensitivity_) for all
- *   your applications that use this function.
- * - Always use a unique app string for each one, and make sure it never
- *   changes for an app once you've decided on it.
- * - Unicode characters are legal, as long as it's UTF-8 encoded, but...
- * - ...only use letters, numbers, and spaces. Avoid punctuation like "Game
- *   Name 2: Bad Guy's Revenge!" ... "Game Name 2" is sufficient.
- *
- * The returned path is guaranteed to end with a path separator ('\\' on
- * Windows, '/' on most other platforms).
- *
- * The pointer returned is owned by the caller. Please call SDL_free() on the
- * pointer when done with it.
- *
- * \param org the name of your organization.
- * \param app the name of your application.
- * \returns a UTF-8 string of the user directory in platform-dependent
- *          notation. NULL if there's a problem (creating directory failed,
- *          etc.).
- *
- * \since This function is available since SDL 2.0.1.
- *
- * \sa SDL_GetBasePath
- */
-extern DECLSPEC char *SDLCALL SDL_GetPrefPath(const char *org, const char *app);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_filesystem_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */

thirdparty/include/android/SDL2/SDL_gesture.h

@@ -1,117 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- * # CategoryGesture
- *
- * Include file for SDL gesture event handling.
- */
-
-#ifndef SDL_gesture_h_
-#define SDL_gesture_h_
-
-#include "SDL_stdinc.h"
-#include "SDL_error.h"
-#include "SDL_video.h"
-
-#include "SDL_touch.h"
-
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef Sint64 SDL_GestureID;
-
-/* Function prototypes */
-
-/**
- * Begin recording a gesture on a specified touch device or all touch devices.
- *
- * If the parameter `touchId` is -1 (i.e., all devices), this function will
- * always return 1, regardless of whether there actually are any devices.
- *
- * \param touchId the touch device id, or -1 for all touch devices.
- * \returns 1 on success or 0 if the specified device could not be found.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetTouchDevice
- */
-extern DECLSPEC int SDLCALL SDL_RecordGesture(SDL_TouchID touchId);
-
-
-/**
- * Save all currently loaded Dollar Gesture templates.
- *
- * \param dst a SDL_RWops to save to.
- * \returns the number of saved templates on success or 0 on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_LoadDollarTemplates
- * \sa SDL_SaveDollarTemplate
- */
-extern DECLSPEC int SDLCALL SDL_SaveAllDollarTemplates(SDL_RWops *dst);
-
-/**
- * Save a currently loaded Dollar Gesture template.
- *
- * \param gestureId a gesture id.
- * \param dst a SDL_RWops to save to.
- * \returns 1 on success or 0 on failure; call SDL_GetError() for more
- *          information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_LoadDollarTemplates
- * \sa SDL_SaveAllDollarTemplates
- */
-extern DECLSPEC int SDLCALL SDL_SaveDollarTemplate(SDL_GestureID gestureId,SDL_RWops *dst);
-
-
-/**
- * Load Dollar Gesture templates from a file.
- *
- * \param touchId a touch id.
- * \param src a SDL_RWops to load from.
- * \returns the number of loaded templates on success or a negative error code
- *          (or 0) on failure; call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_SaveAllDollarTemplates
- * \sa SDL_SaveDollarTemplate
- */
-extern DECLSPEC int SDLCALL SDL_LoadDollarTemplates(SDL_TouchID touchId, SDL_RWops *src);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_gesture_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */

thirdparty/include/android/SDL2/SDL_guid.h

@@ -1,107 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/* WIKI CATEGORY: GUID */
-
-/**
- * # CategoryGUID
- *
- * A GUID is a 128-bit value that represents something that is uniquely
- * identifiable by this value: "globally unique."
- */
-
-#ifndef SDL_guid_h_
-#define SDL_guid_h_
-
-#include "SDL_stdinc.h"
-#include "SDL_error.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * An SDL_GUID is a 128-bit identifier.
- *
- * This is an acronym for "Globally Unique ID."
- *
- * While a GUID can be used to assign a unique value to almost anything, in
- * SDL these are largely used to identify input devices across runs of SDL
- * programs on the same platform.If the device is detached and then
- * re-attached to a different port, or if the base system is rebooted, the
- * device should still report the same GUID.
- *
- * GUIDs are as precise as possible but are not guaranteed to distinguish
- * physically distinct but equivalent devices. For example, two game
- * controllers from the same vendor with the same product ID and revision may
- * have the same GUID.
- *
- * GUIDs may be platform-dependent (i.e., the same device may report different
- * GUIDs on different operating systems).
- */
-typedef struct SDL_GUID {
-    Uint8 data[16];
-} SDL_GUID;
-
-/* Function prototypes */
-
-/**
- * Get an ASCII string representation for a given SDL_GUID.
- *
- * You should supply at least 33 bytes for pszGUID.
- *
- * \param guid the SDL_GUID you wish to convert to string.
- * \param pszGUID buffer in which to write the ASCII string.
- * \param cbGUID the size of pszGUID.
- *
- * \since This function is available since SDL 2.24.0.
- *
- * \sa SDL_GUIDFromString
- */
-extern DECLSPEC void SDLCALL SDL_GUIDToString(SDL_GUID guid, char *pszGUID, int cbGUID);
-
-/**
- * Convert a GUID string into a SDL_GUID structure.
- *
- * Performs no error checking. If this function is given a string containing
- * an invalid GUID, the function will silently succeed, but the GUID generated
- * will not be useful.
- *
- * \param pchGUID string containing an ASCII representation of a GUID.
- * \returns a SDL_GUID structure.
- *
- * \since This function is available since SDL 2.24.0.
- *
- * \sa SDL_GUIDToString
- */
-extern DECLSPEC SDL_GUID SDLCALL SDL_GUIDFromString(const char *pchGUID);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_guid_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */

thirdparty/include/android/SDL2/SDL_hidapi.h

@@ -1,444 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/* WIKI CATEGORY: HIDAPI */
-
-/**
- * # CategoryHIDAPI
- *
- * Header file for SDL HIDAPI functions.
- *
- * This is an adaptation of the original HIDAPI interface by Alan Ott, and
- * includes source code licensed under the following license:
- *
- * ```
- * HIDAPI - Multi-Platform library for
- * communication with HID devices.
- *
- * Copyright 2009, Alan Ott, Signal 11 Software.
- * All Rights Reserved.
- *
- * This software may be used by anyone for any reason so
- * long as the copyright notice in the source files
- * remains intact.
- * ```
- *
- * (Note that this license is the same as item three of SDL's zlib license, so
- * it adds no new requirements on the user.)
- *
- * If you would like a version of SDL without this code, you can build SDL
- * with SDL_HIDAPI_DISABLED defined to 1. You might want to do this for
- * example on iOS or tvOS to avoid a dependency on the CoreBluetooth
- * framework.
- */
-
-#ifndef SDL_hidapi_h_
-#define SDL_hidapi_h_
-
-#include "SDL_stdinc.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * A handle representing an open HID device
- */
-struct SDL_hid_device_;
-typedef struct SDL_hid_device_ SDL_hid_device; /**< opaque hidapi structure */
-
-/** hidapi info structure */
-
-/**
- * Information about a connected HID device
- */
-typedef struct SDL_hid_device_info
-{
-    /** Platform-specific device path */
-    char *path;
-    /** Device Vendor ID */
-    unsigned short vendor_id;
-    /** Device Product ID */
-    unsigned short product_id;
-    /** Serial Number */
-    wchar_t *serial_number;
-    /** Device Release Number in binary-coded decimal,
-        also known as Device Version Number */
-    unsigned short release_number;
-    /** Manufacturer String */
-    wchar_t *manufacturer_string;
-    /** Product string */
-    wchar_t *product_string;
-    /** Usage Page for this Device/Interface
-        (Windows/Mac only). */
-    unsigned short usage_page;
-    /** Usage for this Device/Interface
-        (Windows/Mac only).*/
-    unsigned short usage;
-    /** The USB interface which this logical device
-        represents.
-
-        * Valid on both Linux implementations in all cases.
-        * Valid on the Windows implementation only if the device
-          contains more than one interface. */
-    int interface_number;
-
-    /** Additional information about the USB interface.
-        Valid on libusb and Android implementations. */
-    int interface_class;
-    int interface_subclass;
-    int interface_protocol;
-
-    /** Pointer to the next device */
-    struct SDL_hid_device_info *next;
-} SDL_hid_device_info;
-
-
-/**
- * Initialize the HIDAPI library.
- *
- * This function initializes the HIDAPI library. Calling it is not strictly
- * necessary, as it will be called automatically by SDL_hid_enumerate() and
- * any of the SDL_hid_open_*() functions if it is needed. This function should
- * be called at the beginning of execution however, if there is a chance of
- * HIDAPI handles being opened by different threads simultaneously.
- *
- * Each call to this function should have a matching call to SDL_hid_exit()
- *
- * \returns 0 on success and -1 on error.
- *
- * \since This function is available since SDL 2.0.18.
- *
- * \sa SDL_hid_exit
- */
-extern DECLSPEC int SDLCALL SDL_hid_init(void);
-
-/**
- * Finalize the HIDAPI library.
- *
- * This function frees all of the static data associated with HIDAPI. It
- * should be called at the end of execution to avoid memory leaks.
- *
- * \returns 0 on success and -1 on error.
- *
- * \since This function is available since SDL 2.0.18.
- *
- * \sa SDL_hid_init
- */
-extern DECLSPEC int SDLCALL SDL_hid_exit(void);
-
-/**
- * Check to see if devices may have been added or removed.
- *
- * Enumerating the HID devices is an expensive operation, so you can call this
- * to see if there have been any system device changes since the last call to
- * this function. A change in the counter returned doesn't necessarily mean
- * that anything has changed, but you can call SDL_hid_enumerate() to get an
- * updated device list.
- *
- * Calling this function for the first time may cause a thread or other system
- * resource to be allocated to track device change notifications.
- *
- * \returns a change counter that is incremented with each potential device
- *          change, or 0 if device change detection isn't available.
- *
- * \since This function is available since SDL 2.0.18.
- *
- * \sa SDL_hid_enumerate
- */
-extern DECLSPEC Uint32 SDLCALL SDL_hid_device_change_count(void);
-
-/**
- * Enumerate the HID Devices.
- *
- * This function returns a linked list of all the HID devices attached to the
- * system which match vendor_id and product_id. If `vendor_id` is set to 0
- * then any vendor matches. If `product_id` is set to 0 then any product
- * matches. If `vendor_id` and `product_id` are both set to 0, then all HID
- * devices will be returned.
- *
- * \param vendor_id The Vendor ID (VID) of the types of device to open.
- * \param product_id The Product ID (PID) of the types of device to open.
- * \returns a pointer to a linked list of type SDL_hid_device_info, containing
- *          information about the HID devices attached to the system, or NULL
- *          in the case of failure. Free this linked list by calling
- *          SDL_hid_free_enumeration().
- *
- * \since This function is available since SDL 2.0.18.
- *
- * \sa SDL_hid_device_change_count
- */
-extern DECLSPEC SDL_hid_device_info * SDLCALL SDL_hid_enumerate(unsigned short vendor_id, unsigned short product_id);
-
-/**
- * Free an enumeration Linked List
- *
- * This function frees a linked list created by SDL_hid_enumerate().
- *
- * \param devs Pointer to a list of struct_device returned from
- *             SDL_hid_enumerate().
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC void SDLCALL SDL_hid_free_enumeration(SDL_hid_device_info *devs);
-
-/**
- * Open a HID device using a Vendor ID (VID), Product ID (PID) and optionally
- * a serial number.
- *
- * If `serial_number` is NULL, the first device with the specified VID and PID
- * is opened.
- *
- * \param vendor_id The Vendor ID (VID) of the device to open.
- * \param product_id The Product ID (PID) of the device to open.
- * \param serial_number The Serial Number of the device to open (Optionally
- *                      NULL).
- * \returns a pointer to a SDL_hid_device object on success or NULL on
- *          failure.
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC SDL_hid_device * SDLCALL SDL_hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number);
-
-/**
- * Open a HID device by its path name.
- *
- * The path name be determined by calling SDL_hid_enumerate(), or a
- * platform-specific path name can be used (eg: /dev/hidraw0 on Linux).
- *
- * \param path The path name of the device to open.
- * \param bExclusive boolean exclusive.
- * \returns a pointer to a SDL_hid_device object on success or NULL on
- *          failure.
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC SDL_hid_device * SDLCALL SDL_hid_open_path(const char *path, int bExclusive);
-
-/**
- * Write an Output report to a HID device.
- *
- * The first byte of `data` must contain the Report ID. For devices which only
- * support a single report, this must be set to 0x0. The remaining bytes
- * contain the report data. Since the Report ID is mandatory, calls to
- * SDL_hid_write() will always contain one more byte than the report contains.
- * For example, if a hid report is 16 bytes long, 17 bytes must be passed to
- * SDL_hid_write(), the Report ID (or 0x0, for devices with a single report),
- * followed by the report data (16 bytes). In this example, the length passed
- * in would be 17.
- *
- * SDL_hid_write() will send the data on the first OUT endpoint, if one
- * exists. If it does not, it will send the data through the Control Endpoint
- * (Endpoint 0).
- *
- * \param dev A device handle returned from SDL_hid_open().
- * \param data The data to send, including the report number as the first
- *             byte.
- * \param length The length in bytes of the data to send.
- * \returns the actual number of bytes written and -1 on error.
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC int SDLCALL SDL_hid_write(SDL_hid_device *dev, const unsigned char *data, size_t length);
-
-/**
- * Read an Input report from a HID device with timeout.
- *
- * Input reports are returned to the host through the INTERRUPT IN endpoint.
- * The first byte will contain the Report number if the device uses numbered
- * reports.
- *
- * \param dev A device handle returned from SDL_hid_open().
- * \param data A buffer to put the read data into.
- * \param length The number of bytes to read. For devices with multiple
- *               reports, make sure to read an extra byte for the report
- *               number.
- * \param milliseconds timeout in milliseconds or -1 for blocking wait.
- * \returns the actual number of bytes read and -1 on error. If no packet was
- *          available to be read within the timeout period, this function
- *          returns 0.
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC int SDLCALL SDL_hid_read_timeout(SDL_hid_device *dev, unsigned char *data, size_t length, int milliseconds);
-
-/**
- * Read an Input report from a HID device.
- *
- * Input reports are returned to the host through the INTERRUPT IN endpoint.
- * The first byte will contain the Report number if the device uses numbered
- * reports.
- *
- * \param dev A device handle returned from SDL_hid_open().
- * \param data A buffer to put the read data into.
- * \param length The number of bytes to read. For devices with multiple
- *               reports, make sure to read an extra byte for the report
- *               number.
- * \returns the actual number of bytes read and -1 on error. If no packet was
- *          available to be read and the handle is in non-blocking mode, this
- *          function returns 0.
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC int SDLCALL SDL_hid_read(SDL_hid_device *dev, unsigned char *data, size_t length);
-
-/**
- * Set the device handle to be non-blocking.
- *
- * In non-blocking mode calls to SDL_hid_read() will return immediately with a
- * value of 0 if there is no data to be read. In blocking mode, SDL_hid_read()
- * will wait (block) until there is data to read before returning.
- *
- * Nonblocking can be turned on and off at any time.
- *
- * \param dev A device handle returned from SDL_hid_open().
- * \param nonblock enable or not the nonblocking reads - 1 to enable
- *                 nonblocking - 0 to disable nonblocking.
- * \returns 0 on success and -1 on error.
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC int SDLCALL SDL_hid_set_nonblocking(SDL_hid_device *dev, int nonblock);
-
-/**
- * Send a Feature report to the device.
- *
- * Feature reports are sent over the Control endpoint as a Set_Report
- * transfer. The first byte of `data` must contain the Report ID. For devices
- * which only support a single report, this must be set to 0x0. The remaining
- * bytes contain the report data. Since the Report ID is mandatory, calls to
- * SDL_hid_send_feature_report() will always contain one more byte than the
- * report contains. For example, if a hid report is 16 bytes long, 17 bytes
- * must be passed to SDL_hid_send_feature_report(): the Report ID (or 0x0, for
- * devices which do not use numbered reports), followed by the report data (16
- * bytes). In this example, the length passed in would be 17.
- *
- * \param dev A device handle returned from SDL_hid_open().
- * \param data The data to send, including the report number as the first
- *             byte.
- * \param length The length in bytes of the data to send, including the report
- *               number.
- * \returns the actual number of bytes written and -1 on error.
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC int SDLCALL SDL_hid_send_feature_report(SDL_hid_device *dev, const unsigned char *data, size_t length);
-
-/**
- * Get a feature report from a HID device.
- *
- * Set the first byte of `data` to the Report ID of the report to be read.
- * Make sure to allow space for this extra byte in `data`. Upon return, the
- * first byte will still contain the Report ID, and the report data will start
- * in data[1].
- *
- * \param dev A device handle returned from SDL_hid_open().
- * \param data A buffer to put the read data into, including the Report ID.
- *             Set the first byte of `data` to the Report ID of the report to
- *             be read, or set it to zero if your device does not use numbered
- *             reports.
- * \param length The number of bytes to read, including an extra byte for the
- *               report ID. The buffer can be longer than the actual report.
- * \returns the number of bytes read plus one for the report ID (which is
- *          still in the first byte), or -1 on error.
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC int SDLCALL SDL_hid_get_feature_report(SDL_hid_device *dev, unsigned char *data, size_t length);
-
-/**
- * Close a HID device.
- *
- * \param dev A device handle returned from SDL_hid_open().
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC void SDLCALL SDL_hid_close(SDL_hid_device *dev);
-
-/**
- * Get The Manufacturer String from a HID device.
- *
- * \param dev A device handle returned from SDL_hid_open().
- * \param string A wide string buffer to put the data into.
- * \param maxlen The length of the buffer in multiples of wchar_t.
- * \returns 0 on success and -1 on error.
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC int SDLCALL SDL_hid_get_manufacturer_string(SDL_hid_device *dev, wchar_t *string, size_t maxlen);
-
-/**
- * Get The Product String from a HID device.
- *
- * \param dev A device handle returned from SDL_hid_open().
- * \param string A wide string buffer to put the data into.
- * \param maxlen The length of the buffer in multiples of wchar_t.
- * \returns 0 on success and -1 on error.
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC int SDLCALL SDL_hid_get_product_string(SDL_hid_device *dev, wchar_t *string, size_t maxlen);
-
-/**
- * Get The Serial Number String from a HID device.
- *
- * \param dev A device handle returned from SDL_hid_open().
- * \param string A wide string buffer to put the data into.
- * \param maxlen The length of the buffer in multiples of wchar_t.
- * \returns 0 on success and -1 on error.
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC int SDLCALL SDL_hid_get_serial_number_string(SDL_hid_device *dev, wchar_t *string, size_t maxlen);
-
-/**
- * Get a string from a HID device, based on its string index.
- *
- * \param dev A device handle returned from SDL_hid_open().
- * \param string_index The index of the string to get.
- * \param string A wide string buffer to put the data into.
- * \param maxlen The length of the buffer in multiples of wchar_t.
- * \returns 0 on success and -1 on error.
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC int SDLCALL SDL_hid_get_indexed_string(SDL_hid_device *dev, int string_index, wchar_t *string, size_t maxlen);
-
-/**
- * Start or stop a BLE scan on iOS and tvOS to pair Steam Controllers
- *
- * \param active SDL_TRUE to start the scan, SDL_FALSE to stop the scan.
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC void SDLCALL SDL_hid_ble_scan(SDL_bool active);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_hidapi_h_ */
-
-/* vi: set sts=4 ts=4 sw=4 expandtab: */

thirdparty/include/android/SDL2/SDL_keyboard.h

@@ -1,364 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- * # CategoryKeyboard
- *
- * Include file for SDL keyboard event handling
- */
-
-#ifndef SDL_keyboard_h_
-#define SDL_keyboard_h_
-
-#include "SDL_stdinc.h"
-#include "SDL_error.h"
-#include "SDL_keycode.h"
-#include "SDL_video.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * The SDL keysym structure, used in key events.
- *
- * If you are looking for translated character input, see the SDL_TEXTINPUT
- * event.
- */
-typedef struct SDL_Keysym
-{
-    SDL_Scancode scancode;      /**< SDL physical key code - see SDL_Scancode for details */
-    SDL_Keycode sym;            /**< SDL virtual key code - see SDL_Keycode for details */
-    Uint16 mod;                 /**< current key modifiers - see SDL_Keymod for details */
-    Uint32 unused;
-} SDL_Keysym;
-
-/* Function prototypes */
-
-/**
- * Query the window which currently has keyboard focus.
- *
- * \returns the window with keyboard focus.
- *
- * \since This function is available since SDL 2.0.0.
- */
-extern DECLSPEC SDL_Window * SDLCALL SDL_GetKeyboardFocus(void);
-
-/**
- * Get a snapshot of the current state of the keyboard.
- *
- * The pointer returned is a pointer to an internal SDL array. It will be
- * valid for the whole lifetime of the application and should not be freed by
- * the caller.
- *
- * A array element with a value of 1 means that the key is pressed and a value
- * of 0 means that it is not. Indexes into this array are obtained by using
- * SDL_Scancode values.
- *
- * Use SDL_PumpEvents() to update the state array.
- *
- * This function gives you the current state after all events have been
- * processed, so if a key or button has been pressed and released before you
- * process events, then the pressed state will never show up in the
- * SDL_GetKeyboardState() calls.
- *
- * Note: This function doesn't take into account whether shift has been
- * pressed or not.
- *
- * \param numkeys if non-NULL, receives the length of the returned array.
- * \returns a pointer to an array of key states.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_PumpEvents
- * \sa SDL_ResetKeyboard
- */
-extern DECLSPEC const Uint8 *SDLCALL SDL_GetKeyboardState(int *numkeys);
-
-/**
- * Clear the state of the keyboard
- *
- * This function will generate key up events for all pressed keys.
- *
- * \since This function is available since SDL 2.24.0.
- *
- * \sa SDL_GetKeyboardState
- */
-extern DECLSPEC void SDLCALL SDL_ResetKeyboard(void);
-
-/**
- * Get the current key modifier state for the keyboard.
- *
- * \returns an OR'd combination of the modifier keys for the keyboard. See
- *          SDL_Keymod for details.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetKeyboardState
- * \sa SDL_SetModState
- */
-extern DECLSPEC SDL_Keymod SDLCALL SDL_GetModState(void);
-
-/**
- * Set the current key modifier state for the keyboard.
- *
- * The inverse of SDL_GetModState(), SDL_SetModState() allows you to impose
- * modifier key states on your application. Simply pass your desired modifier
- * states into `modstate`. This value may be a bitwise, OR'd combination of
- * SDL_Keymod values.
- *
- * This does not change the keyboard state, only the key modifier flags that
- * SDL reports.
- *
- * \param modstate the desired SDL_Keymod for the keyboard.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetModState
- */
-extern DECLSPEC void SDLCALL SDL_SetModState(SDL_Keymod modstate);
-
-/**
- * Get the key code corresponding to the given scancode according to the
- * current keyboard layout.
- *
- * See SDL_Keycode for details.
- *
- * \param scancode the desired SDL_Scancode to query.
- * \returns the SDL_Keycode that corresponds to the given SDL_Scancode.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetKeyName
- * \sa SDL_GetScancodeFromKey
- */
-extern DECLSPEC SDL_Keycode SDLCALL SDL_GetKeyFromScancode(SDL_Scancode scancode);
-
-/**
- * Get the scancode corresponding to the given key code according to the
- * current keyboard layout.
- *
- * See SDL_Scancode for details.
- *
- * \param key the desired SDL_Keycode to query.
- * \returns the SDL_Scancode that corresponds to the given SDL_Keycode.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetKeyFromScancode
- * \sa SDL_GetScancodeName
- */
-extern DECLSPEC SDL_Scancode SDLCALL SDL_GetScancodeFromKey(SDL_Keycode key);
-
-/**
- * Get a human-readable name for a scancode.
- *
- * See SDL_Scancode for details.
- *
- * **Warning**: The returned name is by design not stable across platforms,
- * e.g. the name for `SDL_SCANCODE_LGUI` is "Left GUI" under Linux but "Left
- * Windows" under Microsoft Windows, and some scancodes like
- * `SDL_SCANCODE_NONUSBACKSLASH` don't have any name at all. There are even
- * scancodes that share names, e.g. `SDL_SCANCODE_RETURN` and
- * `SDL_SCANCODE_RETURN2` (both called "Return"). This function is therefore
- * unsuitable for creating a stable cross-platform two-way mapping between
- * strings and scancodes.
- *
- * \param scancode the desired SDL_Scancode to query.
- * \returns a pointer to the name for the scancode. If the scancode doesn't
- *          have a name this function returns an empty string ("").
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetScancodeFromKey
- * \sa SDL_GetScancodeFromName
- */
-extern DECLSPEC const char *SDLCALL SDL_GetScancodeName(SDL_Scancode scancode);
-
-/**
- * Get a scancode from a human-readable name.
- *
- * \param name the human-readable scancode name.
- * \returns the SDL_Scancode, or `SDL_SCANCODE_UNKNOWN` if the name wasn't
- *          recognized; call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetKeyFromName
- * \sa SDL_GetScancodeFromKey
- * \sa SDL_GetScancodeName
- */
-extern DECLSPEC SDL_Scancode SDLCALL SDL_GetScancodeFromName(const char *name);
-
-/**
- * Get a human-readable name for a key.
- *
- * See SDL_Scancode and SDL_Keycode for details.
- *
- * \param key the desired SDL_Keycode to query.
- * \returns a pointer to a UTF-8 string that stays valid at least until the
- *          next call to this function. If you need it around any longer, you
- *          must copy it. If the key doesn't have a name, this function
- *          returns an empty string ("").
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetKeyFromName
- * \sa SDL_GetKeyFromScancode
- * \sa SDL_GetScancodeFromKey
- */
-extern DECLSPEC const char *SDLCALL SDL_GetKeyName(SDL_Keycode key);
-
-/**
- * Get a key code from a human-readable name.
- *
- * \param name the human-readable key name.
- * \returns key code, or `SDLK_UNKNOWN` if the name wasn't recognized; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetKeyFromScancode
- * \sa SDL_GetKeyName
- * \sa SDL_GetScancodeFromName
- */
-extern DECLSPEC SDL_Keycode SDLCALL SDL_GetKeyFromName(const char *name);
-
-/**
- * Start accepting Unicode text input events.
- *
- * This function will start accepting Unicode text input events in the focused
- * SDL window, and start emitting SDL_TextInputEvent (SDL_TEXTINPUT) and
- * SDL_TextEditingEvent (SDL_TEXTEDITING) events. Please use this function in
- * pair with SDL_StopTextInput().
- *
- * On some platforms using this function activates the screen keyboard.
- *
- * On desktop platforms, SDL_StartTextInput() is implicitly called on SDL
- * video subsystem initialization which will cause SDL_TextInputEvent and
- * SDL_TextEditingEvent to begin emitting.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_SetTextInputRect
- * \sa SDL_StopTextInput
- */
-extern DECLSPEC void SDLCALL SDL_StartTextInput(void);
-
-/**
- * Check whether or not Unicode text input events are enabled.
- *
- * \returns SDL_TRUE if text input events are enabled else SDL_FALSE.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_StartTextInput
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_IsTextInputActive(void);
-
-/**
- * Stop receiving any text input events.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_StartTextInput
- */
-extern DECLSPEC void SDLCALL SDL_StopTextInput(void);
-
-/**
- * Dismiss the composition window/IME without disabling the subsystem.
- *
- * \since This function is available since SDL 2.0.22.
- *
- * \sa SDL_StartTextInput
- * \sa SDL_StopTextInput
- */
-extern DECLSPEC void SDLCALL SDL_ClearComposition(void);
-
-/**
- * Returns if an IME Composite or Candidate window is currently shown.
- *
- * \returns SDL_TRUE if an IME Composite or Candidate window is currently
- *          shown else SDL_FALSE.
- *
- * \since This function is available since SDL 2.0.22.
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_IsTextInputShown(void);
-
-/**
- * Set the rectangle used to type Unicode text inputs.
- *
- * Native input methods will place a window with word suggestions near it,
- * without covering the text being inputted.
- *
- * To start text input in a given location, this function is intended to be
- * called before SDL_StartTextInput, although some platforms support moving
- * the rectangle even while text input (and a composition) is active.
- *
- * Note: If you want to use the system native IME window, try setting hint
- * **SDL_HINT_IME_SHOW_UI** to **1**, otherwise this function won't give you
- * any feedback.
- *
- * \param rect the SDL_Rect structure representing the rectangle to receive
- *             text (ignored if NULL).
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_StartTextInput
- */
-extern DECLSPEC void SDLCALL SDL_SetTextInputRect(const SDL_Rect *rect);
-
-/**
- * Check whether the platform has screen keyboard support.
- *
- * \returns SDL_TRUE if the platform has some screen keyboard support or
- *          SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_StartTextInput
- * \sa SDL_IsScreenKeyboardShown
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasScreenKeyboardSupport(void);
-
-/**
- * Check whether the screen keyboard is shown for given window.
- *
- * \param window the window for which screen keyboard should be queried.
- * \returns SDL_TRUE if screen keyboard is shown or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_HasScreenKeyboardSupport
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_IsScreenKeyboardShown(SDL_Window *window);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_keyboard_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */

thirdparty/include/android/SDL2/SDL_keycode.h

@@ -1,364 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- * # CategoryKeycode
- *
- * Defines constants which identify keyboard keys and modifiers.
- */
-
-#ifndef SDL_keycode_h_
-#define SDL_keycode_h_
-
-#include "SDL_stdinc.h"
-#include "SDL_scancode.h"
-
-/**
- * The SDL virtual key representation.
- *
- * Values of this type are used to represent keyboard keys using the current
- * layout of the keyboard. These values include Unicode values representing
- * the unmodified character that would be generated by pressing the key, or an
- * SDLK_* constant for those keys that do not generate characters.
- *
- * A special exception is the number keys at the top of the keyboard which map
- * to SDLK_0...SDLK_9 on AZERTY layouts.
- *
- * The actual values that might be set for this type are listed in the
- * SDL_KeyCode (capital C) enumeration.
- */
-typedef Sint32 SDL_Keycode;
-
-#define SDLK_SCANCODE_MASK (1<<30)
-#define SDL_SCANCODE_TO_KEYCODE(X)  (X | SDLK_SCANCODE_MASK)
-
-/**
- * The possible values for keycodes.
- */
-typedef enum SDL_KeyCode
-{
-    SDLK_UNKNOWN = 0,
-
-    SDLK_RETURN = '\r',
-    SDLK_ESCAPE = '\x1B',
-    SDLK_BACKSPACE = '\b',
-    SDLK_TAB = '\t',
-    SDLK_SPACE = ' ',
-    SDLK_EXCLAIM = '!',
-    SDLK_QUOTEDBL = '"',
-    SDLK_HASH = '#',
-    SDLK_PERCENT = '%',
-    SDLK_DOLLAR = '$',
-    SDLK_AMPERSAND = '&',
-    SDLK_QUOTE = '\'',
-    SDLK_LEFTPAREN = '(',
-    SDLK_RIGHTPAREN = ')',
-    SDLK_ASTERISK = '*',
-    SDLK_PLUS = '+',
-    SDLK_COMMA = ',',
-    SDLK_MINUS = '-',
-    SDLK_PERIOD = '.',
-    SDLK_SLASH = '/',
-    SDLK_0 = '0',
-    SDLK_1 = '1',
-    SDLK_2 = '2',
-    SDLK_3 = '3',
-    SDLK_4 = '4',
-    SDLK_5 = '5',
-    SDLK_6 = '6',
-    SDLK_7 = '7',
-    SDLK_8 = '8',
-    SDLK_9 = '9',
-    SDLK_COLON = ':',
-    SDLK_SEMICOLON = ';',
-    SDLK_LESS = '<',
-    SDLK_EQUALS = '=',
-    SDLK_GREATER = '>',
-    SDLK_QUESTION = '?',
-    SDLK_AT = '@',
-
-    /*
-       Skip uppercase letters
-     */
-
-    SDLK_LEFTBRACKET = '[',
-    SDLK_BACKSLASH = '\\',
-    SDLK_RIGHTBRACKET = ']',
-    SDLK_CARET = '^',
-    SDLK_UNDERSCORE = '_',
-    SDLK_BACKQUOTE = '`',
-    SDLK_a = 'a',
-    SDLK_b = 'b',
-    SDLK_c = 'c',
-    SDLK_d = 'd',
-    SDLK_e = 'e',
-    SDLK_f = 'f',
-    SDLK_g = 'g',
-    SDLK_h = 'h',
-    SDLK_i = 'i',
-    SDLK_j = 'j',
-    SDLK_k = 'k',
-    SDLK_l = 'l',
-    SDLK_m = 'm',
-    SDLK_n = 'n',
-    SDLK_o = 'o',
-    SDLK_p = 'p',
-    SDLK_q = 'q',
-    SDLK_r = 'r',
-    SDLK_s = 's',
-    SDLK_t = 't',
-    SDLK_u = 'u',
-    SDLK_v = 'v',
-    SDLK_w = 'w',
-    SDLK_x = 'x',
-    SDLK_y = 'y',
-    SDLK_z = 'z',
-
-    SDLK_CAPSLOCK = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_CAPSLOCK),
-
-    SDLK_F1 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F1),
-    SDLK_F2 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F2),
-    SDLK_F3 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F3),
-    SDLK_F4 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F4),
-    SDLK_F5 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F5),
-    SDLK_F6 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F6),
-    SDLK_F7 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F7),
-    SDLK_F8 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F8),
-    SDLK_F9 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F9),
-    SDLK_F10 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F10),
-    SDLK_F11 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F11),
-    SDLK_F12 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F12),
-
-    SDLK_PRINTSCREEN = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_PRINTSCREEN),
-    SDLK_SCROLLLOCK = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_SCROLLLOCK),
-    SDLK_PAUSE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_PAUSE),
-    SDLK_INSERT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_INSERT),
-    SDLK_HOME = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_HOME),
-    SDLK_PAGEUP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_PAGEUP),
-    SDLK_DELETE = '\x7F',
-    SDLK_END = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_END),
-    SDLK_PAGEDOWN = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_PAGEDOWN),
-    SDLK_RIGHT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_RIGHT),
-    SDLK_LEFT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_LEFT),
-    SDLK_DOWN = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_DOWN),
-    SDLK_UP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_UP),
-
-    SDLK_NUMLOCKCLEAR = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_NUMLOCKCLEAR),
-    SDLK_KP_DIVIDE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_DIVIDE),
-    SDLK_KP_MULTIPLY = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_MULTIPLY),
-    SDLK_KP_MINUS = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_MINUS),
-    SDLK_KP_PLUS = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_PLUS),
-    SDLK_KP_ENTER = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_ENTER),
-    SDLK_KP_1 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_1),
-    SDLK_KP_2 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_2),
-    SDLK_KP_3 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_3),
-    SDLK_KP_4 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_4),
-    SDLK_KP_5 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_5),
-    SDLK_KP_6 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_6),
-    SDLK_KP_7 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_7),
-    SDLK_KP_8 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_8),
-    SDLK_KP_9 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_9),
-    SDLK_KP_0 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_0),
-    SDLK_KP_PERIOD = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_PERIOD),
-
-    SDLK_APPLICATION = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_APPLICATION),
-    SDLK_POWER = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_POWER),
-    SDLK_KP_EQUALS = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_EQUALS),
-    SDLK_F13 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F13),
-    SDLK_F14 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F14),
-    SDLK_F15 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F15),
-    SDLK_F16 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F16),
-    SDLK_F17 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F17),
-    SDLK_F18 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F18),
-    SDLK_F19 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F19),
-    SDLK_F20 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F20),
-    SDLK_F21 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F21),
-    SDLK_F22 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F22),
-    SDLK_F23 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F23),
-    SDLK_F24 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F24),
-    SDLK_EXECUTE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_EXECUTE),
-    SDLK_HELP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_HELP),
-    SDLK_MENU = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_MENU),
-    SDLK_SELECT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_SELECT),
-    SDLK_STOP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_STOP),
-    SDLK_AGAIN = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AGAIN),
-    SDLK_UNDO = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_UNDO),
-    SDLK_CUT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_CUT),
-    SDLK_COPY = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_COPY),
-    SDLK_PASTE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_PASTE),
-    SDLK_FIND = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_FIND),
-    SDLK_MUTE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_MUTE),
-    SDLK_VOLUMEUP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_VOLUMEUP),
-    SDLK_VOLUMEDOWN = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_VOLUMEDOWN),
-    SDLK_KP_COMMA = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_COMMA),
-    SDLK_KP_EQUALSAS400 =
-        SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_EQUALSAS400),
-
-    SDLK_ALTERASE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_ALTERASE),
-    SDLK_SYSREQ = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_SYSREQ),
-    SDLK_CANCEL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_CANCEL),
-    SDLK_CLEAR = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_CLEAR),
-    SDLK_PRIOR = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_PRIOR),
-    SDLK_RETURN2 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_RETURN2),
-    SDLK_SEPARATOR = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_SEPARATOR),
-    SDLK_OUT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_OUT),
-    SDLK_OPER = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_OPER),
-    SDLK_CLEARAGAIN = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_CLEARAGAIN),
-    SDLK_CRSEL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_CRSEL),
-    SDLK_EXSEL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_EXSEL),
-
-    SDLK_KP_00 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_00),
-    SDLK_KP_000 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_000),
-    SDLK_THOUSANDSSEPARATOR =
-        SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_THOUSANDSSEPARATOR),
-    SDLK_DECIMALSEPARATOR =
-        SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_DECIMALSEPARATOR),
-    SDLK_CURRENCYUNIT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_CURRENCYUNIT),
-    SDLK_CURRENCYSUBUNIT =
-        SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_CURRENCYSUBUNIT),
-    SDLK_KP_LEFTPAREN = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_LEFTPAREN),
-    SDLK_KP_RIGHTPAREN = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_RIGHTPAREN),
-    SDLK_KP_LEFTBRACE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_LEFTBRACE),
-    SDLK_KP_RIGHTBRACE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_RIGHTBRACE),
-    SDLK_KP_TAB = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_TAB),
-    SDLK_KP_BACKSPACE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_BACKSPACE),
-    SDLK_KP_A = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_A),
-    SDLK_KP_B = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_B),
-    SDLK_KP_C = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_C),
-    SDLK_KP_D = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_D),
-    SDLK_KP_E = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_E),
-    SDLK_KP_F = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_F),
-    SDLK_KP_XOR = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_XOR),
-    SDLK_KP_POWER = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_POWER),
-    SDLK_KP_PERCENT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_PERCENT),
-    SDLK_KP_LESS = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_LESS),
-    SDLK_KP_GREATER = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_GREATER),
-    SDLK_KP_AMPERSAND = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_AMPERSAND),
-    SDLK_KP_DBLAMPERSAND =
-        SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_DBLAMPERSAND),
-    SDLK_KP_VERTICALBAR =
-        SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_VERTICALBAR),
-    SDLK_KP_DBLVERTICALBAR =
-        SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_DBLVERTICALBAR),
-    SDLK_KP_COLON = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_COLON),
-    SDLK_KP_HASH = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_HASH),
-    SDLK_KP_SPACE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_SPACE),
-    SDLK_KP_AT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_AT),
-    SDLK_KP_EXCLAM = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_EXCLAM),
-    SDLK_KP_MEMSTORE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_MEMSTORE),
-    SDLK_KP_MEMRECALL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_MEMRECALL),
-    SDLK_KP_MEMCLEAR = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_MEMCLEAR),
-    SDLK_KP_MEMADD = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_MEMADD),
-    SDLK_KP_MEMSUBTRACT =
-        SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_MEMSUBTRACT),
-    SDLK_KP_MEMMULTIPLY =
-        SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_MEMMULTIPLY),
-    SDLK_KP_MEMDIVIDE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_MEMDIVIDE),
-    SDLK_KP_PLUSMINUS = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_PLUSMINUS),
-    SDLK_KP_CLEAR = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_CLEAR),
-    SDLK_KP_CLEARENTRY = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_CLEARENTRY),
-    SDLK_KP_BINARY = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_BINARY),
-    SDLK_KP_OCTAL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_OCTAL),
-    SDLK_KP_DECIMAL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_DECIMAL),
-    SDLK_KP_HEXADECIMAL =
-        SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_HEXADECIMAL),
-
-    SDLK_LCTRL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_LCTRL),
-    SDLK_LSHIFT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_LSHIFT),
-    SDLK_LALT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_LALT),
-    SDLK_LGUI = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_LGUI),
-    SDLK_RCTRL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_RCTRL),
-    SDLK_RSHIFT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_RSHIFT),
-    SDLK_RALT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_RALT),
-    SDLK_RGUI = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_RGUI),
-
-    SDLK_MODE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_MODE),
-
-    SDLK_AUDIONEXT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AUDIONEXT),
-    SDLK_AUDIOPREV = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AUDIOPREV),
-    SDLK_AUDIOSTOP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AUDIOSTOP),
-    SDLK_AUDIOPLAY = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AUDIOPLAY),
-    SDLK_AUDIOMUTE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AUDIOMUTE),
-    SDLK_MEDIASELECT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_MEDIASELECT),
-    SDLK_WWW = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_WWW),
-    SDLK_MAIL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_MAIL),
-    SDLK_CALCULATOR = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_CALCULATOR),
-    SDLK_COMPUTER = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_COMPUTER),
-    SDLK_AC_SEARCH = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AC_SEARCH),
-    SDLK_AC_HOME = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AC_HOME),
-    SDLK_AC_BACK = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AC_BACK),
-    SDLK_AC_FORWARD = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AC_FORWARD),
-    SDLK_AC_STOP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AC_STOP),
-    SDLK_AC_REFRESH = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AC_REFRESH),
-    SDLK_AC_BOOKMARKS = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AC_BOOKMARKS),
-
-    SDLK_BRIGHTNESSDOWN =
-        SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_BRIGHTNESSDOWN),
-    SDLK_BRIGHTNESSUP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_BRIGHTNESSUP),
-    SDLK_DISPLAYSWITCH = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_DISPLAYSWITCH),
-    SDLK_KBDILLUMTOGGLE =
-        SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KBDILLUMTOGGLE),
-    SDLK_KBDILLUMDOWN = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KBDILLUMDOWN),
-    SDLK_KBDILLUMUP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KBDILLUMUP),
-    SDLK_EJECT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_EJECT),
-    SDLK_SLEEP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_SLEEP),
-    SDLK_APP1 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_APP1),
-    SDLK_APP2 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_APP2),
-
-    SDLK_AUDIOREWIND = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AUDIOREWIND),
-    SDLK_AUDIOFASTFORWARD = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AUDIOFASTFORWARD),
-
-    SDLK_SOFTLEFT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_SOFTLEFT),
-    SDLK_SOFTRIGHT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_SOFTRIGHT),
-    SDLK_CALL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_CALL),
-    SDLK_ENDCALL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_ENDCALL)
-} SDL_KeyCode;
-
-/**
- * Enumeration of valid key mods (possibly OR'd together).
- */
-typedef enum SDL_Keymod
-{
-    KMOD_NONE = 0x0000,
-    KMOD_LSHIFT = 0x0001,
-    KMOD_RSHIFT = 0x0002,
-    KMOD_LCTRL = 0x0040,
-    KMOD_RCTRL = 0x0080,
-    KMOD_LALT = 0x0100,
-    KMOD_RALT = 0x0200,
-    KMOD_LGUI = 0x0400,
-    KMOD_RGUI = 0x0800,
-    KMOD_NUM = 0x1000,
-    KMOD_CAPS = 0x2000,
-    KMOD_MODE = 0x4000,
-    KMOD_SCROLL = 0x8000,
-
-    KMOD_CTRL = KMOD_LCTRL | KMOD_RCTRL,
-    KMOD_SHIFT = KMOD_LSHIFT | KMOD_RSHIFT,
-    KMOD_ALT = KMOD_LALT | KMOD_RALT,
-    KMOD_GUI = KMOD_LGUI | KMOD_RGUI,
-
-    KMOD_RESERVED = KMOD_SCROLL /* This is for source-level compatibility with SDL 2.0.0. */
-} SDL_Keymod;
-
-#endif /* SDL_keycode_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */

thirdparty/include/android/SDL2/SDL_loadso.h

@@ -1,117 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/* WIKI CATEGORY: LoadSO */
-
-/**
- * # CategoryLoadSO
- *
- * System-dependent library loading routines.
- *
- * Some things to keep in mind:
- *
- * - These functions only work on C function names. Other languages may have
- *   name mangling and intrinsic language support that varies from compiler to
- *   compiler.
- * - Make sure you declare your function pointers with the same calling
- *   convention as the actual library function. Your code will crash
- *   mysteriously if you do not do this.
- * - Avoid namespace collisions. If you load a symbol from the library, it is
- *   not defined whether or not it goes into the global symbol namespace for
- *   the application. If it does and it conflicts with symbols in your code or
- *   other shared libraries, you will not get the results you expect. :)
- */
-
-#ifndef SDL_loadso_h_
-#define SDL_loadso_h_
-
-#include "SDL_stdinc.h"
-#include "SDL_error.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * Dynamically load a shared object.
- *
- * \param sofile a system-dependent name of the object file.
- * \returns an opaque pointer to the object handle or NULL if there was an
- *          error; call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_LoadFunction
- * \sa SDL_UnloadObject
- */
-extern DECLSPEC void *SDLCALL SDL_LoadObject(const char *sofile);
-
-/**
- * Look up the address of the named function in a shared object.
- *
- * This function pointer is no longer valid after calling SDL_UnloadObject().
- *
- * This function can only look up C function names. Other languages may have
- * name mangling and intrinsic language support that varies from compiler to
- * compiler.
- *
- * Make sure you declare your function pointers with the same calling
- * convention as the actual library function. Your code will crash
- * mysteriously if you do not do this.
- *
- * If the requested function doesn't exist, NULL is returned.
- *
- * \param handle a valid shared object handle returned by SDL_LoadObject().
- * \param name the name of the function to look up.
- * \returns a pointer to the function or NULL if there was an error; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_LoadObject
- * \sa SDL_UnloadObject
- */
-extern DECLSPEC void *SDLCALL SDL_LoadFunction(void *handle,
-                                               const char *name);
-
-/**
- * Unload a shared object from memory.
- *
- * \param handle a valid shared object handle returned by SDL_LoadObject().
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_LoadFunction
- * \sa SDL_LoadObject
- */
-extern DECLSPEC void SDLCALL SDL_UnloadObject(void *handle);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_loadso_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */

thirdparty/include/android/SDL2/SDL_locale.h

@@ -1,103 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- * # CategoryLocale
- *
- * Include file for SDL locale services
- */
-
-#ifndef _SDL_locale_h
-#define _SDL_locale_h
-
-#include "SDL_stdinc.h"
-#include "SDL_error.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-/* *INDENT-OFF* */
-extern "C" {
-/* *INDENT-ON* */
-#endif
-
-
-typedef struct SDL_Locale
-{
-    const char *language;  /**< A language name, like "en" for English. */
-    const char *country;  /**< A country, like "US" for America. Can be NULL. */
-} SDL_Locale;
-
-/**
- * Report the user's preferred locale.
- *
- * This returns an array of SDL_Locale structs, the final item zeroed out.
- * When the caller is done with this array, it should call SDL_free() on the
- * returned value; all the memory involved is allocated in a single block, so
- * a single SDL_free() will suffice.
- *
- * Returned language strings are in the format xx, where 'xx' is an ISO-639
- * language specifier (such as "en" for English, "de" for German, etc).
- * Country strings are in the format YY, where "YY" is an ISO-3166 country
- * code (such as "US" for the United States, "CA" for Canada, etc). Country
- * might be NULL if there's no specific guidance on them (so you might get {
- * "en", "US" } for American English, but { "en", NULL } means "English
- * language, generically"). Language strings are never NULL, except to
- * terminate the array.
- *
- * Please note that not all of these strings are 2 characters; some are three
- * or more.
- *
- * The returned list of locales are in the order of the user's preference. For
- * example, a German citizen that is fluent in US English and knows enough
- * Japanese to navigate around Tokyo might have a list like: { "de", "en_US",
- * "jp", NULL }. Someone from England might prefer British English (where
- * "color" is spelled "colour", etc), but will settle for anything like it: {
- * "en_GB", "en", NULL }.
- *
- * This function returns NULL on error, including when the platform does not
- * supply this information at all.
- *
- * This might be a "slow" call that has to query the operating system. It's
- * best to ask for this once and save the results. However, this list can
- * change, usually because the user has changed a system preference outside of
- * your program; SDL will send an SDL_LOCALECHANGED event in this case, if
- * possible, and you can call this function again to get an updated copy of
- * preferred locales.
- *
- * \return array of locales, terminated with a locale with a NULL language
- *         field. Will return NULL on error.
- *
- * \since This function is available since SDL 2.0.14.
- */
-extern DECLSPEC SDL_Locale * SDLCALL SDL_GetPreferredLocales(void);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-/* *INDENT-OFF* */
-}
-/* *INDENT-ON* */
-#endif
-#include "close_code.h"
-
-#endif /* _SDL_locale_h */
-
-/* vi: set ts=4 sw=4 expandtab: */

thirdparty/include/android/SDL2/SDL_log.h

@@ -1,404 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- * # CategoryLog
- *
- * Simple log messages with categories and priorities.
- *
- * By default logs are quiet, but if you're debugging SDL you might want:
- *
- * SDL_LogSetAllPriority(SDL_LOG_PRIORITY_WARN);
- *
- * Here's where the messages go on different platforms:
- *
- * - Windows: debug output stream
- * - Android: log output
- * - Others: standard error output (stderr)
- */
-
-#ifndef SDL_log_h_
-#define SDL_log_h_
-
-#include "SDL_stdinc.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/**
- * The maximum size of a log message prior to SDL 2.0.24
- *
- * As of 2.0.24 there is no limit to the length of SDL log messages.
- */
-#define SDL_MAX_LOG_MESSAGE 4096
-
-/**
- * The predefined log categories
- *
- * By default the application category is enabled at the INFO level, the
- * assert category is enabled at the WARN level, test is enabled at the
- * VERBOSE level and all other categories are enabled at the ERROR level.
- */
-typedef enum SDL_LogCategory
-{
-    SDL_LOG_CATEGORY_APPLICATION,
-    SDL_LOG_CATEGORY_ERROR,
-    SDL_LOG_CATEGORY_ASSERT,
-    SDL_LOG_CATEGORY_SYSTEM,
-    SDL_LOG_CATEGORY_AUDIO,
-    SDL_LOG_CATEGORY_VIDEO,
-    SDL_LOG_CATEGORY_RENDER,
-    SDL_LOG_CATEGORY_INPUT,
-    SDL_LOG_CATEGORY_TEST,
-
-    /* Reserved for future SDL library use */
-    SDL_LOG_CATEGORY_RESERVED1,
-    SDL_LOG_CATEGORY_RESERVED2,
-    SDL_LOG_CATEGORY_RESERVED3,
-    SDL_LOG_CATEGORY_RESERVED4,
-    SDL_LOG_CATEGORY_RESERVED5,
-    SDL_LOG_CATEGORY_RESERVED6,
-    SDL_LOG_CATEGORY_RESERVED7,
-    SDL_LOG_CATEGORY_RESERVED8,
-    SDL_LOG_CATEGORY_RESERVED9,
-    SDL_LOG_CATEGORY_RESERVED10,
-
-    /* Beyond this point is reserved for application use, e.g.
-       enum {
-           MYAPP_CATEGORY_AWESOME1 = SDL_LOG_CATEGORY_CUSTOM,
-           MYAPP_CATEGORY_AWESOME2,
-           MYAPP_CATEGORY_AWESOME3,
-           ...
-       };
-     */
-    SDL_LOG_CATEGORY_CUSTOM
-} SDL_LogCategory;
-
-/**
- * The predefined log priorities
- */
-typedef enum SDL_LogPriority
-{
-    SDL_LOG_PRIORITY_VERBOSE = 1,
-    SDL_LOG_PRIORITY_DEBUG,
-    SDL_LOG_PRIORITY_INFO,
-    SDL_LOG_PRIORITY_WARN,
-    SDL_LOG_PRIORITY_ERROR,
-    SDL_LOG_PRIORITY_CRITICAL,
-    SDL_NUM_LOG_PRIORITIES
-} SDL_LogPriority;
-
-
-/**
- * Set the priority of all log categories.
- *
- * \param priority the SDL_LogPriority to assign.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_LogSetPriority
- */
-extern DECLSPEC void SDLCALL SDL_LogSetAllPriority(SDL_LogPriority priority);
-
-/**
- * Set the priority of a particular log category.
- *
- * \param category the category to assign a priority to.
- * \param priority the SDL_LogPriority to assign.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_LogGetPriority
- * \sa SDL_LogSetAllPriority
- */
-extern DECLSPEC void SDLCALL SDL_LogSetPriority(int category,
-                                                SDL_LogPriority priority);
-
-/**
- * Get the priority of a particular log category.
- *
- * \param category the category to query.
- * \returns the SDL_LogPriority for the requested category.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_LogSetPriority
- */
-extern DECLSPEC SDL_LogPriority SDLCALL SDL_LogGetPriority(int category);
-
-/**
- * Reset all priorities to default.
- *
- * This is called by SDL_Quit().
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_LogSetAllPriority
- * \sa SDL_LogSetPriority
- */
-extern DECLSPEC void SDLCALL SDL_LogResetPriorities(void);
-
-/**
- * Log a message with SDL_LOG_CATEGORY_APPLICATION and SDL_LOG_PRIORITY_INFO.
- *
- * \param fmt a printf() style message format string.
- * \param ... additional parameters matching % tokens in the `fmt` string, if
- *            any.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_LogCritical
- * \sa SDL_LogDebug
- * \sa SDL_LogError
- * \sa SDL_LogInfo
- * \sa SDL_LogMessage
- * \sa SDL_LogMessageV
- * \sa SDL_LogVerbose
- * \sa SDL_LogWarn
- */
-extern DECLSPEC void SDLCALL SDL_Log(SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(1);
-
-/**
- * Log a message with SDL_LOG_PRIORITY_VERBOSE.
- *
- * \param category the category of the message.
- * \param fmt a printf() style message format string.
- * \param ... additional parameters matching % tokens in the **fmt** string,
- *            if any.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Log
- * \sa SDL_LogCritical
- * \sa SDL_LogDebug
- * \sa SDL_LogError
- * \sa SDL_LogInfo
- * \sa SDL_LogMessage
- * \sa SDL_LogMessageV
- * \sa SDL_LogWarn
- */
-extern DECLSPEC void SDLCALL SDL_LogVerbose(int category, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(2);
-
-/**
- * Log a message with SDL_LOG_PRIORITY_DEBUG.
- *
- * \param category the category of the message.
- * \param fmt a printf() style message format string.
- * \param ... additional parameters matching % tokens in the **fmt** string,
- *            if any.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Log
- * \sa SDL_LogCritical
- * \sa SDL_LogError
- * \sa SDL_LogInfo
- * \sa SDL_LogMessage
- * \sa SDL_LogMessageV
- * \sa SDL_LogVerbose
- * \sa SDL_LogWarn
- */
-extern DECLSPEC void SDLCALL SDL_LogDebug(int category, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(2);
-
-/**
- * Log a message with SDL_LOG_PRIORITY_INFO.
- *
- * \param category the category of the message.
- * \param fmt a printf() style message format string.
- * \param ... additional parameters matching % tokens in the **fmt** string,
- *            if any.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Log
- * \sa SDL_LogCritical
- * \sa SDL_LogDebug
- * \sa SDL_LogError
- * \sa SDL_LogMessage
- * \sa SDL_LogMessageV
- * \sa SDL_LogVerbose
- * \sa SDL_LogWarn
- */
-extern DECLSPEC void SDLCALL SDL_LogInfo(int category, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(2);
-
-/**
- * Log a message with SDL_LOG_PRIORITY_WARN.
- *
- * \param category the category of the message.
- * \param fmt a printf() style message format string.
- * \param ... additional parameters matching % tokens in the **fmt** string,
- *            if any.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Log
- * \sa SDL_LogCritical
- * \sa SDL_LogDebug
- * \sa SDL_LogError
- * \sa SDL_LogInfo
- * \sa SDL_LogMessage
- * \sa SDL_LogMessageV
- * \sa SDL_LogVerbose
- */
-extern DECLSPEC void SDLCALL SDL_LogWarn(int category, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(2);
-
-/**
- * Log a message with SDL_LOG_PRIORITY_ERROR.
- *
- * \param category the category of the message.
- * \param fmt a printf() style message format string.
- * \param ... additional parameters matching % tokens in the **fmt** string,
- *            if any.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Log
- * \sa SDL_LogCritical
- * \sa SDL_LogDebug
- * \sa SDL_LogInfo
- * \sa SDL_LogMessage
- * \sa SDL_LogMessageV
- * \sa SDL_LogVerbose
- * \sa SDL_LogWarn
- */
-extern DECLSPEC void SDLCALL SDL_LogError(int category, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(2);
-
-/**
- * Log a message with SDL_LOG_PRIORITY_CRITICAL.
- *
- * \param category the category of the message.
- * \param fmt a printf() style message format string.
- * \param ... additional parameters matching % tokens in the **fmt** string,
- *            if any.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Log
- * \sa SDL_LogDebug
- * \sa SDL_LogError
- * \sa SDL_LogInfo
- * \sa SDL_LogMessage
- * \sa SDL_LogMessageV
- * \sa SDL_LogVerbose
- * \sa SDL_LogWarn
- */
-extern DECLSPEC void SDLCALL SDL_LogCritical(int category, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(2);
-
-/**
- * Log a message with the specified category and priority.
- *
- * \param category the category of the message.
- * \param priority the priority of the message.
- * \param fmt a printf() style message format string.
- * \param ... additional parameters matching % tokens in the **fmt** string,
- *            if any.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Log
- * \sa SDL_LogCritical
- * \sa SDL_LogDebug
- * \sa SDL_LogError
- * \sa SDL_LogInfo
- * \sa SDL_LogMessageV
- * \sa SDL_LogVerbose
- * \sa SDL_LogWarn
- */
-extern DECLSPEC void SDLCALL SDL_LogMessage(int category,
-                                            SDL_LogPriority priority,
-                                            SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(3);
-
-/**
- * Log a message with the specified category and priority.
- *
- * \param category the category of the message.
- * \param priority the priority of the message.
- * \param fmt a printf() style message format string.
- * \param ap a variable argument list.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Log
- * \sa SDL_LogCritical
- * \sa SDL_LogDebug
- * \sa SDL_LogError
- * \sa SDL_LogInfo
- * \sa SDL_LogMessage
- * \sa SDL_LogVerbose
- * \sa SDL_LogWarn
- */
-extern DECLSPEC void SDLCALL SDL_LogMessageV(int category,
-                                             SDL_LogPriority priority,
-                                             SDL_PRINTF_FORMAT_STRING const char *fmt, va_list ap) SDL_PRINTF_VARARG_FUNCV(3);
-
-/**
- * The prototype for the log output callback function.
- *
- * This function is called by SDL when there is new text to be logged.
- *
- * \param userdata what was passed as `userdata` to
- *                 SDL_LogSetOutputFunction().
- * \param category the category of the message.
- * \param priority the priority of the message.
- * \param message the message being output.
- */
-typedef void (SDLCALL *SDL_LogOutputFunction)(void *userdata, int category, SDL_LogPriority priority, const char *message);
-
-/**
- * Get the current log output function.
- *
- * \param callback an SDL_LogOutputFunction filled in with the current log
- *                 callback.
- * \param userdata a pointer filled in with the pointer that is passed to
- *                 `callback`.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_LogSetOutputFunction
- */
-extern DECLSPEC void SDLCALL SDL_LogGetOutputFunction(SDL_LogOutputFunction *callback, void **userdata);
-
-/**
- * Replace the default log output function with one of your own.
- *
- * \param callback an SDL_LogOutputFunction to call instead of the default.
- * \param userdata a pointer that is passed to `callback`.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_LogGetOutputFunction
- */
-extern DECLSPEC void SDLCALL SDL_LogSetOutputFunction(SDL_LogOutputFunction callback, void *userdata);
-
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_log_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */

thirdparty/include/android/SDL2/SDL_main.h

@@ -1,282 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_main_h_
-#define SDL_main_h_
-
-#include "SDL_stdinc.h"
-
-/**
- * # CategoryMain
- *
- * Redefine main() on some platforms so that it is called by SDL.
- */
-
-#ifndef SDL_MAIN_HANDLED
-#if defined(__WIN32__)
-/* On Windows SDL provides WinMain(), which parses the command line and passes
-   the arguments to your main function.
-
-   If you provide your own WinMain(), you may define SDL_MAIN_HANDLED
- */
-#define SDL_MAIN_AVAILABLE
-
-#elif defined(__WINRT__)
-/* On WinRT, SDL provides a main function that initializes CoreApplication,
-   creating an instance of IFrameworkView in the process.
-
-   Please note that #include'ing SDL_main.h is not enough to get a main()
-   function working.  In non-XAML apps, the file,
-   src/main/winrt/SDL_WinRT_main_NonXAML.cpp, or a copy of it, must be compiled
-   into the app itself.  In XAML apps, the function, SDL_WinRTRunApp must be
-   called, with a pointer to the Direct3D-hosted XAML control passed in.
-*/
-#define SDL_MAIN_NEEDED
-
-#elif defined(__GDK__)
-/* On GDK, SDL provides a main function that initializes the game runtime.
-
-   Please note that #include'ing SDL_main.h is not enough to get a main()
-   function working. You must either link against SDL2main or, if not possible,
-   call the SDL_GDKRunApp function from your entry point.
-*/
-#define SDL_MAIN_NEEDED
-
-#elif defined(__IPHONEOS__)
-/* On iOS SDL provides a main function that creates an application delegate
-   and starts the iOS application run loop.
-
-   If you link with SDL dynamically on iOS, the main function can't be in a
-   shared library, so you need to link with libSDLmain.a, which includes a
-   stub main function that calls into the shared library to start execution.
-
-   See src/video/uikit/SDL_uikitappdelegate.m for more details.
- */
-#define SDL_MAIN_NEEDED
-
-#elif defined(__ANDROID__)
-/* On Android SDL provides a Java class in SDLActivity.java that is the
-   main activity entry point.
-
-   See docs/README-android.md for more details on extending that class.
- */
-#define SDL_MAIN_NEEDED
-
-/* We need to export SDL_main so it can be launched from Java */
-#define SDLMAIN_DECLSPEC    DECLSPEC
-
-#elif defined(__NACL__)
-/* On NACL we use ppapi_simple to set up the application helper code,
-   then wait for the first PSE_INSTANCE_DIDCHANGEVIEW event before 
-   starting the user main function.
-   All user code is run in a separate thread by ppapi_simple, thus 
-   allowing for blocking io to take place via nacl_io
-*/
-#define SDL_MAIN_NEEDED
-
-#elif defined(__PSP__)
-/* On PSP SDL provides a main function that sets the module info,
-   activates the GPU and starts the thread required to be able to exit
-   the software.
-
-   If you provide this yourself, you may define SDL_MAIN_HANDLED
- */
-#define SDL_MAIN_AVAILABLE
-
-#elif defined(__PS2__)
-#define SDL_MAIN_AVAILABLE
-
-#define SDL_PS2_SKIP_IOP_RESET() \
-   void reset_IOP(); \
-   void reset_IOP() {}
-
-#elif defined(__3DS__)
-/*
-  On N3DS, SDL provides a main function that sets up the screens
-  and storage.
-
-  If you provide this yourself, you may define SDL_MAIN_HANDLED
-*/
-#define SDL_MAIN_AVAILABLE
-
-#endif
-#endif /* SDL_MAIN_HANDLED */
-
-#ifndef SDLMAIN_DECLSPEC
-#define SDLMAIN_DECLSPEC
-#endif
-
-/**
- *  \file SDL_main.h
- *
- *  The application's main() function must be called with C linkage,
- *  and should be declared like this:
- *  ```c
- *  #ifdef __cplusplus
- *  extern "C"
- *  #endif
- *  int main(int argc, char *argv[])
- *  {
- *  }
- *  ```
- */
-
-#if defined(SDL_MAIN_NEEDED) || defined(SDL_MAIN_AVAILABLE)
-#define main    SDL_main
-#endif
-
-#include "begin_code.h"
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * The prototype for the application's main() function
- */
-typedef int (*SDL_main_func)(int argc, char *argv[]);
-extern SDLMAIN_DECLSPEC int SDL_main(int argc, char *argv[]);
-
-
-/**
- * Circumvent failure of SDL_Init() when not using SDL_main() as an entry
- * point.
- *
- * This function is defined in SDL_main.h, along with the preprocessor rule to
- * redefine main() as SDL_main(). Thus to ensure that your main() function
- * will not be changed it is necessary to define SDL_MAIN_HANDLED before
- * including SDL.h.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Init
- */
-extern DECLSPEC void SDLCALL SDL_SetMainReady(void);
-
-#if defined(__WIN32__) || defined(__GDK__)
-
-/**
- * Register a win32 window class for SDL's use.
- *
- * This can be called to set the application window class at startup. It is
- * safe to call this multiple times, as long as every call is eventually
- * paired with a call to SDL_UnregisterApp, but a second registration attempt
- * while a previous registration is still active will be ignored, other than
- * to increment a counter.
- *
- * Most applications do not need to, and should not, call this directly; SDL
- * will call it when initializing the video subsystem.
- *
- * \param name the window class name, in UTF-8 encoding. If NULL, SDL
- *             currently uses "SDL_app" but this isn't guaranteed.
- * \param style the value to use in WNDCLASSEX::style. If `name` is NULL, SDL
- *              currently uses `(CS_BYTEALIGNCLIENT \| CS_OWNDC)` regardless
- *              of what is specified here.
- * \param hInst the HINSTANCE to use in WNDCLASSEX::hInstance. If zero, SDL
- *              will use `GetModuleHandle(NULL)` instead.
- * \returns 0 on success, -1 on error. SDL_GetError() may have details.
- *
- * \since This function is available since SDL 2.0.2.
- */
-extern DECLSPEC int SDLCALL SDL_RegisterApp(const char *name, Uint32 style, void *hInst);
-
-/**
- * Deregister the win32 window class from an SDL_RegisterApp call.
- *
- * This can be called to undo the effects of SDL_RegisterApp.
- *
- * Most applications do not need to, and should not, call this directly; SDL
- * will call it when deinitializing the video subsystem.
- *
- * It is safe to call this multiple times, as long as every call is eventually
- * paired with a prior call to SDL_RegisterApp. The window class will only be
- * deregistered when the registration counter in SDL_RegisterApp decrements to
- * zero through calls to this function.
- *
- * \since This function is available since SDL 2.0.2.
- */
-extern DECLSPEC void SDLCALL SDL_UnregisterApp(void);
-
-#endif /* defined(__WIN32__) || defined(__GDK__) */
-
-
-#ifdef __WINRT__
-
-/**
- * Initialize and launch an SDL/WinRT application.
- *
- * \param mainFunction the SDL app's C-style main(), an SDL_main_func.
- * \param reserved reserved for future use; should be NULL.
- * \returns 0 on success or -1 on failure; call SDL_GetError() to retrieve
- *          more information on the failure.
- *
- * \since This function is available since SDL 2.0.3.
- */
-extern DECLSPEC int SDLCALL SDL_WinRTRunApp(SDL_main_func mainFunction, void * reserved);
-
-#endif /* __WINRT__ */
-
-#if defined(__IPHONEOS__)
-
-/**
- * Initializes and launches an SDL application.
- *
- * \param argc The argc parameter from the application's main() function.
- * \param argv The argv parameter from the application's main() function.
- * \param mainFunction The SDL app's C-style main(), an SDL_main_func.
- * \return the return value from mainFunction.
- *
- * \since This function is available since SDL 2.0.10.
- */
-extern DECLSPEC int SDLCALL SDL_UIKitRunApp(int argc, char *argv[], SDL_main_func mainFunction);
-
-#endif /* __IPHONEOS__ */
-
-#ifdef __GDK__
-
-/**
- * Initialize and launch an SDL GDK application.
- *
- * \param mainFunction the SDL app's C-style main(), an SDL_main_func.
- * \param reserved reserved for future use; should be NULL.
- * \returns 0 on success or -1 on failure; call SDL_GetError() to retrieve
- *          more information on the failure.
- *
- * \since This function is available since SDL 2.24.0.
- */
-extern DECLSPEC int SDLCALL SDL_GDKRunApp(SDL_main_func mainFunction, void *reserved);
-
-/**
- * Callback from the application to let the suspend continue.
- *
- * \since This function is available since SDL 2.28.0.
- */
-extern DECLSPEC void SDLCALL SDL_GDKSuspendComplete(void);
-
-#endif /* __GDK__ */
-
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_main_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */

thirdparty/include/android/SDL2/SDL_messagebox.h

@@ -1,196 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_messagebox_h_
-#define SDL_messagebox_h_
-
-#include "SDL_stdinc.h"
-#include "SDL_video.h"      /* For SDL_Window */
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * SDL_MessageBox flags.
- *
- * If supported will display warning icon, etc.
- */
-typedef enum SDL_MessageBoxFlags
-{
-    SDL_MESSAGEBOX_ERROR                 = 0x00000010,   /**< error dialog */
-    SDL_MESSAGEBOX_WARNING               = 0x00000020,   /**< warning dialog */
-    SDL_MESSAGEBOX_INFORMATION           = 0x00000040,   /**< informational dialog */
-    SDL_MESSAGEBOX_BUTTONS_LEFT_TO_RIGHT = 0x00000080,   /**< buttons placed left to right */
-    SDL_MESSAGEBOX_BUTTONS_RIGHT_TO_LEFT = 0x00000100    /**< buttons placed right to left */
-} SDL_MessageBoxFlags;
-
-/**
- * Flags for SDL_MessageBoxButtonData.
- */
-typedef enum SDL_MessageBoxButtonFlags
-{
-    SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT = 0x00000001,  /**< Marks the default button when return is hit */
-    SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT = 0x00000002   /**< Marks the default button when escape is hit */
-} SDL_MessageBoxButtonFlags;
-
-/**
- * Individual button data.
- */
-typedef struct SDL_MessageBoxButtonData
-{
-    Uint32 flags;       /**< SDL_MessageBoxButtonFlags */
-    int buttonid;       /**< User defined button id (value returned via SDL_ShowMessageBox) */
-    const char * text;  /**< The UTF-8 button text */
-} SDL_MessageBoxButtonData;
-
-/**
- * RGB value used in a message box color scheme
- */
-typedef struct SDL_MessageBoxColor
-{
-    Uint8 r, g, b;
-} SDL_MessageBoxColor;
-
-typedef enum SDL_MessageBoxColorType
-{
-    SDL_MESSAGEBOX_COLOR_BACKGROUND,
-    SDL_MESSAGEBOX_COLOR_TEXT,
-    SDL_MESSAGEBOX_COLOR_BUTTON_BORDER,
-    SDL_MESSAGEBOX_COLOR_BUTTON_BACKGROUND,
-    SDL_MESSAGEBOX_COLOR_BUTTON_SELECTED,
-    SDL_MESSAGEBOX_COLOR_MAX
-} SDL_MessageBoxColorType;
-
-/**
- * A set of colors to use for message box dialogs
- */
-typedef struct SDL_MessageBoxColorScheme
-{
-    SDL_MessageBoxColor colors[SDL_MESSAGEBOX_COLOR_MAX];
-} SDL_MessageBoxColorScheme;
-
-/**
- * MessageBox structure containing title, text, window, etc.
- */
-typedef struct SDL_MessageBoxData
-{
-    Uint32 flags;                       /**< SDL_MessageBoxFlags */
-    SDL_Window *window;                 /**< Parent window, can be NULL */
-    const char *title;                  /**< UTF-8 title */
-    const char *message;                /**< UTF-8 message text */
-
-    int numbuttons;
-    const SDL_MessageBoxButtonData *buttons;
-
-    const SDL_MessageBoxColorScheme *colorScheme;   /**< SDL_MessageBoxColorScheme, can be NULL to use system settings */
-} SDL_MessageBoxData;
-
-/**
- * Create a modal message box.
- *
- * If your needs aren't complex, it might be easier to use
- * SDL_ShowSimpleMessageBox.
- *
- * This function should be called on the thread that created the parent
- * window, or on the main thread if the messagebox has no parent. It will
- * block execution of that thread until the user clicks a button or closes the
- * messagebox.
- *
- * This function may be called at any time, even before SDL_Init(). This makes
- * it useful for reporting errors like a failure to create a renderer or
- * OpenGL context.
- *
- * On X11, SDL rolls its own dialog box with X11 primitives instead of a
- * formal toolkit like GTK+ or Qt.
- *
- * Note that if SDL_Init() would fail because there isn't any available video
- * target, this function is likely to fail for the same reasons. If this is a
- * concern, check the return value from this function and fall back to writing
- * to stderr if you can.
- *
- * \param messageboxdata the SDL_MessageBoxData structure with title, text and
- *                       other options.
- * \param buttonid the pointer to which user id of hit button should be
- *                 copied.
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_ShowSimpleMessageBox
- */
-extern DECLSPEC int SDLCALL SDL_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid);
-
-/**
- * Display a simple modal message box.
- *
- * If your needs aren't complex, this function is preferred over
- * SDL_ShowMessageBox.
- *
- * `flags` may be any of the following:
- *
- * - `SDL_MESSAGEBOX_ERROR`: error dialog
- * - `SDL_MESSAGEBOX_WARNING`: warning dialog
- * - `SDL_MESSAGEBOX_INFORMATION`: informational dialog
- *
- * This function should be called on the thread that created the parent
- * window, or on the main thread if the messagebox has no parent. It will
- * block execution of that thread until the user clicks a button or closes the
- * messagebox.
- *
- * This function may be called at any time, even before SDL_Init(). This makes
- * it useful for reporting errors like a failure to create a renderer or
- * OpenGL context.
- *
- * On X11, SDL rolls its own dialog box with X11 primitives instead of a
- * formal toolkit like GTK+ or Qt.
- *
- * Note that if SDL_Init() would fail because there isn't any available video
- * target, this function is likely to fail for the same reasons. If this is a
- * concern, check the return value from this function and fall back to writing
- * to stderr if you can.
- *
- * \param flags an SDL_MessageBoxFlags value.
- * \param title UTF-8 title text.
- * \param message UTF-8 message text.
- * \param window the parent window, or NULL for no parent.
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_ShowMessageBox
- */
-extern DECLSPEC int SDLCALL SDL_ShowSimpleMessageBox(Uint32 flags, const char *title, const char *message, SDL_Window *window);
-
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_messagebox_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */

thirdparty/include/android/SDL2/SDL_metal.h

@@ -1,122 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- * # CategoryMetal
- *
- * Header file for functions to creating Metal layers and views on SDL
- * windows.
- */
-
-#ifndef SDL_metal_h_
-#define SDL_metal_h_
-
-#include "SDL_video.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * A handle to a CAMetalLayer-backed NSView (macOS) or UIView (iOS/tvOS).
- *
- * This can be cast directly to an NSView or UIView.
- */
-typedef void *SDL_MetalView;
-
-/**
- *  \name Metal support functions
- */
-/* @{ */
-
-/**
- * Create a CAMetalLayer-backed NSView/UIView and attach it to the specified
- * window.
- *
- * On macOS, this does *not* associate a MTLDevice with the CAMetalLayer on
- * its own. It is up to user code to do that.
- *
- * The returned handle can be casted directly to a NSView or UIView. To access
- * the backing CAMetalLayer, call SDL_Metal_GetLayer().
- *
- * \param window the window.
- * \returns handle NSView or UIView.
- *
- * \since This function is available since SDL 2.0.12.
- *
- * \sa SDL_Metal_DestroyView
- * \sa SDL_Metal_GetLayer
- */
-extern DECLSPEC SDL_MetalView SDLCALL SDL_Metal_CreateView(SDL_Window * window);
-
-/**
- * Destroy an existing SDL_MetalView object.
- *
- * This should be called before SDL_DestroyWindow, if SDL_Metal_CreateView was
- * called after SDL_CreateWindow.
- *
- * \param view the SDL_MetalView object.
- *
- * \since This function is available since SDL 2.0.12.
- *
- * \sa SDL_Metal_CreateView
- */
-extern DECLSPEC void SDLCALL SDL_Metal_DestroyView(SDL_MetalView view);
-
-/**
- * Get a pointer to the backing CAMetalLayer for the given view.
- *
- * \param view the SDL_MetalView object.
- * \returns a pointer.
- *
- * \since This function is available since SDL 2.0.14.
- *
- * \sa SDL_Metal_CreateView
- */
-extern DECLSPEC void *SDLCALL SDL_Metal_GetLayer(SDL_MetalView view);
-
-/**
- * Get the size of a window's underlying drawable in pixels (for use with
- * setting viewport, scissor & etc).
- *
- * \param window SDL_Window from which the drawable size should be queried.
- * \param w Pointer to variable for storing the width in pixels, may be NULL.
- * \param h Pointer to variable for storing the height in pixels, may be NULL.
- *
- * \since This function is available since SDL 2.0.14.
- *
- * \sa SDL_GetWindowSize
- * \sa SDL_CreateWindow
- */
-extern DECLSPEC void SDLCALL SDL_Metal_GetDrawableSize(SDL_Window* window, int *w,
-                                                       int *h);
-
-/* @} *//* Metal support functions */
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_metal_h_ */

thirdparty/include/android/SDL2/SDL_misc.h

@@ -1,79 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- * # CategoryMisc
- *
- * Include file for SDL API functions that don't fit elsewhere.
- */
-
-#ifndef SDL_misc_h_
-#define SDL_misc_h_
-
-#include "SDL_stdinc.h"
-
-#include "begin_code.h"
-
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * Open a URL/URI in the browser or other appropriate external application.
- *
- * Open a URL in a separate, system-provided application. How this works will
- * vary wildly depending on the platform. This will likely launch what makes
- * sense to handle a specific URL's protocol (a web browser for `http://`,
- * etc), but it might also be able to launch file managers for directories and
- * other things.
- *
- * What happens when you open a URL varies wildly as well: your game window
- * may lose focus (and may or may not lose focus if your game was fullscreen
- * or grabbing input at the time). On mobile devices, your app will likely
- * move to the background or your process might be paused. Any given platform
- * may or may not handle a given URL.
- *
- * If this is unimplemented (or simply unavailable) for a platform, this will
- * fail with an error. A successful result does not mean the URL loaded, just
- * that we launched _something_ to handle it (or at least believe we did).
- *
- * All this to say: this function can be useful, but you should definitely
- * test it on every platform you target.
- *
- * \param url A valid URL/URI to open. Use `file:///full/path/to/file` for
- *            local files, if supported.
- * \returns 0 on success, or -1 on error; call SDL_GetError() for more
- *          information.
- *
- * \since This function is available since SDL 2.0.14.
- */
-extern DECLSPEC int SDLCALL SDL_OpenURL(const char *url);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_misc_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */

thirdparty/include/android/SDL2/SDL_mouse.h

@@ -1,464 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- * # CategoryMouse
- *
- * Include file for SDL mouse event handling.
- */
-
-#ifndef SDL_mouse_h_
-#define SDL_mouse_h_
-
-#include "SDL_stdinc.h"
-#include "SDL_error.h"
-#include "SDL_video.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct SDL_Cursor SDL_Cursor;   /**< Implementation dependent */
-
-/**
- * Cursor types for SDL_CreateSystemCursor().
- */
-typedef enum SDL_SystemCursor
-{
-    SDL_SYSTEM_CURSOR_ARROW,     /**< Arrow */
-    SDL_SYSTEM_CURSOR_IBEAM,     /**< I-beam */
-    SDL_SYSTEM_CURSOR_WAIT,      /**< Wait */
-    SDL_SYSTEM_CURSOR_CROSSHAIR, /**< Crosshair */
-    SDL_SYSTEM_CURSOR_WAITARROW, /**< Small wait cursor (or Wait if not available) */
-    SDL_SYSTEM_CURSOR_SIZENWSE,  /**< Double arrow pointing northwest and southeast */
-    SDL_SYSTEM_CURSOR_SIZENESW,  /**< Double arrow pointing northeast and southwest */
-    SDL_SYSTEM_CURSOR_SIZEWE,    /**< Double arrow pointing west and east */
-    SDL_SYSTEM_CURSOR_SIZENS,    /**< Double arrow pointing north and south */
-    SDL_SYSTEM_CURSOR_SIZEALL,   /**< Four pointed arrow pointing north, south, east, and west */
-    SDL_SYSTEM_CURSOR_NO,        /**< Slashed circle or crossbones */
-    SDL_SYSTEM_CURSOR_HAND,      /**< Hand */
-    SDL_NUM_SYSTEM_CURSORS
-} SDL_SystemCursor;
-
-/**
- * Scroll direction types for the Scroll event
- */
-typedef enum SDL_MouseWheelDirection
-{
-    SDL_MOUSEWHEEL_NORMAL,    /**< The scroll direction is normal */
-    SDL_MOUSEWHEEL_FLIPPED    /**< The scroll direction is flipped / natural */
-} SDL_MouseWheelDirection;
-
-/* Function prototypes */
-
-/**
- * Get the window which currently has mouse focus.
- *
- * \returns the window with mouse focus.
- *
- * \since This function is available since SDL 2.0.0.
- */
-extern DECLSPEC SDL_Window * SDLCALL SDL_GetMouseFocus(void);
-
-/**
- * Retrieve the current state of the mouse.
- *
- * The current button state is returned as a button bitmask, which can be
- * tested using the `SDL_BUTTON(X)` macros (where `X` is generally 1 for the
- * left, 2 for middle, 3 for the right button), and `x` and `y` are set to the
- * mouse cursor position relative to the focus window. You can pass NULL for
- * either `x` or `y`.
- *
- * \param x the x coordinate of the mouse cursor position relative to the
- *          focus window.
- * \param y the y coordinate of the mouse cursor position relative to the
- *          focus window.
- * \returns a 32-bit button bitmask of the current button state.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetGlobalMouseState
- * \sa SDL_GetRelativeMouseState
- * \sa SDL_PumpEvents
- */
-extern DECLSPEC Uint32 SDLCALL SDL_GetMouseState(int *x, int *y);
-
-/**
- * Get the current state of the mouse in relation to the desktop.
- *
- * This works similarly to SDL_GetMouseState(), but the coordinates will be
- * reported relative to the top-left of the desktop. This can be useful if you
- * need to track the mouse outside of a specific window and SDL_CaptureMouse()
- * doesn't fit your needs. For example, it could be useful if you need to
- * track the mouse while dragging a window, where coordinates relative to a
- * window might not be in sync at all times.
- *
- * Note: SDL_GetMouseState() returns the mouse position as SDL understands it
- * from the last pump of the event queue. This function, however, queries the
- * OS for the current mouse position, and as such, might be a slightly less
- * efficient function. Unless you know what you're doing and have a good
- * reason to use this function, you probably want SDL_GetMouseState() instead.
- *
- * \param x filled in with the current X coord relative to the desktop; can be
- *          NULL.
- * \param y filled in with the current Y coord relative to the desktop; can be
- *          NULL.
- * \returns the current button state as a bitmask which can be tested using
- *          the SDL_BUTTON(X) macros.
- *
- * \since This function is available since SDL 2.0.4.
- *
- * \sa SDL_CaptureMouse
- */
-extern DECLSPEC Uint32 SDLCALL SDL_GetGlobalMouseState(int *x, int *y);
-
-/**
- * Retrieve the relative state of the mouse.
- *
- * The current button state is returned as a button bitmask, which can be
- * tested using the `SDL_BUTTON(X)` macros (where `X` is generally 1 for the
- * left, 2 for middle, 3 for the right button), and `x` and `y` are set to the
- * mouse deltas since the last call to SDL_GetRelativeMouseState() or since
- * event initialization. You can pass NULL for either `x` or `y`.
- *
- * \param x a pointer filled with the last recorded x coordinate of the mouse.
- * \param y a pointer filled with the last recorded y coordinate of the mouse.
- * \returns a 32-bit button bitmask of the relative button state.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetMouseState
- */
-extern DECLSPEC Uint32 SDLCALL SDL_GetRelativeMouseState(int *x, int *y);
-
-/**
- * Move the mouse cursor to the given position within the window.
- *
- * This function generates a mouse motion event if relative mode is not
- * enabled. If relative mode is enabled, you can force mouse events for the
- * warp by setting the SDL_HINT_MOUSE_RELATIVE_WARP_MOTION hint.
- *
- * Note that this function will appear to succeed, but not actually move the
- * mouse when used over Microsoft Remote Desktop.
- *
- * \param window the window to move the mouse into, or NULL for the current
- *               mouse focus.
- * \param x the x coordinate within the window.
- * \param y the y coordinate within the window.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_WarpMouseGlobal
- */
-extern DECLSPEC void SDLCALL SDL_WarpMouseInWindow(SDL_Window * window,
-                                                   int x, int y);
-
-/**
- * Move the mouse to the given position in global screen space.
- *
- * This function generates a mouse motion event.
- *
- * A failure of this function usually means that it is unsupported by a
- * platform.
- *
- * Note that this function will appear to succeed, but not actually move the
- * mouse when used over Microsoft Remote Desktop.
- *
- * \param x the x coordinate.
- * \param y the y coordinate.
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.4.
- *
- * \sa SDL_WarpMouseInWindow
- */
-extern DECLSPEC int SDLCALL SDL_WarpMouseGlobal(int x, int y);
-
-/**
- * Set relative mouse mode.
- *
- * While the mouse is in relative mode, the cursor is hidden, the mouse
- * position is constrained to the window, and SDL will report continuous
- * relative mouse motion even if the mouse is at the edge of the window.
- *
- * This function will flush any pending mouse motion.
- *
- * \param enabled SDL_TRUE to enable relative mode, SDL_FALSE to disable.
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- *          If relative mode is not supported, this returns -1.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetRelativeMouseMode
- */
-extern DECLSPEC int SDLCALL SDL_SetRelativeMouseMode(SDL_bool enabled);
-
-/**
- * Capture the mouse and to track input outside an SDL window.
- *
- * Capturing enables your app to obtain mouse events globally, instead of just
- * within your window. Not all video targets support this function. When
- * capturing is enabled, the current window will get all mouse events, but
- * unlike relative mode, no change is made to the cursor and it is not
- * restrained to your window.
- *
- * This function may also deny mouse input to other windows--both those in
- * your application and others on the system--so you should use this function
- * sparingly, and in small bursts. For example, you might want to track the
- * mouse while the user is dragging something, until the user releases a mouse
- * button. It is not recommended that you capture the mouse for long periods
- * of time, such as the entire time your app is running. For that, you should
- * probably use SDL_SetRelativeMouseMode() or SDL_SetWindowGrab(), depending
- * on your goals.
- *
- * While captured, mouse events still report coordinates relative to the
- * current (foreground) window, but those coordinates may be outside the
- * bounds of the window (including negative values). Capturing is only allowed
- * for the foreground window. If the window loses focus while capturing, the
- * capture will be disabled automatically.
- *
- * While capturing is enabled, the current window will have the
- * `SDL_WINDOW_MOUSE_CAPTURE` flag set.
- *
- * Please note that as of SDL 2.0.22, SDL will attempt to "auto capture" the
- * mouse while the user is pressing a button; this is to try and make mouse
- * behavior more consistent between platforms, and deal with the common case
- * of a user dragging the mouse outside of the window. This means that if you
- * are calling SDL_CaptureMouse() only to deal with this situation, you no
- * longer have to (although it is safe to do so). If this causes problems for
- * your app, you can disable auto capture by setting the
- * `SDL_HINT_MOUSE_AUTO_CAPTURE` hint to zero.
- *
- * \param enabled SDL_TRUE to enable capturing, SDL_FALSE to disable.
- * \returns 0 on success or -1 if not supported; call SDL_GetError() for more
- *          information.
- *
- * \since This function is available since SDL 2.0.4.
- *
- * \sa SDL_GetGlobalMouseState
- */
-extern DECLSPEC int SDLCALL SDL_CaptureMouse(SDL_bool enabled);
-
-/**
- * Query whether relative mouse mode is enabled.
- *
- * \returns SDL_TRUE if relative mode is enabled or SDL_FALSE otherwise.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_SetRelativeMouseMode
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_GetRelativeMouseMode(void);
-
-/**
- * Create a cursor using the specified bitmap data and mask (in MSB format).
- *
- * `mask` has to be in MSB (Most Significant Bit) format.
- *
- * The cursor width (`w`) must be a multiple of 8 bits.
- *
- * The cursor is created in black and white according to the following:
- *
- * - data=0, mask=1: white
- * - data=1, mask=1: black
- * - data=0, mask=0: transparent
- * - data=1, mask=0: inverted color if possible, black if not.
- *
- * Cursors created with this function must be freed with SDL_FreeCursor().
- *
- * If you want to have a color cursor, or create your cursor from an
- * SDL_Surface, you should use SDL_CreateColorCursor(). Alternately, you can
- * hide the cursor and draw your own as part of your game's rendering, but it
- * will be bound to the framerate.
- *
- * Also, since SDL 2.0.0, SDL_CreateSystemCursor() is available, which
- * provides twelve readily available system cursors to pick from.
- *
- * \param data the color value for each pixel of the cursor.
- * \param mask the mask value for each pixel of the cursor.
- * \param w the width of the cursor.
- * \param h the height of the cursor.
- * \param hot_x the X-axis location of the upper left corner of the cursor
- *              relative to the actual mouse position.
- * \param hot_y the Y-axis location of the upper left corner of the cursor
- *              relative to the actual mouse position.
- * \returns a new cursor with the specified parameters on success or NULL on
- *          failure; call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_FreeCursor
- * \sa SDL_SetCursor
- * \sa SDL_ShowCursor
- */
-extern DECLSPEC SDL_Cursor *SDLCALL SDL_CreateCursor(const Uint8 * data,
-                                                     const Uint8 * mask,
-                                                     int w, int h, int hot_x,
-                                                     int hot_y);
-
-/**
- * Create a color cursor.
- *
- * \param surface an SDL_Surface structure representing the cursor image.
- * \param hot_x the x position of the cursor hot spot.
- * \param hot_y the y position of the cursor hot spot.
- * \returns the new cursor on success or NULL on failure; call SDL_GetError()
- *          for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CreateCursor
- * \sa SDL_FreeCursor
- */
-extern DECLSPEC SDL_Cursor *SDLCALL SDL_CreateColorCursor(SDL_Surface *surface,
-                                                          int hot_x,
-                                                          int hot_y);
-
-/**
- * Create a system cursor.
- *
- * \param id an SDL_SystemCursor enum value.
- * \returns a cursor on success or NULL on failure; call SDL_GetError() for
- *          more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_FreeCursor
- */
-extern DECLSPEC SDL_Cursor *SDLCALL SDL_CreateSystemCursor(SDL_SystemCursor id);
-
-/**
- * Set the active cursor.
- *
- * This function sets the currently active cursor to the specified one. If the
- * cursor is currently visible, the change will be immediately represented on
- * the display. SDL_SetCursor(NULL) can be used to force cursor redraw, if
- * this is desired for any reason.
- *
- * \param cursor a cursor to make active.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CreateCursor
- * \sa SDL_GetCursor
- * \sa SDL_ShowCursor
- */
-extern DECLSPEC void SDLCALL SDL_SetCursor(SDL_Cursor * cursor);
-
-/**
- * Get the active cursor.
- *
- * This function returns a pointer to the current cursor which is owned by the
- * library. It is not necessary to free the cursor with SDL_FreeCursor().
- *
- * \returns the active cursor or NULL if there is no mouse.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_SetCursor
- */
-extern DECLSPEC SDL_Cursor *SDLCALL SDL_GetCursor(void);
-
-/**
- * Get the default cursor.
- *
- * You do not have to call SDL_FreeCursor() on the return value, but it is
- * safe to do so.
- *
- * \returns the default cursor on success or NULL on failure.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CreateSystemCursor
- */
-extern DECLSPEC SDL_Cursor *SDLCALL SDL_GetDefaultCursor(void);
-
-/**
- * Free a previously-created cursor.
- *
- * Use this function to free cursor resources created with SDL_CreateCursor(),
- * SDL_CreateColorCursor() or SDL_CreateSystemCursor().
- *
- * \param cursor the cursor to free.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CreateColorCursor
- * \sa SDL_CreateCursor
- * \sa SDL_CreateSystemCursor
- */
-extern DECLSPEC void SDLCALL SDL_FreeCursor(SDL_Cursor * cursor);
-
-/**
- * Toggle whether or not the cursor is shown.
- *
- * The cursor starts off displayed but can be turned off. Passing `SDL_ENABLE`
- * displays the cursor and passing `SDL_DISABLE` hides it.
- *
- * The current state of the mouse cursor can be queried by passing
- * `SDL_QUERY`; either `SDL_DISABLE` or `SDL_ENABLE` will be returned.
- *
- * \param toggle `SDL_ENABLE` to show the cursor, `SDL_DISABLE` to hide it,
- *               `SDL_QUERY` to query the current state without changing it.
- * \returns `SDL_ENABLE` if the cursor is shown, or `SDL_DISABLE` if the
- *          cursor is hidden, or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CreateCursor
- * \sa SDL_SetCursor
- */
-extern DECLSPEC int SDLCALL SDL_ShowCursor(int toggle);
-
-/**
- * Used as a mask when testing buttons in buttonstate.
- *
- * - Button 1: Left mouse button
- * - Button 2: Middle mouse button
- * - Button 3: Right mouse button
- */
-#define SDL_BUTTON(X)       (1 << ((X)-1))
-#define SDL_BUTTON_LEFT     1
-#define SDL_BUTTON_MIDDLE   2
-#define SDL_BUTTON_RIGHT    3
-#define SDL_BUTTON_X1       4
-#define SDL_BUTTON_X2       5
-#define SDL_BUTTON_LMASK    SDL_BUTTON(SDL_BUTTON_LEFT)
-#define SDL_BUTTON_MMASK    SDL_BUTTON(SDL_BUTTON_MIDDLE)
-#define SDL_BUTTON_RMASK    SDL_BUTTON(SDL_BUTTON_RIGHT)
-#define SDL_BUTTON_X1MASK   SDL_BUTTON(SDL_BUTTON_X1)
-#define SDL_BUTTON_X2MASK   SDL_BUTTON(SDL_BUTTON_X2)
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_mouse_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */

thirdparty/include/android/SDL2/SDL_mutex.h

@@ -1,545 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_mutex_h_
-#define SDL_mutex_h_
-
-/**
- * # CategoryMutex
- *
- * Functions to provide thread synchronization primitives.
- */
-
-#include "SDL_stdinc.h"
-#include "SDL_error.h"
-
-/******************************************************************************/
-/* Enable thread safety attributes only with clang.
- * The attributes can be safely erased when compiling with other compilers.
- */
-#if defined(SDL_THREAD_SAFETY_ANALYSIS) && \
-    defined(__clang__) && (!defined(SWIG))
-#define SDL_THREAD_ANNOTATION_ATTRIBUTE__(x)   __attribute__((x))
-#else
-#define SDL_THREAD_ANNOTATION_ATTRIBUTE__(x)   /* no-op */
-#endif
-
-#define SDL_CAPABILITY(x) \
-  SDL_THREAD_ANNOTATION_ATTRIBUTE__(capability(x))
-
-#define SDL_SCOPED_CAPABILITY \
-  SDL_THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable)
-
-#define SDL_GUARDED_BY(x) \
-  SDL_THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x))
-
-#define SDL_PT_GUARDED_BY(x) \
-  SDL_THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_by(x))
-
-#define SDL_ACQUIRED_BEFORE(x) \
-  SDL_THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(x))
-
-#define SDL_ACQUIRED_AFTER(x) \
-  SDL_THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(x))
-
-#define SDL_REQUIRES(x) \
-  SDL_THREAD_ANNOTATION_ATTRIBUTE__(requires_capability(x))
-
-#define SDL_REQUIRES_SHARED(x) \
-  SDL_THREAD_ANNOTATION_ATTRIBUTE__(requires_shared_capability(x))
-
-#define SDL_ACQUIRE(x) \
-  SDL_THREAD_ANNOTATION_ATTRIBUTE__(acquire_capability(x))
-
-#define SDL_ACQUIRE_SHARED(x) \
-  SDL_THREAD_ANNOTATION_ATTRIBUTE__(acquire_shared_capability(x))
-
-#define SDL_RELEASE(x) \
-  SDL_THREAD_ANNOTATION_ATTRIBUTE__(release_capability(x))
-
-#define SDL_RELEASE_SHARED(x) \
-  SDL_THREAD_ANNOTATION_ATTRIBUTE__(release_shared_capability(x))
-
-#define SDL_RELEASE_GENERIC(x) \
-  SDL_THREAD_ANNOTATION_ATTRIBUTE__(release_generic_capability(x))
-
-#define SDL_TRY_ACQUIRE(x, y) \
-  SDL_THREAD_ANNOTATION_ATTRIBUTE__(try_acquire_capability(x, y))
-
-#define SDL_TRY_ACQUIRE_SHARED(x, y) \
-  SDL_THREAD_ANNOTATION_ATTRIBUTE__(try_acquire_shared_capability(x, y))
-
-#define SDL_EXCLUDES(x) \
-  SDL_THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(x))
-
-#define SDL_ASSERT_CAPABILITY(x) \
-  SDL_THREAD_ANNOTATION_ATTRIBUTE__(assert_capability(x))
-
-#define SDL_ASSERT_SHARED_CAPABILITY(x) \
-  SDL_THREAD_ANNOTATION_ATTRIBUTE__(assert_shared_capability(x))
-
-#define SDL_RETURN_CAPABILITY(x) \
-  SDL_THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x))
-
-#define SDL_NO_THREAD_SAFETY_ANALYSIS \
-  SDL_THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis)
-
-/******************************************************************************/
-
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * Synchronization functions which can time out return this value if they time
- * out.
- */
-#define SDL_MUTEX_TIMEDOUT  1
-
-/**
- * This is the timeout value which corresponds to never time out.
- */
-#define SDL_MUTEX_MAXWAIT   (~(Uint32)0)
-
-
-/**
- *  \name Mutex functions
- */
-/* @{ */
-
-/* The SDL mutex structure, defined in SDL_sysmutex.c */
-struct SDL_mutex;
-typedef struct SDL_mutex SDL_mutex;
-
-/**
- * Create a new mutex.
- *
- * All newly-created mutexes begin in the _unlocked_ state.
- *
- * Calls to SDL_LockMutex() will not return while the mutex is locked by
- * another thread. See SDL_TryLockMutex() to attempt to lock without blocking.
- *
- * SDL mutexes are reentrant.
- *
- * \returns the initialized and unlocked mutex or NULL on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_DestroyMutex
- * \sa SDL_LockMutex
- * \sa SDL_TryLockMutex
- * \sa SDL_UnlockMutex
- */
-extern DECLSPEC SDL_mutex *SDLCALL SDL_CreateMutex(void);
-
-/**
- * Lock the mutex.
- *
- * This will block until the mutex is available, which is to say it is in the
- * unlocked state and the OS has chosen the caller as the next thread to lock
- * it. Of all threads waiting to lock the mutex, only one may do so at a time.
- *
- * It is legal for the owning thread to lock an already-locked mutex. It must
- * unlock it the same number of times before it is actually made available for
- * other threads in the system (this is known as a "recursive mutex").
- *
- * \param mutex the mutex to lock.
- * \return 0, or -1 on error.
- *
- * \since This function is available since SDL 2.0.0.
- */
-extern DECLSPEC int SDLCALL SDL_LockMutex(SDL_mutex * mutex) SDL_ACQUIRE(mutex);
-#define SDL_mutexP(m)   SDL_LockMutex(m)
-
-/**
- * Try to lock a mutex without blocking.
- *
- * This works just like SDL_LockMutex(), but if the mutex is not available,
- * this function returns `SDL_MUTEX_TIMEOUT` immediately.
- *
- * This technique is useful if you need exclusive access to a resource but
- * don't want to wait for it, and will return to it to try again later.
- *
- * \param mutex the mutex to try to lock.
- * \returns 0, `SDL_MUTEX_TIMEDOUT`, or -1 on error; call SDL_GetError() for
- *          more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CreateMutex
- * \sa SDL_DestroyMutex
- * \sa SDL_LockMutex
- * \sa SDL_UnlockMutex
- */
-extern DECLSPEC int SDLCALL SDL_TryLockMutex(SDL_mutex * mutex) SDL_TRY_ACQUIRE(0, mutex);
-
-/**
- * Unlock the mutex.
- *
- * It is legal for the owning thread to lock an already-locked mutex. It must
- * unlock it the same number of times before it is actually made available for
- * other threads in the system (this is known as a "recursive mutex").
- *
- * It is an error to unlock a mutex that has not been locked by the current
- * thread, and doing so results in undefined behavior.
- *
- * It is also an error to unlock a mutex that isn't locked at all.
- *
- * \param mutex the mutex to unlock.
- * \returns 0, or -1 on error.
- *
- * \since This function is available since SDL 2.0.0.
- */
-extern DECLSPEC int SDLCALL SDL_UnlockMutex(SDL_mutex * mutex) SDL_RELEASE(mutex);
-#define SDL_mutexV(m)   SDL_UnlockMutex(m)
-
-/**
- * Destroy a mutex created with SDL_CreateMutex().
- *
- * This function must be called on any mutex that is no longer needed. Failure
- * to destroy a mutex will result in a system memory or resource leak. While
- * it is safe to destroy a mutex that is _unlocked_, it is not safe to attempt
- * to destroy a locked mutex, and may result in undefined behavior depending
- * on the platform.
- *
- * \param mutex the mutex to destroy.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CreateMutex
- * \sa SDL_LockMutex
- * \sa SDL_TryLockMutex
- * \sa SDL_UnlockMutex
- */
-extern DECLSPEC void SDLCALL SDL_DestroyMutex(SDL_mutex * mutex);
-
-/* @} *//* Mutex functions */
-
-
-/**
- *  \name Semaphore functions
- */
-/* @{ */
-
-/* The SDL semaphore structure, defined in SDL_syssem.c */
-struct SDL_semaphore;
-typedef struct SDL_semaphore SDL_sem;
-
-/**
- * Create a semaphore.
- *
- * This function creates a new semaphore and initializes it with the value
- * `initial_value`. Each wait operation on the semaphore will atomically
- * decrement the semaphore value and potentially block if the semaphore value
- * is 0. Each post operation will atomically increment the semaphore value and
- * wake waiting threads and allow them to retry the wait operation.
- *
- * \param initial_value the starting value of the semaphore.
- * \returns a new semaphore or NULL on failure; call SDL_GetError() for more
- *          information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_DestroySemaphore
- * \sa SDL_SemPost
- * \sa SDL_SemTryWait
- * \sa SDL_SemValue
- * \sa SDL_SemWait
- * \sa SDL_SemWaitTimeout
- */
-extern DECLSPEC SDL_sem *SDLCALL SDL_CreateSemaphore(Uint32 initial_value);
-
-/**
- * Destroy a semaphore.
- *
- * It is not safe to destroy a semaphore if there are threads currently
- * waiting on it.
- *
- * \param sem the semaphore to destroy.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CreateSemaphore
- * \sa SDL_SemPost
- * \sa SDL_SemTryWait
- * \sa SDL_SemValue
- * \sa SDL_SemWait
- * \sa SDL_SemWaitTimeout
- */
-extern DECLSPEC void SDLCALL SDL_DestroySemaphore(SDL_sem * sem);
-
-/**
- * Wait until a semaphore has a positive value and then decrements it.
- *
- * This function suspends the calling thread until either the semaphore
- * pointed to by `sem` has a positive value or the call is interrupted by a
- * signal or error. If the call is successful it will atomically decrement the
- * semaphore value.
- *
- * This function is the equivalent of calling SDL_SemWaitTimeout() with a time
- * length of `SDL_MUTEX_MAXWAIT`.
- *
- * \param sem the semaphore wait on.
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CreateSemaphore
- * \sa SDL_DestroySemaphore
- * \sa SDL_SemPost
- * \sa SDL_SemTryWait
- * \sa SDL_SemValue
- * \sa SDL_SemWait
- * \sa SDL_SemWaitTimeout
- */
-extern DECLSPEC int SDLCALL SDL_SemWait(SDL_sem * sem);
-
-/**
- * See if a semaphore has a positive value and decrement it if it does.
- *
- * This function checks to see if the semaphore pointed to by `sem` has a
- * positive value and atomically decrements the semaphore value if it does. If
- * the semaphore doesn't have a positive value, the function immediately
- * returns SDL_MUTEX_TIMEDOUT.
- *
- * \param sem the semaphore to wait on.
- * \returns 0 if the wait succeeds, `SDL_MUTEX_TIMEDOUT` if the wait would
- *          block, or a negative error code on failure; call SDL_GetError()
- *          for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CreateSemaphore
- * \sa SDL_DestroySemaphore
- * \sa SDL_SemPost
- * \sa SDL_SemValue
- * \sa SDL_SemWait
- * \sa SDL_SemWaitTimeout
- */
-extern DECLSPEC int SDLCALL SDL_SemTryWait(SDL_sem * sem);
-
-/**
- * Wait until a semaphore has a positive value and then decrements it.
- *
- * This function suspends the calling thread until either the semaphore
- * pointed to by `sem` has a positive value, the call is interrupted by a
- * signal or error, or the specified time has elapsed. If the call is
- * successful it will atomically decrement the semaphore value.
- *
- * \param sem the semaphore to wait on.
- * \param timeout the length of the timeout, in milliseconds.
- * \returns 0 if the wait succeeds, `SDL_MUTEX_TIMEDOUT` if the wait does not
- *          succeed in the allotted time, or a negative error code on failure;
- *          call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CreateSemaphore
- * \sa SDL_DestroySemaphore
- * \sa SDL_SemPost
- * \sa SDL_SemTryWait
- * \sa SDL_SemValue
- * \sa SDL_SemWait
- */
-extern DECLSPEC int SDLCALL SDL_SemWaitTimeout(SDL_sem *sem, Uint32 timeout);
-
-/**
- * Atomically increment a semaphore's value and wake waiting threads.
- *
- * \param sem the semaphore to increment.
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CreateSemaphore
- * \sa SDL_DestroySemaphore
- * \sa SDL_SemTryWait
- * \sa SDL_SemValue
- * \sa SDL_SemWait
- * \sa SDL_SemWaitTimeout
- */
-extern DECLSPEC int SDLCALL SDL_SemPost(SDL_sem * sem);
-
-/**
- * Get the current value of a semaphore.
- *
- * \param sem the semaphore to query.
- * \returns the current value of the semaphore.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CreateSemaphore
- */
-extern DECLSPEC Uint32 SDLCALL SDL_SemValue(SDL_sem * sem);
-
-/* @} *//* Semaphore functions */
-
-
-/**
- *  \name Condition variable functions
- */
-/* @{ */
-
-/* The SDL condition variable structure, defined in SDL_syscond.c */
-struct SDL_cond;
-typedef struct SDL_cond SDL_cond;
-
-/**
- * Create a condition variable.
- *
- * \returns a new condition variable or NULL on failure; call SDL_GetError()
- *          for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CondBroadcast
- * \sa SDL_CondSignal
- * \sa SDL_CondWait
- * \sa SDL_CondWaitTimeout
- * \sa SDL_DestroyCond
- */
-extern DECLSPEC SDL_cond *SDLCALL SDL_CreateCond(void);
-
-/**
- * Destroy a condition variable.
- *
- * \param cond the condition variable to destroy.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CondBroadcast
- * \sa SDL_CondSignal
- * \sa SDL_CondWait
- * \sa SDL_CondWaitTimeout
- * \sa SDL_CreateCond
- */
-extern DECLSPEC void SDLCALL SDL_DestroyCond(SDL_cond * cond);
-
-/**
- * Restart one of the threads that are waiting on the condition variable.
- *
- * \param cond the condition variable to signal.
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CondBroadcast
- * \sa SDL_CondWait
- * \sa SDL_CondWaitTimeout
- * \sa SDL_CreateCond
- * \sa SDL_DestroyCond
- */
-extern DECLSPEC int SDLCALL SDL_CondSignal(SDL_cond * cond);
-
-/**
- * Restart all threads that are waiting on the condition variable.
- *
- * \param cond the condition variable to signal.
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CondSignal
- * \sa SDL_CondWait
- * \sa SDL_CondWaitTimeout
- * \sa SDL_CreateCond
- * \sa SDL_DestroyCond
- */
-extern DECLSPEC int SDLCALL SDL_CondBroadcast(SDL_cond * cond);
-
-/**
- * Wait until a condition variable is signaled.
- *
- * This function unlocks the specified `mutex` and waits for another thread to
- * call SDL_CondSignal() or SDL_CondBroadcast() on the condition variable
- * `cond`. Once the condition variable is signaled, the mutex is re-locked and
- * the function returns.
- *
- * The mutex must be locked before calling this function.
- *
- * This function is the equivalent of calling SDL_CondWaitTimeout() with a
- * time length of `SDL_MUTEX_MAXWAIT`.
- *
- * \param cond the condition variable to wait on.
- * \param mutex the mutex used to coordinate thread access.
- * \returns 0 when it is signaled or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CondBroadcast
- * \sa SDL_CondSignal
- * \sa SDL_CondWaitTimeout
- * \sa SDL_CreateCond
- * \sa SDL_DestroyCond
- */
-extern DECLSPEC int SDLCALL SDL_CondWait(SDL_cond * cond, SDL_mutex * mutex);
-
-/**
- * Wait until a condition variable is signaled or a certain time has passed.
- *
- * This function unlocks the specified `mutex` and waits for another thread to
- * call SDL_CondSignal() or SDL_CondBroadcast() on the condition variable
- * `cond`, or for the specified time to elapse. Once the condition variable is
- * signaled or the time elapsed, the mutex is re-locked and the function
- * returns.
- *
- * The mutex must be locked before calling this function.
- *
- * \param cond the condition variable to wait on.
- * \param mutex the mutex used to coordinate thread access.
- * \param ms the maximum time to wait, in milliseconds, or `SDL_MUTEX_MAXWAIT`
- *           to wait indefinitely.
- * \returns 0 if the condition variable is signaled, `SDL_MUTEX_TIMEDOUT` if
- *          the condition is not signaled in the allotted time, or a negative
- *          error code on failure; call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CondBroadcast
- * \sa SDL_CondSignal
- * \sa SDL_CondWait
- * \sa SDL_CreateCond
- * \sa SDL_DestroyCond
- */
-extern DECLSPEC int SDLCALL SDL_CondWaitTimeout(SDL_cond * cond,
-                                                SDL_mutex * mutex, Uint32 ms);
-
-/* @} *//* Condition variable functions */
-
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_mutex_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */