__declspec(align(16)) union Mat4f {
	struct {
		Vec4f col1;
		Vec4f col2;
		Vec4f col3;
		Vec4f col4;
	};
	struct {
		f32 elements[4][4];
	};
	f32 m[16];
};

name of display: :1
display: :1  screen: 0
direct rendering: Yes
server glx vendor string: NVIDIA Corporation
server glx version string: 1.4
server glx extensions:
    GLX_ARB_context_flush_control, GLX_ARB_create_context,
    GLX_ARB_create_context_profile, GLX_ARB_create_context_robustness,
    GLX_ARB_fbconfig_float, GLX_ARB_multisample, GLX_EXT_buffer_age,
    GLX_EXT_create_context_es2_profile, GLX_EXT_create_context_es_profile,
    GLX_EXT_framebuffer_sRGB, GLX_EXT_import_context, GLX_EXT_libglvnd,
    GLX_EXT_stereo_tree, GLX_EXT_swap_control, GLX_EXT_swap_control_tear,
    GLX_EXT_texture_from_pixmap, GLX_EXT_visual_info, GLX_EXT_visual_rating,
    GLX_NV_copy_image, GLX_NV_delay_before_swap, GLX_NV_float_buffer,
    GLX_NV_robustness_video_memory_purge, GLX_SGIX_fbconfig, GLX_SGIX_pbuffer,
    GLX_SGI_swap_control, GLX_SGI_video_sync
client glx vendor string: NVIDIA Corporation
client glx version string: 1.4
client glx extensions:
    GLX_ARB_context_flush_control, GLX_ARB_create_context,
    GLX_ARB_create_context_profile, GLX_ARB_create_context_robustness,
    GLX_ARB_fbconfig_float, GLX_ARB_get_proc_address, GLX_ARB_multisample,
    GLX_EXT_buffer_age, GLX_EXT_create_context_es2_profile,
    GLX_EXT_create_context_es_profile, GLX_EXT_fbconfig_packed_float,
    GLX_EXT_framebuffer_sRGB, GLX_EXT_import_context, GLX_EXT_stereo_tree,
    GLX_EXT_swap_control, GLX_EXT_swap_control_tear,
    GLX_EXT_texture_from_pixmap, GLX_EXT_visual_info, GLX_EXT_visual_rating,
    GLX_NV_copy_buffer, GLX_NV_copy_image, GLX_NV_delay_before_swap,
    GLX_NV_float_buffer, GLX_NV_multisample_coverage, GLX_NV_present_video,
    GLX_NV_robustness_video_memory_purge, GLX_NV_swap_group,
    GLX_NV_video_capture, GLX_NV_video_out, GLX_SGIX_fbconfig,
    GLX_SGIX_pbuffer, GLX_SGI_swap_control, GLX_SGI_video_sync
GLX version: 1.4
GLX extensions:
    GLX_ARB_context_flush_control, GLX_ARB_create_context,
    GLX_ARB_create_context_profile, GLX_ARB_create_context_robustness,
    GLX_ARB_fbconfig_float, GLX_ARB_get_proc_address, GLX_ARB_multisample,
    GLX_EXT_buffer_age, GLX_EXT_create_context_es2_profile,
    GLX_EXT_create_context_es_profile, GLX_EXT_framebuffer_sRGB,
    GLX_EXT_import_context, GLX_EXT_stereo_tree, GLX_EXT_swap_control,
    GLX_EXT_swap_control_tear, GLX_EXT_texture_from_pixmap,
    GLX_EXT_visual_info, GLX_EXT_visual_rating, GLX_NV_copy_image,
    GLX_NV_delay_before_swap, GLX_NV_float_buffer,
    GLX_NV_robustness_video_memory_purge, GLX_SGIX_fbconfig, GLX_SGIX_pbuffer,
    GLX_SGI_swap_control, GLX_SGI_video_sync

final@final-i7:~$ nvidia-smi 
Thu Mar 22 19:39:12 2018       
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 384.111                Driver Version: 384.111                   |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  GeForce GTX 970     Off  | 00000000:01:00.0  On |                  N/A |
|  0%   32C    P0    50W / 200W |    336MiB /  4034MiB |      0%      Default |
+-------------------------------+----------------------+----------------------+
                                                                               
+-----------------------------------------------------------------------------+
| Processes:                                                       GPU Memory |
|  GPU       PID   Type   Process name                             Usage      |
|=============================================================================|
|    0       988      G   /usr/lib/xorg/Xorg                            16MiB |
|    0      1043      G   /usr/bin/gnome-shell                          52MiB |
|    0      1305      G   /usr/lib/xorg/Xorg                           111MiB |
|    0      1433      G   /usr/bin/gnome-shell                          76MiB |
|    0      1819      G   ...-token=80B7115FD44AA707D1FBCFCDFDE322BE    75MiB |
+-----------------------------------------------------------------------------+

/usr/lib/libGLX_nvidia.so
/usr/lib/libGLX_mesa.so.0
/usr/lib/libGLX_indirect.so.0
/usr/lib/libGLX.so

// ****************************************************************************
//
// > HEADER
//
// ****************************************************************************
#ifndef FPL_INCLUDE_H
#define FPL_INCLUDE_H

// C99 detection
#if defined(__cplusplus) || (defined(__cplusplus) && defined(_MSC_VER) && _MSC_VER >= 1900)
#	define FPL_IS_CPP
#elif (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || (defined(_MSC_VER) && _MSC_VER >= 1900)
#	define FPL_IS_C99
#else
#	error "This C/C++ compiler is not supported!"
#endif

//
// Platform detection
//
// https://sourceforge.net/p/predef/wiki/OperatingSystems/
#if defined(_WIN32) || defined(_WIN64)
#	define FPL_PLATFORM_WIN32
#	define FPL_PLATFORM_NAME "Windows"
#	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__)
#	define FPL_PLATFORM_BSD
#	define FPL_PLATFORM_NAME "BSD"
#	define FPL_SUBPLATFORM_POSIX
#	define FPL_SUBPLATFORM_X11
#	define FPL_SUBPLATFORM_STD_STRINGS
#	define FPL_SUBPLATFORM_STD_CONSOLE
#	error "Not implemented yet!"
#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
#	error "Not implemented yet!"
#else
#	error "This platform is not supported!"
#endif // FPL_PLATFORM

//
// Architecture detection (x86, x64)
// See: https://sourceforge.net/p/predef/wiki/Architectures/
//
#if defined(_M_X64) || defined(__x86_64__) || defined(__amd64__)
#	define FPL_ARCH_X64
#elif defined(_M_IX86) || defined(__i386__) || defined(__X86__) || defined(_X86_)
#	define FPL_ARCH_X86
#elif defined(__arm__) || defined(_M_ARM)
#	if defined(__aarch64__)
#		define FPL_ARCH_ARM64
#	else	
#		define FPL_ARCH_ARM32
#	endif
#else
#	error "This architecture is not supported!"
#endif // FPL_ARCH

//
// Build configuration and compilers
// See: http://beefchunk.com/documentation/lang/c/pre-defined-c/precomp.html
// See: http://nadeausoftware.com/articles/2012/10/c_c_tip_how_detect_compiler_name_and_version_using_compiler_predefined_macros
//
#if defined(__clang__)
	//! CLANG compiler detected
#	define FPL_COMPILER_CLANG
#elif defined(__llvm__)
	//! LLVM compiler detected
#	define FPL_COMPILER_LLVM
#elif defined(__INTEL_COMPILER)
	//! Intel compiler detected
#	define FPL_COMPILER_INTEL
#elif defined(__MINGW32__)
	//! MingW compiler detected
#	define FPL_COMPILER_MINGW
#elif defined(__GNUC__) && !defined(__clang__)
	//! GCC compiler detected
#	define FPL_COMPILER_GCC
#elif defined(_MSC_VER)
	//! Visual studio compiler detected
#	define FPL_COMPILER_MSVC
#else
	//! No compiler detected
#	define FPL_COMPILER_UNKNOWN
#endif // FPL_COMPILER

//
// Compiler depended settings and detections
//
#if defined(FPL_COMPILER_MSVC)
	//! 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 )

#	if defined(_DEBUG) || (!defined(NDEBUG))
		//! Debug mode detected
#		define FPL_ENABLE_DEBUG
#	else
		//! Non-debug (Release) mode detected
#		define FPL_ENABLE_RELEASE
#	endif

	//! Function name macro (Win32)
#   define FPL_FUNCTION_NAME __FUNCTION__
#else
	// @NOTE(final): Expect all other compilers to pass in FPL_DEBUG manually
#	if defined(FPL_DEBUG)
		//! Debug mode detected
#		define FPL_ENABLE_DEBUG
#	else
		//! Non-debug (Release) mode detected
#		define FPL_ENABLE_RELEASE
#	endif

	//! Function name macro (Other compilers)
#   define FPL_FUNCTION_NAME __FUNCTION__
#endif // FPL_COMPILER

//
// Options & Feature detection
//

// Assertions
#if !defined(FPL_NO_ASSERTIONS)
#	if !defined(FPL_FORCE_ASSERTIONS)
#		if defined(FPL_ENABLE_DEBUG)
			//! Enable Assertions in Debug Mode by default
#			define FPL_ENABLE_ASSERTIONS
#		endif
#	else
		//! Enable Assertions always
#		define FPL_ENABLE_ASSERTIONS
#	endif
#endif // !FPL_NO_ASSERTIONS
#if defined(FPL_ENABLE_ASSERTIONS)
#	if !defined(FPL_NO_C_ASSERT)
		//! Enable C-Runtime Assertions by default
#		define FPL_ENABLE_C_ASSERT
#	endif
#endif // FPL_ENABLE_ASSERTIONS

// Window
#if !defined(FPL_NO_WINDOW)
	//! Window support enabled by default
#	define FPL_SUPPORT_WINDOW
#endif

// Video
#if !defined(FPL_NO_VIDEO)
	//! Video support
#	define FPL_SUPPORT_VIDEO
#endif
#if defined(FPL_SUPPORT_VIDEO)
#	if !defined(FPL_NO_VIDEO_OPENGL)
		//! OpenGL support enabled by default
#		define FPL_SUPPORT_VIDEO_OPENGL
#	endif
#	if !defined(FPL_NO_VIDEO_SOFTWARE)
		//! Software rendering support enabled by default
#		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_WIN32)
		//! DirectSound support is only available on Win32
#		define FPL_SUPPORT_AUDIO_DIRECTSOUND
#	endif
#endif // FPL_SUPPORT_AUDIO

// Remove video support when 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_SOFTWARE)
#		undef FPL_SUPPORT_VIDEO_SOFTWARE
#	endif
#endif // !FPL_SUPPORT_WINDOW

//
// Enable supports (FPL uses _ENABLE_ internally only)
//
#if defined(FPL_SUPPORT_WINDOW)
	//! Enable Window
#	define FPL_ENABLE_WINDOW
#endif
#if defined(FPL_SUPPORT_VIDEO)
	//! Enable Video
#	define FPL_ENABLE_VIDEO
#	if defined(FPL_SUPPORT_VIDEO_OPENGL)
		//! Enable OpenGL Video
#		define FPL_ENABLE_VIDEO_OPENGL
#	endif
#	if defined(FPL_SUPPORT_VIDEO_SOFTWARE)
		//! Enable Software Rendering Video
#		define FPL_ENABLE_VIDEO_SOFTWARE
#	endif
#endif // FPL_SUPPORT_VIDEO
#if defined(FPL_SUPPORT_AUDIO)
	//! Enable Audio
#	define FPL_ENABLE_AUDIO
#	if defined(FPL_SUPPORT_AUDIO_DIRECTSOUND)
		//! Enable DirectSound Audio
#		define FPL_ENABLE_AUDIO_DIRECTSOUND
#	endif
#endif // FPL_SUPPORT_AUDIO

#if !defined(FPL_NO_ERROR_IN_CONSOLE)
	//! Write errors in console
#	define FPL_ENABLE_ERROR_IN_CONSOLE
#endif
#if !defined(FPL_NO_MULTIPLE_ERRORSTATES)
	//! Allow multiple error states
#	define FPL_ENABLE_MULTIPLE_ERRORSTATES
#endif
#if defined(FPL_AUTO_NAMESPACE)
	//! Expand namespaces at the header end always
#	define FPL_ENABLE_AUTO_NAMESPACE
#endif

//
// Static/Inline/Extern/Internal
//
//! Global persistent variable
#define fpl_globalvar static
//! Local persistent variable
#define fpl_localvar static
//! Private/Internal function
#define fpl_internal static
//! Inline function
#define fpl_inline inline
//! Internal inlined function
#define fpl_internal_inline inline
//! Null
#define fpl_null '\0'

