final_platform_layer.h

Go to the documentation of this file.

/*
final_platform_layer.h
 
-------------------------------------------------------------------------------
    About
-------------------------------------------------------------------------------
 
Final Platform Layer is a Single-Header-File cross-platform C development library designed to abstract the underlying platform to a simple and easy-to-use API - providing low-level access to (Window, Video, Audio, Input, File/Path IO, Threads, Memory, Hardware, etc.).
 
The main focus is game/media/simulation development, so the default settings will create a window, set up an OpenGL rendering context, and initialize audio playback on any platform.
 
It is written in C99 for simplicity and best portability but is C++ compatible as well.
 
FPL supports the platforms Windows/Linux/Unix for the architectures x86/x64/arm.
 
The only dependencies are built-in operating system libraries and a C99 compliant compiler.
 
It is licensed under the MIT-License. This license allows you to use FPL freely in any software.
 
-------------------------------------------------------------------------------
    Getting started
-------------------------------------------------------------------------------
 
- Drop this file into any C/C++ projects you want and include it in any place you want
- In your main translation unit provide the typical main() entry point
- Define FPL_IMPLEMENTATION in at least one translation unit before including this header file
- Init the platform using fplPlatformInit()
- Use the features you want
- Release the platform when you are done using fplPlatformRelease()
 
-------------------------------------------------------------------------------
    Usage: Hello world console application
-------------------------------------------------------------------------------
 
#define FPL_IMPLEMENTATION
#include <final_platform_layer.h>
 
int main(int argc, char **args){
    if (fplPlatformInit(fplInitFlags_None, fpl_null)) {
        fplConsoleOut("Hello World!");
        fplPlatformRelease();
        return 0;
    } else {
        return -1;
    }
}
 
-------------------------------------------------------------------------------
    Usage: OpenGL legacy or modern application
-------------------------------------------------------------------------------
 
#define FPL_IMPLEMENTATION
#include <final_platform_layer.h>
 
int main(int argc, char **args){
    // Create default settings
    fplSettings settings = fplMakeDefaultSettings();
 
    // Overwrite the video backend
    settings.video.backend = fplVideoBackendType_OpenGL;
 
    // Legacy OpenGL
    settings.video.graphics.opengl.compabilityFlags = fplOpenGLCompabilityFlags_Legacy;
 
    // or
 
    // Modern OpenGL
    settings.video.graphics.opengl.compabilityFlags = fplOpenGLCompabilityFlags_Core;
    settings.video.graphics.opengl.majorVersion = 3;
    settings.video.graphics.opengl.minorVersion = 3;
 
    if (fplPlatformInit(fplInitFlags_Video, &settings)) {
        // Event/Main loop
        while (fplWindowUpdate()) {
            // Poll events
            fplEvent ev;
            while (fplPollEvent(&ev)) {
            }
 
            // your code goes here
 
            fplVideoFlip();
        }
        fplPlatformRelease();
        return 0;
    } else {
        return -1;
    }
}
 
-------------------------------------------------------------------------------
    License
-------------------------------------------------------------------------------
 
Final Platform Layer is released under the following license:
 
MIT License
 
Copyright (c) 2017-2023 Torsten Spaete
 
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
 
// ----------------------------------------------------------------------------
// > CHANGELOG
// ----------------------------------------------------------------------------
// ****************************************************************************
//
// > HEADER
//
// ****************************************************************************
#ifndef FPL_HEADER_H
#define FPL_HEADER_H
 
//
// C99 detection
//
// https://en.wikipedia.org/wiki/C99#Version_detection
// C99 is partially supported since MSVC 2015
#if !defined(__cplusplus) && ((defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || (defined(_MSC_VER) && (_MSC_VER >= 1900)))
#   define FPL_IS_C99
#elif defined(__cplusplus)
#   define FPL_IS_CPP
#   if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || (__cplusplus >= 201103L) || (_MSC_VER >= 1900)
#       define FPL_IS_CPP11
#   endif
#else
#   error "This C/C++ compiler is not supported!"
#endif
 
//
// Architecture detection (x86, x64)
// https://sourceforge.net/p/predef/wiki/Architectures/
//
#if defined(__x86_64__) || defined(_M_X64) || defined(__amd64__)
#   define FPL_ARCH_X64
#elif defined(__i386__) || defined(_M_IX86) || defined(__X86__) || defined(_X86_)
#   define FPL_ARCH_X86
#elif defined(__aarch64__) || defined(_M_ARM64)
#   define FPL_ARCH_ARM64
#elif defined(__arm__) || defined(_M_ARM)
#   define FPL_ARCH_ARM32
#elif defined(__powerpc64__) || defined(__ppc64__) || defined(__PPC64__) || defined(_ARCH_PPC64)
#   define FPL_ARCH_POWERPC64
#elif defined(__powerpc__) || defined(__POWERPC__) || defined(__ppc__) || defined(__PPC__) || defined(_ARCH_PPC)
#   define FPL_ARCH_POWERPC32
#else
#   error "This architecture is not supported!"
#endif // FPL_ARCH
 
//
// 32-bit or 64-bit
//
#if defined(_WIN32)
#   if defined(_WIN64)
#       define FPL__M_CPU_64BIT
#   else
#       define FPL__M_CPU_32BIT
#   endif
#elif defined(__GNUC__)
#   if defined(__LP64__)
#       define FPL__M_CPU_64BIT
#   else
#       define FPL__M_CPU_32BIT
#   endif
#else
#   if (defined(__SIZEOF_POINTER__) && __SIZEOF_POINTER__ == 8) || (sizeof(void *) == 8)
#       define FPL__M_CPU_64BIT
#   else
#       define FPL__M_CPU_32BIT
#   endif
#endif
 
#if defined(FPL__M_CPU_64BIT)
#   define FPL_CPU_64BIT
#elif defined(FPL__M_CPU_32BIT)
#   define FPL_CPU_32BIT
#endif
 
//
// Compiler detection
// http://beefchunk.com/documentation/lang/c/pre-defined-c/precomp.html
// http://nadeausoftware.com/articles/2012/10/c_c_tip_how_detect_compiler_name_and_version_using_compiler_predefined_macros
//
#if defined(__clang__)
#   define FPL_COMPILER_CLANG
#elif defined(__INTEL_COMPILER)
#   define FPL_COMPILER_INTEL
#elif defined(__MINGW32__)
#   define FPL_COMPILER_MINGW
#elif defined(__CC_ARM)
#   define FPL_COMPILER_ARM
#elif defined(__GNUC__)
#   define FPL_COMPILER_GCC
#elif defined(_MSC_VER)
#   define FPL_COMPILER_MSVC
#else
#error "This compiler is not supported!"
#endif // FPL_COMPILER
 
//
// Platform detection
// https://sourceforge.net/p/predef/wiki/OperatingSystems/
//
#if defined(_WIN32) || defined(_WIN64)
#   define FPL_PLATFORM_WINDOWS
#   define FPL_PLATFORM_NAME "Windows"
#elif defined(__ANDROID__)
#   define FPL_PLATFORM_ANDROID
#   define FPL_PLATFORM_NAME "Android"
#   define FPL_SUBPLATFORM_POSIX
#   define FPL_SUBPLATFORM_STD_STRINGS
#   define FPL_SUBPLATFORM_STD_CONSOLE
#elif defined(__linux__) || defined(__gnu_linux__)
#   define FPL_PLATFORM_LINUX
#   define FPL_PLATFORM_NAME "Linux"
#   define FPL_SUBPLATFORM_POSIX
#   define FPL_SUBPLATFORM_X11
#   define FPL_SUBPLATFORM_STD_STRINGS
#   define FPL_SUBPLATFORM_STD_CONSOLE
#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(__bsdi__)
    // @NOTE(final): BSD is treated as a subplatform for now
#   define FPL_PLATFORM_UNIX
#   define FPL_PLATFORM_NAME "BSD"
#   define FPL_SUBPLATFORM_BSD
#   define FPL_SUBPLATFORM_POSIX
#   define FPL_SUBPLATFORM_X11
#   define FPL_SUBPLATFORM_STD_STRINGS
#   define FPL_SUBPLATFORM_STD_CONSOLE
#elif defined(unix) || defined(__unix) || defined(__unix__)
#   define FPL_PLATFORM_UNIX
#   define FPL_PLATFORM_NAME "Unix"
#   define FPL_SUBPLATFORM_POSIX
#   define FPL_SUBPLATFORM_X11
#   define FPL_SUBPLATFORM_STD_STRINGS
#   define FPL_SUBPLATFORM_STD_CONSOLE
#else
#   error "This platform is not supported!"
#endif // FPL_PLATFORM
 
// Assembler keyword is compiler specific
#if defined(FPL_COMPILER_CLANG) || defined(FPL_COMPILER_GCC)
#define fpl__m_Asm __asm__
#elif defined(FPL_COMPILER_MSVC)
#define fpl__m_Asm __asm
#else
#define fpl__m_Asm asm
#endif
 
#define fplAsm fpl__m_Asm
 
// Minimum alignment
#if defined(FPL_COMPILER_MSVC)
#   define fpl__MinAlignment 8
#elif defined(FPL_COMPILER_GCC) || defined(FPL_COMPILER_CLANG)
#   if defined(FPL_CPU_64BIT)
#       define fpl__MinAlignment 8
#   else
#       define fpl__MinAlignment 4
#   endif
#else
#   define fpl__MinAlignment 8
#endif
#define fplMinAlignment fpl__MinAlignment
 
// Alignment keyword
#if defined(FPL_IS_CPP11)
#define fpl__m_AlignAs(N) alignas(N)
#elif defined(FPL_COMPILER_MSVC)
#define fpl__m_AlignAs(N) __declspec(align(N))
#elif defined(FPL_COMPILER_GCC) || defined(FPL_COMPILER_CLANG)
#define fpl__m_AlignAs(N) __attribute__((aligned(N)))
#else
#define fpl__m_AlignAs(N)
#endif
#define fpl__m_AlignAsAuto(N) fpl__m_AlignAs(((N) < fplMinAlignment ? fplMinAlignment : (N)))
 
#define fplAlignAs(N) fpl__m_AlignAsAuto(N)
 
//
// Defines required for POSIX (mmap, 64-bit file io, etc.)
//
#if defined(FPL_SUBPLATFORM_POSIX)
#   if !defined(_XOPEN_SOURCE)
#       define _XOPEN_SOURCE 600
#   endif
#   if !defined(_DEFAULT_SOURCE)
#       define _DEFAULT_SOURCE 1
#   endif
#   if !defined(__STDC_FORMAT_MACROS)
#       define __STDC_FORMAT_MACROS
#   endif
#   if !defined(__STDC_LIMIT_MACROS)
#       define __STDC_LIMIT_MACROS
#   endif
#   if !defined(_LARGEFILE_SOURCE)
#       define _LARGEFILE_SOURCE
#   endif
#   if !defined(_LARGEFILE64_SOURCE)
#       define _LARGEFILE64_SOURCE
#   endif
#   if !defined(_FILE_OFFSET_BITS)
#       define _FILE_OFFSET_BITS 64
#   endif
#endif
 
#if defined(FPL_PLATFORM_LINUX)
#   define FPL__INCLUDE_ALLOCA
#else
#   define FPL__INCLUDE_MALLOC
#endif
 
// MingW compiler hack
#if defined(FPL_PLATFORM_WINDOWS) && defined(FPL_COMPILER_MINGW)
#   if !defined(_WIN32_WINNT)
#       define _WIN32_WINNT 0x0600
#   endif 
#endif // FPL_COMPILER_MINGW
 
//
// Storage class identifiers
//
 
#define fpl_globalvar static
#define fpl_localvar static
#define fpl_internal static
#define fpl_inline inline
#define fpl_internal_inline inline
#if defined(FPL_IS_CPP)
#   define fpl_extern
#else
#   define fpl_extern extern
#endif
 
//
// DLL Export/Import definition
//
#if defined(_WIN32) || defined(__CYGWIN__)
#   ifdef __GNUC__
#       define fpl__m_dllexport __attribute__ ((dllexport))
#       define fpl__m_dllimport __attribute__ ((dllimport))
#   else
#       define fpl__m_dllexport __declspec(dllexport)
#       define fpl__m_dllimport __declspec(dllimport)
#   endif
#   define fpl__m_dlllocal
#else
#   if __GNUC__ >= 4
#       define fpl__m_dllimport __attribute__((visibility("default")))
#       define fpl__m_dllexport __attribute__((visibility("default")))
#       define fpl__m_dlllocal __attribute__((visibility("hidden")))
#   else
#       define fpl__m_dllimport
#       define fpl__m_dllexport
#       define fpl__m_dlllocal
#   endif
#endif
 
#define fpl_dllimport fpl__m_dllimport
#define fpl_dllexport fpl__m_dllexport
#define fpl_dlllocal fpl__m_dlllocal
 
//
// API Call
//
#if defined(FPL_API_AS_PRIVATE)
#   define fpl__m_api static
#elif defined(FPL_DLLEXPORT)
#   define fpl__m_api fpl_dllexport
#elif defined(FPL_DLLIMPORT)
#   define fpl__m_api fpl_dllimport
#else
#   define fpl__m_api fpl_extern
#endif // FPL_API_AS_PRIVATE
 
#define fpl_api fpl__m_api
 
#define fpl_main
 
#if defined(FPL_IS_CPP)
#   define fpl__m_platform_api extern "C" fpl_api
#   define fpl__m_common_api extern "C" fpl_api
#else
#   define fpl__m_platform_api fpl_api
#   define fpl__m_common_api fpl_api
#endif
 
#define fpl_platform_api fpl__m_platform_api
#define fpl_common_api fpl__m_common_api
 
//
// Inlining
//
#if defined(FPL_COMPILER_MSVC)
#   define fpl__m_force_inline __forceinline
#   define fpl__m_no_inline __declspec(noinline)
#elif defined(FPL_COMPILER_GCC) || defined(FPL_COMPILER_CLANG)
#   define fpl__m_force_inline __attribute__((__always_inline__)) inline
#   define fpl__m_no_inline __attribute__((noinline))
#else
#   define fpl__m_force_inline inline
#   define fpl__m_no_inline
#endif
 
#define fpl_force_inline fpl__m_force_inline
#define fpl_no_inline fpl__m_no_inline
 
//
// When C-Runtime is disabled we cannot use any function from the C-Standard Library <stdio.h> or <stdlib.h>
//
#if defined(FPL_NO_CRT)
#   if defined(FPL_SUBPLATFORM_STD_CONSOLE)
#       undef FPL_SUBPLATFORM_STD_CONSOLE
#   endif
#   if defined(FPL_SUBPLATFORM_STD_STRINGS)
#       undef FPL_SUBPLATFORM_STD_STRINGS
#   endif
#   if !defined(FPL_USERFUNC_vsnprintf)
#       error "You need to provide a replacement for vsnprintf() by defining FPL_USERFUNC_vsnprintf!"
#   endif
#endif
 
//
// Application type detection
// - Can be disabled by FPL_NO_APPTYPE
// - Must be explicitly set for No-CRT on Win32
//
#if defined(FPL_APPTYPE_CONSOLE) && defined(FPL_APPTYPE_WINDOW)
#   error "Its now allowed to define both FPL_APPTYPE_CONSOLE and FPL_APPTYPE_WINDOW!"
#endif
#if defined(FPL_NO_CRT)
#   if !defined(FPL_APPTYPE_CONSOLE) && !defined(FPL_APPTYPE_WINDOW)
#       error "In 'No-CRT' mode you need to define either FPL_APPTYPE_CONSOLE or FPL_APPTYPE_WINDOW manually!"
#   endif
#elif !defined(FPL_NO_APPTYPE) && !(defined(FPL_APPTYPE_CONSOLE) || defined(FPL_APPTYPE_WINDOW))
#   if !defined(FPL_NO_WINDOW)
#       define FPL_APPTYPE_WINDOW
#   else
#       define FPL_APPTYPE_CONSOLE
#   endif
#endif
 
//
// Include entry points always when its not disabled and implementation block is compiled in
//
#if defined(FPL_IMPLEMENTATION) && !defined(FPL_NO_ENTRYPOINT)
#   define FPL_ENTRYPOINT
#endif
 
//
// Debug/Release detection
//
#if defined(FPL_DEBUG)
#   define FPL__ENABLE_DEBUG
#elif defined(FPL_RELEASE)
#   define FPL__ENABLE_RELEASE
#endif
 
//
// Compiler settings
//
#if defined(FPL_COMPILER_MSVC)
    // Debug/Release detection
#   if !defined(FPL__ENABLE_DEBUG) && !defined(FPL__ENABLE_RELEASE)
#       if defined(_DEBUG) || (!defined(NDEBUG))
#           define FPL__ENABLE_DEBUG
#       else
#           define FPL__ENABLE_RELEASE
#       endif
#   endif
 
    // Function name macro (Win32)
#   define FPL__M_FUNCTION_NAME __FUNCTION__
 
    // Setup MSVC subsystem hints
#   if defined(FPL_APPTYPE_WINDOW)
#       pragma comment(linker, "/SUBSYSTEM:WINDOWS")
#   elif defined(FPL_APPTYPE_CONSOLE)
#       pragma comment(linker, "/SUBSYSTEM:CONSOLE")
#   endif
 
    // Setup MSVC linker hints
#   pragma comment(lib, "kernel32.lib")
#else
    // Function name macro (Other compilers)
#   define FPL__M_FUNCTION_NAME __FUNCTION__
#endif // FPL_COMPILER
 
// Debug Release fallback
#if !defined(FPL__ENABLE_DEBUG) && !defined(FPL__ENABLE_RELEASE)
#   define FPL__ENABLE_DEBUG
#endif
 
#if defined(__INTELLISENSE__) || defined(__JETBRAINS_IDE__)
#   define FPL_IS_IDE 1
#else
#   define FPL_IS_IDE 0
#endif
 
#define FPL_FUNCTION_NAME FPL__M_FUNCTION_NAME
 
//
// Options & Feature detection
//
 
//
// CPU Instruction Set Detection based on compiler settings
//
#if defined(__AVX512F__)
#   define FPL__COMPILED_X86_CPU_INSTR_SET 9
#elif defined(__AVX2__)
#   define FPL__COMPILED_X86_CPU_INSTR_SET 8
#elif defined(__AVX__)
#   define FPL__COMPILED_X86_CPU_INSTR_SET 7
#elif defined(__SSE4_2__)
#   define FPL__COMPILED_X86_CPU_INSTR_SET 6
#elif defined(__SSE4_1__)
#   define FPL__COMPILED_X86_CPU_INSTR_SET 5
#elif defined(__SSSE3__)
#   define FPL__COMPILED_X86_CPU_INSTR_SET 4
#elif defined(__SSE3__)
#   define FPL__COMPILED_X86_CPU_INSTR_SET 3
#elif defined(__SSE2__) || (_M_IX86_FP >= 2)
#   define FPL__COMPILED_X86_CPU_INSTR_SET 2
#elif defined(__SSE__) || (_M_IX86_FP >= 1)
#   define FPL__COMPILED_X86_CPU_INSTR_SET 1
#elif defined(_M_IX86_FP)
#   define FPL__COMPILED_X86_CPU_INSTR_SET _M_IX86_FP
#else
#   define FPL__COMPILED_X86_CPU_INSTR_SET 0
#endif
 
//
// Assertions
//
#if !defined(FPL_NO_ASSERTIONS)
#   if !defined(FPL_FORCE_ASSERTIONS)
#       if defined(FPL__ENABLE_DEBUG)
#           define FPL__ENABLE_ASSERTIONS
#       endif
#   else
#       define FPL__ENABLE_ASSERTIONS
#   endif
#endif // !FPL_NO_ASSERTIONS
#if defined(FPL__ENABLE_ASSERTIONS)
#   if !defined(FPL_NO_C_ASSERT) && !defined(FPL_NO_CRT)
#       define FPL__ENABLE_C_ASSERT
#   endif
#endif // FPL__ENABLE_ASSERTIONS
 
//
// HasInclude
//
#if defined(__has_include)
#   define fpl__m_HasInclude(inc) __has_include(inc)
#else
#   define fpl__m_HasInclude(inc) (1)
#endif
#define fplHasInclude(inc) fpl__m_HasInclude(inc)
 
//
// Window
//
#if !defined(FPL_NO_WINDOW) && !defined(FPL_APPTYPE_CONSOLE)
#   define FPL__SUPPORT_WINDOW
#endif
 
//
// Video
//
#if !defined(FPL_NO_VIDEO)
#   define FPL__SUPPORT_VIDEO
#endif
#if defined(FPL__SUPPORT_VIDEO)
#   if !defined(FPL_NO_VIDEO_OPENGL)
#       define FPL__SUPPORT_VIDEO_OPENGL
#   endif
#   if !defined(FPL_NO_VIDEO_VULKAN)
#       define FPL__SUPPORT_VIDEO_VULKAN
#   endif
#   if !defined(FPL_NO_VIDEO_SOFTWARE)
#       define FPL__SUPPORT_VIDEO_SOFTWARE
#   endif
#endif // FPL__SUPPORT_VIDEO
 
//
// Audio
//
#if !defined(FPL_NO_AUDIO)
    // Audio support
#   define FPL__SUPPORT_AUDIO
#endif
#if defined(FPL__SUPPORT_AUDIO)
#   if !defined(FPL_NO_AUDIO_DIRECTSOUND) && defined(FPL_PLATFORM_WINDOWS)
#       define FPL__SUPPORT_AUDIO_DIRECTSOUND // <dsound.h> is always present on windows
#   endif
#   if !defined(FPL_NO_AUDIO_ALSA) && defined(FPL_PLATFORM_LINUX)
#       if fplHasInclude(<alsa/asoundlib.h>)
#           define FPL__SUPPORT_AUDIO_ALSA
#       else
#           warning "FPL-Warning: ALSA audio development library is missing. Please install 'libasound2-dev' and try again!"
#       endif
#   endif
#endif // FPL__SUPPORT_AUDIO
 
//
// Remove video support when the window is disabled
//
#if !defined(FPL__SUPPORT_WINDOW)
#   if defined(FPL_SUBPLATFORM_X11)
#       undef FPL_SUBPLATFORM_X11
#   endif
 
#   if defined(FPL__SUPPORT_VIDEO)
#       undef FPL__SUPPORT_VIDEO
#   endif
#   if defined(FPL__SUPPORT_VIDEO_OPENGL)
#       undef FPL__SUPPORT_VIDEO_OPENGL
#   endif
#   if defined(FPL__SUPPORT_VIDEO_VULKAN)
#       undef FPL__SUPPORT_VIDEO_VULKAN
#   endif
#   if defined(FPL__SUPPORT_VIDEO_SOFTWARE)
#       undef FPL__SUPPORT_VIDEO_SOFTWARE
#   endif
#endif // !FPL__SUPPORT_WINDOW
 
//
// Enable supports (FPL uses _ENABLE_ internally only)
//
#if defined(FPL__SUPPORT_WINDOW)
#   define FPL__ENABLE_WINDOW
#endif
 
#if defined(FPL__SUPPORT_VIDEO)
#   define FPL__ENABLE_VIDEO
#   if defined(FPL__SUPPORT_VIDEO_OPENGL)
#       define FPL__ENABLE_VIDEO_OPENGL
#   endif
#   if defined(FPL__SUPPORT_VIDEO_VULKAN)
#       define FPL__ENABLE_VIDEO_VULKAN
#   endif
#   if defined(FPL__SUPPORT_VIDEO_SOFTWARE)
#       define FPL__ENABLE_VIDEO_SOFTWARE
#   endif
#endif // FPL__SUPPORT_VIDEO
 
#if defined(FPL__SUPPORT_AUDIO)
#   define FPL__ENABLE_AUDIO
#   if defined(FPL__SUPPORT_AUDIO_DIRECTSOUND)
#       define FPL__ENABLE_AUDIO_DIRECTSOUND
#   endif
#   if defined(FPL__SUPPORT_AUDIO_ALSA)
#       define FPL__ENABLE_AUDIO_ALSA
#   endif
#endif // FPL__SUPPORT_AUDIO
 
#if defined(FPL_LOGGING)
#   define FPL__ENABLE_LOGGING
#   if defined(FPL_LOG_MULTIPLE_WRITERS)
#       define FPL__ENABLE_LOG_MULTIPLE_WRITERS
#   endif
#endif
 
//
// Assertions & Debug
//
 
#if defined(FPL__ENABLE_ASSERTIONS)
#   if defined(FPL__ENABLE_C_ASSERT) && !defined(FPL_FORCE_ASSERTIONS)
#       define FPL__INCLUDE_ASSERT
#       define fpl__m_Assert(exp) assert(exp)
#       if defined(__cplusplus)
#           define fpl__m_StaticAssert(exp) static_assert(exp, "fpl_static_assert")
#       endif
#   else
#       define fpl__m_Assert(exp) if(!(exp)) {*(int *)0 = 0;}
#   endif // FPL__ENABLE_C_ASSERT
#   if !defined(fpl__m_StaticAssert)
#       define FPL__M_STATICASSERT_0(exp, line, counter) \
            int fpl__ct_assert_##line_##counter(int ct_assert_failed[(exp)?1:-1])
#       define fpl__m_StaticAssert(exp) \
            FPL__M_STATICASSERT_0(exp, __LINE__, __COUNTER__)
#   endif
#else
#   define fpl__m_Assert(exp)
#   define fpl__m_StaticAssert(exp)
#endif // FPL__ENABLE_ASSERTIONS
 
#define fplAssert(exp) fpl__m_Assert(exp)
#define fplStaticAssert(exp) fpl__m_StaticAssert(exp)
#define fplAlwaysAssert(exp) if(!(exp)) {*(int *)0 = 0;}
#define fplAssertPtr(ptr) fpl__m_Assert((ptr) != fpl_null)
 
//
// Debug-Break
// Based on: https://stackoverflow.com/questions/173618/is-there-a-portable-equivalent-to-debugbreak-debugbreak
//
#if defined(__has_builtin)
#   if __has_builtin(__builtin_debugtrap)
#       define fpl__m_DebugBreak() __builtin_debugtrap()
#   elif __has_builtin(__debugbreak)
#       define fpl__m_DebugBreak() __debugbreak()
#   endif
#endif
#if !defined(fpl__m_DebugBreak)
#   if defined(FPL_COMPILER_MSVC) || defined(FPL_COMPILER_INTEL)
#       define fpl__m_DebugBreak() __debugbreak()
#   elif defined(FPL_COMPILER_ARM)
#       define fpl__m_DebugBreak() __breakpoint(42)
#   elif defined(FPL_ARCH_X86) || defined(FPL_ARCH_X64)
fpl_internal fpl_force_inline void fpl__m_DebugBreak() { __asm__ __volatile__("int $03"); }
#   elif defined(__thumb__)
fpl_internal fpl_force_inline void fpl__m_DebugBreak() { __asm__ __volatile__(".inst 0xde01"); }
#   elif defined(FPL_ARCH_ARM64)
fpl_internal fpl_force_inline void fpl__m_DebugBreak() { __asm__ __volatile__(".inst 0xd4200000"); }
#   elif defined(FPL_ARCH_ARM32)
fpl_internal fpl_force_inline void fpl__m_DebugBreak() { __asm__ __volatile__(".inst 0xe7f001f0"); }
#   elif defined(FPL_COMPILER_GCC)
#       define fpl__m_DebugBreak() __builtin_trap()
#   else
#       define FPL__INCLUDE_SIGNAL
#       if defined(SIGTRAP)
#           define fpl__m_DebugBreak() raise(SIGTRAP)
#       else
#           define fpl__m_DebugBreak() raise(SIGABRT)
#       endif
#   endif
#endif
 
#define fplDebugBreak() fpl__m_DebugBreak()
 
//
// Memory macros
//
 
#if !defined(FPL_NO_MEMORY_MACROS) || defined(FPL_FORCE_MEMORY_MACROS)
#   define FPL__ENABLE_MEMORY_MACROS
#endif
 
//
// Types & Limits
//
#include <stdint.h> // uint32_t, ...
#include <stddef.h> // size_t
#include <stdbool.h> // bool
#include <stdarg.h> // va_start, va_end, va_list, va_arg
#include <limits.h> // UINT32_MAX, ...
#if defined(FPL__INCLUDE_ASSERT)
#   include <assert.h>
#endif
#if defined(FPL__INCLUDE_SIGNAL)
#   include <signal.h>
#endif
#if defined(FPL__INCLUDE_MALLOC)
#   include <malloc.h>
#endif
#if defined(FPL__INCLUDE_ALLOCA)
#   include <alloca.h>
#endif
 
#if !defined(UINT32_MAX)
    // On android or older posix versions there is no UINT32_MAX
#   define UINT32_MAX ((uint32_t)-1)
#endif
 
#if defined(FPL_IS_CPP11)
#   define fpl__m_null nullptr
#elif defined(NULL)
#   define fpl__m_null NULL
#else
#   define fpl__m_null 0
#endif
#define fpl_null fpl__m_null
 
typedef int32_t fpl_b32;
 
//
// Test sizes
//
#if defined(FPL_CPU_64BIT)
fplStaticAssert(sizeof(uintptr_t) >= sizeof(uint64_t));
fplStaticAssert(sizeof(size_t) >= sizeof(uint64_t));
#elif defined(FPL_CPU_32BIT)
fplStaticAssert(sizeof(uintptr_t) >= sizeof(uint32_t));
fplStaticAssert(sizeof(size_t) >= sizeof(uint32_t));
#endif
 
//
// Macro functions
//
 
#define FPL_NOT_IMPLEMENTED {*(int *)0 = 0xBAD;}
 
#if defined(FPL_IS_C99)
#   define fpl__m_ZeroInit {0}
#   define fpl__m_StructSet(ptr, type, value) *(ptr) = (type)value
#   define fpl__m_StructInit(type, ...) (type){__VA_ARGS__}
#else
#   define fpl__m_ZeroInit {}
#   define fpl__m_StructSet(ptr, type, value) *(ptr) = value
#   define fpl__m_StructInit(type, ...) {__VA_ARGS__}
#endif
 
#define fplZeroInit fpl__m_ZeroInit
#define fplStructSet fpl__m_StructSet
#define fplStructInit fpl__m_StructInit
 
#define fplGetAlignmentOffset(value, alignment) ( (((alignment) > 1) && (((value) & ((alignment) - 1)) != 0)) ? ((alignment) - ((value) & (alignment - 1))) : 0)            
#define fplGetAlignedSize(size, alignment) (((size) > 0 && (alignment) > 0) ? ((size) + fplGetAlignmentOffset(size, alignment)) : (size))
#define fplIsAligned(ptr, alignment) (((uintptr_t)(const void *)(ptr)) % (alignment) == 0)
#define fplIsPowerOfTwo(value) (((value) != 0) && (((value) & (~(value) + 1)) == (value)))
#define fplIsBigEndian() (*(uint16_t *)"\0\xff" < 0x100)
#define fplIsLittleEndian() (!fplIsBigEndian())
#define fplIsBitSet(value, bit) (((value) >> (bit)) & 0x1)
 
#define fplKiloBytes(value) (((value) * 1024ull))
#define fplMegaBytes(value) ((fplKiloBytes(value) * 1024ull))
#define fplGigaBytes(value) ((fplMegaBytes(value) * 1024ull))
#define fplTeraBytes(value) ((fplGigaBytes(value) * 1024ull))
 
#define fplClearStruct(ptr) fplMemoryClear((void *)(ptr), sizeof(*(ptr)))
#define fplCopyStruct(src, dst) fplMemoryCopy(src, sizeof(*(src)), dst);
 
// Array count
#if defined(FPL_COMPILER_MSVC) && !defined(FPL_NO_CRT) // @TODO(final): Find a better way to detect no-crt inclusion!
#   define fpl__m_ArrayCount(arr) _countof(arr)
#elif defined(ARRAY_SIZE)
#   define fpl__m_ArrayCount(arr) ARRAY_SIZE(arr)
#else
#   define FPL__NO_ARRAYCOUNT_VALIDATION
#   define fpl__m_ArrayCount(arr) (sizeof(arr) / sizeof((arr)[0]))
#endif
#define fplArrayCount(arr) fpl__m_ArrayCount(arr)
 
#define fplOffsetOf(type, field) ((size_t)(&(((type*)(0))->field)))
 
#define fplMin(a, b) ((a) < (b) ? (a) : (b))
 
#define fplMax(a, b) ((a) > (b) ? (a) : (b))
 
#if defined(FPL_PLATFORM_WINDOWS)
#   define fpl__m_StackAllocate(size) _alloca(size)
#else
#   define fpl__m_StackAllocate(size) alloca(size)
#endif
 
#define fplStackAllocate(size) fpl__m_StackAllocate(size)
 
#if defined(FPL_IS_CPP)
#   define FPL__M_ENUM_AS_FLAGS_OPERATORS(etype) \
    inline etype operator | (etype a, etype b) { \
        return static_cast<etype>(static_cast<int>(a) | static_cast<int>(b)); \
    } \
    inline etype& operator |= (etype &a, etype b) { \
        return a = a | b; \
    } \
    inline etype operator & (etype a, etype b) { \
        return static_cast<etype>(static_cast<int>(a) & static_cast<int>(b)); \
    } \
    inline etype& operator &= (etype &a, etype b) { \
        return a = a & b; \
    } \
    inline etype operator ~ (etype a) { \
        return static_cast<etype>(~static_cast<int>(a)); \
    } \
    inline etype operator ^ (etype a, etype b) { \
        return static_cast<etype>(static_cast<int>(a) ^ static_cast<int>(b)); \
    } \
    inline etype& operator ^= (etype &a, etype b) { \
        return a = a ^ b; \
    }
#else
#   define FPL__M_ENUM_AS_FLAGS_OPERATORS(etype)
#endif
 
#define FPL_ENUM_AS_FLAGS_OPERATORS(type) FPL__M_ENUM_AS_FLAGS_OPERATORS(type)
 
// ****************************************************************************
//
// Platform Includes
//
// ****************************************************************************
#if !defined(FPL_NO_PLATFORM_INCLUDES) && !defined(FPL__HAS_PLATFORM_INCLUDES)
#   define FPL__HAS_PLATFORM_INCLUDES
 
#   if defined(FPL_PLATFORM_WINDOWS)
        // @NOTE(final): windef.h defines min/max macros in lowerspace, this will break for example std::min/max, so we have to tell the header we dont want this!
#       if !defined(NOMINMAX)
#           define NOMINMAX
#       endif
        // @NOTE(final): For now we dont want any network, com or gdi stuff at all, maybe later who knows.
#       if !defined(WIN32_LEAN_AND_MEAN)
#           define WIN32_LEAN_AND_MEAN 1
#       endif
        // @STUPID(final): Workaround for "combaseapi.h(229): error C2187: syntax error: 'identifier' was unexpected here"
struct IUnknown;
#       include <windows.h> // Win32 api
#       if _WIN32_WINNT < 0x0600
#           error "Windows Vista or higher required!"
#       endif
#   endif // FPL_PLATFORM_WINDOWS
 
#   if defined(FPL_SUBPLATFORM_POSIX)
#       include <pthread.h> // pthread_t, pthread_mutex_, pthread_cond_, pthread_barrier_
#       include <sched.h> // sched_param, sched_get_priority_max, SCHED_FIFO
#       include <semaphore.h> // sem_t
#       include <dirent.h> // DIR, dirent
#   endif // FPL_SUBPLATFORM_POSIX
 
#   if defined(FPL_SUBPLATFORM_X11)
#       include <X11/X.h> // Window
#       include <X11/Xlib.h> // Display
#       include <X11/Xutil.h> // XVisualInfo
#       include <X11/Xatom.h> // XA_CARDINAL
#   endif // FPL_SUBPLATFORM_X11
 
#endif // !FPL_NO_PLATFORM_INCLUDES
 
//
// Platform handles
//
#if !defined(FPL__HAS_PLATFORM_INCLUDES) || defined(FPL_OPAQUE_HANDLES)
 
#   if defined(FPL_PLATFORM_WINDOWS)
 
typedef uint64_t fpl__Win32Guid[4];
typedef void *fpl__Win32Handle;
typedef fpl__Win32Handle fpl__Win32InstanceHandle;
typedef fpl__Win32Handle fpl__Win32LibraryHandle;
typedef fpl__Win32Handle fpl__Win32FileHandle;
typedef fpl__Win32Handle fpl__Win32ThreadHandle;
typedef uint64_t fpl__Win32MutexHandle[16];
typedef fpl__Win32Handle fpl__Win32SignalHandle;
typedef void *fpl__Win32ConditionVariable;
typedef fpl__Win32Handle fpl__Win32SemaphoreHandle;
typedef fpl__Win32Handle fpl__Win32WindowHandle;
typedef fpl__Win32Handle fpl__Win32DeviceContext;
typedef fpl__Win32Handle fpl__Win32RenderingContext;
typedef union fpl__Win32LargeInteger {
    int64_t QuadPart;
    struct {
        int32_t LowPart;
        int32_t HighPart;
    };
} fpl__Win32LargeInteger;
 
#   endif // FPL_PLATFORM_WINDOWS
 
#   if defined(FPL_SUBPLATFORM_POSIX)
 
typedef void *fpl__POSIXLibraryHandle;
typedef int fpl__POSIXFileHandle;
typedef void *fpl__POSIXDirHandle;
typedef uint64_t fpl__POSIXThreadHandle;
typedef uint64_t fpl__POSIXMutexHandle[16];
typedef uint64_t fpl__POSIXSemaphoreHandle[8];
typedef uint64_t fpl__POSIXConditionVariable[16];
 
#   endif // FPL_SUBPLATFORM_POSIX
 
#   if defined(FPL_SUBPLATFORM_X11)
 
typedef void *fpl__X11Display;
typedef int fpl__X11Window;
typedef void *fpl__X11Visual;
typedef void *fpl__X11GC;
typedef void *fpl__X11Image;
typedef void *fpl__GLXContext;
 
#   endif // FPL_SUBPLATFORM_X11
 
#   if defined(FPL_PLATFORM_LINUX)
 
typedef int fpl__LinuxSignalHandle;
 
#   endif // FPL_PLATFORM_LINUX
 
#else
 
#   if defined(FPL_PLATFORM_WINDOWS)
 
typedef GUID fpl__Win32Guid;
typedef HANDLE fpl__Win32Handle;
typedef HINSTANCE fpl__Win32InstanceHandle;
typedef HMODULE fpl__Win32LibraryHandle;
typedef HANDLE fpl__Win32ThreadHandle;
typedef HANDLE fpl__Win32FileHandle;
typedef CRITICAL_SECTION fpl__Win32MutexHandle;
typedef HANDLE fpl__Win32SignalHandle;
typedef CONDITION_VARIABLE fpl__Win32ConditionVariable;
typedef HANDLE fpl__Win32SemaphoreHandle;
typedef HWND fpl__Win32WindowHandle;
typedef HDC fpl__Win32DeviceContext;
typedef HGLRC fpl__Win32RenderingContext;
typedef LARGE_INTEGER fpl__Win32LargeInteger;
 
#   endif // FPL_PLATFORM_WINDOWS
 
#   if defined(FPL_SUBPLATFORM_POSIX)
 
typedef void *fpl__POSIXLibraryHandle;
typedef int fpl__POSIXFileHandle;
typedef DIR *fpl__POSIXDirHandle;
typedef pthread_t fpl__POSIXThreadHandle;
typedef pthread_mutex_t fpl__POSIXMutexHandle;
typedef sem_t fpl__POSIXSemaphoreHandle;
typedef pthread_cond_t fpl__POSIXConditionVariable;
 
#   endif // FPL_SUBPLATFORM_POSIX
 
#   if defined(FPL_SUBPLATFORM_X11)
 
typedef Display *fpl__X11Display;
typedef Window fpl__X11Window;
typedef Visual *fpl__X11Visual;
typedef GC fpl__X11GC;
typedef XImage *fpl__X11Image;
typedef void *fpl__GLXContext;
 
#   endif // FPL_SUBPLATFORM_X11
 
 
#   if defined(FPL_PLATFORM_LINUX)
 
typedef int fpl__LinuxSignalHandle;
 
#   endif // FPL_PLATFORM_LINUX
 
 
#endif
 
//
// Constants
//
 
#if defined(FPL_PLATFORM_WINDOWS)
#   if defined(MAX_PATH)
#       define FPL__M_MAX_FILENAME_LENGTH (MAX_PATH)
#       define FPL__M_MAX_PATH_LENGTH (MAX_PATH * 2)
#   else
#       define FPL__M_MAX_FILENAME_LENGTH (260)
#       define FPL__M_MAX_PATH_LENGTH (260 * 2)
#   endif
#   define FPL__M_PATH_SEPARATOR '\\'
#   define FPL__M_FILE_EXT_SEPARATOR '.'
#else
#   define FPL__M_MAX_FILENAME_LENGTH (512)
#   define FPL__M_MAX_PATH_LENGTH (2048)
#   define FPL__M_PATH_SEPARATOR '/'
#   define FPL__M_FILE_EXT_SEPARATOR '.'
#endif
 
#define FPL_MAX_FILENAME_LENGTH FPL__M_MAX_FILENAME_LENGTH
#define FPL_MAX_PATH_LENGTH FPL__M_MAX_PATH_LENGTH
#define FPL_PATH_SEPARATOR FPL__M_PATH_SEPARATOR
#define FPL_FILE_EXT_SEPARATOR FPL__M_FILE_EXT_SEPARATOR
#define FPL_MAX_NAME_LENGTH (256)
#define FPL_MAX_BUFFER_LENGTH (2048)
 
// ****************************************************************************
//
// > API
//
// ****************************************************************************
 
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
 
//
// Barrier/Fence
//
 
fpl_platform_api void fplAtomicReadFence();
fpl_platform_api void fplAtomicWriteFence();
fpl_platform_api void fplAtomicReadWriteFence();
 
//
// Exchange
//
 
fpl_platform_api uint32_t fplAtomicExchangeU32(volatile uint32_t *target, const uint32_t value);
fpl_platform_api uint64_t fplAtomicExchangeU64(volatile uint64_t *target, const uint64_t value);
fpl_platform_api int32_t fplAtomicExchangeS32(volatile int32_t *target, const int32_t value);
fpl_platform_api int64_t fplAtomicExchangeS64(volatile int64_t *target, const int64_t value);
fpl_common_api void *fplAtomicExchangePtr(volatile void **target, const void *value);
fpl_common_api size_t fplAtomicExchangeSize(volatile size_t *target, const size_t value);
 
//
// Fetch and Add
//
 
fpl_platform_api uint32_t fplAtomicFetchAndAddU32(volatile uint32_t *value, const uint32_t addend);
fpl_platform_api uint64_t fplAtomicFetchAndAddU64(volatile uint64_t *value, const uint64_t addend);
fpl_platform_api int32_t fplAtomicFetchAndAddS32(volatile int32_t *value, const int32_t addend);
fpl_platform_api int64_t fplAtomicFetchAndAddS64(volatile int64_t *value, const int64_t addend);
fpl_common_api size_t fplAtomicFetchAndAddSize(volatile size_t *dest, const size_t addend);
fpl_common_api void *fplAtomicFetchAndAddPtr(volatile void **dest, const intptr_t addend);
 
//
// Add and Fetch
//
 
fpl_platform_api uint32_t fplAtomicAddAndFetchU32(volatile uint32_t *dest, const uint32_t addend);
fpl_platform_api uint64_t fplAtomicAddAndFetchU64(volatile uint64_t *dest, const uint64_t addend);
fpl_platform_api int32_t fplAtomicAddAndFetchS32(volatile int32_t *dest, const int32_t addend);
fpl_platform_api int64_t fplAtomicAddAndFetchS64(volatile int64_t *dest, const int64_t addend);
fpl_common_api size_t fplAtomicAddAndFetchSize(volatile size_t *dest, const size_t addend);
fpl_common_api void *fplAtomicAddAndFetchPtr(volatile void **dest, const intptr_t addend);
 
//
// Increment
//
 
fpl_platform_api uint32_t fplAtomicIncrementU32(volatile uint32_t *dest);
fpl_platform_api uint64_t fplAtomicIncrementU64(volatile uint64_t *dest);
fpl_platform_api int32_t fplAtomicIncrementS32(volatile int32_t *dest);
fpl_platform_api int64_t fplAtomicIncrementS64(volatile int64_t *dest);
fpl_common_api size_t fplAtomicIncrementSize(volatile size_t *dest);
fpl_common_api void *fplAtomicIncrementPtr(volatile void **dest);
 
//
// CAS
//
 
fpl_platform_api uint32_t fplAtomicCompareAndSwapU32(volatile uint32_t *dest, const uint32_t comparand, const uint32_t exchange);
fpl_platform_api uint64_t fplAtomicCompareAndSwapU64(volatile uint64_t *dest, const uint64_t comparand, const uint64_t exchange);
fpl_platform_api int32_t fplAtomicCompareAndSwapS32(volatile int32_t *dest, const int32_t comparand, const int32_t exchange);
fpl_platform_api int64_t fplAtomicCompareAndSwapS64(volatile int64_t *dest, const int64_t comparand, const int64_t exchange);
fpl_common_api size_t fplAtomicCompareAndSwapSize(volatile size_t *dest, const size_t comparand, const size_t exchange);
fpl_common_api void *fplAtomicCompareAndSwapPtr(volatile void **dest, const void *comparand, const void *exchange);
 
fpl_platform_api bool fplAtomicIsCompareAndSwapU32(volatile uint32_t *dest, const uint32_t comparand, const uint32_t exchange);
fpl_platform_api bool fplAtomicIsCompareAndSwapU64(volatile uint64_t *dest, const uint64_t comparand, const uint64_t exchange);
fpl_platform_api bool fplAtomicIsCompareAndSwapS32(volatile int32_t *dest, const int32_t comparand, const int32_t exchange);
fpl_platform_api bool fplAtomicIsCompareAndSwapS64(volatile int64_t *dest, const int64_t comparand, const int64_t exchange);
fpl_common_api bool fplAtomicIsCompareAndSwapSize(volatile size_t *dest, const size_t comparand, const size_t exchange);
fpl_common_api bool fplAtomicIsCompareAndSwapPtr(volatile void **dest, const void *comparand, const void *exchange);
 
//
// Load
//
 
fpl_platform_api uint32_t fplAtomicLoadU32(volatile uint32_t *source);
fpl_platform_api uint64_t fplAtomicLoadU64(volatile uint64_t *source);
fpl_platform_api int32_t fplAtomicLoadS32(volatile int32_t *source);
fpl_platform_api int64_t fplAtomicLoadS64(volatile int64_t *source);
fpl_common_api size_t fplAtomicLoadSize(volatile size_t *source);
fpl_common_api void *fplAtomicLoadPtr(volatile void **source);
 
//
// Store
//
 
fpl_platform_api void fplAtomicStoreU32(volatile uint32_t *dest, const uint32_t value);
fpl_platform_api void fplAtomicStoreU64(volatile uint64_t *dest, const uint64_t value);
fpl_platform_api void fplAtomicStoreS32(volatile int32_t *dest, const int32_t value);
fpl_platform_api void fplAtomicStoreS64(volatile int64_t *dest, const int64_t value);
fpl_common_api void fplAtomicStoreSize(volatile size_t *dest, const size_t value);
fpl_common_api void fplAtomicStorePtr(volatile void **dest, const void *value);
 
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
 
typedef struct fplMemoryBlock {
    void *base;
    size_t size;
} fplMemoryBlock;
 
typedef struct fplMemoryInfos {
    uint64_t installedPhysicalSize;
    uint64_t totalPhysicalSize;
    uint64_t freePhysicalSize;
    uint64_t totalCacheSize;
    uint64_t freeCacheSize;
    uint64_t totalPageCount;
    uint64_t freePageCount;
    uint64_t pageSize;
} fplMemoryInfos;
 
fpl_common_api void fplMemoryClear(void *mem, const size_t size);
fpl_common_api void fplMemorySet(void *mem, const uint8_t value, const size_t size);
fpl_common_api void fplMemoryCopy(const void *sourceMem, const size_t sourceSize, void *targetMem);
fpl_platform_api void *fplMemoryAllocate(const size_t size);
fpl_platform_api void fplMemoryFree(void *ptr);
fpl_common_api void *fplMemoryAlignedAllocate(const size_t size, const size_t alignment);
fpl_common_api void fplMemoryAlignedFree(void *ptr);
fpl_platform_api bool fplMemoryGetInfos(fplMemoryInfos *outInfos);
 
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
 
typedef char fplVersionNumberPart[4 + 1];
 
typedef struct fplVersionInfo {
    char fullName[FPL_MAX_NAME_LENGTH];
    union {
        fplVersionNumberPart values[4];
        struct {
            fplVersionNumberPart major;
            fplVersionNumberPart minor;
            fplVersionNumberPart fix;
            fplVersionNumberPart build;
        };
    };
} fplVersionInfo;
 
typedef struct fplOSVersionInfos {
    char osName[FPL_MAX_NAME_LENGTH];
    char distributionName[FPL_MAX_NAME_LENGTH];
    fplVersionInfo osVersion;
    fplVersionInfo distributionVersion;
} fplOSVersionInfos;
 
fpl_platform_api bool fplOSGetVersionInfos(fplOSVersionInfos *outInfos);
 
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
 
fpl_platform_api size_t fplSessionGetUsername(char *nameBuffer, const size_t maxNameBufferLen);
 
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
 
typedef enum fplCPUArchType {
    fplCPUArchType_Unknown = 0,
    fplCPUArchType_x86,
    fplCPUArchType_x86_64,
    fplCPUArchType_x64,
    fplCPUArchType_Arm32,
    fplCPUArchType_Arm64,
 
    fplCPUArchType_First = fplCPUArchType_Unknown,
    fplCPUArchType_Last = fplCPUArchType_Arm64,
} fplCPUArchType;
 
typedef struct fplCPUCapabilities {
    fpl_b32 hasMMX;
    fpl_b32 hasSSE;
    fpl_b32 hasSSE2;
    fpl_b32 hasSSE3;
    fpl_b32 hasSSSE3;
    fpl_b32 hasSSE4_1;
    fpl_b32 hasSSE4_2;
    fpl_b32 hasAVX;
    fpl_b32 hasAVX2;
    fpl_b32 hasAVX512;
    fpl_b32 hasFMA3;
} fplCPUCapabilities;
 
typedef union fplCPUIDLeaf {
    struct {
        uint32_t eax;
        uint32_t ebx;
        uint32_t ecx;
        uint32_t edx;
    };
    uint32_t raw[4];
} fplCPUIDLeaf;
 
fpl_common_api void fplCPUID(fplCPUIDLeaf *outLeaf, const uint32_t functionId);
fpl_common_api uint64_t fplCPUXCR0();
fpl_common_api uint64_t fplCPURDTSC();
fpl_common_api const char *fplCPUGetArchName(const fplCPUArchType type);
fpl_platform_api size_t fplCPUGetCoreCount();
fpl_common_api size_t fplCPUGetName(char *destBuffer, const size_t maxDestBufferLen);
fpl_common_api bool fplCPUGetCapabilities(fplCPUCapabilities *outCaps);
fpl_platform_api fplCPUArchType fplCPUGetArchitecture();
 
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
 
typedef enum fplInitFlags {
    fplInitFlags_None = 0,
    fplInitFlags_Console = 1 << 0,
    fplInitFlags_Window = 1 << 1,
    fplInitFlags_Video = 1 << 2,
    fplInitFlags_Audio = 1 << 3,
    fplInitFlags_GameController = 1 << 4,
    fplInitFlags_All = fplInitFlags_Console | fplInitFlags_Window | fplInitFlags_Video | fplInitFlags_Audio | fplInitFlags_GameController,
} fplInitFlags;
FPL_ENUM_AS_FLAGS_OPERATORS(fplInitFlags);
 
typedef enum fplPlatformType {
    fplPlatformType_Unknown = 0,
    fplPlatformType_Windows,
    fplPlatformType_Linux,
    fplPlatformType_Unix,
 
    fplPlatformType_First = fplPlatformType_Unknown,
    fplPlatformType_Last = fplPlatformType_Unix,
} fplPlatformType;
 
typedef enum fplPlatformResultType {
    fplPlatformResultType_FailedWindow = -6,
    fplPlatformResultType_FailedAudio = -5,
    fplPlatformResultType_FailedVideo = -4,
    fplPlatformResultType_FailedPlatform = -3,
    fplPlatformResultType_FailedAllocatingMemory = -2,
    fplPlatformResultType_AlreadyInitialized = -1,
    fplPlatformResultType_NotInitialized = 0,
    fplPlatformResultType_Success = 1,
 
    fplPlatformResultType_First = fplPlatformResultType_FailedWindow,
    fplPlatformResultType_Last = fplPlatformResultType_Success,
} fplPlatformResultType;
 
fpl_common_api const char *fplPlatformGetResultName(const fplPlatformResultType type);
 
typedef enum fplVideoBackendType {
    fplVideoBackendType_None = 0,
    fplVideoBackendType_Software,
    fplVideoBackendType_OpenGL,
    fplVideoBackendType_Vulkan,
 
    fplVideoBackendType_First = fplVideoBackendType_None,
    fplVideoBackendType_Last = fplVideoBackendType_Vulkan,
} fplVideoBackendType;
 
#if defined(FPL__ENABLE_VIDEO_OPENGL)
typedef enum fplOpenGLCompabilityFlags {
    fplOpenGLCompabilityFlags_Legacy = 0,
    fplOpenGLCompabilityFlags_Core = 1 << 1,
    fplOpenGLCompabilityFlags_Compability = 1 << 2,
    fplOpenGLCompabilityFlags_Forward = 1 << 3,
} fplOpenGLCompabilityFlags;
 
typedef struct fplOpenGLSettings {
    const char *libraryFile;
    fplOpenGLCompabilityFlags compabilityFlags;
    uint32_t majorVersion;
    uint32_t minorVersion;
    uint8_t multiSamplingCount;
} fplOpenGLSettings;
#endif // FPL__ENABLE_VIDEO_OPENGL
 
#if defined(FPL__ENABLE_VIDEO_VULKAN)
 
typedef void (fplVulkanValidationLayerCallback)(void *userData, const char *message, const uint32_t messageSeverity, const uint32_t messageType, const void *debugUtilsMessengerCallbackData);
 
typedef enum fplVulkanValidationLayerMode {
    fplVulkanValidationLayerMode_Disabled = 0,
    fplVulkanValidationLayerMode_Optional,
    fplVulkanValidationLayerMode_Required,
} fplVulkanValidationLayerMode;
 
typedef enum fplVulkanValidationSeverity {
    fplVulkanValidationSeverity_Off = 0,
    fplVulkanValidationSeverity_Error = 1,
    fplVulkanValidationSeverity_Warning = 2,
    fplVulkanValidationSeverity_Info = 3,
    fplVulkanValidationSeverity_Verbose = 4,
    fplVulkanValidationSeverity_All = INT32_MAX,
} fplVulkanValidationSeverity;
 
typedef struct fplVulkanSettings {
    fplVersionInfo appVersion;
    fplVersionInfo engineVersion;
    fplVersionInfo apiVersion;
    const char *libraryFile;
    const char *appName;
    const char *engineName;
    void *instanceHandle;
    const void *allocator;
    fplVulkanValidationLayerCallback *validationLayerCallback;
    void *userData;
    fplVulkanValidationLayerMode validationLayerMode;
    fplVulkanValidationSeverity validationSeverity;
} fplVulkanSettings;
#endif // FPL__ENABLE_VIDEO_VULKAN
 
typedef struct fplGraphicsApiSettings {
#if defined(FPL__ENABLE_VIDEO_OPENGL)
    fplOpenGLSettings opengl;
#endif
#if defined(FPL__ENABLE_VIDEO_VULKAN)
    fplVulkanSettings vulkan;
#endif
    int dummy;
} fplGraphicsApiSettings;
 
typedef struct fplVideoSettings {
    fplGraphicsApiSettings graphics;
    fplVideoBackendType backend;
    fpl_b32 isVSync;
    fpl_b32 isAutoSize;
} fplVideoSettings;
 
fpl_common_api void fplSetDefaultVideoSettings(fplVideoSettings *video);
 
typedef enum fplAudioBackendType {
    fplAudioBackendType_None = 0,
    fplAudioBackendType_Auto,
    fplAudioBackendType_DirectSound,
    fplAudioBackendType_Alsa,
 
    fplAudioBackendType_First = fplAudioBackendType_None,
    fplAudioBackendType_Last = fplAudioBackendType_Alsa,
} fplAudioBackendType;
 
typedef enum fplAudioFormatType {
    fplAudioFormatType_None = 0,
    fplAudioFormatType_U8,
    fplAudioFormatType_S16,
    fplAudioFormatType_S24,
    fplAudioFormatType_S32,
    fplAudioFormatType_S64,
    fplAudioFormatType_F32,
    fplAudioFormatType_F64,
 
    fplAudioFormatType_First = fplAudioFormatType_None,
    fplAudioFormatType_Last = fplAudioFormatType_F64,
} fplAudioFormatType;
 
typedef enum fplAudioDefaultFields {
    fplAudioDefaultFields_None = 0,
    fplAudioDefaultFields_BufferSize = 1 << 0,
    fplAudioDefaultFields_SampleRate = 1 << 1,
    fplAudioDefaultFields_Channels = 1 << 2,
    fplAudioDefaultFields_Periods = 1 << 3,
    fplAudioDefaultFields_Type = 1 << 4,
} fplAudioDefaultFields;
FPL_ENUM_AS_FLAGS_OPERATORS(fplAudioDefaultFields);
 
typedef enum fplAudioLatencyMode {
    fplAudioLatencyMode_Conservative = 0,
    fplAudioLatencyMode_Low,
} fplAudioLatencyMode;
 
typedef struct fplAudioDeviceFormat {
    uint32_t bufferSizeInFrames;
    uint32_t sampleRate;
    uint32_t channels;
    uint32_t periods;
    fplAudioFormatType type;
    fpl_b32 preferExclusiveMode;
    fplAudioDefaultFields defaultFields;
    fplAudioBackendType backend;
} fplAudioDeviceFormat;
 
typedef struct fplAudioTargetFormat {
    uint32_t sampleRate;
    uint32_t channels;
    uint32_t bufferSizeInFrames;
    uint32_t bufferSizeInMilliseconds;
    uint32_t periods;
    fplAudioFormatType type;
    fplAudioLatencyMode latencyMode;
    fpl_b32 preferExclusiveMode;
} fplAudioTargetFormat;
 
typedef union fplAudioDeviceID {
#if defined(FPL__ENABLE_AUDIO_DIRECTSOUND)
    fpl__Win32Guid dshow;
#endif
#if defined(FPL__ENABLE_AUDIO_ALSA)
    char alsa[256];
#endif
    int dummy;
} fplAudioDeviceID;
 
typedef struct fplAudioDeviceInfo {
    char name[FPL_MAX_NAME_LENGTH];
    fplAudioDeviceID id;
} fplAudioDeviceInfo;
 
#if defined(FPL__ENABLE_AUDIO_ALSA)
typedef struct fplAlsaAudioSettings {
    fpl_b32 noMMap;
} fplAlsaAudioSettings;
#endif
 
typedef union fplSpecificAudioSettings {
#if defined(FPL__ENABLE_AUDIO_ALSA)
    fplAlsaAudioSettings alsa;
#endif
    int dummy;
} fplSpecificAudioSettings;
 
typedef uint32_t(fpl_audio_client_read_callback)(const fplAudioDeviceFormat *deviceFormat, const uint32_t frameCount, void *outputSamples, void *userData);
 
typedef struct fplAudioSettings {
    fplAudioTargetFormat targetFormat;
    fplAudioDeviceInfo targetDevice;
    fplSpecificAudioSettings specific;
    fpl_audio_client_read_callback *clientReadCallback;
    void *userData;
    fplAudioBackendType backend;
    fpl_b32 startAuto;
    fpl_b32 stopAuto;
} fplAudioSettings;
 
fpl_common_api void fplSetDefaultAudioSettings(fplAudioSettings *audio);
 
typedef enum fplImageType {
    fplImageType_None = 0,
    fplImageType_RGBA,
} fplImageType;
 
typedef struct fplImageSource {
    const uint8_t *data;
    uint32_t width;
    uint32_t height;
    fplImageType type;
} fplImageSource;
 
typedef bool (fpl_window_event_callback)(const fplPlatformType platformType, void *windowState, void *rawEventData, void *userData);
 
typedef fpl_window_event_callback fpl_window_exposed_callback;
 
typedef struct fplWindowCallbacks {
    fpl_window_exposed_callback *exposedCallback;
    void *exposedUserData;
    fpl_window_event_callback *eventCallback;
    void *eventUserData;
} fplWindowCallbacks;
 
typedef struct fplWindowSize {
    uint32_t width;
    uint32_t height;
} fplWindowSize;
 
typedef struct fplWindowPosition {
    int32_t left;
    int32_t top;
} fplWindowPosition;
 
typedef union fplColor32 {
    struct {
        uint8_t b;
        uint8_t g;
        uint8_t r;
        uint8_t a;
    };
    uint32_t value;
    uint8_t m[4];
} fplColor32;
 
fpl_inline fplColor32 fplCreateColorRGBA(const uint8_t r, const uint8_t g, const uint8_t b, const uint8_t a) {
    fplColor32 result = fplStructInit(fplColor32, b, g, r, a);
    return(result);
}
 
typedef struct fplWindowSettings {
    char title[FPL_MAX_NAME_LENGTH];
    fplImageSource icons[2];
    fplWindowCallbacks callbacks;
    fplColor32 background;
    fplWindowSize windowSize;
    fplWindowSize fullscreenSize;
    uint32_t fullscreenRefreshRate;
    fpl_b32 isResizable;
    fpl_b32 isDecorated;
    fpl_b32 isFloating;
    fpl_b32 isFullscreen;
    fpl_b32 isScreenSaverPrevented;
    fpl_b32 isMonitorPowerPrevented;
} fplWindowSettings;
 
fpl_common_api void fplSetDefaultWindowSettings(fplWindowSettings *window);
 
typedef struct fplConsoleSettings {
    char title[FPL_MAX_NAME_LENGTH];
} fplConsoleSettings;
 
fpl_common_api void fplSetDefaultConsoleSettings(fplConsoleSettings *console);
 
typedef struct fplInputSettings {
    uint32_t controllerDetectionFrequency;
    fpl_b32 disabledEvents;
} fplInputSettings;
 
fpl_common_api void fplSetDefaultInputSettings(fplInputSettings *input);
 
typedef void *(fpl_memory_allocate_callback)(void *userData, const size_t size, const size_t alignment);
typedef void (fpl_memory_release_callback)(void *userData, void *ptr);
 
typedef enum fplMemoryAllocationMode {
    fplMemoryAllocationMode_Automatic = 0,
    fplMemoryAllocationMode_Custom,
} fplMemoryAllocationMode;
 
typedef struct fplMemoryAllocationSettings {
    fplMemoryAllocationMode mode;
    fpl_memory_allocate_callback *allocateCallback;
    fpl_memory_release_callback *releaseCallback;
    void *userData;
} fplMemoryAllocationSettings;
 
typedef struct fplMemorySettings {
    fplMemoryAllocationSettings dynamic;
    fplMemoryAllocationSettings temporary;
} fplMemorySettings;
 
typedef struct fplSettings {
    fplWindowSettings window;
    fplVideoSettings video;
    fplAudioSettings audio;
    fplInputSettings input;
    fplConsoleSettings console;
    fplMemorySettings memory;
} fplSettings;
 
fpl_common_api void fplSetDefaultSettings(fplSettings *settings);
fpl_common_api fplSettings fplMakeDefaultSettings();
fpl_common_api const fplSettings *fplGetCurrentSettings();
 
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
 
fpl_common_api fplPlatformType fplGetPlatformType();
fpl_common_api const char *fplGetPlatformName(const fplPlatformType type);
fpl_common_api bool fplPlatformInit(const fplInitFlags initFlags, const fplSettings *initSettings);
fpl_common_api fplPlatformResultType fplGetPlatformResult();
fpl_common_api void fplPlatformRelease();
fpl_common_api bool fplIsPlatformInitialized();
 
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
 
typedef enum fplLogLevel {
    fplLogLevel_All = -1,
    fplLogLevel_Critical = 0,
    fplLogLevel_Error = 1,
    fplLogLevel_Warning = 2,
    fplLogLevel_Info = 3,
    fplLogLevel_Verbose = 4,
    fplLogLevel_Debug = 5,
    fplLogLevel_Trace = 6,
 
    fplLogLevel_First = fplLogLevel_All,
    fplLogLevel_Last = fplLogLevel_Trace,
} fplLogLevel;
 
#if defined(FPL__ENABLE_LOGGING)
typedef void (fpl_log_func_callback)(const char *funcName, const int lineNumber, const fplLogLevel level, const char *message);
 
typedef enum fplLogWriterFlags {
    fplLogWriterFlags_None = 0,
    fplLogWriterFlags_StandardConsole = 1 << 0,
    fplLogWriterFlags_ErrorConsole = 1 << 1,
    fplLogWriterFlags_DebugOut = 1 << 2,
    fplLogWriterFlags_Custom = 1 << 3,
} fplLogWriterFlags;
FPL_ENUM_AS_FLAGS_OPERATORS(fplLogWriterFlags);
 
typedef struct fplLogWriterConsole {
    int dummy;
} fplLogWriterConsole;
 
typedef struct fplLogWriterCustom {
    fpl_log_func_callback *callback;
} fplLogWriterCustom;
 
typedef struct fplLogWriter {
    fplLogWriterFlags flags;
    fplLogWriterConsole console;
    fplLogWriterCustom custom;
} fplLogWriter;
 
typedef struct fplLogSettings {
#if defined(FPL__ENABLE_LOG_MULTIPLE_WRITERS)
    union {
        fplLogWriter writers[6];
        struct {
            fplLogWriter criticalWriter;
            fplLogWriter errorWriter;
            fplLogWriter warningWriter;
            fplLogWriter infoWriter;
            fplLogWriter verboseWriter;
            fplLogWriter debugWriter;
        };
    };
#else
    fplLogWriter writers[1];
#endif // FPL_USE_LOG_SIMPLE
    fplLogLevel maxLevel;
    fpl_b32 isInitialized;
} fplLogSettings;
 
fpl_common_api void fplSetLogSettings(const fplLogSettings *params);
fpl_common_api const fplLogSettings *fplGetLogSettings();
fpl_common_api void fplSetMaxLogLevel(const fplLogLevel maxLevel);
fpl_common_api fplLogLevel fplGetMaxLogLevel();
#endif // FPL__ENABLE_LOGGING
 
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
 
fpl_common_api const char *fplGetLastError();
fpl_common_api const char *fplGetErrorByIndex(const size_t index);
fpl_common_api size_t fplGetErrorCount();
fpl_common_api void fplClearErrors();
 
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
 
typedef union fplInternalDynamicLibraryHandle {
#if defined(FPL_PLATFORM_WINDOWS)
    fpl__Win32LibraryHandle win32LibraryHandle;
#elif defined(FPL_SUBPLATFORM_POSIX)
    fpl__POSIXLibraryHandle posixLibraryHandle;
#endif
} fplInternalDynamicLibraryHandle;
 
typedef struct fplDynamicLibraryHandle {
    fplInternalDynamicLibraryHandle internalHandle;
    fpl_b32 isValid;
} fplDynamicLibraryHandle;
 
fpl_platform_api bool fplDynamicLibraryLoad(const char *libraryFilePath, fplDynamicLibraryHandle *outHandle);
fpl_platform_api void *fplGetDynamicLibraryProc(const fplDynamicLibraryHandle *handle, const char *name);
fpl_platform_api void fplDynamicLibraryUnload(fplDynamicLibraryHandle *handle);
 
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
 
fpl_platform_api void fplDebugOut(const char *text);
fpl_common_api void fplDebugFormatOut(const char *format, ...);
 
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
 
fpl_platform_api void fplConsoleOut(const char *text);
fpl_platform_api void fplConsoleError(const char *text);
fpl_platform_api char fplConsoleWaitForCharInput();
 
fpl_common_api void fplConsoleFormatOut(const char *format, ...);
fpl_common_api void fplConsoleFormatError(const char *format, ...);
 
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
 
typedef union fplTimestamp {
#if defined(FPL_PLATFORM_WINDOWS)
    struct {
        fpl__Win32LargeInteger qpc;
        uint64_t ticks;
    } win32;
#elif defined(FPL_SUBPLATFORM_POSIX)
    struct {
        uint64_t seconds;
        int64_t nanoSeconds;
    } posix;
#endif
    uint64_t unused;
} fplTimestamp;
 
typedef uint32_t fplTimeoutValue;
#define FPL_TIMEOUT_INFINITE UINT32_MAX
 
typedef double fplSeconds;
 
typedef uint64_t fplMilliseconds;
 
fpl_platform_api fplTimestamp fplTimestampQuery();
fpl_platform_api fplMilliseconds fplMillisecondsQuery();
fpl_platform_api fplSeconds fplTimestampElapsed(const fplTimestamp start, const fplTimestamp finish);
 
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
 
typedef enum fplThreadStates {
    fplThreadState_Stopped = 0,
    fplThreadState_Starting,
    fplThreadState_Running,
    fplThreadState_Stopping,
} fplThreadStates;
 
typedef uint32_t fplThreadState;
 
typedef enum fplThreadPriority {
    fplThreadPriority_Unknown = -10,
 
    fplThreadPriority_Idle = -2,
    fplThreadPriority_Low = -1,
    fplThreadPriority_Normal = 0,
    fplThreadPriority_High = 1,
    fplThreadPriority_RealTime = 2,
 
    fplThreadPriority_Lowest = fplThreadPriority_Idle,
    fplThreadPriority_Highest = fplThreadPriority_RealTime,
 
    fplThreadPriority_First = fplThreadPriority_Lowest,
    fplThreadPriority_Last = fplThreadPriority_Highest,
} fplThreadPriority;
 
typedef struct fplThreadHandle fplThreadHandle;
 
typedef void (fpl_run_thread_callback)(const fplThreadHandle *thread, void *data);
 
typedef union fplInternalThreadHandle {
#if defined(FPL_PLATFORM_WINDOWS)
    fpl__Win32ThreadHandle win32ThreadHandle;
#elif defined(FPL_SUBPLATFORM_POSIX)
    fpl__POSIXThreadHandle posixThread;
#endif
} fplInternalThreadHandle;
 
typedef struct fplThreadParameters {
    void *userData;
    fpl_run_thread_callback *runFunc;
    size_t stackSize;
    fplThreadPriority priority;
} fplThreadParameters;
 
typedef struct fplThreadHandle {
    fplInternalThreadHandle internalHandle;
    fplThreadParameters parameters;
    volatile fplThreadState currentState;
    uint32_t id;
    volatile fpl_b32 isValid;
    volatile fpl_b32 isStopping;
} fplThreadHandle;
 
#if defined(FPL_PLATFORM_WINDOWS)
typedef struct fpl__Win32InternalSemaphore {
    fpl__Win32SemaphoreHandle handle;
    volatile int32_t value;
} fpl__Win32InternalSemaphore;
#endif
 
typedef union fplInternalSemaphoreHandle {
#if defined(FPL_PLATFORM_WINDOWS)
    fpl__Win32InternalSemaphore win32;
#elif defined(FPL_SUBPLATFORM_POSIX)
    fpl__POSIXSemaphoreHandle posixHandle;
#endif
} fplInternalSemaphoreHandle;
 
typedef struct fplSemaphoreHandle {
    fplInternalSemaphoreHandle internalHandle;
    fpl_b32 isValid;
} fplSemaphoreHandle;
 
typedef union fplInternalMutexHandle {
#if defined(FPL_PLATFORM_WINDOWS)
    fpl__Win32MutexHandle win32CriticalSection;
#elif defined(FPL_SUBPLATFORM_POSIX)
    fpl__POSIXMutexHandle posixMutex;
#endif
} fplInternalMutexHandle;
 
typedef struct fplMutexHandle {
    fpl_b32 isValid;
    fplInternalMutexHandle internalHandle;
} fplMutexHandle;
 
typedef union fplInternalSignalHandle {
#if defined(FPL_PLATFORM_WINDOWS)
    fpl__Win32SignalHandle win32EventHandle;
#elif defined(FPL_PLATFORM_LINUX)
    fpl__LinuxSignalHandle linuxEventHandle;
#endif
} fplInternalSignalHandle;
 
typedef struct fplSignalHandle {
    fplInternalSignalHandle internalHandle;
    fpl_b32 isValid;
} fplSignalHandle;
 
typedef enum fplSignalValue {
    fplSignalValue_Unset = 0,
    fplSignalValue_Set = 1,
} fplSignalValue;
 
typedef union fplInternalConditionVariable {
#if defined(FPL_PLATFORM_WINDOWS)
    fpl__Win32ConditionVariable win32Condition;
#elif defined(FPL_SUBPLATFORM_POSIX)
    fpl__POSIXConditionVariable posixCondition;
#endif
    int dummy;
} fplInternalConditionVariable;
 
typedef struct fplConditionVariable {
    fplInternalConditionVariable internalHandle;
    fpl_b32 isValid;
} fplConditionVariable;
 
fpl_common_api fplThreadState fplGetThreadState(fplThreadHandle *thread);
fpl_common_api const fplThreadHandle *fplGetMainThread();
fpl_common_api size_t GetAvailableThreadCount();
fpl_common_api size_t GetUsedThreadCount();
fpl_platform_api uint32_t fplGetCurrentThreadId();
fpl_platform_api fplThreadHandle *fplThreadCreate(fpl_run_thread_callback *runFunc, void *data);
fpl_platform_api fplThreadHandle *fplThreadCreateWithParameters(fplThreadParameters *parameters);
fpl_platform_api fplThreadPriority fplGetThreadPriority(fplThreadHandle *thread);
fpl_platform_api bool fplSetThreadPriority(fplThreadHandle *thread, const fplThreadPriority newPriority);
fpl_platform_api void fplThreadSleep(const uint32_t milliseconds);
fpl_platform_api bool fplThreadYield();
fpl_platform_api bool fplThreadTerminate(fplThreadHandle *thread);
fpl_platform_api bool fplThreadWaitForOne(fplThreadHandle *thread, const fplTimeoutValue timeout);
fpl_platform_api bool fplThreadWaitForAll(fplThreadHandle **threads, const size_t count, const size_t stride, const fplTimeoutValue timeout);
fpl_platform_api bool fplThreadWaitForAny(fplThreadHandle **threads, const size_t count, const size_t stride, const fplTimeoutValue timeout);
 
fpl_platform_api bool fplMutexInit(fplMutexHandle *mutex);
fpl_platform_api void fplMutexDestroy(fplMutexHandle *mutex);
fpl_platform_api bool fplMutexLock(fplMutexHandle *mutex);
fpl_platform_api bool fplMutexTryLock(fplMutexHandle *mutex);
fpl_platform_api bool fplMutexUnlock(fplMutexHandle *mutex);
 
fpl_platform_api bool fplSignalInit(fplSignalHandle *signal, const fplSignalValue initialValue);
fpl_platform_api void fplSignalDestroy(fplSignalHandle *signal);
fpl_platform_api bool fplSignalWaitForOne(fplSignalHandle *signal, const fplTimeoutValue timeout);
fpl_platform_api bool fplSignalWaitForAll(fplSignalHandle **signals, const size_t count, const size_t stride, const fplTimeoutValue timeout);
fpl_platform_api bool fplSignalWaitForAny(fplSignalHandle **signals, const size_t count, const size_t stride, const fplTimeoutValue timeout);
fpl_platform_api bool fplSignalSet(fplSignalHandle *signal);
fpl_platform_api bool fplSignalReset(fplSignalHandle *signal);
 
fpl_platform_api bool fplConditionInit(fplConditionVariable *condition);
fpl_platform_api void fplConditionDestroy(fplConditionVariable *condition);
fpl_platform_api bool fplConditionWait(fplConditionVariable *condition, fplMutexHandle *mutex, const fplTimeoutValue timeout);
fpl_platform_api bool fplConditionSignal(fplConditionVariable *condition);
fpl_platform_api bool fplConditionBroadcast(fplConditionVariable *condition);
 
fpl_platform_api bool fplSemaphoreInit(fplSemaphoreHandle *semaphore, const uint32_t initialValue);
fpl_platform_api void fplSemaphoreDestroy(fplSemaphoreHandle *semaphore);
fpl_platform_api bool fplSemaphoreWait(fplSemaphoreHandle *semaphore, const fplTimeoutValue timeout);
fpl_platform_api bool fplSemaphoreTryWait(fplSemaphoreHandle *semaphore);
fpl_platform_api int32_t fplSemaphoreValue(fplSemaphoreHandle *semaphore);
fpl_platform_api bool fplSemaphoreRelease(fplSemaphoreHandle *semaphore);
 
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
 
fpl_common_api bool fplIsStringMatchWildcard(const char *source, const char *wildcard);
fpl_common_api bool fplIsStringEqualLen(const char *a, const size_t aLen, const char *b, const size_t bLen);
fpl_common_api bool fplIsStringEqual(const char *a, const char *b);
fpl_common_api char *fplEnforcePathSeparatorLen(char *path, size_t maxPathLen);
fpl_common_api char *fplEnforcePathSeparator(char *path);
fpl_common_api char *fplStringAppendLen(const char *appended, const size_t appendedLen, char *buffer, size_t maxBufferLen);
fpl_common_api char *fplStringAppend(const char *appended, char *buffer, size_t maxBufferLen);
fpl_common_api size_t fplGetStringLength(const char *str);
fpl_common_api char *fplCopyStringLen(const char *source, const size_t sourceLen, char *dest, const size_t maxDestLen);
fpl_common_api char *fplCopyString(const char *source, char *dest, const size_t maxDestLen);
fpl_platform_api size_t fplWideStringToUTF8String(const wchar_t *wideSource, const size_t wideSourceLen, char *utf8Dest, const size_t maxUtf8DestLen);
fpl_platform_api size_t fplUTF8StringToWideString(const char *utf8Source, const size_t utf8SourceLen, wchar_t *wideDest, const size_t maxWideDestLen);
fpl_common_api size_t fplStringFormat(char *destBuffer, const size_t maxDestBufferLen, const char *format, ...);
fpl_common_api size_t fplStringFormatArgs(char *destBuffer, const size_t maxDestBufferLen, const char *format, va_list argList);
 
fpl_common_api int32_t fplStringToS32Len(const char *str, const size_t len);
 
fpl_common_api int32_t fplStringToS32(const char *str);
 
fpl_common_api size_t fplS32ToString(const int32_t value, char *buffer, const size_t maxBufferLen);
 
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
 
typedef union fplInternalFileHandle {
#if defined(FPL_PLATFORM_WINDOWS)
    fpl__Win32FileHandle win32FileHandle;
#elif defined(FPL_SUBPLATFORM_POSIX)
    fpl__POSIXFileHandle posixFileHandle;
#endif
} fplInternalFileHandle;
 
typedef struct fplFileHandle {
    fplInternalFileHandle internalHandle;
    fpl_b32 isValid;
} fplFileHandle;
 
typedef enum fplFilePositionMode {
    fplFilePositionMode_Beginning = 0,
    fplFilePositionMode_Current,
    fplFilePositionMode_End
} fplFilePositionMode;
 
typedef enum fplFileEntryType {
    fplFileEntryType_Unknown = 0,
    fplFileEntryType_File,
    fplFileEntryType_Directory
} fplFileEntryType;
 
typedef enum fplFilePermissionFlags {
    fplFilePermissionFlags_All = 0,
    fplFilePermissionFlags_CanExecuteSearch = 1 << 0,
    fplFilePermissionFlags_CanWrite = 1 << 1,
    fplFilePermissionFlags_CanRead = 1 << 2,
} fplFilePermissionFlags;
FPL_ENUM_AS_FLAGS_OPERATORS(fplFilePermissionFlags);
 
typedef enum fplFilePermissionMasks {
    fplFilePermissionMasks_None = 0,
    fplFilePermissionMasks_User = 0xFF0000,
    fplFilePermissionMasks_Group = 0x00FF00,
    fplFilePermissionMasks_Owner = 0x0000FF,
} fplFilePermissionMasks;
FPL_ENUM_AS_FLAGS_OPERATORS(fplFilePermissionMasks);
 
typedef union fplFilePermissions {
    struct {
        uint8_t user;
        uint8_t group;
        uint8_t owner;
        uint8_t unused;
    };
    uint32_t umask;
} fplFilePermissions;
 
typedef enum fplFileAttributeFlags {
    fplFileAttributeFlags_None = 0,
    fplFileAttributeFlags_Normal = 1 << 0,
    fplFileAttributeFlags_Hidden = 1 << 1,
    fplFileAttributeFlags_System = 1 << 2,
    fplFileAttributeFlags_Archive = 1 << 3
} fplFileAttributeFlags;
FPL_ENUM_AS_FLAGS_OPERATORS(fplFileAttributeFlags);
 
typedef union fplInternalFileEntryHandle {
#if defined(FPL_PLATFORM_WINDOWS)
    fpl__Win32FileHandle win32FileHandle;
#elif defined(FPL_SUBPLATFORM_POSIX)
    fpl__POSIXDirHandle posixDirHandle;
#endif
} fplInternalFileEntryHandle;
 
typedef struct fplInternalFileRootInfo {
    const char *rootPath;
    const char *filter;
} fplInternalFileRootInfo;
 
typedef uint64_t fplFileTimeStamp;
 
typedef struct fplFileTimeStamps {
    fplFileTimeStamp creationTime;
    fplFileTimeStamp lastAccessTime;
    fplFileTimeStamp lastModifyTime;
} fplFileTimeStamps;
 
typedef struct fplFileEntry {
    char name[FPL_MAX_FILENAME_LENGTH];
    fplInternalFileEntryHandle internalHandle;
    fplInternalFileRootInfo internalRoot;
    fplFileTimeStamps timeStamps;
    fplFilePermissions permissions;
    fplFileEntryType type;
    fplFileAttributeFlags attributes;
    size_t size;
} fplFileEntry;
 
fpl_platform_api bool fplFileOpenBinary(const char *filePath, fplFileHandle *outHandle);
fpl_platform_api bool fplFileCreateBinary(const char *filePath, fplFileHandle *outHandle);
fpl_platform_api uint32_t fplFileReadBlock32(const fplFileHandle *fileHandle, const uint32_t sizeToRead, void *targetBuffer, const uint32_t maxTargetBufferSize);
fpl_platform_api uint64_t fplFileReadBlock64(const fplFileHandle *fileHandle, const uint64_t sizeToRead, void *targetBuffer, const uint64_t maxTargetBufferSize);
fpl_platform_api size_t fplFileReadBlock(const fplFileHandle *fileHandle, const size_t sizeToRead, void *targetBuffer, const size_t maxTargetBufferSize);
fpl_platform_api uint32_t fplFileWriteBlock32(const fplFileHandle *fileHandle, void *sourceBuffer, const uint32_t sourceSize);
fpl_platform_api uint64_t fplFileWriteBlock64(const fplFileHandle *fileHandle, void *sourceBuffer, const uint64_t sourceSize);
fpl_common_api size_t fplFileWriteBlock(const fplFileHandle *fileHandle, void *sourceBuffer, const size_t sourceSize);
fpl_platform_api uint32_t fplFileSetPosition32(const fplFileHandle *fileHandle, const int32_t position, const fplFilePositionMode mode);
fpl_platform_api uint64_t fplFileSetPosition64(const fplFileHandle *fileHandle, const int64_t position, const fplFilePositionMode mode);
fpl_common_api size_t fplFileSetPosition(const fplFileHandle *fileHandle, const intptr_t position, const fplFilePositionMode mode);
fpl_platform_api uint32_t fplFileGetPosition32(const fplFileHandle *fileHandle);
fpl_platform_api uint64_t fplFileGetPosition64(const fplFileHandle *fileHandle);
fpl_common_api size_t fplFileGetPosition(const fplFileHandle *fileHandle);
fpl_platform_api bool fplFileFlush(fplFileHandle *fileHandle);
fpl_platform_api void fplFileClose(fplFileHandle *fileHandle);
 
fpl_platform_api uint32_t fplFileGetSizeFromPath32(const char *filePath);
fpl_platform_api uint64_t fplFileGetSizeFromPath64(const char *filePath);
fpl_platform_api size_t fplFileGetSizeFromPath(const char *filePath);
fpl_platform_api uint32_t fplFileGetSizeFromHandle32(const fplFileHandle *fileHandle);
fpl_platform_api uint64_t fplFileGetSizeFromHandle64(const fplFileHandle *fileHandle);
fpl_common_api size_t fplFileGetSizeFromHandle(const fplFileHandle *fileHandle);
fpl_platform_api bool fplFileGetTimestampsFromPath(const char *filePath, fplFileTimeStamps *outStamps);
fpl_platform_api bool fplFileGetTimestampsFromHandle(const fplFileHandle *fileHandle, fplFileTimeStamps *outStamps);
fpl_platform_api bool fplFileSetTimestamps(const char *filePath, const fplFileTimeStamps *timeStamps);
fpl_platform_api bool fplFileExists(const char *filePath);
fpl_platform_api bool fplFileCopy(const char *sourceFilePath, const char *targetFilePath, const bool overwrite);
fpl_platform_api bool fplFileMove(const char *sourceFilePath, const char *targetFilePath);
fpl_platform_api bool fplFileDelete(const char *filePath);
 
fpl_platform_api bool fplDirectoriesCreate(const char *path);
fpl_platform_api bool fplDirectoryExists(const char *path);
fpl_platform_api bool fplDirectoryRemove(const char *path);
fpl_platform_api bool fplDirectoryListBegin(const char *path, const char *filter, fplFileEntry *entry);
fpl_platform_api bool fplDirectoryListNext(fplFileEntry *entry);
fpl_platform_api void fplDirectoryListEnd(fplFileEntry *entry);
 
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
 
fpl_platform_api size_t fplGetExecutableFilePath(char *destPath, const size_t maxDestLen);
fpl_platform_api size_t fplGetHomePath(char *destPath, const size_t maxDestLen);
fpl_common_api size_t fplExtractFilePath(const char *sourcePath, char *destPath, const size_t maxDestLen);
fpl_common_api const char *fplExtractFileExtension(const char *sourcePath);
fpl_common_api const char *fplExtractFileName(const char *sourcePath);
fpl_common_api size_t fplChangeFileExtension(const char *filePath, const char *newFileExtension, char *destPath, const size_t maxDestLen);
fpl_common_api size_t fplPathCombine(char *destPath, const size_t maxDestPathLen, const size_t pathCount, ...);
 
#if defined(FPL__ENABLE_WINDOW)
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
 
typedef enum fplKey {
    fplKey_None = 0,
 
    // 0x0-0x07: Undefined
 
    fplKey_Backspace = 0x08,
    fplKey_Tab = 0x09,
 
    // 0x0A-0x0B: Reserved
 
    fplKey_Clear = 0x0C,
    fplKey_Return = 0x0D,
 
    // 0x0E-0x0F: Undefined
 
    fplKey_Shift = 0x10,
    fplKey_Control = 0x11,
    fplKey_Alt = 0x12,
    fplKey_Pause = 0x13,
    fplKey_CapsLock = 0x14,
 
    // 0x15: IME-Keys
    // 0x16: Undefined
    // 0x17-0x19 IME-Keys
    // 0x1A: Undefined
 
    fplKey_Escape = 0x1B,
 
    // 0x1C-0x1F: IME-Keys
 
    fplKey_Space = 0x20,
    fplKey_PageUp = 0x21,
    fplKey_PageDown = 0x22,
    fplKey_End = 0x23,
    fplKey_Home = 0x24,
    fplKey_Left = 0x25,
    fplKey_Up = 0x26,
    fplKey_Right = 0x27,
    fplKey_Down = 0x28,
    fplKey_Select = 0x29,
    fplKey_Print = 0x2A,
    fplKey_Execute = 0x2B,
    fplKey_Snapshot = 0x2C,
    fplKey_Insert = 0x2D,
    fplKey_Delete = 0x2E,
    fplKey_Help = 0x2F,
 
    fplKey_0 = 0x30,
    fplKey_1 = 0x31,
    fplKey_2 = 0x32,
    fplKey_3 = 0x33,
    fplKey_4 = 0x34,
    fplKey_5 = 0x35,
    fplKey_6 = 0x36,
    fplKey_7 = 0x37,
    fplKey_8 = 0x38,
    fplKey_9 = 0x39,
 
    // 0x3A-0x40: Undefined
 
    fplKey_A = 0x41,
    fplKey_B = 0x42,
    fplKey_C = 0x43,
    fplKey_D = 0x44,
    fplKey_E = 0x45,
    fplKey_F = 0x46,
    fplKey_G = 0x47,
    fplKey_H = 0x48,
    fplKey_I = 0x49,
    fplKey_J = 0x4A,
    fplKey_K = 0x4B,
    fplKey_L = 0x4C,
    fplKey_M = 0x4D,
    fplKey_N = 0x4E,
    fplKey_O = 0x4F,
    fplKey_P = 0x50,
    fplKey_Q = 0x51,
    fplKey_R = 0x52,
    fplKey_S = 0x53,
    fplKey_T = 0x54,
    fplKey_U = 0x55,
    fplKey_V = 0x56,
    fplKey_W = 0x57,
    fplKey_X = 0x58,
    fplKey_Y = 0x59,
    fplKey_Z = 0x5A,
 
    fplKey_LeftSuper = 0x5B,
    fplKey_RightSuper = 0x5C,
    fplKey_Apps = 0x5D,
 
    // 0x5E: Reserved
 
    fplKey_Sleep = 0x5F,
    fplKey_NumPad0 = 0x60,
    fplKey_NumPad1 = 0x61,
    fplKey_NumPad2 = 0x62,
    fplKey_NumPad3 = 0x63,
    fplKey_NumPad4 = 0x64,
    fplKey_NumPad5 = 0x65,
    fplKey_NumPad6 = 0x66,
    fplKey_NumPad7 = 0x67,
    fplKey_NumPad8 = 0x68,
    fplKey_NumPad9 = 0x69,
    fplKey_Multiply = 0x6A,
    fplKey_Add = 0x6B,
    fplKey_Separator = 0x6C,
    fplKey_Substract = 0x6D,
    fplKey_Decimal = 0x6E,
    fplKey_Divide = 0x6F,
    fplKey_F1 = 0x70,
    fplKey_F2 = 0x71,
    fplKey_F3 = 0x72,
    fplKey_F4 = 0x73,
    fplKey_F5 = 0x74,
    fplKey_F6 = 0x75,
    fplKey_F7 = 0x76,
    fplKey_F8 = 0x77,
    fplKey_F9 = 0x78,
    fplKey_F10 = 0x79,
    fplKey_F11 = 0x7A,
    fplKey_F12 = 0x7B,
    fplKey_F13 = 0x7C,
    fplKey_F14 = 0x7D,
    fplKey_F15 = 0x7E,
    fplKey_F16 = 0x7F,
    fplKey_F17 = 0x80,
    fplKey_F18 = 0x81,
    fplKey_F19 = 0x82,
    fplKey_F20 = 0x83,
    fplKey_F21 = 0x84,
    fplKey_F22 = 0x85,
    fplKey_F23 = 0x86,
    fplKey_F24 = 0x87,
 
    // 0x88-8F: Unassigned
 
    fplKey_NumLock = 0x90,
    fplKey_Scroll = 0x91,
 
    // 0x92-9x96: OEM specific
    // 0x97-0x9F: Unassigned
 
    fplKey_LeftShift = 0xA0,
    fplKey_RightShift = 0xA1,
    fplKey_LeftControl = 0xA2,
    fplKey_RightControl = 0xA3,
    fplKey_LeftAlt = 0xA4,
    fplKey_RightAlt = 0xA5,
 
    // 0xA6-0xAC: Dont care
 
    fplKey_VolumeMute = 0xAD,
    fplKey_VolumeDown = 0xAE,
    fplKey_VolumeUp = 0xAF,
    fplKey_MediaNextTrack = 0xB0,
    fplKey_MediaPrevTrack = 0xB1,
    fplKey_MediaStop = 0xB2,
    fplKey_MediaPlayPause = 0xB3,
 
    // 0xB4-0xB9 Dont care
 
    fplKey_Oem1 = 0xBA,
    fplKey_OemPlus = 0xBB,
    fplKey_OemComma = 0xBC,
    fplKey_OemMinus = 0xBD,
    fplKey_OemPeriod = 0xBE,
    fplKey_Oem2 = 0xBF,
    fplKey_Oem3 = 0xC0,
 
    // 0xC1-0xD7 Reserved
    // 0xD8-0xDA Unassigned
 
    fplKey_Oem4 = 0xDB,
    fplKey_Oem5 = 0xDC,
    fplKey_Oem6 = 0xDD,
    fplKey_Oem7 = 0xDE,
    fplKey_Oem8 = 0xDF,
 
    // 0xE0-0xFE Dont care
} fplKey;
 
typedef enum fplWindowEventType {
    fplWindowEventType_None = 0,
    fplWindowEventType_Resized,
    fplWindowEventType_GotFocus,
    fplWindowEventType_LostFocus,
    fplWindowEventType_Minimized,
    fplWindowEventType_Maximized,
    fplWindowEventType_Restored,
    fplWindowEventType_DroppedFiles,
    fplWindowEventType_Exposed,
    fplWindowEventType_PositionChanged,
    fplWindowEventType_Closed,
    fplWindowEventType_Shown,
    fplWindowEventType_Hidden,
} fplWindowEventType;
 
typedef struct fplWindowDropFiles {
    fplMemoryBlock internalMemory;
    const char **files;
    size_t fileCount;
} fplWindowDropFiles;
 
typedef struct fplWindowEvent {
    fplWindowEventType type;
    union {
        fplWindowSize size;
        fplWindowPosition position;
        fplWindowDropFiles dropFiles;
    };
} fplWindowEvent;
 
typedef enum fplButtonState {
    fplButtonState_Release = 0,
    fplButtonState_Press = 1,
    fplButtonState_Repeat = 2,
} fplButtonState;
 
typedef enum fplKeyboardEventType {
    fplKeyboardEventType_None = 0,
    fplKeyboardEventType_Button,
    fplKeyboardEventType_Input,
} fplKeyboardEventType;
 
typedef enum fplKeyboardModifierFlags {
    fplKeyboardModifierFlags_None = 0,
    fplKeyboardModifierFlags_LAlt = 1 << 0,
    fplKeyboardModifierFlags_RAlt = 1 << 1,
    fplKeyboardModifierFlags_LCtrl = 1 << 2,
    fplKeyboardModifierFlags_RCtrl = 1 << 3,
    fplKeyboardModifierFlags_LShift = 1 << 4,
    fplKeyboardModifierFlags_RShift = 1 << 5,
    fplKeyboardModifierFlags_LSuper = 1 << 6,
    fplKeyboardModifierFlags_RSuper = 1 << 7,
    fplKeyboardModifierFlags_CapsLock = 1 << 8,
    fplKeyboardModifierFlags_NumLock = 1 << 9,
    fplKeyboardModifierFlags_ScrollLock = 1 << 10,
} fplKeyboardModifierFlags;
FPL_ENUM_AS_FLAGS_OPERATORS(fplKeyboardModifierFlags);
 
typedef struct fplKeyboardEvent {
    uint64_t keyCode;
    fplKeyboardEventType type;
    fplKeyboardModifierFlags modifiers;
    fplButtonState buttonState;
    fplKey mappedKey;
} fplKeyboardEvent;
 
typedef enum fplMouseEventType {
    fplMouseEventType_None,
    fplMouseEventType_Move,
    fplMouseEventType_Button,
    fplMouseEventType_Wheel,
} fplMouseEventType;
 
typedef enum fplMouseButtonType {
    fplMouseButtonType_None = -1,
    fplMouseButtonType_Left = 0,
    fplMouseButtonType_Right = 1,
    fplMouseButtonType_Middle = 2,
    fplMouseButtonType_MaxCount,
} fplMouseButtonType;
 
typedef struct fplMouseEvent {
    fplMouseEventType type;
    fplMouseButtonType mouseButton;
    fplButtonState buttonState;
    int32_t mouseX;
    int32_t mouseY;
    float wheelDelta;
} fplMouseEvent;
 
typedef enum fplGamepadEventType {
    fplGamepadEventType_None = 0,
    fplGamepadEventType_Connected,
    fplGamepadEventType_Disconnected,
    fplGamepadEventType_StateChanged,
} fplGamepadEventType;
 
typedef struct fplGamepadButton {
    fpl_b32 isDown;
} fplGamepadButton;
 
typedef enum fplGamepadButtonType {
    fplGamepadButtonType_DPadUp = 0,
    fplGamepadButtonType_DPadRight,
    fplGamepadButtonType_DPadDown,
    fplGamepadButtonType_DPadLeft,
 
    fplGamepadButtonType_ActionA,
    fplGamepadButtonType_ActionB,
    fplGamepadButtonType_ActionX,
    fplGamepadButtonType_ActionY,
 
    fplGamepadButtonType_Start,
    fplGamepadButtonType_Back,
 
    fplGamepadButtonType_LeftThumb,
    fplGamepadButtonType_RightThumb,
 
    fplGamepadButtonType_LeftShoulder,
    fplGamepadButtonType_RightShoulder,
} fplGamepadButtonType;
 
typedef struct fplGamepadState {
    union {
        struct {
            fplGamepadButton dpadUp;
            fplGamepadButton dpadRight;
            fplGamepadButton dpadDown;
            fplGamepadButton dpadLeft;
 
            fplGamepadButton actionA;
            fplGamepadButton actionB;
            fplGamepadButton actionX;
            fplGamepadButton actionY;
 
            fplGamepadButton start;
            fplGamepadButton back;
 
            fplGamepadButton leftThumb;
            fplGamepadButton rightThumb;
 
            fplGamepadButton leftShoulder;
            fplGamepadButton rightShoulder;
        };
        fplGamepadButton buttons[14];
    };
 
    const char *deviceName;
 
    float leftStickX;
    float leftStickY;
    float rightStickX;
    float rightStickY;
 
    float leftTrigger;
    float rightTrigger;
 
    fpl_b32 isConnected;
    fpl_b32 isActive;
} fplGamepadState;
 
typedef struct fplGamepadEvent {
    fplGamepadState state;
    const char *deviceName;
    fplGamepadEventType type;
    uint32_t deviceIndex;
} fplGamepadEvent;
 
typedef enum fplEventType {
    fplEventType_None = 0,
    fplEventType_Window,
    fplEventType_Keyboard,
    fplEventType_Mouse,
    fplEventType_Gamepad,
} fplEventType;
 
typedef struct fplEvent {
    fplEventType type;
    union {
        fplWindowEvent window;
        fplKeyboardEvent keyboard;
        fplMouseEvent mouse;
        fplGamepadEvent gamepad;
    };
} fplEvent;
 
fpl_platform_api bool fplPollEvent(fplEvent *ev);
 
fpl_platform_api void fplPollEvents();
 
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
 
#define FPL_MAX_KEYBOARD_STATE_COUNT 256
 
typedef struct fplKeyboardState {
    fplKeyboardModifierFlags modifiers;
    fpl_b32 keyStatesRaw[FPL_MAX_KEYBOARD_STATE_COUNT];
    fplButtonState buttonStatesMapped[FPL_MAX_KEYBOARD_STATE_COUNT];
} fplKeyboardState;
 
#define FPL_MAX_GAMEPAD_STATE_COUNT 4
 
typedef struct fplGamepadStates {
    fplGamepadState deviceStates[FPL_MAX_GAMEPAD_STATE_COUNT];
} fplGamepadStates;
 
typedef struct fplMouseState {
    fplButtonState buttonStates[fplMouseButtonType_MaxCount];
    int32_t x;
    int32_t y;
} fplMouseState;
 
fpl_platform_api bool fplPollKeyboardState(fplKeyboardState *outState);
fpl_platform_api bool fplPollGamepadStates(fplGamepadStates *outStates);
fpl_platform_api bool fplPollMouseState(fplMouseState *outState);
 
fpl_platform_api bool fplQueryCursorPosition(int32_t *outX, int32_t *outY);
 
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
 
typedef enum fplWindowState {
    fplWindowState_Unknown = 0,
    fplWindowState_Normal,
    fplWindowState_Iconify,
    fplWindowState_Maximize,
    fplWindowState_Fullscreen,
} fplWindowState;
 
typedef enum fplWindowVisibilityState {
    fplWindowVisibilityState_Unknown = 0,
    fplWindowVisibilityState_Show,
    fplWindowVisibilityState_Hide,
} fplWindowVisibilityState;
 
fpl_platform_api bool fplIsWindowRunning();
fpl_platform_api void fplWindowShutdown();
fpl_platform_api bool fplWindowUpdate();
fpl_platform_api void fplSetWindowCursorEnabled(const bool value);
fpl_platform_api bool fplGetWindowSize(fplWindowSize *outSize);
fpl_platform_api void fplSetWindowSize(const uint32_t width, const uint32_t height);
fpl_platform_api bool fplIsWindowResizable();
fpl_platform_api void fplSetWindowResizeable(const bool value);
fpl_platform_api bool fplIsWindowDecorated();
fpl_platform_api void fplSetWindowDecorated(const bool value);
fpl_platform_api bool fplIsWindowFloating();
fpl_platform_api void fplSetWindowFloating(const bool value);
fpl_platform_api bool fplSetWindowFullscreenSize(const bool value, const uint32_t fullscreenWidth, const uint32_t fullscreenHeight, const uint32_t refreshRate);
fpl_platform_api bool fplSetWindowFullscreenRect(const bool value, const int32_t x, const int32_t y, const int32_t width, const int32_t height);
fpl_platform_api bool fplEnableWindowFullscreen();
fpl_platform_api bool fplDisableWindowFullscreen();
fpl_platform_api bool fplIsWindowFullscreen();
fpl_platform_api bool fplGetWindowPosition(fplWindowPosition *outPos);
fpl_platform_api void fplSetWindowPosition(const int32_t left, const int32_t top);
fpl_platform_api void fplSetWindowTitle(const char *title);
fpl_common_api char *fplGetWindowTitle(char *outTitle, const size_t maxOutTitleLength);
fpl_platform_api fplWindowState fplGetWindowState();
fpl_platform_api bool fplSetWindowState(const fplWindowState newState);
fpl_common_api void fplSetWindowInputEvents(const bool enabled);
 
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
 
typedef struct fplDisplayInfo {
    char id[FPL_MAX_NAME_LENGTH];
    fplWindowSize virtualSize;
    fplWindowPosition virtualPosition;
    fplWindowSize physicalSize;
    fpl_b32 isPrimary;
} fplDisplayInfo;
 
typedef struct fplDisplayMode {
    uint32_t width;
    uint32_t height;
    uint32_t colorBits;
    uint32_t refreshRate;
} fplDisplayMode;
 
fpl_platform_api size_t fplGetDisplayCount();
fpl_platform_api size_t fplGetDisplays(fplDisplayInfo *outDisplays, const size_t maxDisplayCount);
fpl_platform_api bool fplGetWindowDisplay(fplDisplayInfo *outInfo);
fpl_platform_api bool fplGetPrimaryDisplay(fplDisplayInfo *outInfo);
fpl_platform_api bool fplGetDisplayFromPosition(const int32_t x, const int32_t y, fplDisplayInfo *outInfo);
fpl_platform_api size_t fplGetDisplayModes(const char *id, fplDisplayMode *outModes, const size_t maxDisplayModeCount);
 
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
 
fpl_platform_api bool fplGetClipboardText(char *dest, const uint32_t maxDestLen);
fpl_platform_api bool fplSetClipboardText(const char *text);
 
#endif // FPL__ENABLE_WINDOW
 
#if defined(FPL__ENABLE_VIDEO)
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
 
typedef struct fplVideoRect {
    int32_t x;
    int32_t y;
    int32_t width;
    int32_t height;
} fplVideoRect;
 
fpl_inline fplVideoRect fplCreateVideoRectFromLTRB(int32_t left, int32_t top, int32_t right, int32_t bottom) {
    fplVideoRect result = { left, top, (right - left) + 1, (bottom - top) + 1 };
    return(result);
}
 
typedef struct fplVideoBackBuffer {
    uint32_t *pixels;
    uint32_t width;
    uint32_t height;
    size_t pixelStride;
    size_t lineWidth;
    fplVideoRect outputRect;
    fpl_b32 useOutputRect;
} fplVideoBackBuffer;
 
#if defined(FPL__ENABLE_VIDEO_VULKAN)
typedef struct fplVideoSurfaceVulkan {
    void *instance;
    void *surfaceKHR;
} fplVideoSurfaceVulkan;
#endif
 
#if defined(FPL__ENABLE_VIDEO_OPENGL)
typedef struct fplVideoSurfaceOpenGL {
    void *renderingContext;
} fplVideoSurfaceOpenGL;
#endif
 
#if defined(FPL_PLATFORM_WINDOWS)
typedef struct fplVideoWindowWin32 {
    fpl__Win32WindowHandle windowHandle;
    fpl__Win32DeviceContext deviceContext;
} fplVideoWindowWin32;
#endif
 
#if defined(FPL_SUBPLATFORM_X11)
typedef struct fplVideoWindowX11 {
    fpl__X11Window window;
    fpl__X11Display display;
    fpl__X11Visual visual;
    int screen;
} fplVideoWindowX11;
#endif // FPL_SUBPLATFORM_X11
 
typedef union fplVideoWindow {
#if defined(FPL_PLATFORM_WINDOWS)
    fplVideoWindowWin32 win32;
#elif defined(FPL_SUBPLATFORM_X11)
    fplVideoWindowX11 x11;
#endif
    int dummy;
} fplVideoWindow;
 
typedef struct fplVideoSurface {
    fplVideoWindow window;
 
#if defined(FPL__ENABLE_VIDEO_VULKAN)
    fplVideoSurfaceVulkan vulkan;
#endif
 
#if defined(FPL__ENABLE_VIDEO_OPENGL)
    fplVideoSurfaceOpenGL opengl;
#endif
 
    int dummy;
} fplVideoSurface;
 
#if defined(FPL__ENABLE_VIDEO_VULKAN)
typedef struct fplVideoRequirementsVulkan {
    const char *instanceExtensions[2];
    uint32_t instanceExtensionCount;
} fplVideoRequirementsVulkan;
#endif // FPL__ENABLE_VIDEO_VULKAN
 
 
typedef union fplVideoRequirements {
#if defined(FPL__ENABLE_VIDEO_VULKAN)
    fplVideoRequirementsVulkan vulkan;
#endif // FPL__ENABLE_VIDEO_VULKAN
    int dummy;
} fplVideoRequirements;
 
fpl_common_api fplVideoBackendType fplGetVideoBackendType();
fpl_common_api const char *fplGetVideoBackendName(fplVideoBackendType backendType);
fpl_common_api fplVideoBackBuffer *fplGetVideoBackBuffer();
fpl_common_api bool fplResizeVideoBackBuffer(const uint32_t width, const uint32_t height);
 
fpl_common_api void fplVideoFlip();
 
fpl_common_api const void *fplGetVideoProcedure(const char *procName);
 
fpl_common_api const fplVideoSurface *fplGetVideoSurface();
 
fpl_common_api bool fplGetVideoRequirements(const fplVideoBackendType backendType, fplVideoRequirements *requirements);
 
#endif // FPL__ENABLE_VIDEO
 
#if defined(FPL__ENABLE_AUDIO)
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
 
typedef enum fplAudioResultType {
    fplAudioResultType_None = 0,
    fplAudioResultType_Success,
    fplAudioResultType_DeviceNotInitialized,
    fplAudioResultType_DeviceAlreadyStopped,
    fplAudioResultType_DeviceAlreadyStarted,
    fplAudioResultType_DeviceBusy,
    fplAudioResultType_NoDeviceFound,
    fplAudioResultType_ApiFailed,
    fplAudioResultType_PlatformNotInitialized,
    fplAudioResultType_BackendAlreadyInitialized,
    fplAudioResultType_UnsetAudioFormat,
    fplAudioResultType_UnsetAudioChannels,
    fplAudioResultType_UnsetAudioSampleRate,
    fplAudioResultType_UnsetAudioBufferSize,
    fplAudioResultType_Failed,
 
    fplAudioResultType_First = fplAudioResultType_None,
    fplAudioResultType_Last = fplAudioResultType_Failed,
} fplAudioResultType;
 
fpl_common_api fplAudioBackendType fplGetAudioBackendType();
fpl_common_api fplAudioResultType fplPlayAudio();
fpl_common_api fplAudioResultType fplStopAudio();
fpl_common_api bool fplGetAudioHardwareFormat(fplAudioDeviceFormat *outFormat);
fpl_common_api bool fplSetAudioClientReadCallback(fpl_audio_client_read_callback *newCallback, void *userData);
fpl_common_api uint32_t fplGetAudioDevices(fplAudioDeviceInfo *devices, uint32_t maxDeviceCount);
fpl_common_api uint32_t fplGetAudioSampleSizeInBytes(const fplAudioFormatType format);
fpl_common_api const char *fplGetAudioFormatName(const fplAudioFormatType format);
fpl_common_api const char *fplGetAudioBackendName(fplAudioBackendType backendType);
fpl_common_api uint32_t fplGetAudioBufferSizeInFrames(uint32_t sampleRate, uint32_t bufferSizeInMilliSeconds);
fpl_common_api uint32_t fplGetAudioBufferSizeInMilliseconds(uint32_t sampleRate, uint32_t frameCount);
fpl_common_api uint32_t fplGetAudioFrameSizeInBytes(const fplAudioFormatType format, const uint32_t channelCount);
fpl_common_api uint32_t fplGetAudioBufferSizeInBytes(const fplAudioFormatType format, const uint32_t channelCount, const uint32_t frameCount);
fpl_common_api void fplConvertAudioTargetFormatToDeviceFormat(const fplAudioTargetFormat *inFormat, fplAudioDeviceFormat *outFormat);
 
#endif // FPL__ENABLE_AUDIO
 
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
 
typedef enum fplLocaleFormat {
    fplLocaleFormat_None = 0,
    fplLocaleFormat_ISO639,
} fplLocaleFormat;
 
fpl_platform_api size_t fplGetUserLocale(const fplLocaleFormat targetFormat, char *buffer, const size_t maxBufferLen);
 
fpl_platform_api size_t fplGetSystemLocale(const fplLocaleFormat targetFormat, char *buffer, const size_t maxBufferLen);
 
fpl_platform_api size_t fplGetInputLocale(const fplLocaleFormat targetFormat, char *buffer, const size_t maxBufferLen);
 
// Ignore any doxygen documentation from here
 
// ****************************************************************************
//
// > EXPORT
//
// Internal functions for static library
// Entry-Point forward declaration
//
// ****************************************************************************
#if defined(FPL_PLATFORM_WINDOWS)
#   if defined(FPL_ENTRYPOINT)
// @NOTE(final): Required for access "main" from the actual win32 entry point
fpl_main int main(int argc, char **args);
#   endif
#endif // FPL_PLATFORM_WINDOWS
 
#endif // FPL_HEADER_H
 
// ****************************************************************************
//
// > IMPLEMENTATION
//
// FPL uses several implementation blocks to structure things in categories.
// Each block has its own ifdef definition to collapse it down if needed.
// But the baseline structure is the following:
//
// - Compiler settings (Disable warnings, etc.)
// - Platform Constants & Types (All required structs, Constants, Global variables, etc.)
// - Common implementations
// - Actual platform implementations (Win32, Linux)
// - Sub platform implementations (X11, POSIX, STD)
// - Backend implementations (Video: OpenGL/Software/Vulkan, Audio: DirectSound/Alsa)
// - Systems (Audio, Video, Window systems)
// - Core (Init & Release of the specific platform by selection)
//
// You can use the following strings to search for implementation blocks - including the > prefix:
//
// > COMPILER_CONFIG
// > PLATFORM_INCLUDES
//
// > INTERNAL_TOP
// > INTERNAL_LOGGING
//
// > PLATFORM_CONSTANTS
// > UTILITY_FUNCTIONS
//
// > TYPES
// > TYPES_WIN32
// > TYPES_POSIX
// > TYPES_LINUX
// > TYPES_X11
//
// > PLATFORM_STATES
//
// > COMMON
//
// > WIN32_PLATFORM
// > POSIX_SUBPLATFORM (Linux, Unix)
// > STD_STRINGS_SUBPLATFORM
// > STD_CONSOLE_SUBPLATFORM
// > X11_SUBPLATFORM
// > LINUX_PLATFORM
// > UNIX_PLATFORM
//
// > VIDEO_BACKENDS
// > VIDEO_BACKEND_OPENGL_WIN32
// > VIDEO_BACKEND_OPENGL_X11
// > VIDEO_BACKEND_SOFTWARE_WIN32
// > VIDEO_BACKEND_SOFTWARE_X11
// > VIDEO_BACKEND_VULKAN
//
// > AUDIO_BACKENDS
// > AUDIO_BACKEND_DIRECTSOUND
// > AUDIO_BACKEND_ALSA
//
// > SYSTEM_AUDIO_L1
// > SYSTEM_VIDEO_L1
// > SYSTEM_WINDOW
// > SYSTEM_AUDIO_L2
// > SYSTEM_VIDEO_L2 (Video backbuffer access and present of the frame)
// > SYSTEM_INIT (Init & Release of the Platform)
//
// ****************************************************************************
#if (defined(FPL_IMPLEMENTATION) || FPL_IS_IDE) && !defined(FPL__IMPLEMENTED)
#define FPL__IMPLEMENTED
 
// ############################################################################
//
// > COMPILER_CONFIG
//
// ############################################################################
#if !defined(FPL__COMPILER_CONFIG_DEFINED)
#define FPL__COMPILER_CONFIG_DEFINED
 
//
// Compiler warnings
//
#if defined(FPL_COMPILER_MSVC)
 
    // Start to overwrite warning settings (MSVC)
#   pragma warning( push )
 
    // Disable noexcept compiler warning for C++
#   pragma warning( disable : 4577 )
    // Disable "switch statement contains 'default' but no 'case' labels" compiler warning for C++
#   pragma warning( disable : 4065 )
    // Disable "conditional expression is constant" warning
#   pragma warning( disable : 4127 )
    // Disable "unreferenced formal parameter" warning
#   pragma warning( disable : 4100 )
    // Disable "nonstandard extension used: nameless struct/union" warning
#   pragma warning( disable : 4201 )
    // Disable "local variable is initialized but not referenced" warning
#   pragma warning( disable : 4189 )
    // Disable "nonstandard extension used: non-constant aggregate initializer" warning
#   pragma warning( disable : 4204 )
 
#elif defined(FPL_COMPILER_GCC)
 
    // Start to overwrite warning settings (GCC)
#   pragma GCC diagnostic push
// Disable warning -Wunused-variable
#   pragma GCC diagnostic ignored "-Wunused-variable"
// Disable warning -Wunused-function
#   pragma GCC diagnostic ignored "-Wunused-function"
 
#elif defined(FPL_COMPILER_CLANG)
 
    // Start to overwrite warning settings (Clang)
#   pragma clang diagnostic push
 
// Disable warning -Wunused-variable
#   pragma clang diagnostic ignored "-Wunused-variable"
// Disable warning -Wunused-function
#   pragma clang diagnostic ignored "-Wunused-function"
 
#endif // FPL_COMPILER
 
#endif // FPL__COMPILER_CONFIG_DEFINED
 
// ############################################################################
//
// > PLATFORM_INCLUDES
//
// ############################################################################
#if !defined(FPL__PLATFORM_INCLUDES_DEFINED)
#define FPL__PLATFORM_INCLUDES_DEFINED
 
#if !defined(FPL__HAS_PLATFORM_INCLUDES)
#   define FPL__HAS_PLATFORM_INCLUDES
 
#   if defined(FPL_PLATFORM_WINDOWS)
        // @NOTE(final): windef.h defines min/max macros in lowerspace, this will break for example std::min/max so we have to tell the header we dont want this!
#       if !defined(NOMINMAX)
#           define NOMINMAX
#       endif
        // @NOTE(final): For now we dont want any network, com or gdi stuff at all, maybe later who knows.
#       if !defined(WIN32_LEAN_AND_MEAN)
#           define WIN32_LEAN_AND_MEAN 1
#       endif
        // @STUPID(final): Workaround for "combaseapi.h(229): error C2187: syntax error: 'identifier' was unexpected here"
struct IUnknown;
#       include <windows.h> // Win32 api
#       if _WIN32_WINNT < 0x0600
#       error "Windows Vista or higher required!"
#       endif
#   endif // FPL_PLATFORM_WINDOWS
 
#   if defined(FPL_SUBPLATFORM_POSIX)
#       include <pthread.h> // pthread_t, pthread_mutex_, pthread_cond_, pthread_barrier_
#       include <sched.h> // sched_param, sched_get_priority_max, SCHED_FIFO
#       include <semaphore.h> // sem_t
#       include <dirent.h> // DIR, dirent
#   endif // FPL_SUBPLATFORM_POSIX
 
#   if defined(FPL_SUBPLATFORM_X11)
#       include <X11/X.h> // Window
#       include <X11/Xlib.h> // Display
#       include <X11/Xutil.h> // XVisualInfo
#       include <X11/Xatom.h> // XA_CARDINAL
#   endif // FPL_SUBPLATFORM_X11
 
#endif // !FPL__HAS_PLATFORM_INCLUDES
 
//
// Test OS handles
//
#if defined(FPL_PLATFORM_WINDOWS)
fplStaticAssert(sizeof(fpl__Win32Handle) >= sizeof(HANDLE));
fplStaticAssert(sizeof(fpl__Win32LibraryHandle) >= sizeof(HANDLE));
fplStaticAssert(sizeof(fpl__Win32FileHandle) >= sizeof(HANDLE));
fplStaticAssert(sizeof(fpl__Win32ThreadHandle) >= sizeof(HANDLE));
fplStaticAssert(sizeof(fpl__Win32MutexHandle) >= sizeof(CRITICAL_SECTION));
fplStaticAssert(sizeof(fpl__Win32SemaphoreHandle) >= sizeof(HANDLE));
fplStaticAssert(sizeof(fpl__Win32ConditionVariable) >= sizeof(CONDITION_VARIABLE));
#elif defined(FPL_SUBPLATFORM_POSIX)
fplStaticAssert(sizeof(fpl__POSIXLibraryHandle) >= sizeof(void *));
fplStaticAssert(sizeof(fpl__POSIXFileHandle) >= sizeof(int));
fplStaticAssert(sizeof(fpl__POSIXDirHandle) >= sizeof(DIR *));
fplStaticAssert(sizeof(fpl__POSIXThreadHandle) >= sizeof(pthread_t));
fplStaticAssert(sizeof(fpl__POSIXMutexHandle) >= sizeof(pthread_mutex_t));
fplStaticAssert(sizeof(fpl__POSIXSemaphoreHandle) >= sizeof(sem_t));
fplStaticAssert(sizeof(fpl__POSIXConditionVariable) >= sizeof(pthread_cond_t));
#endif // FPL_PLATFORM_WINDOWS / FPL_SUBPLATFORM_POSIX
#if defined(FPL_PLATFORM_LINUX)
fplStaticAssert(sizeof(fpl__LinuxSignalHandle) >= sizeof(int));
#endif // FPL_PLATFORM_LINUX
 
//
// Compiler Includes
//
#if defined(FPL_COMPILER_MSVC)
#   include <intrin.h> // __cpuid, _Interlocked*
#elif defined(FPL_COMPILER_GCC) || defined(FPL_COMPILER_CLANG)
#   if defined(FPL_ARCH_X86) || defined(FPL_ARCH_X64)
#       include <cpuid.h> // __cpuid_count
#   endif // X86 or X64
#endif
 
// Only include C-Runtime functions when CRT is enabled
#if !defined(FPL_NO_CRT)
#   include <stdio.h> // stdin, stdout, stderr, fprintf, vfprintf, vsnprintf, getchar
#   include <stdlib.h> // wcstombs, mbstowcs, getenv
#   include <locale.h> // setlocale, struct lconv, localeconv
#endif
 
#endif // FPL__PLATFORM_INCLUDES_DEFINED
 
// ############################################################################
//
// > INTERNAL_TOP
//
// ############################################################################
#if !defined(FPL__INTERNAL_TOP_DEFINED)
#define FPL__INTERNAL_TOP_DEFINED
 
// Module constants used for logging
#define FPL__MODULE_CORE "Core"
#define FPL__MODULE_FILES "Files"
#define FPL__MODULE_THREADING "Threading"
#define FPL__MODULE_MEMORY "Memory"
#define FPL__MODULE_WINDOW "Window"
#define FPL__MODULE_LIBRARIES "Libraries"
#define FPL__MODULE_OS "OS"
#define FPL__MODULE_HARDWARE "Hardware"
#define FPL__MODULE_STRINGS "Strings"
#define FPL__MODULE_PATHS "Paths"
#define FPL__MODULE_ARGS "Arguments"
 
#define FPL__MODULE_AUDIO "Audio"
#define FPL__MODULE_AUDIO_DIRECTSOUND "DirectSound"
#define FPL__MODULE_AUDIO_ALSA "ALSA"
 
#define FPL__MODULE_VIDEO "Video"
#define FPL__MODULE_VIDEO_OPENGL "OpenGL"
#define FPL__MODULE_VIDEO_VULKAN "Vulkan"
#define FPL__MODULE_VIDEO_SOFTWARE "Software"
 
#define FPL__MODULE_WIN32 "Win32"
#define FPL__MODULE_XINPUT "XInput"
 
#define FPL__MODULE_LINUX "Linux"
#define FPL__MODULE_UNIX "Unix"
#define FPL__MODULE_POSIX "POSIX"
#define FPL__MODULE_PTHREAD "pthread"
#define FPL__MODULE_X11 "X11"
#define FPL__MODULE_GLX "GLX"
 
//
// Enum macros
//
#define FPL__ENUM_COUNT(first, last) ((last) - (first) + 1)
#define FPL__ENUM_VALUE_TO_ARRAY_INDEX(value, first, last) (((value) >= (first) && (value) <= (last)) ? ((value) - (first)) : 0)
 
//
// Internal memory
//
fpl_internal void *fpl__AllocateMemory(const fplMemoryAllocationSettings *allocSettings, const size_t size, const size_t alignment);
fpl_internal void fpl__ReleaseMemory(const fplMemoryAllocationSettings *allocSettings, void *ptr);
 
#endif // FPL__INTERNAL_TOP_DEFINED
 
// ############################################################################
//
// > INTERNAL_LOGGING
//
// ############################################################################
#if !defined(FPL__INTERNAL_LOGGING_DEFINED)
#define FPL__INTERNAL_LOGGING_DEFINED
 
#define FPL__MODULE_CONCAT(mod, format) "[" mod "] " format
 
#if defined(FPL__ENABLE_LOGGING)
fpl_globalvar fplLogSettings fpl__global__LogSettings = fplZeroInit;
 
#define FPL__LOGLEVEL_COUNT FPL__ENUM_COUNT(fplLogLevel_First, fplLogLevel_Last)
fpl_globalvar const char *fpl__LogLevelNameTable[] = {
    "All", // fplLogLevel_All (-1)
    "Critical", // fplLogLevel_Critical (0)
    "Error", // fplLogLevel_Error (1)
    "Warning", // fplLogLevel_Warning (2)
    "Info", // fplLogLevel_Info (3)
    "Verbose", // fplLogLevel_Verbose (4)
    "Debug", // fplLogLevel_Debug (5)
    "Trace", // fplLogLevel_Trace (6)
};
fplStaticAssert(fplArrayCount(fpl__LogLevelNameTable) == FPL__LOGLEVEL_COUNT);
 
fpl_internal const char *fpl__LogLevelToString(const fplLogLevel level) {
    uint32_t index = FPL__ENUM_VALUE_TO_ARRAY_INDEX(level, fplLogLevel_First, fplLogLevel_Last);
    const char *result = fpl__LogLevelNameTable[index];
    return(result);
}
 
fpl_internal void fpl__LogWrite(const char *funcName, const int lineNumber, const fplLogLevel level, const char *message) {
    fplLogSettings *settings = &fpl__global__LogSettings;
    if (!settings->isInitialized) {
#if defined(FPL_LOG_MULTIPLE_WRITERS)
        settings->criticalWriter.console.logToError = true;
        settings->criticalWriter.flags = fplLogWriterFlags_ErrorConsole | fplLogWriterFlags_DebugOut;
        settings->errorWriter = settings->criticalWriter;
        settings->warningWriter = settings->criticalWriter;
        settings->infoWriter.flags = fplLogWriterFlags_StandardConsole | fplLogWriterFlags_DebugOut;
        settings->verboseWriter = settings->infoWriter;
        settings->debugWriter.flags = fplLogWriterFlags_DebugOut;
#else
        settings->writers[0].flags = fplLogWriterFlags_StandardConsole | fplLogWriterFlags_DebugOut;
#endif
        settings->maxLevel = fplLogLevel_Warning;
        settings->isInitialized = true;
    }
 
    if ((settings->maxLevel == -1) || (level <= settings->maxLevel)) {
#if defined(FPL_LOG_MULTIPLE_WRITERS)
        fplAssert(level < fplArrayCount(settings->writers));
        const fplLogWriter *writer = &settings->writers[(int)level];
#else
        const fplLogWriter *writer = &settings->writers[0];
#endif
        const char *levelStr = fpl__LogLevelToString(level);
 
        if (writer->flags & fplLogWriterFlags_StandardConsole) {
            fplConsoleFormatOut("[%s:%d][%s] %s\n", funcName, lineNumber, levelStr, message);
        }
        if (writer->flags & fplLogWriterFlags_ErrorConsole) {
            fplConsoleFormatError("[%s:%d][%s] %s\n", funcName, lineNumber, levelStr, message);
        }
        if (writer->flags & fplLogWriterFlags_DebugOut) {
            fplDebugFormatOut("[%s:%d][%s] %s\n", funcName, lineNumber, levelStr, message);
        }
        if (writer->flags & fplLogWriterFlags_Custom && writer->custom.callback != fpl_null) {
            writer->custom.callback(funcName, lineNumber, level, message);
        }
    }
}
fpl_internal void fpl__LogWriteArgs(const char *funcName, const int lineNumber, const fplLogLevel level, const char *format, va_list argList) {
    va_list listCopy;
    va_copy(listCopy, argList);
    char buffer[FPL_MAX_BUFFER_LENGTH];
    size_t formattedLen = fplStringFormatArgs(buffer, fplArrayCount(buffer), format, listCopy);
    if (formattedLen > 0) {
        fpl__LogWrite(funcName, lineNumber, level, buffer);
    }
    va_end(listCopy);
}
 
fpl_internal void fpl__LogWriteVarArgs(const char *funcName, const int lineNumber, const fplLogLevel level, const char *format, ...) {
    va_list argList;
    va_start(argList, format);
    fpl__LogWriteArgs(funcName, lineNumber, level, format, argList);
    va_end(argList);
}
 
#   define FPL_LOG(lvl, mod, format, ...) fpl__LogWriteVarArgs(FPL_FUNCTION_NAME, __LINE__, lvl, FPL__MODULE_CONCAT(mod, format), ## __VA_ARGS__)
#   define FPL_LOG_CRITICAL(mod, format, ...) FPL_LOG(fplLogLevel_Critical, mod, format, ## __VA_ARGS__)
#   define FPL_LOG_ERROR(mod, format, ...) FPL_LOG(fplLogLevel_Error, mod, format, ## __VA_ARGS__)
#   define FPL_LOG_WARN(mod, format, ...) FPL_LOG(fplLogLevel_Warning, mod, format, ## __VA_ARGS__)
#   define FPL_LOG_INFO(mod, format, ...) FPL_LOG(fplLogLevel_Info, mod, format, ## __VA_ARGS__)
#   define FPL_LOG_VERBOSE(mod, format, ...) FPL_LOG(fplLogLevel_Verbose, mod, format, ## __VA_ARGS__)
#   define FPL_LOG_DEBUG(mod, format, ...) FPL_LOG(fplLogLevel_Debug, mod, format, ## __VA_ARGS__)
#   define FPL_LOG_TRACE(mod, format, ...) FPL_LOG(fplLogLevel_Trace, mod, format, ## __VA_ARGS__)
 
#   define FPL__LOG_FUNCTION_N(mod, name) FPL_LOG(fplLogLevel_Debug, mod, "-> %s()", name)
#   define FPL_LOG_FUNCTION(mod) FPL__LOG_FUNCTION_N(mod, FPL_FUNCTION_NAME)
 
#else
 
#   define FPL_LOG(lvl, mod, format, ...)
#   define FPL_LOG_CRITICAL(mod, format, ...)
#   define FPL_LOG_ERROR(mod, format, ...)
#   define FPL_LOG_WARN(mod, format, ...)
#   define FPL_LOG_INFO(mod, format, ...)
#   define FPL_LOG_VERBOSE(mod, format, ...)
#   define FPL_LOG_DEBUG(mod, format, ...)
#   define FPL_LOG_FUNCTION(mod)
 
#endif
 
//
// Error handling
//
 
#define FPL__M_CRITICAL(funcName, line, mod, format, ...)  fpl__HandleError(funcName, line, fplLogLevel_Critical, FPL__MODULE_CONCAT(mod, format), ## __VA_ARGS__)
#define FPL__M_ERROR(funcName, line, mod, format, ...) fpl__HandleError(funcName, line, fplLogLevel_Error, FPL__MODULE_CONCAT(mod, format), ## __VA_ARGS__)
#define FPL__M_WARNING(funcName, line, mod, format, ...) fpl__HandleError(funcName, line, fplLogLevel_Warning, FPL__MODULE_CONCAT(mod, format), ## __VA_ARGS__)
 
#define FPL__CRITICAL(mod, format, ...)  FPL__M_CRITICAL(FPL_FUNCTION_NAME, __LINE__, mod, format, ## __VA_ARGS__)
#define FPL__ERROR(mod, format, ...) FPL__M_ERROR(FPL_FUNCTION_NAME, __LINE__, mod, format, ## __VA_ARGS__)
#define FPL__WARNING(mod, format, ...) FPL__M_WARNING(FPL_FUNCTION_NAME, __LINE__, mod, format, ## __VA_ARGS__)
 
#endif // FPL__INTERNAL_LOGGING_DEFINED
 
// ############################################################################
//
// > PLATFORM_CONSTANTS
//
// ############################################################################
#if !defined(FPL__PLATFORM_CONSTANTS_DEFINED)
#define FPL__PLATFORM_CONSTANTS_DEFINED
 
// One cacheline worth of padding
#define FPL__ARBITARY_PADDING 64
// Small padding to split sections in memory blocks
#define FPL__MEMORY_PADDING sizeof(uintptr_t)
 
fpl_globalvar struct fpl__PlatformAppState *fpl__global__AppState = fpl_null;
 
fpl_internal void fpl__HandleError(const char *funcName, const int lineNumber, const fplLogLevel level, const char *format, ...);
#endif // FPL__PLATFORM_CONSTANTS_DEFINED
 
// ############################################################################
//
// > UTILITY_FUNCTIONS
//
// ############################################################################
fpl_internal void *fpl__AllocateMemory(const fplMemoryAllocationSettings *allocSettings, const size_t size, const size_t alignment) {
    if (allocSettings->mode == fplMemoryAllocationMode_Custom) {
        if (allocSettings->allocateCallback != fpl_null && allocSettings->releaseCallback != fpl_null) {
            return allocSettings->allocateCallback(allocSettings->userData, size, alignment);
        }
    }
    return fplMemoryAlignedAllocate(size, alignment);
}
 
fpl_internal void fpl__ReleaseMemory(const fplMemoryAllocationSettings *allocSettings, void *ptr) {
    if (allocSettings->mode == fplMemoryAllocationMode_Custom) {
        if (allocSettings->allocateCallback != fpl_null && allocSettings->releaseCallback != fpl_null) {
            allocSettings->releaseCallback(allocSettings->userData, ptr);
            return;
        }
    }
    fplMemoryAlignedFree(ptr);
}
 
// Forward declarations of internal memory
fpl_internal void *fpl__AllocateDynamicMemory(const size_t size, const size_t alignment);
fpl_internal void fpl__ReleaseDynamicMemory(void *ptr);
fpl_internal void *fpl__AllocateTemporaryMemory(const size_t size, const size_t alignment);
fpl_internal void fpl__ReleaseTemporaryMemory(void *ptr);
 
fpl_internal uint32_t fpl__NextPowerOfTwo(const uint32_t input) {
    uint32_t x = input;
    x--;
    x |= x >> 1;
    x |= x >> 2;
    x |= x >> 4;
    x |= x >> 8;
    x |= x >> 16;
    x++;
    return(x);
}
fpl_internal uint32_t fpl__PrevPowerOfTwo(const uint32_t input) {
    uint32_t result = fpl__NextPowerOfTwo(input) >> 1;
    return(result);
}
 
fpl_internal uint32_t fpl__RoundToPowerOfTwo(const uint32_t input) {
    uint32_t prev = fpl__PrevPowerOfTwo(input);
    uint32_t next = fpl__NextPowerOfTwo(input);
    if ((next - input) < (input - prev)) {
        return prev;
    } else {
        return next;
    }
}
 
fpl_internal bool fpl__AddLineWhenAnyMatches(const char *line, const char **wildcards, const size_t maxWildcardCount, const size_t maxLineSize, const size_t maxLineCount, char **outLines, size_t *outCount) {
    for (size_t i = 0; i < maxWildcardCount; ++i) {
        const char *wildcard = wildcards[i];
        if (fplIsStringMatchWildcard(line, wildcard)) {
            size_t index = *outCount;
            char *target = outLines[index];
            fplCopyString(line, target, maxLineSize);
            *outCount = index + 1;
            break;
        }
    }
    bool result = *outCount < maxLineCount;
    return(result);
}
 
fpl_internal size_t fpl__ParseTextFile(const char *filePath, const char **wildcards, const size_t maxWildcardCount, const size_t maxLineSize, const size_t maxLineCount, char **outLines) {
    if (filePath == fpl_null || wildcards == fpl_null || maxWildcardCount == 0 || maxLineSize == 0 || maxLineCount == 0 || outLines == fpl_null) {
        return(0);
    }
    // @NOTE(final): Forced Zero-Terminator is not nessecary here, but we do it here to debug it better
    // This function supports maxLineSize < fplArrayCount(buffer)
    // We allocate the line buffer on the stack because we do not know how large the line will be on compile time
    size_t result = 0;
    fplFileHandle fileHandle = fplZeroInit;
    if (fplFileOpenBinary(filePath, &fileHandle)) {
        char *line = (char *)fpl__AllocateTemporaryMemory(maxLineSize, 8);
        char buffer[FPL_MAX_BUFFER_LENGTH];
        const size_t maxBufferSize = fplArrayCount(buffer) - 1;
        size_t bytesRead = 0;
        size_t posLineBytes = 0;
        bool done = false;
        while (!done && ((bytesRead = fplFileReadBlock(&fileHandle, maxBufferSize, &buffer[0], maxBufferSize)) > 0)) {
            buffer[bytesRead] = 0;
            char *start = &buffer[0];
            char *p = start;
            size_t readPos = 0;
            size_t lineSizeToRead = 0;
            while (readPos < bytesRead) {
                if (*p == '\n') {
                    size_t remainingLineBytes = maxLineSize - posLineBytes;
                    char *lineTargetP = line + posLineBytes;
                    if (lineSizeToRead < remainingLineBytes) {
                        fplCopyStringLen(start, lineSizeToRead, lineTargetP, remainingLineBytes);
                    } else {
                        fplCopyStringLen(start, remainingLineBytes - 1, lineTargetP, remainingLineBytes);
                    }
                    if (!fpl__AddLineWhenAnyMatches(line, wildcards, maxWildcardCount, maxLineSize, maxLineCount, outLines, &result)) {
                        done = true;
                        break;
                    }
                    start = p + 1;
                    line[0] = 0;
                    lineSizeToRead = 0;
                    posLineBytes = 0;
                } else {
                    ++lineSizeToRead;
                }
                ++p;
                ++readPos;
            }
            if (done) {
                break;
            }
            if (lineSizeToRead > 0) {
                size_t remainingLineBytes = maxLineSize - posLineBytes;
                char *lineTargetP = line + posLineBytes;
                if (lineSizeToRead < remainingLineBytes) {
                    fplCopyStringLen(start, lineSizeToRead, lineTargetP, remainingLineBytes);
                    posLineBytes += lineSizeToRead;
                    if (bytesRead <= maxBufferSize) {
                        if (!fpl__AddLineWhenAnyMatches(line, wildcards, maxWildcardCount, maxLineSize, maxLineCount, outLines, &result)) {
                            done = true;
                        }
                    }
                } else {
                    fplCopyStringLen(start, remainingLineBytes - 1, lineTargetP, remainingLineBytes);
                    line[0] = 0;
                    lineSizeToRead = 0;
                    posLineBytes = 0;
                    if (!fpl__AddLineWhenAnyMatches(line, wildcards, maxWildcardCount, maxLineSize, maxLineCount, outLines, &result)) {
                        done = true;
                    }
                }
            }
        }
        fpl__ReleaseTemporaryMemory(line);
        fplFileClose(&fileHandle);
    }
    return(result);
}
 
fpl_internal void fpl__ParseVersionString(const char *versionStr, fplVersionInfo *versionInfo) {
    fplCopyString(versionStr, versionInfo->fullName, fplArrayCount(versionInfo->fullName));
    if (versionStr != fpl_null) {
        const char *p = versionStr;
        for (int i = 0; i < 4; ++i) {
            const char *digitStart = p;
            while (*p >= '0' && *p <= '9') {
                ++p;
            }
            size_t len = p - digitStart;
            if (len <= fplArrayCount(versionInfo->values[i])) {
                fplCopyStringLen(digitStart, len, versionInfo->values[i], fplArrayCount(versionInfo->values[i]));
            } else {
                versionInfo->values[i][0] = 0;
            }
            if (*p != '.' && *p != '-') break;
            ++p;
        }
    }
}
 
// ****************************************************************************
//
// > TYPES
//
// This implementation block includes all the required platform-specific
// header files and defines all the constants, structures and types.
//
// ****************************************************************************
 
// ############################################################################
//
// > TYPES_WIN32
//
// ############################################################################
#if defined(FPL_PLATFORM_WINDOWS)
#   include <windowsx.h>    // Macros for window messages
#   include <shlobj.h>      // SHGetFolderPath
#   include <xinput.h>      // XInputGetState
#   include <shellapi.h>    // HDROP
 
#   if defined(FPL_IS_CPP)
#       define fpl__Win32IsEqualGuid(a, b) InlineIsEqualGUID(a, b)
#   else
#       define fpl__Win32IsEqualGuid(a, b) InlineIsEqualGUID(&a, &b)
#   endif
 
fpl_internal const char *fpl__Win32FormatGuidString(char *buffer, const size_t maxBufferLen, const GUID *guid) {
    fplStringFormat(buffer, maxBufferLen, "{%08lX-%04hX-%04hX-%02hhX%02hhX-%02hhX%02hhX%02hhX%02hhX%02hhX%02hhX}",
        guid->Data1, guid->Data2, guid->Data3,
        guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
        guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]);
    return(buffer);
}
 
// Little macro to not write 5 lines of code all the time
#define FPL__WIN32_LOAD_LIBRARY_BREAK(mod, target, libName) \
    (target) = LoadLibraryA(libName); \
    if((target) == fpl_null) { \
        FPL__WARNING(mod, "Failed loading library '%s'", (libName)); \
        break; \
    }
#define FPL__WIN32_GET_FUNCTION_ADDRESS_BREAK(mod, libHandle, libName, target, type, name) \
    (target)->name = (type *)GetProcAddress(libHandle, #name); \
    if ((target)->name == fpl_null) { \
        FPL__WARNING(mod, "Failed getting procedure address '%s' from library '%s'", #name, libName); \
        break; \
    }
#if !defined(FPL_NO_RUNTIME_LINKING)
#   define FPL__WIN32_LOAD_LIBRARY FPL__WIN32_LOAD_LIBRARY_BREAK
#   define FPL__WIN32_GET_FUNCTION_ADDRESS FPL__WIN32_GET_FUNCTION_ADDRESS_BREAK
#else
#   define FPL__WIN32_LOAD_LIBRARY(mod, target, libName)
#   define FPL__WIN32_GET_FUNCTION_ADDRESS(mod, libHandle, libName, target, type, name) \
        (target)->name = name
#endif
 
//
// XInput
//
#define FPL__FUNC_XINPUT_XInputGetState(name) DWORD WINAPI name(DWORD dwUserIndex, XINPUT_STATE *pState)
typedef FPL__FUNC_XINPUT_XInputGetState(fpl__win32_func_XInputGetState);
FPL__FUNC_XINPUT_XInputGetState(fpl__Win32XInputGetStateStub) {
    return(ERROR_DEVICE_NOT_CONNECTED);
}
#define FPL__FUNC_XINPUT_XInputGetCapabilities(name) DWORD WINAPI name(DWORD dwUserIndex, DWORD dwFlags, XINPUT_CAPABILITIES* pCapabilities)
typedef FPL__FUNC_XINPUT_XInputGetCapabilities(fpl__win32_func_XInputGetCapabilities);
FPL__FUNC_XINPUT_XInputGetCapabilities(fpl__Win32XInputGetCapabilitiesStub) {
    return(ERROR_DEVICE_NOT_CONNECTED);
}
typedef struct fpl__Win32XInputApi {
    HMODULE xinputLibrary;
    fpl__win32_func_XInputGetState *XInputGetState;
    fpl__win32_func_XInputGetCapabilities *XInputGetCapabilities;
} fpl__Win32XInputApi;
 
fpl_internal void fpl__Win32UnloadXInputApi(fpl__Win32XInputApi *xinputApi) {
    fplAssert(xinputApi != fpl_null);
    if (xinputApi->xinputLibrary) {
        FPL_LOG_DEBUG("XInput", "Unload XInput Library");
        FreeLibrary(xinputApi->xinputLibrary);
        xinputApi->xinputLibrary = fpl_null;
        xinputApi->XInputGetState = fpl__Win32XInputGetStateStub;
        xinputApi->XInputGetCapabilities = fpl__Win32XInputGetCapabilitiesStub;
    }
}
 
fpl_internal void fpl__Win32LoadXInputApi(fpl__Win32XInputApi *xinputApi) {
    fplAssert(xinputApi != fpl_null);
    const char *xinputFileNames[] = {
        "xinput1_4.dll",
        "xinput1_3.dll",
        "xinput9_1_0.dll",
    };
    bool result = false;
    for (uint32_t index = 0; index < fplArrayCount(xinputFileNames); ++index) {
        const char *libName = xinputFileNames[index];
        fplClearStruct(xinputApi);
        do {
            HMODULE libHandle = fpl_null;
            FPL__WIN32_LOAD_LIBRARY_BREAK(FPL__MODULE_XINPUT, libHandle, libName);
            xinputApi->xinputLibrary = libHandle;
            FPL__WIN32_GET_FUNCTION_ADDRESS_BREAK(FPL__MODULE_XINPUT, libHandle, libName, xinputApi, fpl__win32_func_XInputGetState, XInputGetState);
            FPL__WIN32_GET_FUNCTION_ADDRESS_BREAK(FPL__MODULE_XINPUT, libHandle, libName, xinputApi, fpl__win32_func_XInputGetCapabilities, XInputGetCapabilities);
            result = true;
        } while (0);
        if (result) {
            break;
        }
        fpl__Win32UnloadXInputApi(xinputApi);
    }
 
    if (!result) {
        xinputApi->XInputGetState = fpl__Win32XInputGetStateStub;
        xinputApi->XInputGetCapabilities = fpl__Win32XInputGetCapabilitiesStub;
    }
}
 
//
// WINAPI functions
//
 
// GDI32
#define FPL__FUNC_WIN32_ChoosePixelFormat(name) int WINAPI name(HDC hdc, CONST PIXELFORMATDESCRIPTOR *ppfd)
typedef FPL__FUNC_WIN32_ChoosePixelFormat(fpl__win32_func_ChoosePixelFormat);
#define FPL__FUNC_WIN32_SetPixelFormat(name) BOOL WINAPI name(HDC hdc, int format, CONST PIXELFORMATDESCRIPTOR *ppfd)
typedef FPL__FUNC_WIN32_SetPixelFormat(fpl__win32_func_SetPixelFormat);
#define FPL__FUNC_WIN32_DescribePixelFormat(name) int WINAPI name(HDC hdc, int iPixelFormat, UINT nBytes, LPPIXELFORMATDESCRIPTOR ppfd)
typedef FPL__FUNC_WIN32_DescribePixelFormat(fpl__win32_func_DescribePixelFormat);
#define FPL__FUNC_WIN32_GetDeviceCaps(name) int WINAPI name(HDC hdc, int index)
typedef FPL__FUNC_WIN32_GetDeviceCaps(fpl__win32_func_GetDeviceCaps);
#define FPL__FUNC_WIN32_StretchDIBits(name) int WINAPI name(HDC hdc, int xDest, int yDest, int DestWidth, int DestHeight, int xSrc, int ySrc, int SrcWidth, int SrcHeight, CONST VOID *lpBits, CONST BITMAPINFO *lpbmi, UINT iUsage, DWORD rop)
typedef FPL__FUNC_WIN32_StretchDIBits(fpl__win32_func_StretchDIBits);
#define FPL__FUNC_WIN32_DeleteObject(name) BOOL WINAPI name( _In_ HGDIOBJ ho)
typedef FPL__FUNC_WIN32_DeleteObject(fpl__win32_func_DeleteObject);
#define FPL__FUNC_WIN32_SwapBuffers(name) BOOL WINAPI name(HDC)
typedef FPL__FUNC_WIN32_SwapBuffers(fpl__win32_func_SwapBuffers);
#define FPL__FUNC_WIN32_CreateDIBSection(name) HBITMAP WINAPI name(HDC hdc, CONST BITMAPINFO *pbmi, UINT usage, VOID **ppvBits, HANDLE hSection, DWORD offset)
typedef FPL__FUNC_WIN32_CreateDIBSection(fpl__win32_func_CreateDIBSection);
#define FPL__FUNC_WIN32_CreateBitmap(name) HBITMAP WINAPI name(int nWidth, int nHeight, UINT nPlanes, UINT nBitCount, CONST VOID *lpBits)
typedef FPL__FUNC_WIN32_CreateBitmap(fpl__win32_func_CreateBitmap);
#define FPL__FUNC_WIN32_CreateSolidBrush(name) HBRUSH WINAPI name(COLORREF color)
typedef FPL__FUNC_WIN32_CreateSolidBrush(fpl__win32_func_CreateSolidBrush);
 
// ShellAPI
#define FPL__FUNC_WIN32_SHGetFolderPathW(name) HRESULT WINAPI name(HWND hwnd, int csidl, HANDLE hToken, DWORD dwFlags, LPWSTR pszPath)
typedef FPL__FUNC_WIN32_SHGetFolderPathW(fpl__win32_func_SHGetFolderPathW);
#define FPL__FUNC_WIN32_DragQueryFileW(name) UINT WINAPI name(HDROP hDrop, UINT iFile, LPWSTR lpszFile, UINT cch)
typedef FPL__FUNC_WIN32_DragQueryFileW(fpl__win32_func_DragQueryFileW);
#define FPL__FUNC_WIN32_DragAcceptFiles(name) void WINAPI name(HWND hWnd, BOOL fAccept)
typedef FPL__FUNC_WIN32_DragAcceptFiles(fpl__win32_func_DragAcceptFiles);
 
// User32
#define FPL__FUNC_WIN32_RegisterClassExW(name) ATOM WINAPI name(CONST WNDCLASSEXW *)
typedef FPL__FUNC_WIN32_RegisterClassExW(fpl__win32_func_RegisterClassExW);
#define FPL__FUNC_WIN32_UnregisterClassW(name) BOOL WINAPI name(LPCWSTR lpClassName, HINSTANCE hInstance)
typedef FPL__FUNC_WIN32_UnregisterClassW(fpl__win32_func_UnregisterClassW);
#define FPL__FUNC_WIN32_ShowWindow(name) BOOL WINAPI name(HWND hWnd, int nCmdShow)
typedef FPL__FUNC_WIN32_ShowWindow(fpl__win32_func_ShowWindow);
#define FPL__FUNC_WIN32_DestroyWindow(name) BOOL WINAPI name(HWND hWnd)
typedef FPL__FUNC_WIN32_DestroyWindow(fpl__win32_func_DestroyWindow);
#define FPL__FUNC_WIN32_UpdateWindow(name) BOOL WINAPI name(HWND hWnd)
typedef FPL__FUNC_WIN32_UpdateWindow(fpl__win32_func_UpdateWindow);
#define FPL__FUNC_WIN32_TranslateMessage(name) BOOL WINAPI name(CONST MSG *lpMsg)
typedef FPL__FUNC_WIN32_TranslateMessage(fpl__win32_func_TranslateMessage);
#define FPL__FUNC_WIN32_DispatchMessageW(name) LRESULT WINAPI name(CONST MSG *lpMsg)
typedef FPL__FUNC_WIN32_DispatchMessageW(fpl__win32_func_DispatchMessageW);
#define FPL__FUNC_WIN32_PeekMessageW(name) BOOL WINAPI name(LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax, UINT wRemoveMsg)
typedef FPL__FUNC_WIN32_PeekMessageW(fpl__win32_func_PeekMessageW);
#define FPL__FUNC_WIN32_DefWindowProcW(name) LRESULT WINAPI name(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
typedef FPL__FUNC_WIN32_DefWindowProcW(fpl__win32_func_DefWindowProcW);
#define FPL__FUNC_WIN32_CreateWindowExW(name) HWND WINAPI name(DWORD dwExStyle, LPCWSTR lpClassName, LPCWSTR lpWindowName, DWORD dwStyle, int X, int Y, int nWidth, int nHeight, HWND hWndParent, HMENU hMenu, HINSTANCE hInstance, LPVOID lpParam)
typedef FPL__FUNC_WIN32_CreateWindowExW(fpl__win32_func_CreateWindowExW);
#define FPL__FUNC_WIN32_SetWindowPos(name) BOOL WINAPI name(HWND hWnd, HWND hWndInsertAfter, int X, int Y, int cx, int cy, UINT uFlags)
typedef FPL__FUNC_WIN32_SetWindowPos(fpl__win32_func_SetWindowPos);
#define FPL__FUNC_WIN32_GetWindowPlacement(name) BOOL WINAPI name(HWND hWnd, WINDOWPLACEMENT *lpwndpl)
typedef FPL__FUNC_WIN32_GetWindowPlacement(fpl__win32_func_GetWindowPlacement);
#define FPL__FUNC_WIN32_SetWindowPlacement(name) BOOL WINAPI name(HWND hWnd, CONST WINDOWPLACEMENT *lpwndpl)
typedef FPL__FUNC_WIN32_SetWindowPlacement(fpl__win32_func_SetWindowPlacement);
#define FPL__FUNC_WIN32_GetClientRect(name) BOOL WINAPI name(HWND hWnd, LPRECT lpRect)
typedef FPL__FUNC_WIN32_GetClientRect(fpl__win32_func_GetClientRect);
#define FPL__FUNC_WIN32_GetWindowRect(name) BOOL WINAPI name(HWND hWnd, LPRECT lpRect)
typedef FPL__FUNC_WIN32_GetWindowRect(fpl__win32_func_GetWindowRect);
#define FPL__FUNC_WIN32_AdjustWindowRect(name) BOOL WINAPI name(LPRECT lpRect, DWORD dwStyle, BOOL bMenu)
typedef FPL__FUNC_WIN32_AdjustWindowRect(fpl__win32_func_AdjustWindowRect);
#define FPL__FUNC_WIN32_ClientToScreen(name) BOOL WINAPI name(HWND hWnd, LPPOINT lpPoint)
typedef FPL__FUNC_WIN32_ClientToScreen(fpl__win32_func_ClientToScreen);
#define FPL__FUNC_WIN32_GetAsyncKeyState(name) SHORT WINAPI name(int vKey)
typedef FPL__FUNC_WIN32_GetAsyncKeyState(fpl__win32_func_GetAsyncKeyState);
#define FPL__FUNC_WIN32_GetKeyState(name) SHORT WINAPI name(int vKey)
typedef FPL__FUNC_WIN32_GetKeyState(fpl__win32_func_GetKeyState);
#define FPL__FUNC_WIN32_MapVirtualKeyW(name) UINT WINAPI name(UINT uCode, UINT uMapType)
typedef FPL__FUNC_WIN32_MapVirtualKeyW(fpl__win32_func_MapVirtualKeyW);
#define FPL__FUNC_WIN32_SetCursor(name) HCURSOR WINAPI name(HCURSOR hCursor)
typedef FPL__FUNC_WIN32_SetCursor(fpl__win32_func_SetCursor);
#define FPL__FUNC_WIN32_GetCursor(name) HCURSOR WINAPI name(VOID)
typedef FPL__FUNC_WIN32_GetCursor(fpl__win32_func_GetCursor);
#define FPL__FUNC_WIN32_GetCursorPos(name) BOOL WINAPI name(LPPOINT lpPoint)
typedef FPL__FUNC_WIN32_GetCursorPos(fpl__win32_func_GetCursorPos);
#define FPL__FUNC_WIN32_WindowFromPoint(name) HWND WINAPI name(POINT Point)
typedef FPL__FUNC_WIN32_WindowFromPoint(fpl__win32_func_WindowFromPoint);
#define FPL__FUNC_WIN32_PtInRect(name) BOOL WINAPI name(CONST RECT *lprc, POINT pt)
typedef FPL__FUNC_WIN32_PtInRect(fpl__win32_func_PtInRect);
#define FPL__FUNC_WIN32_LoadCursorA(name) HCURSOR WINAPI name(HINSTANCE hInstance, LPCSTR lpCursorName)
typedef FPL__FUNC_WIN32_LoadCursorA(fpl__win32_func_LoadCursorA);
#define FPL__FUNC_WIN32_LoadCursorW(name) HCURSOR WINAPI name(HINSTANCE hInstance, LPCWSTR lpCursorName)
typedef FPL__FUNC_WIN32_LoadCursorW(fpl__win32_func_LoadCursorW);
#define FPL__FUNC_WIN32_LoadIconA(name) HICON WINAPI name(HINSTANCE hInstance, LPCSTR lpIconName)
typedef FPL__FUNC_WIN32_LoadIconA(fpl__win32_func_LoadIconA);
#define FPL__FUNC_WIN32_LoadIconW(name) HICON WINAPI name(HINSTANCE hInstance, LPCWSTR lpIconName)
typedef FPL__FUNC_WIN32_LoadIconW(fpl__win32_func_LoadIconW);
#define FPL__FUNC_WIN32_SetWindowTextW(name) BOOL WINAPI name(HWND hWnd, LPCWSTR lpString)
typedef FPL__FUNC_WIN32_SetWindowTextW(fpl__win32_func_SetWindowTextW);
#define FPL__FUNC_WIN32_GetWindowTextW(name) int WINAPI name(HWND hWnd, LPWSTR lpString, int nMaxCount)
typedef FPL__FUNC_WIN32_GetWindowTextW(fpl__win32_func_GetWindowTextW);
#define FPL__FUNC_WIN32_SetWindowLongW(name) LONG WINAPI name(HWND hWnd, int nIndex, LONG dwNewLong)
typedef FPL__FUNC_WIN32_SetWindowLongW(fpl__win32_func_SetWindowLongW);
#define FPL__FUNC_WIN32_GetWindowLongW(name) LONG WINAPI name(HWND hWnd, int nIndex)
typedef FPL__FUNC_WIN32_GetWindowLongW(fpl__win32_func_GetWindowLongW);
 
#if defined(FPL_ARCH_X64)
#define FPL__FUNC_WIN32_SetWindowLongPtrW(name) LONG_PTR WINAPI name(HWND hWnd, int nIndex, LONG_PTR dwNewLong)
typedef FPL__FUNC_WIN32_SetWindowLongPtrW(fpl__win32_func_SetWindowLongPtrW);
#define FPL__FUNC_WIN32_GetWindowLongPtrW(name) LONG_PTR WINAPI name(HWND hWnd, int nIndex)
typedef FPL__FUNC_WIN32_GetWindowLongPtrW(fpl__win32_func_GetWindowLongPtrW);
#endif
 
#define FPL__FUNC_WIN32_ReleaseDC(name) int WINAPI name(HWND hWnd, HDC hDC)
typedef FPL__FUNC_WIN32_ReleaseDC(fpl__win32_func_ReleaseDC);
#define FPL__FUNC_WIN32_GetDC(name) HDC WINAPI name(HWND hWnd)
typedef FPL__FUNC_WIN32_GetDC(fpl__win32_func_GetDC);
#define FPL__FUNC_WIN32_ChangeDisplaySettingsW(name) LONG WINAPI name(DEVMODEW* lpDevMode, DWORD dwFlags)
typedef FPL__FUNC_WIN32_ChangeDisplaySettingsW(fpl__win32_func_ChangeDisplaySettingsW);
#define FPL__FUNC_WIN32_EnumDisplaySettingsW(name) BOOL WINAPI name(LPCWSTR lpszDeviceName, DWORD iModeNum, DEVMODEW* lpDevMode)
typedef FPL__FUNC_WIN32_EnumDisplaySettingsW(fpl__win32_func_EnumDisplaySettingsW);
#define FPL__FUNC_WIN32_OpenClipboard(name) BOOL WINAPI name(HWND hWndNewOwner)
typedef FPL__FUNC_WIN32_OpenClipboard(fpl__win32_func_OpenClipboard);
#define FPL__FUNC_WIN32_CloseClipboard(name) BOOL WINAPI name(VOID)
typedef FPL__FUNC_WIN32_CloseClipboard(fpl__win32_func_CloseClipboard);
#define FPL__FUNC_WIN32_EmptyClipboard(name) BOOL WINAPI name(VOID)
typedef FPL__FUNC_WIN32_EmptyClipboard(fpl__win32_func_EmptyClipboard);
#define FPL__FUNC_WIN32_IsClipboardFormatAvailable(name) BOOL WINAPI name(UINT format)
typedef FPL__FUNC_WIN32_IsClipboardFormatAvailable(fpl__win32_func_IsClipboardFormatAvailable);
#define FPL__FUNC_WIN32_SetClipboardData(name) HANDLE WINAPI name(UINT uFormat, HANDLE hMem)
typedef FPL__FUNC_WIN32_SetClipboardData(fpl__win32_func_SetClipboardData);
#define FPL__FUNC_WIN32_GetClipboardData(name) HANDLE WINAPI name(UINT uFormat)
typedef FPL__FUNC_WIN32_GetClipboardData(fpl__win32_func_GetClipboardData);
#define FPL__FUNC_WIN32_GetDesktopWindow(name) HWND WINAPI name(VOID)
typedef FPL__FUNC_WIN32_GetDesktopWindow(fpl__win32_func_GetDesktopWindow);
#define FPL__FUNC_WIN32_GetForegroundWindow(name) HWND WINAPI name(VOID)
typedef FPL__FUNC_WIN32_GetForegroundWindow(fpl__win32_func_GetForegroundWindow);
#define FPL__FUNC_WIN32_IsZoomed(name) BOOL WINAPI name(HWND hWnd)
typedef FPL__FUNC_WIN32_IsZoomed(fpl__win32_func_IsZoomed);
#define FPL__FUNC_WIN32_IsIconic(name) BOOL WINAPI name(HWND hWnd)
typedef FPL__FUNC_WIN32_IsIconic(fpl__win32_func_IsIconic);
#define FPL__FUNC_WIN32_SendMessageW(name) LRESULT WINAPI name(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
typedef FPL__FUNC_WIN32_SendMessageW(fpl__win32_func_SendMessageW);
#define FPL__FUNC_WIN32_GetMonitorInfoW(name) BOOL WINAPI name(HMONITOR hMonitor, LPMONITORINFO lpmi)
typedef FPL__FUNC_WIN32_GetMonitorInfoW(fpl__win32_func_GetMonitorInfoW);
#define FPL__FUNC_WIN32_EnumDisplayMonitors(name) BOOL WINAPI name(HDC hdc, LPCRECT lprcClip, MONITORENUMPROC lpfnEnum,LPARAM dwData)
typedef FPL__FUNC_WIN32_EnumDisplayMonitors(fpl__win32_func_EnumDisplayMonitors);
#define FPL__FUNC_WIN32_MonitorFromRect(name) HMONITOR WINAPI name(LPCRECT lprc, DWORD dwFlags)
typedef FPL__FUNC_WIN32_MonitorFromRect(fpl__win32_func_MonitorFromRect);
#define FPL__FUNC_WIN32_MonitorFromPoint(name) HMONITOR WINAPI name(POINT pt, DWORD dwFlags)
typedef FPL__FUNC_WIN32_MonitorFromPoint(fpl__win32_func_MonitorFromPoint);
#define FPL__FUNC_WIN32_MonitorFromWindow(name) HMONITOR WINAPI name(HWND hwnd, DWORD dwFlags)
typedef FPL__FUNC_WIN32_MonitorFromWindow(fpl__win32_func_MonitorFromWindow);
#define FPL__FUNC_WIN32_RegisterRawInputDevices(name) BOOL WINAPI name(PCRAWINPUTDEVICE pRawInputDevices, UINT uiNumDevices, UINT cbSize)
typedef FPL__FUNC_WIN32_RegisterRawInputDevices(fpl__win32_func_RegisterRawInputDevices);
#define FPL__FUNC_WIN32_ClipCursor(name) BOOL WINAPI name(CONST RECT *lpRect)
typedef FPL__FUNC_WIN32_ClipCursor(fpl__win32_func_ClipCursor);
#define FPL__FUNC_WIN32_PostQuitMessage(name) VOID WINAPI name(int nExitCode)
typedef FPL__FUNC_WIN32_PostQuitMessage(fpl__win32_func_PostQuitMessage);
#define FPL__FUNC_WIN32_CreateIconIndirect(name) HICON WINAPI name(PICONINFO piconinfo)
typedef FPL__FUNC_WIN32_CreateIconIndirect(fpl__win32_func_CreateIconIndirect);
#define FPL__FUNC_WIN32_GetKeyboardLayout(name) HKL WINAPI name(DWORD idThread)
typedef FPL__FUNC_WIN32_GetKeyboardLayout(fpl__win32_func_GetKeyboardLayout);
#define FPL__FUNC_WIN32_SetCapture(name) HWND WINAPI name(HWND hWnd)
typedef FPL__FUNC_WIN32_SetCapture(fpl__win32_func_SetCapture);
#define FPL__FUNC_WIN32_ReleaseCapture(name) BOOL WINAPI name(VOID)
typedef FPL__FUNC_WIN32_ReleaseCapture(fpl__win32_func_ReleaseCapture);
#define FPL__FUNC_WIN32_ScreenToClient(name) BOOL WINAPI name(HWND hWnd, LPPOINT lpPoint)
typedef FPL__FUNC_WIN32_ScreenToClient(fpl__win32_func_ScreenToClient);
#define FPL__FUNC_WIN32_BeginPaint(name) HDC WINAPI name(_In_ HWND hWnd, _Out_ LPPAINTSTRUCT lpPaint)
typedef FPL__FUNC_WIN32_BeginPaint(fpl__win32_func_BeginPaint);
#define FPL__FUNC_WIN32_EndPaint(name) BOOL WINAPI name(_In_ HWND hWnd, _In_ CONST PAINTSTRUCT *lpPaint)
typedef FPL__FUNC_WIN32_EndPaint(fpl__win32_func_EndPaint);
#define FPL__FUNC_WIN32_SetForegroundWindow(name) BOOL WINAPI name(_In_ HWND hWnd)
typedef FPL__FUNC_WIN32_SetForegroundWindow(fpl__win32_func_SetForegroundWindow);
#define FPL__FUNC_WIN32_SetFocus(name) HWND WINAPI name(_In_opt_ HWND hWnd)
typedef FPL__FUNC_WIN32_SetFocus(fpl__win32_func_SetFocus);
#define FPL__FUNC_WIN32_SetTimer(name) UINT_PTR WINAPI name(_In_opt_ HWND hWnd, _In_ UINT_PTR nIDEvent, _In_ UINT uElapse, _In_opt_ TIMERPROC lpTimerFunc)
typedef FPL__FUNC_WIN32_SetTimer(fpl__win32_func_SetTimer);
#define FPL__FUNC_WIN32_GetSysColorBrush(name) HBRUSH WINAPI name(_In_ int nIndex)
typedef FPL__FUNC_WIN32_GetSysColorBrush(fpl__win32_func_GetSysColorBrush);
#define FPL__FUNC_WIN32_GetSysColorBrush(name) HBRUSH WINAPI name(_In_ int nIndex)
typedef FPL__FUNC_WIN32_GetSysColorBrush(fpl__win32_func_GetSysColorBrush);
 
// OLE32
#define FPL__FUNC_WIN32_CoInitializeEx(name) HRESULT WINAPI name(LPVOID pvReserved, DWORD  dwCoInit)
typedef FPL__FUNC_WIN32_CoInitializeEx(fpl__win32_func_CoInitializeEx);
#define FPL__FUNC_WIN32_CoUninitialize(name) void WINAPI name(void)
typedef FPL__FUNC_WIN32_CoUninitialize(fpl__win32_func_CoUninitialize);
#define FPL__FUNC_WIN32_CoCreateInstance(name) HRESULT WINAPI name(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID riid, LPVOID *ppv)
typedef FPL__FUNC_WIN32_CoCreateInstance(fpl__win32_func_CoCreateInstance);
#define FPL__FUNC_WIN32_CoTaskMemFree(name) void WINAPI name(LPVOID pv)
typedef FPL__FUNC_WIN32_CoTaskMemFree(fpl__win32_func_CoTaskMemFree);
#define FPL__FUNC_WIN32_PropVariantClear(name) HRESULT WINAPI name(PROPVARIANT *pvar)
typedef FPL__FUNC_WIN32_PropVariantClear(fpl__win32_func_PropVariantClear);
 
typedef struct fpl__Win32GdiApi {
    HMODULE gdiLibrary;
    fpl__win32_func_ChoosePixelFormat *ChoosePixelFormat;
    fpl__win32_func_SetPixelFormat *SetPixelFormat;
    fpl__win32_func_DescribePixelFormat *DescribePixelFormat;
    fpl__win32_func_GetDeviceCaps *GetDeviceCaps;
    fpl__win32_func_StretchDIBits *StretchDIBits;
    fpl__win32_func_DeleteObject *DeleteObject;
    fpl__win32_func_SwapBuffers *SwapBuffers;
    fpl__win32_func_CreateDIBSection *CreateDIBSection;
    fpl__win32_func_CreateBitmap *CreateBitmap;
    fpl__win32_func_CreateSolidBrush *CreateSolidBrush;
} fpl__Win32GdiApi;
 
typedef struct fpl__Win32ShellApi {
    HMODULE shellLibrary;
    fpl__win32_func_SHGetFolderPathW *SHGetFolderPathW;
    fpl__win32_func_DragQueryFileW *DragQueryFileW;
    fpl__win32_func_DragAcceptFiles *DragAcceptFiles;
} fpl__Win32ShellApi;
 
typedef struct fpl__Win32UserApi {
    HMODULE userLibrary;
    fpl__win32_func_RegisterClassExW *RegisterClassExW;
    fpl__win32_func_UnregisterClassW *UnregisterClassW;
    fpl__win32_func_ShowWindow *ShowWindow;
    fpl__win32_func_DestroyWindow *DestroyWindow;
    fpl__win32_func_UpdateWindow *UpdateWindow;
    fpl__win32_func_TranslateMessage *TranslateMessage;
    fpl__win32_func_DispatchMessageW *DispatchMessageW;
    fpl__win32_func_PeekMessageW *PeekMessageW;
    fpl__win32_func_DefWindowProcW *DefWindowProcW;
    fpl__win32_func_CreateWindowExW *CreateWindowExW;
    fpl__win32_func_SetWindowPos *SetWindowPos;
    fpl__win32_func_GetWindowPlacement *GetWindowPlacement;
    fpl__win32_func_SetWindowPlacement *SetWindowPlacement;
    fpl__win32_func_GetClientRect *GetClientRect;
    fpl__win32_func_GetWindowRect *GetWindowRect;
    fpl__win32_func_AdjustWindowRect *AdjustWindowRect;
    fpl__win32_func_GetAsyncKeyState *GetAsyncKeyState;
    fpl__win32_func_MapVirtualKeyW *MapVirtualKeyW;
    fpl__win32_func_SetCursor *SetCursor;
    fpl__win32_func_GetCursor *GetCursor;
    fpl__win32_func_LoadCursorA *LoadCursorA;
    fpl__win32_func_LoadCursorW *LoadCursorW;
    fpl__win32_func_LoadIconA *LoadIconA;
    fpl__win32_func_LoadIconW *LoadIconW;
    fpl__win32_func_SetWindowTextW *SetWindowTextW;
    fpl__win32_func_GetWindowTextW *GetWindowTextW;
    fpl__win32_func_SetWindowLongW *SetWindowLongW;
    fpl__win32_func_GetWindowLongW *GetWindowLongW;
#if defined(FPL_ARCH_X64)
    fpl__win32_func_SetWindowLongPtrW *SetWindowLongPtrW;
    fpl__win32_func_GetWindowLongPtrW *GetWindowLongPtrW;
#endif
    fpl__win32_func_ReleaseDC *ReleaseDC;
    fpl__win32_func_GetDC *GetDC;
    fpl__win32_func_ChangeDisplaySettingsW *ChangeDisplaySettingsW;
    fpl__win32_func_EnumDisplaySettingsW *EnumDisplaySettingsW;
    fpl__win32_func_OpenClipboard *OpenClipboard;
    fpl__win32_func_CloseClipboard *CloseClipboard;
    fpl__win32_func_EmptyClipboard *EmptyClipboard;
    fpl__win32_func_IsClipboardFormatAvailable *IsClipboardFormatAvailable;
    fpl__win32_func_SetClipboardData *SetClipboardData;
    fpl__win32_func_GetClipboardData *GetClipboardData;
    fpl__win32_func_GetDesktopWindow *GetDesktopWindow;
    fpl__win32_func_GetForegroundWindow *GetForegroundWindow;
    fpl__win32_func_IsZoomed *IsZoomed;
    fpl__win32_func_IsIconic *IsIconic;
    fpl__win32_func_SendMessageW *SendMessageW;
    fpl__win32_func_GetMonitorInfoW *GetMonitorInfoW;
    fpl__win32_func_EnumDisplayMonitors *EnumDisplayMonitors;
    fpl__win32_func_MonitorFromRect *MonitorFromRect;
    fpl__win32_func_MonitorFromPoint *MonitorFromPoint;
    fpl__win32_func_MonitorFromWindow *MonitorFromWindow;
    fpl__win32_func_GetCursorPos *GetCursorPos;
    fpl__win32_func_WindowFromPoint *WindowFromPoint;
    fpl__win32_func_ClientToScreen *ClientToScreen;
    fpl__win32_func_PtInRect *PtInRect;
    fpl__win32_func_RegisterRawInputDevices *RegisterRawInputDevices;
    fpl__win32_func_ClipCursor *ClipCursor;
    fpl__win32_func_PostQuitMessage *PostQuitMessage;
    fpl__win32_func_CreateIconIndirect *CreateIconIndirect;
    fpl__win32_func_GetKeyboardLayout *GetKeyboardLayout;
    fpl__win32_func_GetKeyState *GetKeyState;
    fpl__win32_func_SetCapture *SetCapture;
    fpl__win32_func_ReleaseCapture *ReleaseCapture;
    fpl__win32_func_ScreenToClient *ScreenToClient;
    fpl__win32_func_BeginPaint *BeginPaint;
    fpl__win32_func_EndPaint *EndPaint;
    fpl__win32_func_SetForegroundWindow *SetForegroundWindow;
    fpl__win32_func_SetFocus *SetFocus;
    fpl__win32_func_SetTimer *SetTimer;
    fpl__win32_func_GetSysColorBrush *GetSysColorBrush;
} fpl__Win32UserApi;
 
typedef struct fpl__Win32OleApi {
    HMODULE oleLibrary;
    fpl__win32_func_CoInitializeEx *CoInitializeEx;
    fpl__win32_func_CoUninitialize *CoUninitialize;
    fpl__win32_func_CoCreateInstance *CoCreateInstance;
    fpl__win32_func_CoTaskMemFree *CoTaskMemFree;
    fpl__win32_func_PropVariantClear *PropVariantClear;
} fpl__Win32OleApi;
 
typedef struct fpl__Win32Api {
    fpl__Win32GdiApi gdi;
    fpl__Win32ShellApi shell;
    fpl__Win32UserApi user;
    fpl__Win32OleApi ole;
    fpl_b32 isValid;
} fpl__Win32Api;
 
fpl_internal void fpl__Win32UnloadApi(fpl__Win32Api *wapi) {
    fplAssert(wapi != fpl_null);
    if (wapi->ole.oleLibrary != fpl_null) {
        FreeLibrary(wapi->ole.oleLibrary);
    }
    fplClearStruct(&wapi->ole);
    if (wapi->gdi.gdiLibrary != fpl_null) {
        FreeLibrary(wapi->gdi.gdiLibrary);
    }
    fplClearStruct(&wapi->gdi);
    if (wapi->user.userLibrary != fpl_null) {
        FreeLibrary(wapi->user.userLibrary);
    }
    fplClearStruct(&wapi->user);
    if (wapi->shell.shellLibrary != fpl_null) {
        FreeLibrary(wapi->shell.shellLibrary);
    }
    fplClearStruct(&wapi->shell);
    wapi->isValid = false;
}
 
fpl_internal bool fpl__Win32LoadApi(fpl__Win32Api *wapi) {
    fplAssert(wapi != fpl_null);
    bool result = false;
    fplClearStruct(wapi);
    do {
        // Shell32
        const char *shellLibraryName = "shell32.dll";
        HMODULE shellLibrary = fpl_null;
        FPL__WIN32_LOAD_LIBRARY(FPL__MODULE_WIN32, shellLibrary, shellLibraryName);
        wapi->shell.shellLibrary = shellLibrary;
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, shellLibrary, shellLibraryName, &wapi->shell, fpl__win32_func_SHGetFolderPathW, SHGetFolderPathW);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, shellLibrary, shellLibraryName, &wapi->shell, fpl__win32_func_DragQueryFileW, DragQueryFileW);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, shellLibrary, shellLibraryName, &wapi->shell, fpl__win32_func_DragAcceptFiles, DragAcceptFiles);
 
        // User32
        const char *userLibraryName = "user32.dll";
        HMODULE userLibrary = fpl_null;
        FPL__WIN32_LOAD_LIBRARY(FPL__MODULE_WIN32, userLibrary, userLibraryName);
        wapi->user.userLibrary = userLibrary;
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_RegisterClassExW, RegisterClassExW);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_UnregisterClassW, UnregisterClassW);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_ShowWindow, ShowWindow);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_DestroyWindow, DestroyWindow);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_UpdateWindow, UpdateWindow);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_TranslateMessage, TranslateMessage);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_DispatchMessageW, DispatchMessageW);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_PeekMessageW, PeekMessageW);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_DefWindowProcW, DefWindowProcW);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_CreateWindowExW, CreateWindowExW);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_SetWindowPos, SetWindowPos);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_GetWindowPlacement, GetWindowPlacement);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_SetWindowPlacement, SetWindowPlacement);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_GetClientRect, GetClientRect);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_GetWindowRect, GetWindowRect);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_AdjustWindowRect, AdjustWindowRect);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_GetAsyncKeyState, GetAsyncKeyState);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_MapVirtualKeyW, MapVirtualKeyW);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_SetCursor, SetCursor);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_GetCursor, GetCursor);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_LoadCursorA, LoadCursorA);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_LoadCursorW, LoadCursorW);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_GetCursorPos, GetCursorPos);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_WindowFromPoint, WindowFromPoint);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_LoadIconA, LoadIconA);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_LoadIconW, LoadIconW);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_SetWindowTextW, SetWindowTextW);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_SetWindowLongW, SetWindowLongW);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_GetWindowLongW, GetWindowLongW);
 
#   if defined(FPL_ARCH_X64)
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_SetWindowLongPtrW, SetWindowLongPtrW);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_GetWindowLongPtrW, GetWindowLongPtrW);
#   endif
 
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_ReleaseDC, ReleaseDC);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_GetDC, GetDC);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_ChangeDisplaySettingsW, ChangeDisplaySettingsW);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_EnumDisplaySettingsW, EnumDisplaySettingsW);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_IsClipboardFormatAvailable, IsClipboardFormatAvailable);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_OpenClipboard, OpenClipboard);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_CloseClipboard, CloseClipboard);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_EmptyClipboard, EmptyClipboard);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_SetClipboardData, SetClipboardData);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_GetClipboardData, GetClipboardData);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_GetDesktopWindow, GetDesktopWindow);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_GetForegroundWindow, GetForegroundWindow);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_IsZoomed, IsZoomed);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_IsIconic, IsIconic);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_SendMessageW, SendMessageW);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_GetMonitorInfoW, GetMonitorInfoW);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_EnumDisplayMonitors, EnumDisplayMonitors);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_MonitorFromRect, MonitorFromRect);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_MonitorFromPoint, MonitorFromPoint);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_MonitorFromWindow, MonitorFromWindow);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_ClientToScreen, ClientToScreen);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_PtInRect, PtInRect);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_RegisterRawInputDevices, RegisterRawInputDevices);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_ClipCursor, ClipCursor);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_PostQuitMessage, PostQuitMessage);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_CreateIconIndirect, CreateIconIndirect);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_GetKeyboardLayout, GetKeyboardLayout);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_GetKeyState, GetKeyState);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_SetCapture, SetCapture);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_ReleaseCapture, ReleaseCapture);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_ScreenToClient, ScreenToClient);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_BeginPaint, BeginPaint);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_EndPaint, EndPaint);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_SetForegroundWindow, SetForegroundWindow);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_SetFocus, SetFocus);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_SetTimer, SetTimer);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, userLibrary, userLibraryName, &wapi->user, fpl__win32_func_GetSysColorBrush, GetSysColorBrush);
 
        // GDI32
        const char *gdiLibraryName = "gdi32.dll";
        HMODULE gdiLibrary = fpl_null;
        FPL__WIN32_LOAD_LIBRARY(FPL__MODULE_WIN32, gdiLibrary, gdiLibraryName);
        wapi->gdi.gdiLibrary = gdiLibrary;
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, gdiLibrary, gdiLibraryName, &wapi->gdi, fpl__win32_func_ChoosePixelFormat, ChoosePixelFormat);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, gdiLibrary, gdiLibraryName, &wapi->gdi, fpl__win32_func_SetPixelFormat, SetPixelFormat);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, gdiLibrary, gdiLibraryName, &wapi->gdi, fpl__win32_func_DescribePixelFormat, DescribePixelFormat);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, gdiLibrary, gdiLibraryName, &wapi->gdi, fpl__win32_func_StretchDIBits, StretchDIBits);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, gdiLibrary, gdiLibraryName, &wapi->gdi, fpl__win32_func_DeleteObject, DeleteObject);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, gdiLibrary, gdiLibraryName, &wapi->gdi, fpl__win32_func_SwapBuffers, SwapBuffers);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, gdiLibrary, gdiLibraryName, &wapi->gdi, fpl__win32_func_GetDeviceCaps, GetDeviceCaps);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, gdiLibrary, gdiLibraryName, &wapi->gdi, fpl__win32_func_CreateDIBSection, CreateDIBSection);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, gdiLibrary, gdiLibraryName, &wapi->gdi, fpl__win32_func_CreateBitmap, CreateBitmap);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, gdiLibrary, gdiLibraryName, &wapi->gdi, fpl__win32_func_CreateSolidBrush, CreateSolidBrush);
 
        // OLE32
        const char *oleLibraryName = "ole32.dll";
        HMODULE oleLibrary = fpl_null;
        FPL__WIN32_LOAD_LIBRARY(FPL__MODULE_WIN32, oleLibrary, oleLibraryName);
        wapi->ole.oleLibrary = oleLibrary;
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, oleLibrary, oleLibraryName, &wapi->ole, fpl__win32_func_CoInitializeEx, CoInitializeEx);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, oleLibrary, oleLibraryName, &wapi->ole, fpl__win32_func_CoUninitialize, CoUninitialize);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, oleLibrary, oleLibraryName, &wapi->ole, fpl__win32_func_CoCreateInstance, CoCreateInstance);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, oleLibrary, oleLibraryName, &wapi->ole, fpl__win32_func_CoTaskMemFree, CoTaskMemFree);
        FPL__WIN32_GET_FUNCTION_ADDRESS(FPL__MODULE_WIN32, oleLibrary, oleLibraryName, &wapi->ole, fpl__win32_func_PropVariantClear, PropVariantClear);
 
        result = true;
    } while (0);
    if (!result) {
        fpl__Win32UnloadApi(wapi);
    }
    wapi->isValid = result;
    return(result);
}
 
// Win32 unicode dependend stuff
#define FPL__WIN32_CLASSNAME L"FPLWindowClassW"
#define FPL__WIN32_UNNAMED_WINDOW L"Unnamed FPL Unicode Window"
#define FPL__WIN32_UNNAMED_CONSOLE L"Unnamed FPL Unicode Console"
#if defined(FPL_ARCH_X64)
#   define fpl__win32_SetWindowLongPtr fpl__global__AppState->win32.winApi.user.SetWindowLongPtrW
#else
#   define fpl__win32_SetWindowLongPtr fpl__global__AppState->win32.winApi.user.SetWindowLongW
#endif
#define fpl__win32_SetWindowLong fpl__global__AppState->win32.winApi.user.SetWindowLongW
#define fpl__win32_GetWindowLong fpl__global__AppState->win32.winApi.user.GetWindowLongW
#if UNICODE
#   define fpl__win32_LoadIcon fpl__global__AppState->win32.winApi.user.LoadIconW
#   define fpl__win32_LoadCursor fpl__global__AppState->win32.winApi.user.LoadCursorW
#else
#   define fpl__win32_LoadIcon fpl__global__AppState->win32.winApi.user.LoadIconA
#   define fpl__win32_LoadCursor fpl__global__AppState->win32.winApi.user.LoadCursorA
#endif
 
typedef char fpl__GameControllerName[FPL_MAX_NAME_LENGTH];
 
typedef struct fpl__Win32XInputState {
    fpl__GameControllerName deviceNames[XUSER_MAX_COUNT];
    fpl_b32 isConnected[XUSER_MAX_COUNT];
    fpl__Win32XInputApi xinputApi;
    LARGE_INTEGER lastDeviceSearchTime;
} fpl__Win32XInputState;
 
typedef struct fpl__Win32InitState {
    HINSTANCE appInstance;
    LARGE_INTEGER qpf;
} fpl__Win32InitState;
 
typedef struct fpl__Win32AppState {
    fpl__Win32XInputState xinput;
    fpl__Win32Api winApi;
} fpl__Win32AppState;
 
#if defined(FPL__ENABLE_WINDOW)
typedef struct fpl__Win32LastWindowInfo {
    WINDOWPLACEMENT placement;
    DWORD style;
    DWORD exStyle;
    fpl_b32 isMaximized;
    fpl_b32 isMinimized;
    fpl_b32 wasResolutionChanged;
} fpl__Win32LastWindowInfo;
 
typedef struct fpl__Win32WindowState {
    wchar_t windowClass[256];
    fpl__Win32LastWindowInfo lastFullscreenInfo;
    void *mainFiber;
    void *messageFiber;
    HWND windowHandle;
    HDC deviceContext;
    HBRUSH backgroundBrush;
    HCURSOR defaultCursor;
    int pixelFormat;
    fpl_b32 isCursorActive;
    fpl_b32 isFrameInteraction;
} fpl__Win32WindowState;
#endif // FPL__ENABLE_WINDOW
 
#endif // FPL_PLATFORM_WINDOWS
 
// ############################################################################
//
// > TYPES_POSIX
//
// ############################################################################
#if defined(FPL_SUBPLATFORM_POSIX)
#   include <sys/types.h> // data types
#   include <sys/mman.h> // mmap, munmap
#   include <sys/stat.h> // mkdir
#   include <sys/errno.h> // errno
#   include <sys/time.h> // gettimeofday
#   include <sys/utsname.h> // uname
#   include <signal.h> // pthread_kill
#   include <time.h> // clock_gettime, nanosleep
#   include <dlfcn.h> // dlopen, dlclose
#   include <fcntl.h> // open
#   include <unistd.h> // read, write, close, access, rmdir, getpid, sysconf, geteuid
#   include <ctype.h> // isspace
#   include <pwd.h> // getpwuid
 
// @TODO(final): Detect the case of (Older POSIX versions where st_atim != st_atime)
#if !defined(FPL_PLATFORM_ANDROID)
# define st_atime st_atim.tv_sec
# define st_mtime st_mtim.tv_sec
# define st_ctime st_ctim.tv_sec
#endif
 
#if defined(FPL_PLATFORM_LINUX)
#   define fpl__lseek64 lseek64
#   define fpl__off64_t off64_t
#else
#   define fpl__lseek64 lseek
#   define fpl__off64_t off_t
#endif
 
// Little macros for loading a library and getting proc address for POSIX
#define FPL__POSIX_LOAD_LIBRARY_BREAK(mod, target, libName) \
    (target) = dlopen(libName, FPL__POSIX_DL_LOADTYPE); \
    if((target) == fpl_null) { \
        FPL__WARNING(mod, "Failed loading library '%s'", (libName)); \
        break; \
    }
 
#define FPL__POSIX_GET_FUNCTION_ADDRESS_OPTIONAL(mod, libHandle, libName, target, type, name) \
    (target)->name = (type *)dlsym(libHandle, #name)
 
#define FPL__POSIX_GET_FUNCTION_ADDRESS_BREAK(mod, libHandle, libName, target, type, name) \
    (target)->name = (type *)dlsym(libHandle, #name); \
    if ((target)->name == fpl_null) { \
        FPL__WARNING(mod, "Failed getting procedure address '%s' from library '%s'", #name, libName); \
        break; \
    }
#if !defined(FPL_NO_RUNTIME_LINKING)
#   define FPL__POSIX_LOAD_LIBRARY FPL__POSIX_LOAD_LIBRARY_BREAK
#   define FPL__POSIX_GET_FUNCTION_ADDRESS FPL__POSIX_GET_FUNCTION_ADDRESS_BREAK
#else
#   define FPL__POSIX_LOAD_LIBRARY(mod, target, libName)
#   define FPL__POSIX_GET_FUNCTION_ADDRESS_OPTIONAL(mod, libHandle, libName, target, type, name) \
        (target)->name = name
#   define FPL__POSIX_GET_FUNCTION_ADDRESS(mod, libHandle, libName, target, type, name) \
        (target)->name = name
#endif
 
#define FPL__FUNC_PTHREAD_pthread_self(name) pthread_t name(void)
typedef FPL__FUNC_PTHREAD_pthread_self(fpl__pthread_func_pthread_self);
#define FPL__FUNC_PTHREAD_pthread_setschedparam(name) int name(pthread_t thread, int policy, const struct sched_param *param)
typedef FPL__FUNC_PTHREAD_pthread_setschedparam(fpl__pthread_func_pthread_setschedparam);
#define FPL__FUNC_PTHREAD_pthread_getschedparam(name) int name(pthread_t thread, int *policy, struct sched_param *param)
typedef FPL__FUNC_PTHREAD_pthread_getschedparam(fpl__pthread_func_pthread_getschedparam);
#define FPL__FUNC_PTHREAD_pthread_setschedprio(name) int name(pthread_t thread, int prio)
typedef FPL__FUNC_PTHREAD_pthread_setschedprio(fpl__pthread_func_pthread_setschedprio);
 
#define FPL__FUNC_PTHREAD_pthread_attr_init(name) int name(pthread_attr_t *attr)
typedef FPL__FUNC_PTHREAD_pthread_attr_init(fpl__pthread_func_pthread_attr_init);
#define FPL__FUNC_PTHREAD_pthread_attr_getschedparam(name) int name(const pthread_attr_t *__restrict__ attr, struct sched_param *__restrict__ param)
typedef FPL__FUNC_PTHREAD_pthread_attr_getschedparam(fpl__pthread_func_pthread_attr_getschedparam);
#define FPL__FUNC_PTHREAD_pthread_attr_setschedparam(name) int name(pthread_attr_t *__restrict__ attr, const struct sched_param *__restrict__ param)
typedef FPL__FUNC_PTHREAD_pthread_attr_setschedparam(fpl__pthread_func_pthread_attr_setschedparam);
#define FPL__FUNC_PTHREAD_pthread_attr_setstacksize(name) int name(pthread_attr_t *attr, size_t stacksize)
typedef FPL__FUNC_PTHREAD_pthread_attr_setstacksize(fpl__pthread_func_pthread_attr_setstacksize);
#define FPL__FUNC_PTHREAD_pthread_attr_setdetachstate(name) int name(pthread_attr_t *attr, int detachstate);
typedef FPL__FUNC_PTHREAD_pthread_attr_setdetachstate(fpl__pthread_func_pthread_attr_setdetachstate);
#define FPL__FUNC_PTHREAD_pthread_attr_setschedpolicy(name) int name(pthread_attr_t *__attr, int __policy)
typedef FPL__FUNC_PTHREAD_pthread_attr_setschedpolicy(fpl__pthread_func_pthread_attr_setschedpolicy);
 
#define FPL__FUNC_PTHREAD_pthread_create(name) int name(pthread_t *, const pthread_attr_t *, void *(*__start_routine) (void *), void *)
typedef FPL__FUNC_PTHREAD_pthread_create(fpl__pthread_func_pthread_create);
#define FPL__FUNC_PTHREAD_pthread_kill(name) int name(pthread_t thread, int sig)
typedef FPL__FUNC_PTHREAD_pthread_kill(fpl__pthread_func_pthread_kill);
#define FPL__FUNC_PTHREAD_pthread_join(name) int name(pthread_t __th, void **retval)
typedef FPL__FUNC_PTHREAD_pthread_join(fpl__pthread_func_pthread_join);
#define FPL__FUNC_PTHREAD_pthread_exit(name) void name(void *__retval)
typedef FPL__FUNC_PTHREAD_pthread_exit(fpl__pthread_func_pthread_exit);
#define FPL__FUNC_PTHREAD_pthread_yield(name) int name(void)
typedef FPL__FUNC_PTHREAD_pthread_yield(fpl__pthread_func_pthread_yield);
#define FPL__FUNC_PTHREAD_pthread_timedjoin_np(name) int name(pthread_t thread, void **retval, const struct timespec *abstime)
typedef FPL__FUNC_PTHREAD_pthread_timedjoin_np(fpl__pthread_func_pthread_timedjoin_np);
 
#define FPL__FUNC_PTHREAD_pthread_mutex_init(name) int name(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)
typedef FPL__FUNC_PTHREAD_pthread_mutex_init(fpl__pthread_func_pthread_mutex_init);
#define FPL__FUNC_PTHREAD_pthread_mutex_destroy(name) int name(pthread_mutex_t *mutex)
typedef FPL__FUNC_PTHREAD_pthread_mutex_destroy(fpl__pthread_func_pthread_mutex_destroy);
#define FPL__FUNC_PTHREAD_pthread_mutex_lock(name) int name(pthread_mutex_t *mutex)
typedef FPL__FUNC_PTHREAD_pthread_mutex_lock(fpl__pthread_func_pthread_mutex_lock);
#define FPL__FUNC_PTHREAD_pthread_mutex_trylock(name) int name(pthread_mutex_t *mutex)
typedef FPL__FUNC_PTHREAD_pthread_mutex_trylock(fpl__pthread_func_pthread_mutex_trylock);
#define FPL__FUNC_PTHREAD_pthread_mutex_unlock(name) int name(pthread_mutex_t *mutex)
typedef FPL__FUNC_PTHREAD_pthread_mutex_unlock(fpl__pthread_func_pthread_mutex_unlock);
 
#define FPL__FUNC_PTHREAD_pthread_cond_init(name) int name(pthread_cond_t *cond, const pthread_condattr_t *attr)
typedef FPL__FUNC_PTHREAD_pthread_cond_init(fpl__pthread_func_pthread_cond_init);
#define FPL__FUNC_PTHREAD_pthread_cond_destroy(name) int name(pthread_cond_t *cond)
typedef FPL__FUNC_PTHREAD_pthread_cond_destroy(fpl__pthread_func_pthread_cond_destroy);
#define FPL__FUNC_PTHREAD_pthread_cond_timedwait(name) int name(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime)
typedef FPL__FUNC_PTHREAD_pthread_cond_timedwait(fpl__pthread_func_pthread_cond_timedwait);
#define FPL__FUNC_PTHREAD_pthread_cond_wait(name) int name(pthread_cond_t *cond, pthread_mutex_t *mutex)
typedef FPL__FUNC_PTHREAD_pthread_cond_wait(fpl__pthread_func_pthread_cond_wait);
#define FPL__FUNC_PTHREAD_pthread_cond_broadcast(name) int name(pthread_cond_t *cond)
typedef FPL__FUNC_PTHREAD_pthread_cond_broadcast(fpl__pthread_func_pthread_cond_broadcast);
#define FPL__FUNC_PTHREAD_pthread_cond_signal(name) int name(pthread_cond_t *cond)
typedef FPL__FUNC_PTHREAD_pthread_cond_signal(fpl__pthread_func_pthread_cond_signal);
 
#define FPL__FUNC_PTHREAD_sem_init(name) int name(sem_t *__sem, int __pshared, unsigned int __value)
typedef FPL__FUNC_PTHREAD_sem_init(fpl__pthread_func_sem_init);
#define FPL__FUNC_PTHREAD_sem_destroy(name) int name(sem_t *__sem)
typedef FPL__FUNC_PTHREAD_sem_destroy(fpl__pthread_func_sem_destroy);
#define FPL__FUNC_PTHREAD_sem_wait(name) int name(sem_t *__sem)
typedef FPL__FUNC_PTHREAD_sem_wait(fpl__pthread_func_sem_wait);
#define FPL__FUNC_PTHREAD_sem_timedwait(name) int name(sem_t *__restrict __sem, const struct timespec *__restrict __abstime)
typedef FPL__FUNC_PTHREAD_sem_timedwait(fpl__pthread_func_sem_timedwait);
#define FPL__FUNC_PTHREAD_sem_trywait(name) int name(sem_t *__sem)
typedef FPL__FUNC_PTHREAD_sem_trywait(fpl__pthread_func_sem_trywait);
#define FPL__FUNC_PTHREAD_sem_post(name) int name(sem_t *__sem)
typedef FPL__FUNC_PTHREAD_sem_post(fpl__pthread_func_sem_post);
#define FPL__FUNC_PTHREAD_sem_getvalue(name) int name(sem_t *__restrict __sem, int *__restrict __sval)
typedef FPL__FUNC_PTHREAD_sem_getvalue(fpl__pthread_func_sem_getvalue);
 
typedef struct fpl__PThreadApi {
    void *libHandle;
 
    // pthread_t
    fpl__pthread_func_pthread_self *pthread_self;
    fpl__pthread_func_pthread_setschedparam *pthread_setschedparam;
    fpl__pthread_func_pthread_getschedparam *pthread_getschedparam;
    fpl__pthread_func_pthread_setschedprio *pthread_setschedprio;
 
    fpl__pthread_func_pthread_create *pthread_create;
    fpl__pthread_func_pthread_kill *pthread_kill;
    fpl__pthread_func_pthread_join *pthread_join;
    fpl__pthread_func_pthread_exit *pthread_exit;
    fpl__pthread_func_pthread_yield *pthread_yield;
    fpl__pthread_func_pthread_timedjoin_np *pthread_timedjoin_np;
 
    // pthread_attr_t
    fpl__pthread_func_pthread_attr_init *pthread_attr_init;
    fpl__pthread_func_pthread_attr_getschedparam *pthread_attr_getschedparam;
    fpl__pthread_func_pthread_attr_setschedparam *pthread_attr_setschedparam;
    fpl__pthread_func_pthread_attr_setstacksize *pthread_attr_setstacksize;
    fpl__pthread_func_pthread_attr_setdetachstate *pthread_attr_setdetachstate;
    fpl__pthread_func_pthread_attr_setschedpolicy *pthread_attr_setschedpolicy;
 
    // pthread_mutex_t
    fpl__pthread_func_pthread_mutex_init *pthread_mutex_init;
    fpl__pthread_func_pthread_mutex_destroy *pthread_mutex_destroy;
    fpl__pthread_func_pthread_mutex_lock *pthread_mutex_lock;
    fpl__pthread_func_pthread_mutex_trylock *pthread_mutex_trylock;
    fpl__pthread_func_pthread_mutex_unlock *pthread_mutex_unlock;
 
    // pthread_cond_t
    fpl__pthread_func_pthread_cond_init *pthread_cond_init;
    fpl__pthread_func_pthread_cond_destroy *pthread_cond_destroy;
    fpl__pthread_func_pthread_cond_timedwait *pthread_cond_timedwait;
    fpl__pthread_func_pthread_cond_wait *pthread_cond_wait;
    fpl__pthread_func_pthread_cond_broadcast *pthread_cond_broadcast;
    fpl__pthread_func_pthread_cond_signal *pthread_cond_signal;
 
    // sem_t
    fpl__pthread_func_sem_init *sem_init;
    fpl__pthread_func_sem_destroy *sem_destroy;
    fpl__pthread_func_sem_wait *sem_wait;
    fpl__pthread_func_sem_timedwait *sem_timedwait;
    fpl__pthread_func_sem_trywait *sem_trywait;
    fpl__pthread_func_sem_post *sem_post;
    fpl__pthread_func_sem_getvalue *sem_getvalue;
} fpl__PThreadApi;
 
#define FPL__POSIX_DL_LOADTYPE RTLD_NOW
 
fpl_internal void fpl__PThreadUnloadApi(fpl__PThreadApi *pthreadApi) {
    fplAssert(pthreadApi != fpl_null);
    if (pthreadApi->libHandle != fpl_null) {
        dlclose(pthreadApi->libHandle);
    }
    fplClearStruct(pthreadApi);
}
 
fpl_internal bool fpl__PThreadLoadApi(fpl__PThreadApi *pthreadApi) {
    const char *libpthreadFileNames[] = {
        "libpthread.so",
        "libpthread.so.0",
    };
    bool result = false;
    for (uint32_t index = 0; index < fplArrayCount(libpthreadFileNames); ++index) {
        const char *libName = libpthreadFileNames[index];
        fplClearStruct(pthreadApi);
        do {
            void *libHandle = fpl_null;
            FPL__POSIX_LOAD_LIBRARY(FPL__MODULE_PTHREAD, libHandle, libName);
 
            // pthread_t
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_pthread_self, pthread_self);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_pthread_setschedparam, pthread_setschedparam);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_pthread_getschedparam, pthread_getschedparam);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_pthread_setschedprio, pthread_setschedprio);
 
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_pthread_create, pthread_create);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_pthread_kill, pthread_kill);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_pthread_join, pthread_join);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_pthread_exit, pthread_exit);
            FPL__POSIX_GET_FUNCTION_ADDRESS_OPTIONAL(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_pthread_yield, pthread_yield);
            FPL__POSIX_GET_FUNCTION_ADDRESS_OPTIONAL(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_pthread_timedjoin_np, pthread_timedjoin_np);
 
            // pthread_attr_t
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_pthread_attr_init, pthread_attr_init);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_pthread_attr_getschedparam, pthread_attr_getschedparam);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_pthread_attr_setschedparam, pthread_attr_setschedparam);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_pthread_attr_setstacksize, pthread_attr_setstacksize);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_pthread_attr_setdetachstate, pthread_attr_setdetachstate);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_pthread_attr_setschedpolicy, pthread_attr_setschedpolicy);
 
            // pthread_mutex_t
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_pthread_mutex_init, pthread_mutex_init);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_pthread_mutex_destroy, pthread_mutex_destroy);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_pthread_mutex_lock, pthread_mutex_lock);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_pthread_mutex_trylock, pthread_mutex_trylock);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_pthread_mutex_unlock, pthread_mutex_unlock);
 
            // pthread_cond_t
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_pthread_cond_init, pthread_cond_init);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_pthread_cond_destroy, pthread_cond_destroy);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_pthread_cond_timedwait, pthread_cond_timedwait);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_pthread_cond_wait, pthread_cond_wait);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_pthread_cond_broadcast, pthread_cond_broadcast);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_pthread_cond_signal, pthread_cond_signal);
 
            // sem_t
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_sem_init, sem_init);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_sem_destroy, sem_destroy);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_sem_wait, sem_wait);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_sem_timedwait, sem_timedwait);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_sem_trywait, sem_trywait);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_sem_post, sem_post);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_PTHREAD, libHandle, libName, pthreadApi, fpl__pthread_func_sem_getvalue, sem_getvalue);
 
            pthreadApi->libHandle = libHandle;
            result = true;
        } while (0);
        if (result) {
            break;
        }
        fpl__PThreadUnloadApi(pthreadApi);
    }
    return(result);
}
 
typedef struct fpl__PosixInitState {
    int dummy;
} fpl__PosixInitState;
 
typedef struct fpl__PosixAppState {
    fpl__PThreadApi pthreadApi;
} fpl__PosixAppState;
#endif // FPL_SUBPLATFORM_POSIX
 
// ############################################################################
//
// > TYPES_LINUX
//
// ############################################################################
#if defined(FPL_PLATFORM_LINUX)
typedef struct fpl__LinuxInitState {
    int dummy;
} fpl__LinuxInitState;
 
#if defined(FPL__ENABLE_WINDOW)
#define FPL__LINUX_MAX_GAME_CONTROLLER_COUNT 4
typedef struct fpl__LinuxGameController {
    char deviceName[512 + 1];
    char displayName[FPL_MAX_NAME_LENGTH];
    int fd;
    uint8_t axisCount;
    uint8_t buttonCount;
    fplGamepadState state;
} fpl__LinuxGameController;
 
typedef struct fpl__LinuxGameControllersState {
    fpl__LinuxGameController controllers[FPL__LINUX_MAX_GAME_CONTROLLER_COUNT];
    uint64_t lastCheckTime;
} fpl__LinuxGameControllersState;
#endif
 
typedef struct fpl__LinuxAppState {
#if defined(FPL__ENABLE_WINDOW)
    fpl__LinuxGameControllersState controllersState;
#endif
    int dummy;
} fpl__LinuxAppState;
 
// Forward declarations
#if defined(FPL__ENABLE_WINDOW)
fpl_internal void fpl__LinuxFreeGameControllers(fpl__LinuxGameControllersState *controllersState);
fpl_internal void fpl__LinuxPollGameControllers(const fplSettings *settings, fpl__LinuxGameControllersState *controllersState, const bool useEvents);
#endif
 
#endif // FPL_PLATFORM_LINUX
 
// ############################################################################
//
// > TYPES_UNIX
//
// ############################################################################
#if defined(FPL_PLATFORM_UNIX)
typedef struct fpl__UnixInitState {
    int dummy;
} fpl__UnixInitState;
 
typedef struct fpl__UnixAppState {
    int dummy;
} fpl__UnixAppState;
#endif // FPL_PLATFORM_UNIX
 
// ############################################################################
//
// > TYPES_X11
//
// ############################################################################
#if defined(FPL_SUBPLATFORM_X11)
 
#include <X11/keysym.h> // Keyboard symbols (XK_Escape, etc.)
 
//
// X11 Api
//
#define FPL__FUNC_X11_XFree(name) int name(void *data)
typedef FPL__FUNC_X11_XFree(fpl__func_x11_XFree);
#define FPL__FUNC_X11_XFlush(name) int name(Display *display)
typedef FPL__FUNC_X11_XFlush(fpl__func_x11_XFlush);
#define FPL__FUNC_X11_XOpenDisplay(name) Display *name(char *display_name)
typedef FPL__FUNC_X11_XOpenDisplay(fpl__func_x11_XOpenDisplay);
#define FPL__FUNC_X11_XCloseDisplay(name) int name(Display *display)
typedef FPL__FUNC_X11_XCloseDisplay(fpl__func_x11_XCloseDisplay);
#define FPL__FUNC_X11_XDefaultScreen(name) int name(Display *display)
typedef FPL__FUNC_X11_XDefaultScreen(fpl__func_x11_XDefaultScreen);
#define FPL__FUNC_X11_XRootWindow(name) Window name(Display *display, int screen_number)
typedef FPL__FUNC_X11_XRootWindow(fpl__func_x11_XRootWindow);
#define FPL__FUNC_X11_XCreateWindow(name) Window name(Display *display, Window parent, int x, int y, unsigned int width, unsigned int height, unsigned int border_width, int depth, unsigned int clazz, Visual *visual, unsigned long valuemask, XSetWindowAttributes *attributes)
typedef FPL__FUNC_X11_XCreateWindow(fpl__func_x11_XCreateWindow);
#define FPL__FUNC_X11_XDestroyWindow(name) int name(Display *display, Window w)
typedef FPL__FUNC_X11_XDestroyWindow(fpl__func_x11_XDestroyWindow);
#define FPL__FUNC_X11_XCreateColormap(name) Colormap name(Display *display, Window w, Visual *visual, int alloc)
typedef FPL__FUNC_X11_XCreateColormap(fpl__func_x11_XCreateColormap);
#define FPL__FUNC_X11_XDefaultColormap(name) Colormap name(Display *display, int screen_number)
typedef FPL__FUNC_X11_XDefaultColormap(fpl__func_x11_XDefaultColormap);
#define FPL__FUNC_X11_XFreeColormap(name) int name(Display *display, Colormap colormap)
typedef FPL__FUNC_X11_XFreeColormap(fpl__func_x11_XFreeColormap);
#define FPL__FUNC_X11_XMapWindow(name) int name(Display *display, Window w)
typedef FPL__FUNC_X11_XMapWindow(fpl__func_x11_XMapWindow);
#define FPL__FUNC_X11_XUnmapWindow(name) int name(Display *display, Window w)
typedef FPL__FUNC_X11_XUnmapWindow(fpl__func_x11_XUnmapWindow);
#define FPL__FUNC_X11_XStoreName(name) int name(Display *display, Window w, _Xconst char *window_name)
typedef FPL__FUNC_X11_XStoreName(fpl__func_x11_XStoreName);
#define FPL__FUNC_X11_XDefaultVisual(name) Visual *name(Display *display, int screen_number)
typedef FPL__FUNC_X11_XDefaultVisual(fpl__func_x11_XDefaultVisual);
#define FPL__FUNC_X11_XDefaultDepth(name) int name(Display *display, int screen_number)
typedef FPL__FUNC_X11_XDefaultDepth(fpl__func_x11_XDefaultDepth);
#define FPL__FUNC_X11_XInternAtom(name) Atom name(Display *display, const char *atom_name, Bool only_if_exists)
typedef FPL__FUNC_X11_XInternAtom(fpl__func_x11_XInternAtom);
#define FPL__FUNC_X11_XSetWMProtocols(name) Status name(Display *display, Window w, Atom *protocols, int count)
typedef FPL__FUNC_X11_XSetWMProtocols(fpl__func_x11_XSetWMProtocols);
#define FPL__FUNC_X11_XPending(name) int name(Display *display)
typedef FPL__FUNC_X11_XPending(fpl__func_x11_XPending);
#define FPL__FUNC_X11_XSync(name) int name(Display *display, Bool discard)
typedef FPL__FUNC_X11_XSync(fpl__func_x11_XSync);
#define FPL__FUNC_X11_XNextEvent(name) int name(Display *display, XEvent *event_return)
typedef FPL__FUNC_X11_XNextEvent(fpl__func_x11_XNextEvent);
#define FPL__FUNC_X11_XPeekEvent(name) int name(Display *display, XEvent *event_return)
typedef FPL__FUNC_X11_XPeekEvent(fpl__func_x11_XPeekEvent);
#define FPL__FUNC_X11_XEventsQueued(name) int name(Display *display, int mode)
typedef FPL__FUNC_X11_XEventsQueued(fpl__func_x11_XEventsQueued);
#define FPL__FUNC_X11_XGetWindowAttributes(name) Status name(Display *display, Window w, XWindowAttributes *window_attributes_return)
typedef FPL__FUNC_X11_XGetWindowAttributes(fpl__func_x11_XGetWindowAttributes);
#define FPL__FUNC_X11_XResizeWindow(name) int name(Display *display, Window w, unsigned int width, unsigned int height)
typedef FPL__FUNC_X11_XResizeWindow(fpl__func_x11_XResizeWindow);
#define FPL__FUNC_X11_XMoveWindow(name) int name(Display *display, Window w, int x, int y)
typedef FPL__FUNC_X11_XMoveWindow(fpl__func_x11_XMoveWindow);
#define FPL__FUNC_X11_XGetKeyboardMapping(name) KeySym *name(Display *display, KeyCode first_keycode, int keycode_count, int *keysyms_per_keycode_return)
typedef FPL__FUNC_X11_XGetKeyboardMapping(fpl__func_x11_XGetKeyboardMapping);
#define FPL__FUNC_X11_XLookupString(name) int name(XKeyEvent* event_struct, char* buffer_return, int bytes_buffer, KeySym* keysym_return, XComposeStatus* status_in_out)
typedef FPL__FUNC_X11_XLookupString(fpl__func_x11_XLookupString);
#define FPL__FUNC_X11_XSendEvent(name) Status name(Display *display, Window w, Bool propagate, long event_mask, XEvent *event_send)
typedef FPL__FUNC_X11_XSendEvent(fpl__func_x11_XSendEvent);
#define FPL__FUNC_X11_XMatchVisualInfo(name) Status name(Display* display, int screen, int depth, int clazz, XVisualInfo* vinfo_return)
typedef FPL__FUNC_X11_XMatchVisualInfo(fpl__func_x11_XMatchVisualInfo);
#define FPL__FUNC_X11_XCreateGC(name) GC name(Display* display, Drawable d, unsigned long valuemask, XGCValues* values)
typedef FPL__FUNC_X11_XCreateGC(fpl__func_x11_XCreateGC);
#define FPL__FUNC_X11_XGetImage(name) XImage *name(Display* display, Drawable d, int x, int y, unsigned int width, unsigned int height, unsigned long plane_mask, int format)
typedef FPL__FUNC_X11_XGetImage(fpl__func_x11_XGetImage);
#define FPL__FUNC_X11_XCreateImage(name) XImage *name(Display *display, Visual *visual, unsigned int depth, int format, int offset, char *data, unsigned int width, unsigned int height, int bitmap_pad, int bytes_per_line)
typedef FPL__FUNC_X11_XCreateImage(fpl__func_x11_XCreateImage);
#define FPL__FUNC_X11_XPutImage(name) int name(Display *display, Drawable d, GC gc, XImage *image, int src_x, int src_y, int dest_x, int    dest_y, unsigned int width, unsigned int height)
typedef FPL__FUNC_X11_XPutImage(fpl__func_x11_XPutImage);
#define FPL__FUNC_X11_XMapRaised(name) int name(Display *display, Window w)
typedef FPL__FUNC_X11_XMapRaised(fpl__func_x11_XMapRaised);
#define FPL__FUNC_X11_XCreatePixmap(name) Pixmap name(Display * display, Drawable d, unsigned int width, unsigned int height, unsigned int depth)
typedef FPL__FUNC_X11_XCreatePixmap(fpl__func_x11_XCreatePixmap);
#define FPL__FUNC_X11_XSelectInput(name) int name(Display * display, Window w, long eventMask)
typedef FPL__FUNC_X11_XSelectInput(fpl__func_x11_XSelectInput);
#define FPL__FUNC_X11_XGetWindowProperty(name) int name(Display* display, Window w, Atom prop, long long_offset, long long_length, Bool del, Atom req_type, Atom* actual_type_return, int* actual_format_return, unsigned long* nitems_return, unsigned long*   bytes_after_return, unsigned char** prop_return)
typedef FPL__FUNC_X11_XGetWindowProperty(fpl__func_x11_XGetWindowProperty);
#define FPL__FUNC_X11_XChangeProperty(name) int name(Display* display, Window w, Atom property, Atom type, int format, int mode, _Xconst unsigned char* data, int nelements)
typedef FPL__FUNC_X11_XChangeProperty(fpl__func_x11_XChangeProperty);
#define FPL__FUNC_X11_XDeleteProperty(name) int name(Display* display, Window w,Atom prop)
typedef FPL__FUNC_X11_XDeleteProperty(fpl__func_x11_XDeleteProperty);
#define FPL__FUNC_X11_XStringListToTextProperty(name) Status name(char** list, int count, XTextProperty* text_prop_return)
typedef FPL__FUNC_X11_XStringListToTextProperty(fpl__func_x11_XStringListToTextProperty);
#define FPL__FUNC_X11_XSetWMIconName(name) void name(Display* display, Window w, XTextProperty *text_prop)
typedef FPL__FUNC_X11_XSetWMIconName(fpl__func_x11_XSetWMIconName);
#define FPL__FUNC_X11_XSetWMName(name) void name(Display* display, Window w, XTextProperty *text_prop)
typedef FPL__FUNC_X11_XSetWMName(fpl__func_x11_XSetWMName);
#define FPL__FUNC_X11_XQueryKeymap(name) int name(Display* display, char [32])
typedef FPL__FUNC_X11_XQueryKeymap(fpl__func_x11_XQueryKeymap);
#define FPL__FUNC_X11_XQueryPointer(name) Bool name(Display* display, Window w, Window* root_return, Window* child_return, int* root_x_return, int* root_y_return, int* win_x_return, int* win_y_return, unsigned int* mask_return)
typedef FPL__FUNC_X11_XQueryPointer(fpl__func_x11_XQueryPointer);
#define FPL__FUNC_X11_XConvertSelection(name) int name(Display *display, Atom selection, Atom target, Atom property, Window requestor, Time time)
typedef FPL__FUNC_X11_XConvertSelection(fpl__func_x11_XConvertSelection);
#define FPL__FUNC_X11_XInitThreads(name) Status name(void)
typedef FPL__FUNC_X11_XInitThreads(fpl__func_x11_XInitThreads);
#define FPL__FUNC_X11_XSetErrorHandler(name) XErrorHandler name(XErrorHandler *handler)
typedef FPL__FUNC_X11_XSetErrorHandler(fpl__func_x11_XSetErrorHandler);
 
typedef struct fpl__X11Api {
    void *libHandle;
    fpl__func_x11_XFlush *XFlush;
    fpl__func_x11_XFree *XFree;
    fpl__func_x11_XOpenDisplay *XOpenDisplay;
    fpl__func_x11_XCloseDisplay *XCloseDisplay;
    fpl__func_x11_XDefaultScreen *XDefaultScreen;
    fpl__func_x11_XRootWindow *XRootWindow;
    fpl__func_x11_XCreateWindow *XCreateWindow;
    fpl__func_x11_XDestroyWindow *XDestroyWindow;
    fpl__func_x11_XCreateColormap *XCreateColormap;
    fpl__func_x11_XFreeColormap *XFreeColormap;
    fpl__func_x11_XDefaultColormap *XDefaultColormap;
    fpl__func_x11_XMapWindow *XMapWindow;
    fpl__func_x11_XUnmapWindow *XUnmapWindow;
    fpl__func_x11_XStoreName *XStoreName;
    fpl__func_x11_XDefaultVisual *XDefaultVisual;
    fpl__func_x11_XDefaultDepth *XDefaultDepth;
    fpl__func_x11_XInternAtom *XInternAtom;
    fpl__func_x11_XSetWMProtocols *XSetWMProtocols;
    fpl__func_x11_XPending *XPending;
    fpl__func_x11_XSync *XSync;
    fpl__func_x11_XNextEvent *XNextEvent;
    fpl__func_x11_XPeekEvent *XPeekEvent;
    fpl__func_x11_XEventsQueued *XEventsQueued;
    fpl__func_x11_XGetWindowAttributes *XGetWindowAttributes;
    fpl__func_x11_XResizeWindow *XResizeWindow;
    fpl__func_x11_XMoveWindow *XMoveWindow;
    fpl__func_x11_XGetKeyboardMapping *XGetKeyboardMapping;
    fpl__func_x11_XLookupString *XLookupString;
    fpl__func_x11_XSendEvent *XSendEvent;
    fpl__func_x11_XMatchVisualInfo *XMatchVisualInfo;
    fpl__func_x11_XCreateGC *XCreateGC;
    fpl__func_x11_XGetImage *XGetImage;
    fpl__func_x11_XPutImage *XPutImage;
    fpl__func_x11_XMapRaised *XMapRaised;
    fpl__func_x11_XCreateImage *XCreateImage;
    fpl__func_x11_XCreatePixmap *XCreatePixmap;
    fpl__func_x11_XSelectInput *XSelectInput;
    fpl__func_x11_XGetWindowProperty *XGetWindowProperty;
    fpl__func_x11_XChangeProperty *XChangeProperty;
    fpl__func_x11_XDeleteProperty *XDeleteProperty;
    fpl__func_x11_XStringListToTextProperty *XStringListToTextProperty;
    fpl__func_x11_XSetWMIconName *XSetWMIconName;
    fpl__func_x11_XSetWMName *XSetWMName;
    fpl__func_x11_XQueryKeymap *XQueryKeymap;
    fpl__func_x11_XQueryPointer *XQueryPointer;
    fpl__func_x11_XConvertSelection *XConvertSelection;
    fpl__func_x11_XInitThreads *XInitThreads;
    fpl__func_x11_XSetErrorHandler *XSetErrorHandler;
} fpl__X11Api;
 
fpl_internal void fpl__UnloadX11Api(fpl__X11Api *x11Api) {
    fplAssert(x11Api != fpl_null);
    if (x11Api->libHandle != fpl_null) {
        dlclose(x11Api->libHandle);
    }
    fplClearStruct(x11Api);
}
 
fpl_internal bool fpl__LoadX11Api(fpl__X11Api *x11Api) {
    fplAssert(x11Api != fpl_null);
    const char *libFileNames[] = {
        "libX11.so",
        "libX11.so.7",
        "libX11.so.6",
        "libX11.so.5",
    };
    bool result = false;
    for (uint32_t index = 0; index < fplArrayCount(libFileNames); ++index) {
        const char *libName = libFileNames[index];
        fplClearStruct(x11Api);
        do {
            void *libHandle = fpl_null;
            FPL__POSIX_LOAD_LIBRARY(FPL__MODULE_X11, libHandle, libName);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XFlush, XFlush);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XFree, XFree);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XOpenDisplay, XOpenDisplay);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XCloseDisplay, XCloseDisplay);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XDefaultScreen, XDefaultScreen);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XRootWindow, XRootWindow);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XCreateWindow, XCreateWindow);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XDestroyWindow, XDestroyWindow);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XCreateColormap, XCreateColormap);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XFreeColormap, XFreeColormap);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XDefaultColormap, XDefaultColormap);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XMapWindow, XMapWindow);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XUnmapWindow, XUnmapWindow);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XStoreName, XStoreName);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XDefaultVisual, XDefaultVisual);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XDefaultDepth, XDefaultDepth);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XInternAtom, XInternAtom);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XSetWMProtocols, XSetWMProtocols);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XPending, XPending);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XSync, XSync);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XNextEvent, XNextEvent);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XPeekEvent, XPeekEvent);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XEventsQueued, XEventsQueued);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XGetWindowAttributes, XGetWindowAttributes);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XResizeWindow, XResizeWindow);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XMoveWindow, XMoveWindow);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XGetKeyboardMapping, XGetKeyboardMapping);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XLookupString, XLookupString);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XSendEvent, XSendEvent);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XMatchVisualInfo, XMatchVisualInfo);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XCreateGC, XCreateGC);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XGetImage, XGetImage);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XPutImage, XPutImage);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XMapRaised, XMapRaised);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XCreateImage, XCreateImage);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XCreatePixmap, XCreatePixmap);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XSelectInput, XSelectInput);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XGetWindowProperty, XGetWindowProperty);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XChangeProperty, XChangeProperty);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XDeleteProperty, XDeleteProperty);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XStringListToTextProperty, XStringListToTextProperty);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XSetWMIconName, XSetWMIconName);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XSetWMName, XSetWMName);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XQueryKeymap, XQueryKeymap);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XQueryPointer, XQueryPointer);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XConvertSelection, XConvertSelection);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XInitThreads, XInitThreads);
            FPL__POSIX_GET_FUNCTION_ADDRESS(FPL__MODULE_X11, libHandle, libName, x11Api, fpl__func_x11_XSetErrorHandler, XSetErrorHandler);
            x11Api->libHandle = libHandle;
            result = true;
        } while (0);
        if (result) {
            break;
        }
        fpl__UnloadX11Api(x11Api);
    }
    return(result);
}
 
typedef struct fpl__X11SubplatformState {
    fpl__X11Api api;
} fpl__X11SubplatformState;
 
typedef struct fpl__X11WindowStateInfo {
    fplWindowState state;
    fplWindowVisibilityState visibility;
    fplWindowPosition position;
    fplWindowSize size;
} fpl__X11WindowStateInfo;
 
typedef struct fpl__X11Xdnd {
    int version;
    Window source;
    Atom format;
} fpl__X11Xdnd;
 
#define FPL__FUNC_X11_ErrorHandlerCallback(name) int name(Display *display, XErrorEvent *ev)
typedef FPL__FUNC_X11_ErrorHandlerCallback(fpl__func_X11ErrorHandlerCallback);
 
typedef struct fpl__X11WindowState {
    fpl__X11WindowStateInfo lastWindowStateInfo;
    Colormap colorMap;
    Display *display;
    fpl__func_X11ErrorHandlerCallback *lastErrorHandler;
    fpl__X11Xdnd xdnd;
    Window root;
    Window window;
    Visual *visual;
    Atom wmProtocols;
    Atom wmDeleteWindow;
    Atom wmState;
    Atom netWMPing;
    Atom netWMState;
    Atom netWMStateFocused;
    Atom netWMStateFullscreen;
    Atom netWMStateHidden;
    Atom netWMStateMaximizedVert;
    Atom netWMStateMaximizedHorz;
    Atom netWMPid;
    Atom netWMIcon;
    Atom netWMName;
    Atom netWMIconName;
    Atom utf8String;
    Atom motifWMHints;
    // drag and drop
    Atom xdndAware;
    Atom xdndEnter;
    Atom xdndPosition;
    Atom xdndStatus;
    Atom xdndActionCopy;
    Atom xdndDrop;
    Atom xdndFinished;
    Atom xdndSelection;
    Atom xdndTypeList;
    Atom textUriList;
    int screen;
    int colorDepth;
} fpl__X11WindowState;
 
#define FPL__XDND_VERSION 5
 
#endif // FPL_SUBPLATFORM_X11
 
// ****************************************************************************
//
// > PLATFORM_STATES
//
// - Defines the final PlatformInitState and PlatformAppState
// - Declares all required global variables
//
// ****************************************************************************
#if !defined(FPL__PLATFORM_STATES_DEFINED)
#define FPL__PLATFORM_STATES_DEFINED
//
// Platform initialization state
//
typedef struct fpl__PlatformInitSettings {
    fplMemorySettings memorySettings;
} fpl__PlatformInitSettings;
 
typedef struct fpl__PlatformInitState {
#if defined(FPL_SUBPLATFORM_POSIX)
    fpl__PosixInitState posix;
#endif
 
    fpl__PlatformInitSettings initSettings;
    fplPlatformResultType initResult;
    fpl_b32 isInitialized;
 
    union {
#   if defined(FPL_PLATFORM_WINDOWS)
        fpl__Win32InitState win32;
#   elif defined(FPL_PLATFORM_LINUX)
        fpl__LinuxInitState plinux;
#   elif defined(FPL_PLATFORM_UNIX)
        fpl__UnixInitState punix;
#   endif               
    };
} fpl__PlatformInitState;
fpl_globalvar fpl__PlatformInitState fpl__global__InitState = fplZeroInit;
 
#if defined(FPL__ENABLE_WINDOW)
#define FPL__MAX_EVENT_COUNT 32768
typedef struct fpl__EventQueue {
    // @FIXME(final): Internal events are not Thread-Safe!
    fplEvent events[FPL__MAX_EVENT_COUNT];
    uint32_t pollIndex;
    uint32_t pushCount;
} fpl__EventQueue;
 
typedef struct fpl__PlatformWindowState {
    fpl__EventQueue eventQueue;
    fplKey keyMap[256];
    fplButtonState keyStates[256];
    uint64_t keyPressTimes[256];
    fplButtonState mouseStates[5];
    fpl_b32 isRunning;
 
#if defined(FPL_PLATFORM_WINDOWS)
    fpl__Win32WindowState win32;
#endif
#if defined(FPL_SUBPLATFORM_X11)
    fpl__X11WindowState x11;
#endif
} fpl__PlatformWindowState;
#endif // FPL__ENABLE_WINDOW
 
#if defined(FPL__ENABLE_VIDEO)
typedef struct fpl__PlatformVideoState {
    void *mem; // Points to fpl__VideoState
    size_t memSize;
} fpl__PlatformVideoState;
#endif // FPL__ENABLE_VIDEO
 
#if defined(FPL__ENABLE_AUDIO)
typedef struct fpl__PlatformAudioState {
    void *mem; // Points to fpl__AudioState
    size_t memSize;
} fpl__PlatformAudioState;
#endif
 
//
// Platform application state
//
typedef struct fpl__PlatformAppState fpl__PlatformAppState;
struct fpl__PlatformAppState {
    // Subplatforms
#if defined(FPL_SUBPLATFORM_POSIX)
    fpl__PosixAppState posix;
#endif
#if defined(FPL_SUBPLATFORM_X11)
    fpl__X11SubplatformState x11;
#endif
 
    // Window/video/audio
#if defined(FPL__ENABLE_WINDOW)
    fpl__PlatformWindowState window;
#endif
#if defined(FPL__ENABLE_VIDEO)
    fpl__PlatformVideoState video;
#endif
#if defined(FPL__ENABLE_AUDIO)
    fpl__PlatformAudioState audio;
#endif
 
    // Settings
    fplSettings initSettings;
    fplSettings currentSettings;
    fplInitFlags initFlags;
 
    // Platforms
    union {
#   if defined(FPL_PLATFORM_WINDOWS)
        fpl__Win32AppState win32;
#   elif defined(FPL_PLATFORM_LINUX)
        fpl__LinuxAppState plinux;
#   elif defined(FPL_PLATFORM_UNIX)
        fpl__UnixAppState plinux;
#   endif
    };
};
 
//
// Internal window
//
#if defined(FPL__ENABLE_WINDOW)
fpl_internal fplKey fpl__GetMappedKey(const fpl__PlatformWindowState *windowState, const uint64_t keyCode) {
    fplKey result;
    if (keyCode < fplArrayCount(windowState->keyMap))
        result = windowState->keyMap[keyCode];
    else
        result = fplKey_None;
    return(result);
}
 
fpl_internal void fpl__ClearInternalEvents() {
    fpl__PlatformAppState *appState = fpl__global__AppState;
    fplAssert(appState != fpl_null);
    fpl__EventQueue *eventQueue = &appState->window.eventQueue;
    // @FIXME(final): Internal events are not thread-safe, introduce a proper thread-safe queue here!
    uint32_t eventCount = eventQueue->pollIndex;
    eventQueue->pollIndex = 0;
    for (size_t eventIndex = 0; eventIndex < eventCount; ++eventIndex) {
        fplEvent *ev = &eventQueue->events[eventIndex];
        if (ev->window.dropFiles.internalMemory.base != fpl_null) {
            fpl__ReleaseDynamicMemory(ev->window.dropFiles.internalMemory.base);
            fplClearStruct(&ev->window.dropFiles.internalMemory);
        }
    }
    eventQueue->pushCount = 0;
}