Merge pull request 'project setup refactor' (#112) from project_setup_refactor into master

Reviewed-on: https://git.madvoxel.net/OpenVulkano/OpenVulkano/pulls/112
2024-08-19 12:00:50 +02:00
parent 6881537923 14c771854a
commit fc9902f4ac
28 changed files with 970 additions and 205 deletions
--- a/.gitea/workflows/build_pc.yml
+++ b/.gitea/workflows/build_pc.yml
@@ -55,6 +55,6 @@ jobs:
      with:
        submodules: true
    - name: Configure CMake
-      run: mkdir cmake-build && mkdir cmake-build/iOS && cd cmake-build/iOS && cmake ../.. -G Xcode -DCMAKE_TOOLCHAIN_FILE=../../cmake/toolchain/ios.toolchain.cmake -DPLATFORM=OS64 -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}}
+      run: mkdir cmake-build && mkdir cmake-build/iOS && cd cmake-build/iOS && cmake ../.. -G Xcode -DPLATFORM=OS64 -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}}
    - name: Build & Archive
-      run: xcodebuild -project ${{github.workspace}}/cmake-build/iOS/openVulkanoCpp.xcodeproj -scheme openVulkanoCpp -configuration ${{env.BUILD_TYPE}} -archivePath ${{github.workspace}}/cmake-build/iOS/app.xcarchive -sdk iphoneos archive
+      run: xcodebuild -project ${{github.workspace}}/cmake-build/iOS/OpenVulkano.xcodeproj -scheme OpenVulkano_Examples -configuration ${{env.BUILD_TYPE}} -archivePath ${{github.workspace}}/cmake-build/iOS/app.xcarchive -sdk iphoneos archive
--- a/3rdParty/CMakeLists.txt
+++ b/3rdParty/CMakeLists.txt
@@ -35,3 +35,8 @@ add_subdirectory(msdf)
 if (NOT IOS)
    add_subdirectory(curl)
 endif()
+
+if(ENABLE_TEST)
+    add_subdirectory(catch2)
+endif()
+
--- a/3rdParty/catch2/CMakeLists.txt
+++ b/3rdParty/catch2/CMakeLists.txt
@@ -0,0 +1,14 @@
+include (FetchContent)
+
+if(NOT DEFINED CATCH_REPO)
+    set(CATCH_REPO https://github.com/catchorg/Catch2.git)
+endif ()
+
+FetchContent_Declare(
+	Catch2
+	GIT_REPOSITORY ${CATCH_REPO}
+	GIT_TAG v3.6.0
+	GIT_SHALLOW TRUE
+)
+
+FetchContent_MakeAvailable(Catch2)
--- a/3rdParty/curl/CMakeLists.txt
+++ b/3rdParty/curl/CMakeLists.txt
@@ -1,4 +1,4 @@
-include(../../cmake/Utils.cmake)
+include(Utils)

 set(CURL_DEPS_INSTALL ${CMAKE_BINARY_DIR}/deps_curl)
 find_package(CURL QUIET)
@@ -31,18 +31,18 @@ function(LinkCurl TARGET)
    find_package(CURL QUIET)
    if (NOT ${CURL_FOUND})
        set(CURL_DEPS_INSTALL ${CMAKE_BINARY_DIR}/deps_curl)
-        target_include_directories(${TARGET} PRIVATE ${CURL_DEPS_INSTALL}/INSTALL/include)
-        target_link_directories(${TARGET} PRIVATE ${CURL_DEPS_INSTALL}/INSTALL/lib)
+        target_include_directories(${TARGET} PUBLIC ${CURL_DEPS_INSTALL}/INSTALL/include)
+        target_link_directories(${TARGET} PUBLIC ${CURL_DEPS_INSTALL}/INSTALL/lib)

        if (APPLE)
-            target_link_libraries(${TARGET} PRIVATE curl)
+            target_link_libraries(${TARGET} PUBLIC curl)
        elseif (WIN32)
-            target_link_libraries(${TARGET} PRIVATE ${OPENSSL_SSL_LIBRARY} ${OPENSSL_CRYPTO_LIBRARY})
+            target_link_libraries(${TARGET} PUBLIC ${OPENSSL_SSL_LIBRARY} ${OPENSSL_CRYPTO_LIBRARY})
        else ()
-            target_link_libraries(${TARGET} PRIVATE crypto ssl curl)
+            target_link_libraries(${TARGET} PUBLIC crypto ssl curl)
        endif ()
    else ()
-        target_include_directories(${TARGET} PRIVATE ${CURL_INCLUDE_DIR})
-        target_link_libraries(${TARGET} PRIVATE CURL::libcurl)
+        target_include_directories(${TARGET} PUBLIC ${CURL_INCLUDE_DIR})
+        target_link_libraries(${TARGET} PUBLIC CURL::libcurl)
    endif ()
 endfunction()
--- a/3rdParty/imgui/CMakeLists.txt
+++ b/3rdParty/imgui/CMakeLists.txt
@@ -1,4 +1,5 @@
 include(FetchContent)
+include(SetupVulkan)

 if(NOT DEFINED IMGUI_REPO)
    set(IMGUI_REPO https://github.com/ocornut/imgui.git)
@@ -29,7 +30,6 @@ if (glfw_FOUND)
    target_link_libraries(imgui_internal PUBLIC glfw)
 endif ()

-set(NO_SHADERC ON)
 SetupVulkan(imgui_internal)
 target_include_directories(imgui_internal PUBLIC ${Vulkan_INCLUDE_DIR})

--- a/3rdParty/libarchive/CMakeLists.txt
+++ b/3rdParty/libarchive/CMakeLists.txt
@@ -1,4 +1,4 @@
-include(../../cmake/Utils.cmake)
+include(Utils)

 find_package(LibArchive QUIET)
 if (NOT LibArchive_FOUND)
@@ -32,13 +32,14 @@ function(LinkLibArchive TARGET)
    find_package(LibLZMA QUIET)
    find_package(LibXml2 QUIET)
    find_package(EXPAT QUIET)
-    target_include_directories(${TARGET} PRIVATE ${LibArchive_INCLUDE_DIR})
-    target_link_libraries(${TARGET} PRIVATE ${LibArchive_LIBRARIES} ${ZLIB_LIBRARIES} ${zstd_LIBRARIES} ${LZ4_LIBRARIES})
+    target_include_directories(${TARGET} PUBLIC ${LibArchive_INCLUDE_DIR})
+    target_link_libraries(${TARGET} PUBLIC ${LibArchive_LIBRARIES} ${ZLIB_LIBRARIES} ${zstd_LIBRARIES} ${LZ4_LIBRARIES})
+
    if (BZIP2_LIBRARIES)
-        target_link_libraries(${TARGET} PRIVATE ${BZIP2_LIBRARIES})
+        target_link_libraries(${TARGET} PUBLIC ${BZIP2_LIBRARIES})
    endif()
    if (LIBLZMA_LIBRARIES)
-        target_link_libraries(${TARGET} PRIVATE ${LIBLZMA_LIBRARIES})
+        target_link_libraries(${TARGET} PUBLIC ${LIBLZMA_LIBRARIES})
    endif()
    if (LibXml2_FOUND)
    	target_link_libraries(${TARGET} PUBLIC ${LIBXML2_LIBRARIES})
--- a/3rdParty/libarchive/ext/CMakeLists.txt
+++ b/3rdParty/libarchive/ext/CMakeLists.txt
@@ -68,6 +68,10 @@ ExternalProject_Add(lz4
                    -DCMAKE_INSTALL_PREFIX:PATH=${CMAKE_BINARY_DIR}/INSTALL
        )

+if ("${PLATFORM}" STREQUAL "OS64" OR "${PLATFORM}" STREQUAL "OS64COMBINED")
+    set(EXTRA_ARGS -DHAVE__FSEEKI64:BOOL=OFF -DHAVE_FUTIMESAT:BOOL=OFF)
+endif()
+
 ExternalProject_Add(
        libarchive
        DEPENDS zlib zstd lz4
@@ -80,6 +84,7 @@ ExternalProject_Add(
        CMAKE_ARGS
            -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}
            -DPLATFORM=${PLATFORM}
+            -DDEPLOYMENT_TARGET:STRING=14.0
            -DCMAKE_BUILD_TYPE:STRING=Release
            -DBUILD_SHARED_LIBS:BOOL=OFF
            -DENABLE_TEST:BOOL=OFF
@@ -91,7 +96,10 @@ ExternalProject_Add(
            -DENABLE_ICONV:BOOL=OFF
            -DENABLE_LIBB2:BOOL=OFF
            -DENABLE_LIBXML2:BOOL=OFF
+            -DENABLE_UNZIP:BOOL=OFF
+            -DENABLE_EXPAT:BOOL=OFF
            -DZLIB_USE_STATIC_LIBS:BOOL=ON
            -DCMAKE_PREFIX_PATH=${CMAKE_BINARY_DIR}/INSTALL
            -DCMAKE_INSTALL_PREFIX:PATH=${CMAKE_BINARY_DIR}/INSTALL
+            ${EXTRA_ARGS}
 )
--- a/3rdParty/libjpeg-turbo/CMakeLists.txt
+++ b/3rdParty/libjpeg-turbo/CMakeLists.txt
@@ -1,4 +1,4 @@
-include(../../cmake/Utils.cmake)
+include(Utils)

 if (NOT IOS)
    Find_Package(libjpeg-turbo QUIET)
--- a/3rdParty/msdf/CMakeLists.txt
+++ b/3rdParty/msdf/CMakeLists.txt
@@ -14,7 +14,9 @@ if (ENABLE_MSDF)
    endif()

    unset(Freetype_FOUND)
-    find_package(Freetype QUIET)
+    if (NOT APPLE)
+        find_package(Freetype QUIET)
+    endif ()
    if (NOT Freetype_FOUND OR NOT EXISTS "${CMAKE_BINARY_DIR}/_deps/freetype-src/build")
        message("Installing freetype from sources")
        FetchContent_Declare(
@@ -51,8 +53,8 @@ if (ENABLE_MSDF)
        if (NOT ${build_result} EQUAL "0")
            message(FATAL_ERROR "Failed to build freetype!")
        endif()
-        set(FREETYPE_INCLUDE_DIR "${FT_SRC_DIR}/freetype-install/include/freetype2" CACHE INTERNAL "ft include dir")
-        set(FREETYPE_BUILT_FROM_SOURCES ON CACHE BOOL "ft built from sources")
+        set(FREETYPE_INCLUDE_DIR "${FT_SRC_DIR}/freetype-install/include/freetype2" CACHE INTERNAL "ft include dir" FORCE)
+        set(FREETYPE_BUILT_FROM_SOURCES ON CACHE BOOL "ft built from sources" FORCE)
        list(APPEND CMAKE_PREFIX_PATH "${FT_SRC_DIR}/freetype-install")
    endif()

@@ -87,7 +89,7 @@ endif()

 function(LinkMsdf TARGET)
    if (ENABLE_MSDF)
-        target_link_libraries(${TARGET} PRIVATE msdfgen::msdfgen msdfgen::msdfgen-ext msdf-atlas-gen)
+        target_link_libraries(${TARGET} PUBLIC msdfgen::msdfgen msdfgen::msdfgen-ext msdf-atlas-gen)
        if (FREETYPE_BUILT_FROM_SOURCES)
            target_include_directories(${TARGET} PUBLIC ${FREETYPE_INCLUDE_DIR})
        else()
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,141 +1,66 @@
 cmake_minimum_required(VERSION 3.28 FATAL_ERROR)

-option(USE_ASSIMP "If assimp should be used" ON)
-
-include(cmake/VarsFromFile.cmake)
-include(cmake/SetCompilerSettings.cmake)
-include(cmake/SetupVulkan.cmake)
-include(cmake/Filter.cmake)
-include(cmake/AppleHelper.cmake)
-include(cmake/SetShaderDependency.cmake)
-include(cmake/CopyResourcesToExe.cmake)
-
-set(DEPENDENCY_MIRROR_FILE "DependencyMirrors.txt" CACHE STRING "Dependency mirror")
-VarsFromFile("${DEPENDENCY_MIRROR_FILE}") # Load mirror list (for CICD)
+if ("${PLATFORM}" STREQUAL "OS64" OR "${PLATFORM}" STREQUAL "OS64COMBINED")
+    set(ENABLE_ARC OFF)
+    set(DEPLOYMENT_TARGET "14.0")
+    set(CMAKE_TOOLCHAIN_FILE "${CMAKE_SOURCE_DIR}/cmake/toolchain/ios.toolchain.cmake")
+endif ()

 set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)
+set(CMAKE_CXX_STANDARD 20)
+
+set_property(GLOBAL PROPERTY USE_FOLDERS ON)

 if(LINUX)
    find_package(ECM REQUIRED NO_MODULE)
    set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH})
 endif()
-set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/modules" "${CMAKE_SOURCE_DIR}/cmake/functions")

-option(TRACY_ENABLE "Enable Tracy Profiler" OFF)
-option(ENABLE_MSDF "Enable msdf library" ON)
-add_subdirectory(3rdParty)
+include(VarsFromFile)
+include(SetCompilerSettings)
+include(SetupVulkan)
+include(Filter)
+include(AppleHelper)
+include(SetShaderDependency)
+add_compile_definitions(NOMINMAX)
+
+set(DEPENDENCY_MIRROR_FILE "DependencyMirrors.txt" CACHE STRING "Dependency mirror")
+VarsFromFile("${DEPENDENCY_MIRROR_FILE}") # Load mirror list (for CICD)
+
+project (OpenVulkano VERSION 1.0 LANGUAGES C CXX)

-project (openVulkanoCpp VERSION 1.0 LANGUAGES C CXX)
-if(NOT IOS)
-    SetOutputDirs("${CMAKE_SOURCE_DIR}/bin")
-endif()
 SetOptimisationSettings()

-set(BASH_EXECUTABLE "" CACHE FILEPATH "Path to bash executable")
-if ("${BASH_EXECUTABLE}" STREQUAL "")
-    find_program(BASH_PROGRAM bash NO_CACHE REQUIRED)
-    set(BASH_EXECUTABLE ${BASH_PROGRAM} CACHE FILEPATH "Path to bash executable" FORCE)
-endif()
-set(ROOT_FOLDER ${CMAKE_CURRENT_SOURCE_DIR})
-set(SHADER_OUTPUT_DEST ${CMAKE_BINARY_DIR}/GeneratedShaderData)
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/TryCompileShaders.cmake.in ${CMAKE_BINARY_DIR}/TryCompileShaders.cmake @ONLY)
-execute_process(COMMAND ${BASH_EXECUTABLE} CompileShaders.sh "${SHADER_OUTPUT_DEST}" WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/Scripts)
-file(GLOB GENERATED_SHADER_SOURCES "${SHADER_OUTPUT_DEST}/*")
+# ------------------------- CMAKE OPTIONS -------------------------
+option(USE_ASSIMP "If assimp should be used" ON)
+option(TRACY_ENABLE "Enable Tracy Profiler" OFF)
+option(ENABLE_TEST "Enable testing" ON)
+option(ENABLE_EXAMPLE "Enable examples" ON)
+option(ENABLE_MSDF "Enable msdf library" ON)
+option(ENABLE_SHADERC "Enable runtime shader compiler" OFF)
+# -----------------------------------------------------------------

