diff --git a/src/common/DataStores/DB2FileLoader.cpp b/src/common/DataStores/DB2FileLoader.cpp new file mode 100644 index 00000000000..6ec065aef27 --- /dev/null +++ b/src/common/DataStores/DB2FileLoader.cpp @@ -0,0 +1,1156 @@ +/* + * Copyright (C) 2008-2017 TrinityCore + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with this program. If not, see . + */ + +#include "DB2FileLoader.h" +#include "ByteConverter.h" +#include "Common.h" +#include "DB2Meta.h" +#include "Errors.h" +#include "Log.h" + +DB2FileLoadInfo::DB2FileLoadInfo() : Fields(nullptr), FieldCount(0), Meta(nullptr) +{ +} + +DB2FileLoadInfo::DB2FileLoadInfo(DB2FieldMeta const* fields, std::size_t fieldCount, DB2Meta const* meta) + : Fields(fields), FieldCount(fieldCount), Meta(meta) +{ + TypesString.reserve(FieldCount); + for (std::size_t i = 0; i < FieldCount; ++i) + TypesString += char(Fields[i].Type); +} + +uint32 DB2FileLoadInfo::GetStringFieldCount(bool localizedOnly) const +{ + uint32 stringFields = 0; + for (std::size_t i = 0; i < TypesString.length(); ++i) + if (TypesString[i] == FT_STRING || (TypesString[i] == FT_STRING_NOT_LOCALIZED && !localizedOnly)) + ++stringFields; + + return stringFields; +} + +DB2FileSource::~DB2FileSource() +{ +} + +class DB2FileLoaderImpl +{ +public: + virtual ~DB2FileLoaderImpl() { } + virtual bool Load(DB2FileSource* source, DB2FileLoadInfo const* loadInfo, DB2Header const* header) = 0; + virtual char* AutoProduceData(uint32& count, char**& indexTable, std::vector& stringPool) = 0; + virtual char* AutoProduceStrings(char* dataTable, uint32 locale) = 0; + virtual void AutoProduceRecordCopies(uint32 records, char** indexTable, char* dataTable) = 0; + virtual DB2Record GetRecord(uint32 recordNumber) const = 0; + virtual DB2RecordCopy GetRecordCopy(uint32 copyNumber) const = 0; + virtual uint32 GetRecordCount() const = 0; + virtual uint32 GetRecordCopyCount() const = 0; + virtual uint32 GetMaxId() const = 0; + +private: + friend class DB2Record; + virtual unsigned char const* GetRawRecordData(uint32 recordNumber) const = 0; + virtual uint32 RecordGetId(unsigned char const* record, uint32 recordIndex) const = 0; + virtual uint8 RecordGetUInt8(unsigned char const* record, uint32 field, uint32 arrayIndex) const = 0; + virtual uint16 RecordGetUInt16(unsigned char const* record, uint32 field, uint32 arrayIndex) const = 0; + virtual uint32 RecordGetUInt32(unsigned char const* record, uint32 field, uint32 arrayIndex) const = 0; + virtual int32 RecordGetInt32(unsigned char const* record, uint32 field, uint32 arrayIndex) const = 0; + virtual float RecordGetFloat(unsigned char const* record, uint32 field, uint32 arrayIndex) const = 0; + virtual char const* RecordGetString(unsigned char const* record, uint32 field, uint32 arrayIndex) const = 0; + virtual std::size_t* RecordCreateDetachedFieldOffsets(std::size_t* oldOffsets) const = 0; + virtual void RecordDestroyFieldOffsets(std::size_t*& fieldOffsets) const = 0; +}; + +class DB2FileLoaderRegularImpl final : public DB2FileLoaderImpl +{ +public: + DB2FileLoaderRegularImpl(); + ~DB2FileLoaderRegularImpl(); + + bool Load(DB2FileSource* source, DB2FileLoadInfo const* loadInfo, DB2Header const* header) override; + char* AutoProduceData(uint32& count, char**& indexTable, std::vector& stringPool) override; + char* AutoProduceStrings(char* dataTable, uint32 locale) override; + void AutoProduceRecordCopies(uint32 records, char** indexTable, char* dataTable) override; + DB2Record GetRecord(uint32 recordNumber) const override; + DB2RecordCopy GetRecordCopy(uint32 copyNumber) const override; + uint32 GetRecordCount() const override; + uint32 GetRecordCopyCount() const override; + uint32 GetMaxId() const override; + +private: + unsigned char const* GetRawRecordData(uint32 recordNumber) const override; + uint32 RecordGetId(unsigned char const* record, uint32 recordIndex) const override; + uint8 RecordGetUInt8(unsigned char const* record, uint32 field, uint32 arrayIndex) const override; + uint16 RecordGetUInt16(unsigned char const* record, uint32 field, uint32 arrayIndex) const override; + uint32 RecordGetUInt32(unsigned char const* record, uint32 field, uint32 arrayIndex) const override; + int32 RecordGetInt32(unsigned char const* record, uint32 field, uint32 arrayIndex) const override; + float RecordGetFloat(unsigned char const* record, uint32 field, uint32 arrayIndex) const override; + char const* RecordGetString(unsigned char const* record, uint32 field, uint32 arrayIndex) const override; + uint32 RecordGetVarInt(unsigned char const* record, uint32 field, uint32 arrayIndex, bool isSigned) const; + uint16 GetFieldOffset(uint32 field) const; + uint16 GetFieldSize(uint32 field) const; + std::size_t* RecordCreateDetachedFieldOffsets(std::size_t* oldOffsets) const override; + void RecordDestroyFieldOffsets(std::size_t*& fieldOffsets) const override; + +#pragma pack(push, 1) + struct FieldEntry + { + uint16 UnusedBits; + uint16 Offset; + }; +#pragma pack(pop) + + char const* fileName; + DB2FileLoadInfo const* _loadInfo; + + DB2Header const* _header; + + unsigned char* data; + unsigned char* stringTable; + unsigned char* idTable; + uint32 idTableSize; + DB2RecordCopy* copyTable; + FieldEntry* fields; +}; + +class DB2FileLoaderSparseImpl final : public DB2FileLoaderImpl +{ +public: + DB2FileLoaderSparseImpl(); + ~DB2FileLoaderSparseImpl(); + + bool Load(DB2FileSource* source, DB2FileLoadInfo const* loadInfo, DB2Header const* header) override; + char* AutoProduceData(uint32& records, char**& indexTable, std::vector& stringPool) override; + char* AutoProduceStrings(char* dataTable, uint32 locale) override; + void AutoProduceRecordCopies(uint32 /*records*/, char** /*indexTable*/, char* /*dataTable*/) override { } + DB2Record GetRecord(uint32 recordNumber) const override; + DB2RecordCopy GetRecordCopy(uint32 copyNumber) const override; + uint32 GetRecordCount() const override; + uint32 GetRecordCopyCount() const override; + uint32 GetMaxId() const override; + +private: + unsigned char const* GetRawRecordData(uint32 recordNumber) const override; + uint32 RecordGetId(unsigned char const* record, uint32 recordIndex) const override; + uint8 RecordGetUInt8(unsigned char const* record, uint32 field, uint32 arrayIndex) const override; + uint16 RecordGetUInt16(unsigned char const* record, uint32 field, uint32 arrayIndex) const override; + uint32 RecordGetUInt32(unsigned char const* record, uint32 field, uint32 arrayIndex) const override; + int32 RecordGetInt32(unsigned char const* record, uint32 field, uint32 arrayIndex) const override; + float RecordGetFloat(unsigned char const* record, uint32 field, uint32 arrayIndex) const override; + char const* RecordGetString(unsigned char const* record, uint32 field, uint32 arrayIndex) const override; + uint32 RecordGetVarInt(unsigned char const* record, uint32 field, uint32 arrayIndex, bool isSigned) const; + uint16 GetFieldOffset(uint32 field, uint32 arrayIndex) const; + uint16 GetFieldSize(uint32 field) const; + std::size_t* RecordCreateDetachedFieldOffsets(std::size_t* oldOffsets) const override; + void RecordDestroyFieldOffsets(std::size_t*& fieldOffsets) const override; + void CalculateAndStoreFieldOffsets(unsigned char const* rawRecord) const; + +#pragma pack(push, 1) + struct OffsetTableEntry + { + uint32 FileOffset; + uint16 RecordSize; + }; + struct FieldEntry + { + uint16 UnusedBits; + uint16 Offset; + }; +#pragma pack(pop) + + char const* fileName; + DB2FileLoadInfo const* _loadInfo; + std::size_t* _fieldAndArrayOffsets; + + DB2Header const* _header; + FieldEntry* fields; + + std::size_t dataStart; + unsigned char* data; + OffsetTableEntry* offsets; +}; + +DB2FileLoaderRegularImpl::DB2FileLoaderRegularImpl() +{ + fileName = nullptr; + _loadInfo = nullptr; + _header = nullptr; + data = nullptr; + stringTable = nullptr; + idTable = nullptr; + idTableSize = 0; + copyTable = nullptr; + fields = nullptr; +} + +bool DB2FileLoaderRegularImpl::Load(DB2FileSource* source, DB2FileLoadInfo const* loadInfo, DB2Header const* header) +{ + _loadInfo = loadInfo; + _header = header; + ASSERT(_loadInfo->Meta->IndexField == -1 || _loadInfo->Meta->IndexField == int32(header->IndexField)); + + fileName = source->GetFileName(); + fields = new FieldEntry[header->FieldCount]; + if (!source->Read(fields, header->FieldCount * sizeof(FieldEntry))) + return false; + + if (!_loadInfo->Meta->HasIndexFieldInData()) + idTableSize = header->RecordCount * sizeof(uint32); + + data = new unsigned char[header->RecordSize * header->RecordCount + header->StringTableSize]; + stringTable = data + header->RecordSize * header->RecordCount; + + if (!source->Read(data, header->RecordSize * header->RecordCount + header->StringTableSize)) + return false; + + if (idTableSize) + { + idTable = new unsigned char[idTableSize]; + if (!source->Read(idTable, idTableSize)) + return false; + } + + if (header->CopyTableSize) + { + copyTable = new DB2RecordCopy[header->CopyTableSize / sizeof(DB2RecordCopy)]; + if (!source->Read(copyTable, header->CopyTableSize)) + return false; + } + + return true; +} + +DB2FileLoaderRegularImpl::~DB2FileLoaderRegularImpl() +{ + delete[] data; + delete[] idTable; + delete[] copyTable; + delete[] fields; +} + +static char const* const nullStr = ""; + +char* DB2FileLoaderRegularImpl::AutoProduceData(uint32& records, char**& indexTable, std::vector& stringPool) +{ + if (_loadInfo->Meta->FieldCount != _header->FieldCount) + return nullptr; + + //get struct size and index pos + uint32 recordsize = _loadInfo->Meta->GetRecordSize(); + + uint32 maxi = GetMaxId() + 1; + + using index_entry_t = char*; + + records = maxi; + indexTable = new index_entry_t[maxi]; + memset(indexTable, 0, maxi * sizeof(index_entry_t)); + + char* dataTable = new char[(_header->RecordCount + (_header->CopyTableSize / 8)) * recordsize]; + + // we store flat holders pool as single memory block + std::size_t stringFields = _loadInfo->GetStringFieldCount(false); + std::size_t localizedStringFields = _loadInfo->GetStringFieldCount(true); + + // each string field at load have array of string for each locale + std::size_t stringHoldersRecordPoolSize = localizedStringFields * sizeof(LocalizedString) + (stringFields - localizedStringFields) * sizeof(char*); + char* stringHoldersPool = nullptr; + if (stringFields) + { + std::size_t stringHoldersPoolSize = stringHoldersRecordPoolSize * _header->RecordCount; + + stringHoldersPool = new char[stringHoldersPoolSize]; + stringPool.push_back(stringHoldersPool); + + // DB2 strings expected to have at least empty string + for (std::size_t i = 0; i < stringHoldersPoolSize / sizeof(char*); ++i) + ((char const**)stringHoldersPool)[i] = nullStr; + } + + uint32 offset = 0; + + for (uint32 y = 0; y < _header->RecordCount; y++) + { + unsigned char const* rawRecord = GetRawRecordData(y); + if (!rawRecord) + continue; + + uint32 indexVal = RecordGetId(rawRecord, y); + + indexTable[indexVal] = &dataTable[offset]; + + uint32 fieldIndex = 0; + if (!_loadInfo->Meta->HasIndexFieldInData()) + { + *((uint32*)(&dataTable[offset])) = indexVal; + offset += 4; + ++fieldIndex; + } + + uint32 stringFieldOffset = 0; + + for (uint32 x = 0; x < _header->FieldCount; ++x) + { + for (uint32 z = 0; z < _loadInfo->Meta->ArraySizes[x]; ++z) + { + switch (_loadInfo->TypesString[fieldIndex]) + { + case FT_FLOAT: + *((float*)(&dataTable[offset])) = RecordGetFloat(rawRecord, x, z); + offset += 4; + break; + case FT_INT: + *((uint32*)(&dataTable[offset])) = RecordGetVarInt(rawRecord, x, z, _loadInfo->Fields[fieldIndex].IsSigned); + offset += 4; + break; + case FT_BYTE: + *((uint8*)(&dataTable[offset])) = RecordGetUInt8(rawRecord, x, z); + offset += 1; + break; + case FT_SHORT: + *((uint16*)(&dataTable[offset])) = RecordGetUInt16(rawRecord, x, z); + offset += 2; + break; + case FT_STRING: + case FT_STRING_NOT_LOCALIZED: + { + // init db2 string field slots by pointers to string holders + char const*** slot = (char const***)(&dataTable[offset]); + *slot = (char const**)(&stringHoldersPool[stringHoldersRecordPoolSize * y + stringFieldOffset]); + if (_loadInfo->TypesString[fieldIndex] == FT_STRING) + stringFieldOffset += sizeof(LocalizedString); + else + stringFieldOffset += sizeof(char*); + + offset += sizeof(char*); + break; + } + default: + ASSERT(false, "Unknown format character '%c' found in %s meta", _loadInfo->TypesString[x], fileName); + break; + } + ++fieldIndex; + } + } + } + + return dataTable; +} + +char* DB2FileLoaderRegularImpl::AutoProduceStrings(char* dataTable, uint32 locale) +{ + if (_loadInfo->Meta->FieldCount != _header->FieldCount) + return nullptr; + + if (!(_header->Locale & (1 << locale))) + { + char const* sep = ""; + std::ostringstream str; + for (uint32 i = 0; i < TOTAL_LOCALES; ++i) + { + if (_header->Locale & (1 << i)) + { + str << sep << localeNames[i]; + sep = ", "; + } + } + + TC_LOG_ERROR("", "Attempted to load %s which has locales %s as %s. Check if you placed your localized db2 files in correct directory.", fileName, str.str().c_str(), localeNames[locale]); + return nullptr; + } + + char* stringPool = new char[_header->StringTableSize]; + memcpy(stringPool, stringTable, _header->StringTableSize); + + uint32 offset = 0; + + for (uint32 y = 0; y < _header->RecordCount; y++) + { + unsigned char const* rawRecord = GetRawRecordData(y); + uint32 fieldIndex = 0; + if (!_loadInfo->Meta->HasIndexFieldInData()) + { + offset += 4; + ++fieldIndex; + } + + for (uint32 x = 0; x < _header->FieldCount; ++x) + { + for (uint32 z = 0; z < _loadInfo->Meta->ArraySizes[x]; ++z) + { + switch (_loadInfo->TypesString[fieldIndex]) + { + case FT_FLOAT: + case FT_INT: + offset += 4; + break; + case FT_BYTE: + offset += 1; + break; + case FT_SHORT: + offset += 2; + break; + case FT_STRING: + { + // fill only not filled entries + LocalizedString* db2str = *(LocalizedString**)(&dataTable[offset]); + if (db2str->Str[locale] == nullStr) + { + char const* st = RecordGetString(rawRecord, x, z); + db2str->Str[locale] = stringPool + (st - (char const*)stringTable); + } + + offset += sizeof(char*); + break; + } + case FT_STRING_NOT_LOCALIZED: + { + char** db2str = (char**)(&dataTable[offset]); + char const* st = RecordGetString(rawRecord, x, z); + *db2str = stringPool + (st - (char const*)stringTable); + offset += sizeof(char*); + break; + } + default: + ASSERT(false, "Unknown format character '%c' found in %s meta", _loadInfo->TypesString[x], fileName); + break; + } + ++fieldIndex; + } + } + } + + return stringPool; +} + +void DB2FileLoaderRegularImpl::AutoProduceRecordCopies(uint32 records, char** indexTable, char* dataTable) +{ + uint32 recordsize = _loadInfo->Meta->GetRecordSize(); + uint32 offset = _header->RecordCount * recordsize; + for (uint32 c = 0; c < GetRecordCopyCount(); ++c) + { + DB2RecordCopy copy = GetRecordCopy(c); + if (copy.SourceRowId && copy.SourceRowId < records && copy.NewRowId < records && indexTable[copy.SourceRowId]) + { + indexTable[copy.NewRowId] = &dataTable[offset]; + memcpy(indexTable[copy.NewRowId], indexTable[copy.SourceRowId], recordsize); + + if (_loadInfo->Meta->HasIndexFieldInData()) + *((uint32*)(&dataTable[offset + GetFieldOffset(_loadInfo->Meta->GetIndexField())])) = copy.NewRowId; + else + *((uint32*)(&dataTable[offset])) = copy.NewRowId; + + offset += recordsize; + } + } +} + +DB2Record DB2FileLoaderRegularImpl::GetRecord(uint32 recordNumber) const +{ + return DB2Record(*this, recordNumber, nullptr); +} + +DB2RecordCopy DB2FileLoaderRegularImpl::GetRecordCopy(uint32 copyNumber) const +{ + if (copyNumber >= GetRecordCopyCount()) + return DB2RecordCopy{}; + + return copyTable[copyNumber]; +} + +uint32 DB2FileLoaderRegularImpl::GetRecordCount() const +{ + return _header->RecordCount; +} + +uint32 DB2FileLoaderRegularImpl::GetRecordCopyCount() const +{ + return _header->CopyTableSize / sizeof(DB2RecordCopy); +} + +unsigned char const* DB2FileLoaderRegularImpl::GetRawRecordData(uint32 recordNumber) const +{ + if (recordNumber >= _header->RecordCount) + return nullptr; + + return data + recordNumber * _header->RecordSize; +} + +uint32 DB2FileLoaderRegularImpl::RecordGetId(unsigned char const* record, uint32 recordIndex) const +{ + if (_loadInfo->Meta->HasIndexFieldInData()) + return RecordGetVarInt(record, _loadInfo->Meta->GetIndexField(), 0, false); + + return (reinterpret_cast(idTable))[recordIndex]; +} + +uint8 DB2FileLoaderRegularImpl::RecordGetUInt8(unsigned char const* record, uint32 field, uint32 arrayIndex) const +{ + ASSERT(field < _header->FieldCount); + ASSERT(GetFieldSize(field) == 1); + return *reinterpret_cast(record + GetFieldOffset(field) + arrayIndex * sizeof(uint8)); +} + +uint16 DB2FileLoaderRegularImpl::RecordGetUInt16(unsigned char const* record, uint32 field, uint32 arrayIndex) const +{ + ASSERT(field < _header->FieldCount); + ASSERT(GetFieldSize(field) == 2); + uint16 val = *reinterpret_cast(record + GetFieldOffset(field) + arrayIndex * sizeof(uint16)); + EndianConvert(val); + return val; +} + +uint32 DB2FileLoaderRegularImpl::RecordGetUInt32(unsigned char const* record, uint32 field, uint32 arrayIndex) const +{ + return RecordGetVarInt(record, field, arrayIndex, false); +} + +int32 DB2FileLoaderRegularImpl::RecordGetInt32(unsigned char const* record, uint32 field, uint32 arrayIndex) const +{ + return int32(RecordGetVarInt(record, field, arrayIndex, true)); +} + +float DB2FileLoaderRegularImpl::RecordGetFloat(unsigned char const* record, uint32 field, uint32 arrayIndex) const +{ + ASSERT(field < _header->FieldCount); + float val = *reinterpret_cast(record + GetFieldOffset(field) + arrayIndex * sizeof(float)); + EndianConvert(val); + return val; +} + +char const* DB2FileLoaderRegularImpl::RecordGetString(unsigned char const* record, uint32 field, uint32 arrayIndex) const +{ + ASSERT(field < _header->FieldCount); + uint32 stringOffset = *reinterpret_cast(record + GetFieldOffset(field) + arrayIndex * sizeof(uint32)); + EndianConvert(stringOffset); + ASSERT(stringOffset < _header->StringTableSize); + return reinterpret_cast(stringTable + stringOffset); +} + +uint32 DB2FileLoaderRegularImpl::RecordGetVarInt(unsigned char const* record, uint32 field, uint32 arrayIndex, bool isSigned) const +{ + ASSERT(field < _header->FieldCount); + uint32 val = *reinterpret_cast(record + GetFieldOffset(field) + arrayIndex * (4 - fields[field].UnusedBits / 8)); + EndianConvert(val); + if (isSigned) + return int32(val) << fields[field].UnusedBits >> fields[field].UnusedBits; + + return val << fields[field].UnusedBits >> fields[field].UnusedBits; +} + +uint16 DB2FileLoaderRegularImpl::GetFieldOffset(uint32 field) const +{ + ASSERT(field < _header->FieldCount); + return fields[field].Offset; +} + +uint16 DB2FileLoaderRegularImpl::GetFieldSize(uint32 field) const +{ + ASSERT(field < _header->FieldCount); + return 4 - fields[field].UnusedBits / 8; +} + +std::size_t* DB2FileLoaderRegularImpl::RecordCreateDetachedFieldOffsets(std::size_t* /*oldOffsets*/) const +{ + return nullptr; +} + +void DB2FileLoaderRegularImpl::RecordDestroyFieldOffsets(std::size_t*& /*fieldOffsets*/) const +{ +} + +uint32 DB2FileLoaderRegularImpl::GetMaxId() const +{ + uint32 maxId = 0; + for (uint32 row = 0; row < _header->RecordCount; ++row) + { + uint32 id = RecordGetId(GetRawRecordData(row), row); + if (id > maxId) + maxId = id; + } + + for (uint32 copy = 0; copy < GetRecordCopyCount(); ++copy) + { + uint32 id = GetRecordCopy(copy).NewRowId; + if (id > maxId) + maxId = id; + } + + return maxId; +} + +DB2FileLoaderSparseImpl::DB2FileLoaderSparseImpl() +{ + fileName = nullptr; + _loadInfo = nullptr; + _fieldAndArrayOffsets = nullptr; + _header = nullptr; + fields = nullptr; + dataStart = 0; + data = nullptr; + offsets = nullptr; +} + +DB2FileLoaderSparseImpl::~DB2FileLoaderSparseImpl() +{ + delete[] _fieldAndArrayOffsets; + delete[] data; + delete[] offsets; + delete[] fields; +} + +bool DB2FileLoaderSparseImpl::Load(DB2FileSource* source, DB2FileLoadInfo const* loadInfo, DB2Header const* header) +{ + _loadInfo = loadInfo; + _header = header; + fileName = source->GetFileName(); + + fields = new FieldEntry[header->FieldCount]; + if (!source->Read(fields, header->FieldCount * sizeof(FieldEntry))) + return false; + + dataStart = source->GetPosition(); + + data = new unsigned char[header->StringTableSize - dataStart]; + + if (!source->Read(data, header->StringTableSize - dataStart)) + return false; + + offsets = new OffsetTableEntry[header->MaxId - header->MinId + 1]; + if (!source->Read(offsets, (header->MaxId - header->MinId + 1) * 6)) + return false; + + _fieldAndArrayOffsets = new std::size_t[_loadInfo->Meta->FieldCount + _loadInfo->FieldCount - (!_loadInfo->Meta->HasIndexFieldInData() ? 1 : 0)]; + return true; +} + +char* DB2FileLoaderSparseImpl::AutoProduceData(uint32& maxId, char**& indexTable, std::vector& stringPool) +{ + if (_loadInfo->Meta->FieldCount != _header->FieldCount) + return NULL; + + //get struct size and index pos + uint32 recordsize = _loadInfo->Meta->GetRecordSize(); + + uint32 offsetCount = _header->MaxId - _header->MinId + 1; + uint32 records = 0; + uint32 expandedDataSize = 0; + for (uint32 i = 0; i < offsetCount; ++i) + { + if (offsets[i].FileOffset && offsets[i].RecordSize) + { + ++records; + expandedDataSize += offsets[i].RecordSize; + } + } + + using index_entry_t = char*; + + maxId = _header->MaxId + 1; + indexTable = new index_entry_t[maxId]; + memset(indexTable, 0, maxId * sizeof(index_entry_t)); + + char* dataTable = new char[records * recordsize]; + + // we store flat holders pool as single memory block + std::size_t stringFields = _loadInfo->GetStringFieldCount(false); + std::size_t localizedStringFields = _loadInfo->GetStringFieldCount(true); + + // each string field at load have array of string for each locale + std::size_t stringHoldersRecordPoolSize = localizedStringFields * sizeof(LocalizedString) + (stringFields - localizedStringFields) * sizeof(char*); + std::size_t stringHoldersPoolSize = stringHoldersRecordPoolSize * records; + + char* stringHoldersPool = new char[stringHoldersPoolSize]; + stringPool.push_back(stringHoldersPool); + + // DB2 strings expected to have at least empty string + for (std::size_t i = 0; i < stringHoldersPoolSize / sizeof(char*); ++i) + ((char const**)stringHoldersPool)[i] = nullStr; + + char* stringTable = new char[expandedDataSize - records * ((recordsize - (!_loadInfo->Meta->HasIndexFieldInData() ? 4 : 0)) - stringFields * sizeof(char*))]; + memset(stringTable, 0, expandedDataSize - records * ((recordsize - (!_loadInfo->Meta->HasIndexFieldInData() ? 4 : 0)) - stringFields * sizeof(char*))); + stringPool.push_back(stringTable); + char* stringPtr = stringTable; + + uint32 offset = 0; + uint32 recordNum = 0; + for (uint32 y = 0; y < offsetCount; ++y) + { + unsigned char const* rawRecord = GetRawRecordData(y); + if (!rawRecord) + continue; + + uint32 indexVal = RecordGetId(rawRecord, y); + indexTable[indexVal] = &dataTable[offset]; + + uint32 fieldIndex = 0; + if (!_loadInfo->Meta->HasIndexFieldInData()) + { + *((uint32*)(&dataTable[offset])) = indexVal; + offset += 4; + ++fieldIndex; + } + + uint32 stringFieldOffset = 0; + for (uint32 x = 0; x < _header->FieldCount; ++x) + { + for (uint32 z = 0; z < _loadInfo->Meta->ArraySizes[x]; ++z) + { + switch (_loadInfo->TypesString[fieldIndex]) + { + case FT_FLOAT: + *((float*)(&dataTable[offset])) = RecordGetFloat(rawRecord, x, z); + offset += 4; + break; + case FT_INT: + *((uint32*)(&dataTable[offset])) = RecordGetVarInt(rawRecord, x, z, _loadInfo->Fields[fieldIndex].IsSigned); + offset += 4; + break; + case FT_BYTE: + *((uint8*)(&dataTable[offset])) = RecordGetUInt8(rawRecord, x, z); + offset += 1; + break; + case FT_SHORT: + *((uint16*)(&dataTable[offset])) = RecordGetUInt16(rawRecord, x, z); + offset += 2; + break; + case FT_STRING: + { + LocalizedString** slot = (LocalizedString**)(&dataTable[offset]); + *slot = (LocalizedString*)(&stringHoldersPool[stringHoldersRecordPoolSize * recordNum + stringFieldOffset]); + for (uint32 locale = 0; locale < TOTAL_LOCALES; ++locale) + if (_header->Locale & (1 << locale)) + (*slot)->Str[locale] = stringPtr; + strcpy(stringPtr, RecordGetString(rawRecord, x, z)); + stringPtr += strlen(stringPtr) + 1; + stringFieldOffset += sizeof(LocalizedString); + offset += sizeof(LocalizedString*); + break; + } + case FT_STRING_NOT_LOCALIZED: + { + char const*** slot = (char const***)(&dataTable[offset]); + *slot = (char const**)(&stringHoldersPool[stringHoldersRecordPoolSize * recordNum + stringFieldOffset]); + **slot = stringPtr; + strcpy(stringPtr, RecordGetString(rawRecord, x, z)); + stringPtr += strlen(stringPtr) + 1; + stringFieldOffset += sizeof(char*); + offset += sizeof(char*); + break; + } + default: + ASSERT(false, "Unknown format character '%c' found in %s meta", _loadInfo->TypesString[x], fileName); + break; + } + ++fieldIndex; + } + } + + ++recordNum; + } + + return dataTable; +} + +char* DB2FileLoaderSparseImpl::AutoProduceStrings(char* dataTable, uint32 locale) +{ + if (_loadInfo->Meta->FieldCount != _header->FieldCount) + return nullptr; + + if (!(_header->Locale & (1 << locale))) + { + char const* sep = ""; + std::ostringstream str; + for (uint32 i = 0; i < TOTAL_LOCALES; ++i) + { + if (_header->Locale & (1 << i)) + { + str << sep << localeNames[i]; + sep = ", "; + } + } + + TC_LOG_ERROR("", "Attempted to load %s which has locales %s as %s. Check if you placed your localized db2 files in correct directory.", fileName, str.str().c_str(), localeNames[locale]); + return nullptr; + } + + uint32 offsetCount = _header->MaxId - _header->MinId + 1; + uint32 records = 0; + for (uint32 i = 0; i < offsetCount; ++i) + if (offsets[i].FileOffset && offsets[i].RecordSize) + ++records; + + uint32 recordsize = _loadInfo->Meta->GetRecordSize(); + std::size_t stringFields = _loadInfo->GetStringFieldCount(true); + char* stringTable = new char[_header->StringTableSize - dataStart - records * ((recordsize - (!_loadInfo->Meta->HasIndexFieldInData() ? 4 : 0)) - stringFields * sizeof(char*))]; + memset(stringTable, 0, _header->StringTableSize - dataStart - records * ((recordsize - (!_loadInfo->Meta->HasIndexFieldInData() ? 4 : 0)) - stringFields * sizeof(char*))); + char* stringPtr = stringTable; + + uint32 offset = 0; + + for (uint32 y = 0; y < offsetCount; y++) + { + unsigned char const* rawRecord = GetRawRecordData(y); + if (!rawRecord) + continue; + + uint32 fieldIndex = 0; + if (!_loadInfo->Meta->HasIndexFieldInData()) + { + offset += 4; + ++fieldIndex; + } + + for (uint32 x = 0; x < _header->FieldCount; ++x) + { + for (uint32 z = 0; z < _loadInfo->Meta->ArraySizes[x]; ++z) + { + switch (_loadInfo->TypesString[fieldIndex]) + { + case FT_FLOAT: + offset += 4; + break; + case FT_INT: + offset += 4; + break; + case FT_BYTE: + offset += 1; + break; + case FT_SHORT: + offset += 2; + break; + case FT_STRING: + { + LocalizedString* db2str = *(LocalizedString**)(&dataTable[offset]); + db2str->Str[locale] = stringPtr; + strcpy(stringPtr, RecordGetString(rawRecord, x, z)); + stringPtr += strlen(stringPtr) + 1; + offset += sizeof(char*); + break; + } + case FT_STRING_NOT_LOCALIZED: + offset += sizeof(char*); + break; + default: + ASSERT(false, "Unknown format character '%c' found in %s meta", _loadInfo->TypesString[x], fileName); + break; + } + ++fieldIndex; + } + } + } + + return stringTable; +} + +DB2Record DB2FileLoaderSparseImpl::GetRecord(uint32 recordNumber) const +{ + return DB2Record(*this, recordNumber, _fieldAndArrayOffsets); +} + +DB2RecordCopy DB2FileLoaderSparseImpl::GetRecordCopy(uint32 /*recordId*/) const +{ + return DB2RecordCopy{}; +} + +uint32 DB2FileLoaderSparseImpl::GetRecordCount() const +{ + return _header->MaxId - _header->MinId + 1; +} + +uint32 DB2FileLoaderSparseImpl::GetRecordCopyCount() const +{ + return 0; +} + +unsigned char const* DB2FileLoaderSparseImpl::GetRawRecordData(uint32 recordNumber) const +{ + if (recordNumber > (_header->MaxId - _header->MinId) || !offsets[recordNumber].FileOffset || !offsets[recordNumber].RecordSize) + return nullptr; + + unsigned char const* rawRecord = &data[offsets[recordNumber].FileOffset - dataStart]; + CalculateAndStoreFieldOffsets(rawRecord); + return rawRecord; +} + +uint32 DB2FileLoaderSparseImpl::RecordGetId(unsigned char const* record, uint32 recordIndex) const +{ + if (_loadInfo->Meta->HasIndexFieldInData()) + return RecordGetVarInt(record, _loadInfo->Meta->GetIndexField(), 0, false); + + return _header->MinId + recordIndex; +} + +uint8 DB2FileLoaderSparseImpl::RecordGetUInt8(unsigned char const* record, uint32 field, uint32 arrayIndex) const +{ + ASSERT(field < _header->FieldCount); + ASSERT(GetFieldSize(field) == 1); + return *reinterpret_cast(record + GetFieldOffset(field, arrayIndex)); +} + +uint16 DB2FileLoaderSparseImpl::RecordGetUInt16(unsigned char const* record, uint32 field, uint32 arrayIndex) const +{ + ASSERT(field < _header->FieldCount); + ASSERT(GetFieldSize(field) == 2); + uint16 val = *reinterpret_cast(record + GetFieldOffset(field, arrayIndex)); + EndianConvert(val); + return val; +} + +uint32 DB2FileLoaderSparseImpl::RecordGetUInt32(unsigned char const* record, uint32 field, uint32 arrayIndex) const +{ + return RecordGetVarInt(record, field, arrayIndex, false); +} + +int32 DB2FileLoaderSparseImpl::RecordGetInt32(unsigned char const* record, uint32 field, uint32 arrayIndex) const +{ + return int32(RecordGetVarInt(record, field, arrayIndex, true)); +} + +float DB2FileLoaderSparseImpl::RecordGetFloat(unsigned char const* record, uint32 field, uint32 arrayIndex) const +{ + ASSERT(field < _header->FieldCount); + float val = *reinterpret_cast(record + GetFieldOffset(field, arrayIndex)); + EndianConvert(val); + return val; +} + +char const* DB2FileLoaderSparseImpl::RecordGetString(unsigned char const* record, uint32 field, uint32 arrayIndex) const +{ + ASSERT(field < _header->FieldCount); + return reinterpret_cast(record + GetFieldOffset(field, arrayIndex)); +} + +uint32 DB2FileLoaderSparseImpl::RecordGetVarInt(unsigned char const* record, uint32 field, uint32 arrayIndex, bool isSigned) const +{ + ASSERT(field < _header->FieldCount); + uint32 val = *reinterpret_cast(record + GetFieldOffset(field, arrayIndex)); + EndianConvert(val); + if (isSigned) + return int32(val) << fields[field].UnusedBits >> fields[field].UnusedBits; + + return val << fields[field].UnusedBits >> fields[field].UnusedBits; +} + +uint16 DB2FileLoaderSparseImpl::GetFieldOffset(uint32 field, uint32 arrayIndex) const +{ + return _fieldAndArrayOffsets[_fieldAndArrayOffsets[field] + arrayIndex]; +} + +uint16 DB2FileLoaderSparseImpl::GetFieldSize(uint32 field) const +{ + ASSERT(field < _header->FieldCount); + return 4 - fields[field].UnusedBits / 8; +} + +std::size_t* DB2FileLoaderSparseImpl::RecordCreateDetachedFieldOffsets(std::size_t* oldOffsets) const +{ + if (oldOffsets != _fieldAndArrayOffsets) + return oldOffsets; + + uint32 size = _loadInfo->Meta->FieldCount + _loadInfo->FieldCount - (!_loadInfo->Meta->HasIndexFieldInData() ? 1 : 0); + std::size_t* newOffsets = new std::size_t[size]; + memcpy(newOffsets, _fieldAndArrayOffsets, size * sizeof(std::size_t)); + return newOffsets; +} + +void DB2FileLoaderSparseImpl::RecordDestroyFieldOffsets(std::size_t*& fieldOffsets) const +{ + if (fieldOffsets == _fieldAndArrayOffsets) + return; + + delete[] fieldOffsets; + fieldOffsets = nullptr; +} + +void DB2FileLoaderSparseImpl::CalculateAndStoreFieldOffsets(unsigned char const* rawRecord) const +{ + std::size_t offset = 0; + uint32 combinedField = _loadInfo->Meta->FieldCount; + for (uint32 field = 0; field < _loadInfo->Meta->FieldCount; ++field) + { + _fieldAndArrayOffsets[field] = combinedField; + for (uint32 arr = 0; arr < _loadInfo->Meta->ArraySizes[field]; ++arr) + { + _fieldAndArrayOffsets[combinedField] = offset; + switch (_loadInfo->Meta->Types[field]) + { + case FT_BYTE: + case FT_SHORT: + case FT_INT: + offset += GetFieldSize(field); + break; + case FT_FLOAT: + offset += sizeof(float); + break; + case FT_STRING: + offset += strlen(reinterpret_cast(rawRecord) + offset) + 1; + break; + default: + ASSERT(false, "Unknown format character '%c' found in %s meta", _loadInfo->Meta->Types[field], fileName); + break; + } + ++combinedField; + } + } +} + +uint32 DB2FileLoaderSparseImpl::GetMaxId() const +{ + return _header->MaxId; +} + +DB2Record::DB2Record(DB2FileLoaderImpl const& db2, uint32 recordIndex, std::size_t* fieldOffsets) + : _db2(db2), _recordIndex(recordIndex), _recordData(db2.GetRawRecordData(recordIndex)), _fieldOffsets(fieldOffsets) +{ +} + +DB2Record::~DB2Record() +{ + _db2.RecordDestroyFieldOffsets(_fieldOffsets); +} + +DB2Record::operator bool() +{ + return _recordData != nullptr; +} + +uint32 DB2Record::GetId() const +{ + return _db2.RecordGetId(_recordData, _recordIndex); +} + +uint8 DB2Record::GetUInt8(uint32 field, uint32 arrayIndex) const +{ + return _db2.RecordGetUInt8(_recordData, field, arrayIndex); +} + +uint16 DB2Record::GetUInt16(uint32 field, uint32 arrayIndex) const +{ + return _db2.RecordGetUInt16(_recordData, field, arrayIndex); +} + +uint32 DB2Record::GetUInt32(uint32 field, uint32 arrayIndex) const +{ + return _db2.RecordGetUInt32(_recordData, field, arrayIndex); +} + +int32 DB2Record::GetInt32(uint32 field, uint32 arrayIndex) const +{ + return _db2.RecordGetInt32(_recordData, field, arrayIndex); +} + +float DB2Record::GetFloat(uint32 field, uint32 arrayIndex) const +{ + return _db2.RecordGetFloat(_recordData, field, arrayIndex); +} + +char const* DB2Record::GetString(uint32 field, uint32 arrayIndex) const +{ + return _db2.RecordGetString(_recordData, field, arrayIndex); +} + +void DB2Record::MakePersistent() +{ + _fieldOffsets = _db2.RecordCreateDetachedFieldOffsets(_fieldOffsets); +} + +DB2FileLoader::DB2FileLoader() : _impl(nullptr) +{ +} + +DB2FileLoader::~DB2FileLoader() +{ + delete _impl; +} + +bool DB2FileLoader::Load(DB2FileSource* source, DB2FileLoadInfo const* loadInfo) +{ + if (!source->IsOpen()) + return false; + + if (!source->Read(&_header, sizeof(DB2Header))) + return false; + + EndianConvert(_header.Signature); + EndianConvert(_header.RecordCount); + EndianConvert(_header.FieldCount); + EndianConvert(_header.RecordSize); + EndianConvert(_header.StringTableSize); + EndianConvert(_header.TableHash); + EndianConvert(_header.LayoutHash); + EndianConvert(_header.MinId); + EndianConvert(_header.MaxId); + EndianConvert(_header.Locale); + EndianConvert(_header.CopyTableSize); + EndianConvert(_header.Flags); + EndianConvert(_header.IndexField); + + if (_header.Signature != 0x35424457) //'WDB5' + return false; + + if (_header.LayoutHash != loadInfo->Meta->LayoutHash) + return false; + + if (!(_header.Flags & 0x1)) + _impl = new DB2FileLoaderRegularImpl(); + else + _impl = new DB2FileLoaderSparseImpl(); + + return _impl->Load(source, loadInfo, &_header); +} + +char* DB2FileLoader::AutoProduceData(uint32& count, char**& indexTable, std::vector& stringPool) +{ + return _impl->AutoProduceData(count, indexTable, stringPool); +} + +char* DB2FileLoader::AutoProduceStrings(char* dataTable, uint32 locale) +{ + return _impl->AutoProduceStrings(dataTable, locale); +} + +void DB2FileLoader::AutoProduceRecordCopies(uint32 records, char** indexTable, char* dataTable) +{ + _impl->AutoProduceRecordCopies(records, indexTable, dataTable); +} + +uint32 DB2FileLoader::GetRecordCount() const +{ + return _impl->GetRecordCount(); +} + +uint32 DB2FileLoader::GetRecordCopyCount() const +{ + return _impl->GetRecordCopyCount(); +} + +uint32 DB2FileLoader::GetMaxId() const +{ + return _impl->GetMaxId(); +} + +DB2Record DB2FileLoader::GetRecord(uint32 recordNumber) const +{ + return _impl->GetRecord(recordNumber); +} + +DB2RecordCopy DB2FileLoader::GetRecordCopy(uint32 copyNumber) const +{ + return _impl->GetRecordCopy(copyNumber); +} diff --git a/src/common/DataStores/DB2FileLoader.h b/src/common/DataStores/DB2FileLoader.h new file mode 100644 index 00000000000..a8dd7d27e41 --- /dev/null +++ b/src/common/DataStores/DB2FileLoader.h @@ -0,0 +1,141 @@ +/* + * Copyright (C) 2008-2017 TrinityCore + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with this program. If not, see . + */ + +#ifndef DB2_FILE_LOADER_H +#define DB2_FILE_LOADER_H + +#include "Define.h" +#include +#include + +class DB2FileLoaderImpl; +struct DB2FieldMeta; +struct DB2Meta; + +#pragma pack(push, 1) +struct DB2Header +{ + uint32 Signature; + uint32 RecordCount; + uint32 FieldCount; + uint32 RecordSize; + uint32 StringTableSize; + uint32 TableHash; + uint32 LayoutHash; + uint32 MinId; + uint32 MaxId; + uint32 Locale; + uint32 CopyTableSize; + uint16 Flags; + int16 IndexField; +}; +#pragma pack(pop) + +struct TC_COMMON_API DB2FileLoadInfo +{ + DB2FileLoadInfo(); + DB2FileLoadInfo(DB2FieldMeta const* fields, std::size_t fieldCount, DB2Meta const* meta); + + uint32 GetStringFieldCount(bool localizedOnly) const; + + DB2FieldMeta const* Fields; + std::size_t FieldCount; + DB2Meta const* Meta; + std::string TypesString; +}; + +struct TC_COMMON_API DB2FileSource +{ + virtual ~DB2FileSource(); + + /// + /** + * Returns true when the source is open for reading + */ + virtual bool IsOpen() const = 0; + + // Reads numBytes bytes from source and places them into buffer + // Retu + virtual bool Read(void* buffer, std::size_t numBytes) = 0; + virtual std::size_t GetPosition() const = 0; + virtual char const* GetFileName() const = 0; +}; + +class TC_COMMON_API DB2Record +{ +public: + DB2Record(DB2FileLoaderImpl const& db2, uint32 recordIndex, std::size_t* fieldOffsets); + ~DB2Record(); + + operator bool(); + + uint32 GetId() const; + + uint8 GetUInt8(uint32 field, uint32 arrayIndex) const; + uint16 GetUInt16(uint32 field, uint32 arrayIndex) const; + uint32 GetUInt32(uint32 field, uint32 arrayIndex) const; + int32 GetInt32(uint32 field, uint32 arrayIndex) const; + float GetFloat(uint32 field, uint32 arrayIndex) const; + char const* GetString(uint32 field, uint32 arrayIndex) const; + + // Creates its own heap allocated copy of _fieldOffsets + // by default _fieldOffets point to a shared array inside Loader to avoid heap allocations + // meaning that only one instance of DB2Record has valid offsets if the file is sparse + void MakePersistent(); + +private: + DB2FileLoaderImpl const& _db2; + uint32 _recordIndex; + unsigned char const* _recordData; + std::size_t* _fieldOffsets; +}; + +#pragma pack(push, 1) +struct DB2RecordCopy +{ + uint32 NewRowId = 0; + uint32 SourceRowId = 0; +}; +#pragma pack(pop) + +class TC_COMMON_API DB2FileLoader +{ +public: + DB2FileLoader(); + ~DB2FileLoader(); + + bool Load(DB2FileSource* source, DB2FileLoadInfo const* loadInfo); + char* AutoProduceData(uint32& count, char**& indexTable, std::vector& stringPool); + char* AutoProduceStrings(char* dataTable, uint32 locale); + void AutoProduceRecordCopies(uint32 records, char** indexTable, char* dataTable); + + uint32 GetCols() const { return _header.FieldCount; } + uint32 GetRecordCount() const; + uint32 GetRecordCopyCount() const; + uint32 GetTableHash() const { return _header.TableHash; } + uint32 GetLayoutHash() const { return _header.LayoutHash; } + uint32 GetMaxId() const; + + DB2Record GetRecord(uint32 recordNumber) const; + DB2RecordCopy GetRecordCopy(uint32 copyNumber) const; + +private: + DB2FileLoaderImpl* _impl; + DB2Header _header; +}; + +#endif diff --git a/src/server/game/DataStores/DB2LoadInfo.h b/src/server/game/DataStores/DB2LoadInfo.h index e8e93a0d87e..f17ce912a9b 100644 --- a/src/server/game/DataStores/DB2LoadInfo.h +++ b/src/server/game/DataStores/DB2LoadInfo.h @@ -21,12 +21,12 @@ #ifndef DB2LoadInfo_h__ #define DB2LoadInfo_h__ -#include "DB2StorageLoader.h" +#include "DB2DatabaseLoader.h" #include "DB2Metadata.h" struct AchievementLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -46,13 +46,14 @@ struct AchievementLoadInfo { false, FT_BYTE, "MinimumCriteria" }, { false, FT_INT, "ID" }, }; - return { &fields[0], std::extent::value, AchievementMeta::Instance(), HOTFIX_SEL_ACHIEVEMENT }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, AchievementMeta::Instance(), HOTFIX_SEL_ACHIEVEMENT); + return &loadInfo; } }; struct AnimKitLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -61,13 +62,14 @@ struct AnimKitLoadInfo { false, FT_SHORT, "OneShotStopAnimKitID" }, { false, FT_SHORT, "LowDefAnimKitID" }, }; - return { &fields[0], std::extent::value, AnimKitMeta::Instance(), HOTFIX_SEL_ANIM_KIT }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, AnimKitMeta::Instance(), HOTFIX_SEL_ANIM_KIT); + return &loadInfo; } }; struct AreaGroupMemberLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -75,13 +77,14 @@ struct AreaGroupMemberLoadInfo { false, FT_SHORT, "AreaGroupID" }, { false, FT_SHORT, "AreaID" }, }; - return { &fields[0], std::extent::value, AreaGroupMemberMeta::Instance(), HOTFIX_SEL_AREA_GROUP_MEMBER }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, AreaGroupMemberMeta::Instance(), HOTFIX_SEL_AREA_GROUP_MEMBER); + return &loadInfo; } }; struct AreaTableLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -114,13 +117,14 @@ struct AreaTableLoadInfo { false, FT_BYTE, "WindSettingsID" }, { false, FT_INT, "UWIntroSound" }, }; - return { &fields[0], std::extent::value, AreaTableMeta::Instance(), HOTFIX_SEL_AREA_TABLE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, AreaTableMeta::Instance(), HOTFIX_SEL_AREA_TABLE); + return &loadInfo; } }; struct AreaTriggerLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -142,13 +146,14 @@ struct AreaTriggerLoadInfo { false, FT_BYTE, "Flag" }, { false, FT_INT, "ID" }, }; - return { &fields[0], std::extent::value, AreaTriggerMeta::Instance(), HOTFIX_SEL_AREA_TRIGGER }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, AreaTriggerMeta::Instance(), HOTFIX_SEL_AREA_TRIGGER); + return &loadInfo; } }; struct ArmorLocationLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -159,13 +164,14 @@ struct ArmorLocationLoadInfo { false, FT_FLOAT, "Modifier4" }, { false, FT_FLOAT, "Modifier5" }, }; - return { &fields[0], std::extent::value, ArmorLocationMeta::Instance(), HOTFIX_SEL_ARMOR_LOCATION }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ArmorLocationMeta::Instance(), HOTFIX_SEL_ARMOR_LOCATION); + return &loadInfo; } }; struct ArtifactLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -179,13 +185,14 @@ struct ArtifactLoadInfo { false, FT_BYTE, "ArtifactCategoryID" }, { false, FT_BYTE, "Flags" }, }; - return { &fields[0], std::extent::value, ArtifactMeta::Instance(), HOTFIX_SEL_ARTIFACT }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ArtifactMeta::Instance(), HOTFIX_SEL_ARTIFACT); + return &loadInfo; } }; struct ArtifactAppearanceLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -205,13 +212,14 @@ struct ArtifactAppearanceLoadInfo { false, FT_INT, "ItemAppearanceID" }, { false, FT_INT, "AltItemAppearanceID" }, }; - return { &fields[0], std::extent::value, ArtifactAppearanceMeta::Instance(), HOTFIX_SEL_ARTIFACT_APPEARANCE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ArtifactAppearanceMeta::Instance(), HOTFIX_SEL_ARTIFACT_APPEARANCE); + return &loadInfo; } }; struct ArtifactAppearanceSetLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -225,13 +233,14 @@ struct ArtifactAppearanceSetLoadInfo { false, FT_BYTE, "Flags" }, { false, FT_INT, "ID" }, }; - return { &fields[0], std::extent::value, ArtifactAppearanceSetMeta::Instance(), HOTFIX_SEL_ARTIFACT_APPEARANCE_SET }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ArtifactAppearanceSetMeta::Instance(), HOTFIX_SEL_ARTIFACT_APPEARANCE_SET); + return &loadInfo; } }; struct ArtifactCategoryLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -239,13 +248,14 @@ struct ArtifactCategoryLoadInfo { false, FT_SHORT, "ArtifactKnowledgeCurrencyID" }, { false, FT_SHORT, "ArtifactKnowledgeMultiplierCurveID" }, }; - return { &fields[0], std::extent::value, ArtifactCategoryMeta::Instance(), HOTFIX_SEL_ARTIFACT_CATEGORY }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ArtifactCategoryMeta::Instance(), HOTFIX_SEL_ARTIFACT_CATEGORY); + return &loadInfo; } }; struct ArtifactPowerLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -257,13 +267,14 @@ struct ArtifactPowerLoadInfo { false, FT_INT, "ID" }, { true, FT_INT, "RelicType" }, }; - return { &fields[0], std::extent::value, ArtifactPowerMeta::Instance(), HOTFIX_SEL_ARTIFACT_POWER }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ArtifactPowerMeta::Instance(), HOTFIX_SEL_ARTIFACT_POWER); + return &loadInfo; } }; struct ArtifactPowerLinkLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -271,13 +282,14 @@ struct ArtifactPowerLinkLoadInfo { false, FT_SHORT, "FromArtifactPowerID" }, { false, FT_SHORT, "ToArtifactPowerID" }, }; - return { &fields[0], std::extent::value, ArtifactPowerLinkMeta::Instance(), HOTFIX_SEL_ARTIFACT_POWER_LINK }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ArtifactPowerLinkMeta::Instance(), HOTFIX_SEL_ARTIFACT_POWER_LINK); + return &loadInfo; } }; struct ArtifactPowerRankLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -288,13 +300,14 @@ struct ArtifactPowerRankLoadInfo { false, FT_SHORT, "Unknown" }, { false, FT_BYTE, "Rank" }, }; - return { &fields[0], std::extent::value, ArtifactPowerRankMeta::Instance(), HOTFIX_SEL_ARTIFACT_POWER_RANK }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ArtifactPowerRankMeta::Instance(), HOTFIX_SEL_ARTIFACT_POWER_RANK); + return &loadInfo; } }; struct ArtifactQuestXpLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -310,13 +323,14 @@ struct ArtifactQuestXpLoadInfo { false, FT_INT, "Exp9" }, { false, FT_INT, "Exp10" }, }; - return { &fields[0], std::extent::value, ArtifactQuestXPMeta::Instance(), HOTFIX_SEL_ARTIFACT_QUEST_XP }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ArtifactQuestXPMeta::Instance(), HOTFIX_SEL_ARTIFACT_QUEST_XP); + return &loadInfo; } }; struct AuctionHouseLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -326,26 +340,28 @@ struct AuctionHouseLoadInfo { false, FT_BYTE, "DepositRate" }, { false, FT_BYTE, "ConsignmentRate" }, }; - return { &fields[0], std::extent::value, AuctionHouseMeta::Instance(), HOTFIX_SEL_AUCTION_HOUSE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, AuctionHouseMeta::Instance(), HOTFIX_SEL_AUCTION_HOUSE); + return &loadInfo; } }; struct BankBagSlotPricesLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { { false, FT_INT, "ID" }, { false, FT_INT, "Cost" }, }; - return { &fields[0], std::extent::value, BankBagSlotPricesMeta::Instance(), HOTFIX_SEL_BANK_BAG_SLOT_PRICES }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, BankBagSlotPricesMeta::Instance(), HOTFIX_SEL_BANK_BAG_SLOT_PRICES); + return &loadInfo; } }; struct BannedAddonsLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -354,13 +370,14 @@ struct BannedAddonsLoadInfo { false, FT_STRING_NOT_LOCALIZED, "Version" }, { false, FT_BYTE, "Flags" }, }; - return { &fields[0], std::extent::value, BannedAddOnsMeta::Instance(), HOTFIX_SEL_BANNED_ADDONS }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, BannedAddOnsMeta::Instance(), HOTFIX_SEL_BANNED_ADDONS); + return &loadInfo; } }; struct BarberShopStyleLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -373,13 +390,14 @@ struct BarberShopStyleLoadInfo { false, FT_BYTE, "Data" }, { false, FT_INT, "ID" }, }; - return { &fields[0], std::extent::value, BarberShopStyleMeta::Instance(), HOTFIX_SEL_BARBER_SHOP_STYLE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, BarberShopStyleMeta::Instance(), HOTFIX_SEL_BARBER_SHOP_STYLE); + return &loadInfo; } }; struct BattlePetBreedQualityLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -387,13 +405,14 @@ struct BattlePetBreedQualityLoadInfo { false, FT_FLOAT, "Modifier" }, { false, FT_BYTE, "Quality" }, }; - return { &fields[0], std::extent::value, BattlePetBreedQualityMeta::Instance(), HOTFIX_SEL_BATTLE_PET_BREED_QUALITY }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, BattlePetBreedQualityMeta::Instance(), HOTFIX_SEL_BATTLE_PET_BREED_QUALITY); + return &loadInfo; } }; struct BattlePetBreedStateLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -402,13 +421,14 @@ struct BattlePetBreedStateLoadInfo { false, FT_BYTE, "BreedID" }, { false, FT_BYTE, "State" }, }; - return { &fields[0], std::extent::value, BattlePetBreedStateMeta::Instance(), HOTFIX_SEL_BATTLE_PET_BREED_STATE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, BattlePetBreedStateMeta::Instance(), HOTFIX_SEL_BATTLE_PET_BREED_STATE); + return &loadInfo; } }; struct BattlePetSpeciesLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -422,13 +442,14 @@ struct BattlePetSpeciesLoadInfo { true, FT_BYTE, "Source" }, { false, FT_INT, "ID" }, }; - return { &fields[0], std::extent::value, BattlePetSpeciesMeta::Instance(), HOTFIX_SEL_BATTLE_PET_SPECIES }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, BattlePetSpeciesMeta::Instance(), HOTFIX_SEL_BATTLE_PET_SPECIES); + return &loadInfo; } }; struct BattlePetSpeciesStateLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -437,13 +458,14 @@ struct BattlePetSpeciesStateLoadInfo { false, FT_SHORT, "SpeciesID" }, { false, FT_BYTE, "State" }, }; - return { &fields[0], std::extent::value, BattlePetSpeciesStateMeta::Instance(), HOTFIX_SEL_BATTLE_PET_SPECIES_STATE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, BattlePetSpeciesStateMeta::Instance(), HOTFIX_SEL_BATTLE_PET_SPECIES_STATE); + return &loadInfo; } }; struct BattlemasterListLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -479,13 +501,14 @@ struct BattlemasterListLoadInfo { false, FT_BYTE, "MaxPlayers" }, { false, FT_BYTE, "Flags" }, }; - return { &fields[0], std::extent::value, BattlemasterListMeta::Instance(), HOTFIX_SEL_BATTLEMASTER_LIST }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, BattlemasterListMeta::Instance(), HOTFIX_SEL_BATTLEMASTER_LIST); + return &loadInfo; } }; struct BroadcastTextLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -505,13 +528,14 @@ struct BroadcastTextLoadInfo { false, FT_INT, "SoundID2" }, { false, FT_INT, "PlayerConditionID" }, }; - return { &fields[0], std::extent::value, BroadcastTextMeta::Instance(), HOTFIX_SEL_BROADCAST_TEXT }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, BroadcastTextMeta::Instance(), HOTFIX_SEL_BROADCAST_TEXT); + return &loadInfo; } }; struct CharSectionsLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -526,13 +550,14 @@ struct CharSectionsLoadInfo { false, FT_BYTE, "Type" }, { false, FT_BYTE, "Color" }, }; - return { &fields[0], std::extent::value, CharSectionsMeta::Instance(), HOTFIX_SEL_CHAR_SECTIONS }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, CharSectionsMeta::Instance(), HOTFIX_SEL_CHAR_SECTIONS); + return &loadInfo; } }; struct CharStartOutfitLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -568,13 +593,14 @@ struct CharStartOutfitLoadInfo { false, FT_BYTE, "OutfitID" }, { false, FT_BYTE, "PetFamilyID" }, }; - return { &fields[0], std::extent::value, CharStartOutfitMeta::Instance(), HOTFIX_SEL_CHAR_START_OUTFIT }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, CharStartOutfitMeta::Instance(), HOTFIX_SEL_CHAR_START_OUTFIT); + return &loadInfo; } }; struct CharTitlesLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -584,13 +610,14 @@ struct CharTitlesLoadInfo { false, FT_SHORT, "MaskID" }, { false, FT_BYTE, "Flags" }, }; - return { &fields[0], std::extent::value, CharTitlesMeta::Instance(), HOTFIX_SEL_CHAR_TITLES }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, CharTitlesMeta::Instance(), HOTFIX_SEL_CHAR_TITLES); + return &loadInfo; } }; struct ChatChannelsLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -600,13 +627,14 @@ struct ChatChannelsLoadInfo { false, FT_STRING, "Shortcut" }, { false, FT_BYTE, "FactionGroup" }, }; - return { &fields[0], std::extent::value, ChatChannelsMeta::Instance(), HOTFIX_SEL_CHAT_CHANNELS }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ChatChannelsMeta::Instance(), HOTFIX_SEL_CHAT_CHANNELS); + return &loadInfo; } }; struct ChrClassesLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -630,13 +658,14 @@ struct ChrClassesLoadInfo { false, FT_BYTE, "Unk1" }, { false, FT_INT, "ID" }, }; - return { &fields[0], std::extent::value, ChrClassesMeta::Instance(), HOTFIX_SEL_CHR_CLASSES }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ChrClassesMeta::Instance(), HOTFIX_SEL_CHR_CLASSES); + return &loadInfo; } }; struct ChrClassesXPowerTypesLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -644,13 +673,14 @@ struct ChrClassesXPowerTypesLoadInfo { false, FT_BYTE, "ClassID" }, { false, FT_BYTE, "PowerType" }, }; - return { &fields[0], std::extent::value, ChrClassesXPowerTypesMeta::Instance(), HOTFIX_SEL_CHR_CLASSES_X_POWER_TYPES }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ChrClassesXPowerTypesMeta::Instance(), HOTFIX_SEL_CHR_CLASSES_X_POWER_TYPES); + return &loadInfo; } }; struct ChrRacesLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -698,13 +728,14 @@ struct ChrRacesLoadInfo { false, FT_INT, "Unk2" }, { false, FT_INT, "Unk3" }, }; - return { &fields[0], std::extent::value, ChrRacesMeta::Instance(), HOTFIX_SEL_CHR_RACES }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ChrRacesMeta::Instance(), HOTFIX_SEL_CHR_RACES); + return &loadInfo; } }; struct ChrSpecializationLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -723,13 +754,14 @@ struct ChrSpecializationLoadInfo { false, FT_INT, "Flags" }, { false, FT_INT, "AnimReplacementSetID" }, }; - return { &fields[0], std::extent::value, ChrSpecializationMeta::Instance(), HOTFIX_SEL_CHR_SPECIALIZATION }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ChrSpecializationMeta::Instance(), HOTFIX_SEL_CHR_SPECIALIZATION); + return &loadInfo; } }; struct CinematicCameraLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -741,13 +773,14 @@ struct CinematicCameraLoadInfo { false, FT_FLOAT, "OriginFacing" }, { false, FT_SHORT, "SoundID" }, }; - return { &fields[0], std::extent::value, CinematicCameraMeta::Instance(), HOTFIX_SEL_CINEMATIC_CAMERA }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, CinematicCameraMeta::Instance(), HOTFIX_SEL_CINEMATIC_CAMERA); + return &loadInfo; } }; struct CinematicSequencesLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -762,13 +795,14 @@ struct CinematicSequencesLoadInfo { false, FT_SHORT, "Camera7" }, { false, FT_SHORT, "Camera8" }, }; - return { &fields[0], std::extent::value, CinematicSequencesMeta::Instance(), HOTFIX_SEL_CINEMATIC_SEQUENCES }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, CinematicSequencesMeta::Instance(), HOTFIX_SEL_CINEMATIC_SEQUENCES); + return &loadInfo; } }; struct CreatureDisplayInfoLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -797,13 +831,14 @@ struct CreatureDisplayInfoLoadInfo { true, FT_BYTE, "Gender" }, { true, FT_BYTE, "Unk700" }, }; - return { &fields[0], std::extent::value, CreatureDisplayInfoMeta::Instance(), HOTFIX_SEL_CREATURE_DISPLAY_INFO }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, CreatureDisplayInfoMeta::Instance(), HOTFIX_SEL_CREATURE_DISPLAY_INFO); + return &loadInfo; } }; struct CreatureDisplayInfoExtraLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -823,13 +858,14 @@ struct CreatureDisplayInfoExtraLoadInfo { false, FT_BYTE, "CustomDisplayOption3" }, { false, FT_BYTE, "Flags" }, }; - return { &fields[0], std::extent::value, CreatureDisplayInfoExtraMeta::Instance(), HOTFIX_SEL_CREATURE_DISPLAY_INFO_EXTRA }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, CreatureDisplayInfoExtraMeta::Instance(), HOTFIX_SEL_CREATURE_DISPLAY_INFO_EXTRA); + return &loadInfo; } }; struct CreatureFamilyLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -845,13 +881,14 @@ struct CreatureFamilyLoadInfo { false, FT_BYTE, "MaxScaleLevel" }, { false, FT_BYTE, "PetTalentType" }, }; - return { &fields[0], std::extent::value, CreatureFamilyMeta::Instance(), HOTFIX_SEL_CREATURE_FAMILY }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, CreatureFamilyMeta::Instance(), HOTFIX_SEL_CREATURE_FAMILY); + return &loadInfo; } }; struct CreatureModelDataLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -890,13 +927,14 @@ struct CreatureModelDataLoadInfo { false, FT_INT, "SoundID" }, { false, FT_INT, "CreatureGeosetDataID" }, }; - return { &fields[0], std::extent::value, CreatureModelDataMeta::Instance(), HOTFIX_SEL_CREATURE_MODEL_DATA }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, CreatureModelDataMeta::Instance(), HOTFIX_SEL_CREATURE_MODEL_DATA); + return &loadInfo; } }; struct CreatureTypeLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -904,13 +942,14 @@ struct CreatureTypeLoadInfo { false, FT_STRING, "Name" }, { false, FT_BYTE, "Flags" }, }; - return { &fields[0], std::extent::value, CreatureTypeMeta::Instance(), HOTFIX_SEL_CREATURE_TYPE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, CreatureTypeMeta::Instance(), HOTFIX_SEL_CREATURE_TYPE); + return &loadInfo; } }; struct CriteriaLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -927,13 +966,14 @@ struct CriteriaLoadInfo { false, FT_BYTE, "Flags" }, { false, FT_BYTE, "EligibilityWorldStateValue" }, }; - return { &fields[0], std::extent::value, CriteriaMeta::Instance(), HOTFIX_SEL_CRITERIA }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, CriteriaMeta::Instance(), HOTFIX_SEL_CRITERIA); + return &loadInfo; } }; struct CriteriaTreeLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -946,13 +986,14 @@ struct CriteriaTreeLoadInfo { false, FT_BYTE, "Operator" }, { true, FT_INT, "OrderIndex" }, }; - return { &fields[0], std::extent::value, CriteriaTreeMeta::Instance(), HOTFIX_SEL_CRITERIA_TREE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, CriteriaTreeMeta::Instance(), HOTFIX_SEL_CRITERIA_TREE); + return &loadInfo; } }; struct CurrencyTypesLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -969,13 +1010,14 @@ struct CurrencyTypesLoadInfo { false, FT_BYTE, "Quality" }, { false, FT_INT, "SpellWeight" }, }; - return { &fields[0], std::extent::value, CurrencyTypesMeta::Instance(), HOTFIX_SEL_CURRENCY_TYPES }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, CurrencyTypesMeta::Instance(), HOTFIX_SEL_CURRENCY_TYPES); + return &loadInfo; } }; struct CurveLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -983,13 +1025,14 @@ struct CurveLoadInfo { false, FT_BYTE, "Type" }, { false, FT_BYTE, "Unused" }, }; - return { &fields[0], std::extent::value, CurveMeta::Instance(), HOTFIX_SEL_CURVE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, CurveMeta::Instance(), HOTFIX_SEL_CURVE); + return &loadInfo; } }; struct CurvePointLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -999,13 +1042,14 @@ struct CurvePointLoadInfo { false, FT_SHORT, "CurveID" }, { false, FT_BYTE, "Index" }, }; - return { &fields[0], std::extent::value, CurvePointMeta::Instance(), HOTFIX_SEL_CURVE_POINT }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, CurvePointMeta::Instance(), HOTFIX_SEL_CURVE_POINT); + return &loadInfo; } }; struct DestructibleModelDataLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1033,13 +1077,14 @@ struct DestructibleModelDataLoadInfo { false, FT_BYTE, "DoNotHighlight" }, { false, FT_BYTE, "HealEffect" }, }; - return { &fields[0], std::extent::value, DestructibleModelDataMeta::Instance(), HOTFIX_SEL_DESTRUCTIBLE_MODEL_DATA }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, DestructibleModelDataMeta::Instance(), HOTFIX_SEL_DESTRUCTIBLE_MODEL_DATA); + return &loadInfo; } }; struct DifficultyLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1058,13 +1103,14 @@ struct DifficultyLoadInfo { false, FT_BYTE, "ItemBonusTreeModID" }, { false, FT_BYTE, "OrderIndex" }, }; - return { &fields[0], std::extent::value, DifficultyMeta::Instance(), HOTFIX_SEL_DIFFICULTY }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, DifficultyMeta::Instance(), HOTFIX_SEL_DIFFICULTY); + return &loadInfo; } }; struct DungeonEncounterLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1078,13 +1124,14 @@ struct DungeonEncounterLoadInfo { false, FT_BYTE, "Flags" }, { true, FT_INT, "OrderIndex" }, }; - return { &fields[0], std::extent::value, DungeonEncounterMeta::Instance(), HOTFIX_SEL_DUNGEON_ENCOUNTER }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, DungeonEncounterMeta::Instance(), HOTFIX_SEL_DUNGEON_ENCOUNTER); + return &loadInfo; } }; struct DurabilityCostsLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1119,26 +1166,28 @@ struct DurabilityCostsLoadInfo { false, FT_SHORT, "ArmorSubClassCost7" }, { false, FT_SHORT, "ArmorSubClassCost8" }, }; - return { &fields[0], std::extent::value, DurabilityCostsMeta::Instance(), HOTFIX_SEL_DURABILITY_COSTS }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, DurabilityCostsMeta::Instance(), HOTFIX_SEL_DURABILITY_COSTS); + return &loadInfo; } }; struct DurabilityQualityLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { { false, FT_INT, "ID" }, { false, FT_FLOAT, "QualityMod" }, }; - return { &fields[0], std::extent::value, DurabilityQualityMeta::Instance(), HOTFIX_SEL_DURABILITY_QUALITY }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, DurabilityQualityMeta::Instance(), HOTFIX_SEL_DURABILITY_QUALITY); + return &loadInfo; } }; struct EmotesLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1153,13 +1202,14 @@ struct EmotesLoadInfo { true, FT_INT, "ClassMask" }, { true, FT_INT, "RaceMask" }, }; - return { &fields[0], std::extent::value, EmotesMeta::Instance(), HOTFIX_SEL_EMOTES }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, EmotesMeta::Instance(), HOTFIX_SEL_EMOTES); + return &loadInfo; } }; struct EmotesTextLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1167,13 +1217,14 @@ struct EmotesTextLoadInfo { false, FT_STRING, "Name" }, { false, FT_SHORT, "EmoteID" }, }; - return { &fields[0], std::extent::value, EmotesTextMeta::Instance(), HOTFIX_SEL_EMOTES_TEXT }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, EmotesTextMeta::Instance(), HOTFIX_SEL_EMOTES_TEXT); + return &loadInfo; } }; struct EmotesTextSoundLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1184,13 +1235,14 @@ struct EmotesTextSoundLoadInfo { false, FT_BYTE, "ClassId" }, { false, FT_INT, "SoundId" }, }; - return { &fields[0], std::extent::value, EmotesTextSoundMeta::Instance(), HOTFIX_SEL_EMOTES_TEXT_SOUND }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, EmotesTextSoundMeta::Instance(), HOTFIX_SEL_EMOTES_TEXT_SOUND); + return &loadInfo; } }; struct FactionLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1227,13 +1279,14 @@ struct FactionLoadInfo { false, FT_BYTE, "Flags" }, { false, FT_BYTE, "FriendshipRepID" }, }; - return { &fields[0], std::extent::value, FactionMeta::Instance(), HOTFIX_SEL_FACTION }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, FactionMeta::Instance(), HOTFIX_SEL_FACTION); + return &loadInfo; } }; struct FactionTemplateLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1252,13 +1305,14 @@ struct FactionTemplateLoadInfo { false, FT_BYTE, "FriendMask" }, { false, FT_BYTE, "EnemyMask" }, }; - return { &fields[0], std::extent::value, FactionTemplateMeta::Instance(), HOTFIX_SEL_FACTION_TEMPLATE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, FactionTemplateMeta::Instance(), HOTFIX_SEL_FACTION_TEMPLATE); + return &loadInfo; } }; struct GameobjectsLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1287,13 +1341,14 @@ struct GameobjectsLoadInfo { false, FT_BYTE, "Type" }, { false, FT_INT, "ID" }, }; - return { &fields[0], std::extent::value, GameObjectsMeta::Instance(), HOTFIX_SEL_GAMEOBJECTS }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, GameObjectsMeta::Instance(), HOTFIX_SEL_GAMEOBJECTS); + return &loadInfo; } }; struct GameobjectDisplayInfoLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1309,13 +1364,14 @@ struct GameobjectDisplayInfoLoadInfo { false, FT_FLOAT, "OverrideNameScale" }, { false, FT_SHORT, "ObjectEffectPackageID" }, }; - return { &fields[0], std::extent::value, GameObjectDisplayInfoMeta::Instance(), HOTFIX_SEL_GAMEOBJECT_DISPLAY_INFO }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, GameObjectDisplayInfoMeta::Instance(), HOTFIX_SEL_GAMEOBJECT_DISPLAY_INFO); + return &loadInfo; } }; struct GarrAbilityLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1328,13 +1384,14 @@ struct GarrAbilityLoadInfo { false, FT_BYTE, "FollowerTypeID" }, { false, FT_INT, "ID" }, }; - return { &fields[0], std::extent::value, GarrAbilityMeta::Instance(), HOTFIX_SEL_GARR_ABILITY }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, GarrAbilityMeta::Instance(), HOTFIX_SEL_GARR_ABILITY); + return &loadInfo; } }; struct GarrBuildingLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1364,13 +1421,14 @@ struct GarrBuildingLoadInfo { true, FT_INT, "CostCurrencyAmount" }, { true, FT_INT, "BonusAmount" }, }; - return { &fields[0], std::extent::value, GarrBuildingMeta::Instance(), HOTFIX_SEL_GARR_BUILDING }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, GarrBuildingMeta::Instance(), HOTFIX_SEL_GARR_BUILDING); + return &loadInfo; } }; struct GarrBuildingPlotInstLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1381,13 +1439,14 @@ struct GarrBuildingPlotInstLoadInfo { false, FT_BYTE, "GarrBuildingID" }, { false, FT_INT, "ID" }, }; - return { &fields[0], std::extent::value, GarrBuildingPlotInstMeta::Instance(), HOTFIX_SEL_GARR_BUILDING_PLOT_INST }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, GarrBuildingPlotInstMeta::Instance(), HOTFIX_SEL_GARR_BUILDING_PLOT_INST); + return &loadInfo; } }; struct GarrClassSpecLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1400,13 +1459,14 @@ struct GarrClassSpecLoadInfo { false, FT_BYTE, "Flags" }, { false, FT_INT, "ID" }, }; - return { &fields[0], std::extent::value, GarrClassSpecMeta::Instance(), HOTFIX_SEL_GARR_CLASS_SPEC }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, GarrClassSpecMeta::Instance(), HOTFIX_SEL_GARR_CLASS_SPEC); + return &loadInfo; } }; struct GarrFollowerLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1442,13 +1502,14 @@ struct GarrFollowerLoadInfo { false, FT_BYTE, "AllianceFlavorTextGarrStringID" }, { false, FT_INT, "ID" }, }; - return { &fields[0], std::extent::value, GarrFollowerMeta::Instance(), HOTFIX_SEL_GARR_FOLLOWER }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, GarrFollowerMeta::Instance(), HOTFIX_SEL_GARR_FOLLOWER); + return &loadInfo; } }; struct GarrFollowerXAbilityLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1457,13 +1518,14 @@ struct GarrFollowerXAbilityLoadInfo { false, FT_SHORT, "GarrAbilityID" }, { false, FT_BYTE, "FactionIndex" }, }; - return { &fields[0], std::extent::value, GarrFollowerXAbilityMeta::Instance(), HOTFIX_SEL_GARR_FOLLOWER_X_ABILITY }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, GarrFollowerXAbilityMeta::Instance(), HOTFIX_SEL_GARR_FOLLOWER_X_ABILITY); + return &loadInfo; } }; struct GarrPlotLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1477,13 +1539,14 @@ struct GarrPlotLoadInfo { false, FT_INT, "MinCount" }, { false, FT_INT, "MaxCount" }, }; - return { &fields[0], std::extent::value, GarrPlotMeta::Instance(), HOTFIX_SEL_GARR_PLOT }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, GarrPlotMeta::Instance(), HOTFIX_SEL_GARR_PLOT); + return &loadInfo; } }; struct GarrPlotBuildingLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1491,13 +1554,14 @@ struct GarrPlotBuildingLoadInfo { false, FT_BYTE, "GarrPlotID" }, { false, FT_BYTE, "GarrBuildingID" }, }; - return { &fields[0], std::extent::value, GarrPlotBuildingMeta::Instance(), HOTFIX_SEL_GARR_PLOT_BUILDING }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, GarrPlotBuildingMeta::Instance(), HOTFIX_SEL_GARR_PLOT_BUILDING); + return &loadInfo; } }; struct GarrPlotInstanceLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1505,13 +1569,14 @@ struct GarrPlotInstanceLoadInfo { false, FT_STRING, "Name" }, { false, FT_BYTE, "GarrPlotID" }, }; - return { &fields[0], std::extent::value, GarrPlotInstanceMeta::Instance(), HOTFIX_SEL_GARR_PLOT_INSTANCE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, GarrPlotInstanceMeta::Instance(), HOTFIX_SEL_GARR_PLOT_INSTANCE); + return &loadInfo; } }; struct GarrSiteLevelLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1527,13 +1592,14 @@ struct GarrSiteLevelLoadInfo { false, FT_BYTE, "MovieID" }, { false, FT_BYTE, "Level2" }, }; - return { &fields[0], std::extent::value, GarrSiteLevelMeta::Instance(), HOTFIX_SEL_GARR_SITE_LEVEL }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, GarrSiteLevelMeta::Instance(), HOTFIX_SEL_GARR_SITE_LEVEL); + return &loadInfo; } }; struct GarrSiteLevelPlotInstLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1544,13 +1610,14 @@ struct GarrSiteLevelPlotInstLoadInfo { false, FT_BYTE, "GarrPlotInstanceID" }, { false, FT_BYTE, "Unknown" }, }; - return { &fields[0], std::extent::value, GarrSiteLevelPlotInstMeta::Instance(), HOTFIX_SEL_GARR_SITE_LEVEL_PLOT_INST }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, GarrSiteLevelPlotInstMeta::Instance(), HOTFIX_SEL_GARR_SITE_LEVEL_PLOT_INST); + return &loadInfo; } }; struct GemPropertiesLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1559,13 +1626,14 @@ struct GemPropertiesLoadInfo { false, FT_SHORT, "EnchantID" }, { false, FT_SHORT, "MinItemLevel" }, }; - return { &fields[0], std::extent::value, GemPropertiesMeta::Instance(), HOTFIX_SEL_GEM_PROPERTIES }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, GemPropertiesMeta::Instance(), HOTFIX_SEL_GEM_PROPERTIES); + return &loadInfo; } }; struct GlyphBindableSpellLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1573,13 +1641,14 @@ struct GlyphBindableSpellLoadInfo { false, FT_INT, "SpellID" }, { false, FT_SHORT, "GlyphPropertiesID" }, }; - return { &fields[0], std::extent::value, GlyphBindableSpellMeta::Instance(), HOTFIX_SEL_GLYPH_BINDABLE_SPELL }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, GlyphBindableSpellMeta::Instance(), HOTFIX_SEL_GLYPH_BINDABLE_SPELL); + return &loadInfo; } }; struct GlyphPropertiesLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1589,13 +1658,14 @@ struct GlyphPropertiesLoadInfo { false, FT_BYTE, "Type" }, { false, FT_BYTE, "GlyphExclusiveCategoryID" }, }; - return { &fields[0], std::extent::value, GlyphPropertiesMeta::Instance(), HOTFIX_SEL_GLYPH_PROPERTIES }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, GlyphPropertiesMeta::Instance(), HOTFIX_SEL_GLYPH_PROPERTIES); + return &loadInfo; } }; struct GlyphRequiredSpecLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1603,13 +1673,14 @@ struct GlyphRequiredSpecLoadInfo { false, FT_SHORT, "GlyphPropertiesID" }, { false, FT_SHORT, "ChrSpecializationID" }, }; - return { &fields[0], std::extent::value, GlyphRequiredSpecMeta::Instance(), HOTFIX_SEL_GLYPH_REQUIRED_SPEC }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, GlyphRequiredSpecMeta::Instance(), HOTFIX_SEL_GLYPH_REQUIRED_SPEC); + return &loadInfo; } }; struct GuildColorBackgroundLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1618,13 +1689,14 @@ struct GuildColorBackgroundLoadInfo { false, FT_BYTE, "Green" }, { false, FT_BYTE, "Blue" }, }; - return { &fields[0], std::extent::value, GuildColorBackgroundMeta::Instance(), HOTFIX_SEL_GUILD_COLOR_BACKGROUND }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, GuildColorBackgroundMeta::Instance(), HOTFIX_SEL_GUILD_COLOR_BACKGROUND); + return &loadInfo; } }; struct GuildColorBorderLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1633,13 +1705,14 @@ struct GuildColorBorderLoadInfo { false, FT_BYTE, "Green" }, { false, FT_BYTE, "Blue" }, }; - return { &fields[0], std::extent::value, GuildColorBorderMeta::Instance(), HOTFIX_SEL_GUILD_COLOR_BORDER }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, GuildColorBorderMeta::Instance(), HOTFIX_SEL_GUILD_COLOR_BORDER); + return &loadInfo; } }; struct GuildColorEmblemLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1648,26 +1721,28 @@ struct GuildColorEmblemLoadInfo { false, FT_BYTE, "Green" }, { false, FT_BYTE, "Blue" }, }; - return { &fields[0], std::extent::value, GuildColorEmblemMeta::Instance(), HOTFIX_SEL_GUILD_COLOR_EMBLEM }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, GuildColorEmblemMeta::Instance(), HOTFIX_SEL_GUILD_COLOR_EMBLEM); + return &loadInfo; } }; struct GuildPerkSpellsLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { { false, FT_INT, "ID" }, { false, FT_INT, "SpellID" }, }; - return { &fields[0], std::extent::value, GuildPerkSpellsMeta::Instance(), HOTFIX_SEL_GUILD_PERK_SPELLS }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, GuildPerkSpellsMeta::Instance(), HOTFIX_SEL_GUILD_PERK_SPELLS); + return &loadInfo; } }; struct HeirloomLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1684,13 +1759,14 @@ struct HeirloomLoadInfo { false, FT_BYTE, "Source" }, { false, FT_INT, "ID" }, }; - return { &fields[0], std::extent::value, HeirloomMeta::Instance(), HOTFIX_SEL_HEIRLOOM }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, HeirloomMeta::Instance(), HOTFIX_SEL_HEIRLOOM); + return &loadInfo; } }; struct HolidaysLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1740,13 +1816,14 @@ struct HolidaysLoadInfo { true, FT_BYTE, "CalendarFilterType" }, { false, FT_BYTE, "Flags" }, }; - return { &fields[0], std::extent::value, HolidaysMeta::Instance(), HOTFIX_SEL_HOLIDAYS }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, HolidaysMeta::Instance(), HOTFIX_SEL_HOLIDAYS); + return &loadInfo; } }; struct ImportPriceArmorLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1756,52 +1833,56 @@ struct ImportPriceArmorLoadInfo { false, FT_FLOAT, "MailFactor" }, { false, FT_FLOAT, "PlateFactor" }, }; - return { &fields[0], std::extent::value, ImportPriceArmorMeta::Instance(), HOTFIX_SEL_IMPORT_PRICE_ARMOR }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ImportPriceArmorMeta::Instance(), HOTFIX_SEL_IMPORT_PRICE_ARMOR); + return &loadInfo; } }; struct ImportPriceQualityLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { { false, FT_INT, "ID" }, { false, FT_FLOAT, "Factor" }, }; - return { &fields[0], std::extent::value, ImportPriceQualityMeta::Instance(), HOTFIX_SEL_IMPORT_PRICE_QUALITY }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ImportPriceQualityMeta::Instance(), HOTFIX_SEL_IMPORT_PRICE_QUALITY); + return &loadInfo; } }; struct ImportPriceShieldLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { { false, FT_INT, "ID" }, { false, FT_FLOAT, "Factor" }, }; - return { &fields[0], std::extent::value, ImportPriceShieldMeta::Instance(), HOTFIX_SEL_IMPORT_PRICE_SHIELD }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ImportPriceShieldMeta::Instance(), HOTFIX_SEL_IMPORT_PRICE_SHIELD); + return &loadInfo; } }; struct ImportPriceWeaponLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { { false, FT_INT, "ID" }, { false, FT_FLOAT, "Factor" }, }; - return { &fields[0], std::extent::value, ImportPriceWeaponMeta::Instance(), HOTFIX_SEL_IMPORT_PRICE_WEAPON }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ImportPriceWeaponMeta::Instance(), HOTFIX_SEL_IMPORT_PRICE_WEAPON); + return &loadInfo; } }; struct ItemLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1815,13 +1896,14 @@ struct ItemLoadInfo { false, FT_BYTE, "Sheath" }, { false, FT_BYTE, "GroupSoundsID" }, }; - return { &fields[0], std::extent::value, ItemMeta::Instance(), HOTFIX_SEL_ITEM }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemMeta::Instance(), HOTFIX_SEL_ITEM); + return &loadInfo; } }; struct ItemAppearanceLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1831,13 +1913,14 @@ struct ItemAppearanceLoadInfo { false, FT_INT, "UIOrder" }, { false, FT_BYTE, "ObjectComponentSlot" }, }; - return { &fields[0], std::extent::value, ItemAppearanceMeta::Instance(), HOTFIX_SEL_ITEM_APPEARANCE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemAppearanceMeta::Instance(), HOTFIX_SEL_ITEM_APPEARANCE); + return &loadInfo; } }; struct ItemArmorQualityLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1851,13 +1934,14 @@ struct ItemArmorQualityLoadInfo { false, FT_FLOAT, "QualityMod7" }, { false, FT_SHORT, "ItemLevel" }, }; - return { &fields[0], std::extent::value, ItemArmorQualityMeta::Instance(), HOTFIX_SEL_ITEM_ARMOR_QUALITY }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemArmorQualityMeta::Instance(), HOTFIX_SEL_ITEM_ARMOR_QUALITY); + return &loadInfo; } }; struct ItemArmorShieldLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1871,13 +1955,14 @@ struct ItemArmorShieldLoadInfo { false, FT_FLOAT, "Quality7" }, { false, FT_SHORT, "ItemLevel" }, }; - return { &fields[0], std::extent::value, ItemArmorShieldMeta::Instance(), HOTFIX_SEL_ITEM_ARMOR_SHIELD }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemArmorShieldMeta::Instance(), HOTFIX_SEL_ITEM_ARMOR_SHIELD); + return &loadInfo; } }; struct ItemArmorTotalLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1888,26 +1973,28 @@ struct ItemArmorTotalLoadInfo { false, FT_FLOAT, "Value4" }, { false, FT_SHORT, "ItemLevel" }, }; - return { &fields[0], std::extent::value, ItemArmorTotalMeta::Instance(), HOTFIX_SEL_ITEM_ARMOR_TOTAL }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemArmorTotalMeta::Instance(), HOTFIX_SEL_ITEM_ARMOR_TOTAL); + return &loadInfo; } }; struct ItemBagFamilyLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { { false, FT_INT, "ID" }, { false, FT_STRING, "Name" }, }; - return { &fields[0], std::extent::value, ItemBagFamilyMeta::Instance(), HOTFIX_SEL_ITEM_BAG_FAMILY }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemBagFamilyMeta::Instance(), HOTFIX_SEL_ITEM_BAG_FAMILY); + return &loadInfo; } }; struct ItemBonusLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1918,26 +2005,28 @@ struct ItemBonusLoadInfo { false, FT_BYTE, "Type" }, { false, FT_BYTE, "Index" }, }; - return { &fields[0], std::extent::value, ItemBonusMeta::Instance(), HOTFIX_SEL_ITEM_BONUS }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemBonusMeta::Instance(), HOTFIX_SEL_ITEM_BONUS); + return &loadInfo; } }; struct ItemBonusListLevelDeltaLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { { true, FT_SHORT, "Delta" }, { false, FT_INT, "ID" }, }; - return { &fields[0], std::extent::value, ItemBonusListLevelDeltaMeta::Instance(), HOTFIX_SEL_ITEM_BONUS_LIST_LEVEL_DELTA }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemBonusListLevelDeltaMeta::Instance(), HOTFIX_SEL_ITEM_BONUS_LIST_LEVEL_DELTA); + return &loadInfo; } }; struct ItemBonusTreeNodeLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1947,13 +2036,14 @@ struct ItemBonusTreeNodeLoadInfo { false, FT_SHORT, "BonusListID" }, { false, FT_BYTE, "BonusTreeModID" }, }; - return { &fields[0], std::extent::value, ItemBonusTreeNodeMeta::Instance(), HOTFIX_SEL_ITEM_BONUS_TREE_NODE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemBonusTreeNodeMeta::Instance(), HOTFIX_SEL_ITEM_BONUS_TREE_NODE); + return &loadInfo; } }; struct ItemChildEquipmentLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1962,13 +2052,14 @@ struct ItemChildEquipmentLoadInfo { false, FT_INT, "AltItemID" }, { false, FT_BYTE, "AltEquipmentSlot" }, }; - return { &fields[0], std::extent::value, ItemChildEquipmentMeta::Instance(), HOTFIX_SEL_ITEM_CHILD_EQUIPMENT }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemChildEquipmentMeta::Instance(), HOTFIX_SEL_ITEM_CHILD_EQUIPMENT); + return &loadInfo; } }; struct ItemClassLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -1978,26 +2069,28 @@ struct ItemClassLoadInfo { false, FT_BYTE, "OldEnumValue" }, { false, FT_BYTE, "Flags" }, }; - return { &fields[0], std::extent::value, ItemClassMeta::Instance(), HOTFIX_SEL_ITEM_CLASS }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemClassMeta::Instance(), HOTFIX_SEL_ITEM_CLASS); + return &loadInfo; } }; struct ItemCurrencyCostLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { { false, FT_INT, "ID" }, { false, FT_INT, "ItemId" }, }; - return { &fields[0], std::extent::value, ItemCurrencyCostMeta::Instance(), HOTFIX_SEL_ITEM_CURRENCY_COST }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemCurrencyCostMeta::Instance(), HOTFIX_SEL_ITEM_CURRENCY_COST); + return &loadInfo; } }; struct ItemDamageAmmoLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2011,13 +2104,14 @@ struct ItemDamageAmmoLoadInfo { false, FT_FLOAT, "DPS7" }, { false, FT_SHORT, "ItemLevel" }, }; - return { &fields[0], std::extent::value, ItemDamageAmmoMeta::Instance(), HOTFIX_SEL_ITEM_DAMAGE_AMMO }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemDamageAmmoMeta::Instance(), HOTFIX_SEL_ITEM_DAMAGE_AMMO); + return &loadInfo; } }; struct ItemDamageOneHandLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2031,13 +2125,14 @@ struct ItemDamageOneHandLoadInfo { false, FT_FLOAT, "DPS7" }, { false, FT_SHORT, "ItemLevel" }, }; - return { &fields[0], std::extent::value, ItemDamageOneHandMeta::Instance(), HOTFIX_SEL_ITEM_DAMAGE_ONE_HAND }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemDamageOneHandMeta::Instance(), HOTFIX_SEL_ITEM_DAMAGE_ONE_HAND); + return &loadInfo; } }; struct ItemDamageOneHandCasterLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2051,13 +2146,14 @@ struct ItemDamageOneHandCasterLoadInfo { false, FT_FLOAT, "DPS7" }, { false, FT_SHORT, "ItemLevel" }, }; - return { &fields[0], std::extent::value, ItemDamageOneHandCasterMeta::Instance(), HOTFIX_SEL_ITEM_DAMAGE_ONE_HAND_CASTER }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemDamageOneHandCasterMeta::Instance(), HOTFIX_SEL_ITEM_DAMAGE_ONE_HAND_CASTER); + return &loadInfo; } }; struct ItemDamageTwoHandLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2071,13 +2167,14 @@ struct ItemDamageTwoHandLoadInfo { false, FT_FLOAT, "DPS7" }, { false, FT_SHORT, "ItemLevel" }, }; - return { &fields[0], std::extent::value, ItemDamageTwoHandMeta::Instance(), HOTFIX_SEL_ITEM_DAMAGE_TWO_HAND }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemDamageTwoHandMeta::Instance(), HOTFIX_SEL_ITEM_DAMAGE_TWO_HAND); + return &loadInfo; } }; struct ItemDamageTwoHandCasterLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2091,13 +2188,14 @@ struct ItemDamageTwoHandCasterLoadInfo { false, FT_FLOAT, "DPS7" }, { false, FT_SHORT, "ItemLevel" }, }; - return { &fields[0], std::extent::value, ItemDamageTwoHandCasterMeta::Instance(), HOTFIX_SEL_ITEM_DAMAGE_TWO_HAND_CASTER }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemDamageTwoHandCasterMeta::Instance(), HOTFIX_SEL_ITEM_DAMAGE_TWO_HAND_CASTER); + return &loadInfo; } }; struct ItemDisenchantLootLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2109,13 +2207,14 @@ struct ItemDisenchantLootLoadInfo { true, FT_BYTE, "ItemSubClass" }, { false, FT_BYTE, "ItemQuality" }, }; - return { &fields[0], std::extent::value, ItemDisenchantLootMeta::Instance(), HOTFIX_SEL_ITEM_DISENCHANT_LOOT }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemDisenchantLootMeta::Instance(), HOTFIX_SEL_ITEM_DISENCHANT_LOOT); + return &loadInfo; } }; struct ItemEffectLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2130,13 +2229,14 @@ struct ItemEffectLoadInfo { false, FT_BYTE, "OrderIndex" }, { false, FT_BYTE, "Trigger" }, }; - return { &fields[0], std::extent::value, ItemEffectMeta::Instance(), HOTFIX_SEL_ITEM_EFFECT }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemEffectMeta::Instance(), HOTFIX_SEL_ITEM_EFFECT); + return &loadInfo; } }; struct ItemExtendedCostLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2168,13 +2268,14 @@ struct ItemExtendedCostLoadInfo { false, FT_BYTE, "RequirementFlags" }, { false, FT_BYTE, "RequiredAchievement" }, }; - return { &fields[0], std::extent::value, ItemExtendedCostMeta::Instance(), HOTFIX_SEL_ITEM_EXTENDED_COST }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemExtendedCostMeta::Instance(), HOTFIX_SEL_ITEM_EXTENDED_COST); + return &loadInfo; } }; struct ItemLimitCategoryLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2183,13 +2284,14 @@ struct ItemLimitCategoryLoadInfo { false, FT_BYTE, "Quantity" }, { false, FT_BYTE, "Flags" }, }; - return { &fields[0], std::extent::value, ItemLimitCategoryMeta::Instance(), HOTFIX_SEL_ITEM_LIMIT_CATEGORY }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemLimitCategoryMeta::Instance(), HOTFIX_SEL_ITEM_LIMIT_CATEGORY); + return &loadInfo; } }; struct ItemModifiedAppearanceLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2200,13 +2302,14 @@ struct ItemModifiedAppearanceLoadInfo { false, FT_BYTE, "SourceType" }, { false, FT_INT, "ID" }, }; - return { &fields[0], std::extent::value, ItemModifiedAppearanceMeta::Instance(), HOTFIX_SEL_ITEM_MODIFIED_APPEARANCE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemModifiedAppearanceMeta::Instance(), HOTFIX_SEL_ITEM_MODIFIED_APPEARANCE); + return &loadInfo; } }; struct ItemPriceBaseLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2215,13 +2318,14 @@ struct ItemPriceBaseLoadInfo { false, FT_FLOAT, "WeaponFactor" }, { false, FT_SHORT, "ItemLevel" }, }; - return { &fields[0], std::extent::value, ItemPriceBaseMeta::Instance(), HOTFIX_SEL_ITEM_PRICE_BASE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemPriceBaseMeta::Instance(), HOTFIX_SEL_ITEM_PRICE_BASE); + return &loadInfo; } }; struct ItemRandomPropertiesLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2233,13 +2337,14 @@ struct ItemRandomPropertiesLoadInfo { false, FT_SHORT, "Enchantment4" }, { false, FT_SHORT, "Enchantment5" }, }; - return { &fields[0], std::extent::value, ItemRandomPropertiesMeta::Instance(), HOTFIX_SEL_ITEM_RANDOM_PROPERTIES }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemRandomPropertiesMeta::Instance(), HOTFIX_SEL_ITEM_RANDOM_PROPERTIES); + return &loadInfo; } }; struct ItemRandomSuffixLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2256,13 +2361,14 @@ struct ItemRandomSuffixLoadInfo { false, FT_SHORT, "AllocationPct4" }, { false, FT_SHORT, "AllocationPct5" }, }; - return { &fields[0], std::extent::value, ItemRandomSuffixMeta::Instance(), HOTFIX_SEL_ITEM_RANDOM_SUFFIX }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemRandomSuffixMeta::Instance(), HOTFIX_SEL_ITEM_RANDOM_SUFFIX); + return &loadInfo; } }; struct ItemSearchNameLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2283,13 +2389,14 @@ struct ItemSearchNameLoadInfo { false, FT_BYTE, "RequiredLevel" }, { true, FT_INT, "AllowableClass" }, }; - return { &fields[0], std::extent::value, ItemSearchNameMeta::Instance(), HOTFIX_SEL_ITEM_SEARCH_NAME }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemSearchNameMeta::Instance(), HOTFIX_SEL_ITEM_SEARCH_NAME); + return &loadInfo; } }; struct ItemSetLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2316,13 +2423,14 @@ struct ItemSetLoadInfo { false, FT_INT, "RequiredSkill" }, { false, FT_INT, "Flags" }, }; - return { &fields[0], std::extent::value, ItemSetMeta::Instance(), HOTFIX_SEL_ITEM_SET }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemSetMeta::Instance(), HOTFIX_SEL_ITEM_SET); + return &loadInfo; } }; struct ItemSetSpellLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2332,13 +2440,14 @@ struct ItemSetSpellLoadInfo { false, FT_SHORT, "ChrSpecID" }, { false, FT_BYTE, "Threshold" }, }; - return { &fields[0], std::extent::value, ItemSetSpellMeta::Instance(), HOTFIX_SEL_ITEM_SET_SPELL }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemSetSpellMeta::Instance(), HOTFIX_SEL_ITEM_SET_SPELL); + return &loadInfo; } }; struct ItemSparseLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2447,13 +2556,14 @@ struct ItemSparseLoadInfo { false, FT_BYTE, "ArtifactID" }, { false, FT_BYTE, "RequiredExpansion" }, }; - return { &fields[0], std::extent::value, ItemSparseMeta::Instance(), HOTFIX_SEL_ITEM_SPARSE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemSparseMeta::Instance(), HOTFIX_SEL_ITEM_SPARSE); + return &loadInfo; } }; struct ItemSpecLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2465,13 +2575,14 @@ struct ItemSpecLoadInfo { false, FT_BYTE, "PrimaryStat" }, { false, FT_BYTE, "SecondaryStat" }, }; - return { &fields[0], std::extent::value, ItemSpecMeta::Instance(), HOTFIX_SEL_ITEM_SPEC }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemSpecMeta::Instance(), HOTFIX_SEL_ITEM_SPEC); + return &loadInfo; } }; struct ItemSpecOverrideLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2479,13 +2590,14 @@ struct ItemSpecOverrideLoadInfo { false, FT_INT, "ItemID" }, { false, FT_SHORT, "SpecID" }, }; - return { &fields[0], std::extent::value, ItemSpecOverrideMeta::Instance(), HOTFIX_SEL_ITEM_SPEC_OVERRIDE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemSpecOverrideMeta::Instance(), HOTFIX_SEL_ITEM_SPEC_OVERRIDE); + return &loadInfo; } }; struct ItemUpgradeLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2496,13 +2608,14 @@ struct ItemUpgradeLoadInfo { false, FT_BYTE, "ItemUpgradePathID" }, { false, FT_BYTE, "ItemLevelBonus" }, }; - return { &fields[0], std::extent::value, ItemUpgradeMeta::Instance(), HOTFIX_SEL_ITEM_UPGRADE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemUpgradeMeta::Instance(), HOTFIX_SEL_ITEM_UPGRADE); + return &loadInfo; } }; struct ItemXBonusTreeLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2510,13 +2623,14 @@ struct ItemXBonusTreeLoadInfo { false, FT_INT, "ItemID" }, { false, FT_SHORT, "BonusTreeID" }, }; - return { &fields[0], std::extent::value, ItemXBonusTreeMeta::Instance(), HOTFIX_SEL_ITEM_X_BONUS_TREE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ItemXBonusTreeMeta::Instance(), HOTFIX_SEL_ITEM_X_BONUS_TREE); + return &loadInfo; } }; struct KeyChainLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2554,13 +2668,14 @@ struct KeyChainLoadInfo { false, FT_BYTE, "Key31" }, { false, FT_BYTE, "Key32" }, }; - return { &fields[0], std::extent::value, KeyChainMeta::Instance(), HOTFIX_SEL_KEY_CHAIN }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, KeyChainMeta::Instance(), HOTFIX_SEL_KEY_CHAIN); + return &loadInfo; } }; struct LfgDungeonsLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2597,13 +2712,14 @@ struct LfgDungeonsLoadInfo { false, FT_BYTE, "MentorCharLevel" }, { false, FT_INT, "ID" }, }; - return { &fields[0], std::extent::value, LfgDungeonsMeta::Instance(), HOTFIX_SEL_LFG_DUNGEONS }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, LfgDungeonsMeta::Instance(), HOTFIX_SEL_LFG_DUNGEONS); + return &loadInfo; } }; struct LightLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2623,13 +2739,14 @@ struct LightLoadInfo { false, FT_SHORT, "LightParamsID7" }, { false, FT_SHORT, "LightParamsID8" }, }; - return { &fields[0], std::extent::value, LightMeta::Instance(), HOTFIX_SEL_LIGHT }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, LightMeta::Instance(), HOTFIX_SEL_LIGHT); + return &loadInfo; } }; struct LiquidTypeLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2685,13 +2802,14 @@ struct LiquidTypeLoadInfo { false, FT_BYTE, "DepthTexCount6" }, { false, FT_INT, "SoundID" }, }; - return { &fields[0], std::extent::value, LiquidTypeMeta::Instance(), HOTFIX_SEL_LIQUID_TYPE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, LiquidTypeMeta::Instance(), HOTFIX_SEL_LIQUID_TYPE); + return &loadInfo; } }; struct LockLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2729,26 +2847,28 @@ struct LockLoadInfo { false, FT_BYTE, "Action7" }, { false, FT_BYTE, "Action8" }, }; - return { &fields[0], std::extent::value, LockMeta::Instance(), HOTFIX_SEL_LOCK }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, LockMeta::Instance(), HOTFIX_SEL_LOCK); + return &loadInfo; } }; struct MailTemplateLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { { false, FT_INT, "ID" }, { false, FT_STRING, "Body" }, }; - return { &fields[0], std::extent::value, MailTemplateMeta::Instance(), HOTFIX_SEL_MAIL_TEMPLATE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, MailTemplateMeta::Instance(), HOTFIX_SEL_MAIL_TEMPLATE); + return &loadInfo; } }; struct MapLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2775,13 +2895,14 @@ struct MapLoadInfo { false, FT_BYTE, "MaxPlayers" }, { false, FT_BYTE, "TimeOffset" }, }; - return { &fields[0], std::extent::value, MapMeta::Instance(), HOTFIX_SEL_MAP }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, MapMeta::Instance(), HOTFIX_SEL_MAP); + return &loadInfo; } }; struct MapDifficultyLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2795,13 +2916,14 @@ struct MapDifficultyLoadInfo { false, FT_BYTE, "ItemBonusTreeModID" }, { false, FT_INT, "Context" }, }; - return { &fields[0], std::extent::value, MapDifficultyMeta::Instance(), HOTFIX_SEL_MAP_DIFFICULTY }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, MapDifficultyMeta::Instance(), HOTFIX_SEL_MAP_DIFFICULTY); + return &loadInfo; } }; struct ModifierTreeLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2814,13 +2936,14 @@ struct ModifierTreeLoadInfo { false, FT_BYTE, "Operator" }, { false, FT_BYTE, "Amount" }, }; - return { &fields[0], std::extent::value, ModifierTreeMeta::Instance(), HOTFIX_SEL_MODIFIER_TREE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ModifierTreeMeta::Instance(), HOTFIX_SEL_MODIFIER_TREE); + return &loadInfo; } }; struct MountLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2836,13 +2959,14 @@ struct MountLoadInfo { false, FT_BYTE, "Source" }, { false, FT_INT, "ID" }, }; - return { &fields[0], std::extent::value, MountMeta::Instance(), HOTFIX_SEL_MOUNT }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, MountMeta::Instance(), HOTFIX_SEL_MOUNT); + return &loadInfo; } }; struct MountCapabilityLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2855,13 +2979,14 @@ struct MountCapabilityLoadInfo { false, FT_INT, "ID" }, { false, FT_INT, "RequiredAura" }, }; - return { &fields[0], std::extent::value, MountCapabilityMeta::Instance(), HOTFIX_SEL_MOUNT_CAPABILITY }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, MountCapabilityMeta::Instance(), HOTFIX_SEL_MOUNT_CAPABILITY); + return &loadInfo; } }; struct MountTypeXCapabilityLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2870,13 +2995,14 @@ struct MountTypeXCapabilityLoadInfo { false, FT_SHORT, "MountCapabilityID" }, { false, FT_BYTE, "OrderIndex" }, }; - return { &fields[0], std::extent::value, MountTypeXCapabilityMeta::Instance(), HOTFIX_SEL_MOUNT_TYPE_X_CAPABILITY }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, MountTypeXCapabilityMeta::Instance(), HOTFIX_SEL_MOUNT_TYPE_X_CAPABILITY); + return &loadInfo; } }; struct MovieLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2886,13 +3012,14 @@ struct MovieLoadInfo { false, FT_BYTE, "Volume" }, { false, FT_BYTE, "KeyID" }, }; - return { &fields[0], std::extent::value, MovieMeta::Instance(), HOTFIX_SEL_MOVIE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, MovieMeta::Instance(), HOTFIX_SEL_MOVIE); + return &loadInfo; } }; struct NameGenLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2901,13 +3028,14 @@ struct NameGenLoadInfo { false, FT_BYTE, "Race" }, { false, FT_BYTE, "Sex" }, }; - return { &fields[0], std::extent::value, NameGenMeta::Instance(), HOTFIX_SEL_NAME_GEN }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, NameGenMeta::Instance(), HOTFIX_SEL_NAME_GEN); + return &loadInfo; } }; struct NamesProfanityLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2915,26 +3043,28 @@ struct NamesProfanityLoadInfo { false, FT_STRING_NOT_LOCALIZED, "Name" }, { true, FT_BYTE, "Language" }, }; - return { &fields[0], std::extent::value, NamesProfanityMeta::Instance(), HOTFIX_SEL_NAMES_PROFANITY }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, NamesProfanityMeta::Instance(), HOTFIX_SEL_NAMES_PROFANITY); + return &loadInfo; } }; struct NamesReservedLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { { false, FT_INT, "ID" }, { false, FT_STRING_NOT_LOCALIZED, "Name" }, }; - return { &fields[0], std::extent::value, NamesReservedMeta::Instance(), HOTFIX_SEL_NAMES_RESERVED }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, NamesReservedMeta::Instance(), HOTFIX_SEL_NAMES_RESERVED); + return &loadInfo; } }; struct NamesReservedLocaleLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2942,13 +3072,14 @@ struct NamesReservedLocaleLoadInfo { false, FT_STRING_NOT_LOCALIZED, "Name" }, { false, FT_BYTE, "LocaleMask" }, }; - return { &fields[0], std::extent::value, NamesReservedLocaleMeta::Instance(), HOTFIX_SEL_NAMES_RESERVED }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, NamesReservedLocaleMeta::Instance(), HOTFIX_SEL_NAMES_RESERVED); + return &loadInfo; } }; struct OverrideSpellDataLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2966,26 +3097,28 @@ struct OverrideSpellDataLoadInfo { false, FT_INT, "PlayerActionbarFileDataID" }, { false, FT_BYTE, "Flags" }, }; - return { &fields[0], std::extent::value, OverrideSpellDataMeta::Instance(), HOTFIX_SEL_OVERRIDE_SPELL_DATA }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, OverrideSpellDataMeta::Instance(), HOTFIX_SEL_OVERRIDE_SPELL_DATA); + return &loadInfo; } }; struct PhaseLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { { false, FT_INT, "ID" }, { false, FT_SHORT, "Flags" }, }; - return { &fields[0], std::extent::value, PhaseMeta::Instance(), HOTFIX_SEL_PHASE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, PhaseMeta::Instance(), HOTFIX_SEL_PHASE); + return &loadInfo; } }; struct PhaseXPhaseGroupLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -2993,13 +3126,14 @@ struct PhaseXPhaseGroupLoadInfo { false, FT_SHORT, "PhaseID" }, { false, FT_SHORT, "PhaseGroupID" }, }; - return { &fields[0], std::extent::value, PhaseXPhaseGroupMeta::Instance(), HOTFIX_SEL_PHASE_X_PHASE_GROUP }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, PhaseXPhaseGroupMeta::Instance(), HOTFIX_SEL_PHASE_X_PHASE_GROUP); + return &loadInfo; } }; struct PlayerConditionLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3150,13 +3284,14 @@ struct PlayerConditionLoadInfo { true, FT_INT, "Unknown7001" }, { true, FT_INT, "Unknown7002" }, }; - return { &fields[0], std::extent::value, PlayerConditionMeta::Instance(), HOTFIX_SEL_PLAYER_CONDITION }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, PlayerConditionMeta::Instance(), HOTFIX_SEL_PLAYER_CONDITION); + return &loadInfo; } }; struct PowerDisplayLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3167,13 +3302,14 @@ struct PowerDisplayLoadInfo { false, FT_BYTE, "Green" }, { false, FT_BYTE, "Blue" }, }; - return { &fields[0], std::extent::value, PowerDisplayMeta::Instance(), HOTFIX_SEL_POWER_DISPLAY }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, PowerDisplayMeta::Instance(), HOTFIX_SEL_POWER_DISPLAY); + return &loadInfo; } }; struct PowerTypeLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3191,13 +3327,14 @@ struct PowerTypeLoadInfo { true, FT_BYTE, "RegenerationMax" }, { false, FT_BYTE, "UIModifier" }, }; - return { &fields[0], std::extent::value, PowerTypeMeta::Instance(), HOTFIX_SEL_POWER_TYPE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, PowerTypeMeta::Instance(), HOTFIX_SEL_POWER_TYPE); + return &loadInfo; } }; struct PvpDifficultyLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3207,13 +3344,14 @@ struct PvpDifficultyLoadInfo { false, FT_BYTE, "MinLevel" }, { false, FT_BYTE, "MaxLevel" }, }; - return { &fields[0], std::extent::value, PvpDifficultyMeta::Instance(), HOTFIX_SEL_PVP_DIFFICULTY }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, PvpDifficultyMeta::Instance(), HOTFIX_SEL_PVP_DIFFICULTY); + return &loadInfo; } }; struct QuestFactionRewardLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3229,13 +3367,14 @@ struct QuestFactionRewardLoadInfo { true, FT_SHORT, "QuestRewFactionValue9" }, { true, FT_SHORT, "QuestRewFactionValue10" }, }; - return { &fields[0], std::extent::value, QuestFactionRewardMeta::Instance(), HOTFIX_SEL_QUEST_FACTION_REWARD }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, QuestFactionRewardMeta::Instance(), HOTFIX_SEL_QUEST_FACTION_REWARD); + return &loadInfo; } }; struct QuestMoneyRewardLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3251,13 +3390,14 @@ struct QuestMoneyRewardLoadInfo { false, FT_INT, "Money9" }, { false, FT_INT, "Money10" }, }; - return { &fields[0], std::extent::value, QuestMoneyRewardMeta::Instance(), HOTFIX_SEL_QUEST_MONEY_REWARD }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, QuestMoneyRewardMeta::Instance(), HOTFIX_SEL_QUEST_MONEY_REWARD); + return &loadInfo; } }; struct QuestPackageItemLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3267,13 +3407,14 @@ struct QuestPackageItemLoadInfo { false, FT_BYTE, "ItemCount" }, { false, FT_BYTE, "FilterType" }, }; - return { &fields[0], std::extent::value, QuestPackageItemMeta::Instance(), HOTFIX_SEL_QUEST_PACKAGE_ITEM }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, QuestPackageItemMeta::Instance(), HOTFIX_SEL_QUEST_PACKAGE_ITEM); + return &loadInfo; } }; struct QuestSortLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3281,26 +3422,28 @@ struct QuestSortLoadInfo { false, FT_STRING, "SortName" }, { false, FT_BYTE, "SortOrder" }, }; - return { &fields[0], std::extent::value, QuestSortMeta::Instance(), HOTFIX_SEL_QUEST_SORT }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, QuestSortMeta::Instance(), HOTFIX_SEL_QUEST_SORT); + return &loadInfo; } }; struct QuestV2LoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { { false, FT_INT, "ID" }, { false, FT_SHORT, "UniqueBitFlag" }, }; - return { &fields[0], std::extent::value, QuestV2Meta::Instance(), HOTFIX_SEL_QUEST_V2 }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, QuestV2Meta::Instance(), HOTFIX_SEL_QUEST_V2); + return &loadInfo; } }; struct QuestXpLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3316,13 +3459,14 @@ struct QuestXpLoadInfo { false, FT_SHORT, "Exp9" }, { false, FT_SHORT, "Exp10" }, }; - return { &fields[0], std::extent::value, QuestXPMeta::Instance(), HOTFIX_SEL_QUEST_XP }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, QuestXPMeta::Instance(), HOTFIX_SEL_QUEST_XP); + return &loadInfo; } }; struct RandPropPointsLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3343,13 +3487,14 @@ struct RandPropPointsLoadInfo { false, FT_INT, "UncommonPropertiesPoints4" }, { false, FT_INT, "UncommonPropertiesPoints5" }, }; - return { &fields[0], std::extent::value, RandPropPointsMeta::Instance(), HOTFIX_SEL_RAND_PROP_POINTS }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, RandPropPointsMeta::Instance(), HOTFIX_SEL_RAND_PROP_POINTS); + return &loadInfo; } }; struct RulesetItemUpgradeLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3357,13 +3502,14 @@ struct RulesetItemUpgradeLoadInfo { false, FT_INT, "ItemID" }, { false, FT_SHORT, "ItemUpgradeID" }, }; - return { &fields[0], std::extent::value, RulesetItemUpgradeMeta::Instance(), HOTFIX_SEL_RULESET_ITEM_UPGRADE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, RulesetItemUpgradeMeta::Instance(), HOTFIX_SEL_RULESET_ITEM_UPGRADE); + return &loadInfo; } }; struct ScalingStatDistributionLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3372,13 +3518,14 @@ struct ScalingStatDistributionLoadInfo { false, FT_INT, "MinLevel" }, { false, FT_INT, "MaxLevel" }, }; - return { &fields[0], std::extent::value, ScalingStatDistributionMeta::Instance(), HOTFIX_SEL_SCALING_STAT_DISTRIBUTION }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ScalingStatDistributionMeta::Instance(), HOTFIX_SEL_SCALING_STAT_DISTRIBUTION); + return &loadInfo; } }; struct ScenarioLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3388,13 +3535,14 @@ struct ScenarioLoadInfo { false, FT_BYTE, "Flags" }, { false, FT_BYTE, "Type" }, }; - return { &fields[0], std::extent::value, ScenarioMeta::Instance(), HOTFIX_SEL_SCENARIO }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ScenarioMeta::Instance(), HOTFIX_SEL_SCENARIO); + return &loadInfo; } }; struct ScenarioStepLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3409,13 +3557,14 @@ struct ScenarioStepLoadInfo { false, FT_BYTE, "Flags" }, { false, FT_INT, "BonusRequiredStepID" }, }; - return { &fields[0], std::extent::value, ScenarioStepMeta::Instance(), HOTFIX_SEL_SCENARIO_STEP }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ScenarioStepMeta::Instance(), HOTFIX_SEL_SCENARIO_STEP); + return &loadInfo; } }; struct SceneScriptLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3425,26 +3574,28 @@ struct SceneScriptLoadInfo { false, FT_SHORT, "PrevScriptId" }, { false, FT_SHORT, "NextScriptId" }, }; - return { &fields[0], std::extent::value, SceneScriptMeta::Instance(), HOTFIX_SEL_SCENE_SCRIPT }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SceneScriptMeta::Instance(), HOTFIX_SEL_SCENE_SCRIPT); + return &loadInfo; } }; struct SceneScriptPackageLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { { false, FT_INT, "ID" }, { false, FT_STRING_NOT_LOCALIZED, "Name" }, }; - return { &fields[0], std::extent::value, SceneScriptPackageMeta::Instance(), HOTFIX_SEL_SCENE_SCRIPT_PACKAGE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SceneScriptPackageMeta::Instance(), HOTFIX_SEL_SCENE_SCRIPT_PACKAGE); + return &loadInfo; } }; struct SkillLineLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3458,13 +3609,14 @@ struct SkillLineLoadInfo { false, FT_BYTE, "CanLink" }, { false, FT_INT, "ParentSkillLineID" }, }; - return { &fields[0], std::extent::value, SkillLineMeta::Instance(), HOTFIX_SEL_SKILL_LINE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SkillLineMeta::Instance(), HOTFIX_SEL_SKILL_LINE); + return &loadInfo; } }; struct SkillLineAbilityLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3483,13 +3635,14 @@ struct SkillLineAbilityLoadInfo { false, FT_BYTE, "NumSkillUps" }, { true, FT_INT, "ClassMask" }, }; - return { &fields[0], std::extent::value, SkillLineAbilityMeta::Instance(), HOTFIX_SEL_SKILL_LINE_ABILITY }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SkillLineAbilityMeta::Instance(), HOTFIX_SEL_SKILL_LINE_ABILITY); + return &loadInfo; } }; struct SkillRaceClassInfoLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3502,13 +3655,14 @@ struct SkillRaceClassInfoLoadInfo { false, FT_BYTE, "MinLevel" }, { true, FT_INT, "ClassMask" }, }; - return { &fields[0], std::extent::value, SkillRaceClassInfoMeta::Instance(), HOTFIX_SEL_SKILL_RACE_CLASS_INFO }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SkillRaceClassInfoMeta::Instance(), HOTFIX_SEL_SKILL_RACE_CLASS_INFO); + return &loadInfo; } }; struct SoundKitLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3530,13 +3684,14 @@ struct SoundKitLoadInfo { false, FT_BYTE, "Unk700" }, { false, FT_INT, "ID" }, }; - return { &fields[0], std::extent::value, SoundKitMeta::Instance(), HOTFIX_SEL_SOUND_KIT }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SoundKitMeta::Instance(), HOTFIX_SEL_SOUND_KIT); + return &loadInfo; } }; struct SpecializationSpellsLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3547,13 +3702,14 @@ struct SpecializationSpellsLoadInfo { false, FT_BYTE, "OrderIndex" }, { false, FT_INT, "ID" }, }; - return { &fields[0], std::extent::value, SpecializationSpellsMeta::Instance(), HOTFIX_SEL_SPECIALIZATION_SPELLS }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpecializationSpellsMeta::Instance(), HOTFIX_SEL_SPECIALIZATION_SPELLS); + return &loadInfo; } }; struct SpellLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3565,13 +3721,14 @@ struct SpellLoadInfo { false, FT_INT, "ID" }, { false, FT_INT, "DescriptionVariablesID" }, }; - return { &fields[0], std::extent::value, SpellMeta::Instance(), HOTFIX_SEL_SPELL }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellMeta::Instance(), HOTFIX_SEL_SPELL); + return &loadInfo; } }; struct SpellAuraOptionsLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3585,13 +3742,14 @@ struct SpellAuraOptionsLoadInfo { false, FT_BYTE, "ProcChance" }, { false, FT_BYTE, "SpellProcsPerMinuteID" }, }; - return { &fields[0], std::extent::value, SpellAuraOptionsMeta::Instance(), HOTFIX_SEL_SPELL_AURA_OPTIONS }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellAuraOptionsMeta::Instance(), HOTFIX_SEL_SPELL_AURA_OPTIONS); + return &loadInfo; } }; struct SpellAuraRestrictionsLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3607,13 +3765,14 @@ struct SpellAuraRestrictionsLoadInfo { false, FT_BYTE, "ExcludeCasterAuraState" }, { false, FT_BYTE, "ExcludeTargetAuraState" }, }; - return { &fields[0], std::extent::value, SpellAuraRestrictionsMeta::Instance(), HOTFIX_SEL_SPELL_AURA_RESTRICTIONS }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellAuraRestrictionsMeta::Instance(), HOTFIX_SEL_SPELL_AURA_RESTRICTIONS); + return &loadInfo; } }; struct SpellCastTimesLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3622,13 +3781,14 @@ struct SpellCastTimesLoadInfo { true, FT_INT, "MinCastTime" }, { true, FT_SHORT, "CastTimePerLevel" }, }; - return { &fields[0], std::extent::value, SpellCastTimesMeta::Instance(), HOTFIX_SEL_SPELL_CAST_TIMES }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellCastTimesMeta::Instance(), HOTFIX_SEL_SPELL_CAST_TIMES); + return &loadInfo; } }; struct SpellCastingRequirementsLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3641,13 +3801,14 @@ struct SpellCastingRequirementsLoadInfo { false, FT_BYTE, "MinReputation" }, { false, FT_BYTE, "RequiredAuraVision" }, }; - return { &fields[0], std::extent::value, SpellCastingRequirementsMeta::Instance(), HOTFIX_SEL_SPELL_CASTING_REQUIREMENTS }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellCastingRequirementsMeta::Instance(), HOTFIX_SEL_SPELL_CASTING_REQUIREMENTS); + return &loadInfo; } }; struct SpellCategoriesLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3662,13 +3823,14 @@ struct SpellCategoriesLoadInfo { false, FT_BYTE, "Mechanic" }, { false, FT_BYTE, "PreventionType" }, }; - return { &fields[0], std::extent::value, SpellCategoriesMeta::Instance(), HOTFIX_SEL_SPELL_CATEGORIES }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellCategoriesMeta::Instance(), HOTFIX_SEL_SPELL_CATEGORIES); + return &loadInfo; } }; struct SpellCategoryLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3680,13 +3842,14 @@ struct SpellCategoryLoadInfo { false, FT_BYTE, "MaxCharges" }, { false, FT_INT, "ChargeCategoryType" }, }; - return { &fields[0], std::extent::value, SpellCategoryMeta::Instance(), HOTFIX_SEL_SPELL_CATEGORY }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellCategoryMeta::Instance(), HOTFIX_SEL_SPELL_CATEGORY); + return &loadInfo; } }; struct SpellClassOptionsLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3699,13 +3862,14 @@ struct SpellClassOptionsLoadInfo { false, FT_BYTE, "SpellClassSet" }, { false, FT_INT, "ModalNextSpell" }, }; - return { &fields[0], std::extent::value, SpellClassOptionsMeta::Instance(), HOTFIX_SEL_SPELL_CLASS_OPTIONS }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellClassOptionsMeta::Instance(), HOTFIX_SEL_SPELL_CLASS_OPTIONS); + return &loadInfo; } }; struct SpellCooldownsLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3716,13 +3880,14 @@ struct SpellCooldownsLoadInfo { false, FT_INT, "StartRecoveryTime" }, { false, FT_BYTE, "DifficultyID" }, }; - return { &fields[0], std::extent::value, SpellCooldownsMeta::Instance(), HOTFIX_SEL_SPELL_COOLDOWNS }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellCooldownsMeta::Instance(), HOTFIX_SEL_SPELL_COOLDOWNS); + return &loadInfo; } }; struct SpellDurationLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3731,13 +3896,14 @@ struct SpellDurationLoadInfo { true, FT_INT, "MaxDuration" }, { true, FT_SHORT, "DurationPerLevel" }, }; - return { &fields[0], std::extent::value, SpellDurationMeta::Instance(), HOTFIX_SEL_SPELL_DURATION }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellDurationMeta::Instance(), HOTFIX_SEL_SPELL_DURATION); + return &loadInfo; } }; struct SpellEffectLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3773,13 +3939,14 @@ struct SpellEffectLoadInfo { false, FT_INT, "EffectIndex" }, { false, FT_INT, "EffectAttributes" }, }; - return { &fields[0], std::extent::value, SpellEffectMeta::Instance(), HOTFIX_SEL_SPELL_EFFECT }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellEffectMeta::Instance(), HOTFIX_SEL_SPELL_EFFECT); + return &loadInfo; } }; struct SpellEffectScalingLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3789,13 +3956,14 @@ struct SpellEffectScalingLoadInfo { false, FT_FLOAT, "ResourceCoefficient" }, { false, FT_INT, "SpellEffectID" }, }; - return { &fields[0], std::extent::value, SpellEffectScalingMeta::Instance(), HOTFIX_SEL_SPELL_EFFECT_SCALING }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellEffectScalingMeta::Instance(), HOTFIX_SEL_SPELL_EFFECT_SCALING); + return &loadInfo; } }; struct SpellEquippedItemsLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3805,26 +3973,28 @@ struct SpellEquippedItemsLoadInfo { true, FT_INT, "EquippedItemSubClassMask" }, { true, FT_BYTE, "EquippedItemClass" }, }; - return { &fields[0], std::extent::value, SpellEquippedItemsMeta::Instance(), HOTFIX_SEL_SPELL_EQUIPPED_ITEMS }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellEquippedItemsMeta::Instance(), HOTFIX_SEL_SPELL_EQUIPPED_ITEMS); + return &loadInfo; } }; struct SpellFocusObjectLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { { false, FT_INT, "ID" }, { false, FT_STRING, "Name" }, }; - return { &fields[0], std::extent::value, SpellFocusObjectMeta::Instance(), HOTFIX_SEL_SPELL_FOCUS_OBJECT }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellFocusObjectMeta::Instance(), HOTFIX_SEL_SPELL_FOCUS_OBJECT); + return &loadInfo; } }; struct SpellInterruptsLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3837,13 +4007,14 @@ struct SpellInterruptsLoadInfo { false, FT_SHORT, "InterruptFlags" }, { false, FT_BYTE, "DifficultyID" }, }; - return { &fields[0], std::extent::value, SpellInterruptsMeta::Instance(), HOTFIX_SEL_SPELL_INTERRUPTS }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellInterruptsMeta::Instance(), HOTFIX_SEL_SPELL_INTERRUPTS); + return &loadInfo; } }; struct SpellItemEnchantmentLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3876,13 +4047,14 @@ struct SpellItemEnchantmentLoadInfo { true, FT_BYTE, "ScalingClassRestricted" }, { false, FT_INT, "PlayerConditionID" }, }; - return { &fields[0], std::extent::value, SpellItemEnchantmentMeta::Instance(), HOTFIX_SEL_SPELL_ITEM_ENCHANTMENT }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellItemEnchantmentMeta::Instance(), HOTFIX_SEL_SPELL_ITEM_ENCHANTMENT); + return &loadInfo; } }; struct SpellItemEnchantmentConditionLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3918,13 +4090,14 @@ struct SpellItemEnchantmentConditionLoadInfo { false, FT_INT, "LTOperand4" }, { false, FT_INT, "LTOperand5" }, }; - return { &fields[0], std::extent::value, SpellItemEnchantmentConditionMeta::Instance(), HOTFIX_SEL_SPELL_ITEM_ENCHANTMENT_CONDITION }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellItemEnchantmentConditionMeta::Instance(), HOTFIX_SEL_SPELL_ITEM_ENCHANTMENT_CONDITION); + return &loadInfo; } }; struct SpellLearnSpellLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3933,13 +4106,14 @@ struct SpellLearnSpellLoadInfo { false, FT_INT, "SpellID" }, { false, FT_INT, "OverridesSpellID" }, }; - return { &fields[0], std::extent::value, SpellLearnSpellMeta::Instance(), HOTFIX_SEL_SPELL_LEARN_SPELL }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellLearnSpellMeta::Instance(), HOTFIX_SEL_SPELL_LEARN_SPELL); + return &loadInfo; } }; struct SpellLevelsLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3951,13 +4125,14 @@ struct SpellLevelsLoadInfo { false, FT_BYTE, "DifficultyID" }, { false, FT_BYTE, "MaxUsableLevel" }, }; - return { &fields[0], std::extent::value, SpellLevelsMeta::Instance(), HOTFIX_SEL_SPELL_LEVELS }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellLevelsMeta::Instance(), HOTFIX_SEL_SPELL_LEVELS); + return &loadInfo; } }; struct SpellMiscLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -3985,13 +4160,14 @@ struct SpellMiscLoadInfo { false, FT_SHORT, "ActiveIconID" }, { false, FT_BYTE, "SchoolMask" }, }; - return { &fields[0], std::extent::value, SpellMiscMeta::Instance(), HOTFIX_SEL_SPELL_MISC }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellMiscMeta::Instance(), HOTFIX_SEL_SPELL_MISC); + return &loadInfo; } }; struct SpellPowerLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4010,13 +4186,14 @@ struct SpellPowerLoadInfo { false, FT_INT, "PowerDisplayID" }, { false, FT_INT, "UnitPowerBarID" }, }; - return { &fields[0], std::extent::value, SpellPowerMeta::Instance(), HOTFIX_SEL_SPELL_POWER }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellPowerMeta::Instance(), HOTFIX_SEL_SPELL_POWER); + return &loadInfo; } }; struct SpellPowerDifficultyLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4024,13 +4201,14 @@ struct SpellPowerDifficultyLoadInfo { false, FT_BYTE, "PowerIndex" }, { false, FT_INT, "ID" }, }; - return { &fields[0], std::extent::value, SpellPowerDifficultyMeta::Instance(), HOTFIX_SEL_SPELL_POWER_DIFFICULTY }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellPowerDifficultyMeta::Instance(), HOTFIX_SEL_SPELL_POWER_DIFFICULTY); + return &loadInfo; } }; struct SpellProcsPerMinuteLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4038,13 +4216,14 @@ struct SpellProcsPerMinuteLoadInfo { false, FT_FLOAT, "BaseProcRate" }, { false, FT_BYTE, "Flags" }, }; - return { &fields[0], std::extent::value, SpellProcsPerMinuteMeta::Instance(), HOTFIX_SEL_SPELL_PROCS_PER_MINUTE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellProcsPerMinuteMeta::Instance(), HOTFIX_SEL_SPELL_PROCS_PER_MINUTE); + return &loadInfo; } }; struct SpellProcsPerMinuteModLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4054,13 +4233,14 @@ struct SpellProcsPerMinuteModLoadInfo { false, FT_BYTE, "Type" }, { false, FT_BYTE, "SpellProcsPerMinuteID" }, }; - return { &fields[0], std::extent::value, SpellProcsPerMinuteModMeta::Instance(), HOTFIX_SEL_SPELL_PROCS_PER_MINUTE_MOD }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellProcsPerMinuteModMeta::Instance(), HOTFIX_SEL_SPELL_PROCS_PER_MINUTE_MOD); + return &loadInfo; } }; struct SpellRadiusLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4070,13 +4250,14 @@ struct SpellRadiusLoadInfo { false, FT_FLOAT, "RadiusMin" }, { false, FT_FLOAT, "RadiusMax" }, }; - return { &fields[0], std::extent::value, SpellRadiusMeta::Instance(), HOTFIX_SEL_SPELL_RADIUS }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellRadiusMeta::Instance(), HOTFIX_SEL_SPELL_RADIUS); + return &loadInfo; } }; struct SpellRangeLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4089,13 +4270,14 @@ struct SpellRangeLoadInfo { false, FT_STRING, "DisplayNameShort" }, { false, FT_BYTE, "Flags" }, }; - return { &fields[0], std::extent::value, SpellRangeMeta::Instance(), HOTFIX_SEL_SPELL_RANGE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellRangeMeta::Instance(), HOTFIX_SEL_SPELL_RANGE); + return &loadInfo; } }; struct SpellReagentsLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4118,13 +4300,14 @@ struct SpellReagentsLoadInfo { false, FT_SHORT, "ReagentCount7" }, { false, FT_SHORT, "ReagentCount8" }, }; - return { &fields[0], std::extent::value, SpellReagentsMeta::Instance(), HOTFIX_SEL_SPELL_REAGENTS }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellReagentsMeta::Instance(), HOTFIX_SEL_SPELL_REAGENTS); + return &loadInfo; } }; struct SpellScalingLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4135,13 +4318,14 @@ struct SpellScalingLoadInfo { false, FT_INT, "MinScalingLevel" }, { false, FT_INT, "MaxScalingLevel" }, }; - return { &fields[0], std::extent::value, SpellScalingMeta::Instance(), HOTFIX_SEL_SPELL_SCALING }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellScalingMeta::Instance(), HOTFIX_SEL_SPELL_SCALING); + return &loadInfo; } }; struct SpellShapeshiftLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4153,13 +4337,14 @@ struct SpellShapeshiftLoadInfo { false, FT_INT, "ShapeshiftMask2" }, { false, FT_BYTE, "StanceBarOrder" }, }; - return { &fields[0], std::extent::value, SpellShapeshiftMeta::Instance(), HOTFIX_SEL_SPELL_SHAPESHIFT }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellShapeshiftMeta::Instance(), HOTFIX_SEL_SPELL_SHAPESHIFT); + return &loadInfo; } }; struct SpellShapeshiftFormLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4185,13 +4370,14 @@ struct SpellShapeshiftFormLoadInfo { true, FT_BYTE, "CreatureType" }, { false, FT_BYTE, "BonusActionBar" }, }; - return { &fields[0], std::extent::value, SpellShapeshiftFormMeta::Instance(), HOTFIX_SEL_SPELL_SHAPESHIFT_FORM }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellShapeshiftFormMeta::Instance(), HOTFIX_SEL_SPELL_SHAPESHIFT_FORM); + return &loadInfo; } }; struct SpellTargetRestrictionsLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4205,13 +4391,14 @@ struct SpellTargetRestrictionsLoadInfo { false, FT_BYTE, "MaxAffectedTargets" }, { false, FT_INT, "MaxTargetLevel" }, }; - return { &fields[0], std::extent::value, SpellTargetRestrictionsMeta::Instance(), HOTFIX_SEL_SPELL_TARGET_RESTRICTIONS }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellTargetRestrictionsMeta::Instance(), HOTFIX_SEL_SPELL_TARGET_RESTRICTIONS); + return &loadInfo; } }; struct SpellTotemsLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4222,13 +4409,14 @@ struct SpellTotemsLoadInfo { false, FT_SHORT, "RequiredTotemCategoryID1" }, { false, FT_SHORT, "RequiredTotemCategoryID2" }, }; - return { &fields[0], std::extent::value, SpellTotemsMeta::Instance(), HOTFIX_SEL_SPELL_TOTEMS }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellTotemsMeta::Instance(), HOTFIX_SEL_SPELL_TOTEMS); + return &loadInfo; } }; struct SpellXSpellVisualLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4243,13 +4431,14 @@ struct SpellXSpellVisualLoadInfo { false, FT_BYTE, "Priority" }, { false, FT_INT, "ID" }, }; - return { &fields[0], std::extent::value, SpellXSpellVisualMeta::Instance(), HOTFIX_SEL_SPELL_X_SPELL_VISUAL }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SpellXSpellVisualMeta::Instance(), HOTFIX_SEL_SPELL_X_SPELL_VISUAL); + return &loadInfo; } }; struct SummonPropertiesLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4260,13 +4449,14 @@ struct SummonPropertiesLoadInfo { true, FT_INT, "Type" }, { true, FT_INT, "Slot" }, }; - return { &fields[0], std::extent::value, SummonPropertiesMeta::Instance(), HOTFIX_SEL_SUMMON_PROPERTIES }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, SummonPropertiesMeta::Instance(), HOTFIX_SEL_SUMMON_PROPERTIES); + return &loadInfo; } }; struct TactKeyLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4288,13 +4478,14 @@ struct TactKeyLoadInfo { false, FT_BYTE, "Key15" }, { false, FT_BYTE, "Key16" }, }; - return { &fields[0], std::extent::value, TactKeyMeta::Instance(), HOTFIX_SEL_TACT_KEY }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, TactKeyMeta::Instance(), HOTFIX_SEL_TACT_KEY); + return &loadInfo; } }; struct TalentLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4310,13 +4501,14 @@ struct TalentLoadInfo { false, FT_BYTE, "CategoryMask2" }, { false, FT_BYTE, "ClassID" }, }; - return { &fields[0], std::extent::value, TalentMeta::Instance(), HOTFIX_SEL_TALENT }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, TalentMeta::Instance(), HOTFIX_SEL_TALENT); + return &loadInfo; } }; struct TaxiNodesLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4334,13 +4526,14 @@ struct TaxiNodesLoadInfo { false, FT_BYTE, "Flags" }, { false, FT_INT, "ID" }, }; - return { &fields[0], std::extent::value, TaxiNodesMeta::Instance(), HOTFIX_SEL_TAXI_NODES }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, TaxiNodesMeta::Instance(), HOTFIX_SEL_TAXI_NODES); + return &loadInfo; } }; struct TaxiPathLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4349,13 +4542,14 @@ struct TaxiPathLoadInfo { false, FT_INT, "ID" }, { false, FT_INT, "Cost" }, }; - return { &fields[0], std::extent::value, TaxiPathMeta::Instance(), HOTFIX_SEL_TAXI_PATH }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, TaxiPathMeta::Instance(), HOTFIX_SEL_TAXI_PATH); + return &loadInfo; } }; struct TaxiPathNodeLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4371,13 +4565,14 @@ struct TaxiPathNodeLoadInfo { false, FT_BYTE, "Flags" }, { false, FT_INT, "ID" }, }; - return { &fields[0], std::extent::value, TaxiPathNodeMeta::Instance(), HOTFIX_SEL_TAXI_PATH_NODE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, TaxiPathNodeMeta::Instance(), HOTFIX_SEL_TAXI_PATH_NODE); + return &loadInfo; } }; struct TotemCategoryLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4386,13 +4581,14 @@ struct TotemCategoryLoadInfo { false, FT_INT, "CategoryMask" }, { false, FT_BYTE, "CategoryType" }, }; - return { &fields[0], std::extent::value, TotemCategoryMeta::Instance(), HOTFIX_SEL_TOTEM_CATEGORY }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, TotemCategoryMeta::Instance(), HOTFIX_SEL_TOTEM_CATEGORY); + return &loadInfo; } }; struct ToyLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4402,13 +4598,14 @@ struct ToyLoadInfo { false, FT_BYTE, "CategoryFilter" }, { false, FT_INT, "ID" }, }; - return { &fields[0], std::extent::value, ToyMeta::Instance(), HOTFIX_SEL_TOY }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, ToyMeta::Instance(), HOTFIX_SEL_TOY); + return &loadInfo; } }; struct TransportAnimationLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4420,13 +4617,14 @@ struct TransportAnimationLoadInfo { false, FT_FLOAT, "PosZ" }, { false, FT_BYTE, "SequenceID" }, }; - return { &fields[0], std::extent::value, TransportAnimationMeta::Instance(), HOTFIX_SEL_TRANSPORT_ANIMATION }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, TransportAnimationMeta::Instance(), HOTFIX_SEL_TRANSPORT_ANIMATION); + return &loadInfo; } }; struct TransportRotationLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4438,13 +4636,14 @@ struct TransportRotationLoadInfo { false, FT_FLOAT, "Z" }, { false, FT_FLOAT, "W" }, }; - return { &fields[0], std::extent::value, TransportRotationMeta::Instance(), HOTFIX_SEL_TRANSPORT_ROTATION }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, TransportRotationMeta::Instance(), HOTFIX_SEL_TRANSPORT_ROTATION); + return &loadInfo; } }; struct UnitPowerBarLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4476,13 +4675,14 @@ struct UnitPowerBarLoadInfo { false, FT_INT, "MinPower" }, { false, FT_INT, "MaxPower" }, }; - return { &fields[0], std::extent::value, UnitPowerBarMeta::Instance(), HOTFIX_SEL_UNIT_POWER_BAR }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, UnitPowerBarMeta::Instance(), HOTFIX_SEL_UNIT_POWER_BAR); + return &loadInfo; } }; struct VehicleLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4528,13 +4728,14 @@ struct VehicleLoadInfo { false, FT_BYTE, "FlagsB" }, { false, FT_BYTE, "UILocomotionType" }, }; - return { &fields[0], std::extent::value, VehicleMeta::Instance(), HOTFIX_SEL_VEHICLE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, VehicleMeta::Instance(), HOTFIX_SEL_VEHICLE); + return &loadInfo; } }; struct VehicleSeatLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4605,13 +4806,14 @@ struct VehicleSeatLoadInfo { false, FT_INT, "EnterUISoundID" }, { false, FT_INT, "ExitUISoundID" }, }; - return { &fields[0], std::extent::value, VehicleSeatMeta::Instance(), HOTFIX_SEL_VEHICLE_SEAT }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, VehicleSeatMeta::Instance(), HOTFIX_SEL_VEHICLE_SEAT); + return &loadInfo; } }; struct WmoAreaTableLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4631,13 +4833,14 @@ struct WmoAreaTableLoadInfo { false, FT_INT, "ID" }, { false, FT_INT, "UWZoneMusic" }, }; - return { &fields[0], std::extent::value, WMOAreaTableMeta::Instance(), HOTFIX_SEL_WMO_AREA_TABLE }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, WMOAreaTableMeta::Instance(), HOTFIX_SEL_WMO_AREA_TABLE); + return &loadInfo; } }; struct WorldMapAreaLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4659,13 +4862,14 @@ struct WorldMapAreaLoadInfo { false, FT_INT, "ID" }, { false, FT_INT, "PlayerConditionID" }, }; - return { &fields[0], std::extent::value, WorldMapAreaMeta::Instance(), HOTFIX_SEL_WORLD_MAP_AREA }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, WorldMapAreaMeta::Instance(), HOTFIX_SEL_WORLD_MAP_AREA); + return &loadInfo; } }; struct WorldMapOverlayLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4687,13 +4891,14 @@ struct WorldMapOverlayLoadInfo { false, FT_INT, "PlayerConditionID" }, { false, FT_INT, "Flags" }, }; - return { &fields[0], std::extent::value, WorldMapOverlayMeta::Instance(), HOTFIX_SEL_WORLD_MAP_OVERLAY }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, WorldMapOverlayMeta::Instance(), HOTFIX_SEL_WORLD_MAP_OVERLAY); + return &loadInfo; } }; struct WorldMapTransformsLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4714,13 +4919,14 @@ struct WorldMapTransformsLoadInfo { false, FT_SHORT, "NewAreaID" }, { false, FT_BYTE, "Flags" }, }; - return { &fields[0], std::extent::value, WorldMapTransformsMeta::Instance(), HOTFIX_SEL_WORLD_MAP_TRANSFORMS }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, WorldMapTransformsMeta::Instance(), HOTFIX_SEL_WORLD_MAP_TRANSFORMS); + return &loadInfo; } }; struct WorldSafeLocsLoadInfo { - static DB2LoadInfo Instance() + static DB2LoadInfo const* Instance() { static DB2FieldMeta const fields[] = { @@ -4732,7 +4938,8 @@ struct WorldSafeLocsLoadInfo { false, FT_STRING, "AreaName" }, { false, FT_SHORT, "MapID" }, }; - return { &fields[0], std::extent::value, WorldSafeLocsMeta::Instance(), HOTFIX_SEL_WORLD_SAFE_LOCS }; + static DB2LoadInfo const loadInfo(&fields[0], std::extent::value, WorldSafeLocsMeta::Instance(), HOTFIX_SEL_WORLD_SAFE_LOCS); + return &loadInfo; } }; diff --git a/src/server/shared/DataStores/DB2DatabaseLoader.cpp b/src/server/shared/DataStores/DB2DatabaseLoader.cpp new file mode 100644 index 00000000000..a19b8a5b389 --- /dev/null +++ b/src/server/shared/DataStores/DB2DatabaseLoader.cpp @@ -0,0 +1,301 @@ +/* + * Copyright (C) 2008-2017 TrinityCore + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with this program. If not, see . + */ + +#include "DB2DatabaseLoader.h" +#include "Database/DatabaseEnv.h" +#include "DB2Meta.h" + +DB2LoadInfo::DB2LoadInfo() : DB2FileLoadInfo() +{ +} + +DB2LoadInfo::DB2LoadInfo(DB2FieldMeta const* fields, std::size_t fieldCount, DB2Meta const* meta, HotfixDatabaseStatements statement) + : DB2FileLoadInfo(fields, fieldCount, meta), Statement(statement) +{ +} + +static char const* nullStr = ""; + +char* DB2DatabaseLoader::Load(uint32& records, char**& indexTable, char*& stringHolders, std::vector& stringPool) +{ + // Even though this query is executed only once, prepared statement is used to send data from mysql server in binary format + PreparedQueryResult result = HotfixDatabase.Query(HotfixDatabase.GetPreparedStatement(_loadInfo->Statement)); + if (!result) + return nullptr; + + if (_loadInfo->Meta->GetDbFieldCount() != result->GetFieldCount()) + return nullptr; + + // get struct size and index pos + uint32 indexField = _loadInfo->Meta->GetDbIndexField(); + uint32 recordSize = _loadInfo->Meta->GetRecordSize(); + + // we store flat holders pool as single memory block + std::size_t stringFields = _loadInfo->GetStringFieldCount(false); + std::size_t localizedStringFields = _loadInfo->GetStringFieldCount(true); + + // each string field at load have array of string for each locale + std::size_t stringHoldersRecordPoolSize = localizedStringFields * sizeof(LocalizedString) + (stringFields - localizedStringFields) * sizeof(char*); + + if (stringFields) + { + std::size_t stringHoldersPoolSize = stringHoldersRecordPoolSize * result->GetRowCount(); + stringHolders = new char[stringHoldersPoolSize]; + + // DB2 strings expected to have at least empty string + for (std::size_t i = 0; i < stringHoldersPoolSize / sizeof(char*); ++i) + ((char const**)stringHolders)[i] = nullStr; + } + else + stringHolders = nullptr; + + // Resize index table + // database query *MUST* contain ORDER BY `index_field` DESC clause + uint32 indexTableSize = (*result)[indexField].GetUInt32() + 1; + if (indexTableSize < records) + indexTableSize = records; + + if (indexTableSize > records) + { + char** tmpIdxTable = new char*[indexTableSize]; + memset(tmpIdxTable, 0, indexTableSize * sizeof(char*)); + memcpy(tmpIdxTable, indexTable, records * sizeof(char*)); + delete[] indexTable; + indexTable = tmpIdxTable; + } + + char* tempDataTable = new char[result->GetRowCount() * recordSize]; + uint32* newIndexes = new uint32[result->GetRowCount()]; + uint32 rec = 0; + uint32 newRecords = 0; + + do + { + Field* fields = result->Fetch(); + uint32 offset = 0; + uint32 stringFieldOffset = 0; + + uint32 indexValue = fields[indexField].GetUInt32(); + + // Attempt to overwrite existing data + char* dataValue = indexTable[indexValue]; + if (!dataValue) + { + newIndexes[newRecords] = indexValue; + dataValue = &tempDataTable[newRecords++ * recordSize]; + } + + uint32 f = 0; + if (!_loadInfo->Meta->HasIndexFieldInData()) + { + *((uint32*)(&dataValue[offset])) = indexValue; + offset += 4; + ++f; + } + + for (uint32 x = 0; x < _loadInfo->Meta->FieldCount; ++x) + { + for (uint32 z = 0; z < _loadInfo->Meta->ArraySizes[x]; ++z) + { + switch (_loadInfo->TypesString[f]) + { + case FT_FLOAT: + *((float*)(&dataValue[offset])) = fields[f].GetFloat(); + offset += 4; + break; + case FT_INT: + *((int32*)(&dataValue[offset])) = fields[f].GetInt32(); + offset += 4; + break; + case FT_BYTE: + *((int8*)(&dataValue[offset])) = fields[f].GetInt8(); + offset += 1; + break; + case FT_SHORT: + *((int16*)(&dataValue[offset])) = fields[f].GetInt16(); + offset += 2; + break; + case FT_STRING: + { + LocalizedString** slot = (LocalizedString**)(&dataValue[offset]); + *slot = (LocalizedString*)(&stringHolders[stringHoldersRecordPoolSize * rec + stringFieldOffset]); + ASSERT(*slot); + + // Value in database in main table field must be for enUS locale + if (char* str = AddString(&(*slot)->Str[LOCALE_enUS], fields[f].GetString())) + stringPool.push_back(str); + + stringFieldOffset += sizeof(LocalizedString); + offset += sizeof(char*); + break; + } + case FT_STRING_NOT_LOCALIZED: + { + char const** slot = (char const**)(&dataValue[offset]); + *slot = (char*)(&stringHolders[stringHoldersRecordPoolSize * rec + stringFieldOffset]); + ASSERT(*slot); + + // Value in database in main table field must be for enUS locale + if (char* str = AddString(slot, fields[f].GetString())) + stringPool.push_back(str); + + stringFieldOffset += sizeof(char*); + offset += sizeof(char*); + break; + } + default: + ASSERT(false, "Unknown format character '%c' found in %s meta", _loadInfo->TypesString[x], _storageName.c_str()); + break; + } + ++f; + } + } + + ASSERT(offset == recordSize); + ++rec; + } while (result->NextRow()); + + if (!newRecords) + { + delete[] tempDataTable; + delete[] newIndexes; + return nullptr; + } + + // Compact new data table to only contain new records not previously loaded from file + char* dataTable = new char[newRecords * recordSize]; + memcpy(dataTable, tempDataTable, newRecords * recordSize); + + // insert new records to index table + for (uint32 i = 0; i < newRecords; ++i) + indexTable[newIndexes[i]] = &dataTable[i * recordSize]; + + delete[] tempDataTable; + delete[] newIndexes; + + records = indexTableSize; + + return dataTable; +} + +void DB2DatabaseLoader::LoadStrings(uint32 locale, uint32 records, char** indexTable, std::vector& stringPool) +{ + PreparedStatement* stmt = HotfixDatabase.GetPreparedStatement(HotfixDatabaseStatements(_loadInfo->Statement + 1)); + stmt->setString(0, localeNames[locale]); + PreparedQueryResult result = HotfixDatabase.Query(stmt); + if (!result) + return; + + std::size_t stringFields = _loadInfo->GetStringFieldCount(true); + if (result->GetFieldCount() != stringFields + 1 /*ID*/) + return; + + uint32 fieldCount = _loadInfo->Meta->FieldCount; + uint32 recordSize = _loadInfo->Meta->GetRecordSize(); + + do + { + Field* fields = result->Fetch(); + uint32 offset = 0; + uint32 stringFieldNumInRecord = 0; + uint32 indexValue = fields[0].GetUInt32(); + + if (indexValue >= records) + continue; + + // Attempt to overwrite existing data + if (char* dataValue = indexTable[indexValue]) + { + uint32 fieldIndex = 0; + if (!_loadInfo->Meta->HasIndexFieldInData()) + { + offset += 4; + ++fieldIndex; + } + + for (uint32 x = 0; x < fieldCount; ++x) + { + for (uint32 z = 0; z < _loadInfo->Meta->ArraySizes[x]; ++z) + { + switch (_loadInfo->TypesString[fieldIndex]) + { + case FT_FLOAT: + case FT_INT: + offset += 4; + break; + case FT_BYTE: + offset += 1; + break; + case FT_SHORT: + offset += 2; + break; + case FT_STRING: + { + // fill only not filled entries + LocalizedString* db2str = *(LocalizedString**)(&dataValue[offset]); + if (db2str->Str[locale] == nullStr) + if (char* str = AddString(&db2str->Str[locale], fields[1 + stringFieldNumInRecord].GetString())) + stringPool.push_back(str); + + ++stringFieldNumInRecord; + offset += sizeof(LocalizedString*); + break; + } + case FT_STRING_NOT_LOCALIZED: + offset += sizeof(char*); + break; + default: + ASSERT(false, "Unknown format character '%c' found in %s meta", _loadInfo->TypesString[x], _storageName.c_str()); + break; + } + ++fieldIndex; + } + } + + ASSERT(offset == recordSize); + } + else + TC_LOG_ERROR("sql.sql", "Hotfix locale table for storage %s references row that does not exist %u locale %s!", _storageName.c_str(), indexValue, localeNames[locale]); + + } while (result->NextRow()); + + return; +} + +char* DB2DatabaseLoader::AddString(char const** holder, std::string const& value) +{ + if (!value.empty()) + { + std::size_t existingLength = strlen(*holder); + if (existingLength >= value.length()) + { + // Reuse existing storage if there is enough space + char* str = const_cast(*holder); + memcpy(str, value.c_str(), value.length()); + str[value.length()] = '\0'; + return nullptr; + } + + char* str = new char[value.length() + 1]; + memcpy(str, value.c_str(), value.length()); + str[value.length()] = '\0'; + *holder = str; + return str; + } + + return nullptr; +} diff --git a/src/server/shared/DataStores/DB2StorageLoader.h b/src/server/shared/DataStores/DB2DatabaseLoader.h similarity index 53% rename from src/server/shared/DataStores/DB2StorageLoader.h rename to src/server/shared/DataStores/DB2DatabaseLoader.h index 62361edcedd..f288b46859b 100644 --- a/src/server/shared/DataStores/DB2StorageLoader.h +++ b/src/server/shared/DataStores/DB2DatabaseLoader.h @@ -15,67 +15,18 @@ * with this program. If not, see . */ -#ifndef DB2_FILE_LOADER_H -#define DB2_FILE_LOADER_H +#ifndef DB2_DATABASE_LOADER_H +#define DB2_DATABASE_LOADER_H -#include "Define.h" +#include "DB2FileLoader.h" #include "Implementation/HotfixDatabase.h" -class DB2FileLoaderImpl; -struct DB2Meta; -struct DB2FieldMeta; - -#pragma pack(push, 1) -struct DB2Header -{ - uint32 Signature; - uint32 RecordCount; - uint32 FieldCount; - uint32 RecordSize; - uint32 StringTableSize; - uint32 TableHash; - uint32 LayoutHash; - uint32 MinId; - uint32 MaxId; - uint32 Locale; - uint32 CopyTableSize; - uint16 Flags; - int16 IndexField; -}; -#pragma pack(pop) - -struct TC_SHARED_API DB2LoadInfo +struct TC_SHARED_API DB2LoadInfo : public DB2FileLoadInfo { DB2LoadInfo(); DB2LoadInfo(DB2FieldMeta const* fields, std::size_t fieldCount, DB2Meta const* meta, HotfixDatabaseStatements statement); - uint32 GetStringFieldCount(bool localizedOnly) const; - - DB2FieldMeta const* Fields; - std::size_t FieldCount; - DB2Meta const* Meta; HotfixDatabaseStatements Statement; - std::string TypesString; -}; - -class TC_SHARED_API DB2FileLoader -{ -public: - DB2FileLoader(); - ~DB2FileLoader(); - - bool Load(char const* filename, DB2LoadInfo const* loadInfo); - char* AutoProduceData(uint32& count, char**& indexTable, std::vector& stringPool); - char* AutoProduceStrings(char* dataTable, uint32 locale); - void AutoProduceRecordCopies(uint32 records, char** indexTable, char* dataTable); - - uint32 GetCols() const { return _header.FieldCount; } - uint32 GetTableHash() const { return _header.TableHash; } - uint32 GetLayoutHash() const { return _header.LayoutHash; } - -private: - DB2FileLoaderImpl* _impl; - DB2Header _header; }; class TC_SHARED_API DB2DatabaseLoader diff --git a/src/server/shared/DataStores/DB2StorageLoader.cpp b/src/server/shared/DataStores/DB2StorageLoader.cpp deleted file mode 100644 index 11caca97afb..00000000000 --- a/src/server/shared/DataStores/DB2StorageLoader.cpp +++ /dev/null @@ -1,1257 +0,0 @@ -/* - * Copyright (C) 2008-2017 TrinityCore - * - * This program is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License as published by the - * Free Software Foundation; either version 2 of the License, or (at your - * option) any later version. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for - * more details. - * - * You should have received a copy of the GNU General Public License along - * with this program. If not, see . - */ - -#include "DB2StorageLoader.h" -#include "Database/DatabaseEnv.h" -#include "DB2Meta.h" -#include "Utilities/ByteConverter.h" - -DB2LoadInfo::DB2LoadInfo() : Fields(nullptr), FieldCount(0), Meta(nullptr), Statement(MAX_HOTFIXDATABASE_STATEMENTS) -{ -} - -DB2LoadInfo::DB2LoadInfo(DB2FieldMeta const* fields, std::size_t fieldCount, DB2Meta const* meta, HotfixDatabaseStatements statement) - : Fields(fields), FieldCount(fieldCount), Meta(meta), Statement(statement) -{ - TypesString.reserve(FieldCount); - for (std::size_t i = 0; i < FieldCount; ++i) - TypesString += char(Fields[i].Type); -} - -uint32 DB2LoadInfo::GetStringFieldCount(bool localizedOnly) const -{ - uint32 stringFields = 0; - for (std::size_t i = 0; i < TypesString.length(); ++i) - if (TypesString[i] == FT_STRING || (TypesString[i] == FT_STRING_NOT_LOCALIZED && !localizedOnly)) - ++stringFields; - - return stringFields; -} - -class DB2FileLoaderImpl -{ -public: - virtual ~DB2FileLoaderImpl() { } - virtual bool Load(char const* filename, FILE* file, DB2LoadInfo const* loadInfo, DB2Header const* header) = 0; - virtual char* AutoProduceData(uint32& count, char**& indexTable, std::vector& stringPool) = 0; - virtual char* AutoProduceStrings(char* dataTable, uint32 locale) = 0; - virtual void AutoProduceRecordCopies(uint32 records, char** indexTable, char* dataTable) = 0; -}; - -class DB2FileLoaderRegularImpl : public DB2FileLoaderImpl -{ -public: - DB2FileLoaderRegularImpl(); - ~DB2FileLoaderRegularImpl(); - - bool Load(char const* filename, FILE* file, DB2LoadInfo const* loadInfo, DB2Header const* header) override; - char* AutoProduceData(uint32& count, char**& indexTable, std::vector& stringPool) override; - char* AutoProduceStrings(char* dataTable, uint32 locale) override; - void AutoProduceRecordCopies(uint32 records, char** indexTable, char* dataTable) override; - -private: - class Record - { - public: - float getFloat(uint32 field, uint32 arrayIndex) const; - uint32 getUInt(uint32 field, uint32 arrayIndex, bool isSigned) const; - uint8 getUInt8(uint32 field, uint32 arrayIndex) const; - uint16 getUInt16(uint32 field, uint32 arrayIndex) const; - char const* getString(uint32 field, uint32 arrayIndex) const; - - private: - uint16 GetOffset(uint32 field) const; - uint16 GetByteSize(uint32 field) const; - uint32 GetVarInt(uint32 field, uint32 arrayIndex, bool isSigned) const; - - Record(DB2FileLoaderRegularImpl &file_, unsigned char *offset_); - unsigned char *offset; - DB2FileLoaderRegularImpl &file; - - friend class DB2FileLoaderRegularImpl; - }; - - // Get record by id - Record getRecord(size_t id); - -#pragma pack(push, 1) - struct FieldEntry - { - uint16 UnusedBits; - uint16 Offset; - }; -#pragma pack(pop) - - char const* fileName; - DB2LoadInfo const* _loadInfo; - DB2Header const* _header; - - unsigned char* data; - unsigned char* stringTable; - unsigned char* idTable; - uint32 idTableSize; - unsigned char* copyTable; - FieldEntry* fields; -}; - -class DB2FileLoaderSparseImpl : public DB2FileLoaderImpl -{ -public: - DB2FileLoaderSparseImpl(); - ~DB2FileLoaderSparseImpl(); - - bool Load(char const* filename, FILE* file, DB2LoadInfo const* loadInfo, DB2Header const* header) override; - char* AutoProduceData(uint32& records, char**& indexTable, std::vector& stringPool) override; - char* AutoProduceStrings(char* dataTable, uint32 locale) override; - void AutoProduceRecordCopies(uint32 /*records*/, char** /*indexTable*/, char* /*dataTable*/) override { } - -private: -#pragma pack(push, 1) - struct OffsetTableEntry - { - uint32 FileOffset; - uint16 RecordSize; - }; - struct FieldEntry - { - uint16 UnusedBits; - uint16 Offset; - }; -#pragma pack(pop) - - char const* fileName; - DB2LoadInfo const* _loadInfo; - DB2Header const* _header; - FieldEntry* fields; - - uint32 dataStart; - unsigned char* data; - OffsetTableEntry* offsets; -}; - -float DB2FileLoaderRegularImpl::Record::getFloat(uint32 field, uint32 arrayIndex) const -{ - ASSERT(field < file._header->FieldCount); - float val = *reinterpret_cast(offset + GetOffset(field) + arrayIndex * sizeof(float)); - EndianConvert(val); - return val; -} - -uint32 DB2FileLoaderRegularImpl::Record::getUInt(uint32 field, uint32 arrayIndex, bool isSigned) const -{ - ASSERT(field < file._header->FieldCount); - return GetVarInt(field, arrayIndex, isSigned); -} - -uint8 DB2FileLoaderRegularImpl::Record::getUInt8(uint32 field, uint32 arrayIndex) const -{ - ASSERT(field < file._header->FieldCount); - ASSERT(GetByteSize(field) == 1); - return *reinterpret_cast(offset + GetOffset(field) + arrayIndex * sizeof(uint8)); -} - -uint16 DB2FileLoaderRegularImpl::Record::getUInt16(uint32 field, uint32 arrayIndex) const -{ - ASSERT(field < file._header->FieldCount); - ASSERT(GetByteSize(field) == 2); - uint16 val = *reinterpret_cast(offset + GetOffset(field) + arrayIndex * sizeof(uint16)); - EndianConvert(val); - return val; -} - -char const* DB2FileLoaderRegularImpl::Record::getString(uint32 field, uint32 arrayIndex) const -{ - ASSERT(field < file._header->FieldCount); - uint32 stringOffset = *reinterpret_cast(offset + GetOffset(field) + arrayIndex * sizeof(uint32)); - EndianConvert(stringOffset); - ASSERT(stringOffset < file._header->StringTableSize); - return reinterpret_cast(file.stringTable + stringOffset); -} - -uint16 DB2FileLoaderRegularImpl::Record::GetOffset(uint32 field) const -{ - ASSERT(field < file._header->FieldCount); - return file.fields[field].Offset; -} - -uint16 DB2FileLoaderRegularImpl::Record::GetByteSize(uint32 field) const -{ - ASSERT(field < file._header->FieldCount); - return 4 - file.fields[field].UnusedBits / 8; -} - -uint32 DB2FileLoaderRegularImpl::Record::GetVarInt(uint32 field, uint32 arrayIndex, bool isSigned) const -{ - ASSERT(field < file._header->FieldCount); - uint32 val = *reinterpret_cast(offset + GetOffset(field) + arrayIndex * (4 - file.fields[field].UnusedBits / 8)); - EndianConvert(val); - if (isSigned) - return int32(val) << file.fields[field].UnusedBits >> file.fields[field].UnusedBits; - - return val << file.fields[field].UnusedBits >> file.fields[field].UnusedBits; -} - -DB2FileLoaderRegularImpl::Record::Record(DB2FileLoaderRegularImpl &file_, unsigned char *offset_) : offset(offset_), file(file_) -{ -} - -DB2FileLoaderRegularImpl::DB2FileLoaderRegularImpl() -{ - fileName = nullptr; - _loadInfo = nullptr; - _header = nullptr; - data = nullptr; - stringTable = nullptr; - idTable = nullptr; - idTableSize = 0; - copyTable = nullptr; - fields = nullptr; -} - -bool DB2FileLoaderRegularImpl::Load(char const* filename, FILE* file, DB2LoadInfo const* loadInfo, DB2Header const* header) -{ - _loadInfo = loadInfo; - _header = header; - ASSERT(_loadInfo->Meta->IndexField == -1 || _loadInfo->Meta->IndexField == int32(header->IndexField)); - - fileName = filename; - fields = new FieldEntry[header->FieldCount]; - if (fread(fields, header->FieldCount * sizeof(FieldEntry), 1, file) != 1) - return false; - - if (!_loadInfo->Meta->HasIndexFieldInData()) - idTableSize = header->RecordCount * sizeof(uint32); - - data = new unsigned char[header->RecordSize * header->RecordCount + header->StringTableSize]; - stringTable = data + header->RecordSize * header->RecordCount; - - if (fread(data, header->RecordSize * header->RecordCount + header->StringTableSize, 1, file) != 1) - return false; - - if (idTableSize) - { - idTable = new unsigned char[idTableSize]; - if (fread(idTable, idTableSize, 1, file) != 1) - return false; - } - - if (header->CopyTableSize) - { - copyTable = new unsigned char[header->CopyTableSize]; - if (fread(copyTable, header->CopyTableSize, 1, file) != 1) - return false; - } - - return true; -} - -DB2FileLoaderRegularImpl::~DB2FileLoaderRegularImpl() -{ - delete[] data; - delete[] idTable; - delete[] copyTable; - delete[] fields; -} - -DB2FileLoaderRegularImpl::Record DB2FileLoaderRegularImpl::getRecord(size_t id) -{ - assert(data); - return Record(*this, data + id * _header->RecordSize); -} - -static char const* const nullStr = ""; - -char* DB2FileLoaderRegularImpl::AutoProduceData(uint32& records, char**& indexTable, std::vector& stringPool) -{ - if (_loadInfo->Meta->FieldCount != _header->FieldCount) - return nullptr; - - //get struct size and index pos - uint32 indexField = _loadInfo->Meta->GetIndexField(); - uint32 recordsize = _loadInfo->Meta->GetRecordSize(); - - uint32 maxi = 0; - //find max index - if (!idTableSize) - { - for (uint32 y = 0; y < _header->RecordCount; ++y) - { - uint32 ind = getRecord(y).getUInt(indexField, 0, false); - if (ind > maxi) - maxi = ind; - } - } - else - { - for (uint32 y = 0; y < _header->RecordCount; ++y) - { - uint32 ind = ((uint32*)idTable)[y]; - if (ind > maxi) - maxi = ind; - } - } - - for (uint32 y = 0; y < _header->CopyTableSize; y += 8) - { - uint32 ind = *((uint32*)(copyTable + y)); - if (ind > maxi) - maxi = ind; - } - - using index_entry_t = char*; - - ++maxi; - records = maxi; - indexTable = new index_entry_t[maxi]; - memset(indexTable, 0, maxi * sizeof(index_entry_t)); - - char* dataTable = new char[(_header->RecordCount + (_header->CopyTableSize / 8)) * recordsize]; - - // we store flat holders pool as single memory block - std::size_t stringFields = _loadInfo->GetStringFieldCount(false); - std::size_t localizedStringFields = _loadInfo->GetStringFieldCount(true); - - // each string field at load have array of string for each locale - std::size_t stringHoldersRecordPoolSize = localizedStringFields * sizeof(LocalizedString) + (stringFields - localizedStringFields) * sizeof(char*); - char* stringHoldersPool = nullptr; - if (stringFields) - { - std::size_t stringHoldersPoolSize = stringHoldersRecordPoolSize * _header->RecordCount; - - stringHoldersPool = new char[stringHoldersPoolSize]; - stringPool.push_back(stringHoldersPool); - - // DB2 strings expected to have at least empty string - for (std::size_t i = 0; i < stringHoldersPoolSize / sizeof(char*); ++i) - ((char const**)stringHoldersPool)[i] = nullStr; - } - - uint32 offset = 0; - - for (uint32 y = 0; y < _header->RecordCount; y++) - { - Record rec = getRecord(y); - uint32 indexVal = _loadInfo->Meta->HasIndexFieldInData() ? rec.getUInt(indexField, 0, false) : ((uint32*)idTable)[y]; - - indexTable[indexVal] = &dataTable[offset]; - - uint32 fieldIndex = 0; - if (!_loadInfo->Meta->HasIndexFieldInData()) - { - *((uint32*)(&dataTable[offset])) = indexVal; - offset += 4; - ++fieldIndex; - } - - uint32 stringFieldOffset = 0; - - for (uint32 x = 0; x < _header->FieldCount; ++x) - { - for (uint32 z = 0; z < _loadInfo->Meta->ArraySizes[x]; ++z) - { - switch (_loadInfo->TypesString[fieldIndex]) - { - case FT_FLOAT: - *((float*)(&dataTable[offset])) = rec.getFloat(x, z); - offset += 4; - break; - case FT_INT: - *((uint32*)(&dataTable[offset])) = rec.getUInt(x, z, _loadInfo->Fields[fieldIndex].IsSigned); - offset += 4; - break; - case FT_BYTE: - *((uint8*)(&dataTable[offset])) = rec.getUInt8(x, z); - offset += 1; - break; - case FT_SHORT: - *((uint16*)(&dataTable[offset])) = rec.getUInt16(x, z); - offset += 2; - break; - case FT_STRING: - case FT_STRING_NOT_LOCALIZED: - { - // init db2 string field slots by pointers to string holders - char const*** slot = (char const***)(&dataTable[offset]); - *slot = (char const**)(&stringHoldersPool[stringHoldersRecordPoolSize * y + stringFieldOffset]); - if (_loadInfo->TypesString[fieldIndex] == FT_STRING) - stringFieldOffset += sizeof(LocalizedString); - else - stringFieldOffset += sizeof(char*); - - offset += sizeof(char*); - break; - } - default: - ASSERT(false, "Unknown format character '%c' found in %s meta", _loadInfo->TypesString[x], fileName); - break; - } - ++fieldIndex; - } - } - } - - return dataTable; -} - -char* DB2FileLoaderRegularImpl::AutoProduceStrings(char* dataTable, uint32 locale) -{ - if (_loadInfo->Meta->FieldCount != _header->FieldCount) - return nullptr; - - if (!(_header->Locale & (1 << locale))) - { - char const* sep = ""; - std::ostringstream str; - for (uint32 i = 0; i < TOTAL_LOCALES; ++i) - { - if (_header->Locale & (1 << i)) - { - str << sep << localeNames[i]; - sep = ", "; - } - } - - TC_LOG_ERROR("", "Attempted to load %s which has locales %s as %s. Check if you placed your localized db2 files in correct directory.", fileName, str.str().c_str(), localeNames[locale]); - return nullptr; - } - - char* stringPool = new char[_header->StringTableSize]; - memcpy(stringPool, stringTable, _header->StringTableSize); - - uint32 offset = 0; - - for (uint32 y = 0; y < _header->RecordCount; y++) - { - uint32 fieldIndex = 0; - if (!_loadInfo->Meta->HasIndexFieldInData()) - { - offset += 4; - ++fieldIndex; - } - - for (uint32 x = 0; x < _header->FieldCount; ++x) - { - for (uint32 z = 0; z < _loadInfo->Meta->ArraySizes[x]; ++z) - { - switch (_loadInfo->TypesString[fieldIndex]) - { - case FT_FLOAT: - case FT_INT: - offset += 4; - break; - case FT_BYTE: - offset += 1; - break; - case FT_SHORT: - offset += 2; - break; - case FT_STRING: - { - // fill only not filled entries - LocalizedString* db2str = *(LocalizedString**)(&dataTable[offset]); - if (db2str->Str[locale] == nullStr) - { - char const* st = getRecord(y).getString(x, z); - db2str->Str[locale] = stringPool + (st - (char const*)stringTable); - } - - offset += sizeof(char*); - break; - } - case FT_STRING_NOT_LOCALIZED: - { - char** db2str = (char**)(&dataTable[offset]); - char const* st = getRecord(y).getString(x, z); - *db2str = stringPool + (st - (char const*)stringTable); - offset += sizeof(char*); - break; - } - default: - ASSERT(false, "Unknown format character '%c' found in %s meta", _loadInfo->TypesString[x], fileName); - break; - } - ++fieldIndex; - } - } - } - - return stringPool; -} - -void DB2FileLoaderRegularImpl::AutoProduceRecordCopies(uint32 records, char** indexTable, char* dataTable) -{ - uint32 recordsize = _loadInfo->Meta->GetRecordSize(); - uint32 offset = _header->RecordCount * recordsize; - uint32* copyIds = (uint32*)copyTable; - for (uint32 c = 0; c < _header->CopyTableSize / 4; c += 2) - { - uint32 to = copyIds[c]; - uint32 from = copyIds[c + 1]; - - if (from && from < records && to < records && indexTable[from]) - { - indexTable[to] = &dataTable[offset]; - memcpy(indexTable[to], indexTable[from], recordsize); - - if (_loadInfo->Meta->HasIndexFieldInData()) - *((uint32*)(&dataTable[offset + fields[_loadInfo->Meta->GetIndexField()].Offset])) = to; - else - *((uint32*)(&dataTable[offset])) = to; - - offset += recordsize; - } - } -} - -DB2FileLoaderSparseImpl::DB2FileLoaderSparseImpl() -{ - fileName = nullptr; - _loadInfo = nullptr; - _header = nullptr; - fields = nullptr; - dataStart = 0; - data = nullptr; - offsets = nullptr; -} - -bool DB2FileLoaderSparseImpl::Load(char const* filename, FILE* file, DB2LoadInfo const* loadInfo, DB2Header const* header) -{ - _loadInfo = loadInfo; - _header = header; - fileName = filename; - - fields = new FieldEntry[header->FieldCount]; - if (fread(fields, header->FieldCount * sizeof(FieldEntry), 1, file) != 1) - return false; - - dataStart = ftell(file); - - data = new unsigned char[header->StringTableSize - dataStart]; - - if (fread(data, header->StringTableSize - dataStart, 1, file) != 1) - return false; - - offsets = new OffsetTableEntry[header->MaxId - header->MinId + 1]; - if (fread(offsets, (header->MaxId - header->MinId + 1) * 6, 1, file) != 1) - return false; - - return true; -} - -DB2FileLoaderSparseImpl::~DB2FileLoaderSparseImpl() -{ - delete[] data; - delete[] offsets; - delete[] fields; -} - -char* DB2FileLoaderSparseImpl::AutoProduceData(uint32& maxId, char**& indexTable, std::vector& stringPool) -{ - if (_loadInfo->Meta->FieldCount != _header->FieldCount) - return NULL; - - //get struct size and index pos - uint32 recordsize = _loadInfo->Meta->GetRecordSize(); - - uint32 offsetCount = _header->MaxId - _header->MinId + 1; - uint32 records = 0; - uint32 expandedDataSize = 0; - for (uint32 i = 0; i < offsetCount; ++i) - { - if (offsets[i].FileOffset && offsets[i].RecordSize) - { - ++records; - expandedDataSize += offsets[i].RecordSize; - } - } - - using index_entry_t = char*; - - maxId = _header->MaxId + 1; - indexTable = new index_entry_t[maxId]; - memset(indexTable, 0, maxId * sizeof(index_entry_t)); - - char* dataTable = new char[records * recordsize]; - - // we store flat holders pool as single memory block - std::size_t stringFields = _loadInfo->GetStringFieldCount(false); - std::size_t localizedStringFields = _loadInfo->GetStringFieldCount(true); - - // each string field at load have array of string for each locale - std::size_t stringHoldersRecordPoolSize = localizedStringFields * sizeof(LocalizedString) + (stringFields - localizedStringFields) * sizeof(char*); - std::size_t stringHoldersPoolSize = stringHoldersRecordPoolSize * records; - - char* stringHoldersPool = new char[stringHoldersPoolSize]; - stringPool.push_back(stringHoldersPool); - - // DB2 strings expected to have at least empty string - for (std::size_t i = 0; i < stringHoldersPoolSize / sizeof(char*); ++i) - ((char const**)stringHoldersPool)[i] = nullStr; - - char* stringTable = new char[expandedDataSize - records * ((recordsize - (!_loadInfo->Meta->HasIndexFieldInData() ? 4 : 0)) - stringFields * sizeof(char*))]; - memset(stringTable, 0, expandedDataSize - records * ((recordsize - (!_loadInfo->Meta->HasIndexFieldInData() ? 4 : 0)) - stringFields * sizeof(char*))); - stringPool.push_back(stringTable); - char* stringPtr = stringTable; - - uint32 offset = 0; - uint32 recordNum = 0; - for (uint32 y = 0; y < offsetCount; ++y) - { - if (!offsets[y].FileOffset || !offsets[y].RecordSize) - continue; - - indexTable[y + _header->MinId] = &dataTable[offset]; - ASSERT(indexTable[y + _header->MinId]); - std::size_t fieldOffset = 0; - uint32 stringFieldOffset = 0; - - uint32 fieldIndex = 0; - if (!_loadInfo->Meta->HasIndexFieldInData()) - { - *((uint32*)(&dataTable[offset])) = y + _header->MinId; - offset += 4; - ++fieldIndex; - } - - for (uint32 x = 0; x < _header->FieldCount; ++x) - { - uint16 fieldBytes = 4 - fields[x].UnusedBits / 8; - for (uint32 z = 0; z < _loadInfo->Meta->ArraySizes[x]; ++z) - { - switch (_loadInfo->TypesString[fieldIndex]) - { - case FT_FLOAT: - { - float val = *reinterpret_cast(&data[offsets[y].FileOffset - dataStart + fieldOffset]); - EndianConvert(val); - *((float*)(&dataTable[offset])) = val; - offset += 4; - fieldOffset += 4; - break; - } - case FT_INT: - { - ASSERT(fieldBytes && fieldBytes <= 4); - uint32 val = 0; - switch (fieldBytes) - { - case 1: - val = *reinterpret_cast(&data[offsets[y].FileOffset - dataStart + fieldOffset]); - break; - case 2: - { - uint16 val16 = *reinterpret_cast(&data[offsets[y].FileOffset - dataStart + fieldOffset]); - EndianConvert(val16); - val = val16; - break; - } - case 3: - { -#pragma pack(push, 1) - struct dbcint24 { uint8 v[3]; }; -#pragma pack(pop) - dbcint24 i24v = *reinterpret_cast(&data[offsets[y].FileOffset - dataStart + fieldOffset]); - EndianConvert(i24v); - val = uint32(i24v.v[0]) | (uint32(i24v.v[1]) << 8) | (uint32(i24v.v[2]) << 16); - break; - } - case 4: - val = *reinterpret_cast(&data[offsets[y].FileOffset - dataStart + fieldOffset]); - EndianConvert(val); - break; - default: - break; - } - *((uint32*)(&dataTable[offset])) = val; - offset += 4; - fieldOffset += fieldBytes; - break; - } - case FT_BYTE: - { - ASSERT(fieldBytes == 1); - *((uint8*)(&dataTable[offset])) = *reinterpret_cast(&data[offsets[y].FileOffset - dataStart + fieldOffset]); - offset += 1; - fieldOffset += 1; - break; - } - case FT_SHORT: - { - ASSERT(fieldBytes == 2); - uint16 val = *reinterpret_cast(&data[offsets[y].FileOffset - dataStart + fieldOffset]); - EndianConvert(val); - *((uint16*)(&dataTable[offset])) = val; - offset += 2; - fieldOffset += 2; - break; - } - case FT_STRING: - { - LocalizedString** slot = (LocalizedString**)(&dataTable[offset]); - *slot = (LocalizedString*)(&stringHoldersPool[stringHoldersRecordPoolSize * recordNum + stringFieldOffset]); - for (uint32 locale = 0; locale < TOTAL_LOCALES; ++locale) - if (_header->Locale & (1 << locale)) - (*slot)->Str[locale] = stringPtr; - strcpy(stringPtr, (char*)&data[offsets[y].FileOffset - dataStart + fieldOffset]); - fieldOffset += strlen(stringPtr) + 1; - stringPtr += strlen(stringPtr) + 1; - stringFieldOffset += sizeof(LocalizedString); - offset += sizeof(LocalizedString*); - break; - } - case FT_STRING_NOT_LOCALIZED: - { - char const*** slot = (char const***)(&dataTable[offset]); - *slot = (char const**)(&stringHoldersPool[stringHoldersRecordPoolSize * recordNum + stringFieldOffset]); - **slot = stringPtr; - strcpy(stringPtr, (char*)&data[offsets[y].FileOffset - dataStart + fieldOffset]); - fieldOffset += strlen(stringPtr) + 1; - stringPtr += strlen(stringPtr) + 1; - stringFieldOffset += sizeof(char*); - offset += sizeof(char*); - break; - } - default: - ASSERT(false, "Unknown format character '%c' found in %s meta", _loadInfo->TypesString[x], fileName); - break; - } - ++fieldIndex; - } - } - - ++recordNum; - } - - return dataTable; -} - -char* DB2FileLoaderSparseImpl::AutoProduceStrings(char* dataTable, uint32 locale) -{ - if (_loadInfo->Meta->FieldCount != _header->FieldCount) - return nullptr; - - if (!(_header->Locale & (1 << locale))) - { - char const* sep = ""; - std::ostringstream str; - for (uint32 i = 0; i < TOTAL_LOCALES; ++i) - { - if (_header->Locale & (1 << i)) - { - str << sep << localeNames[i]; - sep = ", "; - } - } - - TC_LOG_ERROR("", "Attempted to load %s which has locales %s as %s. Check if you placed your localized db2 files in correct directory.", fileName, str.str().c_str(), localeNames[locale]); - return nullptr; - } - - uint32 offsetCount = _header->MaxId - _header->MinId + 1; - uint32 records = 0; - for (uint32 i = 0; i < offsetCount; ++i) - if (offsets[i].FileOffset && offsets[i].RecordSize) - ++records; - - uint32 recordsize = _loadInfo->Meta->GetRecordSize(); - std::size_t stringFields = _loadInfo->GetStringFieldCount(true); - char* stringTable = new char[_header->StringTableSize - dataStart - records * ((recordsize - (!_loadInfo->Meta->HasIndexFieldInData() ? 4 : 0)) - stringFields * sizeof(char*))]; - memset(stringTable, 0, _header->StringTableSize - dataStart - records * ((recordsize - (!_loadInfo->Meta->HasIndexFieldInData() ? 4 : 0)) - stringFields * sizeof(char*))); - char* stringPtr = stringTable; - - uint32 offset = 0; - - for (uint32 y = 0; y < offsetCount; y++) - { - if (!offsets[y].FileOffset || !offsets[y].RecordSize) - continue; - - uint32 fieldIndex = 0; - if (!_loadInfo->Meta->HasIndexFieldInData()) - { - offset += 4; - ++fieldIndex; - } - - std::size_t fieldOffset = 0; - for (uint32 x = 0; x < _header->FieldCount; ++x) - { - for (uint32 z = 0; z < _loadInfo->Meta->ArraySizes[x]; ++z) - { - switch (_loadInfo->TypesString[fieldIndex]) - { - case FT_FLOAT: - offset += 4; - fieldOffset += 4; - break; - case FT_INT: - offset += 4; - fieldOffset += 4 - fields[x].UnusedBits / 8; - break; - case FT_BYTE: - offset += 1; - fieldOffset += 1; - break; - case FT_SHORT: - offset += 2; - fieldOffset += 2; - break; - case FT_STRING: - { - LocalizedString* db2str = *(LocalizedString**)(&dataTable[offset]); - db2str->Str[locale] = stringPtr; - strcpy(stringPtr, (char*)&data[offsets[y].FileOffset - dataStart + fieldOffset]); - fieldOffset += strlen(stringPtr) + 1; - stringPtr += strlen(stringPtr) + 1; - offset += sizeof(char*); - break; - } - case FT_STRING_NOT_LOCALIZED: - { - fieldOffset += strlen((char*)&data[offsets[y].FileOffset - dataStart + fieldOffset]) + 1; - offset += sizeof(char*); - break; - } - default: - ASSERT(false, "Unknown format character '%c' found in %s meta", _loadInfo->TypesString[x], fileName); - break; - } - ++fieldIndex; - } - } - } - - return stringTable; -} - -char* DB2DatabaseLoader::Load(uint32& records, char**& indexTable, char*& stringHolders, std::vector& stringPool) -{ - // Even though this query is executed only once, prepared statement is used to send data from mysql server in binary format - PreparedQueryResult result = HotfixDatabase.Query(HotfixDatabase.GetPreparedStatement(_loadInfo->Statement)); - if (!result) - return nullptr; - - if (_loadInfo->Meta->GetDbFieldCount() != result->GetFieldCount()) - return nullptr; - - // get struct size and index pos - uint32 indexField = _loadInfo->Meta->GetDbIndexField(); - uint32 recordSize = _loadInfo->Meta->GetRecordSize(); - - // we store flat holders pool as single memory block - std::size_t stringFields = _loadInfo->GetStringFieldCount(false); - std::size_t localizedStringFields = _loadInfo->GetStringFieldCount(true); - - // each string field at load have array of string for each locale - std::size_t stringHoldersRecordPoolSize = localizedStringFields * sizeof(LocalizedString) + (stringFields - localizedStringFields) * sizeof(char*); - - if (stringFields) - { - std::size_t stringHoldersPoolSize = stringHoldersRecordPoolSize * result->GetRowCount(); - stringHolders = new char[stringHoldersPoolSize]; - - // DB2 strings expected to have at least empty string - for (std::size_t i = 0; i < stringHoldersPoolSize / sizeof(char*); ++i) - ((char const**)stringHolders)[i] = nullStr; - } - else - stringHolders = nullptr; - - // Resize index table - // database query *MUST* contain ORDER BY `index_field` DESC clause - uint32 indexTableSize = (*result)[indexField].GetUInt32() + 1; - if (indexTableSize < records) - indexTableSize = records; - - if (indexTableSize > records) - { - char** tmpIdxTable = new char*[indexTableSize]; - memset(tmpIdxTable, 0, indexTableSize * sizeof(char*)); - memcpy(tmpIdxTable, indexTable, records * sizeof(char*)); - delete[] indexTable; - indexTable = tmpIdxTable; - } - - char* tempDataTable = new char[result->GetRowCount() * recordSize]; - uint32* newIndexes = new uint32[result->GetRowCount()]; - uint32 rec = 0; - uint32 newRecords = 0; - - do - { - Field* fields = result->Fetch(); - uint32 offset = 0; - uint32 stringFieldOffset = 0; - - uint32 indexValue = fields[indexField].GetUInt32(); - - // Attempt to overwrite existing data - char* dataValue = indexTable[indexValue]; - if (!dataValue) - { - newIndexes[newRecords] = indexValue; - dataValue = &tempDataTable[newRecords++ * recordSize]; - } - - uint32 f = 0; - if (!_loadInfo->Meta->HasIndexFieldInData()) - { - *((uint32*)(&dataValue[offset])) = indexValue; - offset += 4; - ++f; - } - - for (uint32 x = 0; x < _loadInfo->Meta->FieldCount; ++x) - { - for (uint32 z = 0; z < _loadInfo->Meta->ArraySizes[x]; ++z) - { - switch (_loadInfo->TypesString[f]) - { - case FT_FLOAT: - *((float*)(&dataValue[offset])) = fields[f].GetFloat(); - offset += 4; - break; - case FT_INT: - *((int32*)(&dataValue[offset])) = fields[f].GetInt32(); - offset += 4; - break; - case FT_BYTE: - *((int8*)(&dataValue[offset])) = fields[f].GetInt8(); - offset += 1; - break; - case FT_SHORT: - *((int16*)(&dataValue[offset])) = fields[f].GetInt16(); - offset += 2; - break; - case FT_STRING: - { - LocalizedString** slot = (LocalizedString**)(&dataValue[offset]); - *slot = (LocalizedString*)(&stringHolders[stringHoldersRecordPoolSize * rec + stringFieldOffset]); - ASSERT(*slot); - - // Value in database in main table field must be for enUS locale - if (char* str = AddString(&(*slot)->Str[LOCALE_enUS], fields[f].GetString())) - stringPool.push_back(str); - - stringFieldOffset += sizeof(LocalizedString); - offset += sizeof(char*); - break; - } - case FT_STRING_NOT_LOCALIZED: - { - char const** slot = (char const**)(&dataValue[offset]); - *slot = (char*)(&stringHolders[stringHoldersRecordPoolSize * rec + stringFieldOffset]); - ASSERT(*slot); - - // Value in database in main table field must be for enUS locale - if (char* str = AddString(slot, fields[f].GetString())) - stringPool.push_back(str); - - stringFieldOffset += sizeof(char*); - offset += sizeof(char*); - break; - } - default: - ASSERT(false, "Unknown format character '%c' found in %s meta", _loadInfo->TypesString[x], _storageName.c_str()); - break; - } - ++f; - } - } - - ASSERT(offset == recordSize); - ++rec; - } while (result->NextRow()); - - if (!newRecords) - { - delete[] tempDataTable; - delete[] newIndexes; - return nullptr; - } - - // Compact new data table to only contain new records not previously loaded from file - char* dataTable = new char[newRecords * recordSize]; - memcpy(dataTable, tempDataTable, newRecords * recordSize); - - // insert new records to index table - for (uint32 i = 0; i < newRecords; ++i) - indexTable[newIndexes[i]] = &dataTable[i * recordSize]; - - delete[] tempDataTable; - delete[] newIndexes; - - records = indexTableSize; - - return dataTable; -} - -void DB2DatabaseLoader::LoadStrings(uint32 locale, uint32 records, char** indexTable, std::vector& stringPool) -{ - PreparedStatement* stmt = HotfixDatabase.GetPreparedStatement(HotfixDatabaseStatements(_loadInfo->Statement + 1)); - stmt->setString(0, localeNames[locale]); - PreparedQueryResult result = HotfixDatabase.Query(stmt); - if (!result) - return; - - std::size_t stringFields = _loadInfo->GetStringFieldCount(true); - if (result->GetFieldCount() != stringFields + 1 /*ID*/) - return; - - uint32 fieldCount = _loadInfo->Meta->FieldCount; - uint32 recordSize = _loadInfo->Meta->GetRecordSize(); - - do - { - Field* fields = result->Fetch(); - uint32 offset = 0; - uint32 stringFieldNumInRecord = 0; - uint32 indexValue = fields[0].GetUInt32(); - - if (indexValue >= records) - continue; - - // Attempt to overwrite existing data - if (char* dataValue = indexTable[indexValue]) - { - uint32 fieldIndex = 0; - if (!_loadInfo->Meta->HasIndexFieldInData()) - { - offset += 4; - ++fieldIndex; - } - - for (uint32 x = 0; x < fieldCount; ++x) - { - for (uint32 z = 0; z < _loadInfo->Meta->ArraySizes[x]; ++z) - { - switch (_loadInfo->TypesString[fieldIndex]) - { - case FT_FLOAT: - case FT_INT: - offset += 4; - break; - case FT_BYTE: - offset += 1; - break; - case FT_SHORT: - offset += 2; - break; - case FT_STRING: - { - // fill only not filled entries - LocalizedString* db2str = *(LocalizedString**)(&dataValue[offset]); - if (db2str->Str[locale] == nullStr) - if (char* str = AddString(&db2str->Str[locale], fields[1 + stringFieldNumInRecord].GetString())) - stringPool.push_back(str); - - ++stringFieldNumInRecord; - offset += sizeof(LocalizedString*); - break; - } - case FT_STRING_NOT_LOCALIZED: - offset += sizeof(char*); - break; - default: - ASSERT(false, "Unknown format character '%c' found in %s meta", _loadInfo->TypesString[x], _storageName.c_str()); - break; - } - ++fieldIndex; - } - } - - ASSERT(offset == recordSize); - } - else - TC_LOG_ERROR("sql.sql", "Hotfix locale table for storage %s references row that does not exist %u locale %s!", _storageName.c_str(), indexValue, localeNames[locale]); - - } while (result->NextRow()); - - return; -} - -char* DB2DatabaseLoader::AddString(char const** holder, std::string const& value) -{ - if (!value.empty()) - { - std::size_t existingLength = strlen(*holder); - if (existingLength >= value.length()) - { - // Reuse existing storage if there is enough space - char* str = const_cast(*holder); - memcpy(str, value.c_str(), value.length()); - str[value.length()] = '\0'; - return nullptr; - } - - char* str = new char[value.length() + 1]; - memcpy(str, value.c_str(), value.length()); - str[value.length()] = '\0'; - *holder = str; - return str; - } - - return nullptr; -} - -DB2FileLoader::DB2FileLoader() : _impl(nullptr) -{ -} - -DB2FileLoader::~DB2FileLoader() -{ - delete _impl; -} - -bool DB2FileLoader::Load(char const* filename, DB2LoadInfo const* loadInfo) -{ - FILE* f = fopen(filename, "rb"); - if (!f) - return false; - - if (fread(&_header.Signature, 4, 1, f) != 1) // Signature - { - fclose(f); - return false; - } - - EndianConvert(_header.Signature); - - if (_header.Signature != 0x35424457) - { - fclose(f); - return false; //'WDB5' - } - - if (fread(&_header.RecordCount, 4, 1, f) != 1) // Number of records - { - fclose(f); - return false; - } - - EndianConvert(_header.RecordCount); - - if (fread(&_header.FieldCount, 4, 1, f) != 1) // Number of fields - { - fclose(f); - return false; - } - - EndianConvert(_header.FieldCount); - - if (fread(&_header.RecordSize, 4, 1, f) != 1) // Size of a record - { - fclose(f); - return false; - } - - EndianConvert(_header.RecordSize); - - if (fread(&_header.StringTableSize, 4, 1, f) != 1) // String size - { - fclose(f); - return false; - } - - EndianConvert(_header.StringTableSize); - - if (fread(&_header.TableHash, 4, 1, f) != 1) // Table hash - { - fclose(f); - return false; - } - - EndianConvert(_header.TableHash); - - if (fread(&_header.LayoutHash, 4, 1, f) != 1) // Layout hash - { - fclose(f); - return false; - } - - EndianConvert(_header.LayoutHash); - - if (_header.LayoutHash != loadInfo->Meta->LayoutHash) - { - fclose(f); - return false; - } - - if (fread(&_header.MinId, 4, 1, f) != 1) // MinIndex WDB2 - { - fclose(f); - return false; - } - - EndianConvert(_header.MinId); - - if (fread(&_header.MaxId, 4, 1, f) != 1) // MaxIndex WDB2 - { - fclose(f); - return false; - } - - EndianConvert(_header.MaxId); - - if (fread(&_header.Locale, 4, 1, f) != 1) // Locales - { - fclose(f); - return false; - } - - EndianConvert(_header.Locale); - - if (fread(&_header.CopyTableSize, 4, 1, f) != 1) - { - fclose(f); - return false; - } - - EndianConvert(_header.CopyTableSize); - - if (fread(&_header.Flags, 4, 1, f) != 1) - { - fclose(f); - return false; - } - - EndianConvert(_header.Flags); - - if (!(_header.Flags & 0x1)) - _impl = new DB2FileLoaderRegularImpl(); - else - _impl = new DB2FileLoaderSparseImpl(); - - bool result = _impl->Load(filename, f, loadInfo, &_header); - fclose(f); - return result; -} - -char* DB2FileLoader::AutoProduceData(uint32& count, char**& indexTable, std::vector& stringPool) -{ - return _impl->AutoProduceData(count, indexTable, stringPool); -} - -char* DB2FileLoader::AutoProduceStrings(char* dataTable, uint32 locale) -{ - return _impl->AutoProduceStrings(dataTable, locale); -} - -void DB2FileLoader::AutoProduceRecordCopies(uint32 records, char** indexTable, char* dataTable) -{ - _impl->AutoProduceRecordCopies(records, indexTable, dataTable); -} diff --git a/src/server/shared/DataStores/DB2Store.cpp b/src/server/shared/DataStores/DB2Store.cpp new file mode 100644 index 00000000000..bb36ed6b61b --- /dev/null +++ b/src/server/shared/DataStores/DB2Store.cpp @@ -0,0 +1,189 @@ +/* + * Copyright (C) 2008-2017 TrinityCore + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with this program. If not, see . + */ + +#include "DB2Store.h" +#include "ByteBuffer.h" +#include "DB2DatabaseLoader.h" +#include "DB2Meta.h" + +struct DB2FileSystemSource : public DB2FileSource +{ + DB2FileSystemSource(std::string const& fileName) + { + _fileName = fileName; + _file = fopen(_fileName.c_str(), "rb"); + } + + ~DB2FileSystemSource() + { + if (_file) + fclose(_file); + } + + bool IsOpen() const override + { + return _file != nullptr; + } + + bool Read(void* buffer, std::size_t numBytes) override + { + return fread(buffer, numBytes, 1, _file) == 1; + } + + std::size_t GetPosition() const override + { + return ftell(_file); + } + + char const* GetFileName() const override + { + return _fileName.c_str(); + } + +private: + std::string _fileName; + FILE* _file; +}; + +DB2StorageBase::DB2StorageBase(char const* fileName, DB2LoadInfo const* loadInfo) + : _tableHash(0), _layoutHash(0), _fileName(fileName), _fieldCount(0), _loadInfo(loadInfo), _dataTable(nullptr), _dataTableEx(nullptr), _indexTableSize(0) +{ +} + +DB2StorageBase::~DB2StorageBase() +{ + delete[] _dataTable; + delete[] _dataTableEx; + for (char* strings : _stringPool) + delete[] strings; +} + +void DB2StorageBase::WriteRecordData(char const* entry, uint32 locale, ByteBuffer& buffer) const +{ + std::size_t i = 0; + if (!_loadInfo->Meta->HasIndexFieldInData()) + { + entry += 4; + ++i; + } + + for (; i < _loadInfo->FieldCount; ++i) + { + switch (_loadInfo->TypesString[i]) + { + case FT_INT: + buffer << *(uint32*)entry; + entry += 4; + break; + case FT_FLOAT: + buffer << *(float*)entry; + entry += 4; + break; + case FT_BYTE: + buffer << *(uint8*)entry; + entry += 1; + break; + case FT_SHORT: + buffer << *(uint16*)entry; + entry += 2; + break; + case FT_STRING: + { + LocalizedString* locStr = *(LocalizedString**)entry; + if (locStr->Str[locale][0] == '\0') + locale = 0; + + buffer << locStr->Str[locale]; + entry += sizeof(LocalizedString*); + break; + } + case FT_STRING_NOT_LOCALIZED: + { + buffer << *(char const**)entry; + entry += sizeof(char const*); + break; + } + } + } +} + +bool DB2StorageBase::Load(std::string const& path, uint32 locale, char**& indexTable) +{ + indexTable = nullptr; + DB2FileLoader db2; + { + DB2FileSystemSource source(path + _fileName); + // Check if load was successful, only then continue + if (!db2.Load(&source, _loadInfo)) + return false; + } + + _fieldCount = db2.GetCols(); + _tableHash = db2.GetTableHash(); + _layoutHash = db2.GetLayoutHash(); + + // load raw non-string data + _dataTable = db2.AutoProduceData(_indexTableSize, indexTable, _stringPool); + + // load strings from db2 data + if (!_stringPool.empty()) + if (char* stringBlock = db2.AutoProduceStrings(_dataTable, locale)) + _stringPool.push_back(stringBlock); + + db2.AutoProduceRecordCopies(_indexTableSize, indexTable, _dataTable); + + // error in db2 file at loading if NULL + return indexTable != nullptr; +} + +bool DB2StorageBase::LoadStringsFrom(std::string const& path, uint32 locale, char** indexTable) +{ + // DB2 must be already loaded using Load + if (!indexTable) + return false; + + DB2FileLoader db2; + { + DB2FileSystemSource source(path + _fileName); + // Check if load was successful, only then continue + if (!db2.Load(&source, _loadInfo)) + return false; + } + + // load strings from another locale db2 data + if (_loadInfo->GetStringFieldCount(true)) + if (char* stringBlock = db2.AutoProduceStrings(_dataTable, locale)) + _stringPool.push_back(stringBlock); + + return true; +} + +void DB2StorageBase::LoadFromDB(char**& indexTable) +{ + char* extraStringHolders = nullptr; + _dataTableEx = DB2DatabaseLoader(_fileName, _loadInfo).Load(_indexTableSize, indexTable, extraStringHolders, _stringPool); + if (extraStringHolders) + _stringPool.push_back(extraStringHolders); +} + +void DB2StorageBase::LoadStringsFromDB(uint32 locale, char** indexTable) +{ + if (!_loadInfo->GetStringFieldCount(true)) + return; + + DB2DatabaseLoader(_fileName, _loadInfo).LoadStrings(locale, _indexTableSize, indexTable, _stringPool); +} diff --git a/src/server/shared/DataStores/DB2Store.h b/src/server/shared/DataStores/DB2Store.h index 7011a3b6e61..68cd888cd05 100644 --- a/src/server/shared/DataStores/DB2Store.h +++ b/src/server/shared/DataStores/DB2Store.h @@ -19,41 +19,29 @@ #define DB2STORE_H #include "Common.h" -#include "DB2Meta.h" -#include "DB2StorageLoader.h" #include "DBStorageIterator.h" -#include "ByteBuffer.h" +#include + +class ByteBuffer; +struct DB2LoadInfo; /// Interface class for common access -class DB2StorageBase +class TC_SHARED_API DB2StorageBase { public: - DB2StorageBase(char const* fileName, DB2LoadInfo&& loadInfo) - : _tableHash(0), _layoutHash(0), _fileName(fileName), _fieldCount(0), _loadInfo(std::move(loadInfo)), _dataTable(nullptr), _dataTableEx(nullptr) { } - - virtual ~DB2StorageBase() - { - delete[] _dataTable; - delete[] _dataTableEx; - for (char* strings : _stringPool) - delete[] strings; - } + DB2StorageBase(char const* fileName, DB2LoadInfo const* loadInfo); + virtual ~DB2StorageBase(); uint32 GetTableHash() const { return _tableHash; } - uint32 GetLayoutHash() const { return _layoutHash; } virtual bool HasRecord(uint32 id) const = 0; - virtual void WriteRecord(uint32 id, uint32 locale, ByteBuffer& buffer) const = 0; - virtual void EraseRecord(uint32 id) = 0; std::string const& GetFileName() const { return _fileName; } - uint32 GetFieldCount() const { return _fieldCount; } - - DB2LoadInfo const* GetLoadInfo() const { return &_loadInfo; } + DB2LoadInfo const* GetLoadInfo() const { return _loadInfo; } virtual bool Load(std::string const& path, uint32 locale) = 0; virtual bool LoadStringsFrom(std::string const& path, uint32 locale) = 0; @@ -61,63 +49,21 @@ public: virtual void LoadStringsFromDB(uint32 locale) = 0; protected: - void WriteRecordData(char const* entry, uint32 locale, ByteBuffer& buffer) const - { - std::size_t i = 0; - if (!_loadInfo.Meta->HasIndexFieldInData()) - { - entry += 4; - ++i; - } - - for (; i < _loadInfo.FieldCount; ++i) - { - switch (_loadInfo.TypesString[i]) - { - case FT_INT: - buffer << *(uint32*)entry; - entry += 4; - break; - case FT_FLOAT: - buffer << *(float*)entry; - entry += 4; - break; - case FT_BYTE: - buffer << *(uint8*)entry; - entry += 1; - break; - case FT_SHORT: - buffer << *(uint16*)entry; - entry += 2; - break; - case FT_STRING: - { - LocalizedString* locStr = *(LocalizedString**)entry; - if (locStr->Str[locale][0] == '\0') - locale = 0; - - buffer << locStr->Str[locale]; - entry += sizeof(LocalizedString*); - break; - } - case FT_STRING_NOT_LOCALIZED: - { - buffer << *(char const**)entry; - entry += sizeof(char const*); - break; - } - } - } - } + void WriteRecordData(char const* entry, uint32 locale, ByteBuffer& buffer) const; + bool Load(std::string const& path, uint32 locale, char**& indexTable); + bool LoadStringsFrom(std::string const& path, uint32 locale, char** indexTable); + void LoadFromDB(char**& indexTable); + void LoadStringsFromDB(uint32 locale, char** indexTable); uint32 _tableHash; uint32 _layoutHash; std::string _fileName; uint32 _fieldCount; - DB2LoadInfo _loadInfo; + DB2LoadInfo const* _loadInfo; char* _dataTable; char* _dataTableEx; std::vector _stringPool; + uint32 _indexTableSize; }; template @@ -128,10 +74,9 @@ class DB2Storage : public DB2StorageBase public: typedef DBStorageIterator iterator; - DB2Storage(char const* fileName, DB2LoadInfo&& loadInfo) : DB2StorageBase(fileName, std::move(loadInfo)), - _indexTableSize(0) + DB2Storage(char const* fileName, DB2LoadInfo const* loadInfo) : DB2StorageBase(fileName, loadInfo) { - _indexTable.AsT = NULL; + _indexTable.AsT = nullptr; } ~DB2Storage() @@ -153,61 +98,22 @@ public: uint32 GetNumRows() const { return _indexTableSize; } bool Load(std::string const& path, uint32 locale) override { - DB2FileLoader db2; - // Check if load was successful, only then continue - if (!db2.Load((path + _fileName).c_str(), &_loadInfo)) - return false; - - _fieldCount = db2.GetCols(); - _tableHash = db2.GetTableHash(); - _layoutHash = db2.GetLayoutHash(); - - // load raw non-string data - _dataTable = db2.AutoProduceData(_indexTableSize, _indexTable.AsChar, _stringPool); - - // load strings from db2 data - if (!_stringPool.empty()) - if (char* stringBlock = db2.AutoProduceStrings(_dataTable, locale)) - _stringPool.push_back(stringBlock); - - db2.AutoProduceRecordCopies(_indexTableSize, _indexTable.AsChar, _dataTable); - - // error in db2 file at loading if NULL - return _indexTable.AsT != NULL; + return DB2StorageBase::Load(path, locale, _indexTable.AsChar); } bool LoadStringsFrom(std::string const& path, uint32 locale) override { - // DB2 must be already loaded using Load - if (!_indexTable.AsT) - return false; - - DB2FileLoader db2; - // Check if load was successful, only then continue - if (!db2.Load((path + _fileName).c_str(), &_loadInfo)) - return false; - - // load strings from another locale db2 data - if (_loadInfo.GetStringFieldCount(true)) - if (char* stringBlock = db2.AutoProduceStrings(_dataTable, locale)) - _stringPool.push_back(stringBlock); - return true; + return DB2StorageBase::LoadStringsFrom(path, locale, _indexTable.AsChar); } void LoadFromDB() override { - char* extraStringHolders = nullptr; - _dataTableEx = DB2DatabaseLoader(_fileName, &_loadInfo).Load(_indexTableSize, _indexTable.AsChar, extraStringHolders, _stringPool); - if (extraStringHolders) - _stringPool.push_back(extraStringHolders); + DB2StorageBase::LoadFromDB(_indexTable.AsChar); } void LoadStringsFromDB(uint32 locale) override { - if (!_loadInfo.GetStringFieldCount(true)) - return; - - DB2DatabaseLoader(_fileName, &_loadInfo).LoadStrings(locale, _indexTableSize, _indexTable.AsChar, _stringPool); + DB2StorageBase::LoadStringsFromDB(locale, _indexTable.AsChar); } iterator begin() { return iterator(_indexTable.AsT, _indexTableSize); } @@ -219,7 +125,6 @@ private: T** AsT; char** AsChar; } _indexTable; - uint32 _indexTableSize; }; #endif diff --git a/src/tools/extractor_common/CMakeLists.txt b/src/tools/extractor_common/CMakeLists.txt index 50cc20c9682..a982ce6ad1b 100644 --- a/src/tools/extractor_common/CMakeLists.txt +++ b/src/tools/extractor_common/CMakeLists.txt @@ -14,7 +14,10 @@ CollectSourceFiles( add_library(extractor_common STATIC ${PRIVATE_SOURCES}) -target_link_libraries(extractor_common boost casc) +target_link_libraries(extractor_common + PUBLIC + casc + common) target_include_directories(extractor_common PUBLIC diff --git a/src/tools/extractor_common/CascHandles.cpp b/src/tools/extractor_common/CascHandles.cpp index 9624a1ca149..46f90d8233f 100644 --- a/src/tools/extractor_common/CascHandles.cpp +++ b/src/tools/extractor_common/CascHandles.cpp @@ -16,32 +16,29 @@ */ #include "CascHandles.h" -#include "CascLib.h" +#include #include -namespace +char const* CASC::HumanReadableCASCError(DWORD error) { - const char* HumanReadableCASCError(int error) + switch (error) { - switch (error) - { - case ERROR_SUCCESS: return "SUCCESS"; - case ERROR_FILE_CORRUPT: return "FILE_CORRUPT"; - case ERROR_CAN_NOT_COMPLETE: return "CAN_NOT_COMPLETE"; - case ERROR_HANDLE_EOF: return "HANDLE_EOF"; - case ERROR_NO_MORE_FILES: return "NO_MORE_FILES"; - case ERROR_BAD_FORMAT: return "BAD_FORMAT"; - case ERROR_INSUFFICIENT_BUFFER: return "INSUFFICIENT_BUFFER"; - case ERROR_ALREADY_EXISTS: return "ALREADY_EXISTS"; - case ERROR_DISK_FULL: return "DISK_FULL"; - case ERROR_INVALID_PARAMETER: return "INVALID_PARAMETER"; - case ERROR_NOT_SUPPORTED: return "NOT_SUPPORTED"; - case ERROR_NOT_ENOUGH_MEMORY: return "NOT_ENOUGH_MEMORY"; - case ERROR_INVALID_HANDLE: return "INVALID_HANDLE"; - case ERROR_ACCESS_DENIED: return "ACCESS_DENIED"; - case ERROR_FILE_NOT_FOUND: return "FILE_NOT_FOUND"; - default: return "UNKNOWN"; - } + case ERROR_SUCCESS: return "SUCCESS"; + case ERROR_FILE_CORRUPT: return "FILE_CORRUPT"; + case ERROR_CAN_NOT_COMPLETE: return "CAN_NOT_COMPLETE"; + case ERROR_HANDLE_EOF: return "HANDLE_EOF"; + case ERROR_NO_MORE_FILES: return "NO_MORE_FILES"; + case ERROR_BAD_FORMAT: return "BAD_FORMAT"; + case ERROR_INSUFFICIENT_BUFFER: return "INSUFFICIENT_BUFFER"; + case ERROR_ALREADY_EXISTS: return "ALREADY_EXISTS"; + case ERROR_DISK_FULL: return "DISK_FULL"; + case ERROR_INVALID_PARAMETER: return "INVALID_PARAMETER"; + case ERROR_NOT_SUPPORTED: return "NOT_SUPPORTED"; + case ERROR_NOT_ENOUGH_MEMORY: return "NOT_ENOUGH_MEMORY"; + case ERROR_INVALID_HANDLE: return "INVALID_HANDLE"; + case ERROR_ACCESS_DENIED: return "ACCESS_DENIED"; + case ERROR_FILE_NOT_FOUND: return "FILE_NOT_FOUND"; + default: return "UNKNOWN"; } } @@ -95,6 +92,11 @@ DWORD CASC::GetFileSize(FileHandle const& file, PDWORD fileSizeHigh) return ::CascGetFileSize(file.get(), fileSizeHigh); } +DWORD CASC::GetFilePointer(FileHandle const& file) +{ + return ::CascSetFilePointer(file.get(), 0, nullptr, FILE_CURRENT); +} + bool CASC::ReadFile(FileHandle const& file, void* buffer, DWORD bytes, PDWORD bytesRead) { return ::CascReadFile(file.get(), buffer, bytes, bytesRead); diff --git a/src/tools/extractor_common/CascHandles.h b/src/tools/extractor_common/CascHandles.h index 455306ad5e0..ebfd04466ab 100644 --- a/src/tools/extractor_common/CascHandles.h +++ b/src/tools/extractor_common/CascHandles.h @@ -18,7 +18,7 @@ #ifndef CascHandles_h__ #define CascHandles_h__ -#include "CascPort.h" +#include #include namespace boost @@ -46,10 +46,13 @@ namespace CASC typedef std::unique_ptr StorageHandle; typedef std::unique_ptr FileHandle; + char const* HumanReadableCASCError(DWORD error); + StorageHandle OpenStorage(boost::filesystem::path const& path, DWORD localeMask); FileHandle OpenFile(StorageHandle const& storage, char const* fileName, DWORD localeMask, bool printErrors = false); DWORD GetFileSize(FileHandle const& file, PDWORD fileSizeHigh); + DWORD GetFilePointer(FileHandle const& file); bool ReadFile(FileHandle const& file, void* buffer, DWORD bytes, PDWORD bytesRead); } diff --git a/src/tools/extractor_common/DB2CascFileSource.cpp b/src/tools/extractor_common/DB2CascFileSource.cpp new file mode 100644 index 00000000000..24bf47491dd --- /dev/null +++ b/src/tools/extractor_common/DB2CascFileSource.cpp @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2008-2017 TrinityCore + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with this program. If not, see . + */ + +#include "DB2CascFileSource.h" +#include + +DB2CascFileSource::DB2CascFileSource(CASC::StorageHandle const& storage, std::string fileName) +{ + _fileHandle = CASC::OpenFile(storage, fileName.c_str(), CASC_LOCALE_NONE, true); + _fileName = std::move(fileName); +} + +bool DB2CascFileSource::IsOpen() const +{ + return _fileHandle != nullptr; +} + +bool DB2CascFileSource::Read(void* buffer, std::size_t numBytes) +{ + DWORD bytesRead = 0; + return CASC::ReadFile(_fileHandle, buffer, numBytes, &bytesRead) && numBytes == bytesRead; +} + +std::size_t DB2CascFileSource::GetPosition() const +{ + return CASC::GetFilePointer(_fileHandle); +} + +char const* DB2CascFileSource::GetFileName() const +{ + return _fileName.c_str(); +} diff --git a/src/tools/extractor_common/DB2CascFileSource.h b/src/tools/extractor_common/DB2CascFileSource.h new file mode 100644 index 00000000000..b8876fdcdd1 --- /dev/null +++ b/src/tools/extractor_common/DB2CascFileSource.h @@ -0,0 +1,38 @@ +/* + * Copyright (C) 2008-2017 TrinityCore + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with this program. If not, see . + */ + +#ifndef DB2CascFileSource_h__ +#define DB2CascFileSource_h__ + +#include "DB2FileLoader.h" +#include "CascHandles.h" +#include + +struct DB2CascFileSource : public DB2FileSource +{ + DB2CascFileSource(CASC::StorageHandle const& storage, std::string fileName); + bool IsOpen() const override; + bool Read(void* buffer, std::size_t numBytes) override; + std::size_t GetPosition() const override; + char const* GetFileName() const override; + +private: + CASC::FileHandle _fileHandle; + std::string _fileName; +}; + +#endif // DB2CascFile_h__ diff --git a/src/tools/map_extractor/CMakeLists.txt b/src/tools/map_extractor/CMakeLists.txt index 3cf7dab9ea0..6347d3bc807 100644 --- a/src/tools/map_extractor/CMakeLists.txt +++ b/src/tools/map_extractor/CMakeLists.txt @@ -28,7 +28,6 @@ target_include_directories(mapextractor target_link_libraries(mapextractor PUBLIC - common extractor_common) CollectIncludeDirectories( diff --git a/src/tools/map_extractor/DB2.cpp b/src/tools/map_extractor/DB2.cpp deleted file mode 100644 index fca95476edb..00000000000 --- a/src/tools/map_extractor/DB2.cpp +++ /dev/null @@ -1,200 +0,0 @@ -/* - * Copyright (C) 2008-2017 TrinityCore - * - * This program is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License as published by the - * Free Software Foundation; either version 2 of the License, or (at your - * option) any later version. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for - * more details. - * - * You should have received a copy of the GNU General Public License along - * with this program. If not, see . - */ - -#include "DB2.h" -#include - -DB2FileLoader::DB2FileLoader() -{ - meta = nullptr; - - recordSize = 0; - recordCount = 0; - fieldCount = 0; - stringSize = 0; - tableHash = 0; - layoutHash = 0; - minIndex = 0; - maxIndex = 0; - localeMask = 0; - copyIdSize = 0; - - data = nullptr; - stringTable = nullptr; - idTable = nullptr; - idTableSize = 0; - copyTable = nullptr; - fields = nullptr; -} - -bool DB2FileLoader::Load(CASC::FileHandle const& db2Handle, DB2Meta const* meta_) -{ - if (data) - { - delete[] data; - data = nullptr; - } - - DWORD bytesRead = 0; - meta = meta_; - std::uint32_t header; - CASC::ReadFile(db2Handle, &header, sizeof(header), &bytesRead); - if (bytesRead != sizeof(header)) // Signature - return false; - - EndianConvert(header); - - if (header != 0x35424457) - return false; //'WDB5' - - CASC::ReadFile(db2Handle, &recordCount, sizeof(recordCount), &bytesRead); - if (bytesRead != sizeof(recordCount)) // Number of records - return false; - - EndianConvert(recordCount); - - CASC::ReadFile(db2Handle, &fieldCount, sizeof(fieldCount), &bytesRead); - if (bytesRead != sizeof(fieldCount)) // Number of fields - return false; - - EndianConvert(fieldCount); - - CASC::ReadFile(db2Handle, &recordSize, sizeof(recordSize), &bytesRead); - if (bytesRead != sizeof(recordSize)) // Size of a record - return false; - - EndianConvert(recordSize); - - CASC::ReadFile(db2Handle, &stringSize, sizeof(stringSize), &bytesRead); - if (bytesRead != sizeof(stringSize)) // String size - return false; - - EndianConvert(stringSize); - - CASC::ReadFile(db2Handle, &tableHash, sizeof(tableHash), &bytesRead); - if (bytesRead != sizeof(tableHash)) // Table hash - return false; - - EndianConvert(tableHash); - - CASC::ReadFile(db2Handle, &layoutHash, sizeof(layoutHash), &bytesRead); - if (bytesRead != sizeof(layoutHash)) // Layout hash - return false; - - if (layoutHash != meta->LayoutHash) - return false; - - EndianConvert(layoutHash); - - CASC::ReadFile(db2Handle, &minIndex, sizeof(minIndex), &bytesRead); - if (bytesRead != sizeof(minIndex)) // MinIndex WDB2 - return false; - - EndianConvert(minIndex); - - CASC::ReadFile(db2Handle, &maxIndex, sizeof(maxIndex), &bytesRead); - if (bytesRead != sizeof(maxIndex)) // MaxIndex WDB2 - return false; - - EndianConvert(maxIndex); - - CASC::ReadFile(db2Handle, &localeMask, sizeof(localeMask), &bytesRead); - if (bytesRead != sizeof(localeMask)) // Locales - return false; - - EndianConvert(localeMask); - - CASC::ReadFile(db2Handle, ©IdSize, sizeof(copyIdSize), &bytesRead); - if (bytesRead != sizeof(copyIdSize)) - return false; - - EndianConvert(copyIdSize); - - CASC::ReadFile(db2Handle, &metaFlags, sizeof(metaFlags), &bytesRead); - if (bytesRead != sizeof(metaFlags)) - return false; - - EndianConvert(metaFlags); - - ASSERT((metaFlags & 0x1) == 0); - ASSERT((meta->IndexField == -1) || (meta->IndexField == int32((metaFlags >> 16)))); - - fields = new FieldEntry[fieldCount]; - CASC::ReadFile(db2Handle, fields, fieldCount * sizeof(FieldEntry), &bytesRead); - if (bytesRead != fieldCount * sizeof(FieldEntry)) - return false; - - if (!meta->HasIndexFieldInData()) - idTableSize = recordCount * sizeof(std::uint32_t); - - data = new unsigned char[recordSize * recordCount + stringSize]; - stringTable = data + recordSize * recordCount; - - CASC::ReadFile(db2Handle, data, recordSize * recordCount + stringSize, &bytesRead); - if (bytesRead != recordSize * recordCount + stringSize) - return false; - - if (idTableSize) - { - idTable = new unsigned char[idTableSize]; - CASC::ReadFile(db2Handle, idTable, idTableSize, &bytesRead); - if (bytesRead != idTableSize) - return false; - } - - if (copyIdSize) - { - copyTable = new unsigned char[copyIdSize]; - CASC::ReadFile(db2Handle, copyTable, copyIdSize, &bytesRead); - if (bytesRead != copyIdSize) - return false; - } - - return true; -} - -DB2FileLoader::~DB2FileLoader() -{ - delete[] data; - delete[] idTable; - delete[] copyTable; - delete[] fields; -} - -DB2FileLoader::Record DB2FileLoader::getRecord(size_t id) -{ - assert(data); - return Record(*this, data + id * recordSize); -} - -std::pair DB2FileLoader::GetRowCopy(std::uint32_t i) const -{ - std::uint32_t* copyIds = (std::uint32_t*)copyTable; - std::uint32_t to = copyIds[i]; - std::uint32_t from = copyIds[i + 1]; - return{ from, to }; -} - -std::uint32_t DB2FileLoader::GetMaxId() const -{ - std::uint32_t j = maxIndex; - for (std::uint32_t i = 0; i < GetNumRowCopies(); ++i) - if (j < GetRowCopy(i).second) - j = GetRowCopy(i).second; - - return j; -} diff --git a/src/tools/map_extractor/DB2.h b/src/tools/map_extractor/DB2.h deleted file mode 100644 index f28aeb0e05f..00000000000 --- a/src/tools/map_extractor/DB2.h +++ /dev/null @@ -1,176 +0,0 @@ -/* - * Copyright (C) 2008-2017 TrinityCore - * - * This program is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License as published by the - * Free Software Foundation; either version 2 of the License, or (at your - * option) any later version. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for - * more details. - * - * You should have received a copy of the GNU General Public License along - * with this program. If not, see . - */ - -#ifndef MapExtractor_DB2_h__ -#define MapExtractor_DB2_h__ - -#include "DB2Meta.h" -#include "CascHandles.h" -#include "CascLib.h" -#include "Utilities/ByteConverter.h" -#include "Errors.h" - -class DB2FileLoader -{ - public: - DB2FileLoader(); - ~DB2FileLoader(); - - bool Load(CASC::FileHandle const& db2Handle, DB2Meta const* meta); - - class Record - { - public: - float getFloat(std::uint32_t field, std::uint32_t arrayIndex) const - { - ASSERT(field < file.fieldCount); - float val = *reinterpret_cast(offset + GetOffset(field) + arrayIndex * sizeof(float)); - EndianConvert(val); - return val; - } - - std::uint32_t getUInt(std::uint32_t field, std::uint32_t arrayIndex) const - { - ASSERT(field < file.fieldCount); - return GetVarInt(field, GetByteSize(field), arrayIndex); - } - - std::uint8_t getUInt8(std::uint32_t field, std::uint32_t arrayIndex) const - { - ASSERT(field < file.fieldCount); - ASSERT(GetByteSize(field) == 1); - return *reinterpret_cast(offset + GetOffset(field) + arrayIndex * sizeof(std::uint8_t)); - } - - std::uint16_t getUInt16(std::uint32_t field, std::uint32_t arrayIndex) const - { - ASSERT(field < file.fieldCount); - ASSERT(GetByteSize(field) == 2); - std::uint16_t val = *reinterpret_cast(offset + GetOffset(field) + arrayIndex * sizeof(std::uint16_t)); - EndianConvert(val); - return val; - } - - char const* getString(std::uint32_t field, std::uint32_t arrayIndex) const - { - ASSERT(field < file.fieldCount); - std::uint32_t stringOffset = *reinterpret_cast(offset + GetOffset(field) + arrayIndex * sizeof(std::uint32_t)); - EndianConvert(stringOffset); - ASSERT(stringOffset < file.stringSize); - return reinterpret_cast(file.stringTable + stringOffset); - } - - private: - std::uint16_t GetOffset(std::uint32_t field) const - { - ASSERT(field < file.fieldCount); - return file.fields[field].Offset; - } - - std::uint16_t GetByteSize(std::uint32_t field) const - { - ASSERT(field < file.fieldCount); - return 4 - file.fields[field].UnusedBits / 8; - } - - std::uint32_t GetVarInt(std::uint32_t field, std::uint16_t size, std::uint32_t arrayIndex) const - { - ASSERT(field < file.fieldCount); - switch (size) - { - case 1: - { - return *reinterpret_cast(offset + GetOffset(field) + arrayIndex * sizeof(std::uint8_t)); - } - case 2: - { - std::uint16_t val = *reinterpret_cast(offset + GetOffset(field) + arrayIndex * sizeof(std::uint16_t)); - EndianConvert(val); - return val; - } - case 3: - { -#pragma pack(push, 1) - struct dbcint24 { std::uint8_t v[3]; }; -#pragma pack(pop) - dbcint24 val = *reinterpret_cast(offset + GetOffset(field) + arrayIndex * sizeof(dbcint24)); - EndianConvert(val); - return std::uint32_t(val.v[0]) | (std::uint32_t(val.v[1]) << 8) | (std::uint32_t(val.v[2]) << 16); - } - case 4: - { - std::uint32_t val = *reinterpret_cast(offset + GetOffset(field) + arrayIndex * sizeof(std::uint32_t)); - EndianConvert(val); - return val; - } - default: - break; - } - - ASSERT(false, "GetByteSize(field) < 4"); - return 0; - } - - Record(DB2FileLoader &file_, unsigned char *offset_): offset(offset_), file(file_) {} - unsigned char *offset; - DB2FileLoader &file; - - friend class DB2FileLoader; - }; - - // Get record by id - Record getRecord(size_t id); - std::uint32_t getId(size_t row) { return ((std::uint32_t*)idTable)[row]; } - std::pair GetRowCopy(std::uint32_t i) const; - - std::uint32_t GetNumRows() const { return recordCount; } - std::uint32_t GetNumRowCopies() const { return copyIdSize / 8; } - std::uint32_t GetMaxId() const; - -private: -#pragma pack(push, 1) - struct FieldEntry - { - std::uint16_t UnusedBits; - std::uint16_t Offset; - }; -#pragma pack(pop) - - DB2Meta const* meta; - - // WDB2 / WCH2 fields - std::uint32_t recordSize; - std::uint32_t recordCount; - std::uint32_t fieldCount; - std::uint32_t stringSize; - std::uint32_t tableHash; - std::uint32_t layoutHash; - std::uint32_t minIndex; - std::uint32_t maxIndex; - std::uint32_t localeMask; - std::uint32_t copyIdSize; - std::uint32_t metaFlags; - - unsigned char* data; - unsigned char* stringTable; - unsigned char* idTable; - std::uint32_t idTableSize; - unsigned char* copyTable; - FieldEntry* fields; -}; - -#endif // MapExtractor_DB2_h__ diff --git a/src/tools/map_extractor/System.cpp b/src/tools/map_extractor/System.cpp index 4b0dc6fb74f..e1a5d860946 100644 --- a/src/tools/map_extractor/System.cpp +++ b/src/tools/map_extractor/System.cpp @@ -17,7 +17,20 @@ */ #define _CRT_SECURE_NO_DEPRECATE +#define WIN32_LEAN_AND_MEAN +#include "Banner.h" +#include "CascHandles.h" +#include "Common.h" +#include "DB2CascFileSource.h" +#include "DB2Meta.h" +#include "DBFilesClientList.h" +#include "StringFormat.h" +#include "adt.h" +#include "wdt.h" +#include +#include +#include #include #include #include @@ -25,46 +38,6 @@ #include #include -#include -#include - -#include "Common.h" -#include "DBFilesClientList.h" -#include "CascLib.h" -#include "CascHandles.h" -#include "DB2.h" -#include "Banner.h" -#include "StringFormat.h" - -#include "adt.h" -#include "wdt.h" - -namespace -{ - const char* HumanReadableCASCError(int error) - { - switch (error) - { - case ERROR_SUCCESS: return "SUCCESS"; - case ERROR_FILE_CORRUPT: return "FILE_CORRUPT"; - case ERROR_CAN_NOT_COMPLETE: return "CAN_NOT_COMPLETE"; - case ERROR_HANDLE_EOF: return "HANDLE_EOF"; - case ERROR_NO_MORE_FILES: return "NO_MORE_FILES"; - case ERROR_BAD_FORMAT: return "BAD_FORMAT"; - case ERROR_INSUFFICIENT_BUFFER: return "INSUFFICIENT_BUFFER"; - case ERROR_ALREADY_EXISTS: return "ALREADY_EXISTS"; - case ERROR_DISK_FULL: return "DISK_FULL"; - case ERROR_INVALID_PARAMETER: return "INVALID_PARAMETER"; - case ERROR_NOT_SUPPORTED: return "NOT_SUPPORTED"; - case ERROR_NOT_ENOUGH_MEMORY: return "NOT_ENOUGH_MEMORY"; - case ERROR_INVALID_HANDLE: return "INVALID_HANDLE"; - case ERROR_ACCESS_DENIED: return "ACCESS_DENIED"; - case ERROR_FILE_NOT_FOUND: return "FILE_NOT_FOUND"; - default: return "UNKNOWN"; - } - } -} - CASC::StorageHandle CascStorage; typedef struct @@ -79,36 +52,128 @@ std::set CameraFileNames; boost::filesystem::path input_path; boost::filesystem::path output_path; -struct CinematicCameraMeta +struct CinematicCameraLoadInfo { - static DB2Meta const* Instance() + static DB2FileLoadInfo const* Instance() { + static DB2FieldMeta const fields[] = + { + { false, FT_INT, "ID" }, + { false, FT_STRING_NOT_LOCALIZED, "Model" }, + { false, FT_FLOAT, "OriginX" }, + { false, FT_FLOAT, "OriginY" }, + { false, FT_FLOAT, "OriginZ" }, + { false, FT_FLOAT, "OriginFacing" }, + { false, FT_SHORT, "SoundID" }, + }; static char const* types = "sffh"; static uint8 const arraySizes[4] = { 1, 3, 1, 1 }; - static DB2Meta instance(-1, 4, 0xA7B95349, types, arraySizes); - return &instance; + static DB2Meta const meta(-1, 4, 0xA7B95349, types, arraySizes); + static DB2FileLoadInfo const loadInfo(&fields[0], std::extent::value, &meta); + return &loadInfo; } }; -struct LiquidTypeMeta +struct LiquidTypeLoadInfo { - static DB2Meta const* Instance() + static DB2FileLoadInfo const* Instance() { + static DB2FieldMeta const fields[] = + { + { false, FT_INT, "ID" }, + { false, FT_STRING, "Name" }, + { false, FT_INT, "SpellID" }, + { false, FT_FLOAT, "MaxDarkenDepth" }, + { false, FT_FLOAT, "FogDarkenIntensity" }, + { false, FT_FLOAT, "AmbDarkenIntensity" }, + { false, FT_FLOAT, "DirDarkenIntensity" }, + { false, FT_FLOAT, "ParticleScale" }, + { false, FT_STRING_NOT_LOCALIZED, "Texture1" }, + { false, FT_STRING_NOT_LOCALIZED, "Texture2" }, + { false, FT_STRING_NOT_LOCALIZED, "Texture3" }, + { false, FT_STRING_NOT_LOCALIZED, "Texture4" }, + { false, FT_STRING_NOT_LOCALIZED, "Texture5" }, + { false, FT_STRING_NOT_LOCALIZED, "Texture6" }, + { false, FT_INT, "Color1" }, + { false, FT_INT, "Color2" }, + { false, FT_FLOAT, "Float1" }, + { false, FT_FLOAT, "Float2" }, + { false, FT_FLOAT, "Float3" }, + { false, FT_FLOAT, "Float4" }, + { false, FT_FLOAT, "Float5" }, + { false, FT_FLOAT, "Float6" }, + { false, FT_FLOAT, "Float7" }, + { false, FT_FLOAT, "Float8" }, + { false, FT_FLOAT, "Float9" }, + { false, FT_FLOAT, "Float10" }, + { false, FT_FLOAT, "Float11" }, + { false, FT_FLOAT, "Float12" }, + { false, FT_FLOAT, "Float13" }, + { false, FT_FLOAT, "Float14" }, + { false, FT_FLOAT, "Float15" }, + { false, FT_FLOAT, "Float16" }, + { false, FT_FLOAT, "Float17" }, + { false, FT_FLOAT, "Float18" }, + { false, FT_INT, "Int1" }, + { false, FT_INT, "Int2" }, + { false, FT_INT, "Int3" }, + { false, FT_INT, "Int4" }, + { false, FT_SHORT, "Flags" }, + { false, FT_SHORT, "LightID" }, + { false, FT_BYTE, "Type" }, + { false, FT_BYTE, "ParticleMovement" }, + { false, FT_BYTE, "ParticleTexSlots" }, + { false, FT_BYTE, "MaterialID" }, + { false, FT_BYTE, "DepthTexCount1" }, + { false, FT_BYTE, "DepthTexCount2" }, + { false, FT_BYTE, "DepthTexCount3" }, + { false, FT_BYTE, "DepthTexCount4" }, + { false, FT_BYTE, "DepthTexCount5" }, + { false, FT_BYTE, "DepthTexCount6" }, + { false, FT_INT, "SoundID" }, + }; static char const* types = "sifffffsifihhbbbbbi"; static uint8 const arraySizes[19] = { 1, 1, 1, 1, 1, 1, 1, 6, 2, 18, 4, 1, 1, 1, 1, 1, 1, 6, 1 }; - static DB2Meta instance(-1, 19, 0x99FC34E5, types, arraySizes); - return &instance; + static DB2Meta const meta(-1, 19, 0x99FC34E5, types, arraySizes); + static DB2FileLoadInfo const loadInfo(&fields[0], std::extent::value, &meta); + return &loadInfo; } }; -struct MapMeta +struct MapLoadInfo { - static DB2Meta const* Instance() + static DB2FileLoadInfo const* Instance() { + static DB2FieldMeta const fields[] = + { + { false, FT_INT, "ID" }, + { false, FT_STRING_NOT_LOCALIZED, "Directory" }, + { false, FT_INT, "Flags1" }, + { false, FT_INT, "Flags2" }, + { false, FT_FLOAT, "MinimapIconScale" }, + { false, FT_FLOAT, "CorpsePosX" }, + { false, FT_FLOAT, "CorpsePosY" }, + { false, FT_STRING, "MapName" }, + { false, FT_STRING, "MapDescription0" }, + { false, FT_STRING, "MapDescription1" }, + { false, FT_SHORT, "AreaTableID" }, + { false, FT_SHORT, "LoadingScreenID" }, + { true, FT_SHORT, "CorpseMapID" }, + { false, FT_SHORT, "TimeOfDayOverride" }, + { true, FT_SHORT, "ParentMapID" }, + { true, FT_SHORT, "CosmeticParentMapID" }, + { false, FT_SHORT, "WindSettingsID" }, + { false, FT_BYTE, "InstanceType" }, + { false, FT_BYTE, "unk5" }, + { false, FT_BYTE, "ExpansionID" }, + { false, FT_BYTE, "MaxPlayers" }, + { false, FT_BYTE, "TimeOffset" }, + }; static char const* types = "siffssshhhhhhhbbbbb"; static uint8 const arraySizes[19] = { 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }; - static DB2Meta instance(-1, 19, 0xF7CF2DA2, types, arraySizes); - return &instance; + static DB2Meta const meta(-1, 19, 0xF7CF2DA2, types, arraySizes); + static DB2FileLoadInfo const loadInfo(&fields[0], std::extent::value, &meta); + return &loadInfo; } }; @@ -306,29 +371,22 @@ void ReadMapDBC() { printf("Read Map.db2 file...\n"); - CASC::FileHandle dbcFile = CASC::OpenFile(CascStorage, "DBFilesClient\\Map.db2", CASC_LOCALE_NONE, true); - if (!dbcFile) - { - exit(1); - } - + DB2CascFileSource source(CascStorage, "DBFilesClient\\Map.db2"); DB2FileLoader db2; - if (!db2.Load(dbcFile, MapMeta::Instance())) + if (!db2.Load(&source, MapLoadInfo::Instance())) { - printf("Fatal error: Invalid Map.db2 file format! %s\n", HumanReadableCASCError(GetLastError())); + printf("Fatal error: Invalid Map.db2 file format! %s\n", CASC::HumanReadableCASCError(GetLastError())); exit(1); } - map_ids.resize(db2.GetNumRows()); + map_ids.resize(db2.GetRecordCount()); std::unordered_map idToIndex; - for (uint32 x = 0; x < db2.GetNumRows(); ++x) + for (uint32 x = 0; x < db2.GetRecordCount(); ++x) { - if (MapMeta::Instance()->HasIndexFieldInData()) - map_ids[x].id = db2.getRecord(x).getUInt(MapMeta::Instance()->GetIndexField(), 0); - else - map_ids[x].id = db2.getId(x); + DB2Record record = db2.GetRecord(x); + map_ids[x].id = record.GetId(); - const char* map_name = db2.getRecord(x).getString(0, 0); + const char* map_name = record.GetString(0, 0); size_t max_map_name_length = sizeof(map_ids[x].name); if (strlen(map_name) >= max_map_name_length) { @@ -341,15 +399,14 @@ void ReadMapDBC() idToIndex[map_ids[x].id] = x; } - for (uint32 x = 0; x < db2.GetNumRowCopies(); ++x) + for (uint32 x = 0; x < db2.GetRecordCopyCount(); ++x) { - uint32 from = db2.GetRowCopy(x).first; - uint32 to = db2.GetRowCopy(x).second; - auto itr = idToIndex.find(from); + DB2RecordCopy copy = db2.GetRecordCopy(x); + auto itr = idToIndex.find(copy.SourceRowId); if (itr != idToIndex.end()) { map_id id; - id.id = to; + id.id = copy.NewRowId; strcpy(id.name, map_ids[itr->second].name); map_ids.push_back(id); } @@ -361,14 +418,10 @@ void ReadMapDBC() void ReadLiquidTypeTableDBC() { printf("Read LiquidType.db2 file...\n"); - CASC::FileHandle dbcFile = CASC::OpenFile(CascStorage, "DBFilesClient\\LiquidType.db2", CASC_LOCALE_NONE, true); - if (!dbcFile) - { - exit(1); - } + DB2CascFileSource source(CascStorage, "DBFilesClient\\LiquidType.db2"); DB2FileLoader db2; - if (!db2.Load(dbcFile, LiquidTypeMeta::Instance())) + if (!db2.Load(&source, LiquidTypeLoadInfo::Instance())) { printf("Fatal error: Invalid LiquidType.db2 file format!\n"); exit(1); @@ -376,19 +429,14 @@ void ReadLiquidTypeTableDBC() LiqType.resize(db2.GetMaxId() + 1, 0xFFFF); - for (uint32 x = 0; x < db2.GetNumRows(); ++x) + for (uint32 x = 0; x < db2.GetRecordCount(); ++x) { - uint32 liquidTypeId; - if (LiquidTypeMeta::Instance()->HasIndexFieldInData()) - liquidTypeId = db2.getRecord(x).getUInt(LiquidTypeMeta::Instance()->GetIndexField(), 0); - else - liquidTypeId = db2.getId(x); - - LiqType[liquidTypeId] = db2.getRecord(x).getUInt8(13, 0); + DB2Record record = db2.GetRecord(x); + LiqType[record.GetId()] = record.GetUInt8(13, 0); } - for (uint32 x = 0; x < db2.GetNumRowCopies(); ++x) - LiqType[db2.GetRowCopy(x).second] = LiqType[db2.GetRowCopy(x).first]; + for (uint32 x = 0; x < db2.GetRecordCopyCount(); ++x) + LiqType[db2.GetRecordCopy(x).NewRowId] = LiqType[db2.GetRecordCopy(x).SourceRowId]; printf("Done! (" SZFMTD " LiqTypes loaded)\n", LiqType.size()); } @@ -397,24 +445,19 @@ bool ReadCinematicCameraDBC() { printf("Read CinematicCamera.db2 file...\n"); - CASC::FileHandle dbcFile = CASC::OpenFile(CascStorage, "DBFilesClient\\CinematicCamera.db2", CASC_LOCALE_NONE, true); - if (!dbcFile) - { - printf("Unable to open CinematicCamera.db2. Camera extract aborted.\n"); - return false; - } - + DB2CascFileSource source(CascStorage, "DBFilesClient\\CinematicCamera.db2"); DB2FileLoader db2; - if (!db2.Load(dbcFile, CinematicCameraMeta::Instance())) + if (!db2.Load(&source, CinematicCameraLoadInfo::Instance())) { - printf("Invalid CinematicCamera.db2 file format. Camera extract aborted. %s\n", HumanReadableCASCError(GetLastError())); + printf("Invalid CinematicCamera.db2 file format. Camera extract aborted. %s\n", CASC::HumanReadableCASCError(GetLastError())); return false; } // get camera file list from DB2 - for (size_t i = 0; i < db2.GetNumRows(); ++i) + for (size_t i = 0; i < db2.GetRecordCount(); ++i) { - std::string camFile(db2.getRecord(i).getString(0, 0)); + DB2Record record = db2.GetRecord(i); + std::string camFile(record.GetString(0, 0)); size_t loc = camFile.find(".mdx"); if (loc != std::string::npos) camFile.replace(loc, 4, ".m2"); @@ -1089,23 +1132,6 @@ bool ConvertADT(std::string const& inputPath, std::string const& outputPath, int return true; } -void ExtractWmos(ChunkedFile& file, std::set& wmoList) -{ - if (FileChunk* chunk = file.GetChunk("MWMO")) - { - file_MWMO* wmo = chunk->As(); - if (wmo->size) - { - char* fileName = wmo->FileList; - while (fileName < wmo->FileList + wmo->size) - { - wmoList.insert(fileName); - fileName += strlen(fileName) + 1; - } - } - } -} - void ExtractMaps(uint32 build) { std::string storagePath; @@ -1119,8 +1145,6 @@ void ExtractMaps(uint32 build) CreateDir(output_path / "maps"); - std::set wmoList; - printf("Convert map files\n"); for (std::size_t z = 0; z < map_ids.size(); ++z) { @@ -1131,8 +1155,6 @@ void ExtractMaps(uint32 build) if (!wdt.loadFile(CascStorage, storagePath, false)) continue; - ExtractWmos(wdt, wmoList); - FileChunk* chunk = wdt.GetChunk("MAIN"); for (uint32 y = 0; y < WDT_MAP_SIZE; ++y) { @@ -1144,11 +1166,6 @@ void ExtractMaps(uint32 build) storagePath = Trinity::StringFormat("World\\Maps\\%s\\%s_%u_%u.adt", map_ids[z].name, map_ids[z].name, x, y); outputFileName = Trinity::StringFormat("%s/maps/%04u_%02u_%02u.map", output_path.string().c_str(), map_ids[z].id, y, x); ConvertADT(storagePath, outputFileName, y, x, build); - - storagePath = Trinity::StringFormat("World\\Maps\\%s\\%s_%u_%u_obj0.adt", map_ids[z].name, map_ids[z].name, x, y); - ChunkedFile adtObj; - if (adtObj.loadFile(CascStorage, storagePath, false)) - ExtractWmos(adtObj, wmoList); } // draw progress bar @@ -1156,17 +1173,6 @@ void ExtractMaps(uint32 build) } } - if (!wmoList.empty()) - { - if (FILE* wmoListFile = fopen("wmo_list.txt", "w")) - { - for (std::string const& wmo : wmoList) - fprintf(wmoListFile, "%s\n", wmo.c_str()); - - fclose(wmoListFile); - } - } - printf("\n"); } @@ -1226,7 +1232,7 @@ void ExtractDBFilesClient(int l) ++count; } else - printf("Unable to open file %s in the archive for locale %s: %s\n", fileName, localeNames[l], HumanReadableCASCError(GetLastError())); + printf("Unable to open file %s in the archive for locale %s: %s\n", fileName, localeNames[l], CASC::HumanReadableCASCError(GetLastError())); fileName = DBFilesClientList[++index]; } @@ -1260,7 +1266,7 @@ void ExtractCameraFiles() ++count; } else - printf("Unable to open file %s in the archive: %s\n", cameraFileName.c_str(), HumanReadableCASCError(GetLastError())); + printf("Unable to open file %s in the archive: %s\n", cameraFileName.c_str(), CASC::HumanReadableCASCError(GetLastError())); } printf("Extracted %u camera files\n", count); @@ -1326,7 +1332,7 @@ void ExtractGameTables() ++count; } else - printf("Unable to open file %s in the archive: %s\n", fileName, HumanReadableCASCError(GetLastError())); + printf("Unable to open file %s in the archive: %s\n", fileName, CASC::HumanReadableCASCError(GetLastError())); fileName = GameTables[++index]; } diff --git a/src/tools/map_extractor/loadlib.cpp b/src/tools/map_extractor/loadlib.cpp index cb195f6b714..6f21c92ce5e 100644 --- a/src/tools/map_extractor/loadlib.cpp +++ b/src/tools/map_extractor/loadlib.cpp @@ -19,6 +19,7 @@ #define _CRT_SECURE_NO_DEPRECATE #include "loadlib.h" +#include u_map_fcc MverMagic = { { 'R','E','V','M' } }; @@ -40,9 +41,16 @@ bool ChunkedFile::loadFile(CASC::StorageHandle const& mpq, std::string const& fi if (!file) return false; - data_size = CASC::GetFileSize(file, nullptr); + DWORD fileSize = CASC::GetFileSize(file, nullptr); + if (fileSize == CASC_INVALID_SIZE) + return false; + + data_size = fileSize; data = new uint8[data_size]; - CASC::ReadFile(file, data, data_size, nullptr/*bytesRead*/); + DWORD bytesRead = 0; + if (!CASC::ReadFile(file, data, data_size, &bytesRead) || bytesRead != data_size) + return false; + parseChunks(); if (prepareLoadedData()) return true; diff --git a/src/tools/map_extractor/loadlib/loadlib.h b/src/tools/map_extractor/loadlib/loadlib.h index 3267d944955..d6a8b9015c3 100644 --- a/src/tools/map_extractor/loadlib/loadlib.h +++ b/src/tools/map_extractor/loadlib/loadlib.h @@ -21,7 +21,6 @@ #include "Define.h" #include "CascHandles.h" -#include "CascLib.h" #include #include diff --git a/src/tools/vmap4_extractor/CMakeLists.txt b/src/tools/vmap4_extractor/CMakeLists.txt index 8ef299295f8..8af68c8e8ed 100644 --- a/src/tools/vmap4_extractor/CMakeLists.txt +++ b/src/tools/vmap4_extractor/CMakeLists.txt @@ -21,8 +21,6 @@ add_executable(vmap4extractor ${PRIVATE_SOURCES}) target_link_libraries(vmap4extractor PUBLIC - common - casc bzip2 extractor_common) diff --git a/src/tools/vmap4_extractor/DB2.cpp b/src/tools/vmap4_extractor/DB2.cpp deleted file mode 100644 index fca95476edb..00000000000 --- a/src/tools/vmap4_extractor/DB2.cpp +++ /dev/null @@ -1,200 +0,0 @@ -/* - * Copyright (C) 2008-2017 TrinityCore - * - * This program is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License as published by the - * Free Software Foundation; either version 2 of the License, or (at your - * option) any later version. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for - * more details. - * - * You should have received a copy of the GNU General Public License along - * with this program. If not, see . - */ - -#include "DB2.h" -#include - -DB2FileLoader::DB2FileLoader() -{ - meta = nullptr; - - recordSize = 0; - recordCount = 0; - fieldCount = 0; - stringSize = 0; - tableHash = 0; - layoutHash = 0; - minIndex = 0; - maxIndex = 0; - localeMask = 0; - copyIdSize = 0; - - data = nullptr; - stringTable = nullptr; - idTable = nullptr; - idTableSize = 0; - copyTable = nullptr; - fields = nullptr; -} - -bool DB2FileLoader::Load(CASC::FileHandle const& db2Handle, DB2Meta const* meta_) -{ - if (data) - { - delete[] data; - data = nullptr; - } - - DWORD bytesRead = 0; - meta = meta_; - std::uint32_t header; - CASC::ReadFile(db2Handle, &header, sizeof(header), &bytesRead); - if (bytesRead != sizeof(header)) // Signature - return false; - - EndianConvert(header); - - if (header != 0x35424457) - return false; //'WDB5' - - CASC::ReadFile(db2Handle, &recordCount, sizeof(recordCount), &bytesRead); - if (bytesRead != sizeof(recordCount)) // Number of records - return false; - - EndianConvert(recordCount); - - CASC::ReadFile(db2Handle, &fieldCount, sizeof(fieldCount), &bytesRead); - if (bytesRead != sizeof(fieldCount)) // Number of fields - return false; - - EndianConvert(fieldCount); - - CASC::ReadFile(db2Handle, &recordSize, sizeof(recordSize), &bytesRead); - if (bytesRead != sizeof(recordSize)) // Size of a record - return false; - - EndianConvert(recordSize); - - CASC::ReadFile(db2Handle, &stringSize, sizeof(stringSize), &bytesRead); - if (bytesRead != sizeof(stringSize)) // String size - return false; - - EndianConvert(stringSize); - - CASC::ReadFile(db2Handle, &tableHash, sizeof(tableHash), &bytesRead); - if (bytesRead != sizeof(tableHash)) // Table hash - return false; - - EndianConvert(tableHash); - - CASC::ReadFile(db2Handle, &layoutHash, sizeof(layoutHash), &bytesRead); - if (bytesRead != sizeof(layoutHash)) // Layout hash - return false; - - if (layoutHash != meta->LayoutHash) - return false; - - EndianConvert(layoutHash); - - CASC::ReadFile(db2Handle, &minIndex, sizeof(minIndex), &bytesRead); - if (bytesRead != sizeof(minIndex)) // MinIndex WDB2 - return false; - - EndianConvert(minIndex); - - CASC::ReadFile(db2Handle, &maxIndex, sizeof(maxIndex), &bytesRead); - if (bytesRead != sizeof(maxIndex)) // MaxIndex WDB2 - return false; - - EndianConvert(maxIndex); - - CASC::ReadFile(db2Handle, &localeMask, sizeof(localeMask), &bytesRead); - if (bytesRead != sizeof(localeMask)) // Locales - return false; - - EndianConvert(localeMask); - - CASC::ReadFile(db2Handle, ©IdSize, sizeof(copyIdSize), &bytesRead); - if (bytesRead != sizeof(copyIdSize)) - return false; - - EndianConvert(copyIdSize); - - CASC::ReadFile(db2Handle, &metaFlags, sizeof(metaFlags), &bytesRead); - if (bytesRead != sizeof(metaFlags)) - return false; - - EndianConvert(metaFlags); - - ASSERT((metaFlags & 0x1) == 0); - ASSERT((meta->IndexField == -1) || (meta->IndexField == int32((metaFlags >> 16)))); - - fields = new FieldEntry[fieldCount]; - CASC::ReadFile(db2Handle, fields, fieldCount * sizeof(FieldEntry), &bytesRead); - if (bytesRead != fieldCount * sizeof(FieldEntry)) - return false; - - if (!meta->HasIndexFieldInData()) - idTableSize = recordCount * sizeof(std::uint32_t); - - data = new unsigned char[recordSize * recordCount + stringSize]; - stringTable = data + recordSize * recordCount; - - CASC::ReadFile(db2Handle, data, recordSize * recordCount + stringSize, &bytesRead); - if (bytesRead != recordSize * recordCount + stringSize) - return false; - - if (idTableSize) - { - idTable = new unsigned char[idTableSize]; - CASC::ReadFile(db2Handle, idTable, idTableSize, &bytesRead); - if (bytesRead != idTableSize) - return false; - } - - if (copyIdSize) - { - copyTable = new unsigned char[copyIdSize]; - CASC::ReadFile(db2Handle, copyTable, copyIdSize, &bytesRead); - if (bytesRead != copyIdSize) - return false; - } - - return true; -} - -DB2FileLoader::~DB2FileLoader() -{ - delete[] data; - delete[] idTable; - delete[] copyTable; - delete[] fields; -} - -DB2FileLoader::Record DB2FileLoader::getRecord(size_t id) -{ - assert(data); - return Record(*this, data + id * recordSize); -} - -std::pair DB2FileLoader::GetRowCopy(std::uint32_t i) const -{ - std::uint32_t* copyIds = (std::uint32_t*)copyTable; - std::uint32_t to = copyIds[i]; - std::uint32_t from = copyIds[i + 1]; - return{ from, to }; -} - -std::uint32_t DB2FileLoader::GetMaxId() const -{ - std::uint32_t j = maxIndex; - for (std::uint32_t i = 0; i < GetNumRowCopies(); ++i) - if (j < GetRowCopy(i).second) - j = GetRowCopy(i).second; - - return j; -} diff --git a/src/tools/vmap4_extractor/DB2.h b/src/tools/vmap4_extractor/DB2.h deleted file mode 100644 index f28aeb0e05f..00000000000 --- a/src/tools/vmap4_extractor/DB2.h +++ /dev/null @@ -1,176 +0,0 @@ -/* - * Copyright (C) 2008-2017 TrinityCore - * - * This program is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License as published by the - * Free Software Foundation; either version 2 of the License, or (at your - * option) any later version. - * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for - * more details. - * - * You should have received a copy of the GNU General Public License along - * with this program. If not, see . - */ - -#ifndef MapExtractor_DB2_h__ -#define MapExtractor_DB2_h__ - -#include "DB2Meta.h" -#include "CascHandles.h" -#include "CascLib.h" -#include "Utilities/ByteConverter.h" -#include "Errors.h" - -class DB2FileLoader -{ - public: - DB2FileLoader(); - ~DB2FileLoader(); - - bool Load(CASC::FileHandle const& db2Handle, DB2Meta const* meta); - - class Record - { - public: - float getFloat(std::uint32_t field, std::uint32_t arrayIndex) const - { - ASSERT(field < file.fieldCount); - float val = *reinterpret_cast(offset + GetOffset(field) + arrayIndex * sizeof(float)); - EndianConvert(val); - return val; - } - - std::uint32_t getUInt(std::uint32_t field, std::uint32_t arrayIndex) const - { - ASSERT(field < file.fieldCount); - return GetVarInt(field, GetByteSize(field), arrayIndex); - } - - std::uint8_t getUInt8(std::uint32_t field, std::uint32_t arrayIndex) const - { - ASSERT(field < file.fieldCount); - ASSERT(GetByteSize(field) == 1); - return *reinterpret_cast(offset + GetOffset(field) + arrayIndex * sizeof(std::uint8_t)); - } - - std::uint16_t getUInt16(std::uint32_t field, std::uint32_t arrayIndex) const - { - ASSERT(field < file.fieldCount); - ASSERT(GetByteSize(field) == 2); - std::uint16_t val = *reinterpret_cast(offset + GetOffset(field) + arrayIndex * sizeof(std::uint16_t)); - EndianConvert(val); - return val; - } - - char const* getString(std::uint32_t field, std::uint32_t arrayIndex) const - { - ASSERT(field < file.fieldCount); - std::uint32_t stringOffset = *reinterpret_cast(offset + GetOffset(field) + arrayIndex * sizeof(std::uint32_t)); - EndianConvert(stringOffset); - ASSERT(stringOffset < file.stringSize); - return reinterpret_cast(file.stringTable + stringOffset); - } - - private: - std::uint16_t GetOffset(std::uint32_t field) const - { - ASSERT(field < file.fieldCount); - return file.fields[field].Offset; - } - - std::uint16_t GetByteSize(std::uint32_t field) const - { - ASSERT(field < file.fieldCount); - return 4 - file.fields[field].UnusedBits / 8; - } - - std::uint32_t GetVarInt(std::uint32_t field, std::uint16_t size, std::uint32_t arrayIndex) const - { - ASSERT(field < file.fieldCount); - switch (size) - { - case 1: - { - return *reinterpret_cast(offset + GetOffset(field) + arrayIndex * sizeof(std::uint8_t)); - } - case 2: - { - std::uint16_t val = *reinterpret_cast(offset + GetOffset(field) + arrayIndex * sizeof(std::uint16_t)); - EndianConvert(val); - return val; - } - case 3: - { -#pragma pack(push, 1) - struct dbcint24 { std::uint8_t v[3]; }; -#pragma pack(pop) - dbcint24 val = *reinterpret_cast(offset + GetOffset(field) + arrayIndex * sizeof(dbcint24)); - EndianConvert(val); - return std::uint32_t(val.v[0]) | (std::uint32_t(val.v[1]) << 8) | (std::uint32_t(val.v[2]) << 16); - } - case 4: - { - std::uint32_t val = *reinterpret_cast(offset + GetOffset(field) + arrayIndex * sizeof(std::uint32_t)); - EndianConvert(val); - return val; - } - default: - break; - } - - ASSERT(false, "GetByteSize(field) < 4"); - return 0; - } - - Record(DB2FileLoader &file_, unsigned char *offset_): offset(offset_), file(file_) {} - unsigned char *offset; - DB2FileLoader &file; - - friend class DB2FileLoader; - }; - - // Get record by id - Record getRecord(size_t id); - std::uint32_t getId(size_t row) { return ((std::uint32_t*)idTable)[row]; } - std::pair GetRowCopy(std::uint32_t i) const; - - std::uint32_t GetNumRows() const { return recordCount; } - std::uint32_t GetNumRowCopies() const { return copyIdSize / 8; } - std::uint32_t GetMaxId() const; - -private: -#pragma pack(push, 1) - struct FieldEntry - { - std::uint16_t UnusedBits; - std::uint16_t Offset; - }; -#pragma pack(pop) - - DB2Meta const* meta; - - // WDB2 / WCH2 fields - std::uint32_t recordSize; - std::uint32_t recordCount; - std::uint32_t fieldCount; - std::uint32_t stringSize; - std::uint32_t tableHash; - std::uint32_t layoutHash; - std::uint32_t minIndex; - std::uint32_t maxIndex; - std::uint32_t localeMask; - std::uint32_t copyIdSize; - std::uint32_t metaFlags; - - unsigned char* data; - unsigned char* stringTable; - unsigned char* idTable; - std::uint32_t idTableSize; - unsigned char* copyTable; - FieldEntry* fields; -}; - -#endif // MapExtractor_DB2_h__ diff --git a/src/tools/vmap4_extractor/adtfile.cpp b/src/tools/vmap4_extractor/adtfile.cpp index f4cb5b686da..e97469c0918 100644 --- a/src/tools/vmap4_extractor/adtfile.cpp +++ b/src/tools/vmap4_extractor/adtfile.cpp @@ -148,12 +148,16 @@ bool ADTFile::init(uint32 map_num, uint32 tileX, uint32 tileY) char* p = buf; while (p < buf + size) { + std::string path(p); + char* s = GetPlainName(p); FixNameCase(s, strlen(s)); FixNameSpaces(s, strlen(s)); WmoInstanceNames.push_back(s); + ExtractSingleWmo(path); + p += strlen(p) + 1; } delete[] buf; diff --git a/src/tools/vmap4_extractor/cascfile.cpp b/src/tools/vmap4_extractor/cascfile.cpp index b9074d8696e..2a54e5ba27b 100644 --- a/src/tools/vmap4_extractor/cascfile.cpp +++ b/src/tools/vmap4_extractor/cascfile.cpp @@ -1,5 +1,22 @@ +/* + * Copyright (C) 2008-2017 TrinityCore + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with this program. If not, see . + */ + #include "cascfile.h" -#include +#include #include CASCFile::CASCFile(CASC::StorageHandle const& casc, const char* filename, bool warnNoExist /*= true*/) : @@ -12,33 +29,34 @@ CASCFile::CASCFile(CASC::StorageHandle const& casc, const char* filename, bool w if (!file) { if (warnNoExist || GetLastError() != ERROR_FILE_NOT_FOUND) - fprintf(stderr, "Can't open %s, err=%u!\n", filename, GetLastError()); + fprintf(stderr, "Can't open %s: %s\n", filename, CASC::HumanReadableCASCError(GetLastError())); eof = true; return; } - DWORD hi = 0; - size = CASC::GetFileSize(file, &hi); - - if (hi) + DWORD fileSizeHigh = 0; + DWORD fileSize = CASC::GetFileSize(file, &fileSizeHigh); + if (fileSize == CASC_INVALID_SIZE) { - fprintf(stderr, "Can't open %s, size[hi] = %u!\n", filename, uint32(hi)); + fprintf(stderr, "Can't open %s, failed to get size: %s!\n", filename, CASC::HumanReadableCASCError(GetLastError())); eof = true; return; } - if (size <= 1) + if (fileSizeHigh) { - fprintf(stderr, "Can't open %s, size = %u!\n", filename, uint32(size)); + fprintf(stderr, "Can't open %s, file larger than 2GB", filename); eof = true; return; } + size = fileSize; + DWORD read = 0; buffer = new char[size]; if (!CASC::ReadFile(file, buffer, size, &read) || size != read) { - fprintf(stderr, "Can't read %s, size=%u read=%u!\n", filename, uint32(size), uint32(read)); + fprintf(stderr, "Can't read %s, size=%u read=%u: %s\n", filename, uint32(size), uint32(read), CASC::HumanReadableCASCError(GetLastError())); eof = true; return; } @@ -46,10 +64,12 @@ CASCFile::CASCFile(CASC::StorageHandle const& casc, const char* filename, bool w size_t CASCFile::read(void* dest, size_t bytes) { - if (eof) return 0; + if (eof) + return 0; size_t rpos = pointer + bytes; - if (rpos > size) { + if (rpos > size) + { bytes = size - pointer; eof = true; } @@ -75,7 +95,7 @@ void CASCFile::seekRelative(int offset) void CASCFile::close() { - if (buffer) delete[] buffer; + delete[] buffer; buffer = 0; eof = true; } diff --git a/src/tools/vmap4_extractor/cascfile.h b/src/tools/vmap4_extractor/cascfile.h index 882ec116ca5..fd97fb6e008 100644 --- a/src/tools/vmap4_extractor/cascfile.h +++ b/src/tools/vmap4_extractor/cascfile.h @@ -1,3 +1,20 @@ +/* + * Copyright (C) 2008-2017 TrinityCore + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with this program. If not, see . + */ + #define _CRT_SECURE_NO_DEPRECATE #ifndef _CRT_SECURE_NO_WARNINGS // fuck the police^Wwarnings #define _CRT_SECURE_NO_WARNINGS @@ -6,33 +23,12 @@ #ifndef MPQ_H #define MPQ_H -#include -#include -#include -#include -#include -#include +#include "Define.h" #include "CascHandles.h" -#include "CascLib.h" - -typedef int64_t int64; -typedef int32_t int32; -typedef int16_t int16; -typedef int8_t int8; -typedef uint64_t uint64; -typedef uint32_t uint32; -typedef uint16_t uint16; -typedef uint8_t uint8; - -#ifdef _WIN32 -#include // mainly only HANDLE definition is required -#else -int GetLastError(); -#endif +#include class CASCFile { - //MPQHANDLE handle; bool eof; char *buffer; size_t pointer,size; @@ -57,13 +53,8 @@ public: inline void flipcc(char *fcc) { - char t; - t=fcc[0]; - fcc[0]=fcc[3]; - fcc[3]=t; - t=fcc[1]; - fcc[1]=fcc[2]; - fcc[2]=t; + std::swap(fcc[0], fcc[3]); + std::swap(fcc[1], fcc[2]); } #endif diff --git a/src/tools/vmap4_extractor/gameobject_extract.cpp b/src/tools/vmap4_extractor/gameobject_extract.cpp index 08777315470..73fa7130f24 100644 --- a/src/tools/vmap4_extractor/gameobject_extract.cpp +++ b/src/tools/vmap4_extractor/gameobject_extract.cpp @@ -16,14 +16,16 @@ * with this program. If not, see . */ -#include "DB2.h" -#include "model.h" #include "adtfile.h" -#include "vmapexport.h" +#include "DB2CascFileSource.h" +#include "DB2Meta.h" +#include "Errors.h" +#include "model.h" #include "StringFormat.h" - +#include "vmapexport.h" +#include #include -#include +#include bool ExtractSingleModel(std::string& fname) { @@ -55,14 +57,29 @@ bool ExtractSingleModel(std::string& fname) extern CASC::StorageHandle CascStorage; -struct GameObjectDisplayInfoMeta +struct GameobjectDisplayInfoLoadInfo { - static DB2Meta const* Instance() + static DB2FileLoadInfo const* Instance() { + static DB2FieldMeta const fields[] = + { + { false, FT_INT, "ID" }, + { false, FT_INT, "FileDataID" }, + { false, FT_FLOAT, "GeoBoxMinX" }, + { false, FT_FLOAT, "GeoBoxMinY" }, + { false, FT_FLOAT, "GeoBoxMinZ" }, + { false, FT_FLOAT, "GeoBoxMaxX" }, + { false, FT_FLOAT, "GeoBoxMaxY" }, + { false, FT_FLOAT, "GeoBoxMaxZ" }, + { false, FT_FLOAT, "OverrideLootEffectScale" }, + { false, FT_FLOAT, "OverrideNameScale" }, + { false, FT_SHORT, "ObjectEffectPackageID" }, + }; static char const* types = "ifffh"; static uint8 const arraySizes[5] = { 1, 6, 1, 1, 1 }; - static DB2Meta instance(-1, 5, 0xE2D6FAB7, types, arraySizes); - return &instance; + static DB2Meta const meta(-1, 5, 0xE2D6FAB7, types, arraySizes); + static DB2FileLoadInfo const loadInfo(&fields[0], std::extent::value, &meta); + return &loadInfo; } }; @@ -89,15 +106,11 @@ bool GetHeaderMagic(std::string const& fileName, uint32* magic) void ExtractGameobjectModels() { - printf("Extracting GameObject models..."); - CASC::FileHandle dbcFile = CASC::OpenFile(CascStorage, "DBFilesClient\\GameObjectDisplayInfo.db2", CASC_LOCALE_NONE, true); - if (!dbcFile) - { - exit(1); - } + printf("Extracting GameObject models...\n"); + DB2CascFileSource source(CascStorage, "DBFilesClient\\GameObjectDisplayInfo.db2"); DB2FileLoader db2; - if (!db2.Load(dbcFile, GameObjectDisplayInfoMeta::Instance())) + if (!db2.Load(&source, GameobjectDisplayInfoLoadInfo::Instance())) { printf("Fatal error: Invalid GameObjectDisplayInfo.db2 file format!\n"); exit(1); @@ -114,9 +127,10 @@ void ExtractGameobjectModels() return; } - for (uint32 rec = 0; rec < db2.GetNumRows(); ++rec) + for (uint32 rec = 0; rec < db2.GetRecordCount(); ++rec) { - uint32 fileId = db2.getRecord(rec).getUInt(0, 0); + DB2Record record = db2.GetRecord(rec); + uint32 fileId = record.GetUInt32(0, 0); if (!fileId) continue; @@ -135,7 +149,7 @@ void ExtractGameobjectModels() if (result) { - uint32 displayId = db2.getId(rec); + uint32 displayId = record.GetId(); uint32 path_length = fileName.length(); fwrite(&displayId, sizeof(uint32), 1, model_list); fwrite(&path_length, sizeof(uint32), 1, model_list); diff --git a/src/tools/vmap4_extractor/vmapexport.cpp b/src/tools/vmap4_extractor/vmapexport.cpp index 571b8655646..02d0df202de 100644 --- a/src/tools/vmap4_extractor/vmapexport.cpp +++ b/src/tools/vmap4_extractor/vmapexport.cpp @@ -17,14 +17,29 @@ */ #define _CRT_SECURE_NO_DEPRECATE -#include +#define WIN32_LEAN_AND_MEAN + +#include "adtfile.h" +#include "Banner.h" +#include "Common.h" +#include "cascfile.h" +#include "DB2CascFileSource.h" +#include "DB2Meta.h" +#include "StringFormat.h" +#include "vmapexport.h" +#include "wdtfile.h" +#include "wmo.h" +#include +#include +#include #include -#include #include -#include +#include +#include +#include +#include #ifdef WIN32 - #define WIN32_LEAN_AND_MEAN #include #include #include @@ -34,22 +49,6 @@ #define ERROR_PATH_NOT_FOUND ERROR_FILE_NOT_FOUND #endif -#include -#include - -#include "Common.h" -//From Extractor -#include "adtfile.h" -#include "wdtfile.h" -#include "DB2.h" -#include "wmo.h" -#include "cascfile.h" - -#include "vmapexport.h" -#include "Banner.h" -#include -#include - //------------------------------------------------------------------------------ // Defines @@ -66,30 +65,44 @@ typedef struct }map_id; std::vector map_ids; -std::vector LiqType; uint32 map_count; boost::filesystem::path input_path; bool preciseVectorData = false; -struct LiquidTypeMeta +struct MapLoadInfo { - static DB2Meta const* Instance() - { - static char const* types = "sifffffsifihhbbbbbi"; - static uint8 const arraySizes[19] = { 1, 1, 1, 1, 1, 1, 1, 6, 2, 18, 4, 1, 1, 1, 1, 1, 1, 6, 1 }; - static DB2Meta instance(-1, 19, 0x99FC34E5, types, arraySizes); - return &instance; - } -}; - -struct MapMeta -{ - static DB2Meta const* Instance() + static DB2FileLoadInfo const* Instance() { + static DB2FieldMeta const fields[] = + { + { false, FT_INT, "ID" }, + { false, FT_STRING_NOT_LOCALIZED, "Directory" }, + { false, FT_INT, "Flags1" }, + { false, FT_INT, "Flags2" }, + { false, FT_FLOAT, "MinimapIconScale" }, + { false, FT_FLOAT, "CorpsePosX" }, + { false, FT_FLOAT, "CorpsePosY" }, + { false, FT_STRING, "MapName" }, + { false, FT_STRING, "MapDescription0" }, + { false, FT_STRING, "MapDescription1" }, + { false, FT_SHORT, "AreaTableID" }, + { false, FT_SHORT, "LoadingScreenID" }, + { true, FT_SHORT, "CorpseMapID" }, + { false, FT_SHORT, "TimeOfDayOverride" }, + { true, FT_SHORT, "ParentMapID" }, + { true, FT_SHORT, "CosmeticParentMapID" }, + { false, FT_SHORT, "WindSettingsID" }, + { false, FT_BYTE, "InstanceType" }, + { false, FT_BYTE, "unk5" }, + { false, FT_BYTE, "ExpansionID" }, + { false, FT_BYTE, "MaxPlayers" }, + { false, FT_BYTE, "TimeOffset" }, + }; static char const* types = "siffssshhhhhhhbbbbb"; static uint8 const arraySizes[19] = { 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }; - static DB2Meta instance(-1, 19, 0xF7CF2DA2, types, arraySizes); - return &instance; + static DB2Meta const meta(-1, 19, 0xF7CF2DA2, types, arraySizes); + static DB2FileLoadInfo const loadInfo(&fields[0], std::extent::value, &meta); + return &loadInfo; } }; @@ -129,32 +142,6 @@ uint32 WowLocaleToCascLocaleFlags[12] = CASC_LOCALE_ITIT, }; -namespace -{ - const char* HumanReadableCASCError(int error) - { - switch (error) - { - case ERROR_SUCCESS: return "SUCCESS"; - case ERROR_FILE_CORRUPT: return "FILE_CORRUPT"; - case ERROR_CAN_NOT_COMPLETE: return "CAN_NOT_COMPLETE"; - case ERROR_HANDLE_EOF: return "HANDLE_EOF"; - case ERROR_NO_MORE_FILES: return "NO_MORE_FILES"; - case ERROR_BAD_FORMAT: return "BAD_FORMAT"; - case ERROR_INSUFFICIENT_BUFFER: return "INSUFFICIENT_BUFFER"; - case ERROR_ALREADY_EXISTS: return "ALREADY_EXISTS"; - case ERROR_DISK_FULL: return "DISK_FULL"; - case ERROR_INVALID_PARAMETER: return "INVALID_PARAMETER"; - case ERROR_NOT_SUPPORTED: return "NOT_SUPPORTED"; - case ERROR_NOT_ENOUGH_MEMORY: return "NOT_ENOUGH_MEMORY"; - case ERROR_INVALID_HANDLE: return "INVALID_HANDLE"; - case ERROR_ACCESS_DENIED: return "ACCESS_DENIED"; - case ERROR_FILE_NOT_FOUND: return "FILE_NOT_FOUND"; - default: return "UNKNOWN"; - } - } -} - uint32 ReadBuild(int locale) { // include build info file also @@ -241,73 +228,6 @@ void strToLower(char* str) } } -// copied from src\tools\map_extractor\System.cpp -void ReadLiquidTypeTableDBC() -{ - printf("Read LiquidType.dbc file..."); - CASC::FileHandle dbcFile = CASC::OpenFile(CascStorage, "DBFilesClient\\LiquidType.db2", CASC_LOCALE_NONE, true); - if (!dbcFile) - { - exit(1); - } - - DB2FileLoader db2; - if (!db2.Load(dbcFile, LiquidTypeMeta::Instance())) - { - printf("Fatal error: Invalid LiquidType.db2 file format!\n"); - exit(1); - } - - LiqType.resize(db2.GetMaxId() + 1, 0xFFFF); - - for (uint32 x = 0; x < db2.GetNumRows(); ++x) - { - uint32 liquidTypeId; - if (LiquidTypeMeta::Instance()->HasIndexFieldInData()) - liquidTypeId = db2.getRecord(x).getUInt(LiquidTypeMeta::Instance()->GetIndexField(), 0); - else - liquidTypeId = db2.getId(x); - - LiqType[liquidTypeId] = db2.getRecord(x).getUInt8(13, 0); - } - - for (uint32 x = 0; x < db2.GetNumRowCopies(); ++x) - LiqType[db2.GetRowCopy(x).second] = LiqType[db2.GetRowCopy(x).first]; - - printf("Done! (" SZFMTD " LiqTypes loaded)\n", LiqType.size()); -} - -bool ExtractWmo() -{ - bool success = true; - - std::ifstream wmoList("wmo_list.txt"); - if (!wmoList) - { - printf("\nUnable to open wmo_list.txt! Nothing extracted.\n"); - return false; - } - - std::set wmos; - for (;;) - { - std::string str; - std::getline(wmoList, str); - if (str.empty()) - break; - - wmos.insert(std::move(str)); - } - - for (std::string str : wmos) - success &= ExtractSingleWmo(str); - - if (success) - printf("\nExtract wmo complete (No (fatal) errors)\n"); - - return success; -} - bool ExtractSingleWmo(std::string& fname) { // Copy files from archive @@ -315,7 +235,8 @@ bool ExtractSingleWmo(std::string& fname) char szLocalFile[1024]; const char * plain_name = GetPlainName(fname.c_str()); sprintf(szLocalFile, "%s/%s", szWorkDirWmo, plain_name); - FixNameCase(szLocalFile,strlen(szLocalFile)); + FixNameCase(szLocalFile, strlen(szLocalFile)); + FixNameSpaces(szLocalFile, strlen(szLocalFile)); if (FileExists(szLocalFile)) return true; @@ -339,7 +260,7 @@ bool ExtractSingleWmo(std::string& fname) return true; bool file_ok = true; - std::cout << "Extracting " << fname << std::endl; + printf("Extracting %s\n", fname.c_str()); WMORoot froot(fname); if(!froot.open()) { @@ -355,25 +276,18 @@ bool ExtractSingleWmo(std::string& fname) froot.ConvertToVMAPRootWmo(output); int Wmo_nVertices = 0; //printf("root has %d groups\n", froot->nGroups); - if (!froot.groupFileDataIDs.empty()) + for (std::size_t i = 0; i < froot.groupFileDataIDs.size(); ++i) { - for (std::size_t i = 0; i < froot.groupFileDataIDs.size(); ++i) + std::string s = Trinity::StringFormat("FILE%08X.xxx", froot.groupFileDataIDs[i]); + WMOGroup fgroup(s); + if(!fgroup.open()) { - char groupFileName[1024]; - sprintf(groupFileName, "FILE%08X", froot.groupFileDataIDs[i]); - //printf("Trying to open groupfile %s\n",groupFileName); - - std::string s = groupFileName; - WMOGroup fgroup(s); - if(!fgroup.open()) - { - printf("Could not open all Group file for: %s\n", plain_name); - file_ok = false; - break; - } - - Wmo_nVertices += fgroup.ConvertToVMAPGroupWmo(output, &froot, preciseVectorData); + printf("Could not open all Group file for: %s\n", plain_name); + file_ok = false; + break; } + + Wmo_nVertices += fgroup.ConvertToVMAPGroupWmo(output, &froot, preciseVectorData); } fseek(output, 8, SEEK_SET); // store the correct no of vertices @@ -544,41 +458,28 @@ int main(int argc, char ** argv) // Extract models, listed in GameObjectDisplayInfo.dbc ExtractGameobjectModels(); - ReadLiquidTypeTableDBC(); - - // extract data - if (success) - success = ExtractWmo(); - //xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx //map.dbc if (success) { printf("Read Map.dbc file... "); - CASC::FileHandle dbcFile = CASC::OpenFile(CascStorage, "DBFilesClient\\Map.db2", CASC_LOCALE_NONE, true); - if (!dbcFile) - { - exit(1); - } - + DB2CascFileSource source(CascStorage, "DBFilesClient\\Map.db2"); DB2FileLoader db2; - if (!db2.Load(dbcFile, MapMeta::Instance())) + if (!db2.Load(&source, MapLoadInfo::Instance())) { - printf("Fatal error: Invalid Map.db2 file format! %s\n", HumanReadableCASCError(GetLastError())); + printf("Fatal error: Invalid Map.db2 file format! %s\n", CASC::HumanReadableCASCError(GetLastError())); exit(1); } - map_ids.resize(db2.GetNumRows()); + map_ids.resize(db2.GetRecordCount()); std::unordered_map idToIndex; - for (uint32 x = 0; x < db2.GetNumRows(); ++x) + for (uint32 x = 0; x < db2.GetRecordCount(); ++x) { - if (MapMeta::Instance()->HasIndexFieldInData()) - map_ids[x].id = db2.getRecord(x).getUInt(MapMeta::Instance()->GetIndexField(), 0); - else - map_ids[x].id = db2.getId(x); + DB2Record record = db2.GetRecord(x); + map_ids[x].id = record.GetId(); - const char* map_name = db2.getRecord(x).getString(0, 0); + const char* map_name = record.GetString(0, 0); size_t max_map_name_length = sizeof(map_ids[x].name); if (strlen(map_name) >= max_map_name_length) { @@ -591,15 +492,14 @@ int main(int argc, char ** argv) idToIndex[map_ids[x].id] = x; } - for (uint32 x = 0; x < db2.GetNumRowCopies(); ++x) + for (uint32 x = 0; x < db2.GetRecordCopyCount(); ++x) { - uint32 from = db2.GetRowCopy(x).first; - uint32 to = db2.GetRowCopy(x).second; - auto itr = idToIndex.find(from); + DB2RecordCopy copy = db2.GetRecordCopy(x); + auto itr = idToIndex.find(copy.SourceRowId); if (itr != idToIndex.end()) { map_id id; - id.id = to; + id.id = copy.NewRowId; strcpy(id.name, map_ids[itr->second].name); map_ids.push_back(id); } diff --git a/src/tools/vmap4_extractor/wdtfile.cpp b/src/tools/vmap4_extractor/wdtfile.cpp index ce2e98886bf..318d16ad3bc 100644 --- a/src/tools/vmap4_extractor/wdtfile.cpp +++ b/src/tools/vmap4_extractor/wdtfile.cpp @@ -80,10 +80,15 @@ bool WDTFile::init(char* /*map_id*/, unsigned int mapID) char *p = buf; while (p < buf + size) { + std::string path(p); + char* s = wdtGetPlainName(p); FixNameCase(s, strlen(s)); + FixNameSpaces(s, strlen(s)); p = p + strlen(p) + 1; gWmoInstansName.push_back(s); + + ExtractSingleWmo(path); } delete[] buf; } diff --git a/src/tools/vmap4_extractor/wdtfile.h b/src/tools/vmap4_extractor/wdtfile.h index 2a7d7df797c..07fc20bd9a8 100644 --- a/src/tools/vmap4_extractor/wdtfile.h +++ b/src/tools/vmap4_extractor/wdtfile.h @@ -23,7 +23,6 @@ #include "wmo.h" #include #include -#include class ADTFile; diff --git a/src/tools/vmap4_extractor/wmo.cpp b/src/tools/vmap4_extractor/wmo.cpp index b538da01d0e..03e32658337 100644 --- a/src/tools/vmap4_extractor/wmo.cpp +++ b/src/tools/vmap4_extractor/wmo.cpp @@ -29,7 +29,6 @@ #include "cascfile.h" using namespace std; -extern std::vector LiqType; WMORoot::WMORoot(std::string &filename) : filename(filename), color(0), nTextures(0), nGroups(0), nPortals(0), nLights(0), diff --git a/src/tools/vmap4_extractor/wmo.h b/src/tools/vmap4_extractor/wmo.h index 05bc940042a..adb84e022c5 100644 --- a/src/tools/vmap4_extractor/wmo.h +++ b/src/tools/vmap4_extractor/wmo.h @@ -135,8 +135,6 @@ public: uint32 indx, id, d2, d3; WMOInstance(CASCFile&f , char const* WmoInstName, uint32 mapID, uint32 tileX, uint32 tileY, FILE* pDirfile); - - static void reset(); }; #endif