zone/OpenAssetTools
zone/OpenAssetTools
2
0
Fork 0
mirror of https://github.com/Laupetin/OpenAssetTools.git synced 2025-05-12 15:34:57 +00:00
Code Issues Packages Projects Wiki Activity

wip

Browse Source
This commit is contained in:
Jan 2025-05-03 17:31:17 +01:00 committed by Jan Laupetin
parent d66f585467
commit 670a5d4c97
No known key found for this signature in database
GPG Key ID: 44B581F78FF5C57C
26 changed files with 279 additions and 187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
src/ZoneCodeGeneratorLib/Generating/Templates/ZoneLoadTemplate.cpp
View File

@ -369,7 +369,8 @@ namespace
{
if (reusable)
{
LINEF("if (*{0} == PTR_FOLLOWING)", MakeTypePtrVarName(def))
LINEF("const auto zonePtrType = GetZonePointerType(*{0});", MakeTypePtrVarName(def))
LINEF("if (zonePtrType == ZonePointerType::FOLLOWING)", MakeTypePtrVarName(def))
LINE("{")
m_intendation++;
@ -805,7 +806,7 @@ namespace
{
LINE("")
LINEF("{0}** toInsert = nullptr;", member->m_member->m_type_declaration->m_type->GetFullName())
LINE("if (ptr == PTR_INSERT)")
LINE("if (zonePtrType == ZonePointerType::INSERT)")
m_intendation++;
LINEF("toInsert = m_stream.InsertPointerNative<{0}>();", member->m_member->m_type_declaration->m_type->GetFullName())
m_intendation--;
@ -850,10 +851,12 @@ namespace
return;
}
LINEF("const auto zonePtrType = GetZonePointerType({0});", MakeMemberAccess(info, member, modifier))
const MemberComputations computations(member);
if (computations.IsInTempBlock())
{
LINEF("if ({0} == PTR_FOLLOWING || {0} == PTR_INSERT)", MakeMemberAccess(info, member, modifier))
LINE("if (zonePtrType == ZonePointerType::FOLLOWING || zonePtrType == ZonePointerType::INSERT)")
LINE("{")
m_intendation++;
@ -872,7 +875,7 @@ namespace
}
else
{
LINEF("if ({0} == PTR_FOLLOWING)", MakeMemberAccess(info, member, modifier))
LINE("if (zonePtrType == ZonePointerType::FOLLOWING)")
LINE("{")
m_intendation++;
@ -1213,13 +1216,14 @@ namespace
LINE("{")
m_intendation++;
LINEF("const auto zonePtrType = GetZonePointerType(*{0});", MakeTypePtrVarName(info->m_definition))
if (inTemp)
{
LINEF("if (*{0} == PTR_FOLLOWING || *{0} == PTR_INSERT)", MakeTypePtrVarName(info->m_definition))
LINEF("if (zonePtrType == ZonePointerType::FOLLOWING || zonePtrType == ZonePointerType::INSERT)", MakeTypePtrVarName(info->m_definition))
}
else
{
LINEF("if (*{0} == PTR_FOLLOWING)", MakeTypePtrVarName(info->m_definition))
LINEF("if (zonePtrType == ZonePointerType::FOLLOWING)", MakeTypePtrVarName(info->m_definition))
}
LINE("{")
m_intendation++;
@ -1237,7 +1241,7 @@ namespace
{
LINE("")
LINEF("{0}** toInsert = nullptr;", info->m_definition->GetFullName())
LINE("if (ptr == PTR_INSERT)")
LINE("if (zonePtrType == ZonePointerType::INSERT)")
m_intendation++;
LINEF("toInsert = m_stream.InsertPointerNative<{0}>();", info->m_definition->GetFullName())
m_intendation--;

25
src/ZoneCommon/Zone/XBlock.cpp
View File

@ -1,34 +1,23 @@
#include "XBlock.h"
#include <cassert>
XBlock::XBlock(const std::string& name, const int index, const Type type)
XBlock::XBlock(std::string name, const unsigned index, const XBlockType type)
: m_name(std::move(name)),
m_index(index),
m_type(type),
m_buffer_size(0u)
{
m_name = name;
m_index = index;
m_type = type;
m_buffer = nullptr;
m_buffer_size = 0;
}
XBlock::~XBlock()
{
delete[] m_buffer;
m_buffer = nullptr;
}
void XBlock::Alloc(const size_t blockSize)
{
delete[] m_buffer;
if (blockSize > 0)
{
m_buffer = new uint8_t[blockSize];
m_buffer = std::make_unique<uint8_t[]>(blockSize);
m_buffer_size = blockSize;
}
else
{
m_buffer = nullptr;
m_buffer.reset();
m_buffer_size = 0;
}
}

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

@ -1,27 +1,29 @@
#pragma once
#include <cstddef>
#include <cstdint>
#include <memory>
#include <string>
enum class XBlockType : std::uint8_t
{
BLOCK_TYPE_TEMP,
BLOCK_TYPE_RUNTIME,
BLOCK_TYPE_DELAY,
BLOCK_TYPE_NORMAL
};
class XBlock
{
public:
enum class Type
{
BLOCK_TYPE_TEMP,
BLOCK_TYPE_RUNTIME,
BLOCK_TYPE_DELAY,
BLOCK_TYPE_NORMAL
};
XBlock(std::string name, unsigned index, XBlockType type);
void Alloc(size_t blockSize);
std::string m_name;
unsigned m_index;
Type m_type;
XBlockType m_type;
uint8_t* m_buffer;
std::unique_ptr<uint8_t[]> m_buffer;
size_t m_buffer_size;
XBlock(const std::string& name, int index, Type type);
~XBlock();
void Alloc(size_t blockSize);
};

4
src/ZoneLoading/Game/IW3/ContentLoaderIW3.cpp
View File

@ -48,7 +48,7 @@ void ContentLoader::LoadScriptStringList(const bool atStreamStart)
if (varScriptStringList->strings != nullptr)
{
assert(varScriptStringList->strings == PTR_FOLLOWING);
assert(GetZonePointerType(varScriptStringList->strings) == ZonePointerType::FOLLOWING);
varScriptStringList->strings = m_stream.Alloc<const char*>(alignof(const char*));
varXString = varScriptStringList->strings;
@ -146,7 +146,7 @@ void ContentLoader::Load()
if (assetList.assets != nullptr)
{
assert(assetList.assets == PTR_FOLLOWING);
assert(GetZonePointerType(assetList.assets) == ZonePointerType::FOLLOWING);
assetList.assets = m_stream.Alloc<XAsset>(alignof(XAsset));
varXAsset = assetList.assets;

21
src/ZoneLoading/Game/IW3/ZoneLoaderFactoryIW3.cpp
View File

@ -44,15 +44,15 @@ namespace
{
#define XBLOCK_DEF(name, type) std::make_unique<XBlock>(STR(name), name, type)
zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_TEMP, XBlock::Type::BLOCK_TYPE_TEMP));
zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_LARGE_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_PHYSICAL_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_VIRTUAL, XBlock::Type::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_LARGE, XBlock::Type::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_PHYSICAL, XBlock::Type::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_VERTEX, XBlock::Type::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_INDEX, XBlock::Type::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_LARGE_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_PHYSICAL_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_LARGE, XBlockType::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_VERTEX, XBlockType::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_INDEX, XBlockType::BLOCK_TYPE_NORMAL));
#undef XBLOCK_DEF
}
@ -92,7 +92,8 @@ std::unique_ptr<ZoneLoader> ZoneLoaderFactory::CreateLoaderForHeader(ZoneHeader&
},
32u,
ZoneConstants::OFFSET_BLOCK_BIT_COUNT,
ZoneConstants::INSERT_BLOCK));
ZoneConstants::INSERT_BLOCK,
zonePtr->Memory()));
return zoneLoader;
}

