Merge pull request #72 from KonstantinTomashevich/71-resource-cooking…

…-platform

Resource Cooking Platform.

.github/workflows/Test.yml

@@ -65,11 +65,11 @@ jobs:
 
       - name: Install Ninja
         if: matrix.os == 'ubuntu-22.04'
-        run: sudo apt-get install ninja-build
+        run: sudo apt-get update && sudo apt-get install ninja-build
 
-      - name: Install SDL2
+      - name: Install OpenGL
         if: matrix.os == 'ubuntu-22.04'
-        run: sudo apt-get update && sudo apt-get install libsdl2-dev --fix-missing
+        run: sudo apt-get update && sudo apt-get install libgl1-mesa-dev
 
       - name: Create build directory
         run: cmake -E make_directory ${{env.BUILD_DIRECTORY}}

CMake/Emergence/PhysX.cmake

@@ -78,6 +78,6 @@ if (DEFINED PHYSX_HOME)
         add_library (PhysX::Extensions STATIC IMPORTED)
         set_target_properties (PhysX::Extensions PROPERTIES IMPORTED_LOCATION "${PHYSX_EXTENSIONS_STATIC}")
 
-        target_link_libraries (PhysX INTERFACE PhysX::Common PhysX::Foundation PhysX::PVD PhysX::Extensions)
+        sober_target_link_libraries (PhysX INTERFACE PhysX::Common PhysX::Foundation PhysX::PVD PhysX::Extensions)
     endif ()
 endif ()

CMake/Emergence/Resource.cmake