#if defined(FPL_API_AS_PRIVATE)
	//! Private api call
#	define fpl_api static
#else
	//! Public api call
#	define fpl_api extern
#endif // FPL_API_AS_PRIVATE

//! Platform api definition
#define fpl_platform_api fpl_api
//! Common api definition
#define fpl_common_api fpl_api
//! Main entry point api definition
#define fpl_main

//
// Assertions
//
#if defined(FPL_ENABLE_ASSERTIONS)
#	if defined(FPL_ENABLE_C_ASSERT) && !defined(FPL_FORCE_ASSERTIONS)
#		include <assert.h>
		//! Runtime assert (C Runtime)
#		define FPL_ASSERT(exp) assert(exp)
		//! Compile error assert (C Runtime)
#		define FPL_STATICASSERT(exp) static_assert(exp, "static_assert")
#	else
		//! Runtime assert
#		define FPL_ASSERT(exp) if(!(exp)) {*(int *)0 = 0;}
		//! Compile error assert
#		define FPL_STATICASSERT_(exp, line) \
			int fpl_static_assert_##line(int static_assert_failed[(exp)?1:-1])
#		define FPL_STATICASSERT(exp) \
			FPL_STATICASSERT_(exp, __LINE__)
#	endif // FPL_ENABLE_C_ASSERT
#else
	//! Runtime assertions disabled
#	define FPL_ASSERT(exp)
	//! Compile time assertions disabled
#	define FPL_STATICASSERT(exp)
#endif // FPL_ENABLE_ASSERTIONS

//! This will full-on crash when something is not implemented always.
#define FPL_NOT_IMPLEMENTED {*(int *)0 = 0xBAD;}

//
// Logging
//
#if defined(FPL_LOGGING)
	//! Enable logging
#   define FPL_ENABLE_LOGGING
#endif

//
// Types & Limits
//
#include <stdint.h> // uint32_t, ...
#include <stddef.h> // size_t
#include <stdlib.h> // UINT32_MAX, ...
#include <stdbool.h> // bool

//
// Macro functions
//
//! Macro for initialize a struct to zero
#if defined(FPL_IS_C99)
#	define FPL_STRUCT_ZERO {0}
#else
#	define FPL_STRUCT_ZERO {}
#endif


//! Returns the element count from a static array,
#define FPL_ARRAYCOUNT(arr) (sizeof(arr) / sizeof((arr)[0]))

//! Returns the offset in bytes to a field in a structure
#define FPL_OFFSETOF(type, field) ((size_t)(&(((type*)(0))->field)))

//! Returns the offset for the value to satisfy the given alignment boundary
#define FPL_ALIGNMENT_OFFSET(value, alignment) ( (((alignment) > 1) && (((value) & ((alignment) - 1)) != 0)) ? ((alignment) - ((value) & (alignment - 1))) : 0)           
//! Returns the given size extended o to satisfy the given alignment boundary
#define FPL_ALIGNED_SIZE(size, alignment) (((size) > 0 && (alignment) > 0) ? ((size) + FPL_ALIGNMENT_OFFSET(size, alignment)) : (size))
//! Returns true when the given pointer address is aligned to the given alignment
#define FPL_IS_ALIGNED(ptr, alignment) (((uintptr_t)(const void *)(ptr)) % (alignment) == 0)

//! Returns the smallest value
#define FPL_MIN(a, b) ((a) < (b)) ? (a) : (b)
//! Returns the biggest value
#define FPL_MAX(a, b) ((a) > (b)) ? (a) : (b)

//! Returns the number of bytes for the given kilobytes
#define FPL_KILOBYTES(value) (((value) * 1024ull))
//! Returns the number of bytes for the given megabytes
#define FPL_MEGABYTES(value) ((FPL_KILOBYTES(value) * 1024ull))
//! Returns the number of bytes for the given gigabytes
#define FPL_GIGABYTES(value) ((FPL_MEGABYTES(value) * 1024ull))
//! Returns the number of bytes for the given terabytes
#define FPL_TERABYTES(value) ((FPL_GIGABYTES(value) * 1024ull))

//! Manually allocate memory on the stack (Use this with care!)
#define FPL_STACKALLOCATE(size) _alloca(size)

// ****************************************************************************
// ****************************************************************************
//
// Platform includes
//
// ****************************************************************************
// ****************************************************************************
#if defined(FPL_PLATFORM_WIN32)
// @NOTE(final): windef.h defines min/max macros defined 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
#	include <windows.h>		// Win32 api, its unfortunate we have to include this in the header as well, but there are structures
#endif // FPL_PLATFORM_WIN32

#if defined(FPL_SUBPLATFORM_POSIX)
#	include <pthread.h> // pthread_t, pthread_mutex_, pthread_cond_, pthread_barrier_
#endif // FPL_SUBPLATFORM_POSIX

#if defined(FPL_SUBPLATFORM_X11)
#   include <X11/X.h> // Window
#   include <X11/Xlib.h> // Display
#   undef None
#   undef Success
#endif // FPL_SUBPLATFORM_X11

// ****************************************************************************
// ****************************************************************************
//
// API Declaration
//
// ****************************************************************************
// ****************************************************************************

// ----------------------------------------------------------------------------
/**
  * \defgroup Atomics Atomic functions
  * \brief Atomic functions, like AtomicCompareAndExchange, AtomicReadFence, etc.
  * \{
  */
// ----------------------------------------------------------------------------

/**
  * \brief Insert a memory read fence/barrier.
  *
  * This will complete previous reads before future reads and prevents the compiler from reordering memory reads across this fence.
  */
fpl_platform_api void fplAtomicReadFence();
/**
  * \brief Insert a memory write fence/barrier.
  * This will complete previous writes before future writes and prevents the compiler from reordering memory writes across this fence.
  */
fpl_platform_api void fplAtomicWriteFence();
/**
  * \brief Insert a memory read/write fence/barrier.
  * This will complete previous reads/writes before future reads/writes and prevents the compiler from reordering memory access across this fence.
  */
fpl_platform_api void fplAtomicReadWriteFence();

/**
  * \brief Replace a 32-bit unsigned integer with the given value atomically.
  * Ensures that memory operations are completed in order.
  * \param target The target value to write into.
  * \param value The source value used for exchange.
  * \return Returns the initial value before the replacement.
  */
fpl_platform_api uint32_t fplAtomicExchangeU32(volatile uint32_t *target, const uint32_t value);
/**
  * \brief Replace a 64-bit unsigned integer with the given value atomically.
  * Ensures that memory operations are completed in order.
  * \param target The target value to write into.
  * \param value The source value used for exchange.
  * \return Returns the initial value before the replacement.
  */
fpl_platform_api uint64_t fplAtomicExchangeU64(volatile uint64_t *target, const uint64_t value);
/**
  * \brief Replace a 32-bit signed integer with the given value atomically.
  * Ensures that memory operations are completed in order.
  * \param target The target value to write into.
  * \param value The source value used for exchange.
  * \return Returns the initial value before the replacement.
  */
fpl_platform_api int32_t fplAtomicExchangeS32(volatile int32_t *target, const int32_t value);
/**
  * \brief Replace a 64-bit signed integer with the given value atomically.
  * Ensures that memory operations are completed in order.
  * \param target The target value to write into.
  * \param value The source value used for exchange.
  * \return Returns the initial value before the replacement.
  */
fpl_platform_api int64_t fplAtomicExchangeS64(volatile int64_t *target, const int64_t value);
/**
  * \brief Replace a pointer with the given value atomically.
  * Ensures that memory operations are completed in order.
  * \param target The target value to write into.
  * \param value The source value used for exchange.
  * \return Returns the initial value before the replacement.
  */
fpl_common_api void *fplAtomicExchangePtr(volatile void **target, const void *value);

/**
  * \brief Adds a 32-bit unsigned integer to the value by the given addend atomically.
  * Ensures that memory operations are completed in order.
  * \param value The target value to append to.
  * \param addend The value used for adding.
  * \return Returns the initial value before the append.
  */
fpl_platform_api uint32_t fplAtomicAddU32(volatile uint32_t *value, const uint32_t addend);
/**
  * \brief Adds a 64-bit unsigned integer to the value by the given addend atomically.
  * Ensures that memory operations are completed in order.
  * \param value The target value to append to.
  * \param addend The value used for adding.
  * \return Returns the initial value before the append.
  */
fpl_platform_api uint64_t fplAtomicAddU64(volatile uint64_t *value, const uint64_t addend);
/**
  * \brief Adds a 32-bit signed integer to the value by the given addend atomically.
  * Ensures that memory operations are completed in order.
  * \param value The target value to append to.
  * \param addend The value used for adding.
  * \return Returns the initial value before the append.
  */
fpl_platform_api int32_t fplAtomicAddS32(volatile int32_t *value, const int32_t addend);
/**
  * \brief Adds a 64-bit signed integer to the value by the given addend atomically.
  * Ensures that memory operations are completed in order.
  * \param value The target value to append to.
  * \param addend The value used for adding.
  * \return Returns the initial value before the append.
  */
fpl_platform_api int64_t fplAtomicAddS64(volatile int64_t *value, const int64_t addend);

/**
  * \brief Compares a 32-bit unsigned integer with a comparand and exchange it when comparand matches destination.
  * Ensures that memory operations are completed in order.
  * \param dest The target value to write into.
  * \param comparand The value to compare with.
  * \param exchange The value to exchange with.
  * \note Use \ref fplIsAtomicCompareAndExchangeU32() when you want to check if the exchange has happened or not.
  * \return Returns the dest before the exchange, regardless of the result.
  */
fpl_platform_api uint32_t fplAtomicCompareAndExchangeU32(volatile uint32_t *dest, const uint32_t comparand, const uint32_t exchange);
/**
  * \brief Compares a 64-bit unsigned integer with a comparand and exchange it when comparand matches destination.
  * Ensures that memory operations are completed in order.
  * \param dest The target value to write into.
  * \param comparand The value to compare with.
  * \param exchange The value to exchange with.
  * \note Use \ref fplIsAtomicCompareAndExchangeU64() when you want to check if the exchange has happened or not.
  * \return Returns the value of the destination before the exchange, regardless of the result.
  */
fpl_platform_api uint64_t fplAtomicCompareAndExchangeU64(volatile uint64_t *dest, const uint64_t comparand, const uint64_t exchange);
/**
  * \brief Compares a 32-bit signed integer with a comparand and exchange it when comparand matches destination.
  * Ensures that memory operations are completed in order.
  * \param dest The target value to write into.
  * \param comparand The value to compare with.
  * \param exchange The value to exchange with.
  * \note Use \ref fplIsAtomicCompareAndExchangeS32() when you want to check if the exchange has happened or not.
  * \return Returns the value of the destination before the exchange, regardless of the result.
  */
fpl_platform_api int32_t fplAtomicCompareAndExchangeS32(volatile int32_t *dest, const int32_t comparand, const int32_t exchange);
/**
  * \brief Compares a 64-bit signed integer with a comparand and exchange it when comparand matches destination.
  * Ensures that memory operations are completed in order.
  * \param dest The target value to write into.
  * \param comparand The value to compare with.
  * \param exchange The value to exchange with.
  * \note Use \ref fplIsAtomicCompareAndExchangeS64() when you want to check if the exchange has happened or not.
  * \return Returns the value of the destination before the exchange, regardless of the result.
  */
fpl_platform_api int64_t fplAtomicCompareAndExchangeS64(volatile int64_t *dest, const int64_t comparand, const int64_t exchange);
/**
  * \brief Compares a pointer with a comparand and exchange it when comparand matches destination.
  * Ensures that memory operations are completed in order.
  * \param dest The target value to write into.
  * \param comparand The value to compare with.
  * \param exchange The value to exchange with.
  * \note Use \ref fplIsAtomicCompareAndExchangePtr() when you want to check if the exchange has happened or not.
  * \return Returns the value of the destination before the exchange, regardless of the result.
  */
fpl_common_api void *fplAtomicCompareAndExchangePtr(volatile void **dest, const void *comparand, const void *exchange);

/**
  * \brief Compares a 32-bit unsigned integer with a comparand and exchange it when comparand matches destination and returns a bool indicating the result.
  * Ensures that memory operations are completed in order.
  * \param dest The target value to write into.
  * \param comparand The value to compare with.
  * \param exchange The value to exchange with.
  * \return Returns true when the exchange happened, otherwise false.
  */