6
src/ZoneLoading/Game/IW4/ContentLoaderIW4.cpp
View File

@ -71,9 +71,9 @@ void ContentLoader::LoadScriptStringList(const bool atStreamStart)
if (varScriptStringList->strings != nullptr)
{
assert(varScriptStringList->strings == PTR_FOLLOWING);
assert(GetZonePointerType(varScriptStringList->strings) == ZonePointerType::FOLLOWING);
varScriptStringList->strings = m_stream.Alloc<const char*>(4);
varScriptStringList->strings = m_stream.AllocOutOfBlock<const char*>(4, varScriptStringList->count);
varXString = varScriptStringList->strings;
LoadXStringArray(true, varScriptStringList->count);
@ -179,7 +179,7 @@ void ContentLoader::Load()
if (assetList.assets != nullptr)
{
assert(assetList.assets == PTR_FOLLOWING);
assert(GetZonePointerType(assetList.assets) == ZonePointerType::FOLLOWING);
assetList.assets = m_stream.Alloc<XAsset>(alignof(XAsset));
varXAsset = assetList.assets;

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

@ -80,14 +80,14 @@ namespace
{
#define XBLOCK_DEF(name, type) std::make_unique<XBlock>(STR(name), name, type)
zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_TEMP, XBlock::Type::BLOCK_TYPE_TEMP));
zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_PHYSICAL, XBlock::Type::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_VIRTUAL, XBlock::Type::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_LARGE, XBlock::Type::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_CALLBACK, XBlock::Type::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_VERTEX, XBlock::Type::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_INDEX, XBlock::Type::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_LARGE, XBlockType::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_CALLBACK, XBlockType::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_VERTEX, XBlockType::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_INDEX, XBlockType::BLOCK_TYPE_NORMAL));
#undef XBLOCK_DEF
}
@ -214,7 +214,8 @@ std::unique_ptr<ZoneLoader> ZoneLoaderFactory::CreateLoaderForHeader(ZoneHeader&
},
32u,
ZoneConstants::OFFSET_BLOCK_BIT_COUNT,
ZoneConstants::INSERT_BLOCK));
ZoneConstants::INSERT_BLOCK,
zonePtr->Memory()));
return zoneLoader;
}

4
src/ZoneLoading/Game/IW5/ContentLoaderIW5.cpp
View File

