Added Font Import/Export feature

Launcher/CMakeLists.txt

@@ -1,6 +1,6 @@
 set(WIN32_EXECUTABLE TRUE)
 
-add_executable (AssetBundleExtractor WIN32 "AssetBundleExtractor.cpp" AssetBundleExtractor.manifest Launcher.rc "resource.h")
+add_executable (AssetBundleExtractor WIN32 "AssetBundleExtractor.cpp" Launcher.rc "resource.h")
 
 target_link_libraries (AssetBundleExtractor LINK_PUBLIC UABE_Win32)
 

ModInstaller/CMakeLists.txt

@@ -1,4 +1,4 @@
-add_library (ModInstaller SHARED dllmain.cpp InstallDialog.cpp InstallerDataFormat.cpp MakeIconResource.cpp MakeInstaller.cpp ModInstaller.cpp stdafx.cpp ../UABE_Win32/FileDialog.cpp Dialogs.rc ModInstaller.manifest)
+add_library (ModInstaller SHARED dllmain.cpp InstallDialog.cpp InstallerDataFormat.cpp MakeIconResource.cpp MakeInstaller.cpp ModInstaller.cpp stdafx.cpp ../UABE_Win32/FileDialog.cpp Dialogs.rc )
 target_include_directories (ModInstaller PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
 
 target_compile_definitions(ModInstaller PRIVATE MODINSTALLER_EXPORTS)

Plugins/CMakeLists.txt

@@ -2,4 +2,5 @@ add_subdirectory (Utility)
 add_subdirectory (TextAsset)
 add_subdirectory (AudioClip)
 add_subdirectory (Texture)
+add_subdirectory (Font)
 add_subdirectory (Mesh)

Plugins/Font/CMakeLists.txt

@@ -0,0 +1,7 @@
+add_library (Font SHARED "Font.cpp" Font.def)
+target_include_directories (Font PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+
+set_target_properties(Font PROPERTIES
+	RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin/Plugins"
+	SUFFIX ".bep")
+target_link_libraries(Font PUBLIC UABE_Generic AssetsTools libStringConverter)

Plugins/Font/Font.cpp

@@ -0,0 +1,338 @@
+#include "../UABE_Generic/PluginManager.h"
+#include "../UABE_Generic/FileContextInfo.h"
+#include "../UABE_Generic/AppContext.h"
+#include <unordered_map>
+#include <assert.h>
+
+
+static bool SupportsElements(std::vector<AssetUtilDesc>& elements)
+{
+	std::unordered_map<AssetsFileContextInfo*, int32_t> textClassIDs;
+	for (size_t i = 0; i < elements.size(); i++)
+	{
+		if (elements[i].asset.pFile == nullptr)
+			return false;
+		AssetsFileContextInfo* pFile = elements[i].asset.pFile.get();
+		auto classIDsit = textClassIDs.find(pFile);
+		int32_t FontClassID = -1;
+		if (classIDsit == textClassIDs.end())
+		{
+			FontClassID = pFile->GetClassByName("Font");
+			textClassIDs[pFile] = FontClassID;
+		}
+		else
+			FontClassID = classIDsit->second;
+		if (FontClassID == -1)
+			return false;
+		int32_t classId = elements[i].asset.getClassID();
+		if (classId != FontClassID)
+			return false;
+	}
+	return true;
+}
+
+static bool isOtf(AssetTypeByteArray* data1){
+    auto data = data1->data;
+    return data[0] == 0x4f && data[1] == 0x54 && data[2] == 0x54 && data[3] == 0x4f;
+}
+
+static void FreeByteBufCallback(void* buffer)
+{
+    if (buffer)
+        delete[](uint8_t*)buffer;
+}
+
+class FontImportTask : public AssetImportTask
+{
+	AppContext& appContext;
+	TypeTemplateCache templateCache;
+public:
+	FontImportTask(AppContext& appContext,
+		std::vector<AssetUtilDesc> _assets, std::vector<std::string> _importFilePaths,
+		bool stopOnError = false)
+
+		: AssetImportTask(std::move(_assets), std::move(_importFilePaths), "Import Font", stopOnError),
+		  appContext(appContext)
+	{}
+
+	bool importAsset(AssetUtilDesc& desc, std::string path, std::optional<std::reference_wrapper<TaskProgressManager>> progressManager)
+	{
+		if (desc.asset.pFile == nullptr)
+			throw AssetUtilError("Unable to find the target .assets file.");
+
+		IAssetsReader_ptr pAssetReader = desc.asset.makeReader();
+		if (pAssetReader == nullptr)
+			throw AssetUtilError("Unable to read the asset.");
+		QWORD assetSize = 0;
+		if (!pAssetReader->Seek(AssetsSeek_End, 0) || !pAssetReader->Tell(assetSize) || !pAssetReader->Seek(AssetsSeek_Begin, 0))
+			throw AssetUtilError("Unable to read the asset.");
+
+        AssetTypeTemplateField& templateBase = templateCache.getTemplateField(appContext, desc.asset,
+          [](AssetTypeTemplateField& templateBase) {
+              for (uint32_t i = 0; i < templateBase.children.size(); i++)
+              {
+                  if (templateBase.children[i].name == "m_FontData")
+                  {
+                      templateBase.children[i].valueType = ValueType_None;
+                      for (uint32_t k = 0; k < templateBase.children[i].children.size(); k++)
+                      {
+                          if (templateBase.children[i].children[k].name == "Array")
+                          {
+                              templateBase.children[i].children[k].type = "TypelessData";
+                              break;
+                          }
+                      }
+                      break;
+                  }
+              }
+          }
+        );
+
+        AssetTypeTemplateField* pTemplateBase = &templateBase;
+
+        AssetTypeInstance assetInstance(1, &pTemplateBase, assetSize, pAssetReader.get(), desc.asset.isBigEndian());
+        AssetTypeValueField* pBaseField = assetInstance.GetBaseField();
+        if (pBaseField == nullptr || pBaseField->IsDummy())
+            throw AssetUtilError("Unable to deserialize the asset.");
+
+        AssetTypeValueField* dataArrayField = pBaseField->Get("m_FontData")->Get(0U);
+        if (dataArrayField->GetValue() == nullptr)
+            throw AssetUtilError("Empty data");
+
+        if(dataArrayField->GetValue()->GetType() != ValueType_ByteArray) {
+            throw AssetUtilError("Unexpected Font format.");
+        }
+
+        AssetTypeByteArray* bytes = dataArrayField->GetValue()->AsByteArray();
+
+        std::unique_ptr<IAssetsReader> pReader(Create_AssetsReaderFromFile(path.c_str(), true, RWOpenFlags_Immediately));
+        if (pReader == nullptr)
+            throw AssetUtilError("Unable to read the file.");
+
+        QWORD size = 0;
+        if (!pReader->Seek(AssetsSeek_End, 0) || !pReader->Tell(size) || !pReader->Seek(AssetsSeek_Begin, 0))
+            throw AssetUtilError("Unable to read the file.");
+
+        if (size >= INT32_MAX)
+            throw AssetUtilError("The file is too large (should be below 2 GiB).");
+
+        std::unique_ptr<uint8_t[]> buf(new uint8_t[(size_t)size]);
+
+        if (pReader->Read(size, buf.get()) != size)
+            throw AssetUtilError("Unable to read the file.");
+
+        AssetTypeByteArray byteArrayValue = {};
+        byteArrayValue.data = buf.get();
+        byteArrayValue.size = (uint32_t)size;
+        dataArrayField->GetValue()->Set(&byteArrayValue);
+
+        QWORD outSize = pBaseField->GetByteSize(0);
+        if (outSize >= SIZE_MAX)
+            throw AssetUtilError("Import size out of range.");
+
+        std::unique_ptr<uint8_t[]> newDataBuf(new uint8_t[outSize]);
+        std::unique_ptr<IAssetsWriter> pTempWriter(Create_AssetsWriterToMemory(newDataBuf.get(), outSize));
+        if (pTempWriter == nullptr)
+            throw AssetUtilError("Unexpected runtime error.");
+
+        QWORD newByteSize = pBaseField->Write(pTempWriter.get(), 0, desc.asset.isBigEndian());
+
+        std::shared_ptr<AssetsEntryReplacer> pReplacer(MakeAssetModifierFromMemory(0, desc.asset.pathID,
+                                                                                   desc.asset.getClassID(), desc.asset.getMonoScriptID(),
+                                                                                   newDataBuf.release(), (size_t)newByteSize, FreeByteBufCallback));
+        if (pReplacer == nullptr)
+            throw AssetUtilError("Unexpected runtime error.");
+
+        desc.asset.pFile->addReplacer(pReplacer, appContext);
+
+		return true;
+	}
+};
+class FontImportProvider : public IAssetOptionProviderGeneric
+{
+public:
+	class Runner : public IOptionRunner
+	{
+		AppContext& appContext;
+		std::vector<AssetUtilDesc> selection;
+	public:
+		Runner(AppContext& appContext, std::vector<AssetUtilDesc> _selection)
+			: appContext(appContext), selection(std::move(_selection))
+		{}
+		void operator()()
+		{
+			std::vector<std::string> importLocations = appContext.QueryAssetImportLocation(selection, "", "\\.*", "*|Font file:");
+			if (!importLocations.empty())
+			{
+				auto pTask = std::make_shared<FontImportTask>(appContext, std::move(selection), std::move(importLocations));
+				appContext.taskManager.enqueue(pTask);
+			}
+		}
+	};
+	EAssetOptionType getType()
+	{
+		return EAssetOptionType::Import;
+	}
+	std::unique_ptr<IOptionRunner> prepareForSelection(
+		class AppContext& appContext,
+		std::vector<AssetUtilDesc> selection,
+		std::string& optionName)
+	{
+		if (!SupportsElements(selection))
+			return nullptr;
+		optionName = "Import font";
+		return std::make_unique<Runner>(appContext, std::move(selection));
+	}
+};
+
+
+class FontExportTask : public AssetExportTask
+{
+	AppContext& appContext;
+	TypeTemplateCache templateCache;
+public:
+	FontExportTask(AppContext& appContext,
+		std::vector<AssetUtilDesc> _assets, std::string _baseDir,
+		bool stopOnError = false)
+
+		: AssetExportTask(std::move(_assets), "Export Font", ".ttf", std::move(_baseDir), stopOnError),
+		appContext(appContext)
+	{}
+
+	bool exportAsset(AssetUtilDesc& desc, std::string path, std::optional<std::reference_wrapper<TaskProgressManager>> progressManager)
+	{
+		if (desc.asset.pFile == nullptr)
+			throw AssetUtilError("Unable to find the target .assets file.");
+
+		IAssetsReader_ptr pAssetReader = desc.asset.makeReader();
+		if (pAssetReader == nullptr)
+			throw AssetUtilError("Unable to read the asset.");
+		QWORD assetSize = 0;
+		if (!pAssetReader->Seek(AssetsSeek_End, 0) || !pAssetReader->Tell(assetSize) || !pAssetReader->Seek(AssetsSeek_Begin, 0))
+			throw AssetUtilError("Unable to read the asset.");
+
+        AssetTypeTemplateField& templateBase = templateCache.getTemplateField(appContext, desc.asset,
+          [](AssetTypeTemplateField& templateBase) {
+              for (uint32_t i = 0; i < templateBase.children.size(); i++)
+              {
+                  if (templateBase.children[i].name == "m_FontData")
+                  {
+                      templateBase.children[i].valueType = ValueType_None;
+                      for (uint32_t k = 0; k < templateBase.children[i].children.size(); k++)
+                      {
+                          if (templateBase.children[i].children[k].name == "Array")
+                          {
+                              templateBase.children[i].children[k].type = "TypelessData";
+                              break;
+                          }
+                      }
+                      break;
+                  }
+              }
+          }
+        );
+		AssetTypeTemplateField* pTemplateBase = &templateBase;
+
+        AssetTypeInstance assetInstance(1, &pTemplateBase, assetSize, pAssetReader.get(), desc.asset.isBigEndian());
+        AssetTypeValueField* pBaseField = assetInstance.GetBaseField();
+
+        if (pBaseField == nullptr || pBaseField->IsDummy())
+            throw AssetUtilError("Unable to deserialize the asset.");
+
+        AssetTypeValueField* dataArrayField = pBaseField->Get("m_FontData")->Get(0U);
+        if (dataArrayField->GetValue() == nullptr)
+            throw AssetUtilError("Empty data");
+
+        if(dataArrayField->GetValue()->GetType() != ValueType_ByteArray) {
+            throw AssetUtilError("Unexpected Font format.");
+        }
+
+        AssetTypeByteArray* bytes = dataArrayField->GetValue()->AsByteArray();
+
+        std::string ext = isOtf(bytes) ? ".otf" : ".ttf";
+        std::string fullOutputPath = path + ext;
+        std::unique_ptr<IAssetsWriter> pWriter(Create_AssetsWriterToFile(fullOutputPath.c_str(), true, true, RWOpenFlags_Immediately));
+        if (pWriter == nullptr)
+            throw AssetUtilError("Unable to create the output file.");
+
+        QWORD size = bytes->size;
+        if (pWriter->Write(size, bytes->data) != size)
+            throw AssetUtilError("Unable to write data to the output file.");
+
+		return true;
+    }
+};
+class FontExportProvider : public IAssetOptionProviderGeneric
+{
+public:
+	class Runner : public IOptionRunner
+	{
+		AppContext& appContext;
+		std::vector<AssetUtilDesc> selection;
+	public:
+		Runner(AppContext& appContext, std::vector<AssetUtilDesc> _selection)
+			: appContext(appContext), selection(std::move(_selection))
+		{}
+		void operator()()
+		{
+			std::string exportLocation = appContext.QueryAssetExportLocation(selection, "", "*|Font file:");
+			if (!exportLocation.empty())
+			{
+				auto pTask = std::make_shared<FontExportTask>(appContext, std::move(selection), std::move(exportLocation));
+				appContext.taskManager.enqueue(pTask);
+			}
+		}
+	};
+	EAssetOptionType getType()
+	{
+		return EAssetOptionType::Export;
+	}
+	std::unique_ptr<IOptionRunner> prepareForSelection(
+		class AppContext& appContext,
+		std::vector<struct AssetUtilDesc> selection,
+		std::string& optionName)
+	{
+		if (!SupportsElements(selection))
+			return nullptr;
+		optionName = "Export font";
+		return std::make_unique<Runner>(appContext, std::move(selection));
+	}
+};
+
+class FontPluginDesc : public IPluginDesc
+{
+	std::vector<std::shared_ptr<IOptionProvider>> pProviders;
+public:
+	FontPluginDesc()
+	{
+		pProviders = { std::make_shared<FontExportProvider>(), std::make_shared<FontImportProvider>() };
+	}
+	std::string getName()
+	{
+		return "Font";
+	}
+	std::string getAuthor()
+	{
+		return "deadYokai";
+	}
+	std::string getDescriptionText()
+	{
+		return "Export and import the content of Font assets.";
+	}
+	//The IPluginDesc object should keep a reference to the returned options, as the caller may keep only std::weak_ptrs.
+	//Note: May be called early, e.g. before program UI initialization.
+	std::vector<std::shared_ptr<IOptionProvider>> getPluginOptions(class AppContext& appContext)
+	{
+		return pProviders;
+	}
+};
+
+IPluginDesc* GetUABEPluginDesc1(size_t sizeof_AppContext, size_t sizeof_BundleFileContextInfo)
+{
+	if (sizeof_AppContext != sizeof(AppContext) || sizeof_BundleFileContextInfo != sizeof(BundleFileContextInfo))
+	{
+		assert(false);
+		return nullptr;
+	}
+	return new FontPluginDesc();
+}

Plugins/Font/Font.def

@@ -0,0 +1,3 @@
+LIBRARY Font
+EXPORTS
+	GetUABEPluginDesc1

UABE_Generic/AssetPluginUtil.cpp

@@ -683,7 +683,7 @@ void AssetExportJSONDumpTask::recursiveDumpAsset(IAssetsReader* pReader, AssetTy
 							break;
 						default:
 							if (strValue[i] < 0x20)
-								std::format_to(std::back_inserter(lineBuf), "\\u{:04u}", strValue[i]);
+                                std::vformat_to(std::back_inserter(lineBuf), "\\u{:04u}", std::make_format_args(strValue[i]));
 							break;
 						}
 						if (!lineBuf.empty())
@@ -710,7 +710,7 @@ void AssetExportJSONDumpTask::recursiveDumpAsset(IAssetsReader* pReader, AssetTy
 					if (i)
 						pDumpWriter->Write(2, ", ");
 					lineBuf.clear();
-					std::format_to(std::back_inserter(lineBuf), "{}", pByteArray->data[i]);
+                    std::vformat_to(std::back_inserter(lineBuf), "{}", std::make_format_args(pByteArray->data[i]));
 					outputLineBuf();
 				}
 				outputRawChars("]", 1);

UABE_Generic/FileContextInfo.h

@@ -11,6 +11,7 @@
 #include <memory>
 #include <mutex>
 #include <shared_mutex>
+#include <optional>
 
 //unique_ptr to a IAssetsReader with a deleter.
 typedef std::unique_ptr<IAssetsReader, void(*)(IAssetsReader*)> IAssetsReader_ptr;