diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index 371a72f1..bc115ac5 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -78,6 +78,7 @@ jobs: ./ObjLoadingTests ./ObjWritingTests ./ParserTests + ./SystemTests ./ZoneCodeGeneratorLibTests ./ZoneCommonTests @@ -138,6 +139,8 @@ jobs: $combinedExitCode = [System.Math]::max($combinedExitCode, $LASTEXITCODE) ./ParserTests $combinedExitCode = [System.Math]::max($combinedExitCode, $LASTEXITCODE) + ./SystemTests + $combinedExitCode = [System.Math]::max($combinedExitCode, $LASTEXITCODE) ./ZoneCodeGeneratorLibTests $combinedExitCode = [System.Math]::max($combinedExitCode, $LASTEXITCODE) ./ZoneCommonTests diff --git a/premake5.lua b/premake5.lua index e1c1575a..f03b5c3a 100644 --- a/premake5.lua +++ b/premake5.lua @@ -129,11 +129,13 @@ group "" include "src/Common.lua" include "src/Cryptography.lua" include "src/ImageConverter.lua" -include "src/Linker.lua" +include "src/LinkerCli.lua" +include "src/Linking.lua" include "src/ModMan.lua" include "src/Parser.lua" include "src/RawTemplater.lua" -include "src/Unlinker.lua" +include "src/UnlinkerCli.lua" +include "src/Unlinking.lua" include "src/Utils.lua" include "src/ZoneCode.lua" include "src/ZoneCodeGeneratorLib.lua" @@ -165,6 +167,8 @@ group "Components" ObjImage:project() ObjLoading:project() ObjWriting:project() + Linking:project() + Unlinking:project() group "" -- Tools group: All projects that compile into the final tools @@ -175,8 +179,8 @@ group "" -- Tools group: All projects that compile into the final tools group "Tools" - Linker:project() - Unlinker:project() + LinkerCli:project() + UnlinkerCli:project() ImageConverter:project() if _OPTIONS["modman"] then @@ -199,6 +203,7 @@ include "test/ObjLoadingTests.lua" include "test/ObjWritingTests.lua" include "test/ParserTestUtils.lua" include "test/ParserTests.lua" +include "test/SystemTests.lua" include "test/ZoneCodeGeneratorLibTests.lua" include "test/ZoneCommonTests.lua" @@ -212,6 +217,7 @@ group "Tests" ObjWritingTests:project() ParserTestUtils:project() ParserTests:project() + SystemTests:project() ZoneCodeGeneratorLibTests:project() ZoneCommonTests:project() group "" diff --git a/src/Common/Game/IAsset.h b/src/Common/Game/IAsset.h index 0cd7d6fd..d51b2abe 100644 --- a/src/Common/Game/IAsset.h +++ b/src/Common/Game/IAsset.h @@ -18,11 +18,11 @@ public: template struct AssetNameAccessor { -public: static_assert(std::is_base_of_v); // static constexpr bool IS_SINGLETON = false; + // using RETURN_TYPE = const char*&; - // const char*& operator()(AssetType::Type& asset) + // static RETURN_TYPE GetAssetName(assetType::Type& asset) // { // throw std::runtime_error("Not implemented"); // } @@ -34,8 +34,9 @@ public: public: \ static_assert(std::is_base_of_v); \ static constexpr bool IS_SINGLETON = false; \ + using RETURN_TYPE = const char*&; \ \ - const char*& operator()(assetType::Type& asset) \ + static RETURN_TYPE GetAssetName(assetType::Type& asset) \ { \ return asset.nameProperty; \ } \ @@ -47,10 +48,17 @@ public: public: \ static_assert(std::is_base_of_v); \ static constexpr bool IS_SINGLETON = true; \ + using RETURN_TYPE = const char* const&; \ \ - const char* const& operator()(assetType::Type& asset) \ + static RETURN_TYPE GetAssetName(assetType::Type& asset) \ { \ static const char* NAME = singletonName; \ return NAME; \ } \ } + +template AssetNameAccessor::RETURN_TYPE AssetName(typename AssetType::Type& asset) +{ + static_assert(std::is_base_of_v); + return AssetNameAccessor::GetAssetName(asset); +} diff --git a/src/Linker.lua b/src/Linker.lua deleted file mode 100644 index a4a736d7..00000000 --- a/src/Linker.lua +++ /dev/null @@ -1,56 +0,0 @@ -Linker = {} - -function Linker:include(includes) - if includes:handle(self:name()) then - includedirs { - path.join(ProjectFolder(), "Linker") - } - end -end - -function Linker:link(links) - -end - -function Linker:use() - dependson(self:name()) -end - -function Linker:name() - return "Linker" -end - -function Linker:project() - local folder = ProjectFolder() - local includes = Includes:create() - local links = Links:create() - - project(self:name()) - targetdir(TargetDirectoryBin) - location "%{wks.location}/src/%{prj.name}" - kind "ConsoleApp" - language "C++" - - files { - path.join(folder, "Linker/**.h"), - path.join(folder, "Linker/**.cpp") - } - - self:include(includes) - Utils:include(includes) - ZoneLoading:include(includes) - ObjCompiling:include(includes) - ObjLoading:include(includes) - ObjWriting:include(includes) - ZoneWriting:include(includes) - - Raw:use() - - links:linkto(Utils) - links:linkto(ObjCompiling) - links:linkto(ZoneLoading) - links:linkto(ZoneWriting) - links:linkto(ObjLoading) - links:linkto(ObjWriting) - links:linkall() -end diff --git a/src/Linker/Linker.cpp b/src/Linker/Linker.cpp deleted file mode 100644 index e62109a5..00000000 --- a/src/Linker/Linker.cpp +++ /dev/null @@ -1,480 +0,0 @@ -#include "Linker.h" - -#include "LinkerArgs.h" -#include "LinkerPaths.h" -#include "ObjContainer/SoundBank/SoundBankWriter.h" -#include "ObjWriting.h" -#include "SearchPath/OutputPathFilesystem.h" -#include "SearchPath/SearchPaths.h" -#include "Utils/Logging/Log.h" -#include "Utils/ObjFileStream.h" -#include "Zone/AssetList/AssetList.h" -#include "Zone/AssetList/AssetListReader.h" -#include "Zone/Definition/ZoneDefinitionStream.h" -#include "ZoneCreation/ZoneCreationContext.h" -#include "ZoneCreation/ZoneCreator.h" -#include "ZoneLoading.h" -#include "ZoneWriting.h" - -#include -#include -#include -#include -#include - -namespace fs = std::filesystem; - -namespace -{ - class LinkerSearchPathContext - { - public: - explicit LinkerSearchPathContext(const ILinkerSearchPathBuilder& searchPathBuilder) - : m_search_path_builder(searchPathBuilder) - { - m_independent_search_paths = m_search_path_builder.BuildIndependentSearchPaths(); - if (m_independent_search_paths) - m_search_paths.IncludeSearchPath(m_independent_search_paths.get()); - } - - [[nodiscard]] ISearchPath& GetSearchPaths() - { - return m_search_paths; - } - - void LoadProjectSpecific(const std::string& projectName) - { - m_project_specific_search_paths = m_search_path_builder.BuildSearchPathsSpecificToProject(projectName); - if (m_project_specific_search_paths) - m_search_paths.IncludeSearchPath(m_project_specific_search_paths.get()); - } - - void UnloadProjectSpecific() - { - if (!m_project_specific_search_paths) - return; - - m_search_paths.RemoveSearchPath(m_project_specific_search_paths.get()); - m_project_specific_search_paths.reset(); - } - - void LoadGameSpecific(const std::string& projectName, const GameId game) - { - m_game_specific_search_paths = m_search_path_builder.BuildSearchPathsSpecificToProjectAndGame(projectName, game); - if (m_game_specific_search_paths) - m_search_paths.IncludeSearchPath(m_game_specific_search_paths.get()); - } - - void UnloadGameSpecific() - { - if (!m_game_specific_search_paths) - return; - - m_search_paths.RemoveSearchPath(m_game_specific_search_paths.get()); - m_game_specific_search_paths.reset(); - } - - private: - const ILinkerSearchPathBuilder& m_search_path_builder; - std::unique_ptr m_independent_search_paths; - std::unique_ptr m_project_specific_search_paths; - std::unique_ptr m_game_specific_search_paths; - SearchPaths m_search_paths; - }; - - class LinkerPathManager - { - public: - explicit LinkerPathManager(const LinkerArgs& args) - : m_linker_paths(ILinkerPaths::FromArgs(args)), - m_asset_paths(m_linker_paths->AssetSearchPaths()), - m_gdt_paths(m_linker_paths->GdtSearchPaths()), - m_source_paths(m_linker_paths->SourceSearchPaths()) - { - } - - std::unique_ptr m_linker_paths; - LinkerSearchPathContext m_asset_paths; - LinkerSearchPathContext m_gdt_paths; - LinkerSearchPathContext m_source_paths; - }; - - class PathProjectContext - { - public: - PathProjectContext(LinkerPathManager& paths, const std::string& projectName) - : m_paths(paths) - { - m_paths.m_asset_paths.LoadProjectSpecific(projectName); - m_paths.m_gdt_paths.LoadProjectSpecific(projectName); - m_paths.m_source_paths.LoadProjectSpecific(projectName); - } - - ~PathProjectContext() - { - m_paths.m_asset_paths.UnloadProjectSpecific(); - m_paths.m_gdt_paths.UnloadProjectSpecific(); - m_paths.m_source_paths.UnloadProjectSpecific(); - } - - PathProjectContext(const PathProjectContext& other) = delete; - PathProjectContext(PathProjectContext&& other) noexcept = delete; - PathProjectContext& operator=(const PathProjectContext& other) = delete; - PathProjectContext& operator=(PathProjectContext&& other) noexcept = delete; - - private: - LinkerPathManager& m_paths; - }; - - class PathGameContext - { - public: - PathGameContext(LinkerPathManager& paths, const std::string& projectName, const GameId game) - : m_paths(paths) - { - m_paths.m_asset_paths.LoadGameSpecific(projectName, game); - m_paths.m_gdt_paths.LoadGameSpecific(projectName, game); - m_paths.m_source_paths.LoadGameSpecific(projectName, game); - } - - ~PathGameContext() - { - m_paths.m_asset_paths.UnloadGameSpecific(); - m_paths.m_gdt_paths.UnloadGameSpecific(); - m_paths.m_source_paths.UnloadGameSpecific(); - } - - PathGameContext(const PathGameContext& other) = delete; - PathGameContext(PathGameContext&& other) noexcept = delete; - PathGameContext& operator=(const PathGameContext& other) = delete; - PathGameContext& operator=(PathGameContext&& other) noexcept = delete; - - private: - LinkerPathManager& m_paths; - }; -} // namespace - -class LinkerImpl final : public Linker -{ - std::unique_ptr ReadZoneDefinition(LinkerPathManager& paths, const std::string& targetName, bool logMissing = true) const - { - auto& sourceSearchPath = paths.m_source_paths.GetSearchPaths(); - std::unique_ptr zoneDefinition; - { - const auto definitionFileName = std::format("{}.zone", targetName); - const auto definitionStream = sourceSearchPath.Open(definitionFileName); - if (!definitionStream.IsOpen()) - { - if (logMissing) - con::error("Could not find zone definition file for target \"{}\".", targetName); - return nullptr; - } - - ZoneDefinitionInputStream zoneDefinitionInputStream(*definitionStream.m_stream, targetName, definitionFileName, sourceSearchPath); - zoneDefinition = zoneDefinitionInputStream.ReadDefinition(); - } - - if (!zoneDefinition) - { - con::error("Failed to read zone definition file for target \"{}\".", targetName); - return nullptr; - } - - return zoneDefinition; - } - - bool ReadIgnoreEntries(LinkerPathManager& paths, const std::string& zoneName, const GameId game, AssetList& assetList) const - { - { - AssetListReader assetListReader(paths.m_source_paths.GetSearchPaths(), game); - const auto maybeReadAssetList = assetListReader.ReadAssetList(zoneName, false); - if (maybeReadAssetList) - { - assetList.m_entries.reserve(assetList.m_entries.size() + maybeReadAssetList->m_entries.size()); - for (auto& entry : maybeReadAssetList->m_entries) - assetList.m_entries.emplace_back(std::move(entry)); - - return true; - } - } - - { - const auto zoneDefinition = ReadZoneDefinition(paths, zoneName, false); - - if (zoneDefinition) - { - assetList.m_entries.reserve(assetList.m_entries.size() + zoneDefinition->m_assets.size()); - for (const auto& entry : zoneDefinition->m_assets) - assetList.m_entries.emplace_back(entry.m_asset_type, entry.m_asset_name, entry.m_is_reference); - - return true; - } - } - - return false; - } - - bool ProcessZoneDefinitionIgnores(LinkerPathManager& paths, const std::string& targetName, ZoneCreationContext& context) const - { - if (context.m_definition->m_ignores.empty()) - return true; - - for (const auto& ignore : context.m_definition->m_ignores) - { - if (ignore == targetName) - continue; - - if (!ReadIgnoreEntries(paths, ignore, context.m_definition->m_game, context.m_ignored_assets)) - { - con::error("Failed to read asset listing for ignoring assets of project \"{}\".", ignore); - return false; - } - } - return true; - } - - static bool LoadGdtFilesFromZoneDefinition(std::vector>& gdtList, const ZoneDefinition& zoneDefinition, ISearchPath* gdtSearchPath) - { - for (const auto& gdtName : zoneDefinition.m_gdts) - { - const auto gdtFile = gdtSearchPath->Open(std::format("{}.gdt", gdtName)); - if (!gdtFile.IsOpen()) - { - con::error("Failed to open file for gdt \"{}\"", gdtName); - return false; - } - - GdtReader gdtReader(*gdtFile.m_stream); - auto gdt = std::make_unique(); - if (!gdtReader.Read(*gdt)) - { - con::error("Failed to read gdt file \"{}\"", gdtName); - return false; - } - - gdtList.emplace_back(std::move(gdt)); - } - - return true; - } - - std::unique_ptr CreateZoneForDefinition( - LinkerPathManager& paths, const fs::path& outDir, const fs::path& cacheDir, const std::string& targetName, ZoneDefinition& zoneDefinition) const - { - ZoneCreationContext context(&zoneDefinition, &paths.m_asset_paths.GetSearchPaths(), outDir, cacheDir); - if (!ProcessZoneDefinitionIgnores(paths, targetName, context)) - return nullptr; - if (!LoadGdtFilesFromZoneDefinition(context.m_gdt_files, zoneDefinition, &paths.m_gdt_paths.GetSearchPaths())) - return nullptr; - - return zone_creator::CreateZoneForDefinition(zoneDefinition.m_game, context); - } - - static bool WriteZoneToFile(IOutputPath& outPath, const Zone& zone) - { - const auto stream = outPath.Open(std::format("{}.ff", zone.m_name)); - if (!stream) - { - con::error("Failed to open file for zone: {}", zone.m_name); - return false; - } - - con::info("Building zone \"{}\"", zone.m_name); - - if (!ZoneWriting::WriteZone(*stream, zone)) - { - con::error("Writing zone failed."); - return false; - } - - con::info("Created zone \"{}\"", zone.m_name); - - return true; - } - - bool BuildFastFile(LinkerPathManager& paths, const std::string& projectName, const std::string& targetName, ZoneDefinition& zoneDefinition) const - { - const fs::path outDir(paths.m_linker_paths->BuildOutputFolderPath(projectName, zoneDefinition.m_game)); - - OutputPathFilesystem outputPath(outDir); - - const fs::path cacheDir(paths.m_linker_paths->BuildCacheFolderPath(projectName, zoneDefinition.m_game)); - SoundBankWriter::OutputPath = outDir; - - const auto zone = CreateZoneForDefinition(paths, outDir, cacheDir, targetName, zoneDefinition); - auto result = zone != nullptr; - if (zone) - result = WriteZoneToFile(outputPath, *zone); - - return result; - } - - bool BuildProject(LinkerPathManager& paths, const std::string& projectName, const std::string& targetName) const - { - std::deque targetsToBuild; - std::unordered_set alreadyBuiltTargets; - - targetsToBuild.emplace_back(targetName); - - while (!targetsToBuild.empty()) - { - const auto currentTarget = std::move(targetsToBuild.front()); - targetsToBuild.pop_front(); - alreadyBuiltTargets.emplace(currentTarget); - - PathProjectContext projectContext(paths, projectName); - - const auto zoneDefinition = ReadZoneDefinition(paths, targetName); - if (!zoneDefinition) - return false; - - PathGameContext gameContext(paths, projectName, zoneDefinition->m_game); - - if (!zoneDefinition->m_assets.empty()) - { - if (!BuildFastFile(paths, projectName, targetName, *zoneDefinition)) - return false; - - for (const auto& referencedTarget : zoneDefinition->m_targets_to_build) - { - if (alreadyBuiltTargets.find(referencedTarget) == alreadyBuiltTargets.end()) - { - targetsToBuild.emplace_back(referencedTarget); - con::info("Building referenced target \"{}\"", referencedTarget); - } - } - } - } - - return true; - } - - bool LoadZones() - { - for (const auto& zonePath : m_args.m_zones_to_load) - { - if (!fs::is_regular_file(zonePath)) - { - con::error("Could not find zone file to load \"{}\".", zonePath); - return false; - } - - auto zoneDirectory = fs::path(zonePath).remove_filename(); - if (zoneDirectory.empty()) - zoneDirectory = fs::current_path(); - auto absoluteZoneDirectory = absolute(zoneDirectory).string(); - - auto maybeZone = ZoneLoading::LoadZone(zonePath, std::nullopt); - if (!maybeZone) - { - con::error("Failed to load zone \"{}\": {}", zonePath, maybeZone.error()); - return false; - } - - auto zone = std::move(*maybeZone); - - con::debug("Loaded zone \"{}\"", zone->m_name); - - m_loaded_zones.emplace_back(std::move(zone)); - } - - return true; - } - - void UnloadZones() - { - for (auto i = m_loaded_zones.rbegin(); i != m_loaded_zones.rend(); ++i) - { - auto& loadedZone = *i; - std::string zoneName = loadedZone->m_name; - - loadedZone.reset(); - - con::debug("Unloaded zone \"{}\"", zoneName); - } - m_loaded_zones.clear(); - } - - static bool GetProjectAndTargetFromProjectSpecifier(const std::string& projectSpecifier, std::string& projectName, std::string& targetName) - { - const auto targetNameSeparatorIndex = projectSpecifier.find_first_of('/'); - if (targetNameSeparatorIndex == std::string::npos) - { - projectName = projectSpecifier; - targetName = projectSpecifier; - } - else if (projectSpecifier.find_first_of('/', targetNameSeparatorIndex + 1) != std::string::npos) - { - con::error("Project specifier cannot have more than one target name: \"{}\"", projectSpecifier); - return false; - } - else - { - projectName = projectSpecifier.substr(0, targetNameSeparatorIndex); - targetName = projectSpecifier.substr(targetNameSeparatorIndex + 1); - } - - if (projectName.empty()) - { - con::error("Project name cannot be empty: \"{}\"", projectSpecifier); - return false; - } - - if (targetName.empty()) - { - con::error("Target name cannot be empty: \"{}\"", projectSpecifier); - return false; - } - - return true; - } - -public: - bool Start(const int argc, const char** argv) override - { - con::init(); - - auto shouldContinue = true; - if (!m_args.ParseArgs(argc, argv, shouldContinue)) - return false; - - if (!shouldContinue) - return true; - - LinkerPathManager paths(m_args); - - if (!LoadZones()) - return false; - - auto result = true; - for (const auto& projectSpecifier : m_args.m_project_specifiers_to_build) - { - std::string projectName; - std::string targetName; - if (!GetProjectAndTargetFromProjectSpecifier(projectSpecifier, projectName, targetName)) - { - result = false; - break; - } - - if (!BuildProject(paths, projectName, targetName)) - { - result = false; - break; - } - } - - UnloadZones(); - - return result; - } - -private: - LinkerArgs m_args; - std::vector> m_loaded_zones; -}; - -std::unique_ptr Linker::Create() -{ - return std::make_unique(); -} diff --git a/src/Linker/main.cpp b/src/Linker/main.cpp deleted file mode 100644 index 36f84947..00000000 --- a/src/Linker/main.cpp +++ /dev/null @@ -1,8 +0,0 @@ -#include "Linker.h" - -int main(const int argc, const char** argv) -{ - const auto linker = Linker::Create(); - - return linker->Start(argc, argv) ? 0 : 1; -} diff --git a/src/LinkerCli.lua b/src/LinkerCli.lua new file mode 100644 index 00000000..2c93816e --- /dev/null +++ b/src/LinkerCli.lua @@ -0,0 +1,49 @@ +LinkerCli = {} + +function LinkerCli:include(includes) + if includes:handle(self:name()) then + includedirs { + path.join(ProjectFolder(), "LinkerCli") + } + end +end + +function LinkerCli:link(links) + +end + +function LinkerCli:use() + dependson(self:name()) +end + +function LinkerCli:name() + return "LinkerCli" +end + +function LinkerCli:project() + local folder = ProjectFolder() + local includes = Includes:create() + local links = Links:create() + + project(self:name()) + targetdir(TargetDirectoryBin) + targetname "Linker" + location "%{wks.location}/src/%{prj.name}" + kind "ConsoleApp" + language "C++" + + files { + path.join(folder, "LinkerCli/**.h"), + path.join(folder, "LinkerCli/**.cpp") + } + + self:include(includes) + Utils:include(includes) + Linking:include(includes) + + Raw:use() + + links:linkto(Utils) + links:linkto(Linking) + links:linkall() +end diff --git a/src/LinkerCli/main.cpp b/src/LinkerCli/main.cpp new file mode 100644 index 00000000..0eec80a3 --- /dev/null +++ b/src/LinkerCli/main.cpp @@ -0,0 +1,19 @@ +#include "Linker.h" +#include "Utils/Logging/Log.h" + +int main(const int argc, const char** argv) +{ + con::init(); + + LinkerArgs args; + auto shouldContinue = true; + if (!args.ParseArgs(argc, argv, shouldContinue)) + return 1; + + if (!shouldContinue) + return 0; + + const auto linker = Linker::Create(std::move(args)); + + return linker->Start() ? 0 : 1; +} diff --git a/src/Linking.lua b/src/Linking.lua new file mode 100644 index 00000000..e969ebee --- /dev/null +++ b/src/Linking.lua @@ -0,0 +1,61 @@ +Linking = {} + +function Linking:include(includes) + if includes:handle(self:name()) then + ZoneCommon:include(includes) + includedirs { + path.join(ProjectFolder(), "Linking") + } + end +end + +function Linking:link(links) + links:add(self:name()) + links:linkto(Utils) + links:linkto(ObjCompiling) + links:linkto(ZoneLoading) + links:linkto(ZoneWriting) + links:linkto(ObjLoading) + links:linkto(ObjWriting) +end + +function Linking:use() + +end + +function Linking:name() + return "Linking" +end + +function Linking:project() + local folder = ProjectFolder() + local includes = Includes:create() + + project(self:name()) + targetdir(TargetDirectoryLib) + location "%{wks.location}/src/%{prj.name}" + kind "StaticLib" + language "C++" + + files { + path.join(folder, "Linking/**.h"), + path.join(folder, "Linking/**.cpp") + } + + vpaths { + ["*"] = { + path.join(folder, "Linking") + } + } + + ObjCommon:use() + useSourceTemplating("Linking") + + self:include(includes) + Utils:include(includes) + ZoneLoading:include(includes) + ObjCompiling:include(includes) + ObjLoading:include(includes) + ObjWriting:include(includes) + ZoneWriting:include(includes) +end diff --git a/src/Linking/Linker.cpp b/src/Linking/Linker.cpp new file mode 100644 index 00000000..e2b3e874 --- /dev/null +++ b/src/Linking/Linker.cpp @@ -0,0 +1,476 @@ +#include "Linker.h" + +#include "LinkerArgs.h" +#include "LinkerPaths.h" +#include "ObjContainer/SoundBank/SoundBankWriter.h" +#include "ObjWriting.h" +#include "SearchPath/OutputPathFilesystem.h" +#include "SearchPath/SearchPaths.h" +#include "Utils/Logging/Log.h" +#include "Utils/ObjFileStream.h" +#include "Zone/AssetList/AssetList.h" +#include "Zone/AssetList/AssetListReader.h" +#include "Zone/Definition/ZoneDefinitionStream.h" +#include "ZoneCreation/ZoneCreationContext.h" +#include "ZoneCreation/ZoneCreator.h" +#include "ZoneLoading.h" +#include "ZoneWriting.h" + +#include +#include +#include +#include +#include + +namespace fs = std::filesystem; + +namespace +{ + class LinkerSearchPathContext + { + public: + explicit LinkerSearchPathContext(const ILinkerSearchPathBuilder& searchPathBuilder) + : m_search_path_builder(searchPathBuilder) + { + m_independent_search_paths = m_search_path_builder.BuildIndependentSearchPaths(); + if (m_independent_search_paths) + m_search_paths.IncludeSearchPath(m_independent_search_paths.get()); + } + + [[nodiscard]] ISearchPath& GetSearchPaths() + { + return m_search_paths; + } + + void LoadProjectSpecific(const std::string& projectName) + { + m_project_specific_search_paths = m_search_path_builder.BuildSearchPathsSpecificToProject(projectName); + if (m_project_specific_search_paths) + m_search_paths.IncludeSearchPath(m_project_specific_search_paths.get()); + } + + void UnloadProjectSpecific() + { + if (!m_project_specific_search_paths) + return; + + m_search_paths.RemoveSearchPath(m_project_specific_search_paths.get()); + m_project_specific_search_paths.reset(); + } + + void LoadGameSpecific(const std::string& projectName, const GameId game) + { + m_game_specific_search_paths = m_search_path_builder.BuildSearchPathsSpecificToProjectAndGame(projectName, game); + if (m_game_specific_search_paths) + m_search_paths.IncludeSearchPath(m_game_specific_search_paths.get()); + } + + void UnloadGameSpecific() + { + if (!m_game_specific_search_paths) + return; + + m_search_paths.RemoveSearchPath(m_game_specific_search_paths.get()); + m_game_specific_search_paths.reset(); + } + + private: + const ILinkerSearchPathBuilder& m_search_path_builder; + std::unique_ptr m_independent_search_paths; + std::unique_ptr m_project_specific_search_paths; + std::unique_ptr m_game_specific_search_paths; + SearchPaths m_search_paths; + }; + + class LinkerPathManager + { + public: + explicit LinkerPathManager(const LinkerArgs& args) + : m_linker_paths(ILinkerPaths::FromArgs(args)), + m_asset_paths(m_linker_paths->AssetSearchPaths()), + m_gdt_paths(m_linker_paths->GdtSearchPaths()), + m_source_paths(m_linker_paths->SourceSearchPaths()) + { + } + + std::unique_ptr m_linker_paths; + LinkerSearchPathContext m_asset_paths; + LinkerSearchPathContext m_gdt_paths; + LinkerSearchPathContext m_source_paths; + }; + + class PathProjectContext + { + public: + PathProjectContext(LinkerPathManager& paths, const std::string& projectName) + : m_paths(paths) + { + m_paths.m_asset_paths.LoadProjectSpecific(projectName); + m_paths.m_gdt_paths.LoadProjectSpecific(projectName); + m_paths.m_source_paths.LoadProjectSpecific(projectName); + } + + ~PathProjectContext() + { + m_paths.m_asset_paths.UnloadProjectSpecific(); + m_paths.m_gdt_paths.UnloadProjectSpecific(); + m_paths.m_source_paths.UnloadProjectSpecific(); + } + + PathProjectContext(const PathProjectContext& other) = delete; + PathProjectContext(PathProjectContext&& other) noexcept = delete; + PathProjectContext& operator=(const PathProjectContext& other) = delete; + PathProjectContext& operator=(PathProjectContext&& other) noexcept = delete; + + private: + LinkerPathManager& m_paths; + }; + + class PathGameContext + { + public: + PathGameContext(LinkerPathManager& paths, const std::string& projectName, const GameId game) + : m_paths(paths) + { + m_paths.m_asset_paths.LoadGameSpecific(projectName, game); + m_paths.m_gdt_paths.LoadGameSpecific(projectName, game); + m_paths.m_source_paths.LoadGameSpecific(projectName, game); + } + + ~PathGameContext() + { + m_paths.m_asset_paths.UnloadGameSpecific(); + m_paths.m_gdt_paths.UnloadGameSpecific(); + m_paths.m_source_paths.UnloadGameSpecific(); + } + + PathGameContext(const PathGameContext& other) = delete; + PathGameContext(PathGameContext&& other) noexcept = delete; + PathGameContext& operator=(const PathGameContext& other) = delete; + PathGameContext& operator=(PathGameContext&& other) noexcept = delete; + + private: + LinkerPathManager& m_paths; + }; + + class LinkerImpl final : public Linker + { + public: + LinkerImpl(LinkerArgs args) + : m_args(std::move(args)) + { + } + + bool Start() override + { + LinkerPathManager paths(m_args); + + if (!LoadZones()) + return false; + + auto result = true; + for (const auto& projectSpecifier : m_args.m_project_specifiers_to_build) + { + std::string projectName; + std::string targetName; + if (!GetProjectAndTargetFromProjectSpecifier(projectSpecifier, projectName, targetName)) + { + result = false; + break; + } + + if (!BuildProject(paths, projectName, targetName)) + { + result = false; + break; + } + } + + UnloadZones(); + + return result; + } + + private: + std::unique_ptr ReadZoneDefinition(LinkerPathManager& paths, const std::string& targetName, bool logMissing = true) const + { + auto& sourceSearchPath = paths.m_source_paths.GetSearchPaths(); + std::unique_ptr zoneDefinition; + { + const auto definitionFileName = std::format("{}.zone", targetName); + const auto definitionStream = sourceSearchPath.Open(definitionFileName); + if (!definitionStream.IsOpen()) + { + if (logMissing) + con::error("Could not find zone definition file for target \"{}\".", targetName); + return nullptr; + } + + ZoneDefinitionInputStream zoneDefinitionInputStream(*definitionStream.m_stream, targetName, definitionFileName, sourceSearchPath); + zoneDefinition = zoneDefinitionInputStream.ReadDefinition(); + } + + if (!zoneDefinition) + { + con::error("Failed to read zone definition file for target \"{}\".", targetName); + return nullptr; + } + + return zoneDefinition; + } + + bool ReadIgnoreEntries(LinkerPathManager& paths, const std::string& zoneName, const GameId game, AssetList& assetList) const + { + { + AssetListReader assetListReader(paths.m_source_paths.GetSearchPaths(), game); + const auto maybeReadAssetList = assetListReader.ReadAssetList(zoneName, false); + if (maybeReadAssetList) + { + assetList.m_entries.reserve(assetList.m_entries.size() + maybeReadAssetList->m_entries.size()); + for (auto& entry : maybeReadAssetList->m_entries) + assetList.m_entries.emplace_back(std::move(entry)); + + return true; + } + } + + { + const auto zoneDefinition = ReadZoneDefinition(paths, zoneName, false); + + if (zoneDefinition) + { + assetList.m_entries.reserve(assetList.m_entries.size() + zoneDefinition->m_assets.size()); + for (const auto& entry : zoneDefinition->m_assets) + assetList.m_entries.emplace_back(entry.m_asset_type, entry.m_asset_name, entry.m_is_reference); + + return true; + } + } + + return false; + } + + bool ProcessZoneDefinitionIgnores(LinkerPathManager& paths, const std::string& targetName, ZoneCreationContext& context) const + { + if (context.m_definition->m_ignores.empty()) + return true; + + for (const auto& ignore : context.m_definition->m_ignores) + { + if (ignore == targetName) + continue; + + if (!ReadIgnoreEntries(paths, ignore, context.m_definition->m_game, context.m_ignored_assets)) + { + con::error("Failed to read asset listing for ignoring assets of project \"{}\".", ignore); + return false; + } + } + return true; + } + + static bool LoadGdtFilesFromZoneDefinition(std::vector>& gdtList, const ZoneDefinition& zoneDefinition, ISearchPath* gdtSearchPath) + { + for (const auto& gdtName : zoneDefinition.m_gdts) + { + const auto gdtFile = gdtSearchPath->Open(std::format("{}.gdt", gdtName)); + if (!gdtFile.IsOpen()) + { + con::error("Failed to open file for gdt \"{}\"", gdtName); + return false; + } + + GdtReader gdtReader(*gdtFile.m_stream); + auto gdt = std::make_unique(); + if (!gdtReader.Read(*gdt)) + { + con::error("Failed to read gdt file \"{}\"", gdtName); + return false; + } + + gdtList.emplace_back(std::move(gdt)); + } + + return true; + } + + std::unique_ptr CreateZoneForDefinition( + LinkerPathManager& paths, const fs::path& outDir, const fs::path& cacheDir, const std::string& targetName, ZoneDefinition& zoneDefinition) const + { + ZoneCreationContext context(&zoneDefinition, &paths.m_asset_paths.GetSearchPaths(), outDir, cacheDir); + if (!ProcessZoneDefinitionIgnores(paths, targetName, context)) + return nullptr; + if (!LoadGdtFilesFromZoneDefinition(context.m_gdt_files, zoneDefinition, &paths.m_gdt_paths.GetSearchPaths())) + return nullptr; + + return zone_creator::CreateZoneForDefinition(zoneDefinition.m_game, context); + } + + static bool WriteZoneToFile(IOutputPath& outPath, const Zone& zone) + { + const auto stream = outPath.Open(std::format("{}.ff", zone.m_name)); + if (!stream) + { + con::error("Failed to open file for zone: {}", zone.m_name); + return false; + } + + con::info("Building zone \"{}\"", zone.m_name); + + if (!ZoneWriting::WriteZone(*stream, zone)) + { + con::error("Writing zone failed."); + return false; + } + + con::info("Created zone \"{}\"", zone.m_name); + + return true; + } + + bool BuildFastFile(LinkerPathManager& paths, const std::string& projectName, const std::string& targetName, ZoneDefinition& zoneDefinition) const + { + const fs::path outDir(paths.m_linker_paths->BuildOutputFolderPath(projectName, zoneDefinition.m_game)); + + OutputPathFilesystem outputPath(outDir); + + const fs::path cacheDir(paths.m_linker_paths->BuildCacheFolderPath(projectName, zoneDefinition.m_game)); + SoundBankWriter::OutputPath = outDir; + + const auto zone = CreateZoneForDefinition(paths, outDir, cacheDir, targetName, zoneDefinition); + auto result = zone != nullptr; + if (zone) + result = WriteZoneToFile(outputPath, *zone); + + return result; + } + + bool BuildProject(LinkerPathManager& paths, const std::string& projectName, const std::string& targetName) const + { + std::deque targetsToBuild; + std::unordered_set alreadyBuiltTargets; + + targetsToBuild.emplace_back(targetName); + + while (!targetsToBuild.empty()) + { + const auto currentTarget = std::move(targetsToBuild.front()); + targetsToBuild.pop_front(); + alreadyBuiltTargets.emplace(currentTarget); + + PathProjectContext projectContext(paths, projectName); + + const auto zoneDefinition = ReadZoneDefinition(paths, targetName); + if (!zoneDefinition) + return false; + + PathGameContext gameContext(paths, projectName, zoneDefinition->m_game); + + if (!zoneDefinition->m_assets.empty()) + { + if (!BuildFastFile(paths, projectName, targetName, *zoneDefinition)) + return false; + + for (const auto& referencedTarget : zoneDefinition->m_targets_to_build) + { + if (alreadyBuiltTargets.find(referencedTarget) == alreadyBuiltTargets.end()) + { + targetsToBuild.emplace_back(referencedTarget); + con::info("Building referenced target \"{}\"", referencedTarget); + } + } + } + } + + return true; + } + + bool LoadZones() + { + for (const auto& zonePath : m_args.m_zones_to_load) + { + if (!fs::is_regular_file(zonePath)) + { + con::error("Could not find zone file to load \"{}\".", zonePath); + return false; + } + + auto zoneDirectory = fs::path(zonePath).remove_filename(); + if (zoneDirectory.empty()) + zoneDirectory = fs::current_path(); + auto absoluteZoneDirectory = absolute(zoneDirectory).string(); + + auto maybeZone = ZoneLoading::LoadZone(zonePath, std::nullopt); + if (!maybeZone) + { + con::error("Failed to load zone \"{}\": {}", zonePath, maybeZone.error()); + return false; + } + + auto zone = std::move(*maybeZone); + + con::debug("Loaded zone \"{}\"", zone->m_name); + + m_loaded_zones.emplace_back(std::move(zone)); + } + + return true; + } + + void UnloadZones() + { + for (auto i = m_loaded_zones.rbegin(); i != m_loaded_zones.rend(); ++i) + { + auto& loadedZone = *i; + std::string zoneName = loadedZone->m_name; + + loadedZone.reset(); + + con::debug("Unloaded zone \"{}\"", zoneName); + } + m_loaded_zones.clear(); + } + + static bool GetProjectAndTargetFromProjectSpecifier(const std::string& projectSpecifier, std::string& projectName, std::string& targetName) + { + const auto targetNameSeparatorIndex = projectSpecifier.find_first_of('/'); + if (targetNameSeparatorIndex == std::string::npos) + { + projectName = projectSpecifier; + targetName = projectSpecifier; + } + else if (projectSpecifier.find_first_of('/', targetNameSeparatorIndex + 1) != std::string::npos) + { + con::error("Project specifier cannot have more than one target name: \"{}\"", projectSpecifier); + return false; + } + else + { + projectName = projectSpecifier.substr(0, targetNameSeparatorIndex); + targetName = projectSpecifier.substr(targetNameSeparatorIndex + 1); + } + + if (projectName.empty()) + { + con::error("Project name cannot be empty: \"{}\"", projectSpecifier); + return false; + } + + if (targetName.empty()) + { + con::error("Target name cannot be empty: \"{}\"", projectSpecifier); + return false; + } + + return true; + } + + LinkerArgs m_args; + std::vector> m_loaded_zones; + }; +} // namespace + +std::unique_ptr Linker::Create(LinkerArgs args) +{ + return std::make_unique(std::move(args)); +} diff --git a/src/Linker/Linker.h b/src/Linking/Linker.h similarity index 53% rename from src/Linker/Linker.h rename to src/Linking/Linker.h index 06bb0cb0..d233cd05 100644 --- a/src/Linker/Linker.h +++ b/src/Linking/Linker.h @@ -1,16 +1,15 @@ #pragma once + +#include "LinkerArgs.h" + #include class Linker { public: - Linker() = default; virtual ~Linker() = default; - Linker(const Linker& other) = delete; - Linker(Linker&& other) noexcept = delete; - Linker& operator=(const Linker& other) = delete; - Linker& operator=(Linker&& other) noexcept = delete; + static std::unique_ptr Create(LinkerArgs args); /** * \brief Starts the Linker application logic. @@ -18,7 +17,5 @@ public: * \param argv The command line arguments. * \return \c true if the application was successful or \c false if an error occurred. */ - virtual bool Start(int argc, const char** argv) = 0; - - static std::unique_ptr Create(); + virtual bool Start() = 0; }; diff --git a/src/Linker/LinkerArgs.cpp b/src/Linking/LinkerArgs.cpp similarity index 100% rename from src/Linker/LinkerArgs.cpp rename to src/Linking/LinkerArgs.cpp diff --git a/src/Linker/LinkerArgs.h b/src/Linking/LinkerArgs.h similarity index 100% rename from src/Linker/LinkerArgs.h rename to src/Linking/LinkerArgs.h diff --git a/src/Linker/LinkerPaths.cpp b/src/Linking/LinkerPaths.cpp similarity index 100% rename from src/Linker/LinkerPaths.cpp rename to src/Linking/LinkerPaths.cpp diff --git a/src/Linker/LinkerPaths.h b/src/Linking/LinkerPaths.h similarity index 100% rename from src/Linker/LinkerPaths.h rename to src/Linking/LinkerPaths.h diff --git a/src/Linker/ZoneCreation/ZoneCreationContext.cpp b/src/Linking/ZoneCreation/ZoneCreationContext.cpp similarity index 100% rename from src/Linker/ZoneCreation/ZoneCreationContext.cpp rename to src/Linking/ZoneCreation/ZoneCreationContext.cpp diff --git a/src/Linker/ZoneCreation/ZoneCreationContext.h b/src/Linking/ZoneCreation/ZoneCreationContext.h similarity index 100% rename from src/Linker/ZoneCreation/ZoneCreationContext.h rename to src/Linking/ZoneCreation/ZoneCreationContext.h diff --git a/src/Linker/ZoneCreation/ZoneCreator.cpp b/src/Linking/ZoneCreation/ZoneCreator.cpp similarity index 100% rename from src/Linker/ZoneCreation/ZoneCreator.cpp rename to src/Linking/ZoneCreation/ZoneCreator.cpp diff --git a/src/Linker/ZoneCreation/ZoneCreator.h b/src/Linking/ZoneCreation/ZoneCreator.h similarity index 100% rename from src/Linker/ZoneCreation/ZoneCreator.h rename to src/Linking/ZoneCreation/ZoneCreator.h diff --git a/src/ObjLoading/Asset/AssetCreationContext.cpp b/src/ObjLoading/Asset/AssetCreationContext.cpp index 7624716c..268f7479 100644 --- a/src/ObjLoading/Asset/AssetCreationContext.cpp +++ b/src/ObjLoading/Asset/AssetCreationContext.cpp @@ -104,7 +104,7 @@ XAssetInfoGeneric* AssetCreationContext::LoadDefaultAssetDependency(const asset_ return nullptr; } -XAssetInfoGeneric* AssetCreationContext::LoadDependencyGeneric(const asset_type_t assetType, const std::string& assetName) +XAssetInfoGeneric* AssetCreationContext::LoadDependencyGeneric(const asset_type_t assetType, const std::string& assetName, bool required) { auto* alreadyLoadedAsset = m_zone.m_pools->GetAssetOrAssetReference(assetType, assetName); if (alreadyLoadedAsset) @@ -131,7 +131,7 @@ XAssetInfoGeneric* AssetCreationContext::LoadDependencyGeneric(const asset_type_ con::error("Could not load asset \"{}\" of type \"{}\"", assetName, *m_zone.m_pools->GetAssetTypeName(assetType)); } - else + else if (required) { con::error("Missing asset \"{}\" of type \"{}\"", assetName, *m_zone.m_pools->GetAssetTypeName(assetType)); } diff --git a/src/ObjLoading/Asset/AssetCreationContext.h b/src/ObjLoading/Asset/AssetCreationContext.h index 59c00098..c83446c5 100644 --- a/src/ObjLoading/Asset/AssetCreationContext.h +++ b/src/ObjLoading/Asset/AssetCreationContext.h @@ -54,7 +54,7 @@ public: return static_cast*>(LoadDependencyGeneric(AssetType::EnumEntry, assetName)); } - XAssetInfoGeneric* LoadDependencyGeneric(asset_type_t assetType, const std::string& assetName); + XAssetInfoGeneric* LoadDependencyGeneric(asset_type_t assetType, const std::string& assetName, bool required = true); template IndirectAssetReference LoadIndirectAssetReference(const std::string& assetName) { diff --git a/src/ObjLoading/Asset/GlobalAssetPoolsLoader.cpp b/src/ObjLoading/Asset/GlobalAssetPoolsLoader.cpp new file mode 100644 index 00000000..ec124440 --- /dev/null +++ b/src/ObjLoading/Asset/GlobalAssetPoolsLoader.cpp @@ -0,0 +1,61 @@ +#include "GlobalAssetPoolsLoader.h" + +GlobalAssetPoolsRegistrationPreparation::GlobalAssetPoolsRegistrationPreparation(GenericAssetRegistration& registration, + Zone& zone, + Zone& foreignZone, + AssetCreationContext& context) + : m_registration(registration), + m_zone(zone), + m_foreign_zone(foreignZone), + m_context(context), + m_failure(false) +{ +} + +std::optional GlobalAssetPoolsRegistrationPreparation::Visit_Dependency(const asset_type_t assetType, const char* assetName) +{ + if (assetName && assetName[0] == ',') + { + /* + Try to load the actual asset when the asset from the global asset pools just references one. + If that fails, keep the reference to not destroy previous existing behaviour of just being able to use assets from the global pools + without ignores. + */ + auto* nonReferenceAssetName = &assetName[1]; + + auto* assetDependency = m_context.LoadDependencyGeneric(assetType, nonReferenceAssetName, false); + if (assetDependency) + { + m_registration.AddDependency(assetDependency); + return std::nullopt; + } + } + + auto* newDependency = m_context.LoadDependencyGeneric(assetType, assetName); + if (newDependency) + { + m_registration.AddDependency(newDependency); + return std::nullopt; + } + + m_failure = true; + return std::nullopt; +} + +std::optional GlobalAssetPoolsRegistrationPreparation::Visit_ScriptString(scr_string_t scriptString) +{ + // Make sure any used script string is available in the created zone + m_zone.m_script_strings.AddOrGetScriptString(m_foreign_zone.m_script_strings.CValue(scriptString)); + m_registration.AddScriptString(scriptString); + return std::nullopt; +} + +void GlobalAssetPoolsRegistrationPreparation::Visit_IndirectAssetRef(const asset_type_t assetType, const char* assetName) +{ + m_registration.AddIndirectAssetReference(m_context.LoadIndirectAssetReferenceGeneric(assetType, assetName)); +} + +bool GlobalAssetPoolsRegistrationPreparation::Failed() const +{ + return m_failure; +} diff --git a/src/ObjLoading/Asset/GlobalAssetPoolsLoader.h b/src/ObjLoading/Asset/GlobalAssetPoolsLoader.h index 6aeeb76f..e47a32e4 100644 --- a/src/ObjLoading/Asset/GlobalAssetPoolsLoader.h +++ b/src/ObjLoading/Asset/GlobalAssetPoolsLoader.h @@ -1,13 +1,36 @@ #pragma once + #include "Asset/IAssetCreator.h" +#include "Marking/AssetVisitor.h" +#include "Marking/BaseAssetMarker.h" #include "Pool/GlobalAssetPool.h" +class GlobalAssetPoolsRegistrationPreparation : public AssetVisitor +{ +public: + GlobalAssetPoolsRegistrationPreparation(GenericAssetRegistration& registration, Zone& zone, Zone& foreignZone, AssetCreationContext& context); + + std::optional Visit_Dependency(asset_type_t assetType, const char* assetName) override; + std::optional Visit_ScriptString(scr_string_t scriptString) override; + void Visit_IndirectAssetRef(asset_type_t assetType, const char* assetName) override; + + [[nodiscard]] bool Failed() const; + +private: + GenericAssetRegistration& m_registration; + Zone& m_zone; + Zone& m_foreign_zone; + AssetCreationContext& m_context; + + bool m_failure; +}; + template class GlobalAssetPoolsLoader : public AssetCreator { public: static_assert(std::is_base_of_v); - GlobalAssetPoolsLoader(Zone& zone) + explicit GlobalAssetPoolsLoader(Zone& zone) : m_zone(zone) { } @@ -21,26 +44,12 @@ public: AssetRegistration registration(assetName, existingAsset->Asset()); - for (const auto* dependency : existingAsset->m_dependencies) - { - auto* newDependency = context.LoadDependencyGeneric(dependency->m_type, dependency->m_name); - if (newDependency) - registration.AddDependency(newDependency); - else - return AssetCreationResult::Failure(); - } - - for (const auto& indirectAssetReference : existingAsset->m_indirect_asset_references) - registration.AddIndirectAssetReference(context.LoadIndirectAssetReferenceGeneric(indirectAssetReference.m_type, indirectAssetReference.m_name)); - - // Make sure any used script string is available in the created zone - // The replacement of the scr_string_t values will be done upon writing - for (const auto scrString : existingAsset->m_used_script_strings) - m_zone.m_script_strings.AddOrGetScriptString(existingAsset->m_zone->m_script_strings.CValue(scrString)); + GlobalAssetPoolsRegistrationPreparation registrationPreparation(registration, m_zone, *existingAsset->m_zone, context); + AssetMarker marker(registrationPreparation); + marker.Mark(existingAsset->Asset()); auto* newAsset = context.AddAsset(std::move(registration)); - - // Make sure we remember this asset came from another zone + // Make sure we remember this asset came from a different zone newAsset->m_zone = existingAsset->m_zone; return AssetCreationResult::Success(newAsset); diff --git a/src/ObjLoading/Asset/IDefaultAssetCreator.h b/src/ObjLoading/Asset/IDefaultAssetCreator.h index bcd0963f..cf43ba2a 100644 --- a/src/ObjLoading/Asset/IDefaultAssetCreator.h +++ b/src/ObjLoading/Asset/IDefaultAssetCreator.h @@ -42,7 +42,7 @@ public: AssetCreationResult CreateDefaultAsset(const std::string& assetName, AssetCreationContext& context) const override { auto* asset = m_memory.Alloc(); - AssetNameAccessor{}(*asset) = m_memory.Dup(assetName.c_str()); + AssetName(*asset) = m_memory.Dup(assetName.c_str()); return AssetCreationResult::Success(context.AddAsset(assetName, asset)); } diff --git a/src/ObjLoading/Game/IW3/ObjLoaderIW3.cpp b/src/ObjLoading/Game/IW3/ObjLoaderIW3.cpp index fb2c1627..4052f23c 100644 --- a/src/ObjLoading/Game/IW3/ObjLoaderIW3.cpp +++ b/src/ObjLoading/Game/IW3/ObjLoaderIW3.cpp @@ -1,6 +1,7 @@ #include "ObjLoaderIW3.h" #include "Asset/GlobalAssetPoolsLoader.h" +#include "Game/IW3/AssetMarkerIW3.h" #include "Game/IW3/GameIW3.h" #include "Game/IW3/IW3.h" #include "Game/IW3/XModel/LoaderXModelIW3.h" @@ -65,7 +66,7 @@ namespace collection.AddAssetCreator(std::make_unique>(zone)); collection.AddAssetCreator(std::make_unique>(zone)); collection.AddAssetCreator(std::make_unique>(zone)); - collection.AddAssetCreator(std::make_unique>(zone)); + // collection.AddAssetCreator(std::make_unique>(zone)); collection.AddAssetCreator(std::make_unique>(zone)); collection.AddAssetCreator(std::make_unique>(zone)); collection.AddAssetCreator(std::make_unique>(zone)); @@ -78,7 +79,7 @@ namespace collection.AddAssetCreator(std::make_unique>(zone)); collection.AddAssetCreator(std::make_unique>(zone)); collection.AddAssetCreator(std::make_unique>(zone)); - collection.AddAssetCreator(std::make_unique>(zone)); + // collection.AddAssetCreator(std::make_unique>(zone)); collection.AddAssetCreator(std::make_unique>(zone)); collection.AddAssetCreator(std::make_unique>(zone)); collection.AddAssetCreator(std::make_unique>(zone)); diff --git a/src/ObjLoading/Game/IW4/ObjLoaderIW4.cpp b/src/ObjLoading/Game/IW4/ObjLoaderIW4.cpp index ad5b83c4..5558b40a 100644 --- a/src/ObjLoading/Game/IW4/ObjLoaderIW4.cpp +++ b/src/ObjLoading/Game/IW4/ObjLoaderIW4.cpp @@ -1,6 +1,7 @@ #include "ObjLoaderIW4.h" #include "Asset/GlobalAssetPoolsLoader.h" +#include "Game/IW4/AssetMarkerIW4.h" #include "Game/IW4/GameIW4.h" #include "Game/IW4/IW4.h" #include "Game/IW4/XModel/LoaderXModelIW4.h" @@ -79,7 +80,7 @@ namespace collection.AddAssetCreator(std::make_unique>(zone)); collection.AddAssetCreator(std::make_unique>(zone)); collection.AddAssetCreator(std::make_unique>(zone)); - collection.AddAssetCreator(std::make_unique>(zone)); + // collection.AddAssetCreator(std::make_unique>(zone)); collection.AddAssetCreator(std::make_unique>(zone)); collection.AddAssetCreator(std::make_unique>(zone)); collection.AddAssetCreator(std::make_unique>(zone)); @@ -90,7 +91,7 @@ namespace collection.AddAssetCreator(std::make_unique>(zone)); collection.AddAssetCreator(std::make_unique>(zone)); collection.AddAssetCreator(std::make_unique>(zone)); - collection.AddAssetCreator(std::make_unique>(zone)); + // collection.AddAssetCreator(std::make_unique>(zone)); collection.AddAssetCreator(std::make_unique>(zone)); collection.AddAssetCreator(std::make_unique>(zone)); collection.AddAssetCreator(std::make_unique>(zone)); diff --git a/src/ObjLoading/Game/IW5/ObjLoaderIW5.cpp b/src/ObjLoading/Game/IW5/ObjLoaderIW5.cpp index cb3d96cd..70079f7b 100644 --- a/src/ObjLoading/Game/IW5/ObjLoaderIW5.cpp +++ b/src/ObjLoading/Game/IW5/ObjLoaderIW5.cpp @@ -1,6 +1,7 @@ #include "ObjLoaderIW5.h" #include "Asset/GlobalAssetPoolsLoader.h" +#include "Game/IW5/AssetMarkerIW5.h" #include "Game/IW5/GameIW5.h" #include "Game/IW5/IW5.h" #include "Game/IW5/XModel/LoaderXModelIW5.h" diff --git a/src/ObjLoading/Game/T5/ObjLoaderT5.cpp b/src/ObjLoading/Game/T5/ObjLoaderT5.cpp index cc67cc5a..e8cff138 100644 --- a/src/ObjLoading/Game/T5/ObjLoaderT5.cpp +++ b/src/ObjLoading/Game/T5/ObjLoaderT5.cpp @@ -1,6 +1,7 @@ #include "ObjLoaderT5.h" #include "Asset/GlobalAssetPoolsLoader.h" +#include "Game/T5/AssetMarkerT5.h" #include "Game/T5/GameT5.h" #include "Game/T5/T5.h" #include "Game/T5/XModel/LoaderXModelT5.h" @@ -71,7 +72,7 @@ namespace collection.AddAssetCreator(std::make_unique>(zone)); collection.AddAssetCreator(std::make_unique>(zone)); collection.AddAssetCreator(std::make_unique>(zone)); - collection.AddAssetCreator(std::make_unique>(zone)); + // collection.AddAssetCreator(std::make_unique>(zone)); collection.AddAssetCreator(std::make_unique>(zone)); collection.AddAssetCreator(std::make_unique>(zone)); collection.AddAssetCreator(std::make_unique>(zone)); diff --git a/src/ObjLoading/Game/T6/ObjLoaderT6.cpp b/src/ObjLoading/Game/T6/ObjLoaderT6.cpp index ba53fbeb..a7df0b3f 100644 --- a/src/ObjLoading/Game/T6/ObjLoaderT6.cpp +++ b/src/ObjLoading/Game/T6/ObjLoaderT6.cpp @@ -3,6 +3,7 @@ #include "Asset/GlobalAssetPoolsLoader.h" #include "FontIcon/CsvLoaderFontIconT6.h" #include "FontIcon/JsonLoaderFontIconT6.h" +#include "Game/T6/AssetMarkerT6.h" #include "Game/T6/CommonT6.h" #include "Game/T6/GameAssetPoolT6.h" #include "Game/T6/GameT6.h" @@ -340,7 +341,7 @@ namespace T6 collection.AddAssetCreator(std::make_unique>(zone)); collection.AddAssetCreator(std::make_unique>(zone)); collection.AddAssetCreator(std::make_unique>(zone)); - collection.AddAssetCreator(std::make_unique>(zone)); + // collection.AddAssetCreator(std::make_unique>(zone)); collection.AddAssetCreator(std::make_unique>(zone)); collection.AddAssetCreator(std::make_unique>(zone)); collection.AddAssetCreator(std::make_unique>(zone)); diff --git a/src/Unlinker.lua b/src/Unlinker.lua deleted file mode 100644 index f0fdc2c4..00000000 --- a/src/Unlinker.lua +++ /dev/null @@ -1,52 +0,0 @@ -Unlinker = {} - -function Unlinker:include(includes) - if includes:handle(self:name()) then - includedirs { - path.join(ProjectFolder(), "Unlinker") - } - end -end - -function Unlinker:link(links) - -end - -function Unlinker:use() - dependson(self:name()) -end - -function Unlinker:name() - return "Unlinker" -end - -function Unlinker:project() - local folder = ProjectFolder() - local includes = Includes:create() - local links = Links:create() - - project(self:name()) - targetdir(TargetDirectoryBin) - location "%{wks.location}/src/%{prj.name}" - kind "ConsoleApp" - language "C++" - - files { - path.join(folder, "Unlinker/**.h"), - path.join(folder, "Unlinker/**.cpp") - } - - self:include(includes) - Utils:include(includes) - ZoneLoading:include(includes) - ObjLoading:include(includes) - ObjWriting:include(includes) - - Raw:use() - - links:linkto(Utils) - links:linkto(ZoneLoading) - links:linkto(ObjLoading) - links:linkto(ObjWriting) - links:linkall() -end diff --git a/src/Unlinker/Unlinker.cpp b/src/Unlinker/Unlinker.cpp deleted file mode 100644 index 54192060..00000000 --- a/src/Unlinker/Unlinker.cpp +++ /dev/null @@ -1,342 +0,0 @@ -#include "Unlinker.h" - -#include "ContentLister/ContentPrinter.h" -#include "IObjLoader.h" -#include "IObjWriter.h" -#include "ObjWriting.h" -#include "SearchPath/IWD.h" -#include "SearchPath/OutputPathFilesystem.h" -#include "UnlinkerArgs.h" -#include "UnlinkerPaths.h" -#include "Utils/ClassUtils.h" -#include "Utils/Logging/Log.h" -#include "Utils/ObjFileStream.h" -#include "Zone/Definition/ZoneDefWriter.h" -#include "ZoneLoading.h" - -#include -#include -#include -#include -#include - -namespace fs = std::filesystem; - -class Unlinker::Impl -{ -public: - /** - * \copydoc Unlinker::Start - */ - bool Start(const int argc, const char** argv) - { - con::init(); - - auto shouldContinue = true; - if (!m_args.ParseArgs(argc, argv, shouldContinue)) - return false; - - if (!shouldContinue) - return true; - - UnlinkerPaths paths; - if (!paths.LoadUserPaths(m_args)) - return false; - - if (!LoadZones(paths)) - return false; - - const auto result = UnlinkZones(paths); - - UnloadZones(); - return result; - } - -private: - [[nodiscard]] bool ShouldLoadObj() const - { - return m_args.m_task != UnlinkerArgs::ProcessingTask::LIST && !m_args.m_skip_obj; - } - - [[nodiscard]] bool WriteZoneDefinitionFile(const Zone& zone, const fs::path& zoneDefinitionFileFolder) const - { - auto zoneDefinitionFilePath(zoneDefinitionFileFolder); - zoneDefinitionFilePath.append(zone.m_name); - zoneDefinitionFilePath.replace_extension(".zone"); - - std::ofstream zoneDefinitionFile(zoneDefinitionFilePath, std::fstream::out | std::fstream::binary); - if (!zoneDefinitionFile.is_open()) - { - con::error("Failed to open file for zone definition file of zone \"{}\".", zone.m_name); - return false; - } - - const auto* zoneDefWriter = IZoneDefWriter::GetZoneDefWriterForGame(zone.m_game_id); - zoneDefWriter->WriteZoneDef(zoneDefinitionFile, zone, m_args.m_use_gdt); - - zoneDefinitionFile.close(); - - return true; - } - - static bool OpenGdtFile(const Zone& zone, const fs::path& outputFolder, std::ofstream& stream) - { - auto gdtFilePath(outputFolder); - gdtFilePath.append("source_data"); - - fs::create_directories(gdtFilePath); - - gdtFilePath.append(zone.m_name); - gdtFilePath.replace_extension(".gdt"); - - stream = std::ofstream(gdtFilePath, std::fstream::out | std::fstream::binary); - if (!stream.is_open()) - { - con::error("Failed to open file for zone definition file of zone \"{}\".", zone.m_name); - return false; - } - - return true; - } - - void UpdateAssetIncludesAndExcludes(const AssetDumpingContext& context) const - { - const auto assetTypeCount = context.m_zone.m_pools->GetAssetTypeCount(); - - ObjWriting::Configuration.AssetTypesToHandleBitfield = std::vector(assetTypeCount); - - std::vector handledSpecifiedAssets(m_args.m_specified_asset_types.size()); - for (auto i = 0u; i < assetTypeCount; i++) - { - const auto assetTypeName = std::string(*context.m_zone.m_pools->GetAssetTypeName(i)); - - const auto foundSpecifiedEntry = m_args.m_specified_asset_type_map.find(assetTypeName); - if (foundSpecifiedEntry != m_args.m_specified_asset_type_map.end()) - { - ObjWriting::Configuration.AssetTypesToHandleBitfield[i] = m_args.m_asset_type_handling == UnlinkerArgs::AssetTypeHandling::INCLUDE; - assert(foundSpecifiedEntry->second < handledSpecifiedAssets.size()); - handledSpecifiedAssets[foundSpecifiedEntry->second] = true; - } - else - ObjWriting::Configuration.AssetTypesToHandleBitfield[i] = m_args.m_asset_type_handling == UnlinkerArgs::AssetTypeHandling::EXCLUDE; - } - - auto anySpecifiedValueInvalid = false; - for (auto i = 0u; i < handledSpecifiedAssets.size(); i++) - { - if (!handledSpecifiedAssets[i]) - { - con::error("Unknown asset type \"{}\"", m_args.m_specified_asset_types[i]); - anySpecifiedValueInvalid = true; - } - } - - if (anySpecifiedValueInvalid) - { - con::error("Valid asset types are:"); - - auto first = true; - std::ostringstream ss; - for (auto i = 0u; i < assetTypeCount; i++) - { - const auto assetTypeName = std::string(*context.m_zone.m_pools->GetAssetTypeName(i)); - - if (first) - first = false; - else - ss << ", "; - ss << assetTypeName; - } - con::error(ss.str()); - } - } - - /** - * \brief Performs the tasks specified by the command line arguments on the specified zone. - * \param searchPath The search path for obj data. - * \param zone The zone to handle. - * \return \c true if handling the zone was successful, otherwise \c false - */ - bool HandleZone(ISearchPath& searchPath, Zone& zone) const - { - if (m_args.m_task == UnlinkerArgs::ProcessingTask::LIST) - { - const ContentPrinter printer(zone); - printer.PrintContent(); - } - else if (m_args.m_task == UnlinkerArgs::ProcessingTask::DUMP) - { - const auto outputFolderPathStr = m_args.GetOutputFolderPathForZone(zone); - const fs::path outputFolderPath(outputFolderPathStr); - fs::create_directories(outputFolderPath); - - fs::path zoneDefinitionFileFolder(outputFolderPath); - zoneDefinitionFileFolder.append("zone_source"); - fs::create_directories(zoneDefinitionFileFolder); - - if (!WriteZoneDefinitionFile(zone, zoneDefinitionFileFolder)) - return false; - - OutputPathFilesystem outputFolderOutputPath(outputFolderPath); - AssetDumpingContext context(zone, outputFolderPathStr, outputFolderOutputPath, searchPath, std::nullopt); - - std::ofstream gdtStream; - if (m_args.m_use_gdt) - { - if (!OpenGdtFile(zone, outputFolderPath, gdtStream)) - return false; - auto gdt = std::make_unique(gdtStream); - gdt->BeginStream(); - - const auto* game = IGame::GetGameById(zone.m_game_id); - gdt->WriteVersion(GdtVersion(game->GetShortName(), 1)); - - context.m_gdt = std::move(gdt); - } - - UpdateAssetIncludesAndExcludes(context); - - const auto* objWriter = IObjWriter::GetObjWriterForGame(zone.m_game_id); - - auto result = objWriter->DumpZone(context); - - if (m_args.m_use_gdt) - { - context.m_gdt->EndStream(); - gdtStream.close(); - } - - if (!result) - { - con::error("Dumping zone failed!"); - return false; - } - } - - return true; - } - - bool LoadZones(UnlinkerPaths& paths) - { - for (const auto& zonePath : m_args.m_zones_to_load) - { - if (!fs::is_regular_file(zonePath)) - { - con::error("Could not find file \"{}\".", zonePath); - continue; - } - - auto absoluteZoneDirectory = absolute(std::filesystem::path(zonePath).remove_filename()).string(); - - auto searchPathsForZone = paths.GetSearchPathsForZone(absoluteZoneDirectory); - auto maybeZone = ZoneLoading::LoadZone(zonePath, std::nullopt); - if (!maybeZone) - { - con::error("Failed to load zone \"{}\": {}", zonePath, maybeZone.error()); - return false; - } - - auto zone = std::move(*maybeZone); - - con::debug("Loaded zone \"{}\"", zone->m_name); - - if (ShouldLoadObj()) - { - const auto* objLoader = IObjLoader::GetObjLoaderForGame(zone->m_game_id); - objLoader->LoadReferencedContainersForZone(*searchPathsForZone, *zone); - } - - m_loaded_zones.emplace_back(std::move(zone)); - } - - return true; - } - - void UnloadZones() - { - for (auto i = m_loaded_zones.rbegin(); i != m_loaded_zones.rend(); ++i) - { - auto& loadedZone = *i; - - // Copy zone name since we deallocate before logging - const auto zoneName = loadedZone->m_name; - - if (ShouldLoadObj()) - { - const auto* objLoader = IObjLoader::GetObjLoaderForGame(loadedZone->m_game_id); - objLoader->UnloadContainersOfZone(*loadedZone); - } - - loadedZone.reset(); - - con::debug("Unloaded zone \"{}\"", zoneName); - } - m_loaded_zones.clear(); - } - - bool UnlinkZones(UnlinkerPaths& paths) const - { - for (const auto& zonePath : m_args.m_zones_to_unlink) - { - if (!fs::is_regular_file(zonePath)) - { - con::error("Could not find file \"{}\".", zonePath); - continue; - } - - auto zoneDirectory = fs::path(zonePath).remove_filename(); - if (zoneDirectory.empty()) - zoneDirectory = fs::current_path(); - auto absoluteZoneDirectory = absolute(zoneDirectory).string(); - - auto searchPathsForZone = paths.GetSearchPathsForZone(absoluteZoneDirectory); - - auto maybeZone = ZoneLoading::LoadZone(zonePath, std::nullopt); - if (!maybeZone) - { - con::error("Failed to load zone \"{}\": {}", zonePath, maybeZone.error()); - return false; - } - - auto zone = std::move(*maybeZone); - - con::debug("Loaded zone \"{}\"", zone->m_name); - - const auto* objLoader = IObjLoader::GetObjLoaderForGame(zone->m_game_id); - if (ShouldLoadObj()) - objLoader->LoadReferencedContainersForZone(*searchPathsForZone, *zone); - - if (!HandleZone(*searchPathsForZone, *zone)) - return false; - - if (ShouldLoadObj()) - objLoader->UnloadContainersOfZone(*zone); - - // Copy zone name for using it after freeing the zone - std::string zoneName = zone->m_name; - zone.reset(); - con::debug("Unloaded zone \"{}\"", zoneName); - } - - return true; - } - - UnlinkerArgs m_args; - std::vector> m_loaded_zones; -}; - -Unlinker::Unlinker() -{ - m_impl = new Impl(); -} - -Unlinker::~Unlinker() -{ - delete m_impl; - m_impl = nullptr; -} - -bool Unlinker::Start(const int argc, const char** argv) const -{ - return m_impl->Start(argc, argv); -} diff --git a/src/Unlinker/Unlinker.h b/src/Unlinker/Unlinker.h deleted file mode 100644 index c549682f..00000000 --- a/src/Unlinker/Unlinker.h +++ /dev/null @@ -1,24 +0,0 @@ -#pragma once - -class Unlinker -{ - class Impl; - Impl* m_impl; - -public: - Unlinker(); - ~Unlinker(); - - Unlinker(const Unlinker& other) = delete; - Unlinker(Unlinker&& other) noexcept = delete; - Unlinker& operator=(const Unlinker& other) = delete; - Unlinker& operator=(Unlinker&& other) noexcept = delete; - - /** - * \brief Starts the Unlinker application logic. - * \param argc The amount of command line arguments specified. - * \param argv The command line arguments. - * \return \c true if the application was successful or \c false if an error occurred. - */ - bool Start(int argc, const char** argv) const; -}; diff --git a/src/Unlinker/main.cpp b/src/Unlinker/main.cpp deleted file mode 100644 index 9a326acb..00000000 --- a/src/Unlinker/main.cpp +++ /dev/null @@ -1,8 +0,0 @@ -#include "Unlinker.h" - -int main(const int argc, const char** argv) -{ - Unlinker unlinker; - - return unlinker.Start(argc, argv) ? 0 : 1; -} diff --git a/src/UnlinkerCli.lua b/src/UnlinkerCli.lua new file mode 100644 index 00000000..e7842e88 --- /dev/null +++ b/src/UnlinkerCli.lua @@ -0,0 +1,49 @@ +UnlinkerCli = {} + +function UnlinkerCli:include(includes) + if includes:handle(self:name()) then + includedirs { + path.join(ProjectFolder(), "UnlinkerCli") + } + end +end + +function UnlinkerCli:link(links) + +end + +function UnlinkerCli:use() + dependson(self:name()) +end + +function UnlinkerCli:name() + return "UnlinkerCli" +end + +function UnlinkerCli:project() + local folder = ProjectFolder() + local includes = Includes:create() + local links = Links:create() + + project(self:name()) + targetdir(TargetDirectoryBin) + targetname "Unlinker" + location "%{wks.location}/src/%{prj.name}" + kind "ConsoleApp" + language "C++" + + files { + path.join(folder, "UnlinkerCli/**.h"), + path.join(folder, "UnlinkerCli/**.cpp") + } + + self:include(includes) + Utils:include(includes) + Unlinking:include(includes) + + Raw:use() + + links:linkto(Utils) + links:linkto(Unlinking) + links:linkall() +end diff --git a/src/UnlinkerCli/main.cpp b/src/UnlinkerCli/main.cpp new file mode 100644 index 00000000..07bdbcfb --- /dev/null +++ b/src/UnlinkerCli/main.cpp @@ -0,0 +1,19 @@ +#include "Unlinker.h" +#include "Utils/Logging/Log.h" + +int main(const int argc, const char** argv) +{ + con::init(); + + UnlinkerArgs args; + auto shouldContinue = true; + if (!args.ParseArgs(argc, argv, shouldContinue)) + return 1; + + if (!shouldContinue) + return 0; + + const auto unlinker = Unlinker::Create(std::move(args)); + + return unlinker->Start() ? 0 : 1; +} diff --git a/src/Unlinking.lua b/src/Unlinking.lua new file mode 100644 index 00000000..ad42dfe4 --- /dev/null +++ b/src/Unlinking.lua @@ -0,0 +1,57 @@ +Unlinking = {} + +function Unlinking:include(includes) + if includes:handle(self:name()) then + ZoneCommon:include(includes) + includedirs { + path.join(ProjectFolder(), "Unlinking"), + } + end +end + +function Unlinking:link(links) + links:add(self:name()) + links:linkto(Utils) + links:linkto(ZoneLoading) + links:linkto(ObjLoading) + links:linkto(ObjWriting) +end + +function Unlinking:use() + +end + +function Unlinking:name() + return "Unlinking" +end + +function Unlinking:project() + local folder = ProjectFolder() + local includes = Includes:create() + + project(self:name()) + targetdir(TargetDirectoryLib) + location "%{wks.location}/src/%{prj.name}" + kind "StaticLib" + language "C++" + + files { + path.join(folder, "Unlinking/**.h"), + path.join(folder, "Unlinking/**.cpp") + } + + vpaths { + ["*"] = { + path.join(folder, "Unlinking") + } + } + + ObjCommon:use() + useSourceTemplating("Unlinking") + + self:include(includes) + Utils:include(includes) + ZoneLoading:include(includes) + ObjLoading:include(includes) + ObjWriting:include(includes) +end diff --git a/src/Unlinker/ContentLister/ContentPrinter.cpp b/src/Unlinking/ContentLister/ContentPrinter.cpp similarity index 100% rename from src/Unlinker/ContentLister/ContentPrinter.cpp rename to src/Unlinking/ContentLister/ContentPrinter.cpp diff --git a/src/Unlinker/ContentLister/ContentPrinter.h b/src/Unlinking/ContentLister/ContentPrinter.h similarity index 100% rename from src/Unlinker/ContentLister/ContentPrinter.h rename to src/Unlinking/ContentLister/ContentPrinter.h diff --git a/src/Unlinking/Unlinker.cpp b/src/Unlinking/Unlinker.cpp new file mode 100644 index 00000000..be90a78c --- /dev/null +++ b/src/Unlinking/Unlinker.cpp @@ -0,0 +1,327 @@ +#include "Unlinker.h" + +#include "ContentLister/ContentPrinter.h" +#include "IObjLoader.h" +#include "IObjWriter.h" +#include "ObjWriting.h" +#include "SearchPath/IWD.h" +#include "SearchPath/OutputPathFilesystem.h" +#include "UnlinkerArgs.h" +#include "UnlinkerPaths.h" +#include "Utils/ClassUtils.h" +#include "Utils/Logging/Log.h" +#include "Utils/ObjFileStream.h" +#include "Zone/Definition/ZoneDefWriter.h" +#include "ZoneLoading.h" + +#include +#include +#include +#include +#include + +namespace fs = std::filesystem; + +namespace +{ + class UnlinkerImpl : public Unlinker + { + public: + UnlinkerImpl(UnlinkerArgs args) + : m_args(std::move(args)) + { + } + + bool Start() override + { + UnlinkerPaths paths; + if (!paths.LoadUserPaths(m_args)) + return false; + + if (!LoadZones(paths)) + return false; + + const auto result = UnlinkZones(paths); + + UnloadZones(); + return result; + } + + private: + [[nodiscard]] bool ShouldLoadObj() const + { + return m_args.m_task != UnlinkerArgs::ProcessingTask::LIST && !m_args.m_skip_obj; + } + + [[nodiscard]] bool WriteZoneDefinitionFile(const Zone& zone, const fs::path& zoneDefinitionFileFolder) const + { + auto zoneDefinitionFilePath(zoneDefinitionFileFolder); + zoneDefinitionFilePath.append(zone.m_name); + zoneDefinitionFilePath.replace_extension(".zone"); + + std::ofstream zoneDefinitionFile(zoneDefinitionFilePath, std::fstream::out | std::fstream::binary); + if (!zoneDefinitionFile.is_open()) + { + con::error("Failed to open file for zone definition file of zone \"{}\".", zone.m_name); + return false; + } + + const auto* zoneDefWriter = IZoneDefWriter::GetZoneDefWriterForGame(zone.m_game_id); + zoneDefWriter->WriteZoneDef(zoneDefinitionFile, zone, m_args.m_use_gdt); + + zoneDefinitionFile.close(); + + return true; + } + + static bool OpenGdtFile(const Zone& zone, const fs::path& outputFolder, std::ofstream& stream) + { + auto gdtFilePath(outputFolder); + gdtFilePath.append("source_data"); + + fs::create_directories(gdtFilePath); + + gdtFilePath.append(zone.m_name); + gdtFilePath.replace_extension(".gdt"); + + stream = std::ofstream(gdtFilePath, std::fstream::out | std::fstream::binary); + if (!stream.is_open()) + { + con::error("Failed to open file for zone definition file of zone \"{}\".", zone.m_name); + return false; + } + + return true; + } + + void UpdateAssetIncludesAndExcludes(const AssetDumpingContext& context) const + { + const auto assetTypeCount = context.m_zone.m_pools->GetAssetTypeCount(); + + ObjWriting::Configuration.AssetTypesToHandleBitfield = std::vector(assetTypeCount); + + std::vector handledSpecifiedAssets(m_args.m_specified_asset_types.size()); + for (auto i = 0u; i < assetTypeCount; i++) + { + const auto assetTypeName = std::string(*context.m_zone.m_pools->GetAssetTypeName(i)); + + const auto foundSpecifiedEntry = m_args.m_specified_asset_type_map.find(assetTypeName); + if (foundSpecifiedEntry != m_args.m_specified_asset_type_map.end()) + { + ObjWriting::Configuration.AssetTypesToHandleBitfield[i] = m_args.m_asset_type_handling == UnlinkerArgs::AssetTypeHandling::INCLUDE; + assert(foundSpecifiedEntry->second < handledSpecifiedAssets.size()); + handledSpecifiedAssets[foundSpecifiedEntry->second] = true; + } + else + ObjWriting::Configuration.AssetTypesToHandleBitfield[i] = m_args.m_asset_type_handling == UnlinkerArgs::AssetTypeHandling::EXCLUDE; + } + + auto anySpecifiedValueInvalid = false; + for (auto i = 0u; i < handledSpecifiedAssets.size(); i++) + { + if (!handledSpecifiedAssets[i]) + { + con::error("Unknown asset type \"{}\"", m_args.m_specified_asset_types[i]); + anySpecifiedValueInvalid = true; + } + } + + if (anySpecifiedValueInvalid) + { + con::error("Valid asset types are:"); + + auto first = true; + std::ostringstream ss; + for (auto i = 0u; i < assetTypeCount; i++) + { + const auto assetTypeName = std::string(*context.m_zone.m_pools->GetAssetTypeName(i)); + + if (first) + first = false; + else + ss << ", "; + ss << assetTypeName; + } + con::error(ss.str()); + } + } + + /** + * \brief Performs the tasks specified by the command line arguments on the specified zone. + * \param searchPath The search path for obj data. + * \param zone The zone to handle. + * \return \c true if handling the zone was successful, otherwise \c false + */ + bool HandleZone(ISearchPath& searchPath, Zone& zone) const + { + if (m_args.m_task == UnlinkerArgs::ProcessingTask::LIST) + { + const ContentPrinter printer(zone); + printer.PrintContent(); + } + else if (m_args.m_task == UnlinkerArgs::ProcessingTask::DUMP) + { + const auto outputFolderPathStr = m_args.GetOutputFolderPathForZone(zone); + const fs::path outputFolderPath(outputFolderPathStr); + fs::create_directories(outputFolderPath); + + fs::path zoneDefinitionFileFolder(outputFolderPath); + zoneDefinitionFileFolder.append("zone_source"); + fs::create_directories(zoneDefinitionFileFolder); + + if (!WriteZoneDefinitionFile(zone, zoneDefinitionFileFolder)) + return false; + + OutputPathFilesystem outputFolderOutputPath(outputFolderPath); + AssetDumpingContext context(zone, outputFolderPathStr, outputFolderOutputPath, searchPath, std::nullopt); + + std::ofstream gdtStream; + if (m_args.m_use_gdt) + { + if (!OpenGdtFile(zone, outputFolderPath, gdtStream)) + return false; + auto gdt = std::make_unique(gdtStream); + gdt->BeginStream(); + + const auto* game = IGame::GetGameById(zone.m_game_id); + gdt->WriteVersion(GdtVersion(game->GetShortName(), 1)); + + context.m_gdt = std::move(gdt); + } + + UpdateAssetIncludesAndExcludes(context); + + const auto* objWriter = IObjWriter::GetObjWriterForGame(zone.m_game_id); + + auto result = objWriter->DumpZone(context); + + if (m_args.m_use_gdt) + { + context.m_gdt->EndStream(); + gdtStream.close(); + } + + if (!result) + { + con::error("Dumping zone failed!"); + return false; + } + } + + return true; + } + + bool LoadZones(UnlinkerPaths& paths) + { + for (const auto& zonePath : m_args.m_zones_to_load) + { + if (!fs::is_regular_file(zonePath)) + { + con::error("Could not find file \"{}\".", zonePath); + continue; + } + + auto absoluteZoneDirectory = absolute(std::filesystem::path(zonePath).remove_filename()).string(); + + auto searchPathsForZone = paths.GetSearchPathsForZone(absoluteZoneDirectory); + auto maybeZone = ZoneLoading::LoadZone(zonePath, std::nullopt); + if (!maybeZone) + { + con::error("Failed to load zone \"{}\": {}", zonePath, maybeZone.error()); + return false; + } + + auto zone = std::move(*maybeZone); + + con::debug("Loaded zone \"{}\"", zone->m_name); + + if (ShouldLoadObj()) + { + const auto* objLoader = IObjLoader::GetObjLoaderForGame(zone->m_game_id); + objLoader->LoadReferencedContainersForZone(*searchPathsForZone, *zone); + } + + m_loaded_zones.emplace_back(std::move(zone)); + } + + return true; + } + + void UnloadZones() + { + for (auto i = m_loaded_zones.rbegin(); i != m_loaded_zones.rend(); ++i) + { + auto& loadedZone = *i; + + // Copy zone name since we deallocate before logging + const auto zoneName = loadedZone->m_name; + + if (ShouldLoadObj()) + { + const auto* objLoader = IObjLoader::GetObjLoaderForGame(loadedZone->m_game_id); + objLoader->UnloadContainersOfZone(*loadedZone); + } + + loadedZone.reset(); + + con::debug("Unloaded zone \"{}\"", zoneName); + } + m_loaded_zones.clear(); + } + + bool UnlinkZones(UnlinkerPaths& paths) const + { + for (const auto& zonePath : m_args.m_zones_to_unlink) + { + if (!fs::is_regular_file(zonePath)) + { + con::error("Could not find file \"{}\".", zonePath); + continue; + } + + auto zoneDirectory = fs::path(zonePath).remove_filename(); + if (zoneDirectory.empty()) + zoneDirectory = fs::current_path(); + auto absoluteZoneDirectory = absolute(zoneDirectory).string(); + + auto searchPathsForZone = paths.GetSearchPathsForZone(absoluteZoneDirectory); + + auto maybeZone = ZoneLoading::LoadZone(zonePath, std::nullopt); + if (!maybeZone) + { + con::error("Failed to load zone \"{}\": {}", zonePath, maybeZone.error()); + return false; + } + + auto zone = std::move(*maybeZone); + + con::debug("Loaded zone \"{}\"", zone->m_name); + + const auto* objLoader = IObjLoader::GetObjLoaderForGame(zone->m_game_id); + if (ShouldLoadObj()) + objLoader->LoadReferencedContainersForZone(*searchPathsForZone, *zone); + + if (!HandleZone(*searchPathsForZone, *zone)) + return false; + + if (ShouldLoadObj()) + objLoader->UnloadContainersOfZone(*zone); + + // Copy zone name for using it after freeing the zone + std::string zoneName = zone->m_name; + zone.reset(); + con::debug("Unloaded zone \"{}\"", zoneName); + } + + return true; + } + + UnlinkerArgs m_args; + std::vector> m_loaded_zones; + }; +} // namespace + +std::unique_ptr Unlinker::Create(UnlinkerArgs args) +{ + return std::make_unique(std::move(args)); +} diff --git a/src/Unlinking/Unlinker.h b/src/Unlinking/Unlinker.h new file mode 100644 index 00000000..83f6aaaf --- /dev/null +++ b/src/Unlinking/Unlinker.h @@ -0,0 +1,19 @@ +#pragma once + +#include "UnlinkerArgs.h" + +#include + +class Unlinker +{ +public: + virtual ~Unlinker() = default; + + static std::unique_ptr Create(UnlinkerArgs args); + + /** + * \brief Starts the Unlinker application logic. + * \return \c true if the application was successful or \c false if an error occurred. + */ + virtual bool Start() = 0; +}; diff --git a/src/Unlinker/UnlinkerArgs.cpp b/src/Unlinking/UnlinkerArgs.cpp similarity index 100% rename from src/Unlinker/UnlinkerArgs.cpp rename to src/Unlinking/UnlinkerArgs.cpp diff --git a/src/Unlinker/UnlinkerArgs.h b/src/Unlinking/UnlinkerArgs.h similarity index 100% rename from src/Unlinker/UnlinkerArgs.h rename to src/Unlinking/UnlinkerArgs.h diff --git a/src/Unlinker/UnlinkerPaths.cpp b/src/Unlinking/UnlinkerPaths.cpp similarity index 100% rename from src/Unlinker/UnlinkerPaths.cpp rename to src/Unlinking/UnlinkerPaths.cpp diff --git a/src/Unlinker/UnlinkerPaths.h b/src/Unlinking/UnlinkerPaths.h similarity index 100% rename from src/Unlinker/UnlinkerPaths.h rename to src/Unlinking/UnlinkerPaths.h diff --git a/src/ZoneCode.lua b/src/ZoneCode.lua index 1d418539..d1aa9200 100644 --- a/src/ZoneCode.lua +++ b/src/ZoneCode.lua @@ -225,6 +225,20 @@ function ZoneCode:allTestFiles() return result end +function ZoneCode:allMarkFiles() + result = {} + + for game, assets in pairs(self.Assets) do + for i, assetName in ipairs(assets) do + local assetNameLower = string.lower(assetName) + table.insert(result, "%{wks.location}/src/ZoneCode/Game/" .. game .. "/XAssets/" .. assetNameLower .. "/" .. assetNameLower .. "_mark_db.cpp") + table.insert(result, "%{wks.location}/src/ZoneCode/Game/" .. game .. "/XAssets/" .. assetNameLower .. "/" .. assetNameLower .. "_mark_db.h") + end + end + + return result +end + function ZoneCode:allLoadFiles() result = {} @@ -233,8 +247,6 @@ function ZoneCode:allLoadFiles() local assetNameLower = string.lower(assetName) table.insert(result, "%{wks.location}/src/ZoneCode/Game/" .. game .. "/XAssets/" .. assetNameLower .. "/" .. assetNameLower .. "_load_db.cpp") table.insert(result, "%{wks.location}/src/ZoneCode/Game/" .. game .. "/XAssets/" .. assetNameLower .. "/" .. assetNameLower .. "_load_db.h") - table.insert(result, "%{wks.location}/src/ZoneCode/Game/" .. game .. "/XAssets/" .. assetNameLower .. "/" .. assetNameLower .. "_mark_db.cpp") - table.insert(result, "%{wks.location}/src/ZoneCode/Game/" .. game .. "/XAssets/" .. assetNameLower .. "/" .. assetNameLower .. "_mark_db.h") end end diff --git a/src/ZoneCodeGeneratorLib/Generating/Templates/ZoneLoadTemplate.cpp b/src/ZoneCodeGeneratorLib/Generating/Templates/ZoneLoadTemplate.cpp index c3b7f438..d0283505 100644 --- a/src/ZoneCodeGeneratorLib/Generating/Templates/ZoneLoadTemplate.cpp +++ b/src/ZoneCodeGeneratorLib/Generating/Templates/ZoneLoadTemplate.cpp @@ -145,7 +145,9 @@ namespace LINE("") LINEF("#include \"{0}_load_db.h\"", Lower(m_env.m_asset->m_definition->m_name)) LINE("") - LINEF("#include \"{0}_mark_db.h\"", Lower(m_env.m_asset->m_definition->m_name)) + LINEF("#include \"Game/{0}/AssetMarker{0}.h\"", m_env.m_game) + LINE("") + LINE("#include \"Loading/AssetInfoCollector.h\"") if (!m_env.m_referenced_assets.empty()) { @@ -236,11 +238,6 @@ namespace return std::format("Loader_{0}", asset->m_definition->m_name); } - static std::string MarkerClassName(const StructureInformation* asset) - { - return std::format("Marker_{0}", asset->m_definition->m_name); - } - static std::string VariableDecl(const DataDefinition* def) { return std::format("{0}* var{1};", def->GetFullName(), MakeSafeTypeName(def)); @@ -2155,14 +2152,16 @@ namespace LINE("assert(pAsset != nullptr);") LINE("") - LINEF("{0} marker(m_zone);", MarkerClassName(m_env.m_asset)) + LINE("AssetInfoCollector assetInfo(m_zone);") + LINEF("AssetMarker<{0}> marker(assetInfo);", m_env.m_asset->m_asset_name) LINE("marker.Mark(*pAsset);") LINE("") LINEF("auto* reallocatedAsset = m_zone.Memory().Alloc<{0}>();", info->m_definition->GetFullName()) LINEF("std::memcpy(reallocatedAsset, *pAsset, sizeof({0}));", info->m_definition->GetFullName()) LINE("") - LINEF("m_asset_info = reinterpret_cast*>(LinkAsset(AssetNameAccessor<{1}>()(**pAsset), reallocatedAsset, marker.GetDependencies(), " - "marker.GetUsedScriptStrings(), marker.GetIndirectAssetReferences()));", + LINEF("m_asset_info = reinterpret_cast*>(LinkAsset(AssetName<{1}>(**pAsset), reallocatedAsset, " + "assetInfo.GetDependencies(), " + "assetInfo.GetUsedScriptStrings(), assetInfo.GetIndirectAssetReferences()));", info->m_definition->GetFullName(), info->m_asset_name) LINE("*pAsset = m_asset_info->Asset();") @@ -2186,7 +2185,7 @@ namespace LINE("") LINE("if (m_asset_info == nullptr && *pAsset != nullptr)") m_intendation++; - LINEF("m_asset_info = reinterpret_cast*>(GetAssetInfo(AssetNameAccessor<{1}>()(**pAsset)));", + LINEF("m_asset_info = reinterpret_cast*>(GetAssetInfo(AssetName<{1}>(**pAsset)));", m_env.m_asset->m_definition->GetFullName(), m_env.m_asset->m_asset_name) m_intendation--; diff --git a/src/ZoneCodeGeneratorLib/Generating/Templates/ZoneMarkTemplate.cpp b/src/ZoneCodeGeneratorLib/Generating/Templates/ZoneMarkTemplate.cpp index f5add84c..d43dafc2 100644 --- a/src/ZoneCodeGeneratorLib/Generating/Templates/ZoneMarkTemplate.cpp +++ b/src/ZoneCodeGeneratorLib/Generating/Templates/ZoneMarkTemplate.cpp @@ -32,14 +32,15 @@ namespace LINE("#pragma once") LINE("") LINEF("#include \"Game/{0}/{0}.h\"", m_env.m_game) - LINE("#include \"Loading/AssetMarker.h\"") + LINE("#include \"Marking/BaseAssetMarker.h\"") + LINE("#include \"Marking/AssetVisitor.h\"") LINE("") LINE("#include ") LINE("") LINEF("namespace {0}", m_env.m_game) LINE("{") m_intendation++; - LINEF("class {0} final : public AssetMarker", MarkerClassName(m_env.m_asset)) + LINEF("class {0} final : public BaseAssetMarker", MarkerClassName(m_env.m_asset)) LINE("{") m_intendation++; @@ -48,7 +49,6 @@ namespace m_intendation++; PrintHeaderConstructor(); PrintHeaderMainMarkMethodDeclaration(m_env.m_asset); - PrintHeaderGetAssetInfoMethodDeclaration(m_env.m_asset); LINE("") m_intendation--; @@ -107,6 +107,8 @@ namespace LINE("};") m_intendation--; LINE("}") + LINE("") + LINEF("DEFINE_MARKER_CLASS_FOR_ASSET({0}::{1}, {0}::{2})", m_env.m_game, m_env.m_asset->m_asset_name, MarkerClassName(m_env.m_asset)) } void Source() @@ -136,8 +138,6 @@ namespace PrintConstructorMethod(); LINE("") PrintMainMarkMethod(); - LINE("") - PrintGetAssetInfoMethod(); for (const auto* type : m_env.m_used_types) { @@ -210,14 +210,9 @@ namespace LINEF("void Mark_{0}();", MakeSafeTypeName(info->m_definition)) } - void PrintHeaderGetAssetInfoMethodDeclaration(const StructureInformation* info) const - { - LINEF("XAssetInfo<{0}>* GetAssetInfo({0}* pAsset) const;", info->m_definition->GetFullName()) - } - void PrintHeaderConstructor() const { - LINEF("{0}(Zone& zone);", MarkerClassName(m_env.m_asset)) + LINEF("explicit {0}(AssetVisitor& visitor);", MarkerClassName(m_env.m_asset)) } void PrintHeaderMainMarkMethodDeclaration(const StructureInformation* info) const @@ -237,10 +232,10 @@ namespace void PrintConstructorMethod() { - LINEF("{0}::{0}(Zone& zone)", MarkerClassName(m_env.m_asset)) + LINEF("{0}::{0}(AssetVisitor& visitor)", MarkerClassName(m_env.m_asset)) m_intendation++; - LINEF(": AssetMarker({0}::EnumEntry, zone)", m_env.m_asset->m_asset_name) + LINE(": BaseAssetMarker(visitor)") m_intendation--; LINE("{") @@ -286,7 +281,7 @@ namespace if (info && StructureComputations(info).IsAsset()) { - LINEF("AddDependency({0}(m_zone).GetAssetInfo(*{1}));", MarkerClassName(info), MakeTypePtrVarName(def)) + LINEF("Mark_Dependency<{0}>(*{1});", info->m_asset_name, MakeTypePtrVarName(def)) } else { @@ -413,7 +408,7 @@ namespace { if (loadType == MemberLoadType::SINGLE_POINTER) { - LINEF("AddDependency({0}(m_zone).GetAssetInfo({1}));", MarkerClassName(member->m_type), MakeMemberAccess(info, member, modifier)) + LINEF("Mark_Dependency<{0}>({1});", member->m_type->m_asset_name, MakeMemberAccess(info, member, modifier)) } else if (loadType == MemberLoadType::POINTER_ARRAY) { @@ -752,20 +747,6 @@ namespace LINE("}") } - void PrintGetAssetInfoMethod() - { - LINEF("XAssetInfo<{0}>* {1}::GetAssetInfo({0}* pAsset) const", m_env.m_asset->m_definition->GetFullName(), MarkerClassName(m_env.m_asset)) - LINE("{") - m_intendation++; - - LINEF("return reinterpret_cast*>(GetAssetInfoByName(AssetNameAccessor<{1}>()(*pAsset)));", - m_env.m_asset->m_definition->GetFullName(), - m_env.m_asset->m_asset_name) - - m_intendation--; - LINE("}") - } - void PrintMainMarkMethod() { LINEF("void {0}::Mark({1}* pAsset)", MarkerClassName(m_env.m_asset), m_env.m_asset->m_definition->GetFullName()) diff --git a/src/ZoneCodeGeneratorLib/Generating/Templates/ZoneWriteTemplate.cpp b/src/ZoneCodeGeneratorLib/Generating/Templates/ZoneWriteTemplate.cpp index dc27cb35..64848e49 100644 --- a/src/ZoneCodeGeneratorLib/Generating/Templates/ZoneWriteTemplate.cpp +++ b/src/ZoneCodeGeneratorLib/Generating/Templates/ZoneWriteTemplate.cpp @@ -261,7 +261,7 @@ namespace "{0}::{0}({1}* asset, const Zone& zone, IZoneOutputStream& stream)", WriterClassName(m_env.m_asset), m_env.m_asset->m_definition->GetFullName()) m_intendation++; - LINEF(": AssetWriter(zone.m_pools->GetAssetOrAssetReference({0}::EnumEntry, AssetNameAccessor<{0}>()(*asset)), zone, stream)", + LINEF(": AssetWriter(zone.m_pools->GetAssetOrAssetReference({0}::EnumEntry, NonReferenceAssetName(AssetName<{0}>(*asset))), zone, stream)", m_env.m_asset->m_asset_name) m_intendation--; diff --git a/src/ZoneCommon.lua b/src/ZoneCommon.lua index bd887778..e293d7d0 100644 --- a/src/ZoneCommon.lua +++ b/src/ZoneCommon.lua @@ -10,6 +10,7 @@ function ZoneCommon:include(includes) ObjCommon:include(includes) Parser:include(includes) Cryptography:include(includes) + ZoneCode:include(includes) end end @@ -21,6 +22,7 @@ function ZoneCommon:link(links) links:linkto(Parser) links:linkto(Utils) links:linkto(lzx) + ZoneCode:use() end function ZoneCommon:use() @@ -43,9 +45,20 @@ function ZoneCommon:project() files { path.join(folder, "ZoneCommon/**.h"), - path.join(folder, "ZoneCommon/**.cpp") + path.join(folder, "ZoneCommon/**.cpp"), + ZoneCode:allMarkFiles() + } + + vpaths { + ["*"] = { + path.join(folder, "ZoneCommon"), + path.join(BuildFolder(), "src/ZoneCode") + } } - lzx:include(includes) self:include(includes) + lzx:include(includes) + ZoneCode:include(includes) + + ZoneCode:use() end diff --git a/src/ZoneCommon/Game/IW3/AssetMarkerIW3.h b/src/ZoneCommon/Game/IW3/AssetMarkerIW3.h new file mode 100644 index 00000000..e2d0217a --- /dev/null +++ b/src/ZoneCommon/Game/IW3/AssetMarkerIW3.h @@ -0,0 +1,27 @@ +#pragma once + +#include "Game/IW3/XAssets/clipmap_t/clipmap_t_mark_db.h" +#include "Game/IW3/XAssets/comworld/comworld_mark_db.h" +#include "Game/IW3/XAssets/font_s/font_s_mark_db.h" +#include "Game/IW3/XAssets/fxeffectdef/fxeffectdef_mark_db.h" +#include "Game/IW3/XAssets/fximpacttable/fximpacttable_mark_db.h" +#include "Game/IW3/XAssets/gameworldmp/gameworldmp_mark_db.h" +#include "Game/IW3/XAssets/gameworldsp/gameworldsp_mark_db.h" +#include "Game/IW3/XAssets/gfximage/gfximage_mark_db.h" +#include "Game/IW3/XAssets/gfxlightdef/gfxlightdef_mark_db.h" +#include "Game/IW3/XAssets/gfxworld/gfxworld_mark_db.h" +#include "Game/IW3/XAssets/loadedsound/loadedsound_mark_db.h" +#include "Game/IW3/XAssets/localizeentry/localizeentry_mark_db.h" +#include "Game/IW3/XAssets/mapents/mapents_mark_db.h" +#include "Game/IW3/XAssets/material/material_mark_db.h" +#include "Game/IW3/XAssets/materialtechniqueset/materialtechniqueset_mark_db.h" +#include "Game/IW3/XAssets/menudef_t/menudef_t_mark_db.h" +#include "Game/IW3/XAssets/menulist/menulist_mark_db.h" +#include "Game/IW3/XAssets/physpreset/physpreset_mark_db.h" +#include "Game/IW3/XAssets/rawfile/rawfile_mark_db.h" +#include "Game/IW3/XAssets/snd_alias_list_t/snd_alias_list_t_mark_db.h" +#include "Game/IW3/XAssets/sndcurve/sndcurve_mark_db.h" +#include "Game/IW3/XAssets/stringtable/stringtable_mark_db.h" +#include "Game/IW3/XAssets/weapondef/weapondef_mark_db.h" +#include "Game/IW3/XAssets/xanimparts/xanimparts_mark_db.h" +#include "Game/IW3/XAssets/xmodel/xmodel_mark_db.h" diff --git a/src/ZoneCommon/Game/IW4/AssetMarkerIW4.h b/src/ZoneCommon/Game/IW4/AssetMarkerIW4.h new file mode 100644 index 00000000..73122e2a --- /dev/null +++ b/src/ZoneCommon/Game/IW4/AssetMarkerIW4.h @@ -0,0 +1,37 @@ +#pragma once + +#include "Game/IW4/XAssets/addonmapents/addonmapents_mark_db.h" +#include "Game/IW4/XAssets/clipmap_t/clipmap_t_mark_db.h" +#include "Game/IW4/XAssets/comworld/comworld_mark_db.h" +#include "Game/IW4/XAssets/font_s/font_s_mark_db.h" +#include "Game/IW4/XAssets/fxeffectdef/fxeffectdef_mark_db.h" +#include "Game/IW4/XAssets/fximpacttable/fximpacttable_mark_db.h" +#include "Game/IW4/XAssets/fxworld/fxworld_mark_db.h" +#include "Game/IW4/XAssets/gameworldmp/gameworldmp_mark_db.h" +#include "Game/IW4/XAssets/gameworldsp/gameworldsp_mark_db.h" +#include "Game/IW4/XAssets/gfximage/gfximage_mark_db.h" +#include "Game/IW4/XAssets/gfxlightdef/gfxlightdef_mark_db.h" +#include "Game/IW4/XAssets/gfxworld/gfxworld_mark_db.h" +#include "Game/IW4/XAssets/leaderboarddef/leaderboarddef_mark_db.h" +#include "Game/IW4/XAssets/loadedsound/loadedsound_mark_db.h" +#include "Game/IW4/XAssets/localizeentry/localizeentry_mark_db.h" +#include "Game/IW4/XAssets/mapents/mapents_mark_db.h" +#include "Game/IW4/XAssets/material/material_mark_db.h" +#include "Game/IW4/XAssets/materialpixelshader/materialpixelshader_mark_db.h" +#include "Game/IW4/XAssets/materialtechniqueset/materialtechniqueset_mark_db.h" +#include "Game/IW4/XAssets/materialvertexdeclaration/materialvertexdeclaration_mark_db.h" +#include "Game/IW4/XAssets/materialvertexshader/materialvertexshader_mark_db.h" +#include "Game/IW4/XAssets/menudef_t/menudef_t_mark_db.h" +#include "Game/IW4/XAssets/menulist/menulist_mark_db.h" +#include "Game/IW4/XAssets/physcollmap/physcollmap_mark_db.h" +#include "Game/IW4/XAssets/physpreset/physpreset_mark_db.h" +#include "Game/IW4/XAssets/rawfile/rawfile_mark_db.h" +#include "Game/IW4/XAssets/snd_alias_list_t/snd_alias_list_t_mark_db.h" +#include "Game/IW4/XAssets/sndcurve/sndcurve_mark_db.h" +#include "Game/IW4/XAssets/stringtable/stringtable_mark_db.h" +#include "Game/IW4/XAssets/structureddatadefset/structureddatadefset_mark_db.h" +#include "Game/IW4/XAssets/tracerdef/tracerdef_mark_db.h" +#include "Game/IW4/XAssets/vehicledef/vehicledef_mark_db.h" +#include "Game/IW4/XAssets/weaponcompletedef/weaponcompletedef_mark_db.h" +#include "Game/IW4/XAssets/xanimparts/xanimparts_mark_db.h" +#include "Game/IW4/XAssets/xmodel/xmodel_mark_db.h" diff --git a/src/ZoneCommon/Game/IW5/AssetMarkerIW5.h b/src/ZoneCommon/Game/IW5/AssetMarkerIW5.h new file mode 100644 index 00000000..3518e239 --- /dev/null +++ b/src/ZoneCommon/Game/IW5/AssetMarkerIW5.h @@ -0,0 +1,42 @@ +#pragma once + +#include "Game/IW5/XAssets/addonmapents/addonmapents_mark_db.h" +#include "Game/IW5/XAssets/clipmap_t/clipmap_t_mark_db.h" +#include "Game/IW5/XAssets/comworld/comworld_mark_db.h" +#include "Game/IW5/XAssets/font_s/font_s_mark_db.h" +#include "Game/IW5/XAssets/fxeffectdef/fxeffectdef_mark_db.h" +#include "Game/IW5/XAssets/fximpacttable/fximpacttable_mark_db.h" +#include "Game/IW5/XAssets/fxworld/fxworld_mark_db.h" +#include "Game/IW5/XAssets/gfximage/gfximage_mark_db.h" +#include "Game/IW5/XAssets/gfxlightdef/gfxlightdef_mark_db.h" +#include "Game/IW5/XAssets/gfxworld/gfxworld_mark_db.h" +#include "Game/IW5/XAssets/glassworld/glassworld_mark_db.h" +#include "Game/IW5/XAssets/leaderboarddef/leaderboarddef_mark_db.h" +#include "Game/IW5/XAssets/loadedsound/loadedsound_mark_db.h" +#include "Game/IW5/XAssets/localizeentry/localizeentry_mark_db.h" +#include "Game/IW5/XAssets/mapents/mapents_mark_db.h" +#include "Game/IW5/XAssets/material/material_mark_db.h" +#include "Game/IW5/XAssets/materialpixelshader/materialpixelshader_mark_db.h" +#include "Game/IW5/XAssets/materialtechniqueset/materialtechniqueset_mark_db.h" +#include "Game/IW5/XAssets/materialvertexdeclaration/materialvertexdeclaration_mark_db.h" +#include "Game/IW5/XAssets/materialvertexshader/materialvertexshader_mark_db.h" +#include "Game/IW5/XAssets/menudef_t/menudef_t_mark_db.h" +#include "Game/IW5/XAssets/menulist/menulist_mark_db.h" +#include "Game/IW5/XAssets/pathdata/pathdata_mark_db.h" +#include "Game/IW5/XAssets/physcollmap/physcollmap_mark_db.h" +#include "Game/IW5/XAssets/physpreset/physpreset_mark_db.h" +#include "Game/IW5/XAssets/rawfile/rawfile_mark_db.h" +#include "Game/IW5/XAssets/scriptfile/scriptfile_mark_db.h" +#include "Game/IW5/XAssets/snd_alias_list_t/snd_alias_list_t_mark_db.h" +#include "Game/IW5/XAssets/sndcurve/sndcurve_mark_db.h" +#include "Game/IW5/XAssets/stringtable/stringtable_mark_db.h" +#include "Game/IW5/XAssets/structureddatadefset/structureddatadefset_mark_db.h" +#include "Game/IW5/XAssets/surfacefxtable/surfacefxtable_mark_db.h" +#include "Game/IW5/XAssets/tracerdef/tracerdef_mark_db.h" +#include "Game/IW5/XAssets/vehicledef/vehicledef_mark_db.h" +#include "Game/IW5/XAssets/vehicletrack/vehicletrack_mark_db.h" +#include "Game/IW5/XAssets/weaponattachment/weaponattachment_mark_db.h" +#include "Game/IW5/XAssets/weaponcompletedef/weaponcompletedef_mark_db.h" +#include "Game/IW5/XAssets/xanimparts/xanimparts_mark_db.h" +#include "Game/IW5/XAssets/xmodel/xmodel_mark_db.h" +#include "Game/IW5/XAssets/xmodelsurfs/xmodelsurfs_mark_db.h" diff --git a/src/ZoneCommon/Game/T5/AssetMarkerT5.h b/src/ZoneCommon/Game/T5/AssetMarkerT5.h new file mode 100644 index 00000000..10bba7f8 --- /dev/null +++ b/src/ZoneCommon/Game/T5/AssetMarkerT5.h @@ -0,0 +1,34 @@ +#pragma once + +#include "Game/T5/XAssets/clipmap_t/clipmap_t_mark_db.h" +#include "Game/T5/XAssets/comworld/comworld_mark_db.h" +#include "Game/T5/XAssets/ddlroot_t/ddlroot_t_mark_db.h" +#include "Game/T5/XAssets/destructibledef/destructibledef_mark_db.h" +#include "Game/T5/XAssets/emblemset/emblemset_mark_db.h" +#include "Game/T5/XAssets/font_s/font_s_mark_db.h" +#include "Game/T5/XAssets/fxeffectdef/fxeffectdef_mark_db.h" +#include "Game/T5/XAssets/fximpacttable/fximpacttable_mark_db.h" +#include "Game/T5/XAssets/gameworldmp/gameworldmp_mark_db.h" +#include "Game/T5/XAssets/gameworldsp/gameworldsp_mark_db.h" +#include "Game/T5/XAssets/gfximage/gfximage_mark_db.h" +#include "Game/T5/XAssets/gfxlightdef/gfxlightdef_mark_db.h" +#include "Game/T5/XAssets/gfxworld/gfxworld_mark_db.h" +#include "Game/T5/XAssets/glasses/glasses_mark_db.h" +#include "Game/T5/XAssets/localizeentry/localizeentry_mark_db.h" +#include "Game/T5/XAssets/mapents/mapents_mark_db.h" +#include "Game/T5/XAssets/material/material_mark_db.h" +#include "Game/T5/XAssets/materialtechniqueset/materialtechniqueset_mark_db.h" +#include "Game/T5/XAssets/menudef_t/menudef_t_mark_db.h" +#include "Game/T5/XAssets/menulist/menulist_mark_db.h" +#include "Game/T5/XAssets/packindex/packindex_mark_db.h" +#include "Game/T5/XAssets/physconstraints/physconstraints_mark_db.h" +#include "Game/T5/XAssets/physpreset/physpreset_mark_db.h" +#include "Game/T5/XAssets/rawfile/rawfile_mark_db.h" +#include "Game/T5/XAssets/sndbank/sndbank_mark_db.h" +#include "Game/T5/XAssets/snddriverglobals/snddriverglobals_mark_db.h" +#include "Game/T5/XAssets/sndpatch/sndpatch_mark_db.h" +#include "Game/T5/XAssets/stringtable/stringtable_mark_db.h" +#include "Game/T5/XAssets/weaponvariantdef/weaponvariantdef_mark_db.h" +#include "Game/T5/XAssets/xanimparts/xanimparts_mark_db.h" +#include "Game/T5/XAssets/xglobals/xglobals_mark_db.h" +#include "Game/T5/XAssets/xmodel/xmodel_mark_db.h" diff --git a/src/ZoneCommon/Game/T6/AssetMarkerT6.h b/src/ZoneCommon/Game/T6/AssetMarkerT6.h new file mode 100644 index 00000000..5c2557dc --- /dev/null +++ b/src/ZoneCommon/Game/T6/AssetMarkerT6.h @@ -0,0 +1,50 @@ +#pragma once + +#include "Game/T6/XAssets/addonmapents/addonmapents_mark_db.h" +#include "Game/T6/XAssets/clipmap_t/clipmap_t_mark_db.h" +#include "Game/T6/XAssets/comworld/comworld_mark_db.h" +#include "Game/T6/XAssets/ddlroot_t/ddlroot_t_mark_db.h" +#include "Game/T6/XAssets/destructibledef/destructibledef_mark_db.h" +#include "Game/T6/XAssets/emblemset/emblemset_mark_db.h" +#include "Game/T6/XAssets/font_s/font_s_mark_db.h" +#include "Game/T6/XAssets/fonticon/fonticon_mark_db.h" +#include "Game/T6/XAssets/footstepfxtabledef/footstepfxtabledef_mark_db.h" +#include "Game/T6/XAssets/footsteptabledef/footsteptabledef_mark_db.h" +#include "Game/T6/XAssets/fxeffectdef/fxeffectdef_mark_db.h" +#include "Game/T6/XAssets/fximpacttable/fximpacttable_mark_db.h" +#include "Game/T6/XAssets/gameworldmp/gameworldmp_mark_db.h" +#include "Game/T6/XAssets/gameworldsp/gameworldsp_mark_db.h" +#include "Game/T6/XAssets/gfximage/gfximage_mark_db.h" +#include "Game/T6/XAssets/gfxlightdef/gfxlightdef_mark_db.h" +#include "Game/T6/XAssets/gfxworld/gfxworld_mark_db.h" +#include "Game/T6/XAssets/glasses/glasses_mark_db.h" +#include "Game/T6/XAssets/keyvaluepairs/keyvaluepairs_mark_db.h" +#include "Game/T6/XAssets/leaderboarddef/leaderboarddef_mark_db.h" +#include "Game/T6/XAssets/localizeentry/localizeentry_mark_db.h" +#include "Game/T6/XAssets/mapents/mapents_mark_db.h" +#include "Game/T6/XAssets/material/material_mark_db.h" +#include "Game/T6/XAssets/materialtechniqueset/materialtechniqueset_mark_db.h" +#include "Game/T6/XAssets/memoryblock/memoryblock_mark_db.h" +#include "Game/T6/XAssets/menudef_t/menudef_t_mark_db.h" +#include "Game/T6/XAssets/menulist/menulist_mark_db.h" +#include "Game/T6/XAssets/physconstraints/physconstraints_mark_db.h" +#include "Game/T6/XAssets/physpreset/physpreset_mark_db.h" +#include "Game/T6/XAssets/qdb/qdb_mark_db.h" +#include "Game/T6/XAssets/rawfile/rawfile_mark_db.h" +#include "Game/T6/XAssets/scriptparsetree/scriptparsetree_mark_db.h" +#include "Game/T6/XAssets/skinnedvertsdef/skinnedvertsdef_mark_db.h" +#include "Game/T6/XAssets/slug/slug_mark_db.h" +#include "Game/T6/XAssets/sndbank/sndbank_mark_db.h" +#include "Game/T6/XAssets/snddriverglobals/snddriverglobals_mark_db.h" +#include "Game/T6/XAssets/sndpatch/sndpatch_mark_db.h" +#include "Game/T6/XAssets/stringtable/stringtable_mark_db.h" +#include "Game/T6/XAssets/tracerdef/tracerdef_mark_db.h" +#include "Game/T6/XAssets/vehicledef/vehicledef_mark_db.h" +#include "Game/T6/XAssets/weaponattachment/weaponattachment_mark_db.h" +#include "Game/T6/XAssets/weaponattachmentunique/weaponattachmentunique_mark_db.h" +#include "Game/T6/XAssets/weaponcamo/weaponcamo_mark_db.h" +#include "Game/T6/XAssets/weaponvariantdef/weaponvariantdef_mark_db.h" +#include "Game/T6/XAssets/xanimparts/xanimparts_mark_db.h" +#include "Game/T6/XAssets/xglobals/xglobals_mark_db.h" +#include "Game/T6/XAssets/xmodel/xmodel_mark_db.h" +#include "Game/T6/XAssets/zbarrierdef/zbarrierdef_mark_db.h" diff --git a/src/ZoneCommon/Marking/AssetVisitor.h b/src/ZoneCommon/Marking/AssetVisitor.h new file mode 100644 index 00000000..4a74d962 --- /dev/null +++ b/src/ZoneCommon/Marking/AssetVisitor.h @@ -0,0 +1,29 @@ +#pragma once + +#include "Pool/XAssetInfo.h" +#include "Zone/ZoneTypes.h" + +#include + +class AssetVisitor +{ +public: + virtual ~AssetVisitor() = default; + + virtual std::optional Visit_Dependency(asset_type_t assetType, const char* assetName) + { + // Do nothing by default + return std::nullopt; + } + + virtual std::optional Visit_ScriptString(scr_string_t scriptString) + { + // Do nothing by default + return std::nullopt; + } + + virtual void Visit_IndirectAssetRef(asset_type_t assetType, const char* assetName) + { + // Do nothing by default + } +}; diff --git a/src/ZoneCommon/Marking/BaseAssetMarker.cpp b/src/ZoneCommon/Marking/BaseAssetMarker.cpp new file mode 100644 index 00000000..0ee03381 --- /dev/null +++ b/src/ZoneCommon/Marking/BaseAssetMarker.cpp @@ -0,0 +1,40 @@ +#include "BaseAssetMarker.h" + +#include +#include + +BaseAssetMarker::BaseAssetMarker(AssetVisitor& visitor) + : m_visitor(visitor) +{ +} + +void BaseAssetMarker::Mark_ScriptString(scr_string_t& scriptString) const +{ + const auto result = m_visitor.Visit_ScriptString(scriptString); + if (result.has_value()) + scriptString = *result; +} + +void BaseAssetMarker::MarkArray_ScriptString(scr_string_t* scriptStringArray, const size_t count) const +{ + assert(scriptStringArray != nullptr); + + for (size_t index = 0; index < count; index++) + Mark_ScriptString(scriptStringArray[index]); +} + +void BaseAssetMarker::Mark_IndirectAssetRef(const asset_type_t assetType, const char* assetName) const +{ + if (!assetName) + return; + + m_visitor.Visit_IndirectAssetRef(assetType, assetName); +} + +void BaseAssetMarker::MarkArray_IndirectAssetRef(const asset_type_t assetType, const char** assetNames, const size_t count) const +{ + assert(assetNames != nullptr); + + for (size_t index = 0; index < count; index++) + Mark_IndirectAssetRef(assetType, assetNames[index]); +} diff --git a/src/ZoneCommon/Marking/BaseAssetMarker.h b/src/ZoneCommon/Marking/BaseAssetMarker.h new file mode 100644 index 00000000..2a0cd3f3 --- /dev/null +++ b/src/ZoneCommon/Marking/BaseAssetMarker.h @@ -0,0 +1,45 @@ +#pragma once + +#include "Game/IAsset.h" +#include "Marking/AssetVisitor.h" +#include "Zone/ZoneTypes.h" + +#include + +class BaseAssetMarker +{ +protected: + explicit BaseAssetMarker(AssetVisitor& visitor); + + template void Mark_Dependency(std::add_lvalue_reference_t> asset) + { + static_assert(std::is_base_of_v); + + const auto result = m_visitor.Visit_Dependency(AssetType::EnumEntry, AssetName(*asset)); + if (result.has_value()) + asset = static_cast>((*result)->m_ptr); + } + + void Mark_ScriptString(scr_string_t& scriptString) const; + void MarkArray_ScriptString(scr_string_t* scriptStringArray, size_t count) const; + + void Mark_IndirectAssetRef(asset_type_t assetType, const char* assetName) const; + void MarkArray_IndirectAssetRef(asset_type_t assetType, const char** assetNames, size_t count) const; + + AssetVisitor& m_visitor; +}; + +template struct AssetMarkerWrapper +{ + static_assert(std::is_base_of_v); + // using WrapperClass = WrapperClass; +}; + +template using AssetMarker = AssetMarkerWrapper::WrapperClass; + +#define DEFINE_MARKER_CLASS_FOR_ASSET(asset, markerClass) \ + template<> struct AssetMarkerWrapper \ + { \ + static_assert(std::is_base_of_v); \ + using WrapperClass = markerClass; \ + }; diff --git a/src/ZoneLoading/Loading/AssetInfoCollector.cpp b/src/ZoneLoading/Loading/AssetInfoCollector.cpp new file mode 100644 index 00000000..0f9dbeeb --- /dev/null +++ b/src/ZoneLoading/Loading/AssetInfoCollector.cpp @@ -0,0 +1,85 @@ +#include "AssetInfoCollector.h" + +#include +#include + +AssetInfoCollector::AssetInfoCollector(Zone& zone) + : m_zone(zone) +{ +} + +std::vector AssetInfoCollector::GetDependencies() const +{ + std::vector dependencies; + if (!m_dependencies.empty()) + { + dependencies.reserve(m_dependencies.size()); + for (auto dependency : m_dependencies) + dependencies.push_back(dependency); + } + + return dependencies; +} + +std::vector AssetInfoCollector::GetUsedScriptStrings() const +{ + std::vector usedScriptStrings; + if (!m_used_script_strings.empty()) + { + usedScriptStrings.reserve(m_used_script_strings.size()); + for (auto scrString : m_used_script_strings) + usedScriptStrings.push_back(scrString); + + std::ranges::sort(usedScriptStrings); + } + + return usedScriptStrings; +} + +std::vector AssetInfoCollector::GetIndirectAssetReferences() const +{ + std::vector assetReferences; + if (!m_indirect_asset_references.empty()) + { + assetReferences.reserve(m_indirect_asset_references.size()); + for (const auto& assetReference : m_indirect_asset_references) + assetReferences.emplace_back(assetReference); + } + + return assetReferences; +} + +std::optional AssetInfoCollector::Visit_Dependency(const asset_type_t assetType, const char* assetName) +{ + auto* assetInfo = m_zone.m_pools->GetAsset(assetType, assetName); + if (assetInfo == nullptr) + return std::nullopt; + + const auto existingEntry = m_dependencies.find(assetInfo); + if (existingEntry != m_dependencies.end()) + return std::nullopt; + + m_dependencies.emplace(assetInfo); + + return std::nullopt; +} + +std::optional AssetInfoCollector::Visit_ScriptString(scr_string_t scriptString) +{ + assert(scriptString < m_zone.m_script_strings.Count()); + + if (scriptString >= m_zone.m_script_strings.Count()) + return std::nullopt; + + m_used_script_strings.emplace(scriptString); + + return std::nullopt; +} + +void AssetInfoCollector::Visit_IndirectAssetRef(asset_type_t assetType, const char* assetName) +{ + if (!assetName || !assetName[0]) + return; + + m_indirect_asset_references.emplace(assetType, assetName); +} diff --git a/src/ZoneLoading/Loading/AssetInfoCollector.h b/src/ZoneLoading/Loading/AssetInfoCollector.h new file mode 100644 index 00000000..7bb70fc2 --- /dev/null +++ b/src/ZoneLoading/Loading/AssetInfoCollector.h @@ -0,0 +1,31 @@ +#pragma once + +#include "Marking/AssetVisitor.h" +#include "Pool/XAssetInfo.h" +#include "Zone/ZoneTypes.h" + +#include +#include +#include + +class AssetInfoCollector : public AssetVisitor +{ +public: + explicit AssetInfoCollector(Zone& zone); + ~AssetInfoCollector() override = default; + + [[nodiscard]] std::vector GetDependencies() const; + [[nodiscard]] std::vector GetUsedScriptStrings() const; + [[nodiscard]] std::vector GetIndirectAssetReferences() const; + + std::optional Visit_Dependency(asset_type_t assetType, const char* assetName) override; + std::optional Visit_ScriptString(scr_string_t scriptString) override; + void Visit_IndirectAssetRef(asset_type_t assetType, const char* assetName) override; + +private: + std::unordered_set m_dependencies; + std::unordered_set m_used_script_strings; + std::unordered_set m_indirect_asset_references; + + Zone& m_zone; +}; diff --git a/src/ZoneLoading/Loading/AssetMarker.cpp b/src/ZoneLoading/Loading/AssetMarker.cpp deleted file mode 100644 index c215c7cf..00000000 --- a/src/ZoneLoading/Loading/AssetMarker.cpp +++ /dev/null @@ -1,102 +0,0 @@ -#include "AssetMarker.h" - -#include -#include - -AssetMarker::AssetMarker(const asset_type_t assetType, Zone& zone) - : m_zone(zone), - m_asset_type(assetType) -{ -} - -void AssetMarker::AddDependency(XAssetInfoGeneric* assetInfo) -{ - if (assetInfo == nullptr) - return; - - const auto existingEntry = m_dependencies.find(assetInfo); - if (existingEntry != m_dependencies.end()) - return; - - m_dependencies.emplace(assetInfo); -} - -void AssetMarker::Mark_ScriptString(const scr_string_t scrString) -{ - assert(scrString < m_zone.m_script_strings.Count()); - - if (scrString >= m_zone.m_script_strings.Count()) - return; - - m_used_script_strings.emplace(scrString); -} - -void AssetMarker::MarkArray_ScriptString(const scr_string_t* scrStringArray, const size_t count) -{ - assert(scrStringArray != nullptr); - - for (size_t index = 0; index < count; index++) - Mark_ScriptString(scrStringArray[index]); -} - -void AssetMarker::Mark_IndirectAssetRef(asset_type_t type, const char* assetRefName) -{ - if (!assetRefName || !assetRefName[0]) - return; - - m_indirect_asset_references.emplace(type, assetRefName); -} - -void AssetMarker::MarkArray_IndirectAssetRef(const asset_type_t type, const char** assetRefNames, const size_t count) -{ - assert(assetRefNames != nullptr); - - for (size_t index = 0; index < count; index++) - Mark_IndirectAssetRef(type, assetRefNames[index]); -} - -XAssetInfoGeneric* AssetMarker::GetAssetInfoByName(const std::string& name) const -{ - return m_zone.m_pools->GetAsset(m_asset_type, name); -} - -std::vector AssetMarker::GetDependencies() const -{ - std::vector dependencies; - if (!m_dependencies.empty()) - { - dependencies.reserve(m_dependencies.size()); - for (auto dependency : m_dependencies) - dependencies.push_back(dependency); - } - - return dependencies; -} - -std::vector AssetMarker::GetUsedScriptStrings() const -{ - std::vector usedScriptStrings; - if (!m_used_script_strings.empty()) - { - usedScriptStrings.reserve(m_used_script_strings.size()); - for (auto scrString : m_used_script_strings) - usedScriptStrings.push_back(scrString); - - std::ranges::sort(usedScriptStrings); - } - - return usedScriptStrings; -} - -std::vector AssetMarker::GetIndirectAssetReferences() const -{ - std::vector assetReferences; - if (!m_indirect_asset_references.empty()) - { - assetReferences.reserve(m_indirect_asset_references.size()); - for (const auto& assetReference : m_indirect_asset_references) - assetReferences.emplace_back(assetReference); - } - - return assetReferences; -} diff --git a/src/ZoneLoading/Loading/AssetMarker.h b/src/ZoneLoading/Loading/AssetMarker.h deleted file mode 100644 index 3507db4b..00000000 --- a/src/ZoneLoading/Loading/AssetMarker.h +++ /dev/null @@ -1,37 +0,0 @@ -#pragma once - -#include "ContentLoaderBase.h" -#include "Pool/XAssetInfo.h" -#include "Zone/ZoneTypes.h" - -#include - -class AssetMarker -{ -public: - [[nodiscard]] std::vector GetDependencies() const; - [[nodiscard]] std::vector GetUsedScriptStrings() const; - [[nodiscard]] std::vector GetIndirectAssetReferences() const; - -protected: - AssetMarker(asset_type_t assetType, Zone& zone); - - void AddDependency(XAssetInfoGeneric* assetInfo); - - void Mark_ScriptString(scr_string_t scrString); - void MarkArray_ScriptString(const scr_string_t* scrStringArray, size_t count); - - void Mark_IndirectAssetRef(asset_type_t type, const char* assetRefName); - void MarkArray_IndirectAssetRef(asset_type_t type, const char** assetRefNames, size_t count); - - [[nodiscard]] XAssetInfoGeneric* GetAssetInfoByName(const std::string& name) const; - - Zone& m_zone; - -private: - asset_type_t m_asset_type; - - std::unordered_set m_dependencies; - std::unordered_set m_used_script_strings; - std::unordered_set m_indirect_asset_references; -}; diff --git a/src/ZoneWriting/Writing/AssetWriter.cpp b/src/ZoneWriting/Writing/AssetWriter.cpp index 79426cfc..4dc9752c 100644 --- a/src/ZoneWriting/Writing/AssetWriter.cpp +++ b/src/ZoneWriting/Writing/AssetWriter.cpp @@ -10,6 +10,14 @@ AssetWriter::AssetWriter(XAssetInfoGeneric* asset, const Zone& zone, IZoneOutput { } +const char* AssetWriter::NonReferenceAssetName(const char* assetName) +{ + if (assetName && assetName[0] == ',') + return &assetName[1]; + + return assetName; +} + scr_string_t AssetWriter::UseScriptString(const scr_string_t scrString) const { assert(scrString < m_asset->m_zone->m_script_strings.Count()); @@ -17,6 +25,7 @@ scr_string_t AssetWriter::UseScriptString(const scr_string_t scrString) const if (m_asset->m_zone == &m_zone) return scrString; + // The asset comes from a different zone, we need to translate it const auto strValue = m_asset->m_zone->m_script_strings.CValue(scrString); return m_zone.m_script_strings.GetScriptString(strValue); } diff --git a/src/ZoneWriting/Writing/AssetWriter.h b/src/ZoneWriting/Writing/AssetWriter.h index 7dec6784..188828c1 100644 --- a/src/ZoneWriting/Writing/AssetWriter.h +++ b/src/ZoneWriting/Writing/AssetWriter.h @@ -11,7 +11,8 @@ class AssetWriter : public ContentWriterBase protected: AssetWriter(XAssetInfoGeneric* asset, const Zone& zone, IZoneOutputStream& stream); - _NODISCARD scr_string_t UseScriptString(scr_string_t scrString) const; + [[nodiscard]] static const char* NonReferenceAssetName(const char* assetName); + [[nodiscard]] scr_string_t UseScriptString(scr_string_t scrString) const; void WriteScriptStringArray(bool atStreamStart, size_t count); XAssetInfoGeneric* m_asset; diff --git a/test/Catch2Common.lua b/test/Catch2Common.lua index 514a4ca6..63d03a10 100644 --- a/test/Catch2Common.lua +++ b/test/Catch2Common.lua @@ -11,6 +11,7 @@ end function Catch2Common:link(links) links:add(self:name()) links:linkto(catch2) + links:linkto(Utils) end function Catch2Common:use() @@ -45,7 +46,9 @@ function Catch2Common:project() self:include(includes) catch2:include(includes) + Utils:include(includes) links:linkto(catch2) + links:linkto(Utils) links:linkall() end diff --git a/test/Catch2Common/OatTestPaths.cpp b/test/Catch2Common/OatTestPaths.cpp index 0370a1ba..faf0dd8b 100644 --- a/test/Catch2Common/OatTestPaths.cpp +++ b/test/Catch2Common/OatTestPaths.cpp @@ -24,4 +24,13 @@ namespace oat::paths return result; } + + std::filesystem::path GetTempDirectory(const std::string& subDir) + { + auto result = fs::current_path() / "build" / ".tmp" / subDir; + if (!fs::is_directory(result)) + fs::create_directories(result); + + return result; + } } // namespace oat::paths diff --git a/test/Catch2Common/OatTestPaths.h b/test/Catch2Common/OatTestPaths.h index c63783cf..12cad65c 100644 --- a/test/Catch2Common/OatTestPaths.h +++ b/test/Catch2Common/OatTestPaths.h @@ -1,10 +1,12 @@ #pragma once #include +#include namespace oat::paths { std::filesystem::path GetSourceDirectory(); std::filesystem::path GetTestDirectory(); std::filesystem::path GetTempDirectory(); + std::filesystem::path GetTempDirectory(const std::string& subDir); } // namespace oat::paths diff --git a/test/Catch2Common/main.cpp b/test/Catch2Common/main.cpp index b00818dc..eaf0bfbc 100644 --- a/test/Catch2Common/main.cpp +++ b/test/Catch2Common/main.cpp @@ -1,12 +1,28 @@ +#include "Utils/Logging/Log.h" + #include +#include #include #include #include namespace fs = std::filesystem; +namespace +{ + bool ShouldClearTempFolder() + { + auto* envVar = std::getenv("OAT_KEEP_TMP_DIR"); + + return !envVar || !envVar[0] || (envVar[0] == '0' && !envVar[1]); + } +} // namespace + int main(const int argc, char* argv[]) { + con::init(); + con::set_log_level(con::LogLevel::DEBUG); + const fs::path absoluteBinDir(fs::canonical(argv[0]).parent_path()); const auto expectedLibDir = absoluteBinDir.parent_path().parent_path(); @@ -15,24 +31,24 @@ int main(const int argc, char* argv[]) if (absoluteBinDir.filename() != "tests" || expectedLibDir.filename() != "lib" || expectedBuildDir.filename() != "build") { - std::cerr << std::format("Expected test binary to be in the folder it was compiled into (build/lib/?/tests) but was {}\n", absoluteBinDir.string()); - std::cerr << "Please do not move test executable out of compilation folder\n"; + con::error("Expected test binary to be in the folder it was compiled into (build/lib/?/tests) but was {}", absoluteBinDir.string()); + con::error("Please do not move test executable out of compilation folder"); return 1; } const auto expectedSrcDir = expectedRootDir / "src"; if (!fs::is_directory(expectedSrcDir)) { - std::cerr << std::format("Expected source directory to exist in {}, but it did not\n", expectedSrcDir.string()); - std::cerr << "Please do not move test executable out of compilation folder\n"; + con::error("Expected source directory to exist in {}, but it did not", expectedSrcDir.string()); + con::error("Please do not move test executable out of compilation folder"); return 1; } const auto expectedTestDir = expectedRootDir / "test"; if (!fs::is_directory(expectedTestDir)) { - std::cerr << std::format("Expected test directory to exist in {}, but it did not\n", expectedTestDir.string()); - std::cerr << "Please do not move test executable out of compilation folder\n"; + con::error("Expected test directory to exist in {}, but it did not", expectedTestDir.string()); + con::error("Please do not move test executable out of compilation folder"); return 1; } @@ -41,8 +57,16 @@ int main(const int argc, char* argv[]) const auto result = Catch::Session().run(argc, argv); const auto tempDir = expectedBuildDir / ".tmp"; - if (fs::is_directory(tempDir)) - fs::remove_all(tempDir); + if (ShouldClearTempFolder()) + { + con::info("Clearing tmp folder. Define env var OAT_KEEP_TMP_DIR=1 to keep it."); + if (fs::is_directory(tempDir)) + fs::remove_all(tempDir); + } + else + { + con::info("Kept tmp dir {} on disk.", tempDir.string()); + } return result; } diff --git a/test/SystemTests.lua b/test/SystemTests.lua new file mode 100644 index 00000000..991ce0e3 --- /dev/null +++ b/test/SystemTests.lua @@ -0,0 +1,64 @@ +SystemTests = {} + +function SystemTests:include(includes) + if includes:handle(self:name()) then + includedirs { + path.join(TestFolder(), "SystemTests") + } + end +end + +function SystemTests:link(links) + +end + +function SystemTests:use() + +end + +function SystemTests:name() + return "SystemTests" +end + +function SystemTests:project() + local folder = TestFolder() + local includes = Includes:create() + local links = Links:create() + + project(self:name()) + targetdir(TargetDirectoryTest) + location "%{wks.location}/test/%{prj.name}" + kind "ConsoleApp" + language "C++" + + files { + path.join(folder, "SystemTests/**.h"), + path.join(folder, "SystemTests/**.cpp") + } + + self:include(includes) + Catch2Common:include(includes) + Utils:include(includes) + ZoneLoading:include(includes) + ZoneWriting:include(includes) + ObjLoading:include(includes) + ObjCompiling:include(includes) + ObjWriting:include(includes) + Linking:include(includes) + Unlinking:include(includes) + catch2:include(includes) + + Raw:use() + + links:linkto(Utils) + links:linkto(ZoneLoading) + links:linkto(ZoneWriting) + links:linkto(ObjLoading) + links:linkto(ObjCompiling) + links:linkto(ObjWriting) + links:linkto(catch2) + links:linkto(Catch2Common) + links:linkto(Linking) + links:linkto(Unlinking) + links:linkall() +end diff --git a/test/SystemTests/Game/IW3/Simple/SimpleZone.txt b/test/SystemTests/Game/IW3/Simple/SimpleZone.txt new file mode 100644 index 00000000..aea46cd0 --- /dev/null +++ b/test/SystemTests/Game/IW3/Simple/SimpleZone.txt @@ -0,0 +1 @@ +This is a simple zone. diff --git a/test/SystemTests/Game/IW3/Simple/SimpleZoneIW3.zone b/test/SystemTests/Game/IW3/Simple/SimpleZoneIW3.zone new file mode 100644 index 00000000..0b645a8f --- /dev/null +++ b/test/SystemTests/Game/IW3/Simple/SimpleZoneIW3.zone @@ -0,0 +1,4 @@ +>game,IW3 + +rawfile,SimpleZone.txt + diff --git a/test/SystemTests/Game/IW3/SimpleZoneIW3.cpp b/test/SystemTests/Game/IW3/SimpleZoneIW3.cpp new file mode 100644 index 00000000..4092878a --- /dev/null +++ b/test/SystemTests/Game/IW3/SimpleZoneIW3.cpp @@ -0,0 +1,65 @@ +#include "Game/IW3/GameAssetPoolIW3.h" +#include "Linker.h" +#include "OatTestPaths.h" +#include "SystemTestsPaths.h" +#include "ZoneLoading.h" + +#include +#include +#include +#include +#include + +namespace fs = std::filesystem; +using namespace std::literals; + +namespace +{ + TEST_CASE("Simple Zone(IW3)", "[iw3][system][simple]") + { + const auto assetSearchPath = (oat::paths::GetSystemTestsDirectory() / "Game/IW3/Simple").string(); + const auto sourceSearchPath = (oat::paths::GetSystemTestsDirectory() / "Game/IW3/Simple").string(); + const auto outputPath = oat::paths::GetTempDirectory("SimpleZoneIW3").string(); + + const char* argStrings[]{ + "SystemTests", // bin + "--verbose", + "--asset-search-path", + assetSearchPath.c_str(), + "--source-search-path", + sourceSearchPath.c_str(), + "--output-folder", + outputPath.c_str(), + "SimpleZoneIW3", + }; + + LinkerArgs args; + + bool shouldContinue = true; + const auto couldParseArgs = args.ParseArgs(std::extent_v, argStrings, shouldContinue); + + REQUIRE(couldParseArgs); + REQUIRE(shouldContinue); + + const auto linker = Linker::Create(std::move(args)); + const auto linkerResult = linker->Start(); + + REQUIRE(linkerResult); + + // x64 for now produces invalid zones, don't try to load them yet +#ifdef ARCH_x86 + const auto expectedZonePath = (fs::path(outputPath) / "SimpleZoneIW3.ff").string(); + auto maybeZone = ZoneLoading::LoadZone(expectedZonePath, std::nullopt); + REQUIRE(maybeZone); + + auto zone = std::move(*maybeZone); + auto pools = dynamic_cast(zone->m_pools.get()); + + REQUIRE(zone->m_game_id == GameId::IW3); + REQUIRE(zone->m_platform == GamePlatform::PC); + REQUIRE(zone->m_name == "SimpleZoneIW3"); + REQUIRE(pools->GetTotalAssetCount() == 1); + REQUIRE(pools->m_raw_file->GetAsset("SimpleZone.txt")); +#endif + } +} // namespace diff --git a/test/SystemTests/Game/IW4/Simple/SimpleZone.txt b/test/SystemTests/Game/IW4/Simple/SimpleZone.txt new file mode 100644 index 00000000..aea46cd0 --- /dev/null +++ b/test/SystemTests/Game/IW4/Simple/SimpleZone.txt @@ -0,0 +1 @@ +This is a simple zone. diff --git a/test/SystemTests/Game/IW4/Simple/SimpleZoneIW4.zone b/test/SystemTests/Game/IW4/Simple/SimpleZoneIW4.zone new file mode 100644 index 00000000..bdb55ff4 --- /dev/null +++ b/test/SystemTests/Game/IW4/Simple/SimpleZoneIW4.zone @@ -0,0 +1,4 @@ +>game,IW4 + +rawfile,SimpleZone.txt + diff --git a/test/SystemTests/Game/IW4/SimpleZoneIW4.cpp b/test/SystemTests/Game/IW4/SimpleZoneIW4.cpp new file mode 100644 index 00000000..f89314a7 --- /dev/null +++ b/test/SystemTests/Game/IW4/SimpleZoneIW4.cpp @@ -0,0 +1,65 @@ +#include "Game/IW4/GameAssetPoolIW4.h" +#include "Linker.h" +#include "OatTestPaths.h" +#include "SystemTestsPaths.h" +#include "ZoneLoading.h" + +#include +#include +#include +#include +#include + +namespace fs = std::filesystem; +using namespace std::literals; + +namespace +{ + TEST_CASE("Simple Zone(IW4)", "[iw4][system][simple]") + { + const auto assetSearchPath = (oat::paths::GetSystemTestsDirectory() / "Game/IW4/Simple").string(); + const auto sourceSearchPath = (oat::paths::GetSystemTestsDirectory() / "Game/IW4/Simple").string(); + const auto outputPath = oat::paths::GetTempDirectory("SimpleZoneIW4").string(); + + const char* argStrings[]{ + "SystemTests", // bin + "--verbose", + "--asset-search-path", + assetSearchPath.c_str(), + "--source-search-path", + sourceSearchPath.c_str(), + "--output-folder", + outputPath.c_str(), + "SimpleZoneIW4", + }; + + LinkerArgs args; + + bool shouldContinue = true; + const auto couldParseArgs = args.ParseArgs(std::extent_v, argStrings, shouldContinue); + + REQUIRE(couldParseArgs); + REQUIRE(shouldContinue); + + const auto linker = Linker::Create(std::move(args)); + const auto linkerResult = linker->Start(); + + REQUIRE(linkerResult); + + // x64 for now produces invalid zones, don't try to load them yet +#ifdef ARCH_x86 + const auto expectedZonePath = (fs::path(outputPath) / "SimpleZoneIW4.ff").string(); + auto maybeZone = ZoneLoading::LoadZone(expectedZonePath, std::nullopt); + REQUIRE(maybeZone); + + auto zone = std::move(*maybeZone); + auto pools = dynamic_cast(zone->m_pools.get()); + + REQUIRE(zone->m_game_id == GameId::IW4); + REQUIRE(zone->m_platform == GamePlatform::PC); + REQUIRE(zone->m_name == "SimpleZoneIW4"); + REQUIRE(pools->GetTotalAssetCount() == 1); + REQUIRE(pools->m_raw_file->GetAsset("SimpleZone.txt")); +#endif + } +} // namespace diff --git a/test/SystemTests/Game/IW5/Simple/SimpleZone.txt b/test/SystemTests/Game/IW5/Simple/SimpleZone.txt new file mode 100644 index 00000000..aea46cd0 --- /dev/null +++ b/test/SystemTests/Game/IW5/Simple/SimpleZone.txt @@ -0,0 +1 @@ +This is a simple zone. diff --git a/test/SystemTests/Game/IW5/Simple/SimpleZoneIW5.zone b/test/SystemTests/Game/IW5/Simple/SimpleZoneIW5.zone new file mode 100644 index 00000000..0c35d8b6 --- /dev/null +++ b/test/SystemTests/Game/IW5/Simple/SimpleZoneIW5.zone @@ -0,0 +1,4 @@ +>game,IW5 + +rawfile,SimpleZone.txt + diff --git a/test/SystemTests/Game/IW5/SimpleZoneIW5.cpp b/test/SystemTests/Game/IW5/SimpleZoneIW5.cpp new file mode 100644 index 00000000..bd3c80d3 --- /dev/null +++ b/test/SystemTests/Game/IW5/SimpleZoneIW5.cpp @@ -0,0 +1,65 @@ +#include "Game/IW5/GameAssetPoolIW5.h" +#include "Linker.h" +#include "OatTestPaths.h" +#include "SystemTestsPaths.h" +#include "ZoneLoading.h" + +#include +#include +#include +#include +#include + +namespace fs = std::filesystem; +using namespace std::literals; + +namespace +{ + TEST_CASE("Simple Zone(IW5)", "[iw5][system][simple]") + { + const auto assetSearchPath = (oat::paths::GetSystemTestsDirectory() / "Game/IW5/Simple").string(); + const auto sourceSearchPath = (oat::paths::GetSystemTestsDirectory() / "Game/IW5/Simple").string(); + const auto outputPath = oat::paths::GetTempDirectory("SimpleZoneIW5").string(); + + const char* argStrings[]{ + "SystemTests", // bin + "--verbose", + "--asset-search-path", + assetSearchPath.c_str(), + "--source-search-path", + sourceSearchPath.c_str(), + "--output-folder", + outputPath.c_str(), + "SimpleZoneIW5", + }; + + LinkerArgs args; + + bool shouldContinue = true; + const auto couldParseArgs = args.ParseArgs(std::extent_v, argStrings, shouldContinue); + + REQUIRE(couldParseArgs); + REQUIRE(shouldContinue); + + const auto linker = Linker::Create(std::move(args)); + const auto linkerResult = linker->Start(); + + REQUIRE(linkerResult); + + // x64 for now produces invalid zones, don't try to load them yet +#ifdef ARCH_x86 + const auto expectedZonePath = (fs::path(outputPath) / "SimpleZoneIW5.ff").string(); + auto maybeZone = ZoneLoading::LoadZone(expectedZonePath, std::nullopt); + REQUIRE(maybeZone); + + auto zone = std::move(*maybeZone); + auto pools = dynamic_cast(zone->m_pools.get()); + + REQUIRE(zone->m_game_id == GameId::IW5); + REQUIRE(zone->m_platform == GamePlatform::PC); + REQUIRE(zone->m_name == "SimpleZoneIW5"); + REQUIRE(pools->GetTotalAssetCount() == 1); + REQUIRE(pools->m_raw_file->GetAsset("SimpleZone.txt")); +#endif + } +} // namespace diff --git a/test/SystemTests/Game/T5/Simple/SimpleZone.txt b/test/SystemTests/Game/T5/Simple/SimpleZone.txt new file mode 100644 index 00000000..aea46cd0 --- /dev/null +++ b/test/SystemTests/Game/T5/Simple/SimpleZone.txt @@ -0,0 +1 @@ +This is a simple zone. diff --git a/test/SystemTests/Game/T5/Simple/SimpleZoneT5.zone b/test/SystemTests/Game/T5/Simple/SimpleZoneT5.zone new file mode 100644 index 00000000..705620e7 --- /dev/null +++ b/test/SystemTests/Game/T5/Simple/SimpleZoneT5.zone @@ -0,0 +1,4 @@ +>game,T5 + +rawfile,SimpleZone.txt + diff --git a/test/SystemTests/Game/T5/SimpleZoneT5.cpp b/test/SystemTests/Game/T5/SimpleZoneT5.cpp new file mode 100644 index 00000000..7ba904b0 --- /dev/null +++ b/test/SystemTests/Game/T5/SimpleZoneT5.cpp @@ -0,0 +1,65 @@ +#include "Game/T5/GameAssetPoolT5.h" +#include "Linker.h" +#include "OatTestPaths.h" +#include "SystemTestsPaths.h" +#include "ZoneLoading.h" + +#include +#include +#include +#include +#include + +namespace fs = std::filesystem; +using namespace std::literals; + +namespace +{ + TEST_CASE("Simple Zone(T5)", "[t5][system][simple]") + { + const auto assetSearchPath = (oat::paths::GetSystemTestsDirectory() / "Game/T5/Simple").string(); + const auto sourceSearchPath = (oat::paths::GetSystemTestsDirectory() / "Game/T5/Simple").string(); + const auto outputPath = oat::paths::GetTempDirectory("SimpleZoneT5").string(); + + const char* argStrings[]{ + "SystemTests", // bin + "--verbose", + "--asset-search-path", + assetSearchPath.c_str(), + "--source-search-path", + sourceSearchPath.c_str(), + "--output-folder", + outputPath.c_str(), + "SimpleZoneT5", + }; + + LinkerArgs args; + + bool shouldContinue = true; + const auto couldParseArgs = args.ParseArgs(std::extent_v, argStrings, shouldContinue); + + REQUIRE(couldParseArgs); + REQUIRE(shouldContinue); + + const auto linker = Linker::Create(std::move(args)); + const auto linkerResult = linker->Start(); + + REQUIRE(linkerResult); + + // x64 for now produces invalid zones, don't try to load them yet +#ifdef ARCH_x86 + const auto expectedZonePath = (fs::path(outputPath) / "SimpleZoneT5.ff").string(); + auto maybeZone = ZoneLoading::LoadZone(expectedZonePath, std::nullopt); + REQUIRE(maybeZone); + + auto zone = std::move(*maybeZone); + auto pools = dynamic_cast(zone->m_pools.get()); + + REQUIRE(zone->m_game_id == GameId::T5); + REQUIRE(zone->m_platform == GamePlatform::PC); + REQUIRE(zone->m_name == "SimpleZoneT5"); + REQUIRE(pools->GetTotalAssetCount() == 1); + REQUIRE(pools->m_raw_file->GetAsset("SimpleZone.txt")); +#endif + } +} // namespace diff --git a/test/SystemTests/Game/T6/ExtendAndDereference/CombinedZoneT6.zone b/test/SystemTests/Game/T6/ExtendAndDereference/CombinedZoneT6.zone new file mode 100644 index 00000000..eb46c78d --- /dev/null +++ b/test/SystemTests/Game/T6/ExtendAndDereference/CombinedZoneT6.zone @@ -0,0 +1,4 @@ +>game,T6 + +techniqueset,trivial_floatz_2992w610 +material,test diff --git a/test/SystemTests/Game/T6/ExtendAndDereference/ZoneWithMaterialT6.zone b/test/SystemTests/Game/T6/ExtendAndDereference/ZoneWithMaterialT6.zone new file mode 100644 index 00000000..f29d47a8 --- /dev/null +++ b/test/SystemTests/Game/T6/ExtendAndDereference/ZoneWithMaterialT6.zone @@ -0,0 +1,4 @@ +>game,T6 + +ignore,ZoneWithTechsetT6 +material,test diff --git a/test/SystemTests/Game/T6/ExtendAndDereference/ZoneWithTechsetT6.ff b/test/SystemTests/Game/T6/ExtendAndDereference/ZoneWithTechsetT6.ff new file mode 100644 index 00000000..096666cc Binary files /dev/null and b/test/SystemTests/Game/T6/ExtendAndDereference/ZoneWithTechsetT6.ff differ diff --git a/test/SystemTests/Game/T6/ExtendAndDereference/ZoneWithTechsetT6.zone b/test/SystemTests/Game/T6/ExtendAndDereference/ZoneWithTechsetT6.zone new file mode 100644 index 00000000..dfd78e4e --- /dev/null +++ b/test/SystemTests/Game/T6/ExtendAndDereference/ZoneWithTechsetT6.zone @@ -0,0 +1,3 @@ +>game,T6 + +techniqueset,trivial_floatz_2992w610 diff --git a/test/SystemTests/Game/T6/ExtendAndDereference/materials/test.json b/test/SystemTests/Game/T6/ExtendAndDereference/materials/test.json new file mode 100644 index 00000000..4ec3e470 --- /dev/null +++ b/test/SystemTests/Game/T6/ExtendAndDereference/materials/test.json @@ -0,0 +1,77 @@ +{ + "$schema": "http://openassettools.dev/schema/material.v1.json", + "_game": "t6", + "_type": "material", + "_version": 1, + "cameraRegion": "none", + "constants": [], + "contents": 1, + "gameFlags": [], + "layeredSurfaceTypes": 536870912, + "sortKey": 4, + "stateBits": [ + { + "alphaTest": "disabled", + "blendOpAlpha": "disabled", + "blendOpRgb": "disabled", + "colorWriteAlpha": true, + "colorWriteRgb": true, + "cullFace": "back", + "depthTest": "disabled", + "depthWrite": false, + "dstBlendAlpha": "zero", + "dstBlendRgb": "zero", + "polygonOffset": "offset0", + "polymodeLine": false, + "srcBlendAlpha": "one", + "srcBlendRgb": "one" + } + ], + "stateBitsEntry": [ + -1, + -1, + 0, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1 + ], + "stateFlags": 0, + "surfaceFlags": 0, + "surfaceTypeBits": 0, + "techniqueSet": "trivial_floatz_2992w610", + "textureAtlas": { + "columns": 1, + "rows": 1 + }, + "textures": [] +} diff --git a/test/SystemTests/Game/T6/ExtendAndDereferenceT6.cpp b/test/SystemTests/Game/T6/ExtendAndDereferenceT6.cpp new file mode 100644 index 00000000..b83e2fa6 --- /dev/null +++ b/test/SystemTests/Game/T6/ExtendAndDereferenceT6.cpp @@ -0,0 +1,130 @@ +/* +This makes sure that when reusing assets from an existing zone, asset dependencies that are references can be overwritten to be non-references. + +In this case: + +- The zone `ZoneWithTechsetT6` contains the techniqueset `trivial_floatz_2992w610` +- The zone `ZoneWithMaterialT6` contains the material `test` and with a reference to its techniqueset `,trivial_floatz_2992w610` +- The final zone `CombinedZoneT6` is built while loading both of the other fastfile and is expected to contain both the material `test` with a reference to a +(actual asset, not a reference) techniqueset `trivial_floatz_2992w610` +*/ + +#include "Game/T6/GameAssetPoolT6.h" +#include "Linker.h" +#include "OatTestPaths.h" +#include "SystemTestsPaths.h" +#include "ZoneLoading.h" + +#include +#include +#include +#include +#include + +namespace fs = std::filesystem; +using namespace std::literals; + +namespace +{ + void BuildZoneWithMaterial(const fs::path& testDir, const fs::path& outputPath) + { + const auto testDirStr = testDir.string(); + const auto outputPathStr = outputPath.string(); + + const char* argStrings[]{ + "SystemTests", // bin + "--verbose", + "--asset-search-path", + testDirStr.c_str(), + "--source-search-path", + testDirStr.c_str(), + "--output-folder", + outputPathStr.c_str(), + "ZoneWithMaterialT6", + }; + + LinkerArgs args; + + bool shouldContinue = true; + const auto couldParseArgs = args.ParseArgs(std::extent_v, argStrings, shouldContinue); + + REQUIRE(couldParseArgs); + REQUIRE(shouldContinue); + + const auto linker = Linker::Create(std::move(args)); + const auto linkerResult = linker->Start(); + + REQUIRE(linkerResult); + } + + void BuildCombinedZone(const fs::path& testDir, const fs::path& outputPath) + { + const auto testDirStr = testDir.string(); + const auto outputPathStr = outputPath.string(); + + const auto zoneWithTechsetPathStr = (testDir / "ZoneWithTechsetT6.ff").string(); + const auto zoneWithMaterialPathStr = (outputPath / "ZoneWithMaterialT6.ff").string(); + + const char* argStrings[]{ + "SystemTests", // bin + "--verbose", + "--load", + zoneWithTechsetPathStr.c_str(), + "--load", + zoneWithMaterialPathStr.c_str(), + "--source-search-path", + testDirStr.c_str(), + "--output-folder", + outputPathStr.c_str(), + "CombinedZoneT6", + }; + + LinkerArgs args; + + bool shouldContinue = true; + const auto couldParseArgs = args.ParseArgs(std::extent_v, argStrings, shouldContinue); + + REQUIRE(couldParseArgs); + REQUIRE(shouldContinue); + + const auto linker = Linker::Create(std::move(args)); + const auto linkerResult = linker->Start(); + + REQUIRE(linkerResult); + } + + void CheckCombinedZoneContent(const fs::path& outputPath) + { + const auto expectedZonePath = (fs::path(outputPath) / "CombinedZoneT6.ff").string(); + auto maybeZone = ZoneLoading::LoadZone(expectedZonePath, std::nullopt); + REQUIRE(maybeZone); + + auto zone = std::move(*maybeZone); + auto pools = dynamic_cast(zone->m_pools.get()); + + REQUIRE(zone->m_game_id == GameId::T6); + REQUIRE(zone->m_platform == GamePlatform::PC); + REQUIRE(zone->m_name == "CombinedZoneT6"); + REQUIRE(pools->GetTotalAssetCount() == 2); + REQUIRE(pools->m_technique_set->GetAsset("trivial_floatz_2992w610")); + + const auto* material = pools->m_material->GetAsset("test"); + REQUIRE(material); + REQUIRE(material->Asset()->techniqueSet); + REQUIRE(material->Asset()->techniqueSet->name == "trivial_floatz_2992w610"s); + REQUIRE(material->Asset()->techniqueSet->techniques[T6::TECHNIQUE_UNLIT]); + } + + // x64 for now produces invalid zones, don't try to load them yet +#ifdef ARCH_x86 + TEST_CASE("Extend and dereference(T6)", "[t6][system][simple]") + { + const auto testDir = oat::paths::GetSystemTestsDirectory() / "Game/T6/ExtendAndDereference"; + const auto outputPath = oat::paths::GetTempDirectory("ExtendAndDereferenceT6"); + + BuildZoneWithMaterial(testDir, outputPath); + BuildCombinedZone(testDir, outputPath); + CheckCombinedZoneContent(outputPath); + } +#endif +} // namespace diff --git a/test/SystemTests/Game/T6/ReuseGlobalAssetPoolsAssets/BaseZone.zone b/test/SystemTests/Game/T6/ReuseGlobalAssetPoolsAssets/BaseZone.zone new file mode 100644 index 00000000..0624bcd4 --- /dev/null +++ b/test/SystemTests/Game/T6/ReuseGlobalAssetPoolsAssets/BaseZone.zone @@ -0,0 +1,6 @@ +>game,T6 + +material,,Suzanne +material,,Suzanne2 +xmodel,Suzanne1 +xmodel,Suzanne2 diff --git a/test/SystemTests/Game/T6/ReuseGlobalAssetPoolsAssets/BaseZone/model_export/Suzanne1.gltf b/test/SystemTests/Game/T6/ReuseGlobalAssetPoolsAssets/BaseZone/model_export/Suzanne1.gltf new file mode 100644 index 00000000..498bf129 --- /dev/null +++ b/test/SystemTests/Game/T6/ReuseGlobalAssetPoolsAssets/BaseZone/model_export/Suzanne1.gltf @@ -0,0 +1,181 @@ +{ + "asset": { + "generator": "Khronos glTF Blender I/O v5.0.21", + "version": "2.0" + }, + "scene": 0, + "scenes": [ + { + "name": "Scene", + "nodes": [4] + } + ], + "nodes": [ + { + "name": "EarLeft", + "rotation": [ + 1.5454309831852697e-8, 1.5454309831852697e-8, -0.7071067690849304, + 0.7071067690849304 + ], + "scale": [1, 0.9999999403953552, 1], + "translation": [0, 23.455289840698242, 0] + }, + { + "name": "EarRight", + "rotation": [ + 1.5454309831852697e-8, -1.5454313384566376e-8, 0.7071067690849304, + 0.7071067690849304 + ], + "translation": [0, 23.455289840698242, 0] + }, + { + "children": [0, 1], + "name": "Root", + "rotation": [-2.980232594040899e-8, 0, 0, 1], + "scale": [1, 0.9999999403953552, 0.9999999403953552] + }, + { + "mesh": 0, + "name": "Suzanne", + "skin": 0 + }, + { + "children": [3, 2], + "name": "Armature", + "translation": [0, -23.480762481689453, 0] + } + ], + "materials": [ + { + "doubleSided": true, + "name": "Suzanne", + "pbrMetallicRoughness": { + "baseColorFactor": [ + 0.800000011920929, 0.800000011920929, 0.800000011920929, 1 + ], + "metallicFactor": 0, + "roughnessFactor": 0.5 + } + } + ], + "meshes": [ + { + "name": "Suzanne", + "primitives": [ + { + "attributes": { + "POSITION": 0, + "NORMAL": 1, + "TEXCOORD_0": 2, + "JOINTS_0": 3, + "WEIGHTS_0": 4 + }, + "indices": 5, + "material": 0 + } + ] + } + ], + "skins": [ + { + "inverseBindMatrices": 6, + "joints": [2, 0, 1], + "name": "Armature" + } + ], + "accessors": [ + { + "bufferView": 0, + "componentType": 5126, + "count": 2865, + "max": [34.1796875, 24.609375, 21.2890625], + "min": [-34.1796875, -24.609375, -21.2890625], + "type": "VEC3" + }, + { + "bufferView": 1, + "componentType": 5126, + "count": 2865, + "type": "VEC3" + }, + { + "bufferView": 2, + "componentType": 5126, + "count": 2865, + "type": "VEC2" + }, + { + "bufferView": 3, + "componentType": 5121, + "count": 2865, + "type": "VEC4" + }, + { + "bufferView": 4, + "componentType": 5126, + "count": 2865, + "type": "VEC4" + }, + { + "bufferView": 5, + "componentType": 5123, + "count": 2901, + "type": "SCALAR" + }, + { + "bufferView": 6, + "componentType": 5126, + "count": 3, + "type": "MAT4" + } + ], + "bufferViews": [ + { + "buffer": 0, + "byteLength": 34380, + "byteOffset": 0, + "target": 34962 + }, + { + "buffer": 0, + "byteLength": 34380, + "byteOffset": 34380, + "target": 34962 + }, + { + "buffer": 0, + "byteLength": 22920, + "byteOffset": 68760, + "target": 34962 + }, + { + "buffer": 0, + "byteLength": 11460, + "byteOffset": 91680, + "target": 34962 + }, + { + "buffer": 0, + "byteLength": 45840, + "byteOffset": 103140, + "target": 34962 + }, + { + "buffer": 0, + "byteLength": 5802, + "byteOffset": 148980, + "target": 34963 + }, + { + "buffer": 0, + "byteLength": 192, + "byteOffset": 154784 + } + ], + "buffers": [ + { + "byteLength": 154976, + "uri": "data:application/octet-stream;base64,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" + } + ] +} diff --git a/test/SystemTests/Game/T6/ReuseGlobalAssetPoolsAssets/BaseZone/model_export/Suzanne2.gltf b/test/SystemTests/Game/T6/ReuseGlobalAssetPoolsAssets/BaseZone/model_export/Suzanne2.gltf new file mode 100644 index 00000000..747773d3 --- /dev/null +++ b/test/SystemTests/Game/T6/ReuseGlobalAssetPoolsAssets/BaseZone/model_export/Suzanne2.gltf @@ -0,0 +1,181 @@ +{ + "asset": { + "generator": "Khronos glTF Blender I/O v5.0.21", + "version": "2.0" + }, + "scene": 0, + "scenes": [ + { + "name": "Scene", + "nodes": [4] + } + ], + "nodes": [ + { + "name": "EarLeft2", + "rotation": [ + 1.5454309831852697e-8, 1.5454309831852697e-8, -0.7071067690849304, + 0.7071067690849304 + ], + "scale": [1, 0.9999999403953552, 1], + "translation": [0, 23.455289840698242, 0] + }, + { + "name": "EarRight2", + "rotation": [ + 1.5454309831852697e-8, -1.5454313384566376e-8, 0.7071067690849304, + 0.7071067690849304 + ], + "translation": [0, 23.455289840698242, 0] + }, + { + "children": [0, 1], + "name": "Root2", + "rotation": [-2.980232594040899e-8, 0, 0, 1], + "scale": [1, 0.9999999403953552, 0.9999999403953552] + }, + { + "mesh": 0, + "name": "Suzanne", + "skin": 0 + }, + { + "children": [3, 2], + "name": "Armature", + "translation": [0, -23.480762481689453, 0] + } + ], + "materials": [ + { + "doubleSided": true, + "name": "Suzanne2", + "pbrMetallicRoughness": { + "baseColorFactor": [ + 0.800000011920929, 0.800000011920929, 0.800000011920929, 1 + ], + "metallicFactor": 0, + "roughnessFactor": 0.5 + } + } + ], + "meshes": [ + { + "name": "Suzanne", + "primitives": [ + { + "attributes": { + "POSITION": 0, + "NORMAL": 1, + "TEXCOORD_0": 2, + "JOINTS_0": 3, + "WEIGHTS_0": 4 + }, + "indices": 5, + "material": 0 + } + ] + } + ], + "skins": [ + { + "inverseBindMatrices": 6, + "joints": [2, 0, 1], + "name": "Armature" + } + ], + "accessors": [ + { + "bufferView": 0, + "componentType": 5126, + "count": 2865, + "max": [34.1796875, 24.609375, 21.2890625], + "min": [-34.1796875, -24.609375, -21.2890625], + "type": "VEC3" + }, + { + "bufferView": 1, + "componentType": 5126, + "count": 2865, + "type": "VEC3" + }, + { + "bufferView": 2, + "componentType": 5126, + "count": 2865, + "type": "VEC2" + }, + { + "bufferView": 3, + "componentType": 5121, + "count": 2865, + "type": "VEC4" + }, + { + "bufferView": 4, + "componentType": 5126, + "count": 2865, + "type": "VEC4" + }, + { + "bufferView": 5, + "componentType": 5123, + "count": 2901, + "type": "SCALAR" + }, + { + "bufferView": 6, + "componentType": 5126, + "count": 3, + "type": "MAT4" + } + ], + "bufferViews": [ + { + "buffer": 0, + "byteLength": 34380, + "byteOffset": 0, + "target": 34962 + }, + { + "buffer": 0, + "byteLength": 34380, + "byteOffset": 34380, + "target": 34962 + }, + { + "buffer": 0, + "byteLength": 22920, + "byteOffset": 68760, + "target": 34962 + }, + { + "buffer": 0, + "byteLength": 11460, + "byteOffset": 91680, + "target": 34962 + }, + { + "buffer": 0, + "byteLength": 45840, + "byteOffset": 103140, + "target": 34962 + }, + { + "buffer": 0, + "byteLength": 5802, + "byteOffset": 148980, + "target": 34963 + }, + { + "buffer": 0, + "byteLength": 192, + "byteOffset": 154784 + } + ], + "buffers": [ + { + "byteLength": 154976, + "uri": "data:application/octet-stream;base64,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" + } + ] +} diff --git a/test/SystemTests/Game/T6/ReuseGlobalAssetPoolsAssets/BaseZone/xmodel/Suzanne1.json b/test/SystemTests/Game/T6/ReuseGlobalAssetPoolsAssets/BaseZone/xmodel/Suzanne1.json new file mode 100644 index 00000000..1c86b85a --- /dev/null +++ b/test/SystemTests/Game/T6/ReuseGlobalAssetPoolsAssets/BaseZone/xmodel/Suzanne1.json @@ -0,0 +1,20 @@ +{ + "$schema": "http://openassettools.dev/schema/xmodel.v1.json", + "_game": "t6", + "_type": "xmodel", + "_version": 2, + "flags": 2621440, + "lightingOriginOffset": { + "x": 0.0, + "y": 0.0, + "z": 0.5 + }, + "lightingOriginRange": 0.5, + "lods": [ + { + "distance": 11447.6904296875, + "file": "model_export/Suzanne1.gltf" + } + ], + "type": "rigid" +} diff --git a/test/SystemTests/Game/T6/ReuseGlobalAssetPoolsAssets/BaseZone/xmodel/Suzanne2.json b/test/SystemTests/Game/T6/ReuseGlobalAssetPoolsAssets/BaseZone/xmodel/Suzanne2.json new file mode 100644 index 00000000..9e46a2da --- /dev/null +++ b/test/SystemTests/Game/T6/ReuseGlobalAssetPoolsAssets/BaseZone/xmodel/Suzanne2.json @@ -0,0 +1,20 @@ +{ + "$schema": "http://openassettools.dev/schema/xmodel.v1.json", + "_game": "t6", + "_type": "xmodel", + "_version": 2, + "flags": 2621440, + "lightingOriginOffset": { + "x": 0.0, + "y": 0.0, + "z": 0.5 + }, + "lightingOriginRange": 0.5, + "lods": [ + { + "distance": 11447.6904296875, + "file": "model_export/Suzanne2.gltf" + } + ], + "type": "rigid" +} diff --git a/test/SystemTests/Game/T6/ReuseGlobalAssetPoolsAssets/TestZone.zone b/test/SystemTests/Game/T6/ReuseGlobalAssetPoolsAssets/TestZone.zone new file mode 100644 index 00000000..6f4f3ccd --- /dev/null +++ b/test/SystemTests/Game/T6/ReuseGlobalAssetPoolsAssets/TestZone.zone @@ -0,0 +1,4 @@ +>game,T6 + +ignore,Ignored +xmodel,Suzanne2 diff --git a/test/SystemTests/Game/T6/ReuseGlobalAssetPoolsAssets/TestZone/materials/Suzanne.json b/test/SystemTests/Game/T6/ReuseGlobalAssetPoolsAssets/TestZone/materials/Suzanne.json new file mode 100644 index 00000000..4ec3e470 --- /dev/null +++ b/test/SystemTests/Game/T6/ReuseGlobalAssetPoolsAssets/TestZone/materials/Suzanne.json @@ -0,0 +1,77 @@ +{ + "$schema": "http://openassettools.dev/schema/material.v1.json", + "_game": "t6", + "_type": "material", + "_version": 1, + "cameraRegion": "none", + "constants": [], + "contents": 1, + "gameFlags": [], + "layeredSurfaceTypes": 536870912, + "sortKey": 4, + "stateBits": [ + { + "alphaTest": "disabled", + "blendOpAlpha": "disabled", + "blendOpRgb": "disabled", + "colorWriteAlpha": true, + "colorWriteRgb": true, + "cullFace": "back", + "depthTest": "disabled", + "depthWrite": false, + "dstBlendAlpha": "zero", + "dstBlendRgb": "zero", + "polygonOffset": "offset0", + "polymodeLine": false, + "srcBlendAlpha": "one", + "srcBlendRgb": "one" + } + ], + "stateBitsEntry": [ + -1, + -1, + 0, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1 + ], + "stateFlags": 0, + "surfaceFlags": 0, + "surfaceTypeBits": 0, + "techniqueSet": "trivial_floatz_2992w610", + "textureAtlas": { + "columns": 1, + "rows": 1 + }, + "textures": [] +} diff --git a/test/SystemTests/Game/T6/ReuseGlobalAssetPoolsAssets/TestZone/materials/Suzanne2.json b/test/SystemTests/Game/T6/ReuseGlobalAssetPoolsAssets/TestZone/materials/Suzanne2.json new file mode 100644 index 00000000..4ec3e470 --- /dev/null +++ b/test/SystemTests/Game/T6/ReuseGlobalAssetPoolsAssets/TestZone/materials/Suzanne2.json @@ -0,0 +1,77 @@ +{ + "$schema": "http://openassettools.dev/schema/material.v1.json", + "_game": "t6", + "_type": "material", + "_version": 1, + "cameraRegion": "none", + "constants": [], + "contents": 1, + "gameFlags": [], + "layeredSurfaceTypes": 536870912, + "sortKey": 4, + "stateBits": [ + { + "alphaTest": "disabled", + "blendOpAlpha": "disabled", + "blendOpRgb": "disabled", + "colorWriteAlpha": true, + "colorWriteRgb": true, + "cullFace": "back", + "depthTest": "disabled", + "depthWrite": false, + "dstBlendAlpha": "zero", + "dstBlendRgb": "zero", + "polygonOffset": "offset0", + "polymodeLine": false, + "srcBlendAlpha": "one", + "srcBlendRgb": "one" + } + ], + "stateBitsEntry": [ + -1, + -1, + 0, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1 + ], + "stateFlags": 0, + "surfaceFlags": 0, + "surfaceTypeBits": 0, + "techniqueSet": "trivial_floatz_2992w610", + "textureAtlas": { + "columns": 1, + "rows": 1 + }, + "textures": [] +} diff --git a/test/SystemTests/Game/T6/ReuseGlobalAssetPoolsAssets/assetlist/Ignored.csv b/test/SystemTests/Game/T6/ReuseGlobalAssetPoolsAssets/assetlist/Ignored.csv new file mode 100644 index 00000000..1959e026 --- /dev/null +++ b/test/SystemTests/Game/T6/ReuseGlobalAssetPoolsAssets/assetlist/Ignored.csv @@ -0,0 +1 @@ +techniqueset,trivial_floatz_2992w610 diff --git a/test/SystemTests/Game/T6/ReuseGlobalAssetPoolsAssetsT6.cpp b/test/SystemTests/Game/T6/ReuseGlobalAssetPoolsAssetsT6.cpp new file mode 100644 index 00000000..eb553278 --- /dev/null +++ b/test/SystemTests/Game/T6/ReuseGlobalAssetPoolsAssetsT6.cpp @@ -0,0 +1,137 @@ +/* +This makes sure that when reusing assets from an existing zone, asset dependencies that are references can be overwritten to be non-references. + +In this case: + +- The zone `ZoneWithTechsetT6` contains the techniqueset `trivial_floatz_2992w610` +- The zone `ZoneWithMaterialT6` contains the material `test` and with a reference to its techniqueset `,trivial_floatz_2992w610` +- The final zone `CombinedZoneT6` is built while loading both of the other fastfile and is expected to contain both the material `test` with a reference to a +(actual asset, not a reference) techniqueset `trivial_floatz_2992w610` +*/ + +#include "Game/T6/GameAssetPoolT6.h" +#include "Linker.h" +#include "OatTestPaths.h" +#include "SystemTestsPaths.h" +#include "Unlinker.h" +#include "ZoneLoading.h" + +#include +#include +#include +#include +#include + +namespace fs = std::filesystem; +using namespace std::literals; + +namespace +{ + void BuildBaseZone(const fs::path& testDir, const fs::path& outputPath) + { + const auto testDirStr = testDir.string(); + const auto assetDirStr = (testDir / "BaseZone").string(); + const auto outputPathStr = outputPath.string(); + + const char* argStrings[]{ + "SystemTests", // bin + "--verbose", + "--add-asset-search-path", + assetDirStr.c_str(), + "--source-search-path", + testDirStr.c_str(), + "--output-folder", + outputPathStr.c_str(), + "BaseZone", + }; + + LinkerArgs args; + + bool shouldContinue = true; + const auto couldParseArgs = args.ParseArgs(std::extent_v, argStrings, shouldContinue); + + REQUIRE(couldParseArgs); + REQUIRE(shouldContinue); + + const auto linker = Linker::Create(std::move(args)); + const auto linkerResult = linker->Start(); + + REQUIRE(linkerResult); + } + + void BuildTestZone(const fs::path& testDir, const fs::path& outputPath) + { + const auto testDirStr = testDir.string(); + const auto assetDirStr = (testDir / "TestZone").string(); + const auto outputPathStr = outputPath.string(); + + const auto baseZonePathStr = (outputPath / "BaseZone.ff").string(); + + const char* argStrings[]{ + "SystemTests", // bin + "--verbose", + "--load", + baseZonePathStr.c_str(), + "--add-asset-search-path", + assetDirStr.c_str(), + "--source-search-path", + testDirStr.c_str(), + "--output-folder", + outputPathStr.c_str(), + "TestZone", + "TestZone", // build twice to ensure the second build uses a global asset that the first build already used + }; + + LinkerArgs args; + + bool shouldContinue = true; + const auto couldParseArgs = args.ParseArgs(std::extent_v, argStrings, shouldContinue); + + REQUIRE(couldParseArgs); + REQUIRE(shouldContinue); + + const auto linker = Linker::Create(std::move(args)); + const auto linkerResult = linker->Start(); + + REQUIRE(linkerResult); + } + + void CheckTestZoneContent(const fs::path& outputPath) + { + const auto expectedZonePathStr = (outputPath / "TestZone.ff").string(); + auto maybeZone = ZoneLoading::LoadZone(expectedZonePathStr, std::nullopt); + REQUIRE(maybeZone); + + auto zone = std::move(*maybeZone); + auto pools = dynamic_cast(zone->m_pools.get()); + + REQUIRE(zone->m_game_id == GameId::T6); + REQUIRE(zone->m_platform == GamePlatform::PC); + REQUIRE(zone->m_name == "TestZone"); + REQUIRE(pools->GetTotalAssetCount() == 3); + REQUIRE(pools->m_material->GetAsset("Suzanne2")); + REQUIRE(pools->m_technique_set->GetAsset(",trivial_floatz_2992w610")); + + const auto* xmodel = pools->m_xmodel->GetAsset("Suzanne2"); + REQUIRE(xmodel); + REQUIRE(xmodel->Asset()->boneNames); + REQUIRE(xmodel->Asset()->numRootBones == 1); + REQUIRE(xmodel->Asset()->numBones == 3); + REQUIRE(zone->m_script_strings.Value(xmodel->Asset()->boneNames[0]) == "Root2"); + REQUIRE(zone->m_script_strings.Value(xmodel->Asset()->boneNames[1]) == "EarLeft2"); + REQUIRE(zone->m_script_strings.Value(xmodel->Asset()->boneNames[2]) == "EarRight2"); + } + + // x64 for now produces invalid zones, don't try to load them yet +#ifdef ARCH_x86 + TEST_CASE("Reuse assets from global asset pool(T6)", "[t6][system][simple]") + { + const auto testDir = oat::paths::GetSystemTestsDirectory() / "Game/T6/ReuseGlobalAssetPoolsAssets"; + const auto outputPath = oat::paths::GetTempDirectory("ReuseGlobalAssetPoolsAssetsT6"); + + BuildBaseZone(testDir, outputPath); + BuildTestZone(testDir, outputPath); + CheckTestZoneContent(outputPath); + } +#endif +} // namespace diff --git a/test/SystemTests/Game/T6/Simple/SimpleZone.txt b/test/SystemTests/Game/T6/Simple/SimpleZone.txt new file mode 100644 index 00000000..aea46cd0 --- /dev/null +++ b/test/SystemTests/Game/T6/Simple/SimpleZone.txt @@ -0,0 +1 @@ +This is a simple zone. diff --git a/test/SystemTests/Game/T6/Simple/SimpleZoneT6.zone b/test/SystemTests/Game/T6/Simple/SimpleZoneT6.zone new file mode 100644 index 00000000..1c075965 --- /dev/null +++ b/test/SystemTests/Game/T6/Simple/SimpleZoneT6.zone @@ -0,0 +1,4 @@ +>game,T6 + +rawfile,SimpleZone.txt + diff --git a/test/SystemTests/Game/T6/SimpleZoneT6.cpp b/test/SystemTests/Game/T6/SimpleZoneT6.cpp new file mode 100644 index 00000000..e2eae4c9 --- /dev/null +++ b/test/SystemTests/Game/T6/SimpleZoneT6.cpp @@ -0,0 +1,65 @@ +#include "Game/T6/GameAssetPoolT6.h" +#include "Linker.h" +#include "OatTestPaths.h" +#include "SystemTestsPaths.h" +#include "ZoneLoading.h" + +#include +#include +#include +#include +#include + +namespace fs = std::filesystem; +using namespace std::literals; + +namespace +{ + TEST_CASE("Simple Zone(T6)", "[t6][system][simple]") + { + const auto assetSearchPath = (oat::paths::GetSystemTestsDirectory() / "Game/T6/Simple").string(); + const auto sourceSearchPath = (oat::paths::GetSystemTestsDirectory() / "Game/T6/Simple").string(); + const auto outputPath = oat::paths::GetTempDirectory("SimpleZoneT6").string(); + + const char* argStrings[]{ + "SystemTests", // bin + "--verbose", + "--asset-search-path", + assetSearchPath.c_str(), + "--source-search-path", + sourceSearchPath.c_str(), + "--output-folder", + outputPath.c_str(), + "SimpleZoneT6", + }; + + LinkerArgs args; + + bool shouldContinue = true; + const auto couldParseArgs = args.ParseArgs(std::extent_v, argStrings, shouldContinue); + + REQUIRE(couldParseArgs); + REQUIRE(shouldContinue); + + const auto linker = Linker::Create(std::move(args)); + const auto linkerResult = linker->Start(); + + REQUIRE(linkerResult); + + // x64 for now produces invalid zones, don't try to load them yet +#ifdef ARCH_x86 + const auto expectedZonePath = (fs::path(outputPath) / "SimpleZoneT6.ff").string(); + auto maybeZone = ZoneLoading::LoadZone(expectedZonePath, std::nullopt); + REQUIRE(maybeZone); + + auto zone = std::move(*maybeZone); + auto pools = dynamic_cast(zone->m_pools.get()); + + REQUIRE(zone->m_game_id == GameId::T6); + REQUIRE(zone->m_platform == GamePlatform::PC); + REQUIRE(zone->m_name == "SimpleZoneT6"); + REQUIRE(pools->GetTotalAssetCount() == 1); + REQUIRE(pools->m_raw_file->GetAsset("SimpleZone.txt")); +#endif + } +} // namespace diff --git a/test/SystemTests/SystemTestsPaths.cpp b/test/SystemTests/SystemTestsPaths.cpp new file mode 100644 index 00000000..9267e46d --- /dev/null +++ b/test/SystemTests/SystemTestsPaths.cpp @@ -0,0 +1,15 @@ +#include "SystemTestsPaths.h" + +#include "OatTestPaths.h" + +#include + +namespace fs = std::filesystem; + +namespace oat::paths +{ + std::filesystem::path GetSystemTestsDirectory() + { + return GetTestDirectory() / "SystemTests"; + } +} // namespace oat::paths diff --git a/test/SystemTests/SystemTestsPaths.h b/test/SystemTests/SystemTestsPaths.h new file mode 100644 index 00000000..70073caf --- /dev/null +++ b/test/SystemTests/SystemTestsPaths.h @@ -0,0 +1,8 @@ +#pragma once + +#include + +namespace oat::paths +{ + std::filesystem::path GetSystemTestsDirectory(); +} // namespace oat::paths