@ -63,7 +63,7 @@ void ContentLoader::LoadScriptStringList(const bool atStreamStart)
if (varScriptStringList->strings != nullptr)
{
assert(varScriptStringList->strings == PTR_FOLLOWING);
assert(GetZonePointerType(varScriptStringList->strings) == ZonePointerType::FOLLOWING);
varScriptStringList->strings = m_stream.Alloc<const char*>(alignof(const char*));
varXString = varScriptStringList->strings;
@ -175,7 +175,7 @@ void ContentLoader::Load()
if (assetList.assets != nullptr)
{
assert(assetList.assets == PTR_FOLLOWING);
assert(GetZonePointerType(assetList.assets) == ZonePointerType::FOLLOWING);
assetList.assets = m_stream.Alloc<XAsset>(alignof(XAsset));
varXAsset = assetList.assets;

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

@ -63,15 +63,15 @@ namespace
{
#define XBLOCK_DEF(name, type) std::make_unique<XBlock>(STR(name), name, type)
zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_TEMP, XBlock::Type::BLOCK_TYPE_TEMP));
zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_PHYSICAL, XBlock::Type::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_VIRTUAL, XBlock::Type::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_LARGE, XBlock::Type::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_CALLBACK, XBlock::Type::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_VERTEX, XBlock::Type::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_INDEX, XBlock::Type::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_SCRIPT, XBlock::Type::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_LARGE, XBlockType::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_CALLBACK, XBlockType::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_VERTEX, XBlockType::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_INDEX, XBlockType::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_SCRIPT, XBlockType::BLOCK_TYPE_NORMAL));
#undef XBLOCK_DEF
}
@ -191,7 +191,8 @@ std::unique_ptr<ZoneLoader> ZoneLoaderFactory::CreateLoaderForHeader(ZoneHeader&
},
32u,
ZoneConstants::OFFSET_BLOCK_BIT_COUNT,
ZoneConstants::INSERT_BLOCK));
ZoneConstants::INSERT_BLOCK,
zonePtr->Memory()));
return zoneLoader;
}

4
src/ZoneLoading/Game/T5/ContentLoaderT5.cpp
View File

@ -55,7 +55,7 @@ void ContentLoader::LoadScriptStringList(const bool atStreamStart)
if (varScriptStringList->strings != nullptr)
{
assert(varScriptStringList->strings == PTR_FOLLOWING);
assert(GetZonePointerType(varScriptStringList->strings) == ZonePointerType::FOLLOWING);
varScriptStringList->strings = m_stream.Alloc<const char*>(alignof(const char*));
varXString = varScriptStringList->strings;
@ -159,7 +159,7 @@ void ContentLoader::Load()
if (assetList.assets != nullptr)
{
assert(assetList.assets == PTR_FOLLOWING);
assert(GetZonePointerType(assetList.assets) == ZonePointerType::FOLLOWING);
assetList.assets = m_stream.Alloc<XAsset>(alignof(XAsset));
varXAsset = assetList.assets;

17
src/ZoneLoading/Game/T5/ZoneLoaderFactoryT5.cpp
View File

@ -46,13 +46,13 @@ namespace
{
#define XBLOCK_DEF(name, type) std::make_unique<XBlock>(STR(name), name, type)
zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_TEMP, XBlock::Type::BLOCK_TYPE_TEMP));
zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_LARGE_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_PHYSICAL_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_VIRTUAL, XBlock::Type::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_LARGE, XBlock::Type::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_PHYSICAL, XBlock::Type::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_LARGE_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_PHYSICAL_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_LARGE, XBlockType::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
#undef XBLOCK_DEF
}
@ -92,7 +92,8 @@ std::unique_ptr<ZoneLoader> ZoneLoaderFactory::CreateLoaderForHeader(ZoneHeader&
},
32u,
ZoneConstants::OFFSET_BLOCK_BIT_COUNT,
ZoneConstants::INSERT_BLOCK));
ZoneConstants::INSERT_BLOCK,
zonePtr->Memory()));
return zoneLoader;
}

6
src/ZoneLoading/Game/T6/ContentLoaderT6.cpp
View File

