mirror of
https://github.com/Laupetin/OpenAssetTools.git
synced 2025-06-10 14:58:10 -05:00
Convert StructuredDataDef for IW4
This commit is contained in:
Jan
@ -22,15 +22,167 @@ bool AssetLoaderStructuredDataDefSet::CanLoadFromRaw() const
|
||||
return true;
|
||||
}
|
||||
|
||||
StructuredDataType AssetLoaderStructuredDataDefSet::ConvertType(CommonStructuredDataDefType inputType)
|
||||
{
|
||||
switch (inputType.m_category)
|
||||
{
|
||||
case CommonStructuredDataDefTypeCategory::INT:
|
||||
return {DATA_INT, {0}};
|
||||
case CommonStructuredDataDefTypeCategory::BYTE:
|
||||
return {DATA_BYTE, {0}};
|
||||
case CommonStructuredDataDefTypeCategory::BOOL:
|
||||
return {DATA_BOOL, {0}};
|
||||
case CommonStructuredDataDefTypeCategory::FLOAT:
|
||||
return {DATA_FLOAT, {0}};
|
||||
case CommonStructuredDataDefTypeCategory::SHORT:
|
||||
return {DATA_SHORT, {0}};
|
||||
case CommonStructuredDataDefTypeCategory::STRING:
|
||||
return {DATA_STRING, {inputType.m_info.string_length}};
|
||||
case CommonStructuredDataDefTypeCategory::ENUM:
|
||||
return {DATA_ENUM, {inputType.m_info.type_index}};
|
||||
case CommonStructuredDataDefTypeCategory::STRUCT:
|
||||
return {DATA_STRUCT, {inputType.m_info.type_index}};
|
||||
case CommonStructuredDataDefTypeCategory::INDEXED_ARRAY:
|
||||
return {DATA_INDEXED_ARRAY, {inputType.m_info.type_index}};
|
||||
case CommonStructuredDataDefTypeCategory::ENUM_ARRAY:
|
||||
return {DATA_ENUM_ARRAY, {inputType.m_info.type_index}};
|
||||
case CommonStructuredDataDefTypeCategory::UNKNOWN:
|
||||
default:
|
||||
assert(false);
|
||||
return {DATA_INT, {0}};
|
||||
}
|
||||
}
|
||||
|
||||
void AssetLoaderStructuredDataDefSet::ConvertEnum(StructuredDataEnum* outputEnum, const CommonStructuredDataDefEnum* inputEnum, MemoryManager* memory)
|
||||
{
|
||||
outputEnum->entryCount = static_cast<int>(inputEnum->m_entries.size());
|
||||
if (inputEnum->m_reserved_entry_count <= 0)
|
||||
outputEnum->reservedEntryCount = outputEnum->entryCount;
|
||||
else
|
||||
outputEnum->reservedEntryCount = inputEnum->m_reserved_entry_count;
|
||||
outputEnum->reservedEntryCount = static_cast<int>(inputEnum->m_entries.size());
|
||||
|
||||
if (!inputEnum->m_entries.empty())
|
||||
{
|
||||
outputEnum->entries = static_cast<StructuredDataEnumEntry*>(memory->Alloc(sizeof(StructuredDataEnumEntry) * inputEnum->m_entries.size()));
|
||||
for (auto entryIndex = 0u; entryIndex < inputEnum->m_entries.size(); entryIndex++)
|
||||
{
|
||||
auto& outputEntry = outputEnum->entries[entryIndex];
|
||||
const auto& inputEntry = inputEnum->m_entries[entryIndex];
|
||||
|
||||
outputEntry.string = memory->Dup(inputEntry.m_name.c_str());
|
||||
outputEntry.index = static_cast<uint16_t>(inputEntry.m_value);
|
||||
}
|
||||
}
|
||||
else
|
||||
outputEnum->entries = nullptr;
|
||||
}
|
||||
|
||||
void AssetLoaderStructuredDataDefSet::ConvertStruct(StructuredDataStruct* outputStruct, const CommonStructuredDataDefStruct* inputStruct, MemoryManager* memory)
|
||||
{
|
||||
outputStruct->size = static_cast<int>(inputStruct->m_size);
|
||||
outputStruct->bitOffset = inputStruct->m_bit_offset;
|
||||
|
||||
outputStruct->propertyCount = static_cast<int>(inputStruct->m_properties.size());
|
||||
if (!inputStruct->m_properties.empty())
|
||||
{
|
||||
outputStruct->properties = static_cast<StructuredDataStructProperty*>(memory->Alloc(sizeof(StructuredDataStructProperty) * inputStruct->m_properties.size()));
|
||||
for (auto propertyIndex = 0u; propertyIndex < inputStruct->m_properties.size(); propertyIndex++)
|
||||
{
|
||||
auto& outputProperty = outputStruct->properties[propertyIndex];
|
||||
const auto& inputProperty = inputStruct->m_properties[propertyIndex];
|
||||
|
||||
outputProperty.name = memory->Dup(inputProperty.m_name.c_str());
|
||||
outputProperty.offset = inputProperty.m_offset;
|
||||
outputProperty.type = ConvertType(inputProperty.m_type);
|
||||
}
|
||||
}
|
||||
else
|
||||
outputStruct->properties = nullptr;
|
||||
}
|
||||
|
||||
void AssetLoaderStructuredDataDefSet::ConvertIndexedArray(StructuredDataIndexedArray* outputIndexedArray, const CommonStructuredDataDefIndexedArray* inputIndexedArray, MemoryManager* memory)
|
||||
{
|
||||
outputIndexedArray->arraySize = static_cast<int>(inputIndexedArray->m_array_size);
|
||||
outputIndexedArray->elementType = ConvertType(inputIndexedArray->m_array_type);
|
||||
outputIndexedArray->elementSize = inputIndexedArray->m_element_size;
|
||||
}
|
||||
|
||||
void AssetLoaderStructuredDataDefSet::ConvertEnumedArray(StructuredDataEnumedArray* outputEnumedArray, const CommonStructuredDataDefEnumedArray* inputEnumedArray, MemoryManager* memory)
|
||||
{
|
||||
outputEnumedArray->enumIndex = static_cast<int>(inputEnumedArray->m_enum_index);
|
||||
outputEnumedArray->elementType = ConvertType(inputEnumedArray->m_array_type);
|
||||
outputEnumedArray->elementSize = inputEnumedArray->m_element_size;
|
||||
}
|
||||
|
||||
void AssetLoaderStructuredDataDefSet::ConvertDef(StructuredDataDef* outputDef, const CommonStructuredDataDef* inputDef, MemoryManager* memory)
|
||||
{
|
||||
outputDef->version = inputDef->m_version;
|
||||
outputDef->formatChecksum = inputDef->m_checksum;
|
||||
|
||||
outputDef->enumCount = static_cast<int>(inputDef->m_enums.size());
|
||||
if (!inputDef->m_enums.empty())
|
||||
{
|
||||
outputDef->enums = static_cast<StructuredDataEnum*>(memory->Alloc(sizeof(StructuredDataEnum) * inputDef->m_enums.size()));
|
||||
for (auto enumIndex = 0u; enumIndex < inputDef->m_enums.size(); enumIndex++)
|
||||
ConvertEnum(&outputDef->enums[enumIndex], inputDef->m_enums[enumIndex].get(), memory);
|
||||
}
|
||||
else
|
||||
outputDef->enums = nullptr;
|
||||
|
||||
outputDef->structCount = static_cast<int>(inputDef->m_structs.size());
|
||||
if (!inputDef->m_structs.empty())
|
||||
{
|
||||
outputDef->structs = static_cast<StructuredDataStruct*>(memory->Alloc(sizeof(StructuredDataStruct) * inputDef->m_structs.size()));
|
||||
for (auto structIndex = 0u; structIndex < inputDef->m_structs.size(); structIndex++)
|
||||
ConvertStruct(&outputDef->structs[structIndex], inputDef->m_structs[structIndex].get(), memory);
|
||||
}
|
||||
else
|
||||
outputDef->structs = nullptr;
|
||||
|
||||
outputDef->indexedArrayCount = static_cast<int>(inputDef->m_indexed_arrays.size());
|
||||
if (!inputDef->m_indexed_arrays.empty())
|
||||
{
|
||||
outputDef->indexedArrays = static_cast<StructuredDataIndexedArray*>(memory->Alloc(sizeof(StructuredDataIndexedArray) * inputDef->m_indexed_arrays.size()));
|
||||
for (auto indexedArrayIndex = 0u; indexedArrayIndex < inputDef->m_indexed_arrays.size(); indexedArrayIndex++)
|
||||
ConvertIndexedArray(&outputDef->indexedArrays[indexedArrayIndex], &inputDef->m_indexed_arrays[indexedArrayIndex], memory);
|
||||
}
|
||||
else
|
||||
outputDef->indexedArrays = nullptr;
|
||||
|
||||
outputDef->enumedArrayCount = static_cast<int>(inputDef->m_enumed_arrays.size());
|
||||
if (!inputDef->m_enumed_arrays.empty())
|
||||
{
|
||||
outputDef->enumedArrays = static_cast<StructuredDataEnumedArray*>(memory->Alloc(sizeof(StructuredDataEnumedArray) * inputDef->m_enumed_arrays.size()));
|
||||
for (auto enumedArrayIndex = 0u; enumedArrayIndex < inputDef->m_enumed_arrays.size(); enumedArrayIndex++)
|
||||
ConvertEnumedArray(&outputDef->enumedArrays[enumedArrayIndex], &inputDef->m_enumed_arrays[enumedArrayIndex], memory);
|
||||
}
|
||||
else
|
||||
outputDef->enumedArrays = nullptr;
|
||||
|
||||
outputDef->rootType = ConvertType(inputDef->m_root_type);
|
||||
outputDef->size = inputDef->m_size;
|
||||
}
|
||||
|
||||
StructuredDataDefSet* AssetLoaderStructuredDataDefSet::ConvertSet(const std::string& assetName, const std::vector<std::unique_ptr<CommonStructuredDataDef>>& defs, MemoryManager* memory)
|
||||
{
|
||||
auto* set = memory->Create<StructuredDataDefSet>();
|
||||
set->name = memory->Dup(assetName.c_str());
|
||||
set->defCount = defs.size();
|
||||
set->defs = static_cast<StructuredDataDef*>(memory->Alloc(sizeof(StructuredDataDef) * defs.size()));
|
||||
|
||||
for (auto defIndex = 0u; defIndex < defs.size(); defIndex++)
|
||||
ConvertDef(&set->defs[defIndex], defs[defIndex].get(), memory);
|
||||
|
||||
return set;
|
||||
}
|
||||
|
||||
bool AssetLoaderStructuredDataDefSet::LoadFromRaw(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
|
||||
{
|
||||
const auto file = searchPath->Open(assetName);
|
||||
if (!file.IsOpen())
|
||||
return false;
|
||||
|
||||
auto* structuredDataDefSet = memory->Create<StructuredDataDefSet>();
|
||||
structuredDataDefSet->name = memory->Dup(assetName.c_str());
|
||||
|
||||
StructuredDataDefReader reader(*file.m_stream, assetName, [searchPath](const std::string& filename, const std::string& sourceFile) -> std::unique_ptr<std::istream>
|
||||
{
|
||||
auto foundFileToInclude = searchPath->Open(filename);
|
||||
@ -40,11 +192,11 @@ bool AssetLoaderStructuredDataDefSet::LoadFromRaw(const std::string& assetName,
|
||||
return std::move(foundFileToInclude.m_stream);
|
||||
});
|
||||
|
||||
const auto defs = reader.ReadStructureDataDefs();
|
||||
bool readingDefsSuccessful;
|
||||
const auto defs = reader.ReadStructureDataDefs(readingDefsSuccessful);
|
||||
|
||||
// TODO Convert defs
|
||||
|
||||
manager->AddAsset(ASSET_TYPE_STRUCTURED_DATA_DEF, assetName, structuredDataDefSet);
|
||||
if (readingDefsSuccessful)
|
||||
manager->AddAsset(ASSET_TYPE_STRUCTURED_DATA_DEF, assetName, ConvertSet(assetName, defs, memory));
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user