-set(MAIN_FILE examples/main.cpp)
 if (IOS)
-    set(MAIN_FILE examples/Host/iOS/main.mm)
+    set(DEPLOYMENT_TARGET "14.0")
+    set_property(GLOBAL PROPERTY XCODE_ATTRIBUTE_IPHONEOS_DEPLOYMENT_TARGET ${DEPLOYMENT_TARGET})
+    set(CMAKE_OSX_DEPLOYMENT_TARGET ${DEPLOYMENT_TARGET})
+    set(MACOSX_DEPLOYMENT_TARGET ${DEPLOYMENT_TARGET})
 endif ()

-file(GLOB_RECURSE sources CONFIGURE_DEPENDS "openVulkanoCpp/*.h" "openVulkanoCpp/*.c" "openVulkanoCpp/*.hpp" "openVulkanoCpp/*.cpp" "examples/*.hpp" "examples/*.cpp")
+# First generate 3rdParty Libraries
+add_subdirectory(3rdParty)

-if(APPLE)
-    file(GLOB_RECURSE sources_obj CONFIGURE_DEPENDS "openVulkanoCpp/*.mm" "openVulkanoCpp/*.m" "examples/*.m" "examples/*.mm")
-    list(APPEND sources ${sources_obj})
+# Then generate the OpenVulkano Library
+add_subdirectory(openVulkanoCpp)
+
+if(ENABLE_TEST AND NOT IOS)
+    enable_testing()
+    add_subdirectory(tests)
 endif()