fpl_platform_api bool fplIsAtomicCompareAndExchangeU32(volatile uint32_t *dest, const uint32_t comparand, const uint32_t exchange);
/**
  * \brief Compares a 64-bit unsigned integer with a comparand and exchange it when comparand matches destination and returns a bool indicating the result.
  * Ensures that memory operations are completed in order.
  * \param dest The target value to write into.
  * \param comparand The value to compare with.
  * \param exchange The value to exchange with.
  * \return Returns true when the exchange happened, otherwise false.
  */
fpl_platform_api bool fplIsAtomicCompareAndExchangeU64(volatile uint64_t *dest, const uint64_t comparand, const uint64_t exchange);
/**
  * \brief Compares a 32-bit signed integer with a comparand and exchange it when comparand matches destination and returns a bool indicating the result.
  * Ensures that memory operations are completed in order.
  * \param dest The target value to write into.
  * \param comparand The value to compare with.
  * \param exchange The value to exchange with.
  * \return Returns true when the exchange happened, otherwise false.
  */
fpl_platform_api bool fplIsAtomicCompareAndExchangeS32(volatile int32_t *dest, const int32_t comparand, const int32_t exchange);
/**
  * \brief Compares a 64-bit signed integer with a comparand and exchange it when comparand matches destination and returns a bool indicating the result.
  * Ensures that memory operations are completed in order.
  * \param dest The target value to write into.
  * \param comparand The value to compare with.
  * \param exchange The value to exchange with.
  * \return Returns true when the exchange happened, otherwise false.
  */
fpl_platform_api bool fplIsAtomicCompareAndExchangeS64(volatile int64_t *dest, const int64_t comparand, const int64_t exchange);
/**
  * \brief Compares a pointer with a comparand and exchange it when comparand matches destination and returns a bool indicating the result.
  * Ensures that memory operations are completed in order.
  * \param dest The target value to write into.
  * \param comparand The value to compare with.
  * \param exchange The value to exchange with.
  * \return Returns true when the exchange happened, otherwise false.
  */
fpl_common_api bool fplIsAtomicCompareAndExchangePtr(volatile void **dest, const void *comparand, const void *exchange);

/**
  * \brief Loads the 32-bit unsigned value atomically and returns the value.
  * Ensures that memory operations are completed before the read.
  * \param source The source value to read from.
  * \note This may use a CAS instruction when there is no suitable compiler intrinsics found.
  * \return Returns the source value.
  */
fpl_platform_api uint32_t fplAtomicLoadU32(volatile uint32_t *source);
/**
  * \brief Loads the 64-bit unsigned value atomically and returns the value.
  * Ensures that memory operations are completed before the read.
  * \param source The source value to read from.
  * \note This may use a CAS instruction when there is no suitable compiler intrinsics found.
  * \return Returns the source value.
  */
fpl_platform_api uint64_t fplAtomicLoadU64(volatile uint64_t *source);
/**
  * \brief Loads the 32-bit signed value atomically and returns the value.
  * Ensures that memory operations are completed before the read.
  * \param source The source value to read from.
  * \note This may use a CAS instruction when there is no suitable compiler intrinsics found.
  * \return Returns the source value.
  */
fpl_platform_api int32_t fplAtomicLoadS32(volatile int32_t *source);
/**
  * \brief Loads the 64-bit signed value atomically and returns the value.
  * Ensures that memory operations are completed before the read.
  * \param source The source value to read from.
  * \note This may use a CAS instruction when there is no suitable compiler intrinsics found.
  * \return Returns the source value.
  */
fpl_platform_api int64_t fplAtomicLoadS64(volatile int64_t *source);
/**
  * \brief Loads the pointer value atomically and returns the value.
  * Ensures that memory operations are completed before the read.
  * \param source The source value to read from.
  * \note This may use a CAS instruction when there is no suitable compiler intrinsics found.
  * \return Returns the source value.
  */
fpl_common_api void *fplAtomicLoadPtr(volatile void **source);

/**
  * \brief Overwrites the 32-bit unsigned value atomically.
  * Ensures that memory operations are completed before the write.
  * \param dest The destination to write to.
  * \param value The value to exchange with.
  * \return Returns the source value.
  */
fpl_platform_api void fplAtomicStoreU32(volatile uint32_t *dest, const uint32_t value);
/**
  * \brief Overwrites the 64-bit unsigned value atomically.
  * Ensures that memory operations are completed before the write.
  * \param dest The destination to write to.
  * \param value The value to exchange with.
  * \return Returns the source value.
  */
fpl_platform_api void fplAtomicStoreU64(volatile uint64_t *dest, const uint64_t value);
/**
  * \brief Overwrites the 32-bit signed value atomically.
  * Ensures that memory operations are completed before the write.
  * \param dest The destination to write to.
  * \param value The value to exchange with.
  * \return Returns the source value.
  */
fpl_platform_api void fplAtomicStoreS32(volatile int32_t *dest, const int32_t value);
/**
  * \brief Overwrites the 64-bit signed value atomically.
  * Ensures that memory operations are completed before the write.
  * \param dest The destination to write to.
  * \param value The value to exchange with.
  * \return Returns the source value.
  */
fpl_platform_api void fplAtomicStoreS64(volatile int64_t *dest, const int64_t value);
/**
  * \brief Overwrites the pointer value atomically.
  * Ensures that memory operations are completed before the write.
  * \param dest The destination to write to.
  * \param value The value to exchange with.
  * \return Returns the source value.
  */
fpl_common_api void fplAtomicStorePtr(volatile void **dest, const void *value);

/** \}*/

/**
  * \defgroup Hardware Hardware functions
  * \brief Hardware functions, like GetProcessorCoreCount, GetProcessorName, etc.
  * \{
  */

//! Memory informations
typedef struct fplMemoryInfos {
	//! Total size of physical memory in bytes (Amount of RAM installed)
	uint64_t totalPhysicalSize;
	//! Available size of physical memory in bytes (May be less than the amount of RAM installed)
	uint64_t availablePhysicalSize;
	//! Free size of physical memory in bytes
	uint64_t usedPhysicalSize;
	//! Total size of virtual memory in bytes
	uint64_t totalVirtualSize;
	//! Used size of virtual memory in bytes
	uint64_t usedVirtualSize;
	//! Total page size in bytes
	uint64_t totalPageSize;
	//! Used page size in bytes
	uint64_t usedPageSize;
} fplMemoryInfos;

/**
  * \brief Returns the total number of processor cores.
  * \return Number of processor cores.
  */
fpl_platform_api uint32_t fplGetProcessorCoreCount();
/**
  * \brief Returns the name of the processor.
  * The processor name is written in the destination buffer.
  * \param destBuffer The character buffer to write the processor name into.
  * \param maxDestBufferLen The total number of characters available in the destination character buffer.
  * \return Name of the processor.
  */
fpl_platform_api char *fplGetProcessorName(char *destBuffer, const uint32_t maxDestBufferLen);
/**
  * \brief Returns the current system memory informations.
  * \return Current system memory informations.
  */
fpl_platform_api fplMemoryInfos fplGetSystemMemoryInfos();

/** \}*/

/**
  * \defgroup Settings Settings and configurations
  * \brief Video/audio/window settings
  * \{
  */

//! Initialization flags (Window, Video, etc.)
typedef enum fplInitFlags {
	//! No init flags
	fplInitFlags_None = 0,
	//! Create a single window
	fplInitFlags_Window = 1 << 0,
	//! Use a video backbuffer (This flag ensures that \ref fplInitFlags_Window is included always)
	fplInitFlags_Video = 1 << 1,
	//! Use asyncronous audio playback
	fplInitFlags_Audio = 1 << 2,
	//! Default init flags for initializing everything
	fplInitFlags_All = fplInitFlags_Window | fplInitFlags_Video | fplInitFlags_Audio
} fplInitFlags;

//! Video driver type
typedef enum fplVideoDriverType {
	//! No video driver
	fplVideoDriverType_None = 0,
	//! OpenGL
	fplVideoDriverType_OpenGL,
	//! Software
	fplVideoDriverType_Software
} fplVideoDriverType;

#if defined(FPL_ENABLE_VIDEO_OPENGL)
//! OpenGL compability flags
typedef enum fplOpenGLCompabilityFlags {
	//! Use legacy context
	fplOpenGLCompabilityFlags_Legacy = 0,
	//! Use core profile
	fplOpenGLCompabilityFlags_Core = 1 << 1,
	//! Use compability profile
	fplOpenGLCompabilityFlags_Compability = 1 << 2,
	//! Remove features marked as deprecated
	fplOpenGLCompabilityFlags_Forward = 1 << 3,
} fplOpenGLCompabilityFlags;

//! OpenGL video settings container
typedef struct fplOpenGLVideoSettings {
	//! Compability flags
	fplOpenGLCompabilityFlags compabilityFlags;
	//! Desired major version
	uint32_t majorVersion;
	//! Desired minor version
	uint32_t minorVersion;
} fplOpenGLVideoSettings;
#endif // FPL_ENABLE_VIDEO_OPENGL

	//! Graphics API settings union
typedef union fplGraphicsAPISettings {
#if defined(FPL_ENABLE_VIDEO_OPENGL)
	//! OpenGL settings
	fplOpenGLVideoSettings opengl;
#endif
} fplGraphicsAPISettings;

//! Video settings container (Driver, Flags, Version, VSync, etc.)
typedef struct fplVideoSettings {
	//! Video driver type
	fplVideoDriverType driver;
	//! Vertical syncronisation enabled/disabled
	bool isVSync;
	//! Backbuffer size is automatically resized. Useable only for software rendering!
	bool isAutoSize;
	//! Graphics API settings
	fplGraphicsAPISettings graphics;
} fplVideoSettings;

/**
  * \brief Make default video settings
  * \note This will not change any video settings! To change the actual settings you have to pass the entire \ref fplSettings container to a argument in \ref fplPlatformInit().
  */
fpl_inline fplVideoSettings fplDefaultVideoSettings() {
	fplVideoSettings result = FPL_STRUCT_ZERO;

	result.isVSync = false;
	result.isAutoSize = true;

	// @NOTE(final): Auto detect video driver
#if defined(FPL_ENABLE_VIDEO_OPENGL)
	result.driver = fplVideoDriverType_OpenGL;
	result.graphics.opengl.compabilityFlags = fplOpenGLCompabilityFlags_Legacy;
#elif defined(FPL_ENABLE_VIDEO_SOFTWARE)
	result.driver = VideoDriverType_Software;
#else
	result.driver = VideoDriverType_None;
#endif

	return(result);
}

//! Audio driver type
typedef enum fplAudioDriverType {
	//! No audio driver
	fplAudioDriverType_None = 0,
	//! Auto detection
	fplAudioDriverType_Auto,
	//! DirectSound
	fplAudioDriverType_DirectSound,
} fplAudioDriverType;

//! Audio format type
typedef enum fplAudioFormatType {
	// No audio format
	fplAudioFormatType_None = 0,
	// Unsigned 8-bit integer PCM
	fplAudioFormatType_U8,
	// Signed 16-bit integer PCM
	fplAudioFormatType_S16,
	// Signed 24-bit integer PCM
	fplAudioFormatType_S24,
	// Signed 32-bit integer PCM
	fplAudioFormatType_S32,
	// Signed 64-bit integer PCM
	fplAudioFormatType_S64,
	// 32-bit IEEE_FLOAT
	fplAudioFormatType_F32,
	// 64-bit IEEE_FLOAT
	fplAudioFormatType_F64,
} fplAudioFormatType;

//! Audio device format
typedef struct fplAudioDeviceFormat {
	//! Audio format
	fplAudioFormatType type;
	//! Samples per seconds
	uint32_t sampleRate;
	//! Number of channels
	uint32_t channels;
	//! Number of periods
	uint32_t periods;
	//! Buffer size for the device
	uint32_t bufferSizeInBytes;
	//! Buffer size in frames
	uint32_t bufferSizeInFrames;
} fplAudioDeviceFormat;

//! Audio device id union
typedef union fplAudioDeviceID {
#	if defined(FPL_ENABLE_AUDIO_DIRECTSOUND)
	//! DirectShow Device GUID
	GUID dshow;
#	endif
} fplAudioDeviceID;

//! Audio device info
typedef struct fplAudioDeviceInfo {
	//! Device name
	char name[256];
	//! Device id
	fplAudioDeviceID id;
} fplAudioDeviceInfo;

//! Audio Client Read Callback Function
typedef uint32_t(fpl_audio_client_read_callback)(const fplAudioDeviceFormat deviceFormat, const uint32_t frameCount, void *outputSamples, void *userData);

