zone/OpenAssetTools
zone/OpenAssetTools
2
0
Fork 0
mirror of https://github.com/Laupetin/OpenAssetTools.git synced 2025-05-30 13:07:41 +00:00
Code

refactor: fix x64 compilation for ZoneLoading

Browse Source
This commit is contained in:
Jan 2025-04-26 11:45:33 +01:00 committed by Jan Laupetin
parent de43e33dcd
commit 3b00c1d45b
No known key found for this signature in database
GPG Key ID: 44B581F78FF5C57C
13 changed files with 75 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/Common/Zone/ZoneTypes.h
View File

@ -14,6 +14,6 @@ typedef uint32_t xblock_size_t;
constexpr uint16_t SCR_STRING_MAX = std::numeric_limits<scr_string_t>::max();
typedef int block_t;
typedef int asset_type_t;
typedef unsigned block_t;
typedef unsigned asset_type_t;
typedef unsigned int zone_priority_t;

2
src/ZoneCommon/Zone/XBlock.h
View File

@ -14,7 +14,7 @@ public:
};
std::string m_name;
int m_index;
unsigned m_index;
Type m_type;
uint8_t* m_buffer;

15
src/ZoneLoading/Game/IW4/ZoneLoaderFactoryIW4.cpp
View File

@ -143,7 +143,8 @@ namespace
zoneLoader.AddLoadingStep(std::make_unique<StepVerifyFileName>(fileName, sizeof(DB_AuthSubHeader::fastfileName)));
zoneLoader.AddLoadingStep(std::make_unique<StepSkipBytes>(4)); // Skip reserved
auto masterBlockHashes = std::make_unique<StepLoadHash>(sizeof(DB_AuthHash::bytes), std::extent_v<decltype(DB_AuthSubHeader::masterBlockHashes)>);
auto masterBlockHashes =
std::make_unique<StepLoadHash>(sizeof(DB_AuthHash::bytes), static_cast<unsigned>(std::extent_v<decltype(DB_AuthSubHeader::masterBlockHashes)>));
auto* masterBlockHashesPtr = masterBlockHashes.get();
zoneLoader.AddLoadingStep(std::move(masterBlockHashes));
@ -153,12 +154,12 @@ namespace
// Skip the rest of the first chunk
zoneLoader.AddLoadingStep(std::make_unique<StepSkipBytes>(ZoneConstants::AUTHED_CHUNK_SIZE - sizeof(DB_AuthHeader)));
zoneLoader.AddLoadingStep(
std::make_unique<StepAddProcessor>(std::make_unique<ProcessorAuthedBlocks>(ZoneConstants::AUTHED_CHUNK_COUNT_PER_GROUP,
ZoneConstants::AUTHED_CHUNK_SIZE,
std::extent_v<decltype(DB_AuthSubHeader::masterBlockHashes)>,
cryptography::CreateSha256(),
masterBlockHashesPtr)));
zoneLoader.AddLoadingStep(std::make_unique<StepAddProcessor>(
std::make_unique<ProcessorAuthedBlocks>(ZoneConstants::AUTHED_CHUNK_COUNT_PER_GROUP,
ZoneConstants::AUTHED_CHUNK_SIZE,
static_cast<unsigned>(std::extent_v<decltype(DB_AuthSubHeader::masterBlockHashes)>),
cryptography::CreateSha256(),
masterBlockHashesPtr)));
}
} // namespace

15
src/ZoneLoading/Game/IW5/ZoneLoaderFactoryIW5.cpp
View File