@@ -5,6 +5,11 @@ define_property (TARGET PROPERTY RESOURCE_DIRECTORY_MAPPING
 For each resource usage 3 items are added: global path to source, virtual path for mounting and group name for \
 grouping mount lists. Should only be modified through `register_resource_usage` function.")
 
+# Property for caching deploying target merged resource mapping.
+define_property (TARGET PROPERTY RESOURCE_DIRECTORY_MERGED_MAPPING
+        BRIEF_DOCS "List that describes target all resource directories including linked targets resources."
+        FULL_DOCS "Product of merging own RESOURCE_DIRECTORY_MAPPING with all linked target ones.")
+
 # Registers that given target uses resources at given real path (directory or virtual file system package).
 # In resulting mount configuration this resource will have given virtual target path and will be placed in
 # appropriate mount configuration list (one list per group is created).
@@ -50,19 +55,35 @@ function (private_add_direct_resources_to_merged_mapping TARGET)
     set (MERGED_MAPPING "${LOCAL_MERGED_MAPPING}" PARENT_SCOPE)
 endfunction ()
 
+# File-private function that extracts RESOURCE_DIRECTORY_MERGED_MAPPING from given target.
+# If it is not yet ready, RESOURCE_DIRECTORY_MERGED_MAPPING generation algorithm is executed.
+# Outputs result value to MERGED_MAPPING parent scope variable.
+function (private_request_resource_usage_merged_mapping TARGET)
+    get_target_property (LOCAL_MERGED_MAPPING "${TARGET}" RESOURCE_DIRECTORY_MERGED_MAPPING)
+    if (LOCAL_MERGED_MAPPING STREQUAL "LOCAL_MERGED_MAPPING-NOTFOUND")
+        set (MERGED_MAPPING)
+        private_add_direct_resources_to_merged_mapping ("${TARGET}")
+        sober_find_linked_targets_recursively ("${TARGET}" ALL_LINKED_TARGETS)
+
+        foreach (LINKED_TARGET ${ALL_LINKED_TARGETS})
+            private_add_direct_resources_to_merged_mapping ("${LINKED_TARGET}")
+        endforeach ()
+
+        set (LOCAL_MERGED_MAPPING "${MERGED_MAPPING}")
+        set_target_properties ("${TARGET}" PROPERTIES RESOURCE_DIRECTORY_MERGED_MAPPING "${LOCAL_MERGED_MAPPING}")
+    endif ()
+
+    set (MERGED_MAPPING "${LOCAL_MERGED_MAPPING}" PARENT_SCOPE)
+endfunction ()
+
 # Deploys mount lists for all resources, used by given target and its dependencies, into given deploy directory.
 # One mount list is created for every group: MountCoreResources.yaml, MountTestResources.yaml, etc.
 # Mount grouping makes it easy to mount and unmount resources at runtime using game-specific logic: for example
 # mount and register one resource set for jungle environment and other for desert environment (while using core
 # resource group all the time).
 function (deploy_resource_mount_lists TARGET DEPLOY_DIRECTORY)
     set (MERGED_MAPPING)
-    private_add_direct_resources_to_merged_mapping ("${TARGET}")
-    sober_find_linked_targets_recursively ("${TARGET}" ALL_LINKED_TARGETS)
-
-    foreach (LINKED_TARGET ${ALL_LINKED_TARGETS})
-        private_add_direct_resources_to_merged_mapping ("${LINKED_TARGET}")
-    endforeach ()
+    private_request_resource_usage_merged_mapping ("${TARGET}")
 
     # Make sure that deploy root exists.
     file (MAKE_DIRECTORY "${DEPLOY_DIRECTORY}")
@@ -203,3 +224,124 @@ function (register_bgfx_shaders SOURCE_DIRECTORY BINARY_DIRECTORY)
         unset (SHADER_COMPILATION_COMMANDS)
     endforeach ()
 endfunction ()
+
+# Sets up resource cooking targets and distribution packaging targets for given target.
+# Parameters:
+#    TARGET: Target which resources we're cooking and that we're planning to distribute.
+#    COOKER_TARGET: Target executable that is used for cooking resources. Must accept following parameters:
+#        --groupName: Name of the mount group to fetch mount list and correctly name final results.
+#        --mountListDirectory: Path to directory with all mount lists of given target.
+#        --workspace: Path to the workspace directory.
+#    MOUNT_LIST_DIRECTORY: Path to directory where all mount lists of TARGET are stored.
+#    COOKING_WORKSPACE: Path to directory where cooking routines may store intermediate files and final results.
+#    PACKAGING_OUTPUT: Path to directory when packaging result (game and resources) should be stored.
+function (setup_resource_cooking_and_packaging
+        TARGET COOKER_TARGET MOUNT_LIST_DIRECTORY COOKING_WORKSPACE PACKAGING_OUTPUT)
+
+    set (MERGED_MAPPING)
+    private_request_resource_usage_merged_mapping ("${TARGET}")
+    set (GROUPS)
+
+    list (LENGTH MERGED_MAPPING MERGED_MAPPING_LENGTH)
+    if (MERGED_MAPPING_LENGTH GREATER 0)
+        math (EXPR LAST_INDEX "${MERGED_MAPPING_LENGTH} - 3")
+
+        foreach (INDEX RANGE 0 ${LAST_INDEX} 3)
+            math (EXPR "GROUP_INDEX" "${INDEX} + 2")
+            list (GET MERGED_MAPPING ${GROUP_INDEX} GROUP)
+            list (FIND GROUPS "${GROUP}" GROUP_INDEX_IN_LIST)
+
+            if (GROUP_INDEX_IN_LIST EQUAL -1)
+                list (APPEND GROUPS "${GROUP}")
+            endif ()
+        endforeach ()
+    endif ()
+
+    set (COOKING_MAIN_TARGET "${TARGET}AllResourceCooking")
+    add_custom_target (
+            "${COOKING_MAIN_TARGET}"
+            COMMENT "Cooking all resources for target \"${TARGET}\".")
+
+    set (COOKING_MAIN_CLEAN_TARGET "${TARGET}AllResourceCookingClean")
+    add_custom_target (
+            "${COOKING_MAIN_CLEAN_TARGET}"
+            COMMENT "Cleaning cooking workspace of \"${TARGET}\".")
+
+    set (PACKAGING_MAIN_TARGET "${TARGET}Packaging")
+    add_custom_target (
+            "${PACKAGING_MAIN_TARGET}"
+            COMMENT "Packaging target \"${TARGET}\" executable."
+            COMMAND
+            ${CMAKE_COMMAND} -E copy $<TARGET_FILE:${TARGET}> "${PACKAGING_OUTPUT}"
+            VERBATIM)
+    add_dependencies ("${PACKAGING_MAIN_TARGET}" ${TARGET})
+
+    set (PACKAGING_CLEAN_TARGET "${TARGET}PackageClean")
+    add_custom_target (
+            "${PACKAGING_CLEAN_TARGET}"
+            COMMENT "Cleaning packaging output of \"${TARGET}\"."
+            COMMAND ${CMAKE_COMMAND} -E remove_directory "${PACKAGING_OUTPUT}"
+            COMMAND ${CMAKE_COMMAND} -E make_directory "${PACKAGING_OUTPUT}"
+            VERBATIM)
+
+    foreach (GROUP ${GROUPS})
+        set (COOKING_TARGET "${TARGET}${GROUP}Cooking")
+        add_custom_target (
+                "${COOKING_TARGET}"
+                COMMENT "Cooking resource group \"${GROUP}\" for \"${TARGET}\"."
+                COMMAND
+                $<TARGET_FILE:${COOKER_TARGET}>
+                "--groupName" "${GROUP}"
+                "--mountListDirectory" "${MOUNT_LIST_DIRECTORY}"
+                "--workspace" "${COOKING_WORKSPACE}/${GROUP}"
+                VERBATIM)
+
+        add_dependencies ("${COOKING_TARGET}" "${COOKER_TARGET}")
+        add_dependencies ("${COOKING_MAIN_TARGET}" "${COOKING_TARGET}")
+
+        set (COOKING_CLEAN_TARGET "${TARGET}${GROUP}CookingClean")
+        add_custom_target (
+                "${COOKING_CLEAN_TARGET}"
+                COMMENT "Cleaning cooking workspace for \"${GROUP}\" for \"${TARGET}\"."
+                COMMAND ${CMAKE_COMMAND} -E remove_directory "${COOKING_WORKSPACE}/${GROUP}"
+                VERBATIM)
+        add_dependencies ("${COOKING_MAIN_CLEAN_TARGET}" "${COOKING_CLEAN_TARGET}")
+
+        set (PACKAGING_TARGET "${TARGET}${GROUP}Packaging")
+        add_custom_target (
+                "${PACKAGING_TARGET}"
+                COMMENT "Packaging resource group \"${GROUP}\" for \"${TARGET}\"."
+                COMMAND
+                ${CMAKE_COMMAND} -E copy_directory
+                "${COOKING_WORKSPACE}/${GROUP}/FinalResult" "${PACKAGING_OUTPUT}"
+                VERBATIM)
+
+        add_dependencies ("${PACKAGING_TARGET}" "${PACKAGING_CLEAN_TARGET}" "${COOKING_TARGET}")
+        add_dependencies ("${PACKAGING_MAIN_TARGET}" "${PACKAGING_TARGET}")
+    endforeach ()
+
+    find_required_shared_libraries ("${TARGET}" REQUIRED_LIBRARIES)
+    foreach (LIBRARY_TARGET ${REQUIRED_LIBRARIES})
+        set (PACKAGING_TARGET "${TARGET}${LIBRARY_TARGET}Packaging")
+        string (REPLACE "::" "_" PACKAGING_TARGET "${PACKAGING_TARGET}")
+
+        if (UNIX)
+            add_custom_target (
+                    ${PACKAGING_TARGET}
+                    COMMENT "Packaging \"${LIBRARY_TARGET}\" dependency of \"${TARGET}\"."
+                    COMMAND
+                    ${CMAKE_COMMAND} -E copy $<TARGET_SONAME_FILE:${LIBRARY_TARGET}> "${PACKAGING_OUTPUT}"
+                    VERBATIM)
+        else ()
+            add_custom_target (
+                    ${PACKAGING_TARGET}
+                    COMMENT "Packaging \"${LIBRARY_TARGET}\" dependency of \"${TARGET}\"."
+                    COMMAND
+                    ${CMAKE_COMMAND} -E copy $<TARGET_FILE:${LIBRARY_TARGET}> "${PACKAGING_OUTPUT}"
+                    VERBATIM)
+        endif ()
+
+        add_dependencies ("${PACKAGING_TARGET}" "${PACKAGING_CLEAN_TARGET}")
+        add_dependencies ("${PACKAGING_MAIN_TARGET}" "${PACKAGING_TARGET}")
+    endforeach ()
+endfunction ()

CMake/Emergence/Utility.cmake

@@ -1,11 +1,43 @@
+# Traverses linked libraries tree of given target and outputs all shared libraries to output list with given name.
+function (find_required_shared_libraries TARGET OUTPUT_VARIABLE)
+    set (LIBRARIES)
+    sober_find_linked_targets_recursively ("${TARGET}" ALL_LINKED_TARGETS)
+
+    foreach (LINKED_TARGET ${ALL_LINKED_TARGETS})
+        get_target_property (TARGET_TYPE "${LINKED_TARGET}" TYPE)
+        if (TARGET_TYPE STREQUAL "SHARED_LIBRARY")
+            list (APPEND LIBRARIES "${LINKED_TARGET}")
+        endif ()
+    endforeach ()
+
+    set ("${OUTPUT_VARIABLE}" "${LIBRARIES}" PARENT_SCOPE)
+endfunction ()
+
 # Adds custom command that copies shared libraries, requested by given target.
-# Currently, only Windows platform is supported as there is no TARGET_RUNTIME_DLLS on other platforms.
+# On Unix platforms also forces Windows-like SO search behaviour by settings build rpath to $ORIGIN.
 function (copy_required_shared_libraries TARGET)
-    if (WIN32)
-        add_custom_command (
-                TARGET "${TARGET}" POST_BUILD
-                COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_RUNTIME_DLLS:${TARGET}> $<TARGET_FILE_DIR:${TARGET}>
-                COMMAND_EXPAND_LISTS)
+    find_required_shared_libraries ("${TARGET}" REQUIRED_LIBRARIES)
+    foreach (LIBRARY_TARGET ${REQUIRED_LIBRARIES})
+        if (UNIX)
+            add_custom_command (
+                    TARGET "${TARGET}" POST_BUILD
+                    COMMAND
+                    ${CMAKE_COMMAND} -E copy_if_different
+                    $<TARGET_SONAME_FILE:${LIBRARY_TARGET}> $<TARGET_FILE_DIR:${TARGET}>
+                    COMMAND_EXPAND_LISTS)
+        else ()
+            add_custom_command (
+                    TARGET "${TARGET}" POST_BUILD
+                    COMMAND
+                    ${CMAKE_COMMAND} -E copy_if_different
+                    $<TARGET_FILE:${LIBRARY_TARGET}> $<TARGET_FILE_DIR:${TARGET}>
+                    COMMAND_EXPAND_LISTS)
+        endif ()
+    endforeach ()
+
+    # Force Windows-like behaviour on rpath-driven unix builds.
+    if (UNIX)
+        set_target_properties ("${TARGET}" PROPERTIES BUILD_RPATH "\$ORIGIN")
     endif ()
 endfunction ()
 

CMakeLists.txt

@@ -12,11 +12,11 @@ else ()
     set (CMAKE_CXX_STANDARD 23)
 endif ()
 
+include ("${CMAKE_CURRENT_SOURCE_DIR}/CMake/Sober/Sober.cmake")
 include ("${CMAKE_CURRENT_SOURCE_DIR}/CMake/Emergence/GlobalOptions.cmake")
 include ("${CMAKE_CURRENT_SOURCE_DIR}/CMake/Emergence/PhysX.cmake")
 include ("${CMAKE_CURRENT_SOURCE_DIR}/CMake/Emergence/Resource.cmake")
 include ("${CMAKE_CURRENT_SOURCE_DIR}/CMake/Emergence/Utility.cmake")
-include ("${CMAKE_CURRENT_SOURCE_DIR}/CMake/Sober/Sober.cmake")
 
 # Must be called from root CMakeLists.txt, otherwise CTest configuration won't be placed into binary root.
 enable_testing ()

Coverage.json

@@ -68,6 +68,30 @@
       "Action": "Exclude",
       "Reason": "Math classes and methods are not tested separately from other libraries. Should be changed later."
     },