//! Audio settings
typedef struct fplAudioSettings {
	//! The device format
	fplAudioDeviceFormat deviceFormat;
	//! The device info
	fplAudioDeviceInfo deviceInfo;
	//! The callback for retrieving audio data from the client
	fpl_audio_client_read_callback *clientReadCallback;
	//! The targeted driver
	fplAudioDriverType driver;
	//! Audio buffer in milliseconds
	uint32_t bufferSizeInMilliSeconds;
	//! Is exclude mode prefered
	bool preferExclusiveMode;
	//! User data pointer for client read callback
	void *userData;
} fplAudioSettings;

/**
  * \brief Make default audio settings (S16 PCM, 48 KHz, 2 Channels)
  * \note This will not change any audio settings! To change the actual settings you have to pass the entire \ref fplSettings container to a argument in \ref fplPlatformInit().
  */
fpl_inline fplAudioSettings fplDefaultAudioSettings() {
	fplAudioSettings result = FPL_STRUCT_ZERO;
	result.bufferSizeInMilliSeconds = 25;
	result.preferExclusiveMode = false;
	result.deviceFormat.channels = 2;
	result.deviceFormat.sampleRate = 48000;
	result.deviceFormat.type = fplAudioFormatType_S16;

	result.driver = fplAudioDriverType_None;
#	if defined(FPL_ENABLE_AUDIO_DIRECTSOUND)
	result.driver = fplAudioDriverType_DirectSound;
#	endif
	return(result);
}

//! Window settings (Size, Title etc.)
typedef struct fplWindowSettings {
	//! Window title
	char windowTitle[256];
	//! Window width in screen coordinates
	uint32_t windowWidth;
	//! Window height in screen coordinates
	uint32_t windowHeight;
	//! Fullscreen width in screen coordinates
	uint32_t fullscreenWidth;
	//! Fullscreen height in screen coordinates
	uint32_t fullscreenHeight;
	//! Is window resizable
	bool isResizable;
	//! Is window in fullscreen mode
	bool isFullscreen;
} fplWindowSettings;

/**
  * \brief Make default settings for the window
  * \note This will not change any window settings! To change the actual settings you have to pass the entire \ref fplSettings container to a argument in \ref fplPlatformInit().
  */
fpl_inline fplWindowSettings fplDefaultWindowSettings() {
	fplWindowSettings result = FPL_STRUCT_ZERO;
	result.windowTitle[0] = 0;
	result.windowWidth = 800;
	result.windowHeight = 600;
	result.fullscreenWidth = 0;
	result.fullscreenHeight = 0;
	result.isResizable = true;
	result.isFullscreen = false;
	return(result);
}

//! Input settings
typedef struct fplInputSettings {
	//! Frequency in ms for detecting new or removed controllers (Default: 100 ms)
	uint32_t controllerDetectionFrequency;
} fplInputSettings;

/**
  * \brief Make default settings for input devices.
  * \note This will not change any input settings! To change the actual settings you have to pass the entire \ref fplSettings container to a argument in \ref fplPlatformInit().
  */
fpl_inline fplInputSettings fplDefaultInputSettings() {
	fplInputSettings result = FPL_STRUCT_ZERO;
	result.controllerDetectionFrequency = 100;
	return(result);
}

//! Settings container (Window, Video, etc)
typedef struct fplSettings {
	//! Window settings
	fplWindowSettings window;
	//! Video settings
	fplVideoSettings video;
	//! Audio settings
	fplAudioSettings audio;
	//! Input settings
	fplInputSettings input;
} fplSettings;

/**
  * \brief Make default settings for window, video, audio, etc.
  * \note This will not change any settings! To change the actual settings you have to pass this settings container to a argument in \ref fplPlatformInit().
  */
fpl_inline fplSettings fplDefaultSettings() {
	fplSettings result = FPL_STRUCT_ZERO;
	result.window = fplDefaultWindowSettings();
	result.video = fplDefaultVideoSettings();
	result.audio = fplDefaultAudioSettings();
	result.input = fplDefaultInputSettings();
	return(result);
}

/**
  * \brief Returns the current settings
  */
fpl_common_api const fplSettings *fplGetCurrentSettings();

/** \}*/

/**
  * \defgroup Initialization Initialization functions
  * \brief Initialization and release functions
  * \{
  */

/**
  * \brief Initializes the platform layer.
  * \param initFlags Optional init flags used for enable certain features, like video/audio etc. (Default: \ref fplInitFlags_All)
  * \param initSettings Optional initialization settings which can be passed to control the platform layer behavior or systems. (Default: \ref fplSettings provided by \ref fplDefaultSettings())
  * \note \ref fplPlatformRelease() must be called when you are done! After \ref fplPlatformRelease() has been called you can call this function again if needed.
  * \return Returns true when the initialzation was successful, otherwise false. Will return false when the platform layers is already initialized successfully.
  */
fpl_common_api bool fplPlatformInit(const fplInitFlags initFlags, const fplSettings initSettings);
/**
  * \brief Releases the resources allocated by the platform layer.
  * \note Can only be called when \ref fplPlatformInit() was successful.
  */
fpl_common_api void fplPlatformRelease();

/** \}*/

/**
  * \defgroup ErrorHandling Error Handling
  * \brief Functions for error handling
  * \{
  */

  /**
	* \brief Returns the last internal error string
	* \note This function can be called regardless of the initialization state!
	* \return Last error string or empty string when there was no error.
	*/
fpl_common_api const char *fplGetPlatformError();
/**
  * \brief Returns the last error string from the given index
  * \param index The index
  * \note This function can be called regardless of the initialization state!
  * \return Last error string from the given index or empty when there was no error.
  */
fpl_common_api const char *fplGetPlatformError(const size_t index);
/**
  * \brief Returns the count of total last errors
  * \note This function can be called regardless of the initialization state!
  * \return Number of last errors or zero when there was no error.
  */
fpl_common_api size_t fplGetPlatformErrorCount();
/**
  * \brief Clears all the current errors in the platform
  * \note This function can be called regardless of the initialization state!
  */
fpl_common_api void ClearPlatformErrors();

/** \}*/

/**
  * \defgroup DynamicLibrary Dynamic library loading
  * \brief Loading dynamic libraries and retrieving the procedure addresses.
  * \{
  */

//! Internal library handle union
typedef union fplInternalDynamicLibraryHandle {
#if defined(FPL_PLATFORM_WIN32)
	//! Win32 library handle
	HMODULE win32LibraryHandle;
#elif defined(FPL_SUBPLATFORM_POSIX)
	//! Posix library handle
	void *posixLibraryHandle;
#endif
} fplInternalDynamicLibraryHandle;

  //! Handle to a loaded dynamic library
typedef struct fplDynamicLibraryHandle {
	//! Internal library handle
	fplInternalDynamicLibraryHandle internalHandle;
	//! Library opened successfully
	bool isValid;
} fplDynamicLibraryHandle;

/**
  * \brief Loads a dynamic library and returns the loaded handle for it.
  * \param libraryFilePath The path to the library with included file extension (.dll / .so)
  * \note To check for success, just check the DynamicLibraryHandle.isValid field from the result.
  * \return Handle container of the loaded library.
  */
fpl_platform_api fplDynamicLibraryHandle fplDynamicLibraryLoad(const char *libraryFilePath);
/**
  * \brief Returns the dynamic library procedure address for the given procedure name.
  * \param handle Handle to the loaded library
  * \param name Name of the procedure
  * \return Procedure address for the given procedure name or fpl_null when procedure not found or library is not loaded.
  */
fpl_platform_api void *fplGetDynamicLibraryProc(const fplDynamicLibraryHandle *handle, const char *name);
/**
  * \brief Unloads the loaded library and resets the handle to zero.
  * \param handle Loaded dynamic library handle
  */
fpl_platform_api void fplDynamicLibraryUnload(fplDynamicLibraryHandle *handle);

/** \}*/

/**
  * \defgroup Console Console functions
  * \brief Console out/in functions
  * \{
  */

  /**
	* \brief Writes the given text to the standard output console buffer.
	* \param text The text to write into standard output console.
	* \note This is most likely just a wrapper call to fprintf(stdout)
	*/
fpl_platform_api void fplConsoleOut(const char *text);
/**
  * \brief Writes the given formatted text to the standard output console buffer.
  * \param format The format used for writing into the standard output console.
  * \param ... The dynamic arguments used for formatting the text.
  * \note This is most likely just a wrapper call to vfprintf(stdout)
  */
fpl_platform_api void fplConsoleFormatOut(const char *format, ...);
/**
  * \brief Writes the given text to the standard error console buffer.
  * \param text The text to write into standard error console.
  * \note This is most likely just a wrapper call to fprintf(stderr)
  */
fpl_platform_api void fplConsoleError(const char *text);
/**
  * \brief Writes the given formatted text to the standard error console buffer.
  * \param format The format used for writing into the standard error console.
  * \param ... The dynamic arguments used for formatting the text.
  * \note This is most likely just a wrapper call to vfprintf(stderr)
  */
fpl_platform_api void fplConsoleFormatError(const char *format, ...);
/**
  * \brief Wait for a character to be typed in the console input and return it
  * \note This is most likely just a wrapper call to getchar()
  * \return Character typed in in the console input
  */
fpl_platform_api const char fplConsoleWaitForCharInput();

/** \}*/

/**
  * \defgroup Threading Threading routines
  * \brief Tons of functions for multithreading, mutex and signal creation and handling
  * \{
  */

  //! Thread state
typedef enum fplThreadStates {
	//! Thread is stopped
	fplThreadState_Stopped = 0,
	//! Thread is being started
	fplThreadState_Starting,
	//! Thread is still running
	fplThreadState_Running,
	//! Thread is being stopped
	fplThreadState_Stopping,
} fplThreadStates;
typedef uint32_t fplThreadState;

typedef struct fplThreadHandle fplThreadHandle;
//! Run function type definition for CreateThread
typedef void (fpl_run_thread_function)(const fplThreadHandle *thread, void *data);

#if defined(FPL_SUBPLATFORM_POSIX)
//! Posix internal thread handle
typedef struct fplPosixInternalThreadHandle {
	//! Thread
	pthread_t thread;
	//! Mutex
	pthread_mutex_t mutex;
	//! Stop condition
	pthread_cond_t stopCondition;
} fplPosixInternalThreadHandle;
#endif

//! Internal thread handle union
typedef union fplInternalThreadHandle {
#if defined(FPL_PLATFORM_WIN32)
	//! Win32 thread handle
	HANDLE win32ThreadHandle;
#elif defined(FPL_SUBPLATFORM_POSIX)
	//! Posix thread handle
	fplPosixInternalThreadHandle posix;
#endif
} fplInternalThreadHandle;

//! Thread handle
typedef struct fplThreadHandle {
	//! The internal thread handle
	fplInternalThreadHandle internalHandle;
	//! The identifier of the thread
	uint64_t id;
	//! The stored run function
	fpl_run_thread_function *runFunc;
	//! The user data passed to the run function
	void *data;
	//! Thread state
	volatile fplThreadState currentState;
	//! Is this thread valid
	volatile bool isValid;
	//! Is this thread stopping
	volatile bool isStopping;
} fplThreadHandle;

//! Internal mutex handle union
typedef union fplInternalMutexHandle {
#if defined(FPL_PLATFORM_WIN32)
	//! Win32 mutex handle
	CRITICAL_SECTION win32CriticalSection;
#elif defined(FPL_SUBPLATFORM_POSIX)
	//! Posix mutex handle
	pthread_mutex_t posixMutex;
#endif
} fplInternalMutexHandle;

//! Mutex handle
typedef struct fplMutexHandle {
	//! The internal mutex handle
	fplInternalMutexHandle internalHandle;
	//! Is it valid
	bool isValid;
} fplMutexHandle;

//! Internal signal handle union
typedef union fplInternalSignalHandle {
#if defined(FPL_PLATFORM_WIN32)
	//! Win32 event handle
	HANDLE win32EventHandle;
#elif defined(FPL_SUBPLATFORM_POSIX)
	//! Posix condition
	pthread_cond_t posixCondition;
#endif
} fplInternalSignalHandle;

//! Signal handle
typedef struct fplSignalHandle {
	//! The internal signal handle
	fplInternalSignalHandle internalHandle;
	//! Is it valid
	bool isValid;
} fplSignalHandle;

//! Returns the current thread state from the given thread
fpl_inline fplThreadState GetThreadState(fplThreadHandle *thread) {
	if(thread == fpl_null) {
		return fplThreadState_Stopped;
	}
	fplThreadState result = (fplThreadState)fplAtomicLoadU32((volatile uint32_t *)&thread->currentState);
	return(result);
}