@ -127,7 +127,8 @@ namespace
zoneLoader.AddLoadingStep(std::make_unique<StepVerifyFileName>(fileName, sizeof(DB_AuthSubHeader::fastfileName)));
zoneLoader.AddLoadingStep(std::make_unique<StepSkipBytes>(4)); // Skip reserved
auto masterBlockHashes = std::make_unique<StepLoadHash>(sizeof(DB_AuthHash::bytes), std::extent_v<decltype(DB_AuthSubHeader::masterBlockHashes)>);
auto masterBlockHashes =
std::make_unique<StepLoadHash>(sizeof(DB_AuthHash::bytes), static_cast<unsigned>(std::extent_v<decltype(DB_AuthSubHeader::masterBlockHashes)>));
auto* masterBlockHashesPtr = masterBlockHashes.get();
zoneLoader.AddLoadingStep(std::move(masterBlockHashes));
@ -137,12 +138,12 @@ namespace
// Skip the rest of the first chunk
zoneLoader.AddLoadingStep(std::make_unique<StepSkipBytes>(ZoneConstants::AUTHED_CHUNK_SIZE - sizeof(DB_AuthHeader)));
zoneLoader.AddLoadingStep(
std::make_unique<StepAddProcessor>(std::make_unique<ProcessorAuthedBlocks>(ZoneConstants::AUTHED_CHUNK_COUNT_PER_GROUP,
ZoneConstants::AUTHED_CHUNK_SIZE,
std::extent_v<decltype(DB_AuthSubHeader::masterBlockHashes)>,
cryptography::CreateSha256(),
masterBlockHashesPtr)));
zoneLoader.AddLoadingStep(std::make_unique<StepAddProcessor>(
std::make_unique<ProcessorAuthedBlocks>(ZoneConstants::AUTHED_CHUNK_COUNT_PER_GROUP,
ZoneConstants::AUTHED_CHUNK_SIZE,
static_cast<unsigned>(std::extent_v<decltype(DB_AuthSubHeader::masterBlockHashes)>),
cryptography::CreateSha256(),
masterBlockHashesPtr)));
}
} // namespace

6
src/ZoneLoading/Loading/Processor/ProcessorInflate.cpp
View File

@ -50,20 +50,20 @@ public:
size_t Load(void* buffer, const size_t length)
{
m_stream.next_out = static_cast<Bytef*>(buffer);
m_stream.avail_out = length;
m_stream.avail_out = static_cast<unsigned>(length);
while (m_stream.avail_out > 0)
{
if (m_stream.avail_in == 0)
{
m_stream.avail_in = m_base->m_base_stream->Load(m_buffer.get(), m_buffer_size);
m_stream.avail_in = static_cast<unsigned>(m_base->m_base_stream->Load(m_buffer.get(), m_buffer_size));
m_stream.next_in = m_buffer.get();
if (m_stream.avail_in == 0) // EOF
return length - m_stream.avail_out;
}
auto ret = inflate(&m_stream, Z_SYNC_FLUSH);
const auto ret = inflate(&m_stream, Z_SYNC_FLUSH);
if (ret < 0)
throw InvalidCompressionException();

12
src/ZoneLoading/Loading/Processor/ProcessorXChunks.cpp
View File

@ -78,7 +78,7 @@ public:
m_is_loading = false;
}
uint8_t* GetInputBuffer() const
[[nodiscard]] uint8_t* GetInputBuffer() const
{
return m_input_buffer;
}
@ -140,9 +140,9 @@ class ProcessorXChunks::ProcessorXChunksImpl
bool m_eof_reached;
unsigned int m_eof_stream;
void AdvanceStream(const unsigned int streamNum)
void AdvanceStream(const unsigned streamNum)
{
assert(streamNum >= 0 && streamNum < m_streams.size());
assert(streamNum < m_streams.size());
if (m_eof_reached)
return;
@ -203,8 +203,8 @@ class ProcessorXChunks::ProcessorXChunksImpl
m_initialized_streams = true;
m_vanilla_buffer_offset = static_cast<size_t>(m_base->m_base_stream->Pos());
const unsigned int streamCount = m_streams.size();
for (unsigned int streamNum = 0; streamNum < streamCount; streamNum++)
const auto streamCount = static_cast<unsigned>(m_streams.size());
for (auto streamNum = 0u; streamNum < streamCount; streamNum++)
{
AdvanceStream(streamNum);
}
@ -214,7 +214,7 @@ class ProcessorXChunks::ProcessorXChunksImpl
m_streams[0]->GetOutput(&m_current_chunk, &m_current_chunk_size);
}
bool EndOfStream() const
[[nodiscard]] bool EndOfStream() const
{
return m_eof_reached && m_eof_stream == m_current_stream;
}

8
src/ZoneLoading/Loading/Steps/StepAllocXBlocks.cpp
View File

@ -6,10 +6,10 @@ const uint64_t StepAllocXBlocks::MAX_XBLOCK_SIZE = 0x3C000000;
void StepAllocXBlocks::PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream)
{
const unsigned int blockCount = zoneLoader->m_blocks.size();
const auto blockCount = static_cast<unsigned>(zoneLoader->m_blocks.size());
auto* blockSizes = new xblock_size_t[blockCount];
stream->Load(blockSizes, sizeof(xblock_size_t) * blockCount);
const auto blockSizes = std::make_unique<xblock_size_t[]>(blockCount);
stream->Load(blockSizes.get(), sizeof(xblock_size_t) * blockCount);
uint64_t totalMemory = 0;
for (unsigned int block = 0; block < blockCount; block++)
@ -26,6 +26,4 @@ void StepAllocXBlocks::PerformStep(ZoneLoader* zoneLoader, ILoadingStream* strea
{
zoneLoader->m_blocks[block]->Alloc(blockSizes[block]);
}
delete[] blockSizes;
}

10
src/ZoneLoading/Loading/Steps/StepDumpData.cpp
View File

@ -2,21 +2,21 @@
#include <fstream>
StepDumpData::StepDumpData(const unsigned int dumpCount)
StepDumpData::StepDumpData(const size_t dumpCount)
: m_dump_count(dumpCount)
{
m_dump_count = dumpCount;
}
void StepDumpData::PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream)
{
uint8_t tempBuffer[128];
unsigned int dumpedBytes = 0;
auto dumpedBytes = 0uz;
std::ofstream tempFile("dump.dat", std::fstream::out | std::fstream::binary);
while (dumpedBytes < m_dump_count)
{
unsigned int toDump;
size_t toDump;
if (m_dump_count - dumpedBytes < sizeof(tempBuffer))
{
@ -33,7 +33,7 @@ void StepDumpData::PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream)
if (loadedSize == 0)
break;
tempFile.write(reinterpret_cast<char*>(tempBuffer), loadedSize);
tempFile.write(reinterpret_cast<char*>(tempBuffer), static_cast<std::streamsize>(loadedSize));
}
tempFile.close();

7
src/ZoneLoading/Loading/Steps/StepDumpData.h
View File

@ -4,10 +4,11 @@
class StepDumpData final : public ILoadingStep
{
unsigned int m_dump_count;
public:
explicit StepDumpData(unsigned int dumpCount);
explicit StepDumpData(size_t dumpCount);
void PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream) override;
private:
size_t m_dump_count;
};

