Fixed workflow.

.gitea/workflows/BuildRelease.yaml

@@ -8,6 +8,9 @@ on:
 jobs:
   Windows-AMD64-Build:
     runs-on: windows-x86_64
+    defaults:
+      run:
+        shell: powershell
     steps:
       - name: Check out repository code
         uses: actions/checkout@v3
@@ -19,8 +22,10 @@ jobs:
       - name: Building/Compiling/Installing Project
         run: |
           cd ${{ gitea.workspace }}
-          cmake -A x64 -DCMAKE_BUILD_TYPE=Release --preset=default .
+          vcpkg install
+          mkdir build
           cd build
+          cmake -A x64 -DCMAKE_BUILD_TYPE=Release ..
           cmake --build . --config Release
           cmake --install .
 
@@ -28,10 +33,12 @@ jobs:
         run: |
           cd ${{ gitea.workspace }}
           mkdir bin
+          mv build/Release/EHS_Dyn.dll bin
           mv build/Release/StrToHash.exe bin
           mv build/Release/zlib1.dll bin
           mkdir lib
-          mv build/Release/EHS.lib lib
+          mv build/Release/EHS_Stc.lib lib
+          mv build/Release/EHS_Dyn.lib lib
 
       - name: Zipping Binaries
         run: |
@@ -58,7 +65,7 @@ jobs:
 
       - name: Installing Dependencies
         run: |
-          sudo pacman -S --noconfirm doxygen zip alsa-lib libxcb xcb-util-cursor
+          sudo pacman -S --noconfirm doxygen zip alsa-lib libxcb xcb-util-cursor pipewire
 
       - name: Generating Documentation
         run: |
@@ -73,10 +80,12 @@ jobs:
 
       - name: Creating Appropriate Directories
         run: |
+          cd ${{ gitea.workspace }}
           mkdir bin
+          mv libEHS_Dyn.so bin
           mv StrToHash bin
           mkdir lib
-          mv libEHS.a lib
+          mv libEHS_Stc.a lib
 
       - name: Zipping Binaries
         run: zip -r ehs-linux-amd64.zip include bin lib docs LICENSE RADME.md
@@ -100,7 +109,7 @@ jobs:
         uses: actions/checkout@v3
 
       - name: Installing Dependencies
-        run: sudo apt install -y doxygen zip libasound2-dev libxcb1-dev libxcb-xinput-dev libxcb-cursor-dev
+        run: sudo apt install -y doxygen zip libasound2-dev libxcb1-dev libxcb-xinput-dev libxcb-cursor-dev libpipewire-0.3-dev
 
       - name: Generating Documentation
         run: |
@@ -115,10 +124,12 @@ jobs:
 
       - name: Creating Appropriate Directories
         run: |
+          cd ${{ gitea.workspace }}
           mkdir bin
+          mv libEHS_Dyn.so bin
           mv StrToHash bin
           mkdir lib
-          mv libEHS.a lib
+          mv libEHS_Stc.a lib
 
       - name: Zipping Binaries
         run: zip -r ehs-linux-aarch64.zip include bin lib docs LICENSE README.md

CMakeLists.txt

@@ -13,7 +13,8 @@ project(EHS CXX C)
 
 if (${CMAKE_HOST_SYSTEM_NAME} STREQUAL "Windows")
     set(IS_OS_WINDOWS TRUE)
-    set(USER_HOME_DIRECTORY $ENV{USERPROFILE})
+    set(USER_HOME_DIRECTORY "$ENV{USERPROFILE}")
+    string(REPLACE "\\" "/" USER_HOME_DIRECTORY "${USER_HOME_DIRECTORY}")
     message("Building for the Windows operating system.")
 elseif (${CMAKE_HOST_SYSTEM_NAME} STREQUAL "Linux")
     set(IS_OS_LINUX TRUE)
@@ -207,14 +208,14 @@ elseif (IS_OS_LINUX)
         src/io/File_UNX.cpp include/ehs/io/File_UNX.h
         src/io/FileMonitor_UNX.cpp include/ehs/io/FileMonitor_UNX.h
         src/system/Mutex_PT.cpp include/ehs/system/Mutex_PT.h
-            src/io/audio/AudioDevice_ALSA.cpp include/ehs/io/audio/AudioDevice_ALSA.h
+        src/io/audio/AudioDevice_PW.cpp include/ehs/io/audio/AudioDevice_PW.h
         src/system/FileSystem.cpp include/ehs/system/FileSystem.h
         src/system/User.cpp include/ehs/system/User.h
         src/io/Directory_LNX.cpp include/ehs/io/Directory_LNX.h
         src/io/Usb_LNX.cpp include/ehs/io/Usb_LNX.h
     )
 
-    set(LINUX_WINDOW_SYSTEM "Wayland" CACHE STRING "Linux Window System")
+    #set(LINUX_WINDOW_SYSTEM "Wayland" CACHE STRING "Linux Window System")
 
     if (LINUX_WINDOW_SYSTEM STREQUAL "Wayland")
         add_compile_definitions(EHS_WS_WAYLAND)
@@ -239,27 +240,37 @@ endif()
 #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
 #message("${CMAKE_CXX_FLAGS}")
 
-add_library(EHS_STC STATIC ${EHS_SOURCES})
-add_library(EHS_DYN SHARED ${EHS_SOURCES})
+add_library(EHS_Stc STATIC ${EHS_SOURCES})
+add_library(EHS_Dyn SHARED ${EHS_SOURCES})
 add_executable(StrToHash src/StrToHash.cpp)
 
-target_compile_definitions(EHS_DYN PRIVATE EHS_LIB_EXPORT)
+target_compile_definitions(EHS_Dyn PRIVATE EHS_LIB_EXPORT)
 
-target_include_directories(EHS_STC PUBLIC ${PROJECT_SOURCE_DIR}/include)
-target_include_directories(EHS_DYN PUBLIC ${PROJECT_SOURCE_DIR}/include)
+target_include_directories(EHS_Stc PUBLIC ${PROJECT_SOURCE_DIR}/include)
+target_include_directories(EHS_Dyn PUBLIC ${PROJECT_SOURCE_DIR}/include)
 
 if (IS_OS_LINUX)
     set(CMAKE_INSTALL_PREFIX "${USER_HOME_DIRECTORY}/.local")
+    install(TARGETS EHS_Dyn LIBRARY DESTINATION "bin")
+
+    find_package(PkgConfig REQUIRED)
+    pkg_check_modules(PIPEWIRE REQUIRED libpipewire-0.3)
+
+    target_include_directories(EHS_Stc PRIVATE ${PIPEWIRE_INCLUDE_DIRS})
+    target_include_directories(EHS_Dyn PRIVATE ${PIPEWIRE_INCLUDE_DIRS})
 elseif (IS_OS_WINDOWS)
     set(CMAKE_INSTALL_PREFIX "${USER_HOME_DIRECTORY}/EHS")
+    install(TARGETS EHS_Dyn LIBRARY DESTINATION "lib")
+    install(TARGETS EHS_Dyn RUNTIME DESTINATION "bin")
+
+    file(GLOB DLL_FILES "${CMAKE_CURRENT_BINARY_DIR}/*.dll")
+    install(FILES ${DLL_FILES} DESTINATION "bin")
 endif ()
 
-install(TARGETS EHS_STC DESTINATION lib)
-install(TARGETS EHS_DYN RUNTIME DESTINATION bin)
-install(TARGETS EHS_DYN LIBRARY DESTINATION lib)
-install(TARGETS StrToHash DESTINATION bin)
+install(TARGETS EHS_Stc DESTINATION "lib")
+install(TARGETS StrToHash DESTINATION "bin")
 
-install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/include/ DESTINATION include)
+install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/" DESTINATION "include")
 
 find_package(ZLIB REQUIRED)
 if (ZLIB_FOUND)
@@ -275,17 +286,22 @@ else ()
     message(STATUS "OpenSSL was not found.")
 endif ()
 
-target_link_libraries(EHS_STC OpenSSL::SSL OpenSSL::Crypto ZLIB::ZLIB)
-target_link_libraries(EHS_DYN OpenSSL::SSL OpenSSL::Crypto ZLIB::ZLIB avrt ws2_32)
+target_link_libraries(EHS_Stc OpenSSL::SSL OpenSSL::Crypto ZLIB::ZLIB)
+target_link_libraries(EHS_Dyn OpenSSL::SSL OpenSSL::Crypto ZLIB::ZLIB)
+target_link_libraries(StrToHash OpenSSL::SSL OpenSSL::Crypto ZLIB::ZLIB)
 
 if (IS_OS_WINDOWS)
-    target_link_libraries(StrToHash ws2_32 avrt EHS_STC)
+    target_link_libraries(EHS_Dyn avrt ws2_32)
+    target_link_libraries(StrToHash ws2_32 avrt EHS_Stc)
 elseif (IS_OS_LINUX)
     if (LINUX_WINDOW_SYSTEM STREQUAL "Wayland")
+        target_link_libraries(EHS_Dyn wayland-client)
         target_link_libraries(StrToHash wayland-client)
     elseif (LINUX_WINDOW_SYSTEM STREQUAL "XCB")
+        target_link_libraries(EHS_Dyn xcb xcb-cursor xcb-xfixes xcb-xinput)
         target_link_libraries(StrToHash xcb xcb-cursor xcb-xfixes xcb-xinput)
     endif ()
 
-    target_link_libraries(StrToHash z asound EHS_STC)
+    target_link_libraries(EHS_Dyn z asound pipewire-0.3)
+    target_link_libraries(StrToHash z asound EHS_Stc)
 endif ()

CMakePresets.json

@@ -1,12 +0,0 @@
-{
-  "version": 3,
-  "configurePresets": [
-    {
-      "name": "default",
-      "binaryDir": "${sourceDir}/build",
-      "cacheVariables": {
-        "CMAKE_TOOLCHAIN_FILE": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake"
-      }
-    }
-  ]
-}

README.md