/**
  * \brief Creates a thread and return a handle to it.
  * \param runFunc Function prototype called when this thread starts.
  * \param data User data passed to the run function.
  * \note Use \ref fplThreadDestroy() with this thread context when you dont need this thread anymore. You can only have 64 threads suspended/running at the same time!
  * \warning Do not free this thread context directly! Use \ref fplThreadDestroy() instead.
  * \return Pointer to a internal stored thread-context or return fpl_null when the limit of current threads has been reached.
  */
fpl_platform_api fplThreadHandle *fplThreadCreate(fpl_run_thread_function *runFunc, void *data);
/**
  * \brief Let the current thread sleep for the given amount of milliseconds.
  * \param milliseconds Number of milliseconds to sleep
  * \note There is no guarantee that the OS sleeps for the exact amount of milliseconds! This can vary based on the OS scheduler granularity.
  */
fpl_platform_api void fplThreadSleep(const uint32_t milliseconds);
/**
  * \brief Stop the given thread and release all underlying resources.
  * \param thread Thread
  * \note This thread context may get re-used for another thread in the future!
  * \warning Do not free the given thread context manually!
  */
fpl_platform_api void fplThreadDestroy(fplThreadHandle *thread);
/**
  * \brief Wait until the given thread is done running or the given timeout has been reached.
  * \param thread Thread
  * \param maxMilliseconds Optional number of milliseconds to wait. When this is set to UINT32_MAX it may wait infinitly. (Default: UINT32_MAX)
  * \return Returns true when the thread completes or when the timeout has been reached.
  */
fpl_platform_api bool fplThreadWaitForOne(fplThreadHandle *thread, const uint32_t maxMilliseconds);
/**
  * \brief Wait until all given threads are done running or the given timeout has been reached.
  * \param threads Array of threads
  * \param count Number of threads in the array
  * \param maxMilliseconds Optional number of milliseconds to wait. When this is set to UINT32_MAX it may wait infinitly. (Default: UINT32_MAX)
  * \return Returns true when all threads completes or when the timeout has been reached.
  */
fpl_platform_api bool fplThreadWaitForAll(fplThreadHandle *threads[], const uint32_t count, const uint32_t maxMilliseconds);
/**
  * \brief Wait until one of given threads is done running or the given timeout has been reached.
  * \param threads Array of threads
  * \param count Number of threads in the array
  * \param maxMilliseconds Optional number of milliseconds to wait. When this is set to UINT32_MAX it may wait infinitly. (Default: UINT32_MAX)
  * \return Returns true when one thread completes or when the timeout has been reached.
  */
fpl_platform_api bool fplThreadWaitForAny(fplThreadHandle *threads[], const uint32_t count, const uint32_t maxMilliseconds);

/**
  * \brief Creates a mutex and returns a copy of the handle to it.
  * \note Use \ref fplMutexDestroy() when you are done with this mutex.
  * \return Copy of the handle to the mutex.
  */
fpl_platform_api fplMutexHandle fplMutexCreate();
/**
  * \brief Releases the given mutex and clears the structure to zero.
  * \param mutex The mutex reference to destroy.
  */
fpl_platform_api void fplMutexDestroy(fplMutexHandle *mutex);
/**
  * \brief Locks the given mutex and ensures that other threads will wait until it gets unlocked or the timeout has been reached.
  * \param mutex The mutex reference to lock
  * \param maxMilliseconds Optional number of milliseconds to wait. When this is set to UINT32_MAX it may wait infinitly. (Default: UINT32_MAX)
  * \returns True when mutex was locked or false otherwise.
  */
fpl_platform_api bool fplMutexLock(fplMutexHandle *mutex, const uint32_t maxMilliseconds);
/**
 * \brief Unlocks the given mutex
 * \param mutex The mutex reference to unlock
 * \returns True when mutex was unlocked or false otherwise.
 */
fpl_platform_api bool fplMutexUnlock(fplMutexHandle *mutex);

/**
  * \brief Creates a signal and returns a copy of the handle to it.
  * \note Use \ref fplSignalDestroy() when you are done with this signal.
  * \return Copy of the handle to the signal.
  */
fpl_platform_api fplSignalHandle fplSignalCreate();
/**
  * \brief Releases the given signal and clears the structure to zero.
  * \param signal The signal reference to destroy.
  */
fpl_platform_api void fplSignalDestroy(fplSignalHandle *signal);
/**
  * \brief Waits until the given signal are waked up.
  * \param mutex The mutex reference
  * \param signal The signal reference to signal.
  * \param maxMilliseconds Optional number of milliseconds to wait. When this is set to UINT32_MAX it may wait infinitly. (Default: UINT32_MAX)
  * \return Returns true when the signal woke up or the timeout has been reached, otherwise false.
  */
fpl_platform_api bool fplSignalWaitForOne(fplMutexHandle *mutex, fplSignalHandle *signal, const uint32_t maxMilliseconds);
/**
  * \brief Waits until all the given signal are waked up.
  * \param mutex The mutex reference
  * \param signals Array of signals
  * \param count Number of signals
  * \param maxMilliseconds Optional number of milliseconds to wait. When this is set to UINT32_MAX it may wait infinitly. (Default: UINT32_MAX)
  * \return Returns true when all signals woke up or the timeout has been reached, otherwise false.
  */
fpl_platform_api bool fplSignalWaitForAll(fplMutexHandle *mutex, fplSignalHandle *signals[], const uint32_t count, const uint32_t maxMilliseconds);
/**
  * \brief Waits until any of the given signals wakes up or the timeout has been reached.
  * \param mutex The mutex reference
  * \param signals Array of signals
  * \param count Number of signals
  * \param maxMilliseconds Optional number of milliseconds to wait. When this is set to UINT32_MAX it may wait infinitly. (Default: UINT32_MAX)
  * \return Returns true when any of the signals woke up or the timeout has been reached, otherwise false.
  */
fpl_platform_api bool fplSignalWaitForAny(fplMutexHandle *mutex, fplSignalHandle *signals[], const uint32_t count, const uint32_t maxMilliseconds);
/**
  * \brief Sets the signal and wakes up the given signal.
  * \param signal The reference to the signal
  * \return Returns true when the signal was set and woke up, otherwise false.
  */
fpl_platform_api bool fplSignalSet(fplSignalHandle *signal);

/** \}*/

/**
  * \defgroup Memory Memory functions
  * \brief Memory allocation, clearing and copy functions
  * \{
  */

  /**
	* \brief Clears the given memory by the given size to zero.
	* \param mem Pointer to the memory.
	* \param size Size in bytes to be cleared to zero.
	*/
fpl_common_api void fplMemoryClear(void *mem, const size_t size);
/**
  * \brief Copies the given source memory with its length to the target memory.
  * \param sourceMem Pointer to the source memory to copy from.
  * \param sourceSize Size in bytes to be copied.
  * \param targetMem Pointer to the target memory to copy to.
  */
fpl_common_api void fplMemoryCopy(void *sourceMem, const size_t sourceSize, void *targetMem);
/**
  * \brief Allocates memory from the operating system by the given size.
  * \param size Size to by allocated in bytes.
  * \note The memory is guaranteed to be initialized by zero.
  * \warning Alignment is not ensured here, the OS decides how to handle this. If you want to force a specific alignment use \ref fplMemoryAlignedAllocate() instead.
  * \return Pointer to the new allocated memory.
  */
fpl_platform_api void *fplMemoryAllocate(const size_t size);
/**
  * \brief Releases the memory allocated from the operating system.
  * \param ptr Pointer to the allocated memory.
  * \warning This should never be called with a aligned memory pointer! For freeing aligned memory, use \ref fplMemoryAlignedFree() instead.
  * \return Pointer to the new allocated memory.
  */
fpl_platform_api void fplMemoryFree(void *ptr);
/**
  * \brief Allocates aligned memory from the operating system by the given alignment.
  * \param size Size amount in bytes
  * \param alignment Alignment in bytes (Needs to be a power-of-two!)
  * \note The memory is guaranteed to be initialized by zero.
  * \return Pointer to the new allocated aligned memory.
  */
fpl_common_api void *fplMemoryAlignedAllocate(const size_t size, const size_t alignment);
/**
  * \brief Releases the aligned memory allocated from the operating system.
  * \param ptr Pointer to the aligned allocated memory.
  * \warning This should never be called with a not-aligned memory pointer! For freeing not-aligned memory, use \ref fplMemoryFree() instead.
  * \return Pointer to the new allocated memory.
  */
fpl_common_api void fplMemoryAlignedFree(void *ptr);

/** \}*/

/**
  * \defgroup Timings Timing functions
  * \brief Functions for retrieving timebased informations
  * \{
  */

/**
  * \brief Returns the current system clock in seconds with the highest precision possible.
  * \return Returns number of second since some fixed starting point (OS start, System start, etc).
  * \note Can only be used to calculate a difference in time!
  */
fpl_platform_api double fplGetTimeInSeconds();

/**
  * \brief Returns the current system in milliseconds without deeper precision.
  * \return Returns number of milliseconds since some fixed starting point (OS start, System start, etc).
  * \note Can only be used to calculate a difference in time!
  */
fpl_platform_api uint64_t fplGetTimeInMilliseconds();

/** \}*/

/**
  * \defgroup Strings String manipulation functions
  * \brief Functions for converting/manipulating strings
  * \{
  */

  /**
	* \brief Returns true when both ansi strings are equal with enforcing the given length.
	* \param a First string
	* \param aLen Number of characters for the first string
	* \param b Second string
	* \param bLen Number of characters for the second string
	* \note Len parameters does not include the null-terminator!
	* \return True when strings matches, otherwise false.
	*/
fpl_common_api bool fplIsStringEqualLen(const char *a, const uint32_t aLen, const char *b, const uint32_t bLen);
/**
  * \brief Returns true when both ansi strings are equal.
  * \param a First string
  * \param b Second string
  * \return True when strings matches, otherwise false.
  */
fpl_common_api bool fplIsStringEqual(const char *a, const char *b);
/**
  * \brief Returns the number of characters of the given 8-bit Ansi string.
  * \param str The 8-bit ansi string
  * \note Null terminator is not included!
  * \return Returns the character length or zero when the input string is fpl_null.
  */
fpl_common_api uint32_t fplGetAnsiStringLength(const char *str);
/**
  * \brief Returns the number of characters of the given 16-bit wide string.
  * \param str The 16-bit wide string
  * \note Null terminator is not included!
  * \return Returns the character length or zero when the input string is fpl_null.
  */
fpl_common_api uint32_t fplGetWideStringLength(const wchar_t *str);
/**
  * \brief Copies the given 8-bit source ansi string with a fixed length into a destination ansi string.
  * \param source The 8-bit source ansi string.
  * \param sourceLen The number of characters to copy.
  * \param dest The 8-bit destination ansi string buffer.
  * \param maxDestLen The total number of characters available in the destination buffer.
  * \note Null terminator is included always. Does not allocate any memory.
  * \return Returns the pointer to the first character in the destination buffer or fpl_null when either the dest buffer is too small or the source string is invalid.
  */
fpl_common_api char *fplCopyAnsiStringLen(const char *source, const uint32_t sourceLen, char *dest, const uint32_t maxDestLen);
/**
  * \brief Copies the given 8-bit source ansi string into a destination ansi string.
  * \param source The 8-bit source ansi string.
  * \param dest The 8-bit destination ansi string buffer.
  * \param maxDestLen The total number of characters available in the destination buffer.
  * \note Null terminator is included always. Does not allocate any memory.
  * \return Returns the pointer to the first character in the destination buffer or fpl_null when either the dest buffer is too small or the source string is invalid.
  */
fpl_common_api char *fplCopyAnsiString(const char *source, char *dest, const uint32_t maxDestLen);
/**
  * \brief Copies the given 16-bit source wide string with a fixed length into a destination wide string.
  * \param source The 16-bit source wide string.
  * \param sourceLen The number of characters to copy.
  * \param dest The 16-bit destination wide string buffer.
  * \param maxDestLen The total number of characters available in the destination buffer.
  * \note Null terminator is included always. Does not allocate any memory.
  * \return Returns the pointer to the first character in the destination buffer or fpl_null when either the dest buffer is too small or the source string is invalid.
  */
fpl_common_api wchar_t *fplCopyWideStringLen(const wchar_t *source, const uint32_t sourceLen, wchar_t *dest, const uint32_t maxDestLen);
/**
  * \brief Copies the given 16-bit source wide string into a destination wide string.
  * \param source The 16-bit source wide string.
  * \param dest The 16-bit destination wide string buffer.
  * \param maxDestLen The total number of characters available in the destination buffer.
  * \note Null terminator is included always. Does not allocate any memory.
  * \return Returns the pointer to the first character in the destination buffer or fpl_null when either the dest buffer is too small or the source string is invalid.
  */