8
src/ZoneLoading/Loading/Steps/StepSkipBytes.cpp
View File

@ -1,18 +1,18 @@
#include "StepSkipBytes.h"
StepSkipBytes::StepSkipBytes(const unsigned int skipCount)
StepSkipBytes::StepSkipBytes(const size_t skipCount)
: m_skip_count(skipCount)
{
m_skip_count = skipCount;
}
void StepSkipBytes::PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream)
{
uint8_t tempBuffer[128];
unsigned int skippedBytes = 0;
auto skippedBytes = 0uz;
while (skippedBytes < m_skip_count)
{
unsigned int toSkip;
size_t toSkip;
if (m_skip_count - skippedBytes < sizeof(tempBuffer))
{

7
src/ZoneLoading/Loading/Steps/StepSkipBytes.h
View File

@ -4,10 +4,11 @@
class StepSkipBytes final : public ILoadingStep
{
unsigned int m_skip_count;
public:
explicit StepSkipBytes(unsigned int skipCount);
explicit StepSkipBytes(size_t skipCount);
void PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream) override;
private:
size_t m_skip_count;
};

33
src/ZoneLoading/Zone/Stream/Impl/XBlockInputStream.cpp
View File

@ -13,23 +13,16 @@ XBlockInputStream::XBlockInputStream(std::vector<XBlock*>& blocks, ILoadingStrea
{
m_stream = stream;
const unsigned int blockCount = blocks.size();
m_block_offsets = new size_t[blockCount]{0};
const auto blockCount = static_cast<unsigned>(blocks.size());
m_block_offsets = std::make_unique<size_t[]>(blockCount);
std::memset(m_block_offsets.get(), 0, sizeof(size_t) * blockCount);
m_block_bit_count = blockBitCount;
assert(insertBlock >= 0 && insertBlock < static_cast<block_t>(blocks.size()));
assert(insertBlock < static_cast<block_t>(blocks.size()));
m_insert_block = blocks[insertBlock];
}
XBlockInputStream::~XBlockInputStream()
{
delete[] m_block_offsets;
m_block_offsets = nullptr;
assert(m_block_stack.empty());
}
void XBlockInputStream::Align(const unsigned align)
{
assert(!m_block_stack.empty());
@ -37,13 +30,13 @@ void XBlockInputStream::Align(const unsigned align)
if (align > 0)
{
const block_t blockIndex = m_block_stack.top()->m_index;
m_block_offsets[blockIndex] = (m_block_offsets[blockIndex] + align - 1) / align * align;
m_block_offsets[blockIndex] = (m_block_offsets[blockIndex] + align - 1u) / align * align;
}
}
void XBlockInputStream::PushBlock(const block_t block)
{
assert(block >= 0 && block < static_cast<block_t>(m_blocks.size()));
assert(block < static_cast<block_t>(m_blocks.size()));
XBlock* newBlock = m_blocks[block];
@ -150,7 +143,7 @@ void XBlockInputStream::IncBlockPos(const size_t size)
if (m_block_stack.empty())
return;
XBlock* block = m_block_stack.top();
const XBlock* block = m_block_stack.top();
m_block_offsets[block->m_index] += size;
}
@ -172,7 +165,7 @@ void XBlockInputStream::LoadNullTerminated(void* dst)
assert(dst == &block->m_buffer[m_block_offsets[block->m_index]]);
uint8_t byte;
size_t offset = reinterpret_cast<uint8_t*>(dst) - block->m_buffer;
size_t offset = static_cast<uint8_t*>(dst) - block->m_buffer;
do
{
if (offset >= block->m_buffer_size)
@ -198,7 +191,7 @@ void** XBlockInputStream::InsertPointer()
throw BlockOverflowException(m_insert_block);
}
void** ptr = reinterpret_cast<void**>(&m_insert_block->m_buffer[m_block_offsets[m_insert_block->m_index]]);
auto* ptr = reinterpret_cast<void**>(&m_insert_block->m_buffer[m_block_offsets[m_insert_block->m_index]]);
IncBlockPos(sizeof(void*));
@ -211,9 +204,9 @@ void* XBlockInputStream::ConvertOffsetToPointer(const void* offset)
{
// -1 because otherwise Block 0 Offset 0 would be just 0 which is already used to signalize a nullptr.
// So all offsets are moved by 1.
auto offsetInt = reinterpret_cast<uintptr_t>(offset) - 1;
const auto offsetInt = reinterpret_cast<uintptr_t>(offset) - 1u;
const block_t blockNum = offsetInt >> (sizeof(offsetInt) * 8 - m_block_bit_count);
const block_t blockNum = static_cast<block_t>(offsetInt >> (sizeof(offsetInt) * 8u - m_block_bit_count));
const size_t blockOffset = offsetInt & (UINTPTR_MAX >> m_block_bit_count);
if (blockNum < 0 || blockNum >= static_cast<block_t>(m_blocks.size()))
@ -234,9 +227,9 @@ void* XBlockInputStream::ConvertOffsetToPointer(const void* offset)
void* XBlockInputStream::ConvertOffsetToAlias(const void* offset)
{
// For details see ConvertOffsetToPointer
auto offsetInt = reinterpret_cast<uintptr_t>(offset) - 1;
const auto offsetInt = reinterpret_cast<uintptr_t>(offset) - 1;
const block_t blockNum = offsetInt >> (sizeof(offsetInt) * 8 - m_block_bit_count);
const block_t blockNum = static_cast<block_t>(offsetInt >> (sizeof(offsetInt) * 8 - m_block_bit_count));
const size_t blockOffset = offsetInt & (UINTPTR_MAX >> m_block_bit_count);
if (blockNum < 0 || blockNum >= static_cast<block_t>(m_blocks.size()))

27
src/ZoneLoading/Zone/Stream/Impl/XBlockInputStream.h
View File

@ -4,26 +4,14 @@
#include "Zone/Stream/IZoneInputStream.h"
#include "Zone/XBlock.h"
#include <memory>
#include <stack>
#include <vector>
class XBlockInputStream final : public IZoneInputStream
{
std::vector<XBlock*>& m_blocks;
size_t* m_block_offsets;
std::stack<XBlock*> m_block_stack;
std::stack<size_t> m_temp_offsets;
ILoadingStream* m_stream;
int m_block_bit_count;
XBlock* m_insert_block;
void Align(unsigned align);
public:
XBlockInputStream(std::vector<XBlock*>& blocks, ILoadingStream* stream, int blockBitCount, block_t insertBlock);
~XBlockInputStream() override;
void PushBlock(block_t block) override;
block_t PopBlock() override;
@ -39,4 +27,17 @@ public:
void* ConvertOffsetToPointer(const void* offset) override;
void* ConvertOffsetToAlias(const void* offset) override;
private:
void Align(unsigned align);
std::vector<XBlock*>& m_blocks;
std::unique_ptr<size_t[]> m_block_offsets;
std::stack<XBlock*> m_block_stack;
std::stack<size_t> m_temp_offsets;
ILoadingStream* m_stream;
unsigned m_block_bit_count;
XBlock* m_insert_block;
};