+    {
+      "Prefix": "./Library/Public/ResourceCooking/Resource/Cooking/Context.cpp",
+      "Action": "CustomMinimumCoverage",
+      "MinimumLinesCoveragePerFilePercent": 55.0,
+      "Reason": "Large part of this file is error logging and it isn't covered as we have no negative tests for now."
+    },
+    {
+      "Prefix": "./Library/Public/ResourceCooking/Resource/Cooking/Pass",
+      "Action": "CustomMinimumCoverage",
+      "MinimumLinesCoveragePerFilePercent": 50.0,
+      "Reason": "Currently we're only checking pass positive results and do not check error logging, therefore coverage is low. Might be changed later."
+    },
+    {
+      "Prefix": "./Library/Public/ResourceCooking/Resource/Cooking/ResourceList.cpp",
+      "Action": "CustomMinimumCoverage",
+      "MinimumLinesCoveragePerFilePercent": 55.0,
+      "Reason": "This class serves as a top-level utility wrapper around record collection and not all its features are needed in the code right now."
+    },
+    {
+      "Prefix": "./Library/Public/ResourceCooking/Resource/Cooking/Result",
+      "Action": "CustomMinimumCoverage",
+      "MinimumLinesCoveragePerFilePercent": 48.0,
+      "Reason": "Currently we're only checking positive results and do not check error logging, therefore coverage is low. Might be changed later."
+    },
     {
       "Prefix": "./Library/Public/ResourceObject/Resource/Object/LibraryLoader.cpp",
       "Action": "CustomMinimumCoverage",
@@ -109,6 +133,18 @@
       "MinimumLinesCoveragePerFilePercent": 65.0,
       "Reason": "This class has a lots of error handling logic that isn't covered because we're aren't writing negative tests for now."
     },
