zone/OpenAssetTools
zone/OpenAssetTools
2
0
Fork 0
mirror of https://github.com/Laupetin/OpenAssetTools.git synced 2025-04-19 15:52:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

Calculate checksums for structured data def

Browse Source
This commit is contained in:
Jan 2022-03-20 16:01:29 +01:00
parent c91cb40b76
commit b5e18e6b22
7 changed files with 126 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
src/ObjCommon/StructuredDataDef/CommonStructuredDataDef.cpp
View File

@ -12,8 +12,13 @@ CommonStructuredDataDef::CommonStructuredDataDef(const int version)
{
}
size_t CommonStructuredDataDef::CalculateChecksum() const
uint32_t CommonStructuredDataDef::CalculateChecksum() const
{
// TODO: Implement
return 0u;
auto checksum = 0u;
for (const auto& _enum : m_enums)
checksum = _enum->CalculateChecksum(checksum);
for (const auto& _struct : m_structs)
checksum = _struct->CalculateChecksum(*this, checksum);
return checksum;
}

3
src/ObjCommon/StructuredDataDef/CommonStructuredDataDef.h
View File

@ -3,6 +3,7 @@
#include <memory>
#include <vector>
#include "Utils/ClassUtils.h"
#include "CommonStructuredDataEnum.h"
#include "CommonStructuredDataStruct.h"
@ -22,5 +23,5 @@ public:
CommonStructuredDataDef();
explicit CommonStructuredDataDef(int version);
size_t CalculateChecksum() const;
_NODISCARD uint32_t CalculateChecksum() const;
};

23
src/ObjCommon/StructuredDataDef/CommonStructuredDataEnum.cpp
View File