fpl_common_api wchar_t *fplCopyWideString(const wchar_t *source, wchar_t *dest, const uint32_t maxDestLen);
/**
  * \brief Converts the given 16-bit source wide string with length in a 8-bit ansi string.
  * \param wideSource The 16-bit source wide string.
  * \param maxWideSourceLen The number of characters of the source wide string.
  * \param ansiDest The 8-bit destination ansi string buffer.
  * \param maxAnsiDestLen The total number of characters available in the destination buffer.
  * \note Null terminator is included always. Does not allocate any memory.
  * \return Returns the pointer to the first character in the destination buffer or fpl_null when either the dest buffer is too small or the source string is invalid.
  */
fpl_platform_api char *fplWideStringToAnsiString(const wchar_t *wideSource, const uint32_t maxWideSourceLen, char *ansiDest, const uint32_t maxAnsiDestLen);
/**
  * \brief Converts the given 16-bit source wide string with length in a 8-bit UTF-8 ansi string.
  * \param wideSource The 16-bit source wide string.
  * \param maxWideSourceLen The number of characters of the source wide string.
  * \param utf8Dest The 8-bit destination ansi string buffer.
  * \param maxUtf8DestLen The total number of characters available in the destination buffer.
  * \note Null terminator is included always. Does not allocate any memory.
  * \return Returns the pointer to the first character in the destination buffer or fpl_null when either the dest buffer is too small or the source string is invalid.
  */
fpl_platform_api char *fplWideStringToUTF8String(const wchar_t *wideSource, const uint32_t maxWideSourceLen, char *utf8Dest, const uint32_t maxUtf8DestLen);
/**
  * \brief Converts the given 8-bit source ansi string with length in a 16-bit wide string.
  * \param ansiSource The 8-bit source ansi string.
  * \param ansiSourceLen The number of characters of the source wide string.
  * \param wideDest The 16-bit destination wide string buffer.
  * \param maxWideDestLen The total number of characters available in the destination buffer.
  * \note Null terminator is included always. Does not allocate any memory.
  * \return Returns the pointer to the first character in the destination buffer or fpl_null when either the dest buffer is too small or the source string is invalid.
  */
fpl_platform_api wchar_t *fplAnsiStringToWideString(const char *ansiSource, const uint32_t ansiSourceLen, wchar_t *wideDest, const uint32_t maxWideDestLen);
/**
  * \brief Converts the given 8-bit UTF-8 source ansi string with length in a 16-bit wide string.
  * \param utf8Source The 8-bit source ansi string.
  * \param utf8SourceLen The number of characters of the source wide string.
  * \param wideDest The 16-bit destination wide string buffer.
  * \param maxWideDestLen The total number of characters available in the destination buffer.
  * \note Null terminator is included always. Does not allocate any memory.
  * \return Returns the pointer to the first character in the destination buffer or fpl_null when either the dest buffer is too small or the source string is invalid.
  */
fpl_platform_api wchar_t *fplUTF8StringToWideString(const char *utf8Source, const uint32_t utf8SourceLen, wchar_t *wideDest, const uint32_t maxWideDestLen);
/**
  * \brief Fills out the given destination ansi string buffer with a formatted string, using the format specifier and variable arguments.
  * \param ansiDestBuffer The 8-bit destination ansi string buffer.
  * \param maxAnsiDestBufferLen The total number of characters available in the destination buffer.
  * \param format The string format.
  * \param ... Variable arguments.
  * \note This is most likely just a wrapper call to vsnprintf()
  * \return Pointer to the first character in the destination buffer or fpl_null.
  */
fpl_platform_api char *fplFormatAnsiString(char *ansiDestBuffer, const uint32_t maxAnsiDestBufferLen, const char *format, ...);

/** \}*/

/**
  * \defgroup Files Files/IO functions
  * \brief Tons of file and directory IO functions
  * \{
  */

//! Internal file handle union
typedef union fplInternalFileHandle {
#if defined(FPL_PLATFORM_WIN32)
	//! Win32 file handle
	HANDLE win32FileHandle;
#elif defined(FPL_SUBPLATFORM_POSIX)
	//! Posix file handle
	int posixFileHandle;
#endif
} fplInternalFileHandle;

//! Handle to a loaded/created file
typedef struct fplFileHandle {
	//! Internal file handle
	fplInternalFileHandle internalHandle;
	//! File opened successfully
	bool isValid;
} fplFileHandle;

//! File position mode (Beginning, Current, End)
typedef enum fplFilePositionMode {
	//! Starts from the beginning
	fplFilePositionMode_Beginning = 0,
	//! Starts from the current position
	fplFilePositionMode_Current,
	//! Starts from the end
	fplFilePositionMode_End
} fplFilePositionMode;

//! File entry type (File, Directory, etc.)
typedef enum fplFileEntryType {
	//! Unknown entry type
	fplFileEntryType_Unknown = 0,
	//! Entry is a file
	fplFileEntryTypeFile,
	//! Entry is a directory
	fplFileEntryTypeDirectory
} fplFileEntryType;

//! File attribute flags (Normal, Readonly, Hidden, etc.)
typedef enum fplFileAttributeFlags {
	//! No attributes
	fplFileAttributeFlags_None = 0,
	//! Normal
	fplFileAttributeFlags_Normal = 1 << 0,
	//! Readonly
	fplFileAttributeFlags_ReadOnly = 1 << 1,
	//! Hidden
	fplFileAttributeFlags_Hidden = 1 << 2,
	//! Archive
	fplFileAttributeFlags_Archive = 1 << 3,
	//! System
	fplFileAttributeFlags_System = 1 << 4
} fplFileAttributeFlags;

//! Maximum length of a file entry path
#define FPL_MAX_FILEENTRY_PATH_LENGTH 1024

//! Internal file entry handle
typedef struct fplInternalFileEntryHandle {
#if defined(FPL_PLATFORM_WIN32)
	//! Win32 file handle
	HANDLE win32FileHandle;
#elif defined(FPL_SUBPLATFORM_POSIX)
	//! Posix file handle
	int posixFileHandle;
#endif
} fplInternalFileEntryHandle;

//! Entry for storing current file informations (path, type, attributes, etc.)
typedef struct fplFileEntry {
	//! File path
	char path[FPL_MAX_FILEENTRY_PATH_LENGTH];
	//! Internal file handle
	fplInternalFileEntryHandle internalHandle;
	//! Entry type
	fplFileEntryType type;
	//! File attributes
	fplFileAttributeFlags attributes;
} fplFileEntry;

/**
  * \brief Opens a binary file for reading from a ansi string path and returns the handle of it.
  * \param filePath Ansi file path.
  * \param handle Pointer to the file handle
  * \return True when binary ansi file was opened, false otherwise
  */
fpl_platform_api bool fplOpenAnsiBinaryFile(const char *filePath, fplFileHandle *handle);
/**
  * \brief Opens a binary file for reading from a wide string path and returns the handle of it.
  * \param filePath Wide file path.
  * \param handle Pointer to the file handle
  * \return True when binary wide file was opened, false otherwise
  */
fpl_platform_api bool fplOpenWideBinaryFile(const wchar_t *filePath, fplFileHandle *handle);
/**
  * \brief Create a binary file for writing to the given ansi string path and returns the handle of it.
  * \param filePath Ansi file path.
  * \param handle Pointer to the file handle
  * \return True when binary ansi file was created, false otherwise
  */
fpl_platform_api bool fplCreateAnsiBinaryFile(const char *filePath, fplFileHandle *handle);
/**
  * \brief Create a binary file for writing to the given wide string path and returns the handle of it.
  * \param filePath Wide file path.
  * \param handle Pointer to the file handle
  * \return True when binary wide file was created, false otherwise
  */
fpl_platform_api bool CreateWideBinaryFile(const wchar_t *filePath, fplFileHandle *handle);
/**
  * \brief Reads a block from the given file handle and returns the number of bytes read.
  * \param fileHandle Reference to the file handle.
  * \param sizeToRead Number of bytes to read.
  * \param targetBuffer Target memory to write into.
  * \param maxTargetBufferSize Total number of bytes available in the target buffer.
  * \note Its limited to files < 2 GB.
  * \return Number of bytes read or zero.
  */
fpl_platform_api uint32_t fplReadFileBlock32(const fplFileHandle *fileHandle, const uint32_t sizeToRead, void *targetBuffer, const uint32_t maxTargetBufferSize);
/**
  * \brief Writes a block to the given file handle and returns the number of bytes written.
  * \param fileHandle Reference to the file handle.
  * \param sourceBuffer Source memory to read from.
  * \param sourceSize Number of bytes to write.
  * \note Its limited to files < 2 GB.
  * \return Number of bytes written or zero.
  */
fpl_platform_api uint32_t fplWriteFileBlock32(const fplFileHandle *fileHandle, void *sourceBuffer, const uint32_t sourceSize);
/**
  * \brief Sets the current file position by the given position, depending on the mode its absolute or relative.
  * \param fileHandle Reference to the file handle.
  * \param position Position in bytes
  * \param mode Position mode
  * \note Its limited to files < 2 GB.
  */
fpl_platform_api void fplSetFilePosition32(const fplFileHandle *fileHandle, const int32_t position, const fplFilePositionMode mode);
/**
  * \brief Returns the current file position in bytes.
  * \param fileHandle Reference to the file handle.
  * \note Its limited to files < 2 GB.
  * \return Current file position in bytes.
  */
fpl_platform_api uint32_t fplGetFilePosition32(const fplFileHandle *fileHandle);
/**
  * \brief Closes the given file and releases the underlying resources and clears the handle to zero.
  * \param fileHandle Reference to the file handle.
  */
fpl_platform_api void CloseFile(fplFileHandle *fileHandle);

// @TODO(final): Add 64-bit file operations
// @TODO(final): Add wide file operations

/**
  * \brief Returns the 32-bit file size in bytes for the given file.
  * \param filePath Ansi path to the file.
  * \note Its limited to files < 2 GB.
  * \return File size in bytes or zero.
  */
fpl_platform_api uint32_t fplGetFileSizeFromPath32(const char *filePath);
/**
  * \brief Returns the 32-bit file size in bytes for a opened file.
  * \param fileHandle Reference to the file handle.
  * \note Its limited to files < 2 GB.
  * \return File size in bytes or zero.
  */
fpl_platform_api uint32_t fplGetFileSizeFromHandle32(const fplFileHandle *fileHandle);
/**
  * \brief Returns true when the given file physically exists.
  * \param filePath Ansi path to the file.
  * \return True when the file exists, otherwise false.
  */
fpl_platform_api bool fplFileExists(const char *filePath);
/**
  * \brief Copies the given source file to the target path and returns true when copy was successful.
  * \param sourceFilePath Ansi source file path.
  * \param targetFilePath Ansi target file path.
  * \param overwrite When true the target file always be overwritten, otherwise it will return false when file already exists.
  * \return True when the file was copied, otherwise false.
  */
fpl_platform_api bool fplFileCopy(const char *sourceFilePath, const char *targetFilePath, const bool overwrite);
/**
  * \brief Movies the given source file to the target file and returns true when the move was successful.
  * \param sourceFilePath Ansi source file path.
  * \param targetFilePath Ansi target file path.
  * \return True when the file was moved, otherwise false.
  */
fpl_platform_api bool fplFileMove(const char *sourceFilePath, const char *targetFilePath);
/**
  * \brief Deletes the given file without confirmation and returns true when the deletion was successful.
  * \param filePath Ansi path to the file.
  * \return True when the file was deleted, otherwise false.
  */
fpl_platform_api bool fplFileDelete(const char *filePath);

/**
  * \brief Creates all the directories in the given path.
  * \param path Ansi path to the directory.
  * \return True when at least one directory was created, otherwise false.
  */
fpl_platform_api bool fplDirectoriesCreate(const char *path);
/**
  * \brief Returns true when the given directory physically exists.
  * \param path Ansi path to the directory.
  * \return True when the directory exists, otherwise false.
  */
fpl_platform_api bool fplDirectoryExists(const char *path);
/**
  * \brief Deletes the given empty directory without confirmation and returns true when the deletion was successful.
  * \param path Ansi path to the directory.
  * \return True when the empty directory was deleted, otherwise false.
  */
fpl_platform_api bool fplDirectoryRemove(const char *path);
/**
  * \brief Iterates through files / directories in the given directory.
  * \param pathAndFilter The path with its included after the path separator.
  * \param firstEntry The reference to a file entry.
  * \note The path must contain the filter as well.
  * \return Returns true when there was a first entry found otherwise false.
  */