@ -71,7 +71,7 @@ void ContentLoader::LoadScriptStringList(const bool atStreamStart)
if (varScriptStringList->strings != nullptr)
{
assert(varScriptStringList->strings == PTR_FOLLOWING);
assert(GetZonePointerType(varScriptStringList->strings) == ZonePointerType::FOLLOWING);
varScriptStringList->strings = m_stream.Alloc<const char*>(alignof(const char*));
varXString = varScriptStringList->strings;
@ -188,7 +188,7 @@ void ContentLoader::Load()
if (assetList.depends != nullptr)
{
assert(assetList.depends == PTR_FOLLOWING);
assert(GetZonePointerType(assetList.depends) == ZonePointerType::FOLLOWING);
assetList.depends = m_stream.Alloc<const char*>(alignof(const char*));
varXString = assetList.depends;
@ -197,7 +197,7 @@ void ContentLoader::Load()
if (assetList.assets != nullptr)
{
assert(assetList.assets == PTR_FOLLOWING);
assert(GetZonePointerType(assetList.assets) == ZonePointerType::FOLLOWING);
assetList.assets = m_stream.Alloc<XAsset>(alignof(XAsset));
varXAsset = assetList.assets;

19
src/ZoneLoading/Game/T6/ZoneLoaderFactoryT6.cpp
View File

@ -93,14 +93,14 @@ namespace
{
#define XBLOCK_DEF(name, type) std::make_unique<XBlock>(STR(name), name, type)
zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_TEMP, XBlock::Type::BLOCK_TYPE_TEMP));
zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_RUNTIME_VIRTUAL, XBlock::Type::BLOCK_TYPE_RUNTIME));
zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_RUNTIME_PHYSICAL, XBlock::Type::BLOCK_TYPE_RUNTIME));
zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_DELAY_VIRTUAL, XBlock::Type::BLOCK_TYPE_DELAY));
zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_DELAY_PHYSICAL, XBlock::Type::BLOCK_TYPE_DELAY));
zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_VIRTUAL, XBlock::Type::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_PHYSICAL, XBlock::Type::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_STREAMER_RESERVE, XBlock::Type::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_RUNTIME_VIRTUAL, XBlockType::BLOCK_TYPE_RUNTIME));
zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_RUNTIME_PHYSICAL, XBlockType::BLOCK_TYPE_RUNTIME));
zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_DELAY_VIRTUAL, XBlockType::BLOCK_TYPE_DELAY));
zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_DELAY_PHYSICAL, XBlockType::BLOCK_TYPE_DELAY));
zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_STREAMER_RESERVE, XBlockType::BLOCK_TYPE_NORMAL));
#undef XBLOCK_DEF
}
@ -210,7 +210,8 @@ std::unique_ptr<ZoneLoader> ZoneLoaderFactory::CreateLoaderForHeader(ZoneHeader&
},
32u,
ZoneConstants::OFFSET_BLOCK_BIT_COUNT,
ZoneConstants::INSERT_BLOCK));
ZoneConstants::INSERT_BLOCK,
zonePtr->Memory()));
if (isSecure)
{

32
src/ZoneLoading/Loading/ContentLoaderBase.cpp
View File

@ -1,15 +1,22 @@
#include "ContentLoaderBase.h"
#include <cassert>
const void* ContentLoaderBase::PTR_FOLLOWING = reinterpret_cast<void*>(-1);
const void* ContentLoaderBase::PTR_INSERT = reinterpret_cast<void*>(-2);
#include <cstdint>
#include <limits>
ContentLoaderBase::ContentLoaderBase(Zone& zone, ZoneInputStream& stream)
: varXString(nullptr),
m_zone(zone),
m_memory(zone.Memory()),
m_stream(stream)
m_stream(stream),
// -1
m_zone_ptr_following(
reinterpret_cast<const void*>(std::numeric_limits<std::uintptr_t>::max() >> ((sizeof(std::uintptr_t) * 8u) - stream.GetPointerBitCount()))),
// -2
m_zone_ptr_insert(
reinterpret_cast<const void*>((std::numeric_limits<std::uintptr_t>::max() >> ((sizeof(std::uintptr_t) * 8u) - stream.GetPointerBitCount())) - 1u))
{
}
@ -22,9 +29,9 @@ void ContentLoaderBase::LoadXString(const bool atStreamStart) const
if (*varXString != nullptr)
{
if (*varXString == PTR_FOLLOWING)
if (GetZonePointerType(varXString) == ZonePointerType::FOLLOWING)
{
*varXString = m_stream.Alloc<const char>(alignof(const char));
*varXString = m_stream.Alloc<const char>(1);
m_stream.LoadNullTerminated(const_cast<char*>(*varXString));
}
else
@ -39,7 +46,10 @@ void ContentLoaderBase::LoadXStringArray(const bool atStreamStart, const size_t
assert(varXString != nullptr);
if (atStreamStart)
{
m_stream.LoadWithFill(4u * count);
m_stream.Load<const char*>(varXString, count);
}
for (size_t index = 0; index < count; index++)
{
@ -47,3 +57,13 @@ void ContentLoaderBase::LoadXStringArray(const bool atStreamStart, const size_t
varXString++;
}
}
ZonePointerType ContentLoaderBase::GetZonePointerType(const void* zonePtr) const
{
if (zonePtr == m_zone_ptr_following)
return ZonePointerType::FOLLOWING;
if (zonePtr == m_zone_ptr_insert)
return ZonePointerType::INSERT;
return ZonePointerType::OFFSET;
}

24
src/ZoneLoading/Loading/ContentLoaderBase.h
View File

@ -3,12 +3,17 @@
#include "Zone/Stream/ZoneInputStream.h"
#include "Zone/Zone.h"
#include <cstdint>
enum class ZonePointerType : std::uint8_t
{
FOLLOWING,
INSERT,
OFFSET
};
class ContentLoaderBase
{
protected:
static const void* PTR_FOLLOWING;
static const void* PTR_INSERT;
public:
virtual ~ContentLoaderBase() = default;
ContentLoaderBase(const ContentLoaderBase& other) = default;
@ -22,9 +27,20 @@ protected:
void LoadXString(bool atStreamStart) const;
void LoadXStringArray(bool atStreamStart, size_t count);
[[nodiscard]] ZonePointerType GetZonePointerType(const void* zonePtr) const;
template<typename T> [[nodiscard]] ZonePointerType GetZonePointerType(T* zonePtr) const
{
return GetZonePointerType(reinterpret_cast<const void*>(zonePtr));
}
const char** varXString;
Zone& m_zone;
MemoryManager& m_memory;
ZoneInputStream& m_stream;
private:
const void* m_zone_ptr_following;
const void* m_zone_ptr_insert;
};

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

@ -4,7 +4,7 @@
namespace
{
constexpr uint64_t MAX_XBLOCK_SIZE = 0x3C000000;
constexpr uint64_t MAX_XBLOCK_SIZE = 0x3C000000; // ~1GB
class StepAllocXBlocks final : public ILoadingStep
{

15
src/ZoneLoading/Loading/Steps/StepLoadZoneContent.cpp
View File

@ -10,17 +10,20 @@ namespace
StepLoadZoneContent(std::function<std::unique_ptr<IContentLoadingEntryPoint>(ZoneInputStream&)> entryPointFactory,
const unsigned pointerBitCount,
const unsigned offsetBlockBitCount,
const block_t insertBlock)
const block_t insertBlock,
MemoryManager& memory)
: m_entry_point_factory(std::move(entryPointFactory)),
m_pointer_bit_count(pointerBitCount),
m_offset_block_bit_count(offsetBlockBitCount),
m_insert_block(insertBlock)
m_insert_block(insertBlock),
m_memory(memory)
{
}
void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override
{
const auto inputStream = ZoneInputStream::Create(m_pointer_bit_count, m_offset_block_bit_count, zoneLoader.m_blocks, m_insert_block, stream);
const auto inputStream =
ZoneInputStream::Create(m_pointer_bit_count, m_offset_block_bit_count, zoneLoader.m_blocks, m_insert_block, stream, m_memory);
const auto entryPoint = m_entry_point_factory(*inputStream);
assert(entryPoint);
@ -33,6 +36,7 @@ namespace
unsigned m_pointer_bit_count;
unsigned m_offset_block_bit_count;
block_t m_insert_block;
MemoryManager& m_memory;
};
} // namespace
@ -41,8 +45,9 @@ namespace step
std::unique_ptr<ILoadingStep> CreateStepLoadZoneContent(std::function<std::unique_ptr<IContentLoadingEntryPoint>(ZoneInputStream&)> entryPointFactory,
const unsigned pointerBitCount,
const unsigned offsetBlockBitCount,
const block_t insertBlock)
const block_t insertBlock,
MemoryManager& memory)
{
return std::make_unique<StepLoadZoneContent>(std::move(entryPointFactory), pointerBitCount, offsetBlockBitCount, insertBlock);
return std::make_unique<StepLoadZoneContent>(std::move(entryPointFactory), pointerBitCount, offsetBlockBitCount, insertBlock, memory);
}
} // namespace step

3
src/ZoneLoading/Loading/Steps/StepLoadZoneContent.h
View File

@ -12,5 +12,6 @@ namespace step
std::unique_ptr<ILoadingStep> CreateStepLoadZoneContent(std::function<std::unique_ptr<IContentLoadingEntryPoint>(ZoneInputStream&)> entryPointFactory,
unsigned pointerBitCount,
unsigned offsetBlockBitCount,
block_t insertBlock);
block_t insertBlock,
MemoryManager& memory);
}