@ -1,6 +1,9 @@
#include "CommonStructuredDataEnum.h"
#include <algorithm>
#include <zlib.h>
#include "Utils/Endianness.h"
CommonStructuredDataEnumEntry::CommonStructuredDataEnumEntry()
: m_value(0u)
@ -35,6 +38,26 @@ size_t CommonStructuredDataEnum::ElementCount() const
return m_reserved_entry_count > 0 ? static_cast<size_t>(m_reserved_entry_count) : m_entries.size();
}
uint32_t CommonStructuredDataEnum::CalculateChecksum(const uint32_t initialValue) const
{
auto checksum = initialValue;
checksum = crc32(checksum, reinterpret_cast<const Bytef*>(m_name.c_str()), m_name.size() + 1);
const auto littleEndianElementCount = endianness::ToLittleEndian(ElementCount());
checksum = crc32(checksum, reinterpret_cast<const Bytef*>(&littleEndianElementCount), sizeof(littleEndianElementCount));
for(const auto& entry : m_entries)
{
checksum = crc32(checksum, reinterpret_cast<const Bytef*>(entry.m_name.c_str()), entry.m_name.size() + 1);
const auto littleEndianValue = endianness::ToLittleEndian(entry.m_value);
checksum = crc32(checksum, reinterpret_cast<const Bytef*>(&littleEndianValue), sizeof(littleEndianValue));
}
return checksum;
}
void CommonStructuredDataEnum::SortEntries()
{
std::sort(m_entries.begin(), m_entries.end(), [](const CommonStructuredDataEnumEntry& e1, const CommonStructuredDataEnumEntry& e2)

1
src/ObjCommon/StructuredDataDef/CommonStructuredDataEnum.h
View File

@ -25,6 +25,7 @@ struct CommonStructuredDataEnum
CommonStructuredDataEnum(std::string name, int reservedEntryCount);
_NODISCARD size_t ElementCount() const;
_NODISCARD uint32_t CalculateChecksum(uint32_t initialValue) const;
void SortEntries();
};

83
src/ObjCommon/StructuredDataDef/CommonStructuredDataStruct.cpp
View File

@ -1,6 +1,10 @@
#include "CommonStructuredDataStruct.h"
#include <algorithm>
#include <zlib.h>
#include "CommonStructuredDataDef.h"
#include "Utils/Endianness.h"
CommonStructuredDataStructEntry::CommonStructuredDataStructEntry()
: m_offset_in_bits(0u)
@ -33,6 +37,85 @@ CommonStructuredDataStruct::CommonStructuredDataStruct(std::string name)
{
}
uint32_t CommonStructuredDataStruct::CalculateChecksum(const CommonStructuredDataDef& def, const uint32_t initialValue) const
{
auto checksum = initialValue;
checksum = crc32(checksum, reinterpret_cast<const Bytef*>(m_name.c_str()), m_name.size() + 1);
for (const auto& property : m_properties)
{
checksum = crc32(checksum, reinterpret_cast<const Bytef*>(property.m_name.c_str()), property.m_name.size() + 1);
const auto littleEndianOffset = endianness::ToLittleEndian(property.m_offset_in_bits);
checksum = crc32(checksum, reinterpret_cast<const Bytef*>(&littleEndianOffset), sizeof(littleEndianOffset));
auto currentType = property.m_type;
while (currentType.m_category != CommonStructuredDataTypeCategory::UNKNOWN)
{
const auto categoryByte = static_cast<uint8_t>(currentType.m_category);
checksum = crc32(checksum, &categoryByte, sizeof(categoryByte));
switch (currentType.m_category)
{
case CommonStructuredDataTypeCategory::STRING:
{
const auto littleEndianStringLength = endianness::ToLittleEndian(currentType.m_info.string_length);
checksum = crc32(checksum, reinterpret_cast<const Bytef*>(&littleEndianStringLength), sizeof(littleEndianStringLength));
currentType = CommonStructuredDataType(CommonStructuredDataTypeCategory::UNKNOWN);
}
break;
case CommonStructuredDataTypeCategory::ENUM:
if (currentType.m_info.type_index < def.m_enums.size())
{
const auto& _enum = *def.m_enums[currentType.m_info.type_index];
checksum = crc32(checksum, reinterpret_cast<const Bytef*>(_enum.m_name.c_str()), _enum.m_name.size() + 1);
currentType = CommonStructuredDataType(CommonStructuredDataTypeCategory::UNKNOWN);
}
break;
case CommonStructuredDataTypeCategory::STRUCT:
if (currentType.m_info.type_index < def.m_structs.size())
{
const auto& _struct = *def.m_structs[currentType.m_info.type_index];
checksum = crc32(checksum, reinterpret_cast<const Bytef*>(_struct.m_name.c_str()), _struct.m_name.size() + 1);
currentType = CommonStructuredDataType(CommonStructuredDataTypeCategory::UNKNOWN);
}
break;
case CommonStructuredDataTypeCategory::INDEXED_ARRAY:
if (currentType.m_info.type_index < def.m_indexed_arrays.size())
{
const auto& indexedArray = def.m_indexed_arrays[currentType.m_info.type_index];
const auto littleEndianElementCount = endianness::ToLittleEndian(indexedArray.m_element_count);
checksum = crc32(checksum, reinterpret_cast<const Bytef*>(&littleEndianElementCount), sizeof(littleEndianElementCount));
currentType = indexedArray.m_array_type;
}
else
currentType = CommonStructuredDataType(CommonStructuredDataTypeCategory::UNKNOWN);
break;
case CommonStructuredDataTypeCategory::ENUM_ARRAY:
if (currentType.m_info.type_index < def.m_enumed_arrays.size())
{
const auto& enumedArray = def.m_enumed_arrays[currentType.m_info.type_index];
if(enumedArray.m_enum_index < def.m_enums.size())
{
const auto& _enum = *def.m_enums[enumedArray.m_enum_index];
checksum = crc32(checksum, reinterpret_cast<const Bytef*>(_enum.m_name.c_str()), _enum.m_name.size() + 1);
}
currentType = enumedArray.m_array_type;
}
else
currentType = CommonStructuredDataType(CommonStructuredDataTypeCategory::UNKNOWN);
break;
default:
currentType = CommonStructuredDataType(CommonStructuredDataTypeCategory::UNKNOWN);
break;
}
}
}
return checksum;
}
void CommonStructuredDataStruct::SortProperties()
{
std::sort(m_properties.begin(), m_properties.end(), [](const CommonStructuredDataStructEntry& e1, const CommonStructuredDataStructEntry& e2)

4
src/ObjCommon/StructuredDataDef/CommonStructuredDataStruct.h
View File

@ -3,6 +3,7 @@
#include <string>
#include <vector>
#include "Utils/ClassUtils.h"
#include "CommonStructuredDataTypes.h"
struct CommonStructuredDataStructEntry
@ -16,6 +17,7 @@ struct CommonStructuredDataStructEntry
CommonStructuredDataStructEntry(std::string name, CommonStructuredDataType type, size_t offsetInBits);
};
class CommonStructuredDataDef;
struct CommonStructuredDataStruct
{
std::string m_name;
@ -26,5 +28,7 @@ struct CommonStructuredDataStruct
CommonStructuredDataStruct();
explicit CommonStructuredDataStruct(std::string name);
_NODISCARD uint32_t CalculateChecksum(const CommonStructuredDataDef& def, uint32_t initialValue) const;
void SortProperties();
};

4
src/ObjWriting/Game/IW4/AssetDumpers/AssetDumperStructuredDataDefSet.cpp
View File

@ -401,7 +401,11 @@ CommonStructuredDataType AssetDumperStructuredDataDefSet::ConvertType(const Comm
void AssetDumperStructuredDataDefSet::ConvertEnum(CommonStructuredDataEnum* out, const StructuredDataEnum* in, const size_t enumIndex)
{
out->m_name = "ENUM_" + std::to_string(enumIndex);
if (in->reservedEntryCount > 0 && in->reservedEntryCount != in->entryCount)
out->m_reserved_entry_count = std::max(in->reservedEntryCount, 0);
else
out->m_reserved_entry_count = -1;
out->m_entries.resize(static_cast<size_t>(std::max(in->entryCount, 0)));
for(auto i = 0u; i < out->m_entries.size(); i++)