fpl_platform_api bool fplListFilesBegin(const char *pathAndFilter, fplFileEntry *firstEntry);
/**
  * \brief Gets the next file entry from iterating through files / directories.
  * \param nextEntry The reference to the current file entry.
  * \return Returns true when there was a next file otherwise false if not.
  */
fpl_platform_api bool fplListFilesNext(fplFileEntry *nextEntry);
/**
  * \brief Releases opened resources from iterating through files / directories.
  * \param lastEntry The reference to the last file entry.
  */
fpl_platform_api void fplListFilesEnd(fplFileEntry *lastEntry);

/** \}*/

/**
  * \defgroup Paths Path functions
  * \brief Functions for retrieving paths like HomePath, ExecutablePath, etc.
  * \{
  */

// @TODO(final): Support wide path for 'paths' as well

/**
  * \brief Returns the full path to this executable, including the executable file name.
  * \param destPath Destination buffer
  * \param maxDestLen Total number of characters available in the destination buffer.
  * \note Result is written in the destination buffer.
  * \return Returns the pointer to the first character in the destination buffer or fpl_null.
  */
fpl_platform_api char *fplGetExecutableFilePath(char *destPath, const uint32_t maxDestLen);
/**
  * \brief Returns the full path to your home directory.
  * \param destPath Destination buffer
  * \param maxDestLen Total number of characters available in the destination buffer.
  * \note Result is written in the destination buffer.
  * \return Returns the pointer to the first character in the destination buffer or fpl_null.
  */
fpl_platform_api char *fplGetHomePath(char *destPath, const uint32_t maxDestLen);
/**
  * \brief Returns the path from the given source path.
  * \param sourcePath Source path to extract from.
  * \param destPath Destination buffer
  * \param maxDestLen Total number of characters available in the destination buffer.
  * \note Result is written in the destination buffer.
  * \return Returns the pointer to the first character in the destination buffer or fpl_null.
  */
fpl_common_api char *fplExtractFilePath(const char *sourcePath, char *destPath, const uint32_t maxDestLen);
/**
  * \brief Returns the file extension from the given source path.
  * \param sourcePath Source path to extract from.
  * \return Returns the pointer to the first character of the extension.
  */
fpl_common_api const char *fplExtractFileExtension(const char *sourcePath);
/**
  * \brief Returns the file name including the file extension from the given source path.
  * \param sourcePath Source path to extract from.
  * \return Returns the pointer to the first character of the filename.
  */
fpl_common_api const char *fplExtractFileName(const char *sourcePath);
/**
  * \brief Changes the file extension on the given source path and writes the result into the destination path.
  * \param filePath File path to search for the extension.
  * \param newFileExtension New file extension.
  * \param destPath Destination buffer
  * \param maxDestLen Total number of characters available in the destination buffer.
  * \note Result is written in the destination buffer.
  * \return Returns the pointer to the first character in the destination buffer or fpl_null.
  */
fpl_common_api char *fplChangeFileExtension(const char *filePath, const char *newFileExtension, char *destPath, const uint32_t maxDestLen);
/**
  * \brief Combines all included path by the systems path separator.
  * \param destPath Destination buffer
  * \param maxDestPathLen Total number of characters available in the destination buffer.
  * \param pathCount Number of dynamic path arguments.
  * \param ... Dynamic path arguments.
  * \note Result is written in the destination buffer.
  * \return Returns the pointer to the first character in the destination buffer or fpl_null.
  */
fpl_common_api char *fplPathCombine(char *destPath, const uint32_t maxDestPathLen, const uint32_t pathCount, ...);

/** \}*/

#if defined(FPL_ENABLE_WINDOW)
/**
* \defgroup WindowEvents Window events
* \brief Window event structures
* \{
*/

//! Mapped keys (Based on MS Virtual-Key-Codes, mostly directly mapped from ASCII)
typedef enum fplKey {
	fplKey_None = 0,

	// 0x07: Undefined

	fplKey_Backspace = 0x08,
	fplKey_Tab = 0x09,

	// 0x0A-0x0B: Reserved

	fplKey_Clear = 0x0C,
	fplKey_Enter = 0x0D,

	// 0x0E-0x0F: Undefined

	fplKey_Shift = 0x10,
	fplKey_Control = 0x11,
	fplKey_Alt = 0x12,
	fplKey_Pause = 0x13,
	fplKey_CapsLock = 0x14,

	// 0x15: IME-fplKeys
	// 0x16: Undefined
	// 0x17-0x19 IME-fplKeys
	// 0x1A: Undefined

	fplKey_Escape = 0x1B,

	// 0x1C - 0x1F: IME-fplKeys

	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_LeftWin = 0x5B,
	fplKey_RightWin = 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-0xFE: Dont care
} fplKey;

//! Window event type (Resized, PositionChanged, etc.)
typedef enum fplWindowEventType {
	//! None window event type
	fplWindowEventType_None = 0,
	//! Window has been resized
	fplWindowEventType_Resized,
	//! Window got focus
	fplWindowEventType_GotFocus,
	//! Window lost focus
	fplWindowEventType_LostFocus,
} fplWindowEventType;

//! Window event data (Size, Position, etc.)
typedef struct fplWindowEvent {
	//! Window event type
	fplWindowEventType type;
	//! Window width in screen coordinates
	uint32_t width;
	//! Window height in screen coordinates
	uint32_t height;
} fplWindowEvent;

//! Keyboard event type (KeyDown, KeyUp, Char, ...)
typedef enum fplKeyboardEventType {
	//! None key event type
	fplKeyboardEventType_None = 0,
	//! Key is down
	fplKeyboardEventType_KeyDown,
	//! Key was released
	fplKeyboardEventType_KeyUp,
	//! Character was entered
	fplKeyboardEventType_CharInput,
} fplKeyboardEventType;

//! Keyboard modifier flags (Alt, Ctrl, ...)
typedef enum fplKeyboardModifierFlags {
	//! No modifiers
	fplKeyboardModifierFlags_None = 0,
	//! Alt key is down
	fplKeyboardModifierFlags_Alt = 1 << 0,
	//! Ctrl key is down
	fplKeyboardModifierFlags_Ctrl = 1 << 1,
	//! Shift key is down
	fplKeyboardModifierFlags_Shift = 1 << 2,
	//! Super key is down
	fplKeyboardModifierFlags_Super = 1 << 3,
} fplKeyboardModifierFlags;

//! Keyboard event data (Type, Keycode, Mapped key, etc.)
typedef struct fplKeyboardEvent {
	//! Keyboard event type
	fplKeyboardEventType type;
	//! Raw key code
	uint64_t keyCode;
	//! Mapped key
	fplKey mappedKey;
	//! Keyboard modifiers
	fplKeyboardModifierFlags modifiers;
} fplKeyboardEvent;

//! Mouse event type (Move, ButtonDown, ...)
typedef enum fplMouseEventType {
	//! No mouse event type
	fplMouseEventType_None,
	//! Mouse position has been changed
	fplMouseEventType_Move,
	//! Mouse button is down
	fplMouseEventType_ButtonDown,
	//! Mouse button was released
	fplMouseEventType_ButtonUp,
	//! Mouse wheel up/down
	fplMouseEventType_Wheel,
} fplMouseEventType;

//! Mouse button type (Left, Right, ...)
typedef enum fplMouseButtonType {
	//! No mouse button
	fplMouseButtonType_None = -1,
	//! Left mouse button
	fplMouseButtonType_Left = 0,
	//! Right mouse button
	fplMouseButtonType_Right = 1,
	//! Middle mouse button
	fplMouseButtonType_Middle = 2,
} fplMouseButtonType;

//! Mouse event data (Type, Button, Position, etc.)
typedef struct fplMouseEvent {
	//! Mouse event type
	fplMouseEventType type;
	//! Mouse button
	fplMouseButtonType mouseButton;
	//! Mouse X-Position
	int32_t mouseX;
	//! Mouse Y-Position
	int32_t mouseY;
	//! Mouse wheel delta
	float wheelDelta;
} fplMouseEvent;

//! Gamepad event type (Connected, Disconnected, StateChanged, etc.)
typedef enum fplGamepadEventType {
	//! No gamepad event
	fplGamepadEventType_None = 0,
	//! Gamepad connected
	fplGamepadEventType_Connected,
	//! Gamepad disconnected
	fplGamepadEventType_Disconnected,
	//! Gamepad state updated
	fplGamepadEventType_StateChanged,
} fplGamepadEventType;

//! Gamepad button (IsDown, etc.)
typedef struct fplGamepadButton {
	//! Is button down
	bool isDown;
} fplGamepadButton;

//! Gamepad state data
typedef struct fplGamepadState {
	union {
		struct {
			//! Digital button up
			fplGamepadButton dpadUp;
			//! Digital button right
			fplGamepadButton dpadRight;
			//! Digital button down
			fplGamepadButton dpadDown;
			//! Digital button left
			fplGamepadButton dpadLeft;

			//! Action button A
			fplGamepadButton actionA;
			//! Action button B
			fplGamepadButton actionB;
			//! Action button X
			fplGamepadButton actionX;
			//! Action button Y
			fplGamepadButton actionY;

			//! Start button
			fplGamepadButton start;
			//! Back button
			fplGamepadButton back;

			//! Analog left thumb button
			fplGamepadButton leftThumb;
			//! Analog right thumb button
			fplGamepadButton rightThumb;

			//! Left shoulder button
			fplGamepadButton leftShoulder;
			//! Right shoulder button
			fplGamepadButton rightShoulder;
		};
		//! All gamepad buttons
		fplGamepadButton buttons[14];
	};

	//! Analog left thumb X in range (-1.0 to 1.0f)
	float leftStickX;
	//! Analog left thumb Y in range (-1.0 to 1.0f)
	float leftStickY;
	//! Analog right thumb X in range (-1.0 to 1.0f)
	float rightStickX;
	//! Analog right thumb Y in range (-1.0 to 1.0f)
	float rightStickY;

	//! Analog left trigger in range (-1.0 to 1.0f)
	float leftTrigger;
	//! Analog right trigger in range (-1.0 to 1.0f)
	float rightTrigger;
} fplGamepadState;

//! Gamepad event data (Type, Device, State, etc.)
typedef struct fplGamepadEvent {
	//! Gamepad event type
	fplGamepadEventType type;
	//! Gamepad device index
	uint32_t deviceIndex;
	//! Full gamepad state
	fplGamepadState state;
} fplGamepadEvent;

//! Event type (Window, Keyboard, Mouse, ...)
typedef enum fplEventType {
	//! None event type
	fplEventType_None = 0,
	//! Window event
	fplEventType_Window,
	//! Keyboard event
	fplEventType_Keyboard,
	//! Mouse event
	fplEventType_Mouse,
	//! Gamepad event
	fplEventType_Gamepad,
} fplEventType;

//! Event data (Type, Window, Keyboard, Mouse, etc.)
typedef struct fplEvent {
	//! Event type
	fplEventType type;
	union {
		//! Window event data
		fplWindowEvent window;
		//! Keyboard event data
		fplKeyboardEvent keyboard;
		//! Mouse event data
		fplMouseEvent mouse;
		//! Gamepad event data
		fplGamepadEvent gamepad;
	};
} fplEvent;

/**
  * \brief Gets the top event from the internal event queue and removes it.
  * \param ev Reference to an event
  * \return Returns false when there are no events left, otherwise true.
  */
fpl_common_api bool fplPollEvent(fplEvent *ev);
/**
  * \brief Removes all the events from the internal event queue.
  * \note Dont call when you care about any event!
  */
fpl_common_api void fplClearEvents();
/**
  * \brief Reads the next window event from the OS and pushes it into the internal queue.
  * \return Returns true when there was a event from the OS, otherwise true.
  * \note Use this only if dont use \ref fplWindowUpdate() and want to handle the events more granular!
  */
fpl_platform_api bool fplPushEvent();
/**
  * \brief Updates the game controller states and detects new and disconnected devices.
  * \note Use this only if dont use \ref fplWindowUpdate() and want to handle the events more granular!
  */
fpl_platform_api void fplUpdateGameControllers();

/*\}*/

/**
  * \defgroup WindowBase Window functions
  * \brief Functions for reading/setting/handling the window
  * \{
  */

  //! Window size in screen coordinates
typedef struct fplWindowSize {
	//! Width in screen coordinates
	uint32_t width;
	//! Height in screen coordinates
	uint32_t height;
} fplWindowSize;

//! Window position in screen coordinates
typedef struct fplWindowPosition {
	//! Left position in screen coordinates
	int32_t left;
	//! Top position in screen coordinates
	int32_t top;
} fplWindowPosition;

/**
  * \brief Returns true when the window is active.
  * \return True when the window is active, otherwise false.
  */