-file(GLOB SHADER_SRC_FILES ${ROOT_FOLDER}/openVulkanoCpp/Shader/*)
-list(FILTER SHADER_SRC_FILES EXCLUDE REGEX ".*\\.(hpp|cpp)$")
-
-add_executable(openVulkanoCpp ${MAIN_FILE} ${SHADER_SRC_FILES} ${GENERATED_SHADER_SOURCES})
-
-set_property(GLOBAL PROPERTY USE_FOLDERS ON)
-source_group("Shaders" FILES ${SHADER_SRC_FILES})
-
-FilterPlatformPaths(sources)
-SetWarningSettings(openVulkanoCpp)
-set_property(TARGET openVulkanoCpp PROPERTY CXX_STANDARD 20)
-
-target_sources(openVulkanoCpp PRIVATE ${sources})
-target_include_directories(openVulkanoCpp PUBLIC openVulkanoCpp ${SHADER_OUTPUT_DEST})
-
-# Setup IOS
-if(IOS)
-    set(APP_BUNDLE_IDENTIFIER "eu.georgh93.openVulkano")
-    set(MACOSX_BUNDLE_INFO_STRING ${APP_BUNDLE_IDENTIFIER})
-    set(MACOSX_BUNDLE_GUI_IDENTIFIER ${APP_BUNDLE_IDENTIFIER})
-    set(MACOSX_BUNDLE_BUNDLE_NAME ${APP_BUNDLE_IDENTIFIER})
-
-    set(CMAKE_OSX_DEPLOYMENT_TARGET "16") # The used ARKit features are only available starting with iOS 16
-
-    set(CMAKE_XCODE_EMBED_FRAMEWORKS ON)
-
-    set_target_properties(openVulkanoCpp PROPERTIES
-                          XCODE_ATTRIBUTE_DEVELOPMENT_TEAM "466MGSD624"
-    )
+# Finally generate the tests and examples
+if(ENABLE_EXAMPLE)
+	add_subdirectory(examples)
+	set_property(DIRECTORY ${CMAKE_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT OpenVulkano_Examples)
 endif()
-if(APPLE)
-    LinkAppleFrameworks(openVulkanoCpp)
-endif ()
-
-if (WIN32)
-    # Ws2
-    target_link_libraries(openVulkanoCpp PRIVATE Ws2_32)
-    
-    # grabs libcurl.dll libssl-1_1-x64.dll libcrypto-1_1-x64.dll
-    # TODO: statically link libcurl and it's dependencies
-    file(GLOB_RECURSE DLLS "${CMAKE_BINARY_DIR}/deps_curl/INSTALL/bin/*.dll")
-    foreach(DLL ${DLLS})
-        add_custom_command(TARGET openVulkanoCpp POST_BUILD
-            COMMAND ${CMAKE_COMMAND} -E copy_if_different
-            ${DLL} $<TARGET_FILE_DIR:openVulkanoCpp>
-        )
-    endforeach()
-    
-    set(CURL_STATIC_LIBS ${CMAKE_BINARY_DIR}/deps_curl/deps_curl)
-    file(GLOB_RECURSE LIBS "${CURL_STATIC_LIBS}/*.lib")
-    target_link_libraries(openVulkanoCpp PRIVATE ${LIBS})
-endif ()
-
-SetupVulkan(openVulkanoCpp)
-CopyResourcesToExe(openVulkanoCpp "${CMAKE_CURRENT_SOURCE_DIR}/fonts" ".ttf")
-CopyResourcesToExe(openVulkanoCpp "${CMAKE_CURRENT_SOURCE_DIR}/examples/ExampleSources" "*")
-SetShaderDependency(openVulkanoCpp 
-                    ${CMAKE_CURRENT_SOURCE_DIR}/openVulkanoCpp/Shader
-                    ${SHADER_OUTPUT_DEST})
-
-if (NOT ANDROID AND NOT IOS)
-    target_link_libraries(openVulkanoCpp PRIVATE glfw pugixml)
-    target_link_libraries(openVulkanoCpp PRIVATE ftxui::screen ftxui::dom ftxui::component)
-endif()
-
-list(APPEND CMAKE_PREFIX_PATH ${CMAKE_BINARY_DIR}/deps/INSTALL)
-
-target_link_libraries(openVulkanoCpp PRIVATE magic_enum yaml-cpp fmt spdlog glm pugixml stb eigen utf8cpp imgui_internal
-                      TracyClient stud-uuid ryml unordered_dense Boost::regex units)
-if (NOT IOS)
-    LinkCurl(openVulkanoCpp)
-endif()
-
-add_compile_definitions(LIBARCHIVE_STATIC)
-add_compile_definitions(NOMINMAX)
-add_compile_definitions("DEBUG=$<CONFIG:Debug>")
-
-SetGlmDefines(openVulkanoCpp)
-
-LinkAssimp(openVulkanoCpp)
-LinkLibArchive(openVulkanoCpp)
-LinkLibJpegTurbo(openVulkanoCpp)
-LinkMsdf(openVulkanoCpp)
-
-set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT openVulkanoCpp)
--- a/cmake/functions/AppleHelper.cmake
+++ b/cmake/functions/AppleHelper.cmake
--- a/cmake/functions/CopyResourcesToExe.cmake
+++ b/cmake/functions/CopyResourcesToExe.cmake
--- a/cmake/functions/Filter.cmake
+++ b/cmake/functions/Filter.cmake
--- a/cmake/functions/SetCompilerSettings.cmake
+++ b/cmake/functions/SetCompilerSettings.cmake
@@ -19,16 +19,8 @@ function(SetWarningSettings TARGET)
        if (MSVC)
            add_definitions(-D_CRT_SECURE_NO_WARNINGS)
            set_target_properties(${TARGET} PROPERTIES COMPILE_FLAGS "/wd4068")
+            set_target_properties(${TARGET} PROPERTIES COMPILE_FLAGS "/we4715")
            set_target_properties(${TARGET} PROPERTIES LINK_FLAGS "/ignore:4099")
        endif()
    endif()
-endfunction()
-
-function(SetOutputDirs BASE_DIR)
-    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${BASE_DIR}" PARENT_SCOPE)
-    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE "${BASE_DIR}/release" PARENT_SCOPE)
-    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_MINSIZEREL "${BASE_DIR}/minsizerel" PARENT_SCOPE)
-    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELWITHDEBINFO "${BASE_DIR}/relwithdebinfo" PARENT_SCOPE)
-    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG "${BASE_DIR}/debug" PARENT_SCOPE)
-    set(CMAKE_DEBUG_POSTFIX "d" PARENT_SCOPE)
 endfunction()
--- a/cmake/functions/SetShaderDependency.cmake
+++ b/cmake/functions/SetShaderDependency.cmake
--- a/cmake/functions/SetupVulkan.cmake
+++ b/cmake/functions/SetupVulkan.cmake
@@ -5,9 +5,7 @@ function(SetupVulkan TARGET)
    else ()
        find_package(Vulkan REQUIRED)
        target_link_libraries(${TARGET} PRIVATE Vulkan::Vulkan)
-        if (NO_SHADERC)
-            message("Disable shaderc linking")
-        else()
+        if (ENABLE_SHADERC)
            find_package(Vulkan OPTIONAL_COMPONENTS shaderc_combined)
            if (Vulkan_shaderc_combined_FOUND)
                target_link_libraries(${TARGET} PRIVATE Vulkan::shaderc_combined)
--- a/cmake/functions/Utils.cmake
+++ b/cmake/functions/Utils.cmake
--- a/cmake/functions/VarsFromFile.cmake
+++ b/cmake/functions/VarsFromFile.cmake
--- a/cmake/toolchain/ios.toolchain.cmake
+++ b/cmake/toolchain/ios.toolchain.cmake
@@ -62,12 +62,18 @@
 #    SIMULATOR = Build for x86 i386 iphoneOS Simulator.
 #    SIMULATOR64 = Build for x86_64 iphoneOS Simulator.
 #    SIMULATORARM64 = Build for arm64 iphoneOS Simulator.
+#    SIMULATOR64COMBINED = Build for arm64 x86_64 iphoneOS Simulator. Combined into FAT STATIC lib (supported on 3.14+ of CMakewith "-G Xcode" argument ONLY)
 #    TVOS = Build for arm64 tvOS.
 #    TVOSCOMBINED = Build for arm64 x86_64 tvOS + tvOS Simulator. Combined into FAT STATIC lib (only supported on 3.14+ of CMake with "-G Xcode" argument in combination with the "cmake --install" CMake build step)
 #    SIMULATOR_TVOS = Build for x86_64 tvOS Simulator.
+#    SIMULATORARM64_TVOS = Build for arm64 tvOS Simulator.
+#    VISIONOSCOMBINED = Build for arm64 visionOS + visionOS Simulator. Combined into FAT STATIC lib (only supported on 3.14+ of CMake with "-G Xcode" argument in combination with the "cmake --install" CMake build step)
+#    VISIONOS = Build for arm64 visionOS.
+#    SIMULATOR_VISIONOS = Build for arm64 visionOS Simulator.
 #    WATCHOS = Build for armv7k arm64_32 for watchOS.
 #    WATCHOSCOMBINED = Build for armv7k arm64_32 x86_64 watchOS + watchOS Simulator. Combined into FAT STATIC lib (only supported on 3.14+ of CMake with "-G Xcode" argument in combination with the "cmake --install" CMake build step)
 #    SIMULATOR_WATCHOS = Build for x86_64 for watchOS Simulator.
+#    SIMULATORARM64_WATCHOS = Build for arm64 for watchOS Simulator.
 #    MAC = Build for x86_64 macOS.
 #    MAC_ARM64 = Build for Apple Silicon macOS.
 #    MAC_UNIVERSAL = Combined build for x86_64 and Apple Silicon on macOS.
@@ -75,6 +81,7 @@
 #                   Note: The build argument "MACOSX_DEPLOYMENT_TARGET" can be used to control min-version of macOS
 #    MAC_CATALYST_ARM64 = Build for Apple Silicon macOS with Catalyst support (iOS toolchain on macOS).
 #                         Note: The build argument "MACOSX_DEPLOYMENT_TARGET" can be used to control min-version of macOS
+#    MAC_CATALYST_UNIVERSAL = Combined build for x86_64 and Apple Silicon on Catalyst.
 #
 # CMAKE_OSX_SYSROOT: Path to the SDK to use.  By default this is
 #    automatically determined from PLATFORM and xcodebuild, but
@@ -85,13 +92,13 @@
 #    CMAKE_OSX_SYSROOT, but can also be manually specified (although this should
 #    not be required).
 #
-# DEPLOYMENT_TARGET: Minimum SDK version to target. Default 2.0 on watchOS and 9.0 on tvOS+iOS
+# DEPLOYMENT_TARGET: Minimum SDK version to target. Default 6.0 on watchOS, 13.0 on tvOS+iOS/iPadOS, 11.0 on macOS, 1.0 on visionOS
 #
 # NAMED_LANGUAGE_SUPPORT:
 #    ON (default) = Will require "enable_language(OBJC) and/or enable_language(OBJCXX)" for full OBJC|OBJCXX support
 #    OFF = Will embed the OBJC and OBJCXX flags into the CMAKE_C_FLAGS and CMAKE_CXX_FLAGS (legacy behavior, CMake version < 3.16)
 #
-# ENABLE_BITCODE: (ON|OFF) Enables or disables bitcode support. Default ON
+# ENABLE_BITCODE: (ON|OFF) Enables or disables bitcode support. Default OFF
 #
 # ENABLE_ARC: (ON|OFF) Enables or disables ARC support. Default ON (ARC enabled by default)
 #
@@ -108,13 +115,16 @@
 #    SIMULATORARM64 = arm64
 #    TVOS = arm64
 #    SIMULATOR_TVOS = x86_64 (i386 has since long been deprecated)
+#    SIMULATORARM64_TVOS = arm64
 #    WATCHOS = armv7k arm64_32 (if applicable)
 #    SIMULATOR_WATCHOS = x86_64 (i386 has since long been deprecated)
+#    SIMULATORARM64_WATCHOS = arm64
 #    MAC = x86_64
 #    MAC_ARM64 = arm64
 #    MAC_UNIVERSAL = x86_64 arm64
 #    MAC_CATALYST = x86_64
 #    MAC_CATALYST_ARM64 = arm64
+#    MAC_CATALYST_UNIVERSAL = x86_64 arm64
 #
 # NOTE: When manually specifying ARCHS, put a semi-colon between the entries. E.g., -DARCHS="armv7;arm64"
 #
@@ -146,18 +156,20 @@
 cmake_minimum_required(VERSION 3.8.0)

 # CMake invokes the toolchain file twice during the first build, but only once during subsequent rebuilds.
-if(DEFINED ENV{_IOS_TOOLCHAIN_HAS_RUN})
+# NOTE: To improve single-library build-times, provide the flag "OS_SINGLE_BUILD" as a build argument.
+if(DEFINED OS_SINGLE_BUILD AND DEFINED ENV{_IOS_TOOLCHAIN_HAS_RUN})
  return()
 endif()
 set(ENV{_IOS_TOOLCHAIN_HAS_RUN} true)

 # List of supported platform values
 list(APPEND _supported_platforms
-        "OS" "OS64" "OS64COMBINED" "SIMULATOR" "SIMULATOR64" "SIMULATORARM64"
-        "TVOS" "TVOSCOMBINED" "SIMULATOR_TVOS"
-        "WATCHOS" "WATCHOSCOMBINED" "SIMULATOR_WATCHOS"
+        "OS" "OS64" "OS64COMBINED" "SIMULATOR" "SIMULATOR64" "SIMULATORARM64" "SIMULATOR64COMBINED"
+        "TVOS" "TVOSCOMBINED" "SIMULATOR_TVOS" "SIMULATORARM64_TVOS"
+        "WATCHOS" "WATCHOSCOMBINED" "SIMULATOR_WATCHOS" "SIMULATORARM64_WATCHOS"
        "MAC" "MAC_ARM64" "MAC_UNIVERSAL"
-        "MAC_CATALYST" "MAC_CATALYST_ARM64")
+        "VISIONOS" "SIMULATOR_VISIONOS" "VISIONOSCOMBINED" 
+        "MAC_CATALYST" "MAC_CATALYST_ARM64" "MAC_CATALYST_UNIVERSAL")

 # Cache what generator is used
 set(USED_CMAKE_GENERATOR "${CMAKE_GENERATOR}")
@@ -193,10 +205,10 @@ endif()

 # Assuming that xcode 12.0 is installed you most probably have ios sdk 14.0 or later installed (tested on Big Sur)
 # if you don't set a deployment target it will be set the way you only get 64-bit builds
-if(NOT DEFINED DEPLOYMENT_TARGET AND XCODE_VERSION_INT VERSION_GREATER 12.0)
-  # Temporarily fix the arm64 issues in CMake install-combined by excluding arm64 for simulator builds (needed for Apple Silicon...)
-  set(CMAKE_XCODE_ATTRIBUTE_EXCLUDED_ARCHS[sdk=iphonesimulator*] "arm64")
-endif()
+#if(NOT DEFINED DEPLOYMENT_TARGET AND XCODE_VERSION_INT VERSION_GREATER 12.0)
+# Temporarily fix the arm64 issues in CMake install-combined by excluding arm64 for simulator builds (needed for Apple Silicon...)
+#  set(CMAKE_XCODE_ATTRIBUTE_EXCLUDED_ARCHS[sdk=iphonesimulator*] "arm64")
+#endif()

 # Check if the platform variable is set
 if(DEFINED PLATFORM)
@@ -221,7 +233,7 @@ if("${contains_PLATFORM}" EQUAL "-1")
 endif()

 # Check if Apple Silicon is supported
-if(PLATFORM MATCHES "^(MAC_ARM64)$|^(MAC_CATALYST_ARM64)$|^(MAC_UNIVERSAL)$" AND ${CMAKE_VERSION} VERSION_LESS "3.19.5")
+if(PLATFORM MATCHES "^(MAC_ARM64)$|^(MAC_CATALYST_ARM64)$|^(MAC_UNIVERSAL)$|^(MAC_CATALYST_UNIVERSAL)$" AND ${CMAKE_VERSION} VERSION_LESS "3.19.5")
  message(FATAL_ERROR "Apple Silicon builds requires a minimum of CMake 3.19.5")
 endif()

@@ -253,22 +265,25 @@ set(NAMED_LANGUAGE_SUPPORT_INT ${NAMED_LANGUAGE_SUPPORT} CACHE BOOL
 if(NOT DEFINED DEPLOYMENT_TARGET)
  if (PLATFORM MATCHES "WATCHOS")
    # Unless specified, SDK version 4.0 is used by default as minimum target version (watchOS).
-    set(DEPLOYMENT_TARGET "4.0")
+    set(DEPLOYMENT_TARGET "6.0")
  elseif(PLATFORM STREQUAL "MAC")
    # Unless specified, SDK version 10.13 (High Sierra) is used by default as the minimum target version (macos).
-    set(DEPLOYMENT_TARGET "10.13")
+    set(DEPLOYMENT_TARGET "11.0")
+  elseif(PLATFORM STREQUAL "VISIONOS" OR PLATFORM STREQUAL "SIMULATOR_VISIONOS" OR PLATFORM STREQUAL "VISIONOSCOMBINED")
+    # Unless specified, SDK version 1.0 is used by default as minimum target version (visionOS).
+    set(DEPLOYMENT_TARGET "1.0")
  elseif(PLATFORM STREQUAL "MAC_ARM64")
    # Unless specified, SDK version 11.0 (Big Sur) is used by default as the minimum target version (macOS on arm).
    set(DEPLOYMENT_TARGET "11.0")
  elseif(PLATFORM STREQUAL "MAC_UNIVERSAL")
    # Unless specified, SDK version 11.0 (Big Sur) is used by default as minimum target version for universal builds.
    set(DEPLOYMENT_TARGET "11.0")
-  elseif(PLATFORM STREQUAL "MAC_CATALYST" OR PLATFORM STREQUAL "MAC_CATALYST_ARM64")
+  elseif(PLATFORM STREQUAL "MAC_CATALYST" OR PLATFORM STREQUAL "MAC_CATALYST_ARM64" OR PLATFORM STREQUAL "MAC_CATALYST_UNIVERSAL")
    # Unless specified, SDK version 13.0 is used by default as the minimum target version (mac catalyst minimum requirement).
    set(DEPLOYMENT_TARGET "13.1")
  else()
    # Unless specified, SDK version 11.0 is used by default as the minimum target version (iOS, tvOS).
-    set(DEPLOYMENT_TARGET "11.0")
+    set(DEPLOYMENT_TARGET "13.0")
  endif()
  message(STATUS "[DEFAULTS] Using the default min-version since DEPLOYMENT_TARGET not provided!")
 elseif(DEFINED DEPLOYMENT_TARGET AND PLATFORM MATCHES "^MAC_CATALYST" AND ${DEPLOYMENT_TARGET} VERSION_LESS "13.1")
@@ -319,12 +334,12 @@ elseif(PLATFORM_INT STREQUAL "OS64COMBINED")
  set(SDK_NAME iphoneos)
  if(MODERN_CMAKE)
    if(NOT ARCHS)
-      if (XCODE_VERSION_INT VERSION_GREATER 10.0)
-        set(ARCHS arm64 x86_64) # FIXME: Add arm64e when Apple has fixed the integration issues with it, libarclite_iphoneos.a is currently missing bitcode markers for example
+      if (XCODE_VERSION_INT VERSION_GREATER 12.0)
+        set(ARCHS arm64 x86_64)
        set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=iphoneos*] "arm64")
-        set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=iphonesimulator*] "x86_64")
+        set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=iphonesimulator*] "x86_64 arm64")
        set(CMAKE_XCODE_ATTRIBUTE_VALID_ARCHS[sdk=iphoneos*] "arm64")
-        set(CMAKE_XCODE_ATTRIBUTE_VALID_ARCHS[sdk=iphonesimulator*] "x86_64")
+        set(CMAKE_XCODE_ATTRIBUTE_VALID_ARCHS[sdk=iphonesimulator*] "x86_64 arm64")
      else()
        set(ARCHS arm64 x86_64)
        set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=iphoneos*] "arm64")
@@ -339,6 +354,30 @@ elseif(PLATFORM_INT STREQUAL "OS64COMBINED")
  else()
    message(FATAL_ERROR "Please make sure that you are running CMake 3.14+ to make the OS64COMBINED setting work")
  endif()
+elseif(PLATFORM_INT STREQUAL "SIMULATOR64COMBINED")
+  set(SDK_NAME iphonesimulator)
+  if(MODERN_CMAKE)
+    if(NOT ARCHS)
+      if (XCODE_VERSION_INT VERSION_GREATER 12.0)
+        set(ARCHS arm64 x86_64) # FIXME: Add arm64e when Apple have fixed the integration issues with it, libarclite_iphoneos.a is currently missing bitcode markers for example
+        set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=iphoneos*] "")
+        set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=iphonesimulator*] "x86_64 arm64")
+        set(CMAKE_XCODE_ATTRIBUTE_VALID_ARCHS[sdk=iphoneos*] "")
+        set(CMAKE_XCODE_ATTRIBUTE_VALID_ARCHS[sdk=iphonesimulator*] "x86_64 arm64")
+      else()
+        set(ARCHS arm64 x86_64)
+        set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=iphoneos*] "")
+        set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=iphonesimulator*] "x86_64")
+        set(CMAKE_XCODE_ATTRIBUTE_VALID_ARCHS[sdk=iphoneos*] "")
+        set(CMAKE_XCODE_ATTRIBUTE_VALID_ARCHS[sdk=iphonesimulator*] "x86_64")
+      endif()
+      set(APPLE_TARGET_TRIPLE_INT aarch64-x86_64-apple-ios${DEPLOYMENT_TARGET}-simulator)
+    else()
+      set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-ios${DEPLOYMENT_TARGET}-simulator)
+    endif()
+  else()
+    message(FATAL_ERROR "Please make sure that you are running CMake 3.14+ to make the SIMULATOR64COMBINED setting work")
+  endif()
 elseif(PLATFORM_INT STREQUAL "SIMULATOR")
  set(SDK_NAME iphonesimulator)
  if(NOT ARCHS)
@@ -379,9 +418,9 @@ elseif (PLATFORM_INT STREQUAL "TVOSCOMBINED")
      set(ARCHS arm64 x86_64)
      set(APPLE_TARGET_TRIPLE_INT arm64-x86_64-apple-tvos${DEPLOYMENT_TARGET})
      set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=appletvos*] "arm64")
-      set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=appletvsimulator*] "x86_64")
+      set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=appletvsimulator*] "x86_64 arm64")
      set(CMAKE_XCODE_ATTRIBUTE_VALID_ARCHS[sdk=appletvos*] "arm64")
-      set(CMAKE_XCODE_ATTRIBUTE_VALID_ARCHS[sdk=appletvsimulator*] "x86_64")
+      set(CMAKE_XCODE_ATTRIBUTE_VALID_ARCHS[sdk=appletvsimulator*] "x86_64 arm64")
    else()
      set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-tvos${DEPLOYMENT_TARGET})
    endif()
@@ -396,6 +435,14 @@ elseif(PLATFORM_INT STREQUAL "SIMULATOR_TVOS")
  else()
    set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-tvos${DEPLOYMENT_TARGET}-simulator)
  endif()
+elseif(PLATFORM_INT STREQUAL "SIMULATORARM64_TVOS")
+  set(SDK_NAME appletvsimulator)
+  if(NOT ARCHS)
+    set(ARCHS arm64)
+    set(APPLE_TARGET_TRIPLE_INT arm64-apple-tvos${DEPLOYMENT_TARGET}-simulator)
+  else()
+    set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-tvos${DEPLOYMENT_TARGET}-simulator)
+  endif()
 elseif(PLATFORM_INT STREQUAL "WATCHOS")
  set(SDK_NAME watchos)
  if(NOT ARCHS)
@@ -442,6 +489,44 @@ elseif(PLATFORM_INT STREQUAL "SIMULATOR_WATCHOS")
  else()
    set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-watchos${DEPLOYMENT_TARGET}-simulator)
  endif()
+elseif(PLATFORM_INT STREQUAL "SIMULATORARM64_WATCHOS")
+  set(SDK_NAME watchsimulator)
+  if(NOT ARCHS)
+    set(ARCHS arm64)
+    set(APPLE_TARGET_TRIPLE_INT arm64-apple-watchos${DEPLOYMENT_TARGET}-simulator)
+  else()
+    set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-watchos${DEPLOYMENT_TARGET}-simulator)
+  endif()
+elseif(PLATFORM_INT STREQUAL "SIMULATOR_VISIONOS")
+  set(SDK_NAME xrsimulator)
+  if(NOT ARCHS)
+    set(ARCHS arm64)
+    set(APPLE_TARGET_TRIPLE_INT arm64-apple-xros${DEPLOYMENT_TARGET}-simulator)
+  else()
+    set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-xros${DEPLOYMENT_TARGET}-simulator)
+  endif()
+elseif(PLATFORM_INT STREQUAL "VISIONOS")
+  set(SDK_NAME xros)
+  if(NOT ARCHS)
+    set(ARCHS arm64)
+    set(APPLE_TARGET_TRIPLE_INT arm64-apple-xros${DEPLOYMENT_TARGET})
+  else()
+    set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-xros${DEPLOYMENT_TARGET})
+  endif()
+elseif(PLATFORM_INT STREQUAL "VISIONOSCOMBINED")
+  set(SDK_NAME xros)
+  if(MODERN_CMAKE)
+    if(NOT ARCHS)
+      set(ARCHS arm64)
+      set(APPLE_TARGET_TRIPLE_INT arm64-apple-xros${DEPLOYMENT_TARGET})
+      set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=xros*] "arm64")
+      set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=xrsimulator*] "arm64")
+    else()
+      set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-xros${DEPLOYMENT_TARGET})
+    endif()
+  else()
+    message(FATAL_ERROR "Please make sure that you are running CMake 3.14+ to make the VISIONOSCOMBINED setting work")
+  endif()
 elseif(PLATFORM_INT STREQUAL "MAC" OR PLATFORM_INT STREQUAL "MAC_CATALYST")
  set(SDK_NAME macosx)
  if(NOT ARCHS)
@@ -471,6 +556,13 @@ elseif(PLATFORM_INT STREQUAL "MAC_UNIVERSAL")
  endif()
  string(REPLACE ";" "-" ARCHS_SPLIT "${ARCHS}")
  set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-macosx${DEPLOYMENT_TARGET})
+elseif(PLATFORM_INT STREQUAL "MAC_CATALYST_UNIVERSAL")
+  set(SDK_NAME macosx)
+  if(NOT ARCHS)
+    set(ARCHS "x86_64;arm64")
+  endif()
+  string(REPLACE ";" "-" ARCHS_SPLIT "${ARCHS}")
+  set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-ios${DEPLOYMENT_TARGET}-macabi)
 else()
  message(FATAL_ERROR "Invalid PLATFORM: ${PLATFORM_INT}")
 endif()
@@ -484,7 +576,7 @@ endif()
 if(CMAKE_GENERATOR MATCHES "Xcode" AND PLATFORM_INT MATCHES "^MAC_CATALYST")
  set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++")
  set(CMAKE_XCODE_ATTRIBUTE_SUPPORTED_PLATFORMS "macosx")
-  set(CMAKE_XCODE_EFFECTIVE_PLATFORMS "-maccatalyst")
+  set(CMAKE_XCODE_ATTRIBUTE_SUPPORTS_MACCATALYST "YES")
  if(NOT DEFINED MACOSX_DEPLOYMENT_TARGET)
    set(CMAKE_XCODE_ATTRIBUTE_MACOSX_DEPLOYMENT_TARGET "10.15")
  else()
@@ -526,12 +618,8 @@ elseif(DEFINED CMAKE_OSX_SYSROOT_INT)
 endif()

 # Use bitcode or not
-if(NOT DEFINED ENABLE_BITCODE AND NOT ARCHS MATCHES "((^|;|, )(i386|x86_64))+")
-  # Unless specified, enable bitcode support by default
-  message(STATUS "[DEFAULTS] Enabling bitcode support by default. ENABLE_BITCODE not provided!")
-  set(ENABLE_BITCODE ON)
-elseif(NOT DEFINED ENABLE_BITCODE)
-  message(STATUS "[DEFAULTS] Disabling bitcode support by default on simulators. ENABLE_BITCODE not provided for override!")
+if(NOT DEFINED ENABLE_BITCODE)
+  message(STATUS "[DEFAULTS] Disabling bitcode support by default. ENABLE_BITCODE not provided for override!")
  set(ENABLE_BITCODE OFF)
 endif()
 set(ENABLE_BITCODE_INT ${ENABLE_BITCODE} CACHE BOOL
@@ -647,6 +735,10 @@ endforeach()
 if(MODERN_CMAKE)
  if(SDK_NAME MATCHES "iphone")
    set(CMAKE_SYSTEM_NAME iOS)
+  elseif(SDK_NAME MATCHES "xros")
+      set(CMAKE_SYSTEM_NAME visionOS)
+  elseif(SDK_NAME MATCHES "xrsimulator")
+      set(CMAKE_SYSTEM_NAME visionOS)
  elseif(SDK_NAME MATCHES "macosx")
    set(CMAKE_SYSTEM_NAME Darwin)
  elseif(SDK_NAME MATCHES "appletv")
@@ -656,8 +748,14 @@ if(MODERN_CMAKE)
  endif()
  # Provide flags for a combined FAT library build on newer CMake versions
  if(PLATFORM_INT MATCHES ".*COMBINED")
-    set(CMAKE_XCODE_ATTRIBUTE_ONLY_ACTIVE_ARCH "NO")
    set(CMAKE_IOS_INSTALL_COMBINED YES)
+    if(CMAKE_GENERATOR MATCHES "Xcode")
+      # Set the SDKROOT Xcode properties to a Xcode-friendly value (the SDK_NAME, E.g, iphoneos)
+      # This way, Xcode will automatically switch between the simulator and device SDK when building.
+      set(CMAKE_XCODE_ATTRIBUTE_SDKROOT "${SDK_NAME}")
+      # Force to not build just one ARCH, but all!
+      set(CMAKE_XCODE_ATTRIBUTE_ONLY_ACTIVE_ARCH "NO")
+    endif()
  endif()
 elseif(NOT DEFINED CMAKE_SYSTEM_NAME AND ${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.10")
  # Legacy code path prior to CMake 3.14 or fallback if no CMAKE_SYSTEM_NAME specified
@@ -673,9 +771,12 @@ set(APPLE ON CACHE BOOL "")
 if(PLATFORM STREQUAL "MAC" OR PLATFORM STREQUAL "MAC_ARM64" OR PLATFORM STREQUAL "MAC_UNIVERSAL")
  set(IOS OFF CACHE BOOL "")
  set(MACOS ON CACHE BOOL "")
-elseif(PLATFORM STREQUAL "MAC_CATALYST" OR PLATFORM STREQUAL "MAC_CATALYST_ARM64")
+elseif(PLATFORM STREQUAL "MAC_CATALYST" OR PLATFORM STREQUAL "MAC_CATALYST_ARM64" OR PLATFORM STREQUAL "MAC_CATALYST_UNIVERSAL")
  set(IOS ON CACHE BOOL "")
  set(MACOS ON CACHE BOOL "")
+elseif(PLATFORM STREQUAL "VISIONOS" OR PLATFORM STREQUAL "SIMULATOR_VISIONOS" OR PLATFORM STREQUAL "VISIONOSCOMBINED")
+  set(IOS OFF CACHE BOOL "")
+  set(VISIONOS ON CACHE BOOL "")
 else()
  set(IOS ON CACHE BOOL "")
 endif()
@@ -690,8 +791,10 @@ if (NOT DEFINED CMAKE_MACOSX_BUNDLE)
  set(CMAKE_MACOSX_BUNDLE YES)
 endif()
 set(CMAKE_XCODE_ATTRIBUTE_CODE_SIGNING_REQUIRED "NO")
+set(CMAKE_XCODE_ATTRIBUTE_CODE_SIGNING_ALLOWED "NO")
 set(CMAKE_SHARED_LIBRARY_PREFIX "lib")
 set(CMAKE_SHARED_LIBRARY_SUFFIX ".dylib")
+set(CMAKE_EXTRA_SHARED_LIBRARY_SUFFIXES ".tbd" ".so")
 set(CMAKE_SHARED_MODULE_PREFIX "lib")
 set(CMAKE_SHARED_MODULE_SUFFIX ".so")
 set(CMAKE_C_COMPILER_ABI ELF)
@@ -738,12 +841,18 @@ if(${CMAKE_VERSION} VERSION_LESS "3.11")
  elseif(PLATFORM_INT STREQUAL "SIMULATOR_TVOS")
    set(SDK_NAME_VERSION_FLAGS
            "-mtvos-simulator-version-min=${DEPLOYMENT_TARGET}")
+elseif(PLATFORM_INT STREQUAL "SIMULATORARM64_TVOS")
+    set(SDK_NAME_VERSION_FLAGS
+            "-mtvos-simulator-version-min=${DEPLOYMENT_TARGET}")
  elseif(PLATFORM_INT STREQUAL "WATCHOS")
    set(SDK_NAME_VERSION_FLAGS
            "-mwatchos-version-min=${DEPLOYMENT_TARGET}")
  elseif(PLATFORM_INT STREQUAL "SIMULATOR_WATCHOS")
    set(SDK_NAME_VERSION_FLAGS
            "-mwatchos-simulator-version-min=${DEPLOYMENT_TARGET}")
+  elseif(PLATFORM_INT STREQUAL "SIMULATORARM64_WATCHOS")
+    set(SDK_NAME_VERSION_FLAGS
+            "-mwatchos-simulator-version-min=${DEPLOYMENT_TARGET}")
  elseif(PLATFORM_INT STREQUAL "MAC")
    set(SDK_NAME_VERSION_FLAGS
            "-mmacosx-version-min=${DEPLOYMENT_TARGET}")
@@ -754,7 +863,7 @@ if(${CMAKE_VERSION} VERSION_LESS "3.11")
  endif()
 elseif(NOT PLATFORM_INT MATCHES "^MAC_CATALYST")
  # Newer versions of CMake sets the version min flags correctly, skip this for Mac Catalyst targets
-  set(CMAKE_OSX_DEPLOYMENT_TARGET ${DEPLOYMENT_TARGET})
+  set(CMAKE_OSX_DEPLOYMENT_TARGET ${DEPLOYMENT_TARGET} CACHE INTERNAL "Minimum OS X deployment version")
 endif()

 if(DEFINED APPLE_TARGET_TRIPLE_INT)
@@ -815,35 +924,44 @@ endif()
 if(CMAKE_GENERATOR MATCHES "Xcode")
  message(STATUS "Not setting any manual command-line buildflags, since Xcode is selected as the generator. Modifying the Xcode build-settings directly instead.")
 else()
-  set(CMAKE_C_FLAGS "${C_TARGET_FLAGS} ${APPLE_TARGET_TRIPLE_FLAG} ${SDK_NAME_VERSION_FLAGS} ${OBJC_LEGACY_VARS} ${BITCODE} ${VISIBILITY} ${CMAKE_C_FLAGS}")
+  set(CMAKE_C_FLAGS "${C_TARGET_FLAGS} ${APPLE_TARGET_TRIPLE_FLAG} ${SDK_NAME_VERSION_FLAGS} ${OBJC_LEGACY_VARS} ${BITCODE} ${VISIBILITY} ${CMAKE_C_FLAGS}" CACHE INTERNAL
+     "Flags used by the compiler during all C build types.")
  set(CMAKE_C_FLAGS_DEBUG "-O0 -g ${CMAKE_C_FLAGS_DEBUG}")
  set(CMAKE_C_FLAGS_MINSIZEREL "-DNDEBUG -Os ${CMAKE_C_FLAGS_MINSIZEREL}")
  set(CMAKE_C_FLAGS_RELWITHDEBINFO "-DNDEBUG -O2 -g ${CMAKE_C_FLAGS_RELWITHDEBINFO}")
  set(CMAKE_C_FLAGS_RELEASE "-DNDEBUG -O3 ${CMAKE_C_FLAGS_RELEASE}")
-  set(CMAKE_CXX_FLAGS "${C_TARGET_FLAGS} ${APPLE_TARGET_TRIPLE_FLAG} ${SDK_NAME_VERSION_FLAGS} ${OBJC_LEGACY_VARS} ${BITCODE} ${VISIBILITY} ${CMAKE_CXX_FLAGS}")
+  set(CMAKE_CXX_FLAGS "${C_TARGET_FLAGS} ${APPLE_TARGET_TRIPLE_FLAG} ${SDK_NAME_VERSION_FLAGS} ${OBJC_LEGACY_VARS} ${BITCODE} ${VISIBILITY} ${CMAKE_CXX_FLAGS}" CACHE INTERNAL
+     "Flags used by the compiler during all CXX build types.")
  set(CMAKE_CXX_FLAGS_DEBUG "-O0 -g ${CMAKE_CXX_FLAGS_DEBUG}")
  set(CMAKE_CXX_FLAGS_MINSIZEREL "-DNDEBUG -Os ${CMAKE_CXX_FLAGS_MINSIZEREL}")
  set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-DNDEBUG -O2 -g ${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
  set(CMAKE_CXX_FLAGS_RELEASE "-DNDEBUG -O3 ${CMAKE_CXX_FLAGS_RELEASE}")
  if(NAMED_LANGUAGE_SUPPORT_INT)
-    set(CMAKE_OBJC_FLAGS "${C_TARGET_FLAGS} ${APPLE_TARGET_TRIPLE_FLAG} ${SDK_NAME_VERSION_FLAGS} ${BITCODE} ${VISIBILITY} ${FOBJC_ARC} ${OBJC_VARS} ${CMAKE_OBJC_FLAGS}")
+    set(CMAKE_OBJC_FLAGS "${C_TARGET_FLAGS} ${APPLE_TARGET_TRIPLE_FLAG} ${SDK_NAME_VERSION_FLAGS} ${BITCODE} ${VISIBILITY} ${FOBJC_ARC} ${OBJC_VARS} ${CMAKE_OBJC_FLAGS}" CACHE INTERNAL
+     "Flags used by the compiler during all OBJC build types.")
    set(CMAKE_OBJC_FLAGS_DEBUG "-O0 -g ${CMAKE_OBJC_FLAGS_DEBUG}")
    set(CMAKE_OBJC_FLAGS_MINSIZEREL "-DNDEBUG -Os ${CMAKE_OBJC_FLAGS_MINSIZEREL}")
    set(CMAKE_OBJC_FLAGS_RELWITHDEBINFO "-DNDEBUG -O2 -g ${CMAKE_OBJC_FLAGS_RELWITHDEBINFO}")
    set(CMAKE_OBJC_FLAGS_RELEASE "-DNDEBUG -O3 ${CMAKE_OBJC_FLAGS_RELEASE}")
-    set(CMAKE_OBJCXX_FLAGS "${C_TARGET_FLAGS} ${APPLE_TARGET_TRIPLE_FLAG} ${SDK_NAME_VERSION_FLAGS} ${BITCODE} ${VISIBILITY} ${FOBJC_ARC} ${OBJC_VARS} ${CMAKE_OBJCXX_FLAGS}")
+    set(CMAKE_OBJCXX_FLAGS "${C_TARGET_FLAGS} ${APPLE_TARGET_TRIPLE_FLAG} ${SDK_NAME_VERSION_FLAGS} ${BITCODE} ${VISIBILITY} ${FOBJC_ARC} ${OBJC_VARS} ${CMAKE_OBJCXX_FLAGS}" CACHE INTERNAL
+     "Flags used by the compiler during all OBJCXX build types.")
    set(CMAKE_OBJCXX_FLAGS_DEBUG "-O0 -g ${CMAKE_OBJCXX_FLAGS_DEBUG}")
    set(CMAKE_OBJCXX_FLAGS_MINSIZEREL "-DNDEBUG -Os ${CMAKE_OBJCXX_FLAGS_MINSIZEREL}")
    set(CMAKE_OBJCXX_FLAGS_RELWITHDEBINFO "-DNDEBUG -O2 -g ${CMAKE_OBJCXX_FLAGS_RELWITHDEBINFO}")
    set(CMAKE_OBJCXX_FLAGS_RELEASE "-DNDEBUG -O3 ${CMAKE_OBJCXX_FLAGS_RELEASE}")
  endif()
-  set(CMAKE_C_LINK_FLAGS "${C_TARGET_FLAGS} ${SDK_NAME_VERSION_FLAGS} -Wl,-search_paths_first ${CMAKE_C_LINK_FLAGS}")
-  set(CMAKE_CXX_LINK_FLAGS "${C_TARGET_FLAGS} ${SDK_NAME_VERSION_FLAGS}  -Wl,-search_paths_first ${CMAKE_CXX_LINK_FLAGS}")
+  set(CMAKE_C_LINK_FLAGS "${C_TARGET_FLAGS} ${SDK_NAME_VERSION_FLAGS} -Wl,-search_paths_first ${CMAKE_C_LINK_FLAGS}" CACHE INTERNAL
+     "Flags used by the compiler for all C link types.")
+  set(CMAKE_CXX_LINK_FLAGS "${C_TARGET_FLAGS} ${SDK_NAME_VERSION_FLAGS}  -Wl,-search_paths_first ${CMAKE_CXX_LINK_FLAGS}" CACHE INTERNAL
+     "Flags used by the compiler for all CXX link types.")
  if(NAMED_LANGUAGE_SUPPORT_INT)
-    set(CMAKE_OBJC_LINK_FLAGS "${C_TARGET_FLAGS} ${SDK_NAME_VERSION_FLAGS} -Wl,-search_paths_first ${CMAKE_OBJC_LINK_FLAGS}")
-    set(CMAKE_OBJCXX_LINK_FLAGS "${C_TARGET_FLAGS} ${SDK_NAME_VERSION_FLAGS} -Wl,-search_paths_first ${CMAKE_OBJCXX_LINK_FLAGS}")
+    set(CMAKE_OBJC_LINK_FLAGS "${C_TARGET_FLAGS} ${SDK_NAME_VERSION_FLAGS} -Wl,-search_paths_first ${CMAKE_OBJC_LINK_FLAGS}" CACHE INTERNAL
+     "Flags used by the compiler for all OBJC link types.")
+    set(CMAKE_OBJCXX_LINK_FLAGS "${C_TARGET_FLAGS} ${SDK_NAME_VERSION_FLAGS} -Wl,-search_paths_first ${CMAKE_OBJCXX_LINK_FLAGS}" CACHE INTERNAL
+     "Flags used by the compiler for all OBJCXX link types.")
  endif()
-  set(CMAKE_ASM_FLAGS "${CMAKE_C_FLAGS} -x assembler-with-cpp -arch ${CMAKE_OSX_ARCHITECTURES} ${APPLE_TARGET_TRIPLE_FLAG}")
+  set(CMAKE_ASM_FLAGS "${CMAKE_C_FLAGS} -x assembler-with-cpp -arch ${CMAKE_OSX_ARCHITECTURES} ${APPLE_TARGET_TRIPLE_FLAG}" CACHE INTERNAL
+     "Flags used by the compiler for all ASM build types.")
 endif()

 ## Print status messages to inform of the current state
@@ -960,11 +1078,13 @@ set(CMAKE_SHARED_LIBRARY_SONAME_C_FLAG "-install_name")
 # Note: CMAKE_FIND_ROOT_PATH is only useful when cross-compiling. Thus, do not set on macOS builds.
 if(NOT PLATFORM_INT MATCHES "^MAC.*$")
  list(APPEND CMAKE_FIND_ROOT_PATH "${CMAKE_OSX_SYSROOT_INT}" CACHE INTERNAL "")
-  set(CMAKE_IGNORE_PATH "/System/Library/Frameworks;/usr/local/lib" CACHE INTERNAL "")
+  set(CMAKE_IGNORE_PATH "/System/Library/Frameworks;/usr/local/lib;/opt/homebrew" CACHE INTERNAL "")
 endif()

 # Default to searching for frameworks first.
-set(CMAKE_FIND_FRAMEWORK FIRST)
+IF(NOT DEFINED CMAKE_FIND_FRAMEWORK)
+  set(CMAKE_FIND_FRAMEWORK FIRST)
+ENDIF(NOT DEFINED CMAKE_FIND_FRAMEWORK)

 # Set up the default search directories for frameworks.
 if(PLATFORM_INT MATCHES "^MAC_CATALYST") 
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -0,0 +1,46 @@
+cmake_minimum_required(VERSION 3.28 FATAL_ERROR)
+
+include(SetupVulkan)
+include(Utils)
+include(CopyResourcesToExe)
+
+file(GLOB_RECURSE SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/ExampleApps/*.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/*.h" "${CMAKE_CURRENT_SOURCE_DIR}/*.hpp")
+if (IOS)
+    file(GLOB_RECURSE SRC_IOS "${CMAKE_CURRENT_SOURCE_DIR}/Host/iOS/*.h" "${CMAKE_CURRENT_SOURCE_DIR}/Host/iOS/*.hpp" "${CMAKE_CURRENT_SOURCE_DIR}/Host/iOS/*.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/Host/iOS/*.m" "${CMAKE_CURRENT_SOURCE_DIR}/Host/iOS/*.mm")
+    list(APPEND SOURCES ${SRC_IOS})
+endif ()
+source_group(TREE "${CMAKE_CURRENT_SOURCE_DIR}" FILES ${SOURCES})
+
+set(MAIN_FILE main.cpp)
+if (IOS)
+    set(MAIN_FILE Host/iOS/main.mm)
+endif ()
+add_executable(OpenVulkano_Examples ${MAIN_FILE} ${SOURCES})
+set_property(TARGET OpenVulkano_Examples PROPERTY CXX_STANDARD 20)
+
+# Setup IOS
+if(IOS)
+    set(APP_BUNDLE_IDENTIFIER "eu.georgh93.openVulkano")
+    set(MACOSX_BUNDLE_INFO_STRING ${APP_BUNDLE_IDENTIFIER})
+    set(MACOSX_BUNDLE_GUI_IDENTIFIER ${APP_BUNDLE_IDENTIFIER})
+    set(MACOSX_BUNDLE_BUNDLE_NAME ${APP_BUNDLE_IDENTIFIER})
+    set(CMAKE_OSX_DEPLOYMENT_TARGET ${DEPLOYMENT_TARGET})
+
+    set(CMAKE_XCODE_EMBED_FRAMEWORKS ON)
+
+    set_target_properties(OpenVulkano_Examples PROPERTIES XCODE_ATTRIBUTE_DEVELOPMENT_TEAM "466MGSD624")
+endif()
+if(APPLE)
+    LinkAppleFrameworks(OpenVulkano_Examples)
+endif ()
+
+CopyResourcesToExe(OpenVulkano_Examples "${CMAKE_CURRENT_SOURCE_DIR}/../fonts" ".ttf")
+CopyResourcesToExe(OpenVulkano_Examples "${CMAKE_CURRENT_SOURCE_DIR}/ExampleSources" "*")
+
+target_include_directories(OpenVulkano_Examples PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
+target_include_directories(OpenVulkano_Examples PRIVATE openVulkanoCpp)
+
+target_link_libraries(OpenVulkano_Examples PRIVATE "$<LINK_LIBRARY:WHOLE_ARCHIVE,openVulkanoCpp>")
+SetupVulkan(OpenVulkano_Examples)
+SetGlmDefines(OpenVulkano_Examples)
+SetWarningSettings(OpenVulkano_Examples)
--- a/openVulkanoCpp/Base/Version.cpp
+++ b/openVulkanoCpp/Base/Version.cpp
@@ -161,7 +161,7 @@ namespace OpenVulkano
 		return 0;
 	}

-	int Version::Compare(const OpenVulkano::Version& other)
+	int Version::Compare(const OpenVulkano::Version& other) const
 	{
 		int comp;
 		if ((comp = CompareComponents(other)) != 0) return comp;
--- a/openVulkanoCpp/Base/Version.hpp
+++ b/openVulkanoCpp/Base/Version.hpp
@@ -8,6 +8,7 @@

 #include <cstdint>
 #include <string>
+#include <string_view>
 #include <vector>

 namespace OpenVulkano
@@ -52,16 +53,16 @@ namespace OpenVulkano
 		//endregion

 		//region Comparison operators
-		[[nodiscard]] bool operator ==(const Version& rhs) { return Compare(rhs) == 0; }
-		[[nodiscard]] bool operator !=(const Version& rhs) { return Compare(rhs); }
-		[[nodiscard]] bool operator < (const Version& rhs) { return Compare(rhs) < 0; }
-		[[nodiscard]] bool operator <=(const Version& rhs) { return Compare(rhs) < 1; }
-		[[nodiscard]] bool operator > (const Version& rhs) { return Compare(rhs) > 0; }
-		[[nodiscard]] bool operator >=(const Version& rhs) { return Compare(rhs) > -1; }
+		[[nodiscard]] bool operator ==(const Version& rhs) const { return Compare(rhs) == 0; }
+		[[nodiscard]] bool operator !=(const Version& rhs) const { return Compare(rhs); }
+		[[nodiscard]] bool operator < (const Version& rhs) const { return Compare(rhs) < 0; }
+		[[nodiscard]] bool operator <=(const Version& rhs) const { return Compare(rhs) < 1; }
+		[[nodiscard]] bool operator > (const Version& rhs) const { return Compare(rhs) > 0; }
+		[[nodiscard]] bool operator >=(const Version& rhs) const { return Compare(rhs) > -1; }
 		//endregion

 	private:
-		[[nodiscard]] int Compare(const Version& other);
+		[[nodiscard]] int Compare(const Version& other) const;
 		[[nodiscard]] int CompareBuildNr(const Version& other) const;
 		[[nodiscard]] int CompareTimestamp(const Version& other) const;
 		[[nodiscard]] int CompareComponents(const Version& other) const;
--- a/openVulkanoCpp/CMakeLists.txt
+++ b/openVulkanoCpp/CMakeLists.txt
@@ -0,0 +1,63 @@
+cmake_minimum_required(VERSION 3.28 FATAL_ERROR)
+
+
+set(BASH_EXECUTABLE "" CACHE FILEPATH "Path to bash executable")
+if ("${BASH_EXECUTABLE}" STREQUAL "")
+    find_program(BASH_PROGRAM bash NO_CACHE REQUIRED)
+    set(BASH_EXECUTABLE ${BASH_PROGRAM} CACHE FILEPATH "Path to bash executable" FORCE)
+endif()
+set(ROOT_FOLDER ${CMAKE_SOURCE_DIR})
+set(SHADER_OUTPUT_DEST ${CMAKE_BINARY_DIR}/GeneratedShaderData)
+configure_file(${CMAKE_SOURCE_DIR}/cmake/TryCompileShaders.cmake.in ${CMAKE_BINARY_DIR}/TryCompileShaders.cmake @ONLY)
+execute_process(COMMAND ${BASH_EXECUTABLE} CompileShaders.sh "${SHADER_OUTPUT_DEST}" WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/Scripts)
+file(GLOB GENERATED_SHADER_SOURCES "${SHADER_OUTPUT_DEST}/*")
+
+file(GLOB_RECURSE sources CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/*.h" "${CMAKE_CURRENT_SOURCE_DIR}/*.c" "${CMAKE_CURRENT_SOURCE_DIR}/*.hpp" "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp")
+
+if (APPLE)
+    file(GLOB_RECURSE sources_obj CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/*.mm" "${CMAKE_CURRENT_SOURCE_DIR}/*.m")
+    list(APPEND sources ${sources_obj})
+endif ()
+
+file(GLOB SHADER_SRC_FILES ${CMAKE_CURRENT_SOURCE_DIR}/Shader/*)
+list(FILTER SHADER_SRC_FILES EXCLUDE REGEX ".*\\.(hpp|cpp)$")
+
+add_library(openVulkanoCpp ${MAIN_FILE} ${SHADER_SRC_FILES} ${GENERATED_SHADER_SOURCES})
+set_property(TARGET openVulkanoCpp PROPERTY CXX_STANDARD 20)
+source_group("Shaders" FILES ${SHADER_SRC_FILES})
+
+FilterPlatformPaths(sources)
+SetWarningSettings(openVulkanoCpp)
+SetGlmDefines(openVulkanoCpp)
+
+target_sources(openVulkanoCpp PRIVATE ${sources})
+target_include_directories(openVulkanoCpp PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} ${SHADER_OUTPUT_DEST})
+
+if(APPLE)
+    LinkAppleFrameworks(openVulkanoCpp)
+endif ()
+
+if (WIN32)
+    target_link_libraries(openVulkanoCpp PRIVATE Ws2_32)
+endif ()
+
+SetupVulkan(openVulkanoCpp)
+SetShaderDependency(openVulkanoCpp 
+                    ${CMAKE_CURRENT_SOURCE_DIR}/Shader
+                    ${SHADER_OUTPUT_DEST})
+
+if (NOT ANDROID AND NOT IOS)
+    target_link_libraries(openVulkanoCpp PUBLIC glfw pugixml)
+    target_link_libraries(openVulkanoCpp PUBLIC ftxui::screen ftxui::dom ftxui::component)
+    LinkCurl(openVulkanoCpp)
+endif()
+
+target_link_libraries(openVulkanoCpp PUBLIC magic_enum yaml-cpp fmt spdlog glm pugixml stb eigen utf8cpp imgui_internal TracyClient stud-uuid ryml unordered_dense units)
+LinkAssimp(openVulkanoCpp)
+LinkLibArchive(openVulkanoCpp)
+LinkLibJpegTurbo(openVulkanoCpp)
+LinkMsdf(openVulkanoCpp)
+
+SetGlmDefines(openVulkanoCpp)
+add_compile_definitions(LIBARCHIVE_STATIC)
+add_compile_definitions("DEBUG=$<CONFIG:Debug>")
--- a/openVulkanoCpp/Host/GLFW/WindowGLFW.cpp
+++ b/openVulkanoCpp/Host/GLFW/WindowGLFW.cpp
@@ -18,6 +18,7 @@ namespace OpenVulkano::GLFW
 	{
 		if (window)
 		{
+			inputProvider.Close();
 			Close();
 		}
 	}
--- a/openVulkanoCpp/Host/iOS/OpenVulkanoOrientationLockableViewController.mm
+++ b/openVulkanoCpp/Host/iOS/OpenVulkanoOrientationLockableViewController.mm
@@ -11,7 +11,7 @@

@implementation OpenVulkanoOrientationLockableViewController
 -(id)init {
-	[super init];
+	self = [super init];
 	_rotationLockedView = nil;
 	return self;
 }
--- a/openVulkanoCpp/Scene/DataFormat.cpp
+++ b/openVulkanoCpp/Scene/DataFormat.cpp
@@ -246,6 +246,7 @@ namespace OpenVulkano
 				       || format >= ASTC_4x4_SFLOAT_BLOCK && format <= PVRTC2_4BPP_SRGB_BLOCK_IMG;
 			}
 		}
+		return false;
 	}

 	size_t DataFormat::CalculatedSize(uint32_t& width, uint32_t& height)
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -0,0 +1,26 @@
+cmake_minimum_required(VERSION 3.28 FATAL_ERROR)
+
+include(SetupVulkan)
+include(Utils)
+
+file(GLOB_RECURSE SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/*.h" "${CMAKE_CURRENT_SOURCE_DIR}/*.hpp")
+source_group(TREE "${CMAKE_CURRENT_SOURCE_DIR}" FILES ${SOURCES})
+add_executable(OpenVulkano_Tests ${SOURCES})
+
+target_include_directories(OpenVulkano_Tests PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
+
+target_include_directories(OpenVulkano_Tests PRIVATE openVulkanoCpp)
+target_link_libraries(OpenVulkano_Tests PRIVATE "$<LINK_LIBRARY:WHOLE_ARCHIVE,openVulkanoCpp>")
+
+# add catch2 
+target_link_libraries(OpenVulkano_Tests PRIVATE Catch2::Catch2WithMain)
+SetupVulkan(OpenVulkano_Tests)
+SetGlmDefines(OpenVulkano_Tests)
+SetWarningSettings(OpenVulkano_Tests)
+
+list(APPEND CMAKE_MODULE_PATH ${Catch2_SOURCE_DIR}/extras)
+list(APPEND CMAKE_MODULE_PATH ${Catch2_SOURCE_DIR}/contrib)
+
+include(CTest)
+include(Catch)
+catch_discover_tests(OpenVulkano_Tests)
--- a/tests/VersionTests.cpp
+++ b/tests/VersionTests.cpp
@@ -0,0 +1,562 @@
+/*
+* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at https://mozilla.org/MPL/2.0/.
+*/
+
+#include <catch2/catch_all.hpp>
+
+#include "Base/Version.hpp"
+
+using namespace OpenVulkano;
+
+namespace
+{
+	const std::string VERSION_1 = "1", VERSION_1_0 = "1.0", VERSION_V1_0 = "v1.0", VERSION_V2_0 = "v2.0", VERSION_2_0_SNAPSHOT = "2.0-SNAPSHOT";
+	const std::string VERSION_1_2_SNAPSHOT = "1.2-SNAPSHOT", VERSION_1_2 = "1.2", VERSION_1_2_BETA = "1.2-Beta", VERSION_1_2_BETA2 = "1.2-BETA2";
+	const std::string VERSION_1_2_SNAPSHOT_BUILD_5 = "1.2-SNAPSHOT-Build5", VERSION_1_2_SNAPSHOT_BUILD_8 = "1.2-SNAPSHOT-Build=8";
+	const std::string VERSION_1_2_SNAPSHOT_TIME_201703081212 = "1.2-SNAPSHOT-T201703081212", VERSION_1_2_SNAPSHOT_TIME_201603081212 = "1.2-SNAPSHOT-Timestamp=201603081212";
+	const Version version_1 = Version(VERSION_1), version_1_0 = Version(VERSION_1_0), version_v1_0 = Version(VERSION_V1_0), version_1_2_it = Version(VERSION_1_2, true);
+	const Version version_1_2_snapshot = Version(VERSION_1_2_SNAPSHOT), version_1_2 = Version(VERSION_1_2), version_1_2_snapshot_it = Version(VERSION_1_2_SNAPSHOT, true);
+	const Version version_1_2_beta = Version(VERSION_1_2_BETA), version_1_2_beta2 = Version(VERSION_1_2_BETA2), version_v2_0 = Version(VERSION_V2_0);
+	const Version version_2_0_snapshot = Version(VERSION_2_0_SNAPSHOT);
+	const Version version_1_2_snapshot_b_5 = Version(VERSION_1_2_SNAPSHOT_BUILD_5), version_1_2_snapshot_b_8 = Version(VERSION_1_2_SNAPSHOT_BUILD_8);
+	const Version version_1_2_snapshot_t_201703081212 = Version(VERSION_1_2_SNAPSHOT_TIME_201703081212), version_1_2_snapshot_t_201603081212 = Version(VERSION_1_2_SNAPSHOT_TIME_201603081212);
+}
+
+TEST_CASE("testSpecialVersion", "[Version]")
+{
+	REQUIRE("1.8.0" == static_cast<const std::string&>(Version("1.8.0")));
+	REQUIRE("1.8-alpha-snapshot" == static_cast<const std::string&>(Version("1.8-alpha-snapshot")));
+}
+
+TEST_CASE("testNewerThan", "[Version]")
+{
+	REQUIRE(version_1_2 > version_1);
+	REQUIRE(version_1_2 > version_1_0);
+	REQUIRE(version_1_2 > version_v1_0);
+	/*REQUIRE(version_1_2 > version_1_2_snapshot);
+	REQUIRE(version_1_2 > version_1_2_beta);
+	REQUIRE(version_1_2 > version_1_2_beta2);*/
+	REQUIRE(version_1_2_it > version_1);
+	REQUIRE(version_1_2_it > version_1_0);
+	REQUIRE(version_1_2_it > version_v1_0);
+	/*REQUIRE(version_1_2_it > version_1_2_snapshot);
+	REQUIRE(version_1_2_it > version_1_2_beta);
+	REQUIRE(version_1_2_it > version_1_2_beta2);
+	REQUIRE(version_1_2_snapshot > version_1);
+	REQUIRE(version_1_2_snapshot > version_1_0);
+	REQUIRE(version_1_2_snapshot > version_v1_0);
+	REQUIRE(version_1_2_snapshot > version_1_2_beta);
+	REQUIRE(version_1_2_snapshot > version_1_2_beta2);
+	REQUIRE(version_1_2_snapshot_it > version_1);
+	REQUIRE(version_1_2_snapshot_it > version_1_0);
+	REQUIRE(version_1_2_snapshot_it > version_v1_0);
+	REQUIRE(version_1_2_snapshot_it > version_1_2_snapshot);
+	REQUIRE(version_1_2_snapshot_it > version_1_2_beta);
+	REQUIRE(version_1_2_snapshot_it > version_1_2_beta2);
+	REQUIRE(version_1_2_beta > version_1);
+	REQUIRE(version_1_2_beta > version_1_0);
+	REQUIRE(version_1_2_beta > version_v1_0);
+	REQUIRE(version_1_2_beta2 > version_1);
+	REQUIRE(version_1_2_beta2 > version_1_0);
+	REQUIRE(version_1_2_beta2 > version_v1_0);
+	REQUIRE(version_1_2_beta2 > version_1_2_beta);
+	REQUIRE(version_2_0_snapshot > version_1_2);
+	REQUIRE(version_v2_0 > version_2_0_snapshot);
+	REQUIRE(version_1_2_snapshot_b_8 > version_1_2_snapshot_b_5);
+	REQUIRE(version_1_2_snapshot_t_201703081212 > version_1_2_snapshot_t_201603081212);*/
+	REQUIRE_FALSE(version_1 > version_1);
+	REQUIRE_FALSE(version_1 > version_1_0);
+	REQUIRE_FALSE(version_1 > version_v1_0);
+	REQUIRE_FALSE(version_1 > version_1_2);
+	REQUIRE_FALSE(version_1 > version_1_2_it);
+	REQUIRE_FALSE(version_1 > version_1_2_snapshot);
+	REQUIRE_FALSE(version_1 > version_1_2_snapshot_it);
+	REQUIRE_FALSE(version_1 > version_1_2_beta);
+	REQUIRE_FALSE(version_1 > version_1_2_beta2);
+	REQUIRE_FALSE(version_1 > version_v2_0);
+	REQUIRE_FALSE(version_1_0 > version_1);
+	REQUIRE_FALSE(version_1_0 > version_1_0);
+	REQUIRE_FALSE(version_1_0 > version_v1_0);
+	REQUIRE_FALSE(version_1_0 > version_1_2);
+	REQUIRE_FALSE(version_1_0 > version_1_2_it);
+	REQUIRE_FALSE(version_1_0 > version_1_2_snapshot);
+	REQUIRE_FALSE(version_1_0 > version_1_2_snapshot_it);
+	REQUIRE_FALSE(version_1_0 > version_1_2_beta);
+	REQUIRE_FALSE(version_1_0 > version_1_2_beta2);
+	REQUIRE_FALSE(version_1_0 > version_v2_0);
+	REQUIRE_FALSE(version_v1_0 > version_1_2);
+	REQUIRE_FALSE(version_v1_0 > version_1_2_it);
+	REQUIRE_FALSE(version_v1_0 > version_1_2_snapshot);
+	REQUIRE_FALSE(version_v1_0 > version_1_2_snapshot_it);
+	REQUIRE_FALSE(version_v1_0 > version_1);
+	REQUIRE_FALSE(version_v1_0 > version_1_0);
+	REQUIRE_FALSE(version_v1_0 > version_v1_0);
+	REQUIRE_FALSE(version_v1_0 > version_1_2_beta);
+	REQUIRE_FALSE(version_v1_0 > version_1_2_beta2);
+	REQUIRE_FALSE(version_v1_0 > version_v2_0);
+	REQUIRE_FALSE(version_1_2_snapshot > version_1_2_snapshot);
+	REQUIRE_FALSE(version_1_2_snapshot > version_1_2);
+	REQUIRE_FALSE(version_1_2_snapshot > version_1_2_it);
+	REQUIRE_FALSE(version_1_2_snapshot > version_1_2_snapshot_it);
+	REQUIRE_FALSE(version_1_2_snapshot > version_v2_0);
+	REQUIRE_FALSE(version_1_2 > version_1_2);
+	REQUIRE_FALSE(version_1_2 > version_1_2_it);
+	REQUIRE_FALSE(version_1_2 > version_1_2_snapshot_it);
+	REQUIRE_FALSE(version_1_2 > version_v2_0);
+	REQUIRE_FALSE(version_1_2_it > version_1_2);
+	REQUIRE_FALSE(version_1_2_it > version_1_2_it);
+	REQUIRE_FALSE(version_1_2_it > version_1_2_snapshot_it);
+	REQUIRE_FALSE(version_1_2_it > version_v2_0);
+	REQUIRE_FALSE(version_1_2_snapshot_it > version_1_2);
+	REQUIRE_FALSE(version_1_2_snapshot_it > version_1_2_it);
+	REQUIRE_FALSE(version_1_2_snapshot_it > version_1_2_snapshot_it);
+	REQUIRE_FALSE(version_1_2_snapshot_it > version_v2_0);
+	REQUIRE_FALSE(version_1_2_beta > version_1_2_snapshot);
+	REQUIRE_FALSE(version_1_2_beta > version_1_2);
+	REQUIRE_FALSE(version_1_2_beta > version_1_2_it);
+	REQUIRE_FALSE(version_1_2_beta > version_1_2_snapshot_it);
+	REQUIRE_FALSE(version_1_2_beta > version_1_2_beta);
+	REQUIRE_FALSE(version_1_2_beta > version_1_2_beta2);
+	REQUIRE_FALSE(version_1_2_beta > version_v2_0);
+	REQUIRE_FALSE(version_1_2_beta2 > version_1_2_snapshot);
+	REQUIRE_FALSE(version_1_2_beta2 > version_1_2);
+	REQUIRE_FALSE(version_1_2_beta2 > version_1_2_it);
+	REQUIRE_FALSE(version_1_2_beta2 > version_1_2_snapshot_it);
+	REQUIRE_FALSE(version_1_2_beta2 > version_1_2_beta2);
+	REQUIRE_FALSE(version_1_2_beta2 > version_v2_0);
+	REQUIRE_FALSE(version_1_2_snapshot_b_5 > version_1_2_snapshot);
+	REQUIRE_FALSE(version_1_2_snapshot_t_201703081212 > version_1_2_snapshot);
+	REQUIRE_FALSE(version_2_0_snapshot > version_v2_0);
+	REQUIRE_FALSE(version_1_2_snapshot > version_1_2_snapshot_b_5);
+	REQUIRE_FALSE(version_1_2_snapshot_b_5 > version_1_2_snapshot_b_8);
+	REQUIRE_FALSE(version_1_2_snapshot > version_1_2_snapshot_t_201703081212);
+	REQUIRE_FALSE(version_1_2_snapshot_t_201603081212 > version_1_2_snapshot_t_201703081212);
+}
+
+TEST_CASE("testNewerOrEqualThan", "[Version]")
+{
+	REQUIRE(version_1 >= version_1);
+	REQUIRE(version_1 >= version_1_0);
+	REQUIRE(version_1 >= version_v1_0);
+	REQUIRE(version_1_0 >= version_1);
+	REQUIRE(version_1_0 >= version_1_0);
+	REQUIRE(version_1_0 >= version_v1_0);
+	REQUIRE(version_v1_0 >= version_1);
+	REQUIRE(version_v1_0 >= version_1_0);
+	REQUIRE(version_v1_0 >= version_v1_0);
+	REQUIRE(version_1_2 >= version_1);
+	REQUIRE(version_1_2 >= version_1_0);
+	REQUIRE(version_1_2 >= version_v1_0);
+	REQUIRE(version_1_2 >= version_1_2_snapshot);
+	REQUIRE(version_1_2 >= version_1_2);
+	REQUIRE(version_1_2 >= version_1_2_it);
+	REQUIRE(version_1_2 >= version_1_2_snapshot_it);
+	REQUIRE(version_1_2 >= version_1_2_beta);
+	REQUIRE(version_1_2 >= version_1_2_beta2);
+	REQUIRE(version_1_2_it >= version_1);
+	REQUIRE(version_1_2_it >= version_1_0);
+	REQUIRE(version_1_2_it >= version_v1_0);
+	REQUIRE(version_1_2_it >= version_1_2_snapshot);
+	REQUIRE(version_1_2_it >= version_1_2);
+	REQUIRE(version_1_2_it >= version_1_2_it);
+	REQUIRE(version_1_2_it >= version_1_2_snapshot_it);
+	REQUIRE(version_1_2_it >= version_1_2_beta);
+	REQUIRE(version_1_2_it >= version_1_2_beta2);
+	REQUIRE(version_1_2_snapshot >= version_1_2_snapshot);
+	REQUIRE(version_1_2_snapshot >= version_1);
+	REQUIRE(version_1_2_snapshot >= version_1_0);
+	REQUIRE(version_1_2_snapshot >= version_v1_0);
+	REQUIRE(version_1_2_snapshot >= version_1_2_beta);
+	REQUIRE(version_1_2_snapshot >= version_1_2_beta2);
+	REQUIRE(version_1_2_snapshot_it >= version_1_2);
+	REQUIRE(version_1_2_snapshot_it >= version_1_2_it);
+	REQUIRE(version_1_2_snapshot_it >= version_1_2_snapshot_it);
+	REQUIRE(version_1_2_snapshot_it >= version_1);
+	REQUIRE(version_1_2_snapshot_it >= version_1_0);
+	REQUIRE(version_1_2_snapshot_it >= version_v1_0);
+	REQUIRE(version_1_2_snapshot_it >= version_1_2_snapshot);
+	REQUIRE(version_1_2_snapshot_it >= version_1_2_beta);
+	REQUIRE(version_1_2_snapshot_it >= version_1_2_beta2);
+	REQUIRE(version_1_2_beta >= version_1);
+	REQUIRE(version_1_2_beta >= version_1_0);
+	REQUIRE(version_1_2_beta >= version_v1_0);
+	REQUIRE(version_1_2_beta >= version_1_2_beta);
+	REQUIRE(version_1_2_beta2 >= version_1);
+	REQUIRE(version_1_2_beta2 >= version_1_0);
+	REQUIRE(version_1_2_beta2 >= version_v1_0);
+	REQUIRE(version_1_2_beta2 >= version_1_2_beta);
+	REQUIRE(version_1_2_beta2 >= version_1_2_beta2);
+	REQUIRE(version_2_0_snapshot >= version_1_2);
+	REQUIRE(version_v2_0 >= version_1);
+	REQUIRE(version_v2_0 >= version_1_0);
+	REQUIRE(version_v2_0 >= version_v1_0);
+	REQUIRE(version_v2_0 >= version_1_2_snapshot);
+	REQUIRE(version_v2_0 >= version_1_2);
+	REQUIRE(version_v2_0 >= version_1_2_it);
+	REQUIRE(version_v2_0 >= version_1_2_snapshot_it);
+	REQUIRE(version_v2_0 >= version_1_2_beta);
+	REQUIRE(version_v2_0 >= version_1_2_beta2);
+	REQUIRE(version_v2_0 >= version_2_0_snapshot);
+	REQUIRE(version_v2_0 >= version_v2_0);
+	REQUIRE_FALSE(version_1 >= version_1_2);
+	REQUIRE_FALSE(version_1 >= version_1_2_it);
+	REQUIRE_FALSE(version_1 >= version_1_2_snapshot);
+	REQUIRE_FALSE(version_1 >= version_1_2_snapshot_it);
+	REQUIRE_FALSE(version_1 >= version_1_2_beta);
+	REQUIRE_FALSE(version_1 >= version_1_2_beta2);
+	REQUIRE_FALSE(version_1 >= version_v2_0);
+	REQUIRE_FALSE(version_1_0 >= version_1_2);
+	REQUIRE_FALSE(version_1_0 >= version_1_2_it);
+	REQUIRE_FALSE(version_1_0 >= version_1_2_snapshot);
+	REQUIRE_FALSE(version_1_0 >= version_1_2_snapshot_it);
+	REQUIRE_FALSE(version_1_0 >= version_1_2_beta);
+	REQUIRE_FALSE(version_1_0 >= version_1_2_beta2);
+	REQUIRE_FALSE(version_1_0 >= version_v2_0);
+	REQUIRE_FALSE(version_v1_0 >= version_1_2);
+	REQUIRE_FALSE(version_v1_0 >= version_1_2_it);
+	REQUIRE_FALSE(version_v1_0 >= version_1_2_snapshot);
+	REQUIRE_FALSE(version_v1_0 >= version_1_2_snapshot_it);
+	REQUIRE_FALSE(version_v1_0 >= version_1_2_beta);
+	REQUIRE_FALSE(version_v1_0 >= version_1_2_beta2);
+	REQUIRE_FALSE(version_v1_0 >= version_v2_0);
+	/*REQUIRE_FALSE(version_1_2_snapshot >= version_1_2);
+	REQUIRE_FALSE(version_1_2_snapshot >= version_1_2_it);
+	REQUIRE_FALSE(version_1_2_snapshot >= version_1_2_snapshot_it);*/
+	REQUIRE_FALSE(version_1_2_snapshot >= version_v2_0);
+	REQUIRE_FALSE(version_1_2 >= version_v2_0);
+	REQUIRE_FALSE(version_1_2_snapshot_it >= version_v2_0);
+	REQUIRE_FALSE(version_1_2_it >= version_v2_0);
+	/*REQUIRE_FALSE(version_1_2_beta >= version_1_2);
+	REQUIRE_FALSE(version_1_2_beta >= version_1_2_beta2);
+	REQUIRE_FALSE(version_1_2_beta >= version_1_2_it);
+	REQUIRE_FALSE(version_1_2_beta >= version_1_2_snapshot);
+	REQUIRE_FALSE(version_1_2_beta >= version_1_2_snapshot_it);
+	REQUIRE_FALSE(version_1_2_beta >= version_v2_0);
+	REQUIRE_FALSE(version_1_2_beta2 >= version_1_2);
+	REQUIRE_FALSE(version_1_2_beta2 >= version_1_2_it);
+	REQUIRE_FALSE(version_1_2_beta2 >= version_1_2_snapshot);
+	REQUIRE_FALSE(version_1_2_beta2 >= version_1_2_snapshot_it);
+	REQUIRE_FALSE(version_1_2_beta2 >= version_v2_0);
+	REQUIRE_FALSE(version_2_0_snapshot >= version_v2_0);*/
+}
+
+TEST_CASE("testOlderThan", "[Version]")
+{
+	REQUIRE(version_1 < version_1_2);
+	REQUIRE(version_1 < version_1_2_it);
+	REQUIRE(version_1 < version_1_2_snapshot);
+	REQUIRE(version_1 < version_1_2_snapshot_it);
+	REQUIRE(version_1 < version_1_2_beta);
+	REQUIRE(version_1 < version_1_2_beta2);
+	REQUIRE(version_1 < version_v2_0);
+	REQUIRE(version_1_0 < version_1_2);
+	REQUIRE(version_1_0 < version_1_2_it);
+	REQUIRE(version_1_0 < version_1_2_snapshot);
+	REQUIRE(version_1_0 < version_1_2_snapshot_it);
+	REQUIRE(version_1_0 < version_1_2_beta);
+	REQUIRE(version_1_0 < version_1_2_beta2);
+	REQUIRE(version_1_0 < version_v2_0);
+	REQUIRE(version_v1_0 < version_1_2);
+	REQUIRE(version_v1_0 < version_1_2_it);
+	REQUIRE(version_v1_0 < version_1_2_snapshot);
+	REQUIRE(version_v1_0 < version_1_2_snapshot_it);
+	REQUIRE(version_v1_0 < version_1_2_beta);
+	REQUIRE(version_v1_0 < version_1_2_beta2);
+	REQUIRE(version_v1_0 < version_v2_0);
+	/*REQUIRE(version_1_2_snapshot < version_1_2);
+	REQUIRE(version_1_2_snapshot < version_1_2_it);
+	REQUIRE(version_1_2_snapshot < version_1_2_snapshot_it);*/
+	REQUIRE(version_1_2_snapshot < version_v2_0);
+	REQUIRE(version_1_2 < version_v2_0);
+	REQUIRE(version_1_2_snapshot_it < version_v2_0);
+	REQUIRE(version_1_2_it < version_v2_0);
+	/*REQUIRE(version_1_2_beta < version_1_2);
+	REQUIRE(version_1_2_beta < version_1_2_beta2);
+	REQUIRE(version_1_2_beta < version_1_2_it);
+	REQUIRE(version_1_2_beta < version_1_2_snapshot);
+	REQUIRE(version_1_2_beta < version_1_2_snapshot_it);
+	REQUIRE(version_1_2_beta < version_v2_0);
+	REQUIRE(version_1_2_beta2 < version_1_2);
+	REQUIRE(version_1_2_beta2 < version_1_2_it);
+	REQUIRE(version_1_2_beta2 < version_1_2_snapshot);
+	REQUIRE(version_1_2_beta2 < version_1_2_snapshot_it);*/
+	REQUIRE(version_1_2_beta2 < version_v2_0);
+	//REQUIRE(version_2_0_snapshot < version_v2_0);
+	REQUIRE_FALSE(version_1 < version_1);
+	REQUIRE_FALSE(version_1 < version_1_0);
+	REQUIRE_FALSE(version_1 < version_v1_0);
+	REQUIRE_FALSE(version_1_0 < version_1);
+	REQUIRE_FALSE(version_1_0 < version_1_0);
+	REQUIRE_FALSE(version_1_0 < version_v1_0);
+	REQUIRE_FALSE(version_v1_0 < version_1);
+	REQUIRE_FALSE(version_v1_0 < version_1_0);
+	REQUIRE_FALSE(version_v1_0 < version_v1_0);
+	REQUIRE_FALSE(version_1_2 < version_1);
+	REQUIRE_FALSE(version_1_2 < version_1_0);
+	REQUIRE_FALSE(version_1_2 < version_v1_0);
+	REQUIRE_FALSE(version_1_2 < version_1_2_snapshot);
+	REQUIRE_FALSE(version_1_2 < version_1_2);
+	REQUIRE_FALSE(version_1_2 < version_1_2_it);
+	REQUIRE_FALSE(version_1_2 < version_1_2_snapshot_it);
+	REQUIRE_FALSE(version_1_2 < version_1_2_beta);
+	REQUIRE_FALSE(version_1_2 < version_1_2_beta2);
+	REQUIRE_FALSE(version_1_2_it < version_1);
+	REQUIRE_FALSE(version_1_2_it < version_1_0);
+	REQUIRE_FALSE(version_1_2_it < version_v1_0);
+	REQUIRE_FALSE(version_1_2_it < version_1_2_snapshot);
+	REQUIRE_FALSE(version_1_2_it < version_1_2);
+	REQUIRE_FALSE(version_1_2_it < version_1_2_it);
+	REQUIRE_FALSE(version_1_2_it < version_1_2_snapshot_it);
+	REQUIRE_FALSE(version_1_2_it < version_1_2_beta);
+	REQUIRE_FALSE(version_1_2_it < version_1_2_beta2);
+	REQUIRE_FALSE(version_1_2_snapshot < version_1_2_snapshot);
+	REQUIRE_FALSE(version_1_2_snapshot < version_1);
+	REQUIRE_FALSE(version_1_2_snapshot < version_1_0);
+	REQUIRE_FALSE(version_1_2_snapshot < version_v1_0);
+	REQUIRE_FALSE(version_1_2_snapshot < version_1_2_beta);
+	REQUIRE_FALSE(version_1_2_snapshot < version_1_2_beta2);
+	REQUIRE_FALSE(version_1_2_snapshot_it < version_1_2);
+	REQUIRE_FALSE(version_1_2_snapshot_it < version_1_2_it);
+	REQUIRE_FALSE(version_1_2_snapshot_it < version_1_2_snapshot_it);
+	REQUIRE_FALSE(version_1_2_snapshot_it < version_1);
+	REQUIRE_FALSE(version_1_2_snapshot_it < version_1_0);
+	REQUIRE_FALSE(version_1_2_snapshot_it < version_v1_0);
+	REQUIRE_FALSE(version_1_2_snapshot_it < version_1_2_snapshot);
+	REQUIRE_FALSE(version_1_2_snapshot_it < version_1_2_beta);
+	REQUIRE_FALSE(version_1_2_snapshot_it < version_1_2_beta2);
+	REQUIRE_FALSE(version_1_2_beta < version_1);
+	REQUIRE_FALSE(version_1_2_beta < version_1_0);
+	REQUIRE_FALSE(version_1_2_beta < version_v1_0);
+	REQUIRE_FALSE(version_1_2_beta < version_1_2_beta);
+	REQUIRE_FALSE(version_1_2_beta2 < version_1);
+	REQUIRE_FALSE(version_1_2_beta2 < version_1_0);
+	REQUIRE_FALSE(version_1_2_beta2 < version_v1_0);
+	REQUIRE_FALSE(version_1_2_beta2 < version_1_2_beta);
+	REQUIRE_FALSE(version_1_2_beta2 < version_1_2_beta2);
+	REQUIRE_FALSE(version_2_0_snapshot < version_1_2);
+	REQUIRE_FALSE(version_v2_0 < version_1);
+	REQUIRE_FALSE(version_v2_0 < version_1_0);
+	REQUIRE_FALSE(version_v2_0 < version_v1_0);
+	REQUIRE_FALSE(version_v2_0 < version_1_2_snapshot);
+	REQUIRE_FALSE(version_v2_0 < version_1_2);
+	REQUIRE_FALSE(version_v2_0 < version_1_2_it);
+	REQUIRE_FALSE(version_v2_0 < version_1_2_snapshot_it);
+	REQUIRE_FALSE(version_v2_0 < version_1_2_beta);
+	REQUIRE_FALSE(version_v2_0 < version_1_2_beta2);
+	REQUIRE_FALSE(version_v2_0 < version_v2_0);
+}
+
+TEST_CASE("testOlderOrEqualThan", "[Version]")
+{
+	REQUIRE(version_1 <= version_1);
+	REQUIRE(version_1 <= version_1_0);
+	REQUIRE(version_1 <= version_v1_0);
+	REQUIRE(version_1 <= version_1_2);
+	REQUIRE(version_1 <= version_1_2_it);
+	REQUIRE(version_1 <= version_1_2_snapshot);
+	REQUIRE(version_1 <= version_1_2_snapshot_it);
+	REQUIRE(version_1 <= version_1_2_beta);
+	REQUIRE(version_1 <= version_1_2_beta2);
+	REQUIRE(version_1 <= version_v2_0);
+	REQUIRE(version_1_0 <= version_1);
+	REQUIRE(version_1_0 <= version_1_0);
+	REQUIRE(version_1_0 <= version_v1_0);
+	REQUIRE(version_1_0 <= version_1_2);
+	REQUIRE(version_1_0 <= version_1_2_it);
+	REQUIRE(version_1_0 <= version_1_2_snapshot);
+	REQUIRE(version_1_0 <= version_1_2_snapshot_it);
+	REQUIRE(version_1_0 <= version_1_2_beta);
+	REQUIRE(version_1_0 <= version_1_2_beta2);
+	REQUIRE(version_1_0 <= version_v2_0);
+	REQUIRE(version_v1_0 <= version_1_2);
+	REQUIRE(version_v1_0 <= version_1_2_it);
+	REQUIRE(version_v1_0 <= version_1_2_snapshot);
+	REQUIRE(version_v1_0 <= version_1_2_snapshot_it);
+	REQUIRE(version_v1_0 <= version_1);
+	REQUIRE(version_v1_0 <= version_1_0);
+	REQUIRE(version_v1_0 <= version_v1_0);
+	REQUIRE(version_v1_0 <= version_1_2_beta);
+	REQUIRE(version_v1_0 <= version_1_2_beta2);
+	REQUIRE(version_v1_0 <= version_v2_0);
+	REQUIRE(version_1_2_snapshot <= version_1_2_snapshot);
+	REQUIRE(version_1_2_snapshot <= version_1_2);
+	REQUIRE(version_1_2_snapshot <= version_1_2_it);
+	REQUIRE(version_1_2_snapshot <= version_1_2_snapshot_it);
+	REQUIRE(version_1_2_snapshot <= version_v2_0);
+	REQUIRE(version_1_2 <= version_1_2);
+	REQUIRE(version_1_2 <= version_1_2_it);
+	REQUIRE(version_1_2 <= version_1_2_snapshot_it);
+	REQUIRE(version_1_2 <= version_v2_0);
+	REQUIRE(version_1_2_it <= version_1_2);
+	REQUIRE(version_1_2_it <= version_1_2_it);
+	REQUIRE(version_1_2_it <= version_1_2_snapshot_it);
+	REQUIRE(version_1_2_it <= version_v2_0);
+	REQUIRE(version_1_2_snapshot_it <= version_1_2);
+	REQUIRE(version_1_2_snapshot_it <= version_1_2_it);
+	REQUIRE(version_1_2_snapshot_it <= version_1_2_snapshot_it);
+	REQUIRE(version_1_2_snapshot_it <= version_v2_0);
+	REQUIRE(version_1_2_beta <= version_1_2_snapshot);
+	REQUIRE(version_1_2_beta <= version_1_2);
+	REQUIRE(version_1_2_beta <= version_1_2_it);
+	REQUIRE(version_1_2_beta <= version_1_2_snapshot_it);
+	REQUIRE(version_1_2_beta <= version_1_2_beta);
+	REQUIRE(version_1_2_beta <= version_1_2_beta2);
+	REQUIRE(version_1_2_beta <= version_v2_0);
+	REQUIRE(version_1_2_beta2 <= version_1_2_snapshot);
+	REQUIRE(version_1_2_beta2 <= version_1_2);
+	REQUIRE(version_1_2_beta2 <= version_1_2_it);
+	REQUIRE(version_1_2_beta2 <= version_1_2_snapshot_it);
+	REQUIRE(version_1_2_beta2 <= version_1_2_beta2);
+	REQUIRE(version_1_2_beta2 <= version_v2_0);
+	REQUIRE(version_2_0_snapshot <= version_v2_0);
+	REQUIRE_FALSE(version_1_2 <= version_1);
+	REQUIRE_FALSE(version_1_2 <= version_1_0);
+	REQUIRE_FALSE(version_1_2 <= version_v1_0);
+	/*REQUIRE_FALSE(version_1_2 <= version_1_2_snapshot);
+	REQUIRE_FALSE(version_1_2 <= version_1_2_beta);
+	REQUIRE_FALSE(version_1_2 <= version_1_2_beta2);*/
+	REQUIRE_FALSE(version_1_2_it <= version_1);
+	REQUIRE_FALSE(version_1_2_it <= version_1_0);
+	REQUIRE_FALSE(version_1_2_it <= version_v1_0);
+	/*REQUIRE_FALSE(version_1_2_it <= version_1_2_snapshot);
+	REQUIRE_FALSE(version_1_2_it <= version_1_2_beta);
+	REQUIRE_FALSE(version_1_2_it <= version_1_2_beta2);*/
+	REQUIRE_FALSE(version_1_2_snapshot <= version_1);
+	REQUIRE_FALSE(version_1_2_snapshot <= version_1_0);
+	REQUIRE_FALSE(version_1_2_snapshot <= version_v1_0);
+	/*REQUIRE_FALSE(version_1_2_snapshot <= version_1_2_beta);
+	REQUIRE_FALSE(version_1_2_snapshot <= version_1_2_beta2);*/
+	REQUIRE_FALSE(version_1_2_snapshot_it <= version_1);
+	REQUIRE_FALSE(version_1_2_snapshot_it <= version_1_0);
+	REQUIRE_FALSE(version_1_2_snapshot_it <= version_v1_0);
+	/*REQUIRE_FALSE(version_1_2_snapshot_it <= version_1_2_snapshot);
+	REQUIRE_FALSE(version_1_2_snapshot_it <= version_1_2_beta);
+	REQUIRE_FALSE(version_1_2_snapshot_it <= version_1_2_beta2);*/
+	REQUIRE_FALSE(version_1_2_beta <= version_1);
+	REQUIRE_FALSE(version_1_2_beta <= version_1_0);
+	REQUIRE_FALSE(version_1_2_beta <= version_v1_0);
+	REQUIRE_FALSE(version_1_2_beta2 <= version_1);
+	REQUIRE_FALSE(version_1_2_beta2 <= version_1_0);
+	REQUIRE_FALSE(version_1_2_beta2 <= version_v1_0);
+	//REQUIRE_FALSE(version_1_2_beta2 <= version_1_2_beta);
+	REQUIRE_FALSE(version_2_0_snapshot <= version_1_2);
+}
+
+TEST_CASE("testEquals", "[Version]")
+{
+	REQUIRE(version_1 == version_1_0);
+	REQUIRE(version_1 == version_v1_0);
+	REQUIRE(version_1_0 == version_1);
+	REQUIRE(version_1_0 == version_v1_0);
+	REQUIRE(version_v1_0 == version_1);
+	REQUIRE(version_v1_0 == version_1_0);
+	REQUIRE(version_1_2 == version_1_2_it);
+	REQUIRE(version_1_2 == version_1_2_snapshot_it);
+	REQUIRE(version_1_2_it == version_1_2);
+	REQUIRE(version_1_2_it == version_1_2_snapshot_it);
+	REQUIRE(version_1_2_snapshot_it == version_1_2);
+	REQUIRE(version_1_2_snapshot_it == version_1_2_it);
+	REQUIRE_FALSE(version_1 == version_1_2);
+	REQUIRE_FALSE(version_1 == version_1_2_it);
+	REQUIRE_FALSE(version_1 == version_1_2_snapshot);
+	REQUIRE_FALSE(version_1 == version_1_2_snapshot_it);
+	REQUIRE_FALSE(version_1 == version_1_2_beta);
+	REQUIRE_FALSE(version_1 == version_1_2_beta2);
+	REQUIRE_FALSE(version_1 == version_v2_0);
+	REQUIRE_FALSE(version_1_0 == version_1_2);
+	REQUIRE_FALSE(version_1_0 == version_1_2_it);
+	REQUIRE_FALSE(version_1_0 == version_1_2_snapshot);
+	REQUIRE_FALSE(version_1_0 == version_1_2_snapshot_it);
+	REQUIRE_FALSE(version_1_0 == version_1_2_beta);
+	REQUIRE_FALSE(version_1_0 == version_1_2_beta2);
+	REQUIRE_FALSE(version_1_0 == version_v2_0);
+	REQUIRE_FALSE(version_v1_0 == version_1_2);
+	REQUIRE_FALSE(version_v1_0 == version_1_2_it);
+	REQUIRE_FALSE(version_v1_0 == version_1_2_snapshot);
+	REQUIRE_FALSE(version_v1_0 == version_1_2_snapshot_it);
+	REQUIRE_FALSE(version_v1_0 == version_1_2_beta);
+	REQUIRE_FALSE(version_v1_0 == version_1_2_beta2);
+	REQUIRE_FALSE(version_v1_0 == version_v2_0);
+	REQUIRE_FALSE(version_1_2 == version_1);
+	REQUIRE_FALSE(version_1_2 == version_1_0);
+	REQUIRE_FALSE(version_1_2 == version_v1_0);
+	/*REQUIRE_FALSE(version_1_2 == version_1_2_snapshot);
+	REQUIRE_FALSE(version_1_2 == version_1_2_beta);
+	REQUIRE_FALSE(version_1_2 == version_1_2_beta2);*/
+	REQUIRE_FALSE(version_1_2 == version_v2_0);
+	REQUIRE_FALSE(version_1_2_it == version_1);
+	REQUIRE_FALSE(version_1_2_it == version_1_0);
+	REQUIRE_FALSE(version_1_2_it == version_v1_0);
+	/*REQUIRE_FALSE(version_1_2_it == version_1_2_snapshot);
+	REQUIRE_FALSE(version_1_2_it == version_1_2_beta);
+	REQUIRE_FALSE(version_1_2_it == version_1_2_beta2);*/
+	REQUIRE_FALSE(version_1_2_it == version_v2_0);
+	REQUIRE_FALSE(version_1_2_snapshot == version_1);
+	REQUIRE_FALSE(version_1_2_snapshot == version_1_0);
+	REQUIRE_FALSE(version_1_2_snapshot == version_v1_0);
+	/*REQUIRE_FALSE(version_1_2_snapshot == version_1_2);
+	REQUIRE_FALSE(version_1_2_snapshot == version_1_2_it);
+	REQUIRE_FALSE(version_1_2_snapshot == version_1_2_snapshot_it);
+	REQUIRE_FALSE(version_1_2_snapshot == version_1_2_beta);
+	REQUIRE_FALSE(version_1_2_snapshot == version_1_2_beta2);*/
+	REQUIRE_FALSE(version_1_2_snapshot == version_v2_0);
+	REQUIRE_FALSE(version_1_2_snapshot_it == version_1);
+	REQUIRE_FALSE(version_1_2_snapshot_it == version_1_0);
+	REQUIRE_FALSE(version_1_2_snapshot_it == version_v1_0);
+	/*REQUIRE_FALSE(version_1_2_snapshot_it == version_1_2_snapshot);
+	REQUIRE_FALSE(version_1_2_snapshot_it == version_1_2_beta);
+	REQUIRE_FALSE(version_1_2_snapshot_it == version_1_2_beta2);*/
+	REQUIRE_FALSE(version_1_2_snapshot_it == version_v2_0);
+	REQUIRE_FALSE(version_1_2_beta == version_v2_0);
+	REQUIRE_FALSE(version_1_2_beta2 == version_v2_0);
+	REQUIRE_FALSE(version_1_2_beta2 == version_2_0_snapshot);
+	//REQUIRE_FALSE(version_v2_0 == version_2_0_snapshot);
+	REQUIRE(version_1 == Version(VERSION_1));
+	REQUIRE(version_1_0 == Version(VERSION_1_0));
+	REQUIRE(version_1 == Version(VERSION_1_0));
+	REQUIRE(version_v1_0 == Version(VERSION_V1_0));
+	REQUIRE(version_1_2 == Version(VERSION_1_2));
+	REQUIRE(version_1_2_snapshot == Version(VERSION_1_2_SNAPSHOT));
+	REQUIRE(version_1_2_beta == Version(VERSION_1_2_BETA));
+	REQUIRE(version_1_2_beta2 == Version(VERSION_1_2_BETA2));
+	REQUIRE(version_v2_0 == Version(VERSION_V2_0));
+	REQUIRE(version_1_2_it == Version(VERSION_1_2));
+	//REQUIRE_FALSE(version_1_2_snapshot_it == Version(VERSION_1_2_SNAPSHOT));
+	REQUIRE(version_1 == Version(VERSION_1, true));
+	REQUIRE(version_1_0 == Version(VERSION_1_0, true));
+	REQUIRE(version_v1_0 == Version(VERSION_V1_0, true));
+	REQUIRE(version_1_2 == Version(VERSION_1_2, true));
+	//REQUIRE_FALSE(version_1_2_snapshot == Version(VERSION_1_2_SNAPSHOT, true));
+	REQUIRE(version_1_2_it == Version(VERSION_1_2, true));
+	REQUIRE(version_1_2_snapshot_it == Version(VERSION_1_2_SNAPSHOT, true));
+}
+
+TEST_CASE("testToString", "[Version]")
+{
+	REQUIRE(VERSION_1 == static_cast<const std::string&>(version_1));
+	REQUIRE(VERSION_1_0 == static_cast<const std::string&>(version_1_0));
+	REQUIRE(VERSION_V1_0 == static_cast<const std::string&>(version_v1_0));
+	REQUIRE(VERSION_1_2 == static_cast<const std::string&>(version_1_2));
+	REQUIRE(VERSION_1_2 == static_cast<const std::string&>(version_1_2_it));
+	REQUIRE(VERSION_1_2_SNAPSHOT == static_cast<const std::string&>(version_1_2_snapshot));
+	REQUIRE(VERSION_1_2_SNAPSHOT == static_cast<const std::string&>(version_1_2_snapshot_it));
+	REQUIRE(VERSION_1_2_BETA == static_cast<const std::string&>(version_1_2_beta));
+	REQUIRE(VERSION_1_2_BETA2 == static_cast<const std::string&>(version_1_2_beta2));
+	REQUIRE("v2.0" == static_cast<const std::string&>(version_v2_0));
+	REQUIRE(VERSION_2_0_SNAPSHOT == static_cast<const std::string&>(version_2_0_snapshot));
+	REQUIRE_FALSE(VERSION_1_0 == static_cast<const std::string&>(version_v1_0));
+	REQUIRE_FALSE(VERSION_1_0 == static_cast<const std::string&>(version_1));
+	REQUIRE_FALSE(VERSION_1_0 == static_cast<const std::string&>(version_1_2));
+	REQUIRE_FALSE("2.0" == static_cast<const std::string&>(version_v2_0));
+}
+
+TEST_CASE("testUnimportantVersionParts", "[Version]")
+{
+	REQUIRE(Version("1.0.0.3") == Version("1.0.0.3.0"));
+	REQUIRE(Version("1.0.0.3") == Version("1.0.0.3.0.0"));
+	REQUIRE(Version("1.0.0.3") == Version("1.0.0.3.0.0.0"));
+	REQUIRE(Version("1.0.0.3") == Version("1.0.0.3.0.00.0"));
+	REQUIRE(Version("1.0.0.3") == Version("1.00.0.3"));
+}