71
src/ZoneLoading/Zone/Stream/ZoneInputStream.cpp
View File

@ -28,10 +28,15 @@ namespace
class XBlockInputStream final : public ZoneInputStream
{
public:
XBlockInputStream(
const unsigned pointerBitCount, const unsigned blockBitCount, std::vector<XBlock*>& blocks, const block_t insertBlock, ILoadingStream& stream)
XBlockInputStream(const unsigned pointerBitCount,
const unsigned blockBitCount,
std::vector<XBlock*>& blocks,
const block_t insertBlock,
ILoadingStream& stream,
MemoryManager& memory)
: m_blocks(blocks),
m_stream(stream),
m_memory(memory),
m_pointer_byte_count(pointerBitCount / 8u),
m_block_bit_count(blockBitCount)
{
@ -45,6 +50,11 @@ namespace
m_insert_block = blocks[insertBlock];
}
[[nodiscard]] unsigned GetPointerBitCount() const override
{
return m_pointer_byte_count * 8u;
}
void PushBlock(const block_t block) override
{
assert(block < static_cast<block_t>(m_blocks.size()));
@ -54,7 +64,7 @@ namespace
m_block_stack.push(newBlock);
if (newBlock->m_type == XBlock::Type::BLOCK_TYPE_TEMP)
if (newBlock->m_type == XBlockType::BLOCK_TYPE_TEMP)
m_temp_offsets.push(m_block_offsets[newBlock->m_index]);
}
@ -70,7 +80,7 @@ namespace
m_block_stack.pop();
// If the temp block is not used anymore right now, reset it to the buffer start since as the name suggests, the data inside is temporary.
if (poppedBlock->m_type == XBlock::Type::BLOCK_TYPE_TEMP)
if (poppedBlock->m_type == XBlockType::BLOCK_TYPE_TEMP)
{
m_block_offsets[poppedBlock->m_index] = m_temp_offsets.top();
m_temp_offsets.pop();
@ -96,6 +106,23 @@ namespace
return &block->m_buffer[m_block_offsets[block->m_index]];
}
void* AllocOutOfBlock(const unsigned align, const size_t size) override
{
assert(!m_block_stack.empty());
if (m_block_stack.empty())
return nullptr;
auto* block = m_block_stack.top();
Align(align);
if (m_block_offsets[block->m_index] > block->m_buffer_size)
throw BlockOverflowException(block);
return m_memory.AllocRaw(size);
}
void LoadDataRaw(void* dst, const size_t size) override
{
m_stream.Load(dst, size);
@ -108,10 +135,10 @@ namespace
{
auto* block = m_block_stack.top();
if (block->m_buffer > dst || block->m_buffer + block->m_buffer_size < dst)
if (block->m_buffer.get() > dst || block->m_buffer.get() + block->m_buffer_size < dst)
throw OutOfBlockBoundsException(block);
if (static_cast<uint8_t*>(dst) + size > block->m_buffer + block->m_buffer_size)
if (static_cast<uint8_t*>(dst) + size > block->m_buffer.get() + block->m_buffer_size)
throw BlockOverflowException(block);
// Theoretically ptr should always be at the current block offset.
@ -119,16 +146,16 @@ namespace
switch (block->m_type)
{
case XBlock::Type::BLOCK_TYPE_TEMP:
case XBlock::Type::BLOCK_TYPE_NORMAL:
case XBlockType::BLOCK_TYPE_TEMP:
case XBlockType::BLOCK_TYPE_NORMAL:
m_stream.Load(dst, size);
break;
case XBlock::Type::BLOCK_TYPE_RUNTIME:
case XBlockType::BLOCK_TYPE_RUNTIME:
std::memset(dst, 0, size);
break;
case XBlock::Type::BLOCK_TYPE_DELAY:
case XBlockType::BLOCK_TYPE_DELAY:
assert(false);
break;
}
@ -150,14 +177,14 @@ namespace
auto* block = m_block_stack.top();
if (block->m_buffer > dst || block->m_buffer + block->m_buffer_size < dst)
if (block->m_buffer.get() > dst || block->m_buffer.get() + block->m_buffer_size < dst)
throw OutOfBlockBoundsException(block);
// Theoretically ptr should always be at the current block offset.
assert(dst == &block->m_buffer[m_block_offsets[block->m_index]]);
uint8_t byte;
auto offset = static_cast<size_t>(static_cast<uint8_t*>(dst) - block->m_buffer);
auto offset = static_cast<size_t>(static_cast<uint8_t*>(dst) - block->m_buffer.get());
do
{
if (offset >= block->m_buffer_size)
@ -181,16 +208,16 @@ namespace
const auto* block = m_block_stack.top();
switch (block->m_type)
{
case XBlock::Type::BLOCK_TYPE_TEMP:
case XBlock::Type::BLOCK_TYPE_NORMAL:
case XBlockType::BLOCK_TYPE_TEMP:
case XBlockType::BLOCK_TYPE_NORMAL:
m_stream.Load(dst, size);
break;
case XBlock::Type::BLOCK_TYPE_RUNTIME:
case XBlockType::BLOCK_TYPE_RUNTIME:
std::memset(dst, 0, size);
break;
case XBlock::Type::BLOCK_TYPE_DELAY:
case XBlockType::BLOCK_TYPE_DELAY:
assert(false);
break;
}
@ -293,6 +320,8 @@ namespace
std::stack<size_t> m_temp_offsets;
ILoadingStream& m_stream;
MemoryManager& m_memory;
unsigned m_pointer_byte_count;
unsigned m_block_bit_count;
XBlock* m_insert_block;
@ -301,8 +330,12 @@ namespace
};
} // namespace
std::unique_ptr<ZoneInputStream> ZoneInputStream::Create(
const unsigned pointerBitCount, const unsigned blockBitCount, std::vector<XBlock*>& blocks, const block_t insertBlock, ILoadingStream& stream)
std::unique_ptr<ZoneInputStream> ZoneInputStream::Create(const unsigned pointerBitCount,
const unsigned blockBitCount,
std::vector<XBlock*>& blocks,
const block_t insertBlock,
ILoadingStream& stream,
MemoryManager& memory)
{
return std::make_unique<XBlockInputStream>(pointerBitCount, blockBitCount, blocks, insertBlock, stream);
return std::make_unique<XBlockInputStream>(pointerBitCount, blockBitCount, blocks, insertBlock, stream, memory);
}

21
src/ZoneLoading/Zone/Stream/ZoneInputStream.h
View File

@ -1,10 +1,12 @@
#pragma once
#include "Loading/ILoadingStream.h"
#include "Utils/MemoryManager.h"
#include "Zone/Stream/IZoneStream.h"
#include "Zone/XBlock.h"
#include <cassert>
#include <cstring>
#include <memory>
#include <vector>
@ -47,6 +49,11 @@ private:
class ZoneInputStream : public IZoneStream
{
public:
/**
* \brief Returns the configured bits that make up a pointer.
*/
[[nodiscard]] virtual unsigned GetPointerBitCount() const = 0;
/**
* \brief Retrieves the new read position in the current block by aligning the position with the specified value and then returning the current read
* position in the block.
@ -64,6 +71,16 @@ public:
return static_cast<T*>(Alloc(align));
}
virtual void* AllocOutOfBlock(unsigned align, size_t size) = 0;
/**
* \copydoc ZoneInputStream#AllocOutOfBlock(unsigned)
*/
template<typename T> T* AllocOutOfBlock(const unsigned align, const size_t arraySize = 1u)
{
return static_cast<T*>(AllocOutOfBlock(align, sizeof(T) * arraySize));
}
/**
* \brief Loads data from the underlying stream without considering the current block or advancing the block position.
* The data is read directly to the specified location instead of block memory.
@ -120,6 +137,6 @@ public:
return static_cast<T*>(ConvertOffsetToAliasNative(static_cast<const void*>(offset)));
}
static std::unique_ptr<ZoneInputStream>
Create(unsigned pointerBitCount, unsigned blockBitCount, std::vector<XBlock*>& blocks, block_t insertBlock, ILoadingStream& stream);
static std::unique_ptr<ZoneInputStream> Create(
unsigned pointerBitCount, unsigned blockBitCount, std::vector<XBlock*>& blocks, block_t insertBlock, ILoadingStream& stream, MemoryManager& memory);
};

18
src/ZoneWriting/Game/IW3/ZoneWriterFactoryIW3.cpp
View File

@ -22,15 +22,15 @@ namespace
{
#define XBLOCK_DEF(name, type) std::make_unique<XBlock>(STR(name), name, type)
writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_TEMP, XBlock::Type::BLOCK_TYPE_TEMP));
writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_LARGE_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_PHYSICAL_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_VIRTUAL, XBlock::Type::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_LARGE, XBlock::Type::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_PHYSICAL, XBlock::Type::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_VERTEX, XBlock::Type::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_INDEX, XBlock::Type::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_LARGE_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_PHYSICAL_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_LARGE, XBlockType::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_VERTEX, XBlockType::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_INDEX, XBlockType::BLOCK_TYPE_NORMAL));
#undef XBLOCK_DEF
}

16
src/ZoneWriting/Game/IW4/ZoneWriterFactoryIW4.cpp
View File

@ -24,14 +24,14 @@ namespace
{
#define XBLOCK_DEF(name, type) std::make_unique<XBlock>(STR(name), name, type)
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_TEMP, XBlock::Type::BLOCK_TYPE_TEMP));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_PHYSICAL, XBlock::Type::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_VIRTUAL, XBlock::Type::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_LARGE, XBlock::Type::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_CALLBACK, XBlock::Type::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_VERTEX, XBlock::Type::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_INDEX, XBlock::Type::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_LARGE, XBlockType::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_CALLBACK, XBlockType::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_VERTEX, XBlockType::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_INDEX, XBlockType::BLOCK_TYPE_NORMAL));
#undef XBLOCK_DEF
}

18
src/ZoneWriting/Game/IW5/ZoneWriterFactoryIW5.cpp
View File

@ -24,15 +24,15 @@ namespace
{
#define XBLOCK_DEF(name, type) std::make_unique<XBlock>(STR(name), name, type)
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_TEMP, XBlock::Type::BLOCK_TYPE_TEMP));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_PHYSICAL, XBlock::Type::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_VIRTUAL, XBlock::Type::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_LARGE, XBlock::Type::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_CALLBACK, XBlock::Type::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_VERTEX, XBlock::Type::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_INDEX, XBlock::Type::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_SCRIPT, XBlock::Type::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_LARGE, XBlockType::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_CALLBACK, XBlockType::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_VERTEX, XBlockType::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_INDEX, XBlockType::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_SCRIPT, XBlockType::BLOCK_TYPE_NORMAL));
#undef XBLOCK_DEF
}

14
src/ZoneWriting/Game/T5/ZoneWriterFactoryT5.cpp
View File

@ -22,13 +22,13 @@ namespace
{
#define XBLOCK_DEF(name, type) std::make_unique<XBlock>(STR(name), name, type)
writer.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_TEMP, XBlock::Type::BLOCK_TYPE_TEMP));
writer.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
writer.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_LARGE_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
writer.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_PHYSICAL_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
writer.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_VIRTUAL, XBlock::Type::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_LARGE, XBlock::Type::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_PHYSICAL, XBlock::Type::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
writer.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
writer.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_LARGE_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
writer.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_PHYSICAL_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
writer.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_LARGE, XBlockType::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
#undef XBLOCK_DEF
}

16
src/ZoneWriting/Game/T6/ZoneWriterFactoryT6.cpp
View File

@ -29,14 +29,14 @@ namespace
{
#define XBLOCK_DEF(name, type) std::make_unique<XBlock>(STR(name), name, type)
writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_TEMP, XBlock::Type::BLOCK_TYPE_TEMP));
writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_RUNTIME_VIRTUAL, XBlock::Type::BLOCK_TYPE_RUNTIME));
writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_RUNTIME_PHYSICAL, XBlock::Type::BLOCK_TYPE_RUNTIME));
writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_DELAY_VIRTUAL, XBlock::Type::BLOCK_TYPE_DELAY));
writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_DELAY_PHYSICAL, XBlock::Type::BLOCK_TYPE_DELAY));
writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_VIRTUAL, XBlock::Type::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_PHYSICAL, XBlock::Type::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_STREAMER_RESERVE, XBlock::Type::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_RUNTIME_VIRTUAL, XBlockType::BLOCK_TYPE_RUNTIME));
writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_RUNTIME_PHYSICAL, XBlockType::BLOCK_TYPE_RUNTIME));
writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_DELAY_VIRTUAL, XBlockType::BLOCK_TYPE_DELAY));
writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_DELAY_PHYSICAL, XBlockType::BLOCK_TYPE_DELAY));
writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_STREAMER_RESERVE, XBlockType::BLOCK_TYPE_NORMAL));
#undef XBLOCK_DEF
}

22
src/ZoneWriting/Zone/Stream/Impl/InMemoryZoneOutputStream.cpp
View File

@ -30,7 +30,7 @@ void InMemoryZoneOutputStream::PushBlock(const block_t block)
m_block_stack.push(newBlock);
if (newBlock->m_type == XBlock::Type::BLOCK_TYPE_TEMP)
if (newBlock->m_type == XBlockType::BLOCK_TYPE_TEMP)
{
if (m_temp_sizes.empty())
m_temp_sizes.push(0);
@ -50,7 +50,7 @@ block_t InMemoryZoneOutputStream::PopBlock()
m_block_stack.pop();
// If temp block is popped, see if its size is bigger than the current maximum temp size
if (poppedBlock->m_type == XBlock::Type::BLOCK_TYPE_TEMP)
if (poppedBlock->m_type == XBlockType::BLOCK_TYPE_TEMP)
{
const auto tempSize = m_temp_sizes.top();
m_temp_sizes.pop();
@ -70,7 +70,7 @@ void InMemoryZoneOutputStream::Align(const int align)
{
auto* block = m_block_stack.top();
if (block->m_type == XBlock::Type::BLOCK_TYPE_TEMP)
if (block->m_type == XBlockType::BLOCK_TYPE_TEMP)
m_temp_sizes.top() = (m_temp_sizes.top() + align - 1) / align * align;
else
block->m_buffer_size = (block->m_buffer_size + align - 1) / align * align;
@ -96,16 +96,16 @@ void* InMemoryZoneOutputStream::WriteDataInBlock(const void* src, const size_t s
void* result = nullptr;
switch (block->m_type)
{
case XBlock::Type::BLOCK_TYPE_TEMP:
case XBlock::Type::BLOCK_TYPE_NORMAL:
case XBlockType::BLOCK_TYPE_TEMP:
case XBlockType::BLOCK_TYPE_NORMAL:
result = m_zone_data->GetBufferOfSize(size);
memcpy(result, src, size);
break;
case XBlock::Type::BLOCK_TYPE_RUNTIME:
case XBlockType::BLOCK_TYPE_RUNTIME:
break;
case XBlock::Type::BLOCK_TYPE_DELAY:
case XBlockType::BLOCK_TYPE_DELAY:
assert(false);
break;
}
@ -122,7 +122,7 @@ void InMemoryZoneOutputStream::IncBlockPos(const size_t size)
return;
auto* block = m_block_stack.top();
if (block->m_type == XBlock::Type::BLOCK_TYPE_TEMP)
if (block->m_type == XBlockType::BLOCK_TYPE_TEMP)
{
m_temp_sizes.top() += size;
}
@ -141,7 +141,7 @@ void InMemoryZoneOutputStream::WriteNullTerminated(const void* src)
uintptr_t InMemoryZoneOutputStream::GetCurrentZonePointer()
{
assert(!m_block_stack.empty());
assert(m_block_stack.top()->m_type == XBlock::Type::BLOCK_TYPE_NORMAL);
assert(m_block_stack.top()->m_type == XBlockType::BLOCK_TYPE_NORMAL);
uintptr_t ptr = 0;
ptr |= static_cast<uintptr_t>(m_block_stack.top()->m_index) << (sizeof(uintptr_t) * 8 - m_block_bit_count);
@ -168,7 +168,7 @@ void InMemoryZoneOutputStream::MarkFollowing(void** pPtr)
{
assert(!m_block_stack.empty());
assert(pPtr != nullptr);
*pPtr = m_block_stack.top()->m_type == XBlock::Type::BLOCK_TYPE_TEMP ? PTR_INSERT : PTR_FOLLOWING;
*pPtr = m_block_stack.top()->m_type == XBlockType::BLOCK_TYPE_TEMP ? PTR_INSERT : PTR_FOLLOWING;
}
bool InMemoryZoneOutputStream::ReusableShouldWrite(void** pPtr, const size_t entrySize, const std::type_index type)
@ -202,7 +202,7 @@ void InMemoryZoneOutputStream::ReusableAddOffset(void* ptr, size_t size, size_t
{
assert(!m_block_stack.empty());
const auto inTemp = m_block_stack.top()->m_type == XBlock::Type::BLOCK_TYPE_TEMP;
const auto inTemp = m_block_stack.top()->m_type == XBlockType::BLOCK_TYPE_TEMP;
auto zoneOffset = inTemp ? InsertPointer() : GetCurrentZonePointer();
const auto foundEntriesForType = m_reusable_entries.find(type);
if (foundEntriesForType == m_reusable_entries.end())