fpl_platform_api bool fplIsWindowRunning();
/**
  * \brief Processes the message queue of the window.
  * \note This will update the game controller states as well.
  * \return True when the window is still active, otherwise false.
  */
fpl_platform_api bool fplWindowUpdate();
/**
  * \brief Enables or disables the window cursor.
  * \param value Set this to true for enabling the cursor or false for disabling the cursor.
  */
fpl_platform_api void fplSetWindowCursorEnabled(const bool value);
/**
  * \brief Returns the inner window area.
  * \return Window area size
  */
fpl_platform_api fplWindowSize GetWindowArea();
/**
  * \brief Resizes the window to fit the inner area to the given size.
  * \param width Width in screen units
  * \param height Height in screen units
  */
fpl_platform_api void fplSetWindowArea(const uint32_t width, const uint32_t height);
/**
  * \brief Returns true when the window is resizable.
  * \return True when the window resizable, otherwise false.
  */
fpl_platform_api bool fplIsWindowResizable();
/**
  * \brief Enables or disables the ability to resize the window.
  * \param value Set this to true for making the window resizable or false for making it static
  */
fpl_platform_api void fplSetWindowResizeable(const bool value);
/**
  * \brief Enables or disables fullscreen mode.
  * \param value Set this to true for changing the window to fullscreen or false for switching it back to window mode.
  * \param fullscreenWidth Optional fullscreen width in screen units. When set to zero the desktop default is being used. (Default: 0)
  * \param fullscreenHeight Optional fullscreen height in screen units. When set to zero the desktop default is being used. (Default: 0)
  * \param refreshRate Optional refresh rate in screen units. When set to zero the desktop default is being used. (Default: 0)
  * \return True when the window was changed to the desire fullscreen mode, false when otherwise.
  */
fpl_platform_api bool fplSetWindowFullscreen(const bool value, const uint32_t fullscreenWidth, const uint32_t fullscreenHeight, const uint32_t refreshRate);
/**
  * \brief Returns true when the window is in fullscreen mode
  * \return True when the window is in fullscreen mode, otherwise false.
  */
fpl_platform_api bool fplIsWindowFullscreen();
/**
  * \brief Returns the absolute window position.
  * \return Window position in screen units
  */
fpl_platform_api fplWindowPosition fplGetWindowPosition();
/**
  * \brief Sets the window absolut position to the given coordinates.
  * \param left Left position in screen units.
  * \param top Top position in screen units.
  */
fpl_platform_api void fplSetWindowPosition(const int32_t left, const int32_t top);
/**
  * \brief Sets the window title.
  * \param title New title ansi string
  */
fpl_platform_api void fplSetWindowTitle(const char *title);

/*\}*/

/**
  * \defgroup WindowClipboard Clipboard functions
  * \brief Functions for reading/writing clipboard data
  * \{
  */

  /**
	* \brief Returns the current clipboard ansi text.
	* \param dest The destination ansi string buffer to write the clipboard text into.
	* \param maxDestLen The total number of characters available in the destination buffer.
	* \return Pointer to the first character in the clipboard text or fpl_null otherwise.
	*/
fpl_platform_api char *fplGetClipboardAnsiText(char *dest, const uint32_t maxDestLen);
/**
  * \brief Returns the current clipboard wide text.
  * \param dest The destination wide string buffer to write the clipboard text into.
  * \param maxDestLen The total number of characters available in the destination buffer.
  * \return Pointer to the first character in the clipboard text or fpl_null otherwise.
  */
fpl_platform_api wchar_t *fplGetClipboardWideText(wchar_t *dest, const uint32_t maxDestLen);
/**
  * \brief Overwrites the current clipboard ansi text with the given one.
  * \param ansiSource The new clipboard ansi string.
  * \return Returns true when the text in the clipboard was changed, otherwise false.
  */
fpl_platform_api bool fplSetClipboardAnsiText(const char *ansiSource);
/**
  * \brief Overwrites the current clipboard wide text with the given one.
  * \param wideSource The new clipboard wide string.
  * \return Returns true when the text in the clipboard was changed, otherwise false.
  */
fpl_platform_api bool fplSetClipboardWideText(const wchar_t *wideSource);

/** \}*/
#endif // FPL_ENABLE_WINDOW

#if defined(FPL_ENABLE_VIDEO)
/**
  * \defgroup Video Video functions
  * \brief Functions for retrieving or resizing the video buffer
  * \{
  */

//! Video rectangle
typedef struct fplVideoRect {
	//! Left position in pixels
	int32_t x;
	//! Top position in pixels
	int32_t y;
	//! Width in pixels
	int32_t width;
	//! Height in pixels
	int32_t height;
} fplVideoRect;

/**
  * \brief Makes a video rectangle from a LT-RB rectangle
  * \param left Left position in screen units.
  * \param top Top position in screen units.
  * \param right Right position in screen units.
  * \param bottom Bottom position in screen units.
  * \return Computed video rectangle
  */
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);
}

/**
  * \brief Returns the string for the given video driver
  * \param driver The audio driver
  * \return String for the given audio driver
  */
fpl_inline const char *fplGetVideoDriverString(fplVideoDriverType driver) {
	const char *VIDEO_DRIVER_TYPE_STRINGS[] = {
		"None",
		"OpenGL",
		"Software",
	};
	uint32_t index = (uint32_t)driver;
	FPL_ASSERT(index < FPL_ARRAYCOUNT(VIDEO_DRIVER_TYPE_STRINGS));
	const char *result = VIDEO_DRIVER_TYPE_STRINGS[index];
	return(result);
}


//! Video backbuffer container. Use this for accessing the pixels directly. Use with care!
typedef struct fplVideoBackBuffer {
	//! The 32-bit pixel top-down array, format: 0xAABBGGRR. Do not modify before WindowUpdate
	uint32_t *pixels;
	//! The width of the backbuffer in pixels. Do not modify, it will be set automatically.
	uint32_t width;
	//! The height of the backbuffer in pixels. Do not modify, it will be set automatically.
	uint32_t height;
	//! The size of one entire pixel with all 4 components in bytes. Do not modify, it will be set automatically.
	size_t pixelStride;
	//! The width of one line in bytes. Do not modify, it will be set automatically.
	size_t lineWidth;
	//! The output rectangle for displaying the backbuffer (Size may not match backbuffer size!)
	fplVideoRect outputRect;
	//! Set this to true to actually use the output rectangle
	bool useOutputRect;
} fplVideoBackBuffer;

/**
  * \brief Returns the pointer to the video software context.
  * \warning Do not release this memory by any means, otherwise you will corrupt heap memory!
  * \return Pointer to the video backbuffer.
  */
fpl_common_api fplVideoBackBuffer *fplGetVideoBackBuffer();
/**
  * \brief Resizes the current video backbuffer.
  * \param width Width in pixels.
  * \param height Height in pixels.
  * \return Returns true when video back buffer could be resized or false otherwise.
  */
fpl_common_api bool fplResizeVideoBackBuffer(const uint32_t width, const uint32_t height);
/**
  * \brief Returns the current video driver type used.
  * \return The current video driver type used.
  */
fpl_common_api fplVideoDriverType fplGetVideoDriver();

/**
  * \brief Forces the window to redraw or to swap the back/front buffer.
  */
fpl_common_api void fplVideoFlip();

/** \}*/
#endif // FPL_ENABLE_VIDEO

#if defined(FPL_ENABLE_AUDIO)
/**
  * \defgroup Audio Audio functions
  * \brief Functions for start/stop playing audio and retrieving/changing some audio related settings.
  * \{
  */

//! Audio result
typedef enum fplAudioResult {
	fplAudioResult_None = 0,
	fplAudioResult_Success,
	fplAudioResult_DeviceNotInitialized,
	fplAudioResult_DeviceAlreadyStopped,
	fplAudioResult_DeviceAlreadyStarted,
	fplAudioResult_DeviceBusy,
	fplAudioResult_Failed,
} fplAudioResult;

/**
  * \brief Start playing asyncronous audio.
  * \return Audio result code.
  */
fpl_common_api fplAudioResult fplPlayAudio();
/**
  * \brief Stop playing asyncronous audio.
  * \return Audio result code.
  */
fpl_common_api fplAudioResult fplStopAudio();
/**
  * \brief Returns the native format for the current audio device.
  * \return Copy fo the audio device format.
  */
fpl_common_api fplAudioDeviceFormat fplGetAudioHardwareFormat();
/**
  * \brief Overwrites the audio client read callback.
  * \param newCallback Pointer to the client read callback.
  * \param userData Pointer to the client/user data.
  * \note This has no effect when audio is already playing, you have to call it when audio is in a stopped state!
  */
fpl_common_api void fplSetAudioClientReadCallback(fpl_audio_client_read_callback *newCallback, void *userData);
/**
  * \brief Gets all playback audio devices.
  * \param devices Target device id array.
  * \param maxDeviceCount Total number of devices available in the devices array.
  * \return Number of devices found.
  */
fpl_common_api uint32_t fplGetAudioDevices(fplAudioDeviceInfo *devices, uint32_t maxDeviceCount);

/**
  * \brief Returns the number of bytes required to write one sample with one channel
  * \param format The audio format
  * \return Number of bytes for one sample with one channel
  */
fpl_inline uint32_t fplGetAudioSampleSizeInBytes(const fplAudioFormatType format) {
	switch(format) {
		case fplAudioFormatType_U8:
			return 1;
		case fplAudioFormatType_S16:
			return 2;
		case fplAudioFormatType_S24:
			return 3;
		case fplAudioFormatType_S32:
		case fplAudioFormatType_F32:
			return 4;
		case fplAudioFormatType_S64:
		case fplAudioFormatType_F64:
			return 8;
		default:
			return 0;
	}
}

/**
  * \brief Returns the string for the given format type
  * \param format The audio format
  * \return String for the given format type
  */
fpl_inline const char *fplGetAudioFormatString(const fplAudioFormatType format) {
	// @NOTE(final): Order must be equal to the AudioFormatType enum!
	const char *AUDIO_FORMAT_TYPE_STRINGS[] = {
		"None",
		"U8",
		"S16",
		"S24",
		"S32",
		"S64",
		"F32",
		"F64",
	};
	uint32_t index = (uint32_t)format;
	FPL_ASSERT(index < FPL_ARRAYCOUNT(AUDIO_FORMAT_TYPE_STRINGS));
	const char *result = AUDIO_FORMAT_TYPE_STRINGS[index];
	return(result);
}

/**
  * \brief Returns the string for the given audio driver
  * \param driver The audio driver
  * \return String for the given audio driver
  */
fpl_inline const char *fplGetAudioDriverString(fplAudioDriverType driver) {
	const char *AUDIO_DRIVER_TYPE_STRINGS[] = {
		"None",
		"Auto",
		"DirectSound",
	};
	uint32_t index = (uint32_t)driver;
	FPL_ASSERT(index < FPL_ARRAYCOUNT(AUDIO_DRIVER_TYPE_STRINGS));
	const char *result = AUDIO_DRIVER_TYPE_STRINGS[index];
	return(result);
}

/**
  * \brief Returns the total frame count for given sample rate and buffer size in milliseconds
  * \param sampleRate The sample rate in Hz
  * \param bufferSizeInMilliSeconds The buffer size in number of milliseconds
  * \return Number of frames
  */
fpl_inline uint32_t fplGetAudioBufferSizeInFrames(uint32_t sampleRate, uint32_t bufferSizeInMilliSeconds) {
	uint32_t result = (sampleRate / 1000) * bufferSizeInMilliSeconds;
	return(result);
}

/**
  * \brief Returns the number of bytes required for one interleaved audio frame - containing all the channels
  * \param format The audio format
  * \param channelCount The number of channels
  * \return Number of bytes for one frame in bytes
  */
fpl_inline uint32_t fplGetAudioFrameSizeInBytes(const fplAudioFormatType format, const uint32_t channelCount) {
	uint32_t result = fplGetAudioSampleSizeInBytes(format) * channelCount;
	return(result);
}

/**
  * \brief Returns the total number of bytes for the buffer and the given parameters
  * \param format The audio format
  * \param channelCount The number of channels
  * \param frameCount The number of frames
  * \return Total number of bytes for the buffer
  */
fpl_inline uint32_t fplGetAudioBufferSizeInBytes(const fplAudioFormatType format, const uint32_t channelCount, const uint32_t frameCount) {
	uint32_t frameSize = fplGetAudioFrameSizeInBytes(format, channelCount);
	uint32_t result = frameSize * frameCount;
	return(result);
}

/** \}*/
#endif // FPL_ENABLE_AUDIO

#endif // FPL_INCLUDE_H