@@ -74,7 +74,7 @@ Wayland Window System. Wayland support is currently not fully supported yet, use
 - [vcpkg](https://learn.microsoft.com/en-us/vcpkg/get_started/get-started?pivots=shell-cmd)
 
 ### Building
-`cmake -A x64 -DCMAKE_BUILD_TYPE=Release --preset=default /path/to/source`
+`cmake -A x64 -DCMAKE_BUILD_TYPE=Release /path/to/source`
 
 ### Compiling
 `cmake --build /path/to/build --config Release`
@@ -89,12 +89,10 @@ This will require the terminal to be running in administrator mode.
 #include <ehs/EHS.h>
 #include <ehs/io/Console.h>
 
-ehs::Int_32 Main(ehs::Str_8* appName, ehs::Str_8* appVerId, ehs::Version* appVer)
+int main()
 {
 	// Simple identifying meta-data for the logger.
-	*appName = "Simple Example App"; // The application's name
-	*appVerId = "Release"; // The app's version prefix; i.e. Alpha, Beta or Release as an example.
-	*appVer = {1, 0, 0}; // The app's version major, minor and patch number.
+	ehs::Initialize("Simple Example App", "Release", {1, 0, 0});
 	
 	ehs::Console::Write_8("How old are you?"); // Write to the console in UTF_8 character encoding.
 	
@@ -110,6 +108,8 @@ ehs::Int_32 Main(ehs::Str_8* appName, ehs::Str_8* appVerId, ehs::Version* appVer
 	
 	ehs::Console::Write("Your age is " + ehs::Str_8::FromNum(age) + "."); // Write the console with the age converted back to string.
 
+    ehs::Uninitialize();
+
     return 0;
 }
 ```

include/ehs/Mat4.h

@@ -332,14 +332,14 @@ namespace ehs
 
 		static Mat4<T> YawRotate(const T angle)
 		{
-			T radians = Math::Rads(angle);
+			T radians = Math::Rads<T>(angle);
 
 			Mat4<T> result;
-			result.data[0] = Math::Cos(radians);
-			result.data[2] = -Math::Sin(radians);
+			result.data[0] = Math::Cos<T>(radians);
+			result.data[2] = -Math::Sin<T>(radians);
 			result.data[5] = 1;
-			result.data[8] = Math::Sin(radians);
-			result.data[10] = Math::Cos(radians);
+			result.data[8] = Math::Sin<T>(radians);
+			result.data[10] = Math::Cos<T>(radians);
 			result.data[15] = 1;
 
 			return result;
@@ -347,7 +347,7 @@ namespace ehs
 
 		static Mat4<T> RollRotate(const T angle)
 		{
-			T radians = Math::Rads(angle);
+			T radians = Math::Rads<T>(angle);
 
 			Mat4<T> result;
 			result.data[0] = Math::Cos(radians);
@@ -367,7 +367,7 @@ namespace ehs
 
 		static Mat4<T> RH_Perspective(const T fov, const T aspect, const T zNear, const T zFar)
 		{
-			const float tanHalfFovy = tan(Math::Rads(fov) / 2.0f);
+			const T tanHalfFovy = Math::Tan<T>(Math::Rads(fov) / 2.0f);
 
 			Mat4<T> result;
 			result[0] = 1.0f / (aspect * tanHalfFovy);
@@ -380,7 +380,7 @@ namespace ehs
 
 		static Mat4<T> LH_Perspective(const T fov, const T aspect, const T zNear, const T zFar)
 		{
-			const float tanHalfFovy = Math::Tan(Math::Rads(fov) / 2.0f);
+			const T tanHalfFovy = Math::Tan<T>(Math::Rads(fov) / 2.0f);
 
 			Mat4<T> result;
 			result[0] = 1.0f / (aspect * tanHalfFovy);

include/ehs/Str.h

@@ -1879,6 +1879,9 @@ namespace ehs
 		/// @returns The character count.
         static N Len(const T* const str)
         {
+			if (!str)
+				return 0;
+
             N count = 0;
             while (str[count])
                 ++count;

include/ehs/io/audio/AudioDevice.h

@@ -5,5 +5,5 @@
 #if defined(EHS_OS_WINDOWS)
 #include "AudioDevice_W32.h"
 #elif defined(EHS_OS_LINUX)
-#include "AudioDevice_ALSA.h"
+#include "AudioDevice_PW.h"
 #endif

include/ehs/io/audio/AudioDevice_ALSA.h

@@ -1,46 +0,0 @@
-#pragma once
-
-#include "ehs/EHS.h"
-#include "BaseAudioDevice.h"
-
-#include <alsa/asoundlib.h>
-
-namespace ehs
-{
-	class EHS_LIB_IO AudioDevice : public BaseAudioDevice
-	{
-	private:
-		snd_pcm_t* hdl;
-
-	public:
-		~AudioDevice() override;
-
-		AudioDevice();
-
-		AudioDevice(AudioDevice&& device) noexcept;
-
-		AudioDevice(const AudioDevice& device);
-
-		AudioDevice& operator=(AudioDevice&& device) noexcept;
-
-		AudioDevice& operator=(const AudioDevice& device);
-
-		void Release() override;
-
-		void OpenStream() override;
-
-		void CloseStream() override;
-
-		UInt_64 GetAvailFrames() const override;
-
-		Byte* Map(UInt_64* offset, UInt_64* frames) override;
-
-		void UnMap(const UInt_64 offset, const UInt_64 frames) override;
-
-		bool IsValid() const override;
-
-		static AudioDevice GetDefault(const AudioDeviceType type);
-
-		static Array<AudioDevice> Get(const AudioDeviceType type, const AudioDeviceState state);
-	};
-}

include/ehs/io/audio/AudioDevice_PW.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#include "ehs/EHS.h"
+#include "BaseAudioDevice.h"
+
+#include <pipewire/pipewire.h>
+#include <pipewire/loop.h>
+#include <pipewire/context.h>
+#include <pipewire/stream.h>
+#include <spa/param/audio/format-utils.h>
+
+namespace ehs
+{
+	class EHS_LIB_IO AudioDevice final : public BaseAudioDevice
+	{
+	private:
+		static Array<AudioDevice> devices;
+		static AudioDevice defOut;
+		static AudioDevice defIn;
+
+		UInt_32 id;
+		Str_8 name;
+		pw_loop *loop;
+		pw_context *context;
+		pw_core *core;
+		pw_stream *input;
+		pw_stream *output;
+
+		static void RegistryEventGlobal(void *data, UInt_32 id, UInt_32 permissions, const char *type, UInt_32 version, const spa_dict *props);
+
+		static void RegistryEventGlobalRemove(void *data, UInt_32 id);
+
+		static void OnParamChanged(void *data, UInt_32 id, const spa_pod *param);
+
+	public:
+		~AudioDevice() override;
+
+		AudioDevice();
+
+		AudioDevice(AudioDevice&& device) noexcept;
+
+		AudioDevice(const AudioDevice& device);
+
+		AudioDevice& operator=(AudioDevice&& device) noexcept;
+
+		AudioDevice& operator=(const AudioDevice& device);
+
+		void OpenStream() override;
+
+		void CloseStream() override;
+
+		UInt_64 SendStream(const void *data, UInt_64 size) override;
+
+		UInt_64 ReceiveStream(void *data, UInt_64 size) override;
+
+		bool IsStreaming() const override;
+
+		bool IsValid() const override;
+
+		static AudioDevice GetDefault(AudioDeviceType type);
+
+		static Array<AudioDevice> Get(AudioDeviceType type, AudioDeviceState state);
+
+	private:
+		Str_8 GetCategory() const;
+	};
+}

include/ehs/io/audio/AudioDevice_W32.h

@@ -12,7 +12,7 @@ struct IMMDevice;
 
 namespace ehs
 {
-	class EHS_LIB_IO AudioDevice : public BaseAudioDevice
+	class EHS_LIB_IO AudioDevice final : public BaseAudioDevice
 	{
 	private:
 		IMMDevice* hdl;
@@ -33,17 +33,13 @@ namespace ehs
 
 		AudioDevice& operator=(const AudioDevice& device);
 
-		void Release() override;
-
 		void OpenStream() override;
 
 		void CloseStream() override;
 
-		UInt_64 GetAvailFrames() const override;
+		UInt_64 SendStream(const void *data, UInt_64 outFrameSize) override;
 
-		Byte* Map(UInt_64* offset, UInt_64* frames) override;
-
-		void UnMap(const UInt_64 offset, const UInt_64 frames) override;
+		UInt_64 ReceiveStream(void *data, UInt_64 inFrameSize) override;
 
 		Str_32 GetInterfaceName_32() const;
 
@@ -57,10 +53,12 @@ namespace ehs
 
 		Str_8 GetName_8() const;
 
+        bool IsStreaming() const override;
+
 		bool IsValid() const override;
 
-		static AudioDevice GetDefault(const AudioDeviceType type);
+		static AudioDevice GetDefault(AudioDeviceType type);
 
-		static Array<AudioDevice> Get(const AudioDeviceType type, const AudioDeviceState state);
+		static Array<AudioDevice> Get(AudioDeviceType type, AudioDeviceState state);
 	};
 }

include/ehs/io/audio/BaseAudioDevice.h

@@ -10,8 +10,8 @@ namespace ehs
 {
 	enum class AudioDeviceType
 	{
-		OUTPUT = 0x0,
 		INPUT = 0x1,
+		OUTPUT = 0x0,
 		ALL = 0x2
 	};
 
@@ -28,13 +28,12 @@ namespace ehs
 	protected:
         AudioDeviceType type;
 		DataType dataType;
-		UInt_16 bitDepth;
+		UInt_16 byteDepth;
 		UInt_32 sampleRate;
 		UInt_32 channels;
 		UInt_32 period;
 		UInt_32 latency;
 		UInt_64 maxFrames;
-		bool streaming;
 
     public:
         virtual ~BaseAudioDevice() = default;
@@ -45,21 +44,19 @@ namespace ehs
 
         BaseAudioDevice& operator=(const BaseAudioDevice& device);
 
-		virtual void Release();
-
 		virtual void OpenStream();
 
 		virtual void CloseStream();
 
-		virtual UInt_64 GetAvailFrames() const;
+    	virtual UInt_64 SendStream(const void *data, UInt_64 size);
 
-		virtual Byte* Map(UInt_64* offset, UInt_64* frames);
+    	virtual UInt_64 ReceiveStream(void *data, UInt_64 size);
 
-		virtual void UnMap(const UInt_64 offset, const UInt_64 frames);
+    	void BridgeStreams(UInt_64 bufferSize);
 
         AudioDeviceType GetType() const;
 
-		void SetDataType(const DataType newDataType);
+		void SetDataType(DataType newDataType);
 
 		DataType GetDataType() const;
 
@@ -67,39 +64,39 @@ namespace ehs
 
 		UInt_16 GetBitDepth() const;
 
-		void SetSampleRate(const UInt_32 newSampleRate);
+		void SetSampleRate(UInt_32 newSampleRate);
 
 		UInt_32 GetSampleRate() const;
 
-		void SetChannels(const UInt_32 newChannels);
+		void SetChannels(UInt_32 newChannels);
 
 		UInt_16 GetChannels() const;
 
 		UInt_32 GetFrameSize() const;
 
-		void SetPeriod(const UInt_32 newPeriod);
+		void SetPeriod(UInt_32 newPeriod);
 
 		UInt_32 GetPeriod() const;
 
-		void SetLatency(const UInt_32 newLatency);
+		void SetLatency(UInt_32 newLatency);
 
 		UInt_32 GetLatency() const;
 
 		UInt_64 GetMaxFrames() const;
 
-		bool IsStreaming() const;
+		virtual bool IsStreaming() const;
 
 		virtual bool IsValid() const;
 
 		/// Retrieves the default audio input/output device.
 		/// @param [in] type The audio device type to retrieve.
 		/// @param [out] device The default audio device.
-		static BaseAudioDevice GetDefault(const AudioDeviceType type);
+		static BaseAudioDevice GetDefault(AudioDeviceType type);
 
 		/// Retrieves a list of audio input/output devices.
 		/// @param [in] type The audio device type to retrieve.
 		/// @param [in] state The audio device state to retrieve.
 		/// @param [out] devices The list of audio devices.
-		static Array<BaseAudioDevice> Get(const AudioDeviceType type, const AudioDeviceState state);
+		static Array<BaseAudioDevice> Get(AudioDeviceType type, AudioDeviceState state);
     };
 }

include/ehs/io/hid/Button.h

@@ -8,24 +8,30 @@ namespace ehs
 	class EHS_LIB_IO Button
 	{
 	private:
-		Str_8 name;
 		UInt_32 hash;
+		Str_8 name;
 
 	public:
 		Button();
 
-		Button(const Str_8& name);
+		Button(Str_8 name);
 
-		Button(const Button& key);
+		Button(Button &&key) noexcept;
 
-		Button& operator=(const Button& key);
+		Button(const Button &key);
 
-		bool operator==(const Button& key) const;
+		Button &operator=(Button &&key) noexcept;
 
-		bool operator!=(const Button& key) const;
+		Button &operator=(const Button &key);
+
+		bool operator==(const Button &key) const;
+
+		bool operator!=(const Button &key) const;
+
+		UInt_32 GetHash() const;
 
 		Str_8 GetName() const;
 
-		UInt_32 GetHash() const;
+		bool IsValid() const;
 	};
 }

include/ehs/io/hid/HID.h

@@ -15,11 +15,15 @@ namespace ehs
 		Str_8 name;
 		UInt_64 id;
 		Array<ButtonState> states;
+		Button lastState;
+		float heldTime;
+		float activateTime;
+		bool active;
 
 	public:
 		HID();
 
-		HID(const UInt_8 type, Str_8 name, const UInt_64 id);
+		HID(UInt_8 type, Str_8 name, UInt_64 id);
 
 		HID(HID&& hid) noexcept;
 
@@ -33,11 +37,11 @@ namespace ehs
 
 		bool operator!=(const HID& other) const;
 
-		bool operator==(const UInt_64 otherId) const;
+		bool operator==(UInt_64 otherId) const;
 
-		bool operator!=(const UInt_64 otherId) const;
+		bool operator!=(UInt_64 otherId) const;
 
-		virtual void Poll();
+		virtual void Poll(float delta);
 
 		UInt_8 GetType() const;
 
@@ -71,6 +75,10 @@ namespace ehs
 
 		const ButtonState* IsUp() const;
 
+		const ButtonState *IsPressed(const Button &button);
+
+		const ButtonState *GetPressed();
+
 		void ButtonDown(const Button& button);
 
 		void ButtonUp(const Button& button);
@@ -87,5 +95,11 @@ namespace ehs
 		bool AddState(const ButtonState& state);
 
 		ButtonState* GetState(const Button& button);
+
+		bool TickHoldTime(float delta);
+
+		void ResetTime();
+
+		void TickActivateTime(float delta);
 	};
 }

include/ehs/io/hid/InputHandler.h

@@ -10,6 +10,8 @@ namespace ehs
 	private:
 		UInt_64 hashId;
 		Str_8 id;
+		UInt_64 start;
+		UInt_64 delta;
 
 	protected:
 		Array<HID*> devices;
@@ -29,9 +31,9 @@ namespace ehs
 
 		InputHandler& operator=(const InputHandler& ih);
 
-		bool operator==(const UInt_64 otherHashId);
+		bool operator==(const UInt_64 otherHashId) const;
 
-		bool operator!=(const UInt_64 otherHashId);
+		bool operator!=(const UInt_64 otherHashId) const;
 
 		virtual bool Initialize();
 

include/ehs/io/hid/Keyboard.h

@@ -23,7 +23,7 @@ namespace ehs
 
 		Keyboard& operator=(const Keyboard& hid);
 
-		void Poll() override;
+		void Poll(float delta) override;
 
 		Keyboard* Clone() const override;
 

include/ehs/io/hid/Mouse.h

@@ -19,7 +19,7 @@ namespace ehs
 	public:
 		Mouse();
 
-		Mouse(Str_8 name, const UInt_64 id);
+		Mouse(Str_8 name, UInt_64 id);
 
 		Mouse(Mouse&& hid) noexcept = default;
 
@@ -29,7 +29,7 @@ namespace ehs
 
 		Mouse& operator=(const Mouse& hid);
 
-		void Poll() override;
+		void Poll(float delta) override;
 
 		void SetDelta(const Vec2_s32& newDelta);
 

include/ehs/json/Json.h

@@ -12,57 +12,57 @@
 
 namespace ehs
 {
-	class EHS_LIB_IO Json
+	class EHS_LIB_IO Json final
 	{
     private:
-        JsonBase* value;
+        JsonBase *value;
 
 	public:
-        virtual ~Json();
+		~Json();
 
         Json();
 
-        Json(const JsonBase& value);
+        Json(const JsonBase &value);
 
-        Json(const JsonObj& value);
+        Json(const JsonObj &value);
 
-        Json(const JsonArray& value);
+        Json(const JsonArray &value);
 
-        Json(const JsonBool& value);
+        Json(const JsonBool &value);
 
-        Json(const JsonNum& value);
+        Json(const JsonNum &value);
 
-        Json(const JsonStr& value);
+        Json(const JsonStr &value);
 
-        Json(const char* data, const UInt_64 size, const UInt_64 extra);
+        Json(const char *data, UInt_64 size, UInt_64 extra);
 
-        Json(const Str_8& data, const UInt_64 extra);
+        Json(const Str_8 &data, UInt_64 extra);
 
-		Json(Json&& json) noexcept;
+		Json(Json &&json) noexcept;
 
         Json(const Json &json);
 
-		Json& operator=(Json&& json) noexcept;
+		Json &operator=(Json &&json) noexcept;
 
-        Json& operator=(const Json& json);
+        Json &operator=(const Json &json);
 
-        JsonBase* GetValue();
+        JsonBase *GetValue();
 
-        JsonBase* RetrieveValue(const Str_8& access);
+        JsonBase *RetrieveValue(const Str_8 &access);
 
-        Str_8 ToStr(const bool compact) const;
+        Str_8 ToStr(bool compact) const;
 
     private:
-        static Vector<Str_8> ParseAccess(const Str_8& access);
+        static Vector<Str_8> ParseAccess(const Str_8 &access);
 
-        void ParseValue(JsonVar* var, const Char_8** begin, const Char_8* end, const UInt_64 extra);
+        void ParseValue(JsonVar *var, const Char_8 **begin, const Char_8 *end, UInt_64 extra);
 
-        JsonVar ParseVar(const Char_8** begin, const Char_8* end, const UInt_64 extra);
+        JsonVar ParseVar(const Char_8 **begin, const Char_8 *end, UInt_64 extra);
 
-        void ParseObject(JsonObj* obj, const Char_8** begin, const Char_8* end, const UInt_64 extra);
+        void ParseObject(JsonObj *obj, const Char_8 **begin, const Char_8 *end, UInt_64 extra);
 
-        void ParseArray(JsonArray* arr, const Char_8** begin, const Char_8* end, const UInt_64 extra);
+        void ParseArray(JsonArray *arr, const Char_8 **begin, const Char_8 *end, UInt_64 extra);
 
-        void Parse(const Str_8& data, const UInt_64 extra);
+        void Parse(const Str_8 &data, UInt_64 extra);
 	};
 }

include/ehs/json/JsonArray.h

@@ -20,13 +20,13 @@ namespace ehs
 		JsonBase** data;
 
 	public:
-		virtual ~JsonArray();
+		~JsonArray() override;
 
 		JsonArray();
 
-		JsonArray(const UInt_64 extra);
+		JsonArray(UInt_64 extra);
 
-		JsonArray(const UInt_64 size, const UInt_64 extra);
+		JsonArray(UInt_64 size, UInt_64 extra);
 
 		JsonArray(JsonArray&& ja) noexcept;
 
@@ -46,9 +46,9 @@ namespace ehs
 
 		UInt_64 Size() const;
 
-		void Insert(const UInt_64 index, const JsonBase* const value);
+		void Insert(UInt_64 index, const JsonBase* value);
 
-		void Push(const JsonBase* const value);
+		void Push(const JsonBase* value);
 
 		void Push(const JsonBase& value);
 
@@ -58,20 +58,20 @@ namespace ehs
 
 		void Push(const JsonBool& value);
 
-		void Push(const bool value);
+		void Push(bool value);
 
 		void Push(const JsonNum& value);
 
-		void Push(const float value);
+		void Push(float value);
 
 		void Push(const JsonStr& value);
 
-		void Push(const Char_8* value, const UInt_64 size = 0);
+		void Push(const Char_8* value, UInt_64 size = 0);
 
 		void Push(const Str_8& value);
 
 		void Pop();
 
-		Str_8 ToStr(const UInt_64 level, const bool compact) const;
+		Str_8 ToStr(UInt_64 level, bool compact) const override;
 	};
 }

include/ehs/json/JsonBase.h

@@ -21,14 +21,16 @@ namespace ehs
 		JsonType type;
 
 	public:
+		virtual ~JsonBase() = default;
+
 		JsonBase();
 
-		JsonBase(const JsonType type);
+		JsonBase(JsonType type);
 
 		JsonBase(const JsonBase& base) = default;
 
 		JsonType GetType() const;
 
-		virtual Str_8 ToStr(const UInt_64 level, const bool compact) const;
+		virtual Str_8 ToStr(UInt_64 level, bool compact) const;
 	};
 }

include/ehs/json/JsonBool.h

@@ -7,14 +7,14 @@
 
 namespace ehs
 {
-	class EHS_LIB_IO JsonBool : public JsonBase
+	class EHS_LIB_IO JsonBool final : public JsonBase
 	{
 	public:
 		bool value;
 
 		JsonBool();
 
-		JsonBool(const bool value);
+		JsonBool(bool value);
 
 		JsonBool(const JsonBool& jb) = default;
 
@@ -22,6 +22,6 @@ namespace ehs
 
 		operator bool&();
 
-		Str_8 ToStr(const UInt_64 level, const bool compact) const;
+		Str_8 ToStr(UInt_64 level, bool compact) const override;
 	};
 }

include/ehs/json/JsonNum.h

@@ -7,39 +7,37 @@
 
 namespace ehs
 {
-	class EHS_LIB_IO JsonNum : public JsonBase
+	class EHS_LIB_IO JsonNum final : public JsonBase
 	{
 	public:
 		float value;
 
 		JsonNum();
 
-		JsonNum(const SInt_64 value);
+		JsonNum(SInt_64 value);
 
-		JsonNum(const UInt_64 value);
+		JsonNum(UInt_64 value);
 
-		JsonNum(const SInt_32 value);
+		JsonNum(SInt_32 value);
 
-		JsonNum(const UInt_32 value);
+		JsonNum(UInt_32 value);
 
-		JsonNum(const SInt_16 value);
+		JsonNum(SInt_16 value);
 
-		JsonNum(const UInt_16 value);
+		JsonNum(UInt_16 value);
 
-		JsonNum(const SInt_8 value);
+		JsonNum(SInt_8 value);
 
-		JsonNum(const UInt_8 value);
+		JsonNum(UInt_8 value);
 
-		JsonNum(const double value);
+		JsonNum(double value);
 
-		JsonNum(const float value);
+		JsonNum(float value);
 
 		JsonNum(const JsonNum& jn) = default;
 
 		operator float() const;
 
-		operator float&();
-
-		Str_8 ToStr(const UInt_64 level, const bool compact) const;
+		Str_8 ToStr(UInt_64 level, bool compact) const override;
 	};
 }

include/ehs/json/JsonObj.h

@@ -9,7 +9,7 @@ namespace ehs
 {
 	class JsonVar;
 
-	class EHS_LIB_IO JsonObj : public JsonBase
+	class EHS_LIB_IO JsonObj final : public JsonBase
 	{
 	protected:
 		UInt_64 size;
@@ -18,25 +18,23 @@ namespace ehs
 		JsonVar* vars;
 
 	public:
-		virtual ~JsonObj();
+		~JsonObj() override;
 
 		JsonObj();
 
-		JsonObj(const UInt_64 size, const UInt_64 extra);
+		JsonObj(UInt_64 size, UInt_64 extra);
 
-		JsonObj(const UInt_64 extra);
+		JsonObj(UInt_64 extra);
 
-		JsonObj(JsonObj&& value) noexcept;
+		JsonObj(JsonObj &&value) noexcept;
 
-		JsonObj(const JsonObj& value);
+		JsonObj(const JsonObj &value);
 
-		JsonObj& operator=(JsonObj&& value) noexcept;
+		JsonObj& operator=(JsonObj &&value) noexcept;
 
-		JsonObj& operator=(const JsonObj& value);
+		JsonObj& operator=(const JsonObj &value);
 
-		operator const JsonVar*() const;
-
-		operator JsonVar*();
+		operator JsonVar *() const;
 
 		UInt_64 Size() const;
 
@@ -44,20 +42,20 @@ namespace ehs
 
 		UInt_64 RawSize() const;
 
-		bool HasVar(const UInt_64 hashId) const;
+		bool HasVar(UInt_64 hashId) const;
 
-		bool HasVar(const Str_8& identifier) const;
+		bool HasVar(const Str_8 &identifier) const;
 
-		bool AddVar(const JsonVar& var);
+		bool AddVar(const JsonVar &var);
 
-		const JsonVar* GetVar(const UInt_64 hashId) const;
+		const JsonVar *GetVar(UInt_64 hashId) const;
 
-		const JsonVar* GetVar(const Str_8& identifier) const;
+		const JsonVar *GetVar(const Str_8& identifier) const;
 
-		JsonVar* GetVar(const UInt_64 hashId);
+		JsonVar *GetVar(UInt_64 hashId);
 
-		JsonVar* GetVar(const Str_8& identifier);
+		JsonVar *GetVar(const Str_8& identifier);
 
-		Str_8 ToStr(const UInt_64 level, const bool compact) const;
+		Str_8 ToStr(UInt_64 level, bool compact) const override;
 	};
 }

include/ehs/json/JsonStr.h

@@ -7,7 +7,7 @@
 
 namespace ehs
 {
-	class EHS_LIB_IO JsonStr : public JsonBase
+	class EHS_LIB_IO JsonStr final : public JsonBase
 	{
 	public:
 		Str_8 value;
@@ -16,18 +16,18 @@ namespace ehs
 
 		JsonStr(Str_8 value);
 
-		JsonStr(const Char_8* value, const UInt_64 size = 0);
+		JsonStr(const Char_8 *value, UInt_64 size = 0);
 
-		JsonStr(JsonStr&& js) noexcept;
+		JsonStr(JsonStr &&js) noexcept;
 
-		JsonStr(const JsonStr& js) = default;
+		JsonStr(const JsonStr &js) = default;
 
-		JsonStr& operator=(JsonStr&& js) noexcept;
+		JsonStr& operator=(JsonStr &&js) noexcept;
 
 		operator Str_8() const;
 
-		operator Str_8&();
+		operator Str_8 &();
 
-		Str_8 ToStr(const UInt_64 level, const bool compact) const;
+		Str_8 ToStr(UInt_64 level, bool compact) const override;
 	};
 }

include/ehs/json/JsonVar.h

@@ -12,7 +12,7 @@ namespace ehs
 	class JsonNum;
 	class JsonStr;
 
-	class EHS_LIB_IO JsonVar
+	class EHS_LIB_IO JsonVar final
 	{
 	private:
 		UInt_64 hashId;
@@ -20,49 +20,49 @@ namespace ehs
 		JsonBase* value;
 
 	public:
-		virtual ~JsonVar();
+		~JsonVar();
 
 		JsonVar();
 
 		JsonVar(Str_8 id);
 
-		JsonVar(Str_8 id, const JsonBase* const value);
+		JsonVar(Str_8 id, const JsonBase *value);
 
-		JsonVar(Str_8 id, const JsonBase& value);
+		JsonVar(Str_8 id, const JsonBase &value);
 
-		JsonVar(Str_8 id, const JsonObj& value);
+		JsonVar(Str_8 id, const JsonObj &value);
 
-		JsonVar(Str_8 id, const JsonArray& value);
+		JsonVar(Str_8 id, const JsonArray &value);
 
-		JsonVar(Str_8 id, const JsonBool& value);
+		JsonVar(Str_8 id, const JsonBool &value);
 
-		JsonVar(Str_8 id, const bool boolean);
+		JsonVar(Str_8 id, bool boolean);
 
-		JsonVar(Str_8 id, const JsonNum& value);
+		JsonVar(Str_8 id, const JsonNum &value);
 
-		JsonVar(Str_8 id, const SInt_64 num);
+		JsonVar(Str_8 id, SInt_64 num);
 
-		JsonVar(Str_8 id, const UInt_64 num);
+		JsonVar(Str_8 id, UInt_64 num);
 
-		JsonVar(Str_8 id, const SInt_32 num);
+		JsonVar(Str_8 id, SInt_32 num);
 
-		JsonVar(Str_8 id, const UInt_32 num);
+		JsonVar(Str_8 id, UInt_32 num);
 
-		JsonVar(Str_8 id, const SInt_16 num);
+		JsonVar(Str_8 id, SInt_16 num);
 
-		JsonVar(Str_8 id, const UInt_16 num);
+		JsonVar(Str_8 id, UInt_16 num);
 
-		JsonVar(Str_8 id, const SInt_8 num);
+		JsonVar(Str_8 id, SInt_8 num);
 
-		JsonVar(Str_8 id, const UInt_8 num);
+		JsonVar(Str_8 id, UInt_8 num);
 
-		JsonVar(Str_8 id, const double num);
+		JsonVar(Str_8 id, double num);
 
-		JsonVar(Str_8 id, const float num);
+		JsonVar(Str_8 id, float num);
 
-		JsonVar(Str_8 id, const JsonStr& value);
+		JsonVar(Str_8 id, const JsonStr &value);
 
-		JsonVar(Str_8 id, const Char_8* str, const UInt_64 size = 0);
+		JsonVar(Str_8 id, const Char_8 *str, UInt_64 size = 0);
 
 		JsonVar(Str_8 id, Str_8 str);
 
@@ -78,25 +78,25 @@ namespace ehs
 
 		Str_8 GetId() const;
 
-		void SetValue(const JsonBase* const newValue);
+		void SetValue(const JsonBase *newValue);
 
-		void SetValue(const JsonBase& newValue);
+		void SetValue(const JsonBase &newValue);
 
-		void SetValue(const JsonObj& newValue);
+		void SetValue(const JsonObj &newValue);
 
-		void SetValue(const JsonArray& newValue);
+		void SetValue(const JsonArray &newValue);
 
-		void SetValue(const JsonBool& newValue);
+		void SetValue(const JsonBool &newValue);
 
-		void SetValue(const bool newValue);
+		void SetValue(bool newValue);
 
 		void SetValue(const JsonNum& newValue);
 
-		void SetValue(const float newValue);
+		void SetValue(float newValue);
 
 		void SetValue(const JsonStr& newValue);
 
-		void SetValue(const Char_8* newValue, const UInt_64 size = 0);
+		void SetValue(const Char_8* newValue, UInt_64 size = 0);
 
 		void SetValue(const Str_8& newValue);
 
@@ -104,6 +104,6 @@ namespace ehs
 
 		JsonBase* GetValue();
 
-		Str_8 ToStr(const UInt_64 level, const bool compact) const;
+		Str_8 ToStr(UInt_64 level, bool compact) const;
 	};
 }

include/ehs/system/BaseSystem.h

@@ -9,5 +9,9 @@ namespace ehs
 	{
 	public:
 		static void OpenURI(const Str_8& uri);
+
+		static Str_8 OpenFileDialog(const Str_8 &dir, const Str_8 &filters);
+
+		static Str_8 GetDirDialog(const Str_8 &dir);
 	};
 }

include/ehs/system/System_LNX.h

@@ -9,5 +9,9 @@ namespace ehs
 	{
 	public:
 		static void OpenURI(const Str_8& uri);
+
+		static Str_8 OpenFileDialog(const Str_8 &dir, const Str_8 &filters);
+
+		static Str_8 GetDirDialog(const Str_8 &dir);
 	};
 }

src/io/Window_W32.cpp

@@ -383,7 +383,7 @@ namespace ehs
 
 		rid[0].usUsagePage = HID_USAGE_PAGE_GENERIC;
 		rid[0].usUsage = HID_USAGE_GENERIC_MOUSE;
-		rid[0].dwFlags = RIDEV_INPUTSINK;
+		rid[0].dwFlags = 0;
 		rid[0].hwndTarget = hdl;
 
 		rid[1].usUsagePage = HID_USAGE_PAGE_GENERIC;
@@ -703,11 +703,118 @@ namespace ehs
 
     Serializer<UInt_64> Window::GetClipboard()
     {
+		if (!OpenClipboard(hdl))
+		{
+			EHS_LOG_INT(LogType::ERR, 0, "Failed to open Clipboard with error #" + Str_8::FromNum(GetLastError()) + ".");
 			return {};
 		}
 
+		HANDLE hData = GetClipboardData(CF_TEXT);
+		if (!hData)
+		{
+			EHS_LOG_INT(LogType::ERR, 1, "Failed to get clipboard handle with error #" + Str_8::FromNum(GetLastError()) + ".");
+
+			if (!CloseClipboard())
+				EHS_LOG_INT(LogType::ERR, 4, "Failed to close clipboard with error #" + Str_8::FromNum(GetLastError()) + ".");
+
+			return {};
+		}
+
+		Char_8* text = (Char_8 *)GlobalLock(hData);
+		if (!text)
+		{
+			EHS_LOG_INT(LogType::ERR, 2, "Failed to get clipboard data with error #" + Str_8::FromNum(GetLastError()) + ".");
+			return {};
+		}
+
+		Serializer<UInt_64> data(Endianness::LE, (Byte *)text, Str_8::Len(text));
+
+		if (!GlobalUnlock(hData))
+		{
+			EHS_LOG_INT(LogType::ERR, 3, "Failed to free clipboard data with error #" + Str_8::FromNum(GetLastError()) + ".");
+
+			return data;
+		}
+
+		if (!CloseClipboard())
+		{
+			EHS_LOG_INT(LogType::ERR, 4, "Failed to close clipboard with error #" + Str_8::FromNum(GetLastError()) + ".");
+
+			return data;
+		}
+
+		EHS_LOG_SUCCESS();
+
+        return data;
+    }
+
     void Window::SetClipboard(Serializer<UInt_64> data)
     {
+		if (!OpenClipboard(hdl))
+		{
+			EHS_LOG_INT(LogType::ERR, 0, "Failed to open Clipboard with error #" + Str_8::FromNum(GetLastError()) + ".");
+			return;
+		}
+
+		if (!EmptyClipboard())
+		{
+			EHS_LOG_INT(LogType::ERR, 1, "Failed to empty clipboard with error #" + Str_8::FromNum(GetLastError()) + ".");
+
+			if (!CloseClipboard())
+				EHS_LOG_INT(LogType::ERR, 6, "Failed to close clipboard with error #" + Str_8::FromNum(GetLastError()) + ".");
+
+			return;
+		}
+
+		HGLOBAL hGlob = GlobalAlloc(GMEM_MOVEABLE, data.Size());
+		if (!hGlob)
+		{
+			EHS_LOG_INT(LogType::ERR, 2, "Failed to allocate clipboard data with error #" + Str_8::FromNum(GetLastError()) + ".");
+
+			if (!CloseClipboard())
+				EHS_LOG_INT(LogType::ERR, 6, "Failed to close clipboard with error #" + Str_8::FromNum(GetLastError()) + ".");
+
+			return;
+		}
+
+		Byte* result = (Byte *)GlobalLock(hGlob);
+		if (!result)
+		{
+			EHS_LOG_INT(LogType::ERR, 3, "Failed to lock data with error #" + Str_8::FromNum(GetLastError()) + ".");
+
+			GlobalFree(hGlob);
+
+			if (!CloseClipboard())
+				EHS_LOG_INT(LogType::ERR, 6, "Failed to close clipboard with error #" + Str_8::FromNum(GetLastError()) + ".");
+
+			return;
+		}
+
+		Util::Copy(result, &data[0], data.Size());
+
+		GlobalUnlock(hGlob);
+
+		HANDLE hData = SetClipboardData(CF_TEXT, hGlob);
+		if (!hData)
+		{
+			EHS_LOG_INT(LogType::ERR, 5, "Failed to get clipboard handle with error #" + Str_8::FromNum(GetLastError()) + ".");
+
+			GlobalFree(hGlob);
+
+			if (!CloseClipboard())
+				EHS_LOG_INT(LogType::ERR, 6, "Failed to close clipboard with error #" + Str_8::FromNum(GetLastError()) + ".");
+
+			return;
+		}
+
+		if (!CloseClipboard())
+		{
+			EHS_LOG_INT(LogType::ERR, 6, "Failed to close clipboard with error #" + Str_8::FromNum(GetLastError()) + ".");
+
+			return;
+		}
+
+		EHS_LOG_SUCCESS();
     }
 
     void Window::SetCursorImg(CursorImg img)

src/io/audio/AudioDevice_ALSA.cpp

@@ -1,392 +0,0 @@
-#include "ehs/io/audio/AudioDevice_ALSA.h"
-#include "ehs/EHS.h"
-#include "ehs/Log.h"
-#include "ehs/io/Console.h"
-
-namespace ehs
-{
-	AudioDevice::~AudioDevice()
-	{
-		if (!hdl)
-			return;
-
-		snd_pcm_drain(hdl);
-		snd_pcm_close(hdl);
-	}
-
-	AudioDevice::AudioDevice()
-		: hdl(nullptr)
-	{
-	}
-
-	AudioDevice::AudioDevice(AudioDevice&& device) noexcept
-		: BaseAudioDevice(device), hdl(device.hdl)
-	{
-		device.hdl = nullptr;
-	}
-
-	AudioDevice::AudioDevice(const AudioDevice& device)
-		: BaseAudioDevice(device), hdl(nullptr)
-	{
-	}
-
-	AudioDevice& AudioDevice::operator=(AudioDevice&& device) noexcept
-	{
-		if (this == &device)
-			return *this;
-
-		BaseAudioDevice::operator=(device);
-
-		hdl = device.hdl;
-
-		device.hdl = nullptr;
-
-		return *this;
-	}
-
-	AudioDevice& AudioDevice::operator=(const AudioDevice& device)
-	{
-		if (this == &device)
-			return *this;
-
-		BaseAudioDevice::operator=(device);
-
-		hdl = nullptr;
-
-		return *this;
-	}
-
-	void AudioDevice::Release()
-	{
-		if (!IsValid())
-			return;
-
-		snd_pcm_drain(hdl);
-		snd_pcm_close(hdl);
-		hdl = nullptr;
-	}
-
-	void AudioDevice::OpenStream()
-	{
-		if (streaming)
-			return;
-
-		snd_pcm_hw_params_t* params;
-		snd_pcm_hw_params_alloca(&params);
-
-		snd_pcm_hw_params_any(hdl, params);
-
-		if (snd_pcm_hw_params_set_access(hdl, params, SND_PCM_ACCESS_MMAP_INTERLEAVED) < 0)
-		{
-			EHS_LOG_INT(LogType::ERR, 0, "Failed to set access.");
-			return;
-		}
-
-		if (bitDepth)
-		{
-			snd_pcm_format_t format;
-			switch (dataType)
-			{
-				case DataType::FLOAT:
-				{
-					format = SND_PCM_FORMAT_FLOAT;
-					break;
-				}
-				case DataType::SINT_32:
-				{
-					format = SND_PCM_FORMAT_S32;
-					break;
-				}
-				case DataType::SINT_24:
-				{
-					format = SND_PCM_FORMAT_S24;
-					break;
-				}
-				case DataType::SINT_16:
-				{
-					format = SND_PCM_FORMAT_S16;
-					break;
-				}
-				case DataType::SINT_8:
-				{
-					format = SND_PCM_FORMAT_S8;
-					break;
-				}
-				default:
-				{
-					EHS_LOG_INT(LogType::ERR, 0, "Invalid data type.");
-					return;
-				}
-			}
-
-			snd_pcm_hw_params_set_format(hdl, params, format);
-		}
-
-		if (channels)
-		{
-			if (snd_pcm_hw_params_set_channels_near(hdl, params, &channels) < 0)
-			{
-				EHS_LOG_INT(LogType::ERR, 1, "Failed to set channels.");
-				return;
-			}
-		}
-
-		if (sampleRate)
-		{
-			if (snd_pcm_hw_params_set_rate_near(hdl, params, &sampleRate, nullptr) < 0)
-			{
-				EHS_LOG_INT(LogType::ERR, 2, "Failed to set sample rate.");
-				return;
-			}
-		}
-
-		if (snd_pcm_hw_params_set_period_time_near(hdl, params, &period, nullptr) < 0)
-		{
-			EHS_LOG_INT(LogType::ERR, 3, "Failed to set period.");
-			return;
-		}
-
-		if (snd_pcm_hw_params_set_buffer_time_near(hdl, params, &latency, nullptr) < 0)
-		{
-			EHS_LOG_INT(LogType::ERR, 4, "Failed to set latency.");
-			return;
-		}
-
-		if (snd_pcm_hw_params(hdl, params) < 0)
-		{
-			EHS_LOG_INT(LogType::ERR, 5, "Failed to apply hardware parameters.");
-			return;
-		}
-
-		if (!bitDepth)
-		{
-			snd_pcm_format_t format;
-			if (snd_pcm_hw_params_get_format(params, &format) < 0)
-			{
-				EHS_LOG_INT(LogType::ERR, 6, "Failed to retrieve audio device properties.");
-				return;
-			}
-
-			switch (format)
-			{
-				case SND_PCM_FORMAT_FLOAT:
-				{
-					dataType = DataType::FLOAT;
-					bitDepth = 32;
-					break;
-				}
-				case SND_PCM_FORMAT_S32:
-				{
-					dataType = DataType::SINT_32;
-					bitDepth = 32;
-					break;
-				}
-				case SND_PCM_FORMAT_S24:
-				{
-					dataType = DataType::SINT_24;
-					bitDepth = 24;
-					break;
-				}
-				case SND_PCM_FORMAT_S16:
-				{
-					dataType = DataType::SINT_16;
-					bitDepth = 16;
-					break;
-				}
-				case SND_PCM_FORMAT_S8:
-				{
-					dataType = DataType::SINT_8;
-					bitDepth = 8;
-					break;
-				}
-				default:
-				{
-					EHS_LOG_INT(LogType::ERR, 7, "Format unsupported.");
-					break;
-				}
-			}
-		}
-
-		if (!channels)
-		{
-			if (snd_pcm_hw_params_get_channels(params, &channels) < 0)
-			{
-				EHS_LOG_INT(LogType::ERR, 8, "Failed to retrieve channel count.");
-				return;
-			}
-		}
-
-		if (!sampleRate)
-		{
-			int dir;
-			if (snd_pcm_hw_params_get_rate(params, &sampleRate, &dir) < 0)
-			{
-				EHS_LOG_INT(LogType::ERR, 9, "Failed to retrieve sample rate.");
-				return;
-			}
-		}
-
-		if (snd_pcm_hw_params_get_buffer_size(params, &maxFrames) < 0)
-		{
-			EHS_LOG_INT(LogType::ERR, 10, "Failed to retrieve buffer size.");
-		}
-
-		snd_pcm_sw_params_t* swParams = nullptr;
-		snd_pcm_sw_params_alloca(&swParams);
-
-		if (snd_pcm_sw_params_current(hdl, swParams) < 0)
-		{
-			EHS_LOG_INT(LogType::ERR, 11, "Failed to retrieve software parameters.");
-			return;
-		}
-
-		if (snd_pcm_sw_params_set_silence_threshold(hdl, swParams, maxFrames) < 0)
-		{
-			EHS_LOG_INT(LogType::ERR, 12, "Failed to set silence threshold.");
-			return;
-		}
-
-		if (snd_pcm_sw_params_set_silence_size(hdl, swParams, maxFrames) < 0)
-		{
-			EHS_LOG_INT(LogType::ERR, 12, "Failed to set silence size.");
-			return;
-		}
-
-		if (snd_pcm_sw_params(hdl, swParams) < 0)
-		{
-			EHS_LOG_INT(LogType::ERR, 13, "Failed to set software parameters.");
-			return;
-		}
-
-		if (snd_pcm_prepare(hdl) < 0)
-		{
-			EHS_LOG_INT(LogType::ERR, 14, "Failed to prepare audio stream.");
-			return;
-		}
-
-		streaming = true;
-	}
-
-	void AudioDevice::CloseStream()
-	{
-		if (!streaming)
-			return;
-
-		snd_pcm_drain(hdl);
-
-		streaming = false;
-	}
-
-	UInt_64 AudioDevice::GetAvailFrames() const
-	{
-		snd_pcm_state_t state = snd_pcm_state(hdl);
-		if (state == SND_PCM_STATE_XRUN)
-		{
-			EHS_LOG_INT(LogType::WARN, 0, "Buffer overrun/underrun occurred.");
-			if (snd_pcm_recover(hdl, -EPIPE, 0) < 0)
-			{
-				EHS_LOG_INT(LogType::ERR, 1, "Failed to recover from buffer overrun/underrun.");
-				return 0;
-			}
-			return GetAvailFrames();
-		}
-		else if (state == SND_PCM_STATE_PREPARED)
-		{
-			if (snd_pcm_start(hdl) < 0)
-			{
-				EHS_LOG_INT(LogType::ERR, 2, "Failed to start audio stream.");
-				return 0;
-			}
-
-			return GetAvailFrames();
-		}
-
-		snd_pcm_sframes_t frames = snd_pcm_avail_update(hdl);
-		if (frames < 0)
-		{
-			if (frames == -EPIPE)
-			{
-				EHS_LOG_INT(LogType::WARN, 3, "Buffer overrun/underrun occurred.");
-				if (snd_pcm_recover(hdl, -EPIPE, 1) < 0)
-				{
-					EHS_LOG_INT(LogType::ERR, 4, "Failed to recover from buffer overrun/underrun.");
-					return 0;
-				}
-
-				return GetAvailFrames();
-			}
-			else
-			{
-				EHS_LOG_INT(LogType::ERR, 5, "Failed to retrieve available frames with error #" + Str_8::FromNum(frames) + ".");
-				return 0;
-			}
-		}
-
-		return frames;
-	}
-
-	Byte* AudioDevice::Map(UInt_64* offset, UInt_64* frames)
-	{
-		const snd_pcm_channel_area_t* areas;
-		if (snd_pcm_mmap_begin(hdl, &areas, offset, frames) < 0)
-		{
-			EHS_LOG_INT(LogType::ERR, 0, "Failed to map audio buffer.");
-			return nullptr;
-		}
-
-		return (Byte*)areas->addr + areas->first / 8;
-	}
-
-	void AudioDevice::UnMap(const UInt_64 offset, const UInt_64 frames)
-	{
-		snd_pcm_sframes_t committed = snd_pcm_mmap_commit(hdl, offset, frames);
-		if (committed < 0)
-		{
-			EHS_LOG_INT(LogType::ERR, 0, "Failed to commit mapped audio buffer.");
-			return;
-		}
-	}
-
-	bool AudioDevice::IsValid() const
-	{
-		return hdl;
-	}
-
-	AudioDevice AudioDevice::GetDefault(const AudioDeviceType type)
-	{
-		AudioDevice result;
-
-		snd_pcm_stream_t rType;
-		if (type == AudioDeviceType::INPUT)
-		{
-			rType = SND_PCM_STREAM_CAPTURE;
-		}
-		else if (type == AudioDeviceType::OUTPUT)
-		{
-			rType = SND_PCM_STREAM_PLAYBACK;
-		}
-		else
-		{
-			EHS_LOG_INT(LogType::ERR, 1, "Wrong value for the audio device type.");
-			return {};
-		}
-
-		int err = snd_pcm_open(&result.hdl, "default", rType, SND_PCM_NONBLOCK);
-		if (err < 0)
-		{
-			EHS_LOG_INT(LogType::ERR, 2, "Failed to retrieve default audio device with error #" + Str_8::FromNum(err) + ".");
-			return {};
-		}
-
-		result.type = AudioDeviceType::OUTPUT;
-
-		EHS_LOG_SUCCESS();
-
-		return result;
-	}
-
-	Array<AudioDevice> AudioDevice::Get(const AudioDeviceType type, const AudioDeviceState state)
-	{
-		return {};
-	}
-}

src/io/audio/AudioDevice_PW.cpp

@@ -0,0 +1,409 @@
+#include "ehs/io/audio/AudioDevice_PW.h"
+#include "ehs/EHS.h"
+#include "ehs/Log.h"
+#include "ehs/system/Semaphore.h"
+
+#include <spa/utils/result.h>
+#include <spa/utils/dict.h>
+#include <spa/buffer/buffer.h>
+#include <spa/param/latency-utils.h>
+
+namespace ehs
+{
+	Array<AudioDevice> AudioDevice::devices;
+
+	void AudioDevice::RegistryEventGlobal(void *data, const UInt_32 id, UInt_32 permissions, const char *type, UInt_32 version, const spa_dict *props)
+	{
+		if (Str_8::Cmp(type, PW_TYPE_INTERFACE_Node))
+		{
+			const Str_8 mediaClass = spa_dict_lookup(props, PW_KEY_MEDIA_CLASS);
+			if (mediaClass.Size() && (mediaClass == "Audio/Sink" || mediaClass == "Audio/Source"))
+			{
+				AudioDevice device;
+
+				if (mediaClass == "Audio/Sink")
+					device.type = AudioDeviceType::OUTPUT;
+				else if (mediaClass == "Audio/Source")
+					device.type = AudioDeviceType::INPUT;
+
+				device.id = id;
+				device.name = spa_dict_lookup(props, PW_KEY_NODE_NAME);
+
+				EHS_LOG_INT(LogType::INFO, 1, "\nDevice Name: " + device.name + "\nId: " + Str_8::FromNum(device.id));
+
+				devices.Push(device);
+			}
+		}
+	}
+
+	void AudioDevice::RegistryEventGlobalRemove(void *data, UInt_32 id)
+	{
+	}
+
+	void AudioDevice::OnParamChanged(void *data, UInt_32 id, const spa_pod *param)
+	{
+		if (!param)
+			return;
+
+		if (id == SPA_PARAM_Buffers)
+		{
+			AudioDevice *device = (AudioDevice *)data;
+
+			spa_pod_object *obj = (spa_pod_object *)param;
+			spa_pod_prop *prop;
+
+			SPA_POD_OBJECT_FOREACH(obj, prop)
+			{
+				if (prop->key == SPA_PARAM_BUFFERS_size)
+				{
+					spa_pod_get_int(&prop->value, (int32_t *)&device->maxFrames);
+					device->maxFrames = device->maxFrames / device->byteDepth / device->channels;
+				}
+			}
+		}
+	}
+
+	AudioDevice::~AudioDevice()
+	{
+		if (!IsStreaming())
+			return;
+
+		if (output)
+		{
+			pw_stream_disconnect(output);
+			pw_stream_destroy(output);
+			output = nullptr;
+		}
+
+		if (input)
+		{
+			pw_stream_disconnect(input);
+			pw_stream_destroy(input);
+			input = nullptr;
+		}
+
+		pw_core_disconnect(core);
+		core = nullptr;
+
+		pw_context_destroy(context);
+		context = nullptr;
+
+		pw_loop_destroy(loop);
+		loop = nullptr;
+	}
+
+	AudioDevice::AudioDevice()
+		: id(0), loop(nullptr), context(nullptr), core(nullptr), input(nullptr), output(nullptr)
+	{
+	}
+
+	AudioDevice::AudioDevice(AudioDevice&& device) noexcept
+		: BaseAudioDevice(device), id(device.id), name((Str_8 &&)device.name), loop(device.loop),
+		context(device.context), core(device.core), input(device.input), output(device.output)
+	{
+		device.id = 0;
+		device.loop = nullptr;
+		device.context = nullptr;
+		device.core = nullptr;
+		device.input = nullptr;
+		device.output = nullptr;
+	}
+
+	AudioDevice::AudioDevice(const AudioDevice& device)
+		: BaseAudioDevice(device), id(device.id), name(device.name), loop(nullptr), context(nullptr), core(nullptr),
+		input(nullptr), output(nullptr)
+	{
+	}
+
+	AudioDevice& AudioDevice::operator=(AudioDevice&& device) noexcept
+	{
+		if (this == &device)
+			return *this;
+
+		BaseAudioDevice::operator=(device);
+
+		id = device.id;
+		name = (Str_8 &&)device.name;
+		loop = device.loop;
+		context = device.context;
+		core = device.core;
+		input = device.input;
+		output = device.output;
+
+		device.id = 0;
+		device.loop = nullptr;
+		device.context = nullptr;
+		device.core = nullptr;
+		device.input = nullptr;
+		device.output = nullptr;
+
+		return *this;
+	}
+
+	AudioDevice& AudioDevice::operator=(const AudioDevice& device)
+	{
+		if (this == &device)
+			return *this;
+
+		BaseAudioDevice::operator=(device);
+
+		id = device.id;
+		name = device.name;
+		loop = nullptr;
+		context = nullptr;
+		core = nullptr;
+		input = nullptr;
+		output = nullptr;
+
+		return *this;
+	}
+
+	void AudioDevice::OpenStream()
+	{
+		if (!IsValid() || IsStreaming())
+			return;
+
+		loop = pw_loop_new(nullptr);
+		context = pw_context_new(loop, nullptr, 0);
+		core = pw_context_connect(context, nullptr, 0);
+
+		spa_audio_info_raw info = {
+			.format = SPA_AUDIO_FORMAT_F32,
+			.rate = GetSampleRate(),
+			.channels = GetChannels(),
+			.position = {
+				SPA_AUDIO_CHANNEL_FL,
+				SPA_AUDIO_CHANNEL_FR,
+				SPA_AUDIO_CHANNEL_FC,
+				SPA_AUDIO_CHANNEL_LFE,
+				SPA_AUDIO_CHANNEL_SL,
+				SPA_AUDIO_CHANNEL_SR,
+				SPA_AUDIO_CHANNEL_RL,
+				SPA_AUDIO_CHANNEL_RR
+			}
+		};
+
+		pw_properties *props = pw_properties_new(
+			PW_KEY_MEDIA_TYPE, "Audio",
+			PW_KEY_MEDIA_CATEGORY, GetCategory(),
+			PW_KEY_MEDIA_ROLE, "Game",
+			nullptr
+		);
+
+		spa_pod_builder b = {};
+		Byte buffer[1024];
+
+		spa_pod_builder_init(&b, buffer, sizeof(buffer));
+
+		const spa_pod *pod[] = {spa_format_audio_raw_build(&b, SPA_PARAM_EnumFormat, &info)};
+
+		if (GetType() == AudioDeviceType::INPUT || GetType() == AudioDeviceType::ALL)
+		{
+			input = pw_stream_new(core, "", props);
+			if (!input)
+			{
+				EHS_LOG_INT(LogType::ERR, 1, "Failed to create input stream for audio device.");
+				return;
+			}
+
+			pw_stream_connect(
+				output,
+				PW_DIRECTION_INPUT,
+				id,
+				(pw_stream_flags)(PW_STREAM_FLAG_AUTOCONNECT | PW_STREAM_FLAG_MAP_BUFFERS),
+				pod,
+				1
+			);
+		}
+
+		if (GetType() == AudioDeviceType::OUTPUT || GetType() == AudioDeviceType::ALL)
+		{
+			output = pw_stream_new(core, "", props);
+			if (!output)
+			{
+				EHS_LOG_INT(LogType::ERR, 1, "Failed to create output stream for audio device.");
+				return;
+			}
+
+			pw_stream_connect(
+				output,
+				PW_DIRECTION_OUTPUT,
+				id,
+				(pw_stream_flags)(PW_STREAM_FLAG_AUTOCONNECT | PW_STREAM_FLAG_MAP_BUFFERS),
+				pod,
+				1
+			);
+		}
+
+		static constexpr pw_stream_events streamEvents = {
+			.version = PW_VERSION_STREAM_EVENTS,
+			.param_changed = OnParamChanged
+		};
+
+		spa_hook streamListener = {};
+		pw_stream_add_listener(output, &streamListener, &streamEvents, this);
+
+		EHS_LOG_SUCCESS();
+	}
+
+	void AudioDevice::CloseStream()
+	{
+		if (!IsStreaming())
+			return;
+
+		if (output)
+		{
+			pw_stream_disconnect(output);
+			pw_stream_destroy(output);
+			output = nullptr;
+		}
+
+		if (input)
+		{
+			pw_stream_disconnect(input);
+			pw_stream_destroy(input);
+			input = nullptr;
+		}
+
+		pw_core_disconnect(core);
+		core = nullptr;
+
+		pw_context_destroy(context);
+		context = nullptr;
+
+		pw_loop_destroy(loop);
+		loop = nullptr;
+	}
+
+	UInt_64 AudioDevice::SendStream(const void *data, const UInt_64 size)
+	{
+		if (GetType() != AudioDeviceType::OUTPUT && GetType() != AudioDeviceType::ALL)
+		{
+			EHS_LOG_INT(LogType::ERR, 0, "You can only send an audio stream on an output audio device.");
+			return 0;
+		}
+
+		pw_loop_iterate(loop, 0);
+
+		if (pw_stream_get_state(output, nullptr) != PW_STREAM_STATE_STREAMING)
+			return 0;
+
+		pw_buffer *buf = pw_stream_dequeue_buffer(output);
+		if (!buf)
+			return 0;
+
+		UInt_64 out = 0;
+
+		spa_data &result = buf->buffer->datas[0];
+
+		if (size > result.maxsize)
+			out = result.maxsize;
+		else
+			out = size;
+
+		Util::Copy(result.data, data, out);
+
+		pw_stream_queue_buffer(output, buf);
+
+		EHS_LOG_SUCCESS();
+
+		return out;
+	}
+
+	UInt_64 AudioDevice::ReceiveStream(void *data, const UInt_64 size)
+	{
+		if (GetType() != AudioDeviceType::INPUT && GetType() != AudioDeviceType::ALL)
+		{
+			EHS_LOG_INT(LogType::ERR, 0, "You can only send an audio stream on an input audio device.");
+			return 0;
+		}
+
+		pw_loop_iterate(loop, 0);
+
+		if (pw_stream_get_state(input, nullptr) != PW_STREAM_STATE_STREAMING)
+			return 0;
+
+		pw_buffer *buf = pw_stream_dequeue_buffer(input);
+		if (!buf)
+			return 0;
+
+		spa_data &result = buf->buffer->datas[0];
+
+		UInt_64 in;
+		if (result.chunk->size <= size)
+			in = result.chunk->size;
+		else
+			in = size;
+
+		Util::Copy(data, result.data, in);
+
+		pw_stream_queue_buffer(input, buf);
+
+		EHS_LOG_SUCCESS();
+
+		return in;
+	}
+
+	bool AudioDevice::IsStreaming() const
+	{
+		return loop && context && core && (input || output);
+	}
+
+	bool AudioDevice::IsValid() const
+	{
+		return id;
+	}
+
+	AudioDevice AudioDevice::GetDefault(const AudioDeviceType type)
+	{
+		pw_init(nullptr, nullptr);
+
+		AudioDevice result;
+		result.type = type;
+		result.id = PW_ID_ANY;
+
+		return result;
+	}
+
+	Array<AudioDevice> AudioDevice::Get(const AudioDeviceType type, const AudioDeviceState state)
+	{
+		pw_init(nullptr, nullptr);
+
+		pw_loop *loop = pw_loop_new(nullptr);
+		pw_context *context = pw_context_new(loop, nullptr, 0);
+		pw_core *core = pw_context_connect(context, nullptr, 0);
+		pw_registry *registry = pw_core_get_registry(core, PW_VERSION_REGISTRY, 0);
+		spa_hook listener = {};
+
+		static constexpr pw_registry_events events = {
+			.version = PW_VERSION_REGISTRY_EVENTS,
+			.global = RegistryEventGlobal,
+			.global_remove = RegistryEventGlobalRemove
+		};
+
+		pw_registry_add_listener(registry, &listener, &events, registry);
+
+		while (pw_loop_iterate(loop, 10));
+
+		pw_core_disconnect(core);
+		pw_context_destroy(context);
+		pw_loop_destroy(loop);
+
+		return devices;
+	}
+
+	Str_8 AudioDevice::GetCategory() const
+	{
+		switch (GetType())
+		{
+			case AudioDeviceType::INPUT:
+				return "Capture";
+			case AudioDeviceType::OUTPUT:
+				return "Playback";
+			case AudioDeviceType::ALL:
+				return "Duplex";
+			default:
+				return "";
+		}
+	}
+}

src/io/audio/AudioDevice_W32.cpp

@@ -68,37 +68,9 @@ namespace ehs
 		return *this;
 	}
 
-	void AudioDevice::Release()
-	{
-		if (captureClient)
-		{
-			captureClient->Release();
-			captureClient = nullptr;
-		}
-
-		if (playbackClient)
-		{
-			playbackClient->Release();
-			playbackClient = nullptr;
-		}
-
-		if (hdl)
-		{
-			HRESULT r = client->Stop();
-			if (FAILED(r))
-			{
-				EHS_LOG_INT(LogType::ERR, 0, "Failed to stop audio with error #" + Str_8::FromNum(r) + ".");
-				return;
-			}
-
-			hdl->Release();
-			hdl = nullptr;
-		}
-	}
-
 	void AudioDevice::OpenStream()
 	{
-		if (streaming)
+		if (IsStreaming())
 			return;
 
 		HRESULT r = hdl->Activate(__uuidof(IAudioClient), CLSCTX_ALL, nullptr, (void**)&client);
@@ -108,14 +80,14 @@ namespace ehs
 		WAVEFORMATEXTENSIBLE* format;
 		client->GetMixFormat((WAVEFORMATEX**)&format);
 
-		if (bitDepth)
+		if (byteDepth)
 		{
 			if (dataType == DataType::FLOAT)
 				format->SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
 			else
 				format->SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
 
-			format->Format.wBitsPerSample = bitDepth;
+			format->Format.wBitsPerSample = byteDepth * 8;
 		}
 		else
 		{
@@ -124,7 +96,7 @@ namespace ehs
 			else
 				dataType = FromAudioBitDepth(format->Format.wBitsPerSample);
 
-			bitDepth = format->Format.wBitsPerSample;
+			byteDepth = format->Format.wBitsPerSample / 8;
 		}
 
 		if (sampleRate)
@@ -137,7 +109,7 @@ namespace ehs
 		else
 			channels = format->Format.nChannels;
 
-		format->Format.nBlockAlign = bitDepth / 8 * channels;
+		format->Format.nBlockAlign = byteDepth * channels;
 		format->Format.nAvgBytesPerSec = format->Format.nBlockAlign * sampleRate;
 
 		WAVEFORMATEX* match = {};
@@ -293,12 +265,12 @@ namespace ehs
 			return;
 		}
 
-		streaming = true;
+		EHS_LOG_SUCCESS();
 	}
 
 	void AudioDevice::CloseStream()
 	{
-		if (!streaming)
+		if (!IsStreaming())
 			return;
 
 		if (playbackClient)
@@ -324,98 +296,132 @@ namespace ehs
 
 			client->Release();
 			client = nullptr;
+
+            hdl->Release();
+            hdl = nullptr;
 		}
 
-		streaming = false;
+		EHS_LOG_SUCCESS();
 	}
 
-	UInt_64 AudioDevice::GetAvailFrames() const
+	UInt_64 AudioDevice::SendStream(const void *data, UInt_64 outFrameSize)
 	{
-		if (!IsValid() || !streaming)
+		if (!IsValid() || !IsStreaming() || !playbackClient || !data || !outFrameSize)
 			return 0;
 
-		UInt_32 sampleSize = 0;
+		UInt_32 frameOffset = 0;
 
-		if (playbackClient)
-		{
-			HRESULT r = client->GetCurrentPadding(&sampleSize);
+		HRESULT r = client->GetCurrentPadding(&frameOffset);
 		if (r == AUDCLNT_E_DEVICE_INVALIDATED)
-				EHS_LOG_INT(LogType::ERR, 0, "The audio device has been invalidated.");
+		{
+			EHS_LOG_INT(LogType::WARN, 0, "The audio device has been invalidated.");
+			return 0;
+		}
 		else if (FAILED(r))
+		{
 			EHS_LOG_INT(LogType::ERR, 1, "Failed to retrieve samples padding with error #" + Str_8::FromNum(r) + ".");
-
-			sampleSize = maxFrames - sampleSize;
+			return 0;
 		}
-		else if (captureClient)
-		{
-			HRESULT r = captureClient->GetNextPacketSize(&sampleSize);
+
+		UInt_32 frameSize = maxFrames - frameOffset;
+		if (frameSize > outFrameSize)
+			frameSize = outFrameSize;
+
+		Byte *buffer = nullptr;
+
+		r = playbackClient->GetBuffer(frameSize, &buffer);
 		if (r == AUDCLNT_E_DEVICE_INVALIDATED)
-				EHS_LOG_INT(LogType::ERR, 0, "The audio device has been invalidated.");
-			else if (FAILED(r))
-				EHS_LOG_INT(LogType::ERR, 1, "Failed to retrieve samples size with error #" + Str_8::FromNum(r) + ".");
-		}
-
-		return sampleSize;
-	}
-
-	Byte* AudioDevice::Map(UInt_64* offset, UInt_64* frames)
 		{
+			EHS_LOG_INT(LogType::WARN, 2, "The audio device has been invalidated.");
+			return 0;
+		}
+		else if (FAILED(r))
+		{
+			EHS_LOG_INT(LogType::ERR, 3, "Failed to retrieve buffer with error #" + Str_8::FromNum(r) + ".");
+			return 0;
+		}
+
+		r = playbackClient->ReleaseBuffer(frameSize, 0);
+		if (r == AUDCLNT_E_DEVICE_INVALIDATED)
+		{
+			EHS_LOG_INT(LogType::WARN, 4, "The audio device has been invalidated.");
+			return 0;
+		}
+		else if (FAILED(r))
+		{
+			EHS_LOG_INT(LogType::ERR, 5, "Failed to release buffer with error #" + Str_8::FromNum(r) + ".");
+			return 0;
+		}
+
+		return frameSize;
+	}
+
+	UInt_64 AudioDevice::ReceiveStream(void *data, UInt_64 inFrameSize)
+	{
+		if (!IsValid() || !IsStreaming() || !captureClient || !data || !inFrameSize)
+			return 0;
+
+		UInt_32 frameSize = 0;
+		HRESULT r = captureClient->GetNextPacketSize(&frameSize);
+		if (r == AUDCLNT_E_DEVICE_INVALIDATED)
+		{
+			EHS_LOG_INT(LogType::WARN, 0, "The audio device has been invalidated.");
+			return 0;
+		}
+		else if (FAILED(r))
+		{
+			EHS_LOG_INT(LogType::ERR, 1, "Failed to retrieve samples size with error #" + Str_8::FromNum(r) + ".");
+			return 0;
+		}
+
+		if (frameSize > inFrameSize)
+			frameSize = inFrameSize;
+
+		UInt_64 frameOffset = 0;
+		r = client->GetCurrentPadding((UINT32*)&frameOffset);
+		if (r == AUDCLNT_E_DEVICE_INVALIDATED)
+		{
+			EHS_LOG_INT(LogType::WARN, 2, "The audio device has been invalidated.");
+			return 0;
+		}
+		else if (FAILED(r))
+		{
+			EHS_LOG_INT(LogType::ERR, 3, "Failed to retrieve samples padding with error #" + Str_8::FromNum(r) + ".");
+			return 0;
+		}
+
+		UInt_32 flags = 0;
 		Byte* buffer = nullptr;
 
-		if (!IsValid())
-			return buffer;
-
-		HRESULT r = client->GetCurrentPadding((UINT32*)&offset);
+		r = captureClient->GetBuffer(&buffer, (UINT32*)&frameSize, (DWORD*)&flags, nullptr, nullptr);
 		if (r == AUDCLNT_E_DEVICE_INVALIDATED)
-			EHS_LOG_INT(LogType::ERR, 0, "The audio device has been invalidated.");
-		else if (FAILED(r))
-			EHS_LOG_INT(LogType::ERR, 1, "Failed to retrieve samples padding with error #" + Str_8::FromNum(r) + ".");
-
-		if (playbackClient)
 		{
-			r = playbackClient->GetBuffer(*frames, &buffer);
-			if (r == AUDCLNT_E_BUFFER_TOO_LARGE)
-				EHS_LOG_INT(LogType::ERR, 0, "The given frame size, " + Str_8::FromNum(*frames) + ", must be less than or equal to, " + Str_8::FromNum(maxFrames - *offset) + ".");
-			else if (r == AUDCLNT_E_DEVICE_INVALIDATED)
-				EHS_LOG_INT(LogType::ERR, 1, "The audio device has been invalidated.");
-			else if (FAILED(r))
-				EHS_LOG_INT(LogType::ERR, 2, "Failed to retrieve buffer with error #" + Str_8::FromNum(r) + ".");
+			EHS_LOG_INT(LogType::WARN, 4, "The audio device has been invalidated.");
+			return 0;
 		}
-		else if (captureClient)
+		else if (FAILED(r))
 		{
-			UInt_32 flags = 0;
+			EHS_LOG_INT(LogType::ERR, 5, "Failed to retrieve buffer with error #" + Str_8::FromNum(r) + ".");
+			return 0;
+		}
 
-			r = captureClient->GetBuffer(&buffer, (UINT32*)frames, (DWORD*)&flags, nullptr, nullptr);
+		Util::Copy(data, &buffer[frameOffset], frameSize * byteDepth * channels);
+
+		r = captureClient->ReleaseBuffer(frameSize);
 		if (r == AUDCLNT_E_DEVICE_INVALIDATED)
-				EHS_LOG_INT(LogType::ERR, 1, "The audio device has been invalidated.");
+		{
+			EHS_LOG_INT(LogType::WARN, 6, "The audio device has been invalidated.");
+			return 0;
+		}
 		else if (FAILED(r))
-				EHS_LOG_INT(LogType::ERR, 2, "Failed to retrieve buffer with error #" + Str_8::FromNum(r) + ".");
+		{
+			EHS_LOG_INT(LogType::ERR, 7, "Failed to release buffer with error #" + Str_8::FromNum(r) + ".");
+			return 0;
 		}
 
-		return buffer;
-	}
+		EHS_LOG_SUCCESS();
 
-	void AudioDevice::UnMap(const UInt_64 offset, const UInt_64 frames)
-	{
-		if (!IsValid() || !streaming)
-			return;
-
-		if (playbackClient)
-		{
-			HRESULT r = playbackClient->ReleaseBuffer(frames, 0);
-			if (r == AUDCLNT_E_DEVICE_INVALIDATED)
-				EHS_LOG_INT(LogType::ERR, 0, "The audio device has been invalidated.");
-			else if (FAILED(r))
-				EHS_LOG_INT(LogType::ERR, 1, "Failed to release buffer with error #" + Str_8::FromNum(r) + ".");
-		}
-		else if (captureClient)
-		{
-			HRESULT r = captureClient->ReleaseBuffer(frames);
-			if (r == AUDCLNT_E_DEVICE_INVALIDATED)
-				EHS_LOG_INT(LogType::ERR, 0, "The audio device has been invalidated.");
-			else if (FAILED(r))
-				EHS_LOG_INT(LogType::ERR, 1, "Failed to release buffer with error #" + Str_8::FromNum(r) + ".");
-		}
+		return frameSize;
 	}
 
 	Str_32 AudioDevice::GetInterfaceName_32() const
@@ -484,6 +490,11 @@ namespace ehs
 		return UTF::To_8(GetName_16());
 	}
 
+	bool AudioDevice::IsStreaming() const
+	{
+          return hdl && client && (playbackClient || captureClient);
+	}
+
 	bool AudioDevice::IsValid() const
 	{
 		return hdl;

src/io/audio/BaseAudioDevice.cpp

@@ -3,14 +3,14 @@
 namespace ehs
 {
 	BaseAudioDevice::BaseAudioDevice()
-		: type(AudioDeviceType::ALL), dataType(DataType::SINT_8), bitDepth(0), sampleRate(0), channels(0),
-		period(20000), latency(150000), maxFrames(0), streaming(false)
+		: type(AudioDeviceType::ALL), dataType(DataType::SINT_8), byteDepth(0), sampleRate(0), channels(0),
+		period(20000), latency(150000), maxFrames(0)
     {
     }
 
 	BaseAudioDevice::BaseAudioDevice(const BaseAudioDevice& device)
-		: type(device.type), dataType(device.dataType), bitDepth(device.bitDepth), sampleRate(device.sampleRate),
-		channels(device.channels), period(device.period), latency(device.latency), maxFrames(0), streaming(false)
+		: type(device.type), dataType(device.dataType), byteDepth(device.byteDepth), sampleRate(device.sampleRate),
+		channels(device.channels), period(device.period), latency(device.latency), maxFrames(0)
     {
     }
 
@@ -21,21 +21,16 @@ namespace ehs
 
 		type = device.type;
 		dataType = device.dataType;
-		bitDepth = device.bitDepth;
+		byteDepth = device.byteDepth;
 		sampleRate = device.sampleRate;
 		channels = device.channels;
 		period = device.period;
 		latency = device.latency;
 		maxFrames = device.maxFrames;
-		streaming = false;
 
         return *this;
     }
 
-	void BaseAudioDevice::Release()
-	{
-	}
-
 	void BaseAudioDevice::OpenStream()
 	{
 	}
@@ -44,18 +39,29 @@ namespace ehs
 	{
 	}
 
-	UInt_64 BaseAudioDevice::GetAvailFrames() const
+	UInt_64 BaseAudioDevice::SendStream(const void *data, const UInt_64 size)
 	{
 		return 0;
 	}
 
-	Byte* BaseAudioDevice::Map(UInt_64* offset, UInt_64* frames)
+	UInt_64 BaseAudioDevice::ReceiveStream(void *data, const UInt_64 size)
 	{
-		return nullptr;
+		return 0;
 	}
 
-	void BaseAudioDevice::UnMap(const UInt_64 offset, const UInt_64 frames)
+	void BaseAudioDevice::BridgeStreams(const UInt_64 bufferSize)
 	{
+		Byte* buffer = new Byte[bufferSize];
+
+		UInt_64 result = ReceiveStream(buffer, bufferSize);
+		while (result < bufferSize)
+			result += ReceiveStream(&buffer[result], bufferSize - result);
+
+		result -= SendStream(buffer, result);
+		while (result)
+			result -= SendStream(&buffer[bufferSize - result], result);
+
+		delete[] buffer;
 	}
 
 	AudioDeviceType BaseAudioDevice::GetType() const
@@ -65,11 +71,11 @@ namespace ehs
 
 	void BaseAudioDevice::SetDataType(const DataType newDataType)
 	{
-		if (streaming)
+		if (IsStreaming())
 			return;
 
 		dataType = newDataType;
-		bitDepth = ToBitDepth(newDataType);
+		byteDepth = ToByteDepth(newDataType);
 	}
 
 	DataType BaseAudioDevice::GetDataType() const
@@ -79,17 +85,17 @@ namespace ehs
 
 	UInt_8 BaseAudioDevice::GetByteDepth() const
 	{
-		return bitDepth / 8;
+		return byteDepth;
 	}
 
 	UInt_16 BaseAudioDevice::GetBitDepth() const
 	{
-		return bitDepth;
+		return byteDepth * 8;
 	}
 
 	void BaseAudioDevice::SetSampleRate(const UInt_32 newSampleRate)
 	{
-		if (streaming)
+		if (IsStreaming())
 			return;
 
 		sampleRate = newSampleRate;
@@ -102,7 +108,7 @@ namespace ehs
 
 	void BaseAudioDevice::SetChannels(const UInt_32 newChannels)
 	{
-		if (streaming)
+		if (IsStreaming())
 			return;
 
 		channels = newChannels;
@@ -115,12 +121,12 @@ namespace ehs
 
 	UInt_32 BaseAudioDevice::GetFrameSize() const
 	{
-		return bitDepth / 8 * channels;
+		return byteDepth * channels;
 	}
 
 	void BaseAudioDevice::SetPeriod(const UInt_32 newPeriod)
 	{
-		if (streaming)
+		if (IsStreaming())
 			return;
 
 		period = newPeriod;
@@ -133,7 +139,7 @@ namespace ehs
 
 	void BaseAudioDevice::SetLatency(const UInt_32 newLatency)
 	{
-		if (streaming)
+		if (IsStreaming())
 			return;
 
 		latency = newLatency;
@@ -151,7 +157,7 @@ namespace ehs
 
 	bool BaseAudioDevice::IsStreaming() const
 	{
-		return streaming;
+		return false;
 	}
 
 	bool BaseAudioDevice::IsValid() const

src/io/hid/Button.cpp

@@ -7,43 +7,67 @@ namespace ehs
 	{
 	}
 
-	Button::Button(const Str_8& name)
-		: name(name), hash(name.Hash_32())
+	Button::Button(Str_8 name)
+		: hash(name.Hash_32()), name((Str_8 &&)name)
 	{
 	}
 
-	Button::Button(const Button& key)
-		: name(key.name), hash(key.hash)
+	Button::Button(Button &&key) noexcept
+		: hash(key.hash), name((Str_8 &&)key.name)
+	{
+		key.hash = 0;
+	}
+
+	Button::Button(const Button &key)
+		: hash(key.hash), name(key.name)
 	{
 	}
 
-	Button& Button::operator=(const Button& key)
+	Button & Button::operator=(Button &&key) noexcept
 	{
 		if (this == &key)
 			return *this;
 
-		name = key.name;
 		hash = key.hash;
+		name = (Str_8 &&)key.name;
+
+		key.hash = 0;
 
 		return *this;
 	}
 
-	bool Button::operator==(const Button& key) const
+	Button &Button::operator=(const Button &key)
+	{
+		if (this == &key)
+			return *this;
+
+		hash = key.hash;
+		name = key.name;
+
+		return *this;
+	}
+
+	bool Button::operator==(const Button &key) const
 	{
 		return key.hash == hash;
 	}
 
-	bool Button::operator!=(const Button& key) const
+	bool Button::operator!=(const Button &key) const
 	{
 		return key.hash != hash;
 	}
 
+	UInt_32 Button::GetHash() const
+	{
+		return hash;
+	}
+
 	Str_8 Button::GetName() const
 	{
 		return name;
 	}
 
-	UInt_32 Button::GetHash() const
+	bool Button::IsValid() const
 	{
 		return hash;
 	}

src/io/hid/HID.cpp

@@ -1,26 +1,39 @@
 #include "ehs/io/hid/HID.h"
 
+#include "ehs/Log.h"
+#include "ehs/Math.h"
+#include "ehs/io/hid/Keyboard.h"
+
 namespace ehs
 {
 	HID::HID()
-		: type(EHS_HID_UNKNOWN), id(0)
+		: type(EHS_HID_UNKNOWN), hashName(0), id(0), heldTime(0.0), activateTime(0.0f), active(false)
 	{
 	}
 
 	HID::HID(const UInt_8 type, Str_8 name, const UInt_64 id)
-		: type(type), name((Str_8&&)name), id(id)
+		: type(type), hashName(name.Hash_64()), name((Str_8 &&)name), id(id), heldTime(0.0f), activateTime(0.0f),
+		active(false)
 	{
 	}
 
 	HID::HID(HID&& hid) noexcept
-		: type(hid.type), name((Str_8&&)hid.name), id(hid.id), states((Array<ButtonState>&&)hid.states)
+		: type(hid.type), hashName(hid.hashName), name((Str_8&&)hid.name), id(hid.id),
+		states((Array<ButtonState> &&)hid.states), lastState((Button &&)hid.lastState), heldTime(hid.heldTime),
+		activateTime(hid.activateTime), active(hid.active)
 	{
 		hid.type = EHS_HID_UNKNOWN;
+		hid.hashName = 0;
 		hid.id = 0;
+		hid.lastState = {};
+		hid.heldTime = 0.0f;
+		hid.activateTime = 0.0f;
+		hid.active = false;
 	}
 
 	HID::HID(const HID& hid)
-		: type(hid.type), name(hid.name), id(hid.id), states(hid.states)
+		: type(hid.type), hashName(hid.hashName), name(hid.name), id(hid.id), states(hid.states), heldTime(0.0f),
+		activateTime(0.0f), active(false)
 	{
 	}
 
@@ -30,12 +43,22 @@ namespace ehs
 			return *this;
 
 		type = hid.type;
+		hashName = hid.hashName;
 		name = (Str_8&&)hid.name;
 		id = hid.id;
-		states = (Array<ButtonState>&&)hid.states;
+		states = (Array<ButtonState> &&)hid.states;
+		lastState = (Button &&)hid.lastState;
+		heldTime = hid.heldTime;
+		activateTime = hid.activateTime;
+		active = hid.active;
 
 		hid.type = EHS_HID_UNKNOWN;
+		hid.hashName = 0;
 		hid.id = 0;
+		hid.lastState = {};
+		hid.heldTime = 0.0f;
+		hid.activateTime = 0.0f;
+		hid.active = false;
 
 		return *this;
 	}
@@ -46,9 +69,14 @@ namespace ehs
 			return *this;
 
 		type = hid.type;
+		hashName = hid.hashName;
 		name = hid.name;
 		id = hid.id;
 		states = hid.states;
+		lastState = {};
+		heldTime = 0.0f;
+		activateTime = 0.0f;
+		active = false;
 
 		return *this;
 	}
@@ -73,16 +101,30 @@ namespace ehs
 		return id != otherId;
 	}
 
-	void HID::Poll()
+	void HID::Poll(const float delta)
 	{
 		for (UInt_64 i = 0; i < states.Size(); ++i)
 		{
 			if (states[i].IsPressed())
 			{
 				if (states[i].GetState() == State::RELEASED)
+				{
 					states[i].SetState(State::TOUCHED);
+
+					lastState = states[i].GetButton();
+					ResetTime();
+					active = true;
+				}
 				else
+				{
 					states[i].SetState(State::PRESSED);
+
+					if (lastState == states[i].GetButton())
+					{
+						if (TickHoldTime(delta))
+							TickActivateTime(delta);
+					}
+				}
 			}
 			else
 			{
@@ -90,6 +132,13 @@ namespace ehs
 					states[i].SetState(State::JUST_RELEASED);
 				else
 					states[i].SetState(State::RELEASED);
+
+				if (lastState == states[i].GetButton())
+				{
+					lastState = {};
+					ResetTime();
+					active = false;
+				}
 			}
 		}
 	}
@@ -149,7 +198,7 @@ namespace ehs
 		Vector<const ButtonState*> result(0, states.Size() + 1);
 
 		for (UInt_64 i = 0; i < states.Size(); i++)
-			if (states[i] == State::PRESSED || states[i] == State::TOUCHED)
+			if (states[i] == State::PRESSED)
 				result.Push(&states[i]);
 
 		return result;
@@ -158,7 +207,7 @@ namespace ehs
 	const ButtonState* HID::IsDown(const Button& button) const
 	{
 		const ButtonState* state = GetState(button);
-		if (!state || (*state != State::PRESSED && *state != State::TOUCHED))
+		if (!state || (*state != State::PRESSED))
 			return nullptr;
 
 		return state;
@@ -167,7 +216,7 @@ namespace ehs
 	const ButtonState* HID::IsDown() const
 	{
 		for (UInt_64 i = 0; i < states.Size(); i++)
-			if (states[i] == State::PRESSED || states[i] == State::TOUCHED)
+			if (states[i] == State::PRESSED)
 				return &states[i];
 
 		return nullptr;
@@ -231,6 +280,22 @@ namespace ehs
 		return nullptr;
 	}
 
+	const ButtonState *HID::IsPressed(const Button &button)
+	{
+		if (active && lastState == button)
+			return GetState(lastState);
+
+		return nullptr;
+	}
+
+	const ButtonState *HID::GetPressed()
+	{
+		if (active)
+			return GetState(lastState);
+
+		return nullptr;
+	}
+
 	void HID::ButtonDown(const Button& button)
 	{
 		if (ButtonState* state = GetState(button); state)
@@ -249,6 +314,9 @@ namespace ehs
 
 	const ButtonState* HID::GetState(const Button& button) const
 	{
+		if (!button.IsValid())
+			return nullptr;
+
 		for (UInt_64 i = 0; i < states.Size(); ++i)
 			if (states[i] == button)
 				return &states[i];
@@ -287,10 +355,42 @@ namespace ehs
 
 	ButtonState* HID::GetState(const Button& button)
 	{
+		if (!button.IsValid())
+			return nullptr;
+
 		for (UInt_64 i = 0; i < states.Size(); i++)
 			if (states[i].GetButton() == button)
 				return &states[i];
 
 		return nullptr;
 	}
+
+	bool HID::TickHoldTime(const float delta)
+	{
+		if ((heldTime += delta) > 0.5f)
+			return true;
+
+		active = false;
+
+		return false;
+	}
+
+	void HID::ResetTime()
+	{
+		heldTime = 0.0f;
+		activateTime = 0.0f;
+	}
+
+	void HID::TickActivateTime(const float delta)
+	{
+		if ((activateTime += delta) > 0.075f)
+		{
+			activateTime = ehs::Math::Mod(activateTime, 0.075f);
+			active = true;
+		}
+		else
+		{
+			active = false;
+		}
+	}
 }

src/io/hid/InputHandler.cpp

@@ -1,5 +1,7 @@
 #include "ehs/io/hid/InputHandler.h"
 
+#include "ehs/system/CPU.h"
+
 namespace ehs
 {
 	InputHandler::~InputHandler()
@@ -9,23 +11,24 @@ namespace ehs
 	}
 
 	InputHandler::InputHandler()
-		: hashId(0)
+		: hashId(0), start(0)
 	{
 	}
 
 	InputHandler::InputHandler(Str_8 id)
-		: hashId(id.Hash_64()), id((Str_8&&)id)
+		: hashId(id.Hash_64()), id((Str_8&&)id), start(CPU::GetTSC())
 	{
 	}
 
 	InputHandler::InputHandler(InputHandler&& ih) noexcept
-		: hashId(ih.hashId), id((Str_8&&)ih.id), devices((Array<HID*>&&)ih.devices)
+		: hashId(ih.hashId), id((Str_8&&)ih.id), devices((Array<HID*>&&)ih.devices), start(ih.start)
 	{
 		ih.hashId = 0;
+		ih.start = 0;
 	}
 
 	InputHandler::InputHandler(const InputHandler& ih)
-		: hashId(ih.hashId), id(ih.id), devices(ih.devices.Size())
+		: hashId(ih.hashId), id(ih.id), devices(ih.devices.Size()), start(ih.start)
 	{
 		for (UInt_64 i = 0; i < devices.Size(); i++)
 			devices[i] = ih.devices[i]->Clone();
@@ -39,8 +42,10 @@ namespace ehs
 		hashId = ih.hashId;
 		id = (Str_8&&)ih.id;
 		devices = (Array<HID*>&&)ih.devices;
+		start = ih.start;
 
 		ih.hashId = 0;
+		ih.start = 0;
 
 		return *this;
 	}
@@ -56,6 +61,7 @@ namespace ehs
 		hashId = ih.hashId;
 		id = ih.id;
 		devices = Array<HID*>(ih.devices.Size());
+		start = ih.start;
 
 		for (UInt_64 i = 0; i < devices.Size(); i++)
 			devices[i] = ih.devices[i]->Clone();
@@ -63,12 +69,12 @@ namespace ehs
 		return *this;
 	}
 
-	bool InputHandler::operator==(const UInt_64 otherHashId)
+	bool InputHandler::operator==(const UInt_64 otherHashId) const
 	{
 		return hashId == otherHashId;
 	}
 
-	bool InputHandler::operator!=(const UInt_64 otherHashId)
+	bool InputHandler::operator!=(const UInt_64 otherHashId) const
 	{
 		return hashId != otherHashId;
 	}
@@ -96,8 +102,14 @@ namespace ehs
 
 	void InputHandler::Poll()
 	{
+		static UInt_64 freq = CPU::GetTSC_Freq();
+
+		const UInt_64 newTSC = CPU::GetTSC();
+		delta = newTSC - start;
+		start = newTSC;
+
 		for (UInt_64 i = 0; i < devices.Size(); i++)
-			devices[i]->Poll();
+			devices[i]->Poll((float)delta / (float)freq);
 	}
 
 	UInt_64 InputHandler::GetHashId() const

src/io/hid/Keyboard.cpp

@@ -7,7 +7,7 @@ namespace ehs
 	}
 
 	Keyboard::Keyboard(Str_8 name, const UInt_64 id)
-		: HID(EHS_HID_KEYBOARD, (Str_8&&)name, id)
+		: HID(EHS_HID_KEYBOARD, (Str_8 &&)name, id)
 	{
 	}
 
@@ -26,9 +26,9 @@ namespace ehs
 		return *this;
 	}
 
-	void Keyboard::Poll()
+	void Keyboard::Poll(const float delta)
 	{
-		HID::Poll();
+		HID::Poll(delta);
 	}
 
 	Keyboard* Keyboard::Clone() const
@@ -268,23 +268,23 @@ namespace ehs
 			case 71:
 				return Keyboard::F13;
 			case 72:
-				return Keyboard::F14;
+				return Keyboard::Up;
 			case 73:
 				return Keyboard::F15;
 			case 74:
 				return Keyboard::F16;
 			case 75:
-				return Keyboard::F17;
+				return Keyboard::Left;
 			case 76:
 				return Keyboard::F18;
 			case 77:
-				return Keyboard::F19;
+				return Keyboard::Right;
 			case 78:
 				return Keyboard::F20;
 			case 79:
 				return Keyboard::F21;
 			case 80:
-				return Keyboard::F22;
+				return Keyboard::Down;
 			case 81:
 				return Keyboard::F23;
 			case 82:

src/io/hid/Mouse.cpp

@@ -28,11 +28,11 @@ namespace ehs
 		return *this;
 	}
 
-	void Mouse::Poll()
+	void Mouse::Poll(const float delta)
 	{
-		delta = {};
+		this->delta = {};
 
-		HID::Poll();
+		HID::Poll(delta);
 	}
 
 	void Mouse::SetDelta(const Vec2_s32& newDelta)

src/json/Json.cpp

@@ -13,55 +13,55 @@ namespace ehs
     {
     }
 
-    Json::Json(const JsonBase& value)
+    Json::Json(const JsonBase &value)
         : value(new JsonBase(value))
     {
     }
 
-    Json::Json(const JsonObj& value)
-        : value((JsonBase*)new JsonObj(value))
+    Json::Json(const JsonObj &value)
+        : value((JsonBase *)new JsonObj(value))
     {
     }
 
-    Json::Json(const JsonArray& value)
-        : value((JsonBase*)new JsonArray(value))
+    Json::Json(const JsonArray &value)
+        : value((JsonBase *)new JsonArray(value))
     {
     }
 
-    Json::Json(const JsonBool& value)
+    Json::Json(const JsonBool &value)
         : value((JsonBase*)new JsonBool(value))
     {
     }
 
-    Json::Json(const JsonNum& value)
-            : value((JsonBase*)new JsonNum(value))
+    Json::Json(const JsonNum &value)
+            : value((JsonBase *)new JsonNum(value))
     {
     }
 
-    Json::Json(const JsonStr& value)
-            : value((JsonBase*)new JsonStr(value))
+    Json::Json(const JsonStr &value)
+            : value((JsonBase *)new JsonStr(value))
     {
     }
 	
-	Json::Json(const char* data, const UInt_64 size, const UInt_64 extra)
+	Json::Json(const char *data, const UInt_64 size, const UInt_64 extra)
         : value(nullptr)
 	{
         Parse({data, size}, extra);
 	}
 	
-	Json::Json(const Str_8& data, const UInt_64 extra)
+	Json::Json(const Str_8 &data, const UInt_64 extra)
         : value(nullptr)
 	{
         Parse(data, extra);
 	}
 
-	Json::Json(Json&& json) noexcept
+	Json::Json(Json &&json) noexcept
 		: value(json.value)
 	{
 		json.value = nullptr;
 	}
 
-    Json::Json(const Json& json)
+    Json::Json(const Json &json)
         : value(nullptr)
     {
         if (!json.value)
@@ -70,19 +70,19 @@ namespace ehs
         switch (json.value->GetType())
         {
             case JsonType::OBJ:
-                value = (JsonBase*)new JsonObj(*(JsonObj*)json.value);
+                value = (JsonBase *)new JsonObj(*(JsonObj *)json.value);
                 break;
             case JsonType::ARRAY:
-                value = (JsonBase*)new JsonArray(*(JsonArray*)json.value);
+                value = (JsonBase *)new JsonArray(*(JsonArray *)json.value);
                 break;
             case JsonType::BOOL:
-                value = (JsonBase*)new JsonBool(*(JsonBool*)json.value);
+                value = (JsonBase *)new JsonBool(*(JsonBool *)json.value);
                 break;
             case JsonType::NUM:
-                value = (JsonBase*)new JsonNum(*(JsonNum*)json.value);
+                value = (JsonBase *)new JsonNum(*(JsonNum *)json.value);
                 break;
             case JsonType::STR:
-                value = (JsonBase*)new JsonStr(*(JsonStr*)json.value);
+                value = (JsonBase *)new JsonStr(*(JsonStr *)json.value);
                 break;
             default:
                 value = new JsonBase();
@@ -90,7 +90,7 @@ namespace ehs
         }
     }
 
-	Json& Json::operator=(Json&& json) noexcept
+	Json& Json::operator=(Json &&json) noexcept
 	{
 		if (this == &json)
 			return *this;
@@ -103,7 +103,7 @@ namespace ehs
 		return *this;
 	}
 
-    Json& Json::operator=(const Json& json)
+    Json& Json::operator=(const Json &json)
     {
         if (this == &json)
             return *this;
@@ -117,19 +117,19 @@ namespace ehs
         switch (json.value->GetType())
         {
             case JsonType::OBJ:
-                value = (JsonBase*)new JsonObj(*(JsonObj*)json.value);
+                value = (JsonBase *)new JsonObj(*(JsonObj *)json.value);
                 break;
             case JsonType::ARRAY:
-                value = (JsonBase*)new JsonArray(*(JsonArray*)json.value);
+                value = (JsonBase *)new JsonArray(*(JsonArray *)json.value);
                 break;
             case JsonType::BOOL:
-                value = (JsonBase*)new JsonBool(*(JsonBool*)json.value);
+                value = (JsonBase *)new JsonBool(*(JsonBool *)json.value);
                 break;
             case JsonType::NUM:
-                value = (JsonBase*)new JsonNum(*(JsonNum*)json.value);
+                value = (JsonBase *)new JsonNum(*(JsonNum *)json.value);
                 break;
             case JsonType::STR:
-                value = (JsonBase*)new JsonStr(*(JsonStr*)json.value);
+                value = (JsonBase *)new JsonStr(*(JsonStr *)json.value);
                 break;
             default:
                 value = new JsonBase();
@@ -139,12 +139,12 @@ namespace ehs
         return *this;
     }
 
-    JsonBase* Json::GetValue()
+    JsonBase *Json::GetValue()
     {
         return value;
     }
 
-    JsonBase* Json::RetrieveValue(const Str_8& access)
+    JsonBase *Json::RetrieveValue(const Str_8 &access)
     {
         if (!value || !access.Size())
             return nullptr;
@@ -192,8 +192,8 @@ namespace ehs
     Vector<Str_8> Json::ParseAccess(const Str_8& access)
     {
         bool isIndex = false;
-        const Char_8* start = &access[0];
-        const Char_8* end = &access[access.Size() - 1];
+        const Char_8 *start = &access[0];
+        const Char_8 *end = &access[access.Size() - 1];
 
         Vector<Str_8> levels(0, 5);
 
@@ -251,7 +251,7 @@ namespace ehs
         return levels;
     }
 
-    void Json::ParseValue(JsonVar* var, const Char_8** begin, const Char_8* end, const UInt_64 extra)
+    void Json::ParseValue(JsonVar *var, const Char_8 **begin, const Char_8 *end, const UInt_64 extra)
     {
         const Char_8* start = nullptr;
 		bool isStr = false;
@@ -263,7 +263,7 @@ namespace ehs
                 if (start)
                 {
                     if (*begin - start)
-						((JsonStr*)var->GetValue())->value = Str_8(start, *begin - start);
+						((JsonStr *)var->GetValue())->value = Str_8(start, *begin - start);
 
                     ++(*begin);
                     return;
@@ -312,11 +312,11 @@ namespace ehs
         }
     }
 
-    JsonVar Json::ParseVar(const Char_8** begin, const Char_8* end, const UInt_64 extra)
+    JsonVar Json::ParseVar(const Char_8 **begin, const Char_8 *end, const UInt_64 extra)
     {
         JsonVar var;
 
-        const Char_8* start = nullptr;
+        const Char_8 *start = nullptr;
 
         for (; *begin <= end; ++(*begin))
         {
@@ -351,7 +351,7 @@ namespace ehs
         return var;
     }
 
-    void Json::ParseObject(JsonObj* obj, const Char_8** begin, const Char_8* end, const UInt_64 extra)
+    void Json::ParseObject(JsonObj *obj, const Char_8 **begin, const Char_8 *end, const UInt_64 extra)
     {
         JsonVar var;
         do
@@ -361,9 +361,9 @@ namespace ehs
         while(obj->AddVar(var));
     }
 
-    void Json::ParseArray(JsonArray* arr, const Char_8** begin, const Char_8* end, const UInt_64 extra)
+    void Json::ParseArray(JsonArray *arr, const Char_8 **begin, const Char_8 *end, const UInt_64 extra)
     {
-        const Char_8* start = nullptr;
+        const Char_8 *start = nullptr;
 
         for (; *begin <= end; ++(*begin))
         {
@@ -423,12 +423,12 @@ namespace ehs
         }
     }
 
-    void Json::Parse(const Str_8& data, const UInt_64 extra)
+    void Json::Parse(const Str_8 &data, const UInt_64 extra)
     {
-        const Char_8* start = nullptr;
-        const Char_8* end = &data[data.Size() - 1];
+        const Char_8 *start = nullptr;
+        const Char_8 *end = &data[data.Size() - 1];
 
-        for (const Char_8* i = &data[0]; i <= end; ++i)
+        for (const Char_8 *i = &data[0]; i <= end; ++i)
         {
             if (*i == '}' || *i == ']')
             {

src/json/JsonArray.cpp

@@ -29,7 +29,7 @@ namespace ehs
 	{
 	}
 
-	JsonArray::JsonArray(JsonArray&& ja) noexcept
+	JsonArray::JsonArray(JsonArray &&ja) noexcept
 		: JsonBase(ja), size(ja.size), extra(ja.extra), rawSize(ja.rawSize), data(ja.data)
 	{
 		ja.size = 0;
@@ -38,7 +38,7 @@ namespace ehs
 		ja.data = nullptr;
 	}
 
-	JsonArray::JsonArray(const JsonArray& ja)
+	JsonArray::JsonArray(const JsonArray &ja)
 		: JsonBase(ja), size(ja.size), extra(ja.extra), rawSize(ja.rawSize), data(new JsonBase*[ja.rawSize])
 	{
 		for (UInt_64 i = 0; i < size; ++i)
@@ -46,19 +46,19 @@ namespace ehs
 			switch (ja.data[i]->GetType())
 			{
 				case JsonType::OBJ:
-					data[i] = (JsonBase*)new JsonObj(*(JsonObj*)ja.data[i]);
+					data[i] = (JsonBase *)new JsonObj(*(JsonObj *)ja.data[i]);
 					break;
 				case JsonType::ARRAY:
-					data[i] = (JsonBase*)new JsonArray(*(JsonArray*)ja.data[i]);
+					data[i] = (JsonBase *)new JsonArray(*(JsonArray *)ja.data[i]);
 					break;
 				case JsonType::BOOL:
-					data[i] = (JsonBase*)new JsonBool(*(JsonBool*)ja.data[i]);
+					data[i] = (JsonBase *)new JsonBool(*(JsonBool *)ja.data[i]);
 					break;
 				case JsonType::NUM:
-					data[i] = (JsonBase*)new JsonNum(*(JsonNum*)ja.data[i]);
+					data[i] = (JsonBase *)new JsonNum(*(JsonNum *)ja.data[i]);
 					break;
 				case JsonType::STR:
-					data[i] = (JsonBase*)new JsonStr(*(JsonStr*)ja.data[i]);
+					data[i] = (JsonBase *)new JsonStr(*(JsonStr *)ja.data[i]);
 					break;
 				default:
 					data[i] = new JsonBase();
@@ -67,7 +67,7 @@ namespace ehs
 		}
 	}
 
-	JsonArray& JsonArray::operator=(JsonArray&& ja) noexcept
+	JsonArray &JsonArray::operator=(JsonArray &&ja) noexcept
 	{
 		if (this == &ja)
 			return *this;
@@ -88,7 +88,7 @@ namespace ehs
 		return *this;
 	}
 
-	JsonArray& JsonArray::operator=(const JsonArray& ja)
+	JsonArray &JsonArray::operator=(const JsonArray &ja)
 	{
 		if (this == &ja)
 			return *this;
@@ -134,7 +134,7 @@ namespace ehs
 		return data;
 	}
 
-	JsonArray::operator JsonBase**()
+	JsonArray::operator JsonBase **()
 	{
 		return data;
 	}
@@ -154,12 +154,12 @@ namespace ehs
 		return size;
 	}
 
-	void JsonArray::Insert(const UInt_64 index, const JsonBase* const value)
+	void JsonArray::Insert(const UInt_64 index, const JsonBase * const value)
 	{
 		if (size + 1 >= rawSize)
 			rawSize = size + extra;
 
-		JsonBase** result = new JsonBase*[rawSize];
+		JsonBase **result = new JsonBase*[rawSize];
 
 		for (UInt_64 i = 0; i < index; ++i)
 			result[i] = data[i];
@@ -195,12 +195,12 @@ namespace ehs
 		++size;
 	}
 
-	void JsonArray::Push(const JsonBase* const value)
+	void JsonArray::Push(const JsonBase * const value)
 	{
 		if (size + 1 > rawSize)
 		{
 			rawSize = size + extra + 1;
-			JsonBase** result = new JsonBase*[rawSize];
+			JsonBase **result = new JsonBase*[rawSize];
 
 			for (UInt_64 i = 0; i < size; ++i)
 				result[i] = data[i];
@@ -257,12 +257,12 @@ namespace ehs
 		}
 	}
 
-	void JsonArray::Push(const JsonBase& value)
+	void JsonArray::Push(const JsonBase &value)
 	{
 		if (size + 1 > rawSize)
 		{
 			rawSize = size + extra + 1;
-			JsonBase** result = new JsonBase*[rawSize];
+			JsonBase **result = new JsonBase*[rawSize];
 
 			for (UInt_64 i = 0; i < size; ++i)
 				result[i] = data[i];
@@ -279,7 +279,29 @@ namespace ehs
 		}
 	}
 
-	void JsonArray::Push(const JsonObj& value)
+	void JsonArray::Push(const JsonObj &value)
+	{
+		if (size + 1 > rawSize)
+		{
+			rawSize = size + extra + 1;
+			JsonBase **result = new JsonBase*[rawSize];
+
+			for (UInt_64 i = 0; i < size; ++i)
+				result[i] = data[i];
+
+			result[size++] = (JsonBase *)new JsonObj(value);
+
+			delete[] data;
+
+			data = result;
+		}
+		else
+		{
+			data[size++] = (JsonBase *)new JsonObj(value);
+		}
+	}
+
+	void JsonArray::Push(const JsonArray &value)
 	{
 		if (size + 1 > rawSize)
 		{
@@ -289,7 +311,7 @@ namespace ehs
 			for (UInt_64 i = 0; i < size; ++i)
 				result[i] = data[i];
 
-			result[size++] = (JsonBase*)new JsonObj(value);
+			result[size++] = (JsonBase *)new JsonArray(value);
 
 			delete[] data;
 
@@ -297,11 +319,11 @@ namespace ehs
 		}
 		else
 		{
-			data[size++] = (JsonBase*)new JsonObj(value);
+			data[size++] = (JsonBase *)new JsonArray(value);
 		}
 	}
 
-	void JsonArray::Push(const JsonArray& value)
+	void JsonArray::Push(const JsonBool &value)
 	{
 		if (size + 1 > rawSize)
 		{
@@ -311,7 +333,7 @@ namespace ehs
 			for (UInt_64 i = 0; i < size; ++i)
 				result[i] = data[i];
 
-			result[size++] = (JsonBase*)new JsonArray(value);
+			result[size++] = (JsonBase *)new JsonBool(value);
 
 			delete[] data;
 
@@ -319,29 +341,7 @@ namespace ehs
 		}
 		else
 		{
-			data[size++] = (JsonBase*)new JsonArray(value);
-		}
-	}
-
-	void JsonArray::Push(const JsonBool& value)
-	{
-		if (size + 1 > rawSize)
-		{
-			rawSize = size + extra + 1;
-			JsonBase** result = new JsonBase*[rawSize];
-
-			for (UInt_64 i = 0; i < size; ++i)
-				result[i] = data[i];
-
-			result[size++] = (JsonBase*)new JsonBool(value);
-
-			delete[] data;
-
-			data = result;
-		}
-		else
-		{
-			data[size++] = (JsonBase*)new JsonBool(value);
+			data[size++] = (JsonBase *)new JsonBool(value);
 		}
 	}
 
@@ -355,7 +355,7 @@ namespace ehs
 			for (UInt_64 i = 0; i < size; ++i)
 				result[i] = data[i];
 
-			result[size++] = (JsonBase*)new JsonBool(value);
+			result[size++] = (JsonBase *)new JsonBool(value);
 
 			delete[] data;
 
@@ -363,21 +363,21 @@ namespace ehs
 		}
 		else
 		{
-			data[size++] = (JsonBase*)new JsonBool(value);
+			data[size++] = (JsonBase *)new JsonBool(value);
 		}
 	}
 
-	void JsonArray::Push(const JsonNum& value)
+	void JsonArray::Push(const JsonNum &value)
 	{
 		if (size + 1 > rawSize)
 		{
 			rawSize = size + extra + 1;
-			JsonBase** result = new JsonBase*[rawSize];
+			JsonBase **result = new JsonBase*[rawSize];
 
 			for (UInt_64 i = 0; i < size; ++i)
 				result[i] = data[i];
 
-			result[size++] = (JsonBase*)new JsonNum(value);
+			result[size++] = (JsonBase *)new JsonNum(value);
 
 			delete[] data;
 
@@ -385,7 +385,7 @@ namespace ehs
 		}
 		else
 		{
-			data[size++] = (JsonBase*)new JsonNum(value);
+			data[size++] = (JsonBase *)new JsonNum(value);
 		}
 	}
 
@@ -394,12 +394,12 @@ namespace ehs
 		if (size + 1 > rawSize)
 		{
 			rawSize = size + extra + 1;
-			JsonBase** result = new JsonBase*[rawSize];
+			JsonBase **result = new JsonBase*[rawSize];
 
 			for (UInt_64 i = 0; i < size; ++i)
 				result[i] = data[i];
 
-			result[size++] = (JsonBase*)new JsonNum(value);
+			result[size++] = (JsonBase *)new JsonNum(value);
 
 			delete[] data;
 
@@ -407,11 +407,11 @@ namespace ehs
 		}
 		else
 		{
-			data[size++] = (JsonBase*)new JsonNum(value);
+			data[size++] = (JsonBase *)new JsonNum(value);
 		}
 	}
 
-	void JsonArray::Push(const JsonStr& value)
+	void JsonArray::Push(const JsonStr &value)
 	{
 		if (size + 1 > rawSize)
 		{
@@ -421,7 +421,7 @@ namespace ehs
 			for (UInt_64 i = 0; i < size; ++i)
 				result[i] = data[i];
 
-			result[size++] = (JsonBase*)new JsonStr(value);
+			result[size++] = (JsonBase *)new JsonStr(value);
 
 			delete[] data;
 
@@ -429,11 +429,11 @@ namespace ehs
 		}
 		else
 		{
-			data[size++] = (JsonBase*)new JsonStr(value);
+			data[size++] = (JsonBase *)new JsonStr(value);
 		}
 	}
 
-	void JsonArray::Push(const Char_8* value, const UInt_64 size)
+	void JsonArray::Push(const Char_8 *value, const UInt_64 size)
 	{
 		if (this->size + 1 > rawSize)
 		{
@@ -443,7 +443,7 @@ namespace ehs
 			for (UInt_64 i = 0; i < this->size; ++i)
 				result[i] = data[i];
 
-			result[this->size++] = (JsonBase*)new JsonStr(Str_8(value, size));
+			result[this->size++] = (JsonBase *)new JsonStr(Str_8(value, size));
 
 			delete[] data;
 
@@ -451,11 +451,11 @@ namespace ehs
 		}
 		else
 		{
-			data[this->size++] = (JsonBase*)new JsonStr(Str_8(value, size));
+			data[this->size++] = (JsonBase *)new JsonStr(Str_8(value, size));
 		}
 	}
 
-	void JsonArray::Push(const Str_8& value)
+	void JsonArray::Push(const Str_8 &value)
 	{
 		if (this->size + 1 > rawSize)
 		{
@@ -465,7 +465,7 @@ namespace ehs
 			for (UInt_64 i = 0; i < this->size; ++i)
 				result[i] = data[i];
 
-			result[this->size++] = (JsonBase*)new JsonStr(value);
+			result[this->size++] = (JsonBase *)new JsonStr(value);
 
 			delete[] data;
 
@@ -473,7 +473,7 @@ namespace ehs
 		}
 		else
 		{
-			data[this->size++] = (JsonBase*)new JsonStr(value);
+			data[this->size++] = (JsonBase *)new JsonStr(value);
 		}
 	}
 
@@ -482,7 +482,7 @@ namespace ehs
 		if (rawSize - --size >= extra * 2)
 			rawSize -= extra;
 
-		JsonBase** result = new JsonBase*[rawSize];
+		JsonBase **result = new JsonBase*[rawSize];
 		for (UInt_64 i = 0; i < size; ++i)
 			result[i] = data[i];
 

src/json/JsonNum.cpp

@@ -71,11 +71,6 @@ namespace ehs
 		return value;
 	}
 
-	JsonNum::operator float&()
-	{
-		return value;
-	}
-
 	Str_8 JsonNum::ToStr(const UInt_64 level, const bool compact) const
 	{
 		Str_8 result;

src/json/JsonObj.cpp

@@ -79,12 +79,7 @@ namespace ehs
 		return *this;
 	}
 
-	JsonObj::operator const JsonVar*() const
-	{
-		return vars;
-	}
-
-	JsonObj::operator JsonVar*()
+	JsonObj::operator JsonVar*() const
 	{
 		return vars;
 	}

src/json/JsonStr.cpp

@@ -13,17 +13,17 @@ namespace ehs
 
 	}
 
-	JsonStr::JsonStr(const Char_8* value, const UInt_64 size)
+	JsonStr::JsonStr(const Char_8 *value, const UInt_64 size)
 			: JsonBase(JsonType::STR), value(value, size)
 	{
 	}
 
-	JsonStr::JsonStr(JsonStr&& js) noexcept
+	JsonStr::JsonStr(JsonStr &&js) noexcept
 		: JsonBase(js), value(std::move(js.value))
 	{
 	}
 
-	JsonStr& JsonStr::operator=(JsonStr&& js) noexcept
+	JsonStr& JsonStr::operator=(JsonStr &&js) noexcept
 	{
 		if (this == &js)
 			return *this;
@@ -40,7 +40,7 @@ namespace ehs
 		return value;
 	}
 
-	JsonStr::operator Str_8&()
+	JsonStr::operator Str_8 &()
 	{
 		return value;
 	}

src/json/JsonVar.cpp

@@ -23,25 +23,25 @@ namespace ehs
 	{
 	}
 
-	JsonVar::JsonVar(Str_8 id, const JsonBase* const value)
+	JsonVar::JsonVar(Str_8 id, const JsonBase * const value)
 		: hashId(id.Hash_64()), id(std::move(id))
 	{
 		switch (value->GetType())
 		{
 			case JsonType::OBJ:
-				this->value = (JsonBase*)new JsonObj(*(JsonObj*)value);
+				this->value = (JsonBase *)new JsonObj(*(JsonObj *)value);
 				break;
 			case JsonType::ARRAY:
-				this->value = (JsonBase*)new JsonArray(*(JsonArray*)value);
+				this->value = (JsonBase *)new JsonArray(*(JsonArray *)value);
 				break;
 			case JsonType::BOOL:
-				this->value = (JsonBase*)new JsonBool(*(JsonBool*)value);
+				this->value = (JsonBase *)new JsonBool(*(JsonBool *)value);
 				break;
 			case JsonType::NUM:
-				this->value = (JsonBase*)new JsonNum(*(JsonNum*)value);
+				this->value = (JsonBase *)new JsonNum(*(JsonNum *)value);
 				break;
 			case JsonType::STR:
-				this->value = (JsonBase*)new JsonStr(*(JsonStr*)value);
+				this->value = (JsonBase *)new JsonStr(*(JsonStr *)value);
 				break;
 			default:
 				this->value = new JsonBase(JsonType::NULLOBJ);
@@ -49,22 +49,22 @@ namespace ehs
 		}
 	}
 
-	JsonVar::JsonVar(Str_8 id, const JsonBase& value)
+	JsonVar::JsonVar(Str_8 id, const JsonBase &value)
 		: hashId(id.Hash_64()), id(std::move(id)), value(new JsonBase(value))
 	{
 	}
 
-	JsonVar::JsonVar(Str_8 id, const JsonObj& value)
+	JsonVar::JsonVar(Str_8 id, const JsonObj &value)
 		: hashId(id.Hash_64()), id(std::move(id)), value((JsonBase*)new JsonObj(value))
 	{
 	}
 
-	JsonVar::JsonVar(Str_8 id, const JsonArray& value)
+	JsonVar::JsonVar(Str_8 id, const JsonArray &value)
 		: hashId(id.Hash_64()), id(std::move(id)), value((JsonBase*)new JsonArray(value))
 	{
 	}
 
-	JsonVar::JsonVar(Str_8 id, const JsonBool& value)
+	JsonVar::JsonVar(Str_8 id, const JsonBool &value)
 		: hashId(id.Hash_64()), id(std::move(id)), value((JsonBase*)new JsonBool(value))
 	{
 	}
@@ -74,7 +74,7 @@ namespace ehs
 	{
 	}
 
-	JsonVar::JsonVar(Str_8 id, const JsonNum& value)
+	JsonVar::JsonVar(Str_8 id, const JsonNum &value)
 		: hashId(id.Hash_64()), id(std::move(id)), value((JsonBase*)new JsonNum(value))
 	{
 	}
@@ -144,14 +144,14 @@ namespace ehs
 	{
 	}
 
-	JsonVar::JsonVar(JsonVar&& var) noexcept
+	JsonVar::JsonVar(JsonVar &&var) noexcept
 		: hashId(var.hashId), id(std::move(var.id)), value(var.value)
 	{
 		var.hashId = 0;
 		var.value = nullptr;
 	}
 
-	JsonVar::JsonVar(const JsonVar& var)
+	JsonVar::JsonVar(const JsonVar &var)
 		: hashId(var.hashId), id(var.id), value(nullptr)
 	{
 		if (!var.value)
@@ -180,7 +180,7 @@ namespace ehs
 		}
 	}
 
-	JsonVar& JsonVar::operator=(JsonVar&& var) noexcept
+	JsonVar& JsonVar::operator=(JsonVar &&var) noexcept
 	{
 		if (this == &var)
 			return *this;
@@ -196,7 +196,7 @@ namespace ehs
 		return *this;
 	}
 
-	JsonVar& JsonVar::operator=(const JsonVar& var)
+	JsonVar& JsonVar::operator=(const JsonVar &var)
 	{
 		if (this == &var)
 			return *this;
@@ -212,19 +212,19 @@ namespace ehs
 		switch (var.value->GetType())
 		{
 			case JsonType::OBJ:
-				value = (JsonBase*)new JsonObj(*(JsonObj*)var.value);
+				value = (JsonBase *)new JsonObj(*(JsonObj *)var.value);
 				break;
 			case JsonType::ARRAY:
-				value = (JsonBase*)new JsonArray(*(JsonArray*)var.value);
+				value = (JsonBase *)new JsonArray(*(JsonArray *)var.value);
 				break;
 			case JsonType::BOOL:
-				value = (JsonBase*)new JsonBool(*(JsonBool*)var.value);
+				value = (JsonBase *)new JsonBool(*(JsonBool *)var.value);
 				break;
 			case JsonType::NUM:
-				value = (JsonBase*)new JsonNum(*(JsonNum*)var.value);
+				value = (JsonBase *)new JsonNum(*(JsonNum *)var.value);
 				break;
 			case JsonType::STR:
-				value = (JsonBase*)new JsonStr(*(JsonStr*)var.value);
+				value = (JsonBase *)new JsonStr(*(JsonStr *)var.value);
 				break;
 			default:
 				value = new JsonBase();
@@ -244,7 +244,7 @@ namespace ehs
 		return id;
 	}
 
-	void JsonVar::SetValue(const JsonBase* const newValue)
+	void JsonVar::SetValue(const JsonBase * const newValue)
 	{
 		if (!newValue)
 			return;
@@ -254,19 +254,19 @@ namespace ehs
 		switch (newValue->GetType())
 		{
 			case JsonType::OBJ:
-				value = (JsonBase*)new JsonObj(*(JsonObj*)newValue);
+				value = (JsonBase *)new JsonObj(*(JsonObj *)newValue);
 				break;
 			case JsonType::ARRAY:
-				value = (JsonBase*)new JsonArray(*(JsonArray*)newValue);
+				value = (JsonBase *)new JsonArray(*(JsonArray *)newValue);
 				break;
 			case JsonType::BOOL:
-				value = (JsonBase*)new JsonBool(*(JsonBool*)newValue);
+				value = (JsonBase *)new JsonBool(*(JsonBool *)newValue);
 				break;
 			case JsonType::NUM:
-				value = (JsonBase*)new JsonNum(*(JsonNum*)newValue);
+				value = (JsonBase *)new JsonNum(*(JsonNum *)newValue);
 				break;
 			case JsonType::STR:
-				value = (JsonBase*)new JsonStr(*(JsonStr*)newValue);
+				value = (JsonBase *)new JsonStr(*(JsonStr *)newValue);
 				break;
 			default:
 				value = new JsonBase();
@@ -274,72 +274,72 @@ namespace ehs
 		}
 	}
 
-	void JsonVar::SetValue(const JsonBase& newValue)
+	void JsonVar::SetValue(const JsonBase &newValue)
 	{
 		delete value;
 		value = new JsonBase(newValue);
 	}
 
-	void JsonVar::SetValue(const JsonObj& newValue)
+	void JsonVar::SetValue(const JsonObj &newValue)
 	{
 		delete value;
-		value = (JsonBase*)new JsonObj(newValue);
+		value = (JsonBase *)new JsonObj(newValue);
 	}
 
-	void JsonVar::SetValue(const JsonArray& newValue)
+	void JsonVar::SetValue(const JsonArray &newValue)
 	{
 		delete value;
-		value = (JsonBase*)new JsonArray(newValue);
+		value = (JsonBase *)new JsonArray(newValue);
 	}
 
-	void JsonVar::SetValue(const JsonBool& newValue)
+	void JsonVar::SetValue(const JsonBool &newValue)
 	{
 		delete value;
-		value = (JsonBase*)new JsonBool(newValue);
+		value = (JsonBase *)new JsonBool(newValue);
 	}
 
 	void JsonVar::SetValue(const bool newValue)
 	{
 		delete value;
-		value = (JsonBase*)new JsonBool(newValue);
+		value = (JsonBase *)new JsonBool(newValue);
 	}
 
-	void JsonVar::SetValue(const JsonNum& newValue)
+	void JsonVar::SetValue(const JsonNum &newValue)
 	{
 		delete value;
-		value = (JsonBase*)new JsonNum(newValue);
+		value = (JsonBase *)new JsonNum(newValue);
 	}
 
 	void JsonVar::SetValue(const float newValue)
 	{
 		delete value;
-		value = (JsonBase*)new JsonNum(newValue);
+		value = (JsonBase *)new JsonNum(newValue);
 	}
 
-	void JsonVar::SetValue(const JsonStr& newValue)
+	void JsonVar::SetValue(const JsonStr &newValue)
 	{
 		delete value;
-		value = (JsonBase*)new JsonStr(newValue);
+		value = (JsonBase *)new JsonStr(newValue);
 	}
 
-	void JsonVar::SetValue(const Char_8* newValue, const UInt_64 size)
+	void JsonVar::SetValue(const Char_8 *newValue, const UInt_64 size)
 	{
 		delete value;
-		value = (JsonBase*)new JsonStr(newValue, size);
+		value = (JsonBase *)new JsonStr(newValue, size);
 	}
 
-	void JsonVar::SetValue(const Str_8& newValue)
+	void JsonVar::SetValue(const Str_8 &newValue)
 	{
 		delete value;
-		value = (JsonBase*)new JsonStr(newValue);
+		value = (JsonBase *)new JsonStr(newValue);
 	}
 
-	const JsonBase* JsonVar::GetValue() const
+	const JsonBase *JsonVar::GetValue() const
 	{
 		return value;
 	}
 
-	JsonBase* JsonVar::GetValue()
+	JsonBase *JsonVar::GetValue()
 	{
 		return value;
 	}

src/system/BaseSystem.cpp

@@ -5,4 +5,14 @@ namespace ehs
 	void BaseSystem::OpenURI(const Str_8& uri)
 	{
 	}
+
+	Str_8 BaseSystem::OpenFileDialog(const Str_8 &dir, const Str_8 &filters)
+	{
+		return {};
+	}
+
+	Str_8 BaseSystem::GetDirDialog(const Str_8 &dir)
+	{
+		return {};
+	}
 }

src/system/System_LNX.cpp

@@ -1,6 +1,9 @@
 #include "ehs/system/System_LNX.h"
+
+#include <cstdlib>
+#include <cstdio>
+
 #include "ehs/system/Thread.h"
-#include "ehs/Log.h"
 
 namespace ehs
 {
@@ -19,4 +22,40 @@ namespace ehs
 		xdg.Start(XDG_Thread, (void*)&uri);
 		xdg.Detach();
 	}
+
+	Str_8 System::OpenFileDialog(const Str_8 &dir, const Str_8 &filters)
+	{
+		FILE *file = popen("kdialog --getopenfilename " + dir + " \'" + filters + "\'", "r");
+
+		Str_8 result;
+
+		char array[128];
+		while(fgets(array, sizeof(array), file))
+			result.Push(array);
+
+		pclose(file);
+
+		if (result.Size())
+			result.Pop();
+
+		return result;
+	}
+
+	Str_8 System::GetDirDialog(const Str_8 &dir)
+	{
+		FILE *file = popen("kdialog --getexistingdirectory " + dir, "r");
+
+		Str_8 result;
+
+		char array[128];
+		while(fgets(array, sizeof(array), file))
+			result.Push(array);
+
+		pclose(file);
+
+		if (result.Size())
+			result.Pop();
+
+		return result;
+	}
 }

vcpkg-configuration.json

@@ -1,14 +0,0 @@
-{
-  "default-registry": {
-    "kind": "git",
-    "baseline": "42bb0d9e8d4cf33485afb9ee2229150f79f61a1f",
-    "repository": "https://github.com/microsoft/vcpkg"
-  },
-  "registries": [
-    {
-      "kind": "artifact",
-      "location": "https://github.com/microsoft/vcpkg-ce-catalog/archive/refs/heads/main.zip",
-      "name": "microsoft"
-    }
-  ]
-}

vcpkg.json

@@ -1,6 +1,8 @@
 {
+  "name": "ehs",
+  "version": "1.0",
   "dependencies": [
-    "openssl",
-    "zlib"
+    "zlib",
+    "openssl"
   ]
 }