+    {
+      "Prefix": "./Service/ResourceProvider/Implementation/Original/Resource/Provider/Original/ResourceProvider.hpp",
+      "Action": "CustomMinimumCoverage",
+      "MinimumLinesCoveragePerFilePercent": 70.0,
+      "Reason": "Defaulted cursor copy is not yet used anywhere, therefore coverage is lower than 75%."
+    },
+    {
+      "Prefix": "./Service/VirtualFileSystem/API/VirtualFileSystem/Helpers.hpp",
+      "Action": "CustomMinimumCoverage",
+      "MinimumLinesCoveragePerFilePercent": 20.0,
+      "Reason": "The bigger function is only used in visual tests and therefore is not being executed on CI."
+    },
     {
       "Prefix": "./Service/VirtualFileSystem/Implementation/Original/VirtualFileSystem/MountConfiguration.cpp",
       "Action": "Exclude",

Executable/MemoryRecordingClient/CMakeLists.txt

@@ -11,9 +11,8 @@ sober_library_begin (MemoryRecordingClient OBJECT)
 
     sober_library_link_library (PRIVATE ${CONTAINER_LIBRARY_TARGET})
     sober_library_link_library (PRIVATE ${MEMORY_RECORDING_LIBRARY_TARGET})
-    sober_library_link_library (PRIVATE SDL2)
-    sober_library_link_library (PRIVATE SDL2ImGUI)
-    sober_library_link_library (PRIVATE SDL2main)
+    sober_library_link_library (PRIVATE SDL3::SDL3)
+    sober_library_link_library (PRIVATE SDL3ImGUI)
 
     sober_library_use_service (SHARED PRIVATE Assert)
     sober_library_use_service (SHARED PRIVATE CPUProfiler)