asuro/PuzGame
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

generate type data

Browse Source
This commit is contained in:
Asuro
2025-03-20 20:18:40 +01:00
parent e16c9e0a2f
commit 551796e7ad
19 changed files with 332 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
src/dependency/minidef/src/CppGen.cpp
View File

@@ -15,12 +15,15 @@ namespace WriteTemplates
{
constexpr char FileHeaderStart[] =
R"END(#pragma once
#include "Def.h"
#include <cstdint>
namespace Generated
{
struct Serializer;
struct Deserializer;
)END";
constexpr char FileCppStart[] = R"END(#include "Generated.h"
constexpr char FileCppStart[] = R"END(#include "Def.h"
#include "Generated.h"
namespace Generated
{
@@ -43,8 +46,8 @@ namespace Generated
constexpr char EnumHeader4[] =
R"END( struct %s
{
static constexpr uint32_t Hash = %u;
static constexpr int32_t EntryCount = %u;
static constexpr uint32_t Hash = %u;
enum Enum : %s
{
)END";
@@ -196,8 +199,8 @@ void CppFileWriter::WriteEnums(const Def::DefinitionFile& definitions)
Write(WriteTemplates::EnumHeader4,
e.Name,
e.Hash,
e.EntryCount,
e.Hash,
Generated::KnownType::CName[(int32_t)e.EnumType.Native]);
for (int32_t entryIdx = 0; entryIdx < e.EntryCount; ++entryIdx)
{
@@ -331,3 +334,36 @@ void CppFileWriter::WriteCpp(const char* templateStr, ...)
WriteInternal(CppWrite, templateStr, args);
va_end(args);
}
void CppFileWriter::WriteTypeDataFile(const bx::FilePath& outDir, const Def::DefinitionFile& definitions)
{
constexpr const char _4cc[] = "TDAT";
constexpr uint32_t version = 1;
bx::FilePath typeDataFilePath = outDir;
typeDataFilePath.join("TypeData.bin");
bx::Error err;
bx::FileWriter writer;
if (!writer.open(typeDataFilePath, false, &err))
{
LOG_ERROR(0, "Failed to open type data file to write: %s", err.getMessage().getCPtr());
return;
}
uint32_t size = sizeof(definitions);
writer.write(_4cc, 4, &err);
if (!err.isOk())
{
LOG_ERROR(0, "Failed to write type data: %s", err.getMessage().getCPtr());
writer.close();
return;
}
writer.write(&version, sizeof(version), &err);
writer.write(&size, sizeof(size), &err);
writer.write(&definitions, sizeof(definitions), &err);
if (!err.isOk())
{
LOG_ERROR(0, "Failed to write type data: %s", err.getMessage().getCPtr());
}
writer.close();
return;
}

1
src/dependency/minidef/src/CppGen.h
View File

@@ -29,4 +29,5 @@ struct CppFileWriter
void GenerateCpp(const bx::FilePath& outDir, const Def::DefinitionFile& definitions);
void Write(const char* templateStr, ...);
void WriteCpp(const char* templateStr, ...);
void WriteTypeDataFile(const bx::FilePath& outDir, const Def::DefinitionFile& definitions);
};

41
src/dependency/minidef/src/Gen/Def.cpp Normal file
View File

@@ -0,0 +1,41 @@
#include "Def.h"
#define INST(T) \
template bool Save<T>(const T* obj, uint32_t count, Serializer& serializer); \
template bool Load<T>(T * obj, uint32_t count, Deserializer & serializer);
namespace Generated
{
template <typename T> bool Save(const T* obj, uint32_t count, Serializer& serializer)
{
bool isOk = true;
for (uint32_t i = 0; i < count; ++i)
{
isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
}
return isOk;
}
template <typename T> bool Load(T* obj, uint32_t count, Deserializer& serializer)
{
bool isOk = true;
for (uint32_t i = 0; i < count; ++i)
{
isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
}
return isOk;
}
INST(uint8_t)
INST(uint16_t)
INST(uint32_t)
INST(uint64_t)
INST(int8_t)
INST(int16_t)
INST(int32_t)
INST(int64_t)
INST(float)
INST(double)
INST(bool)
INST(char)
} // namespace Generated

125
src/dependency/minidef/src/Gen/Def.h
View File

@@ -1,2 +1,125 @@
#pragma once
#include <cstdint>
#include "../TypeDef.h"
// #include "../game/Log.h"
#include "bx/string.h"
#include <bx/file.h>
#include <cstdint>
#ifndef LOG_ERROR
#define LOG_ERROR(...)
#endif
namespace Generated
{
struct EmbeddedTypeDef
{
uint32_t Size = sizeof(Def::DefinitionFile);
Def::DefinitionFile Data;
};
struct Serializer
{
bx::Error Err;
bx::FilePath Path;
bx::FileWriter Writer;
bool Init(const bx::FilePath& path)
{
Path = path;
Writer.open(path, false, &Err);
return Err.isOk();
}
template <typename T> bool WriteT(const char* _4cc, const T& data)
{
if (!Write(_4cc, 4)) return false;
uint32_t hash = data.Hash;
if (!Write(&hash, sizeof(hash))) return false;
uint32_t size = sizeof(T);
if (!Write(&size, sizeof(size))) return false;
return Save(&data, 1, *this);
}
bool Write(const void* data, uint32_t size)
{
Writer.write(data, size, &Err);
if (!Err.isOk()) LOG_ERROR("Write error: %s", Err.getMessage().getCPtr());
return Err.isOk();
}
void Finish()
{
Writer.close();
}
};
struct Deserializer
{
bx::Error Err;
bx::FilePath Path;
bx::FileReader Reader;
bool Init(const bx::FilePath& path)
{
Path = path;
Reader.open(path, &Err);
return Err.isOk();
}
bool Read(void* data, uint32_t size)
{
Reader.read(data, size, &Err);
if (!Err.isOk()) LOG_ERROR("Read error: %s", Err.getMessage().getCPtr());
return Err.isOk();
}
template <typename T> bool ReadT(const char* _4cc, T& data)
{
char magic[5]{0};
if (!Read(magic, 4)) return false;
bx::StringView given{_4cc, 4};
bx::StringView loaded{magic, 4};
if (bx::strCmp(given, loaded) != 0)
{
LOG_ERROR("Magic mismatch! %s != %s", _4cc, magic);
return false;
}
uint32_t hash = 0;
if (!Read(&hash, sizeof(hash))) return false;
if (data.Hash != hash)
{
LOG_ERROR("Hash mismatch! %u != %u", data.Hash, hash);
return false;
}
uint32_t size = 0;
if (!Read(&size, sizeof(size))) return false;
if (sizeof(T) != size)
{
LOG_ERROR("Size mismatch! %u != %u", sizeof(T), size);
return false;
}
if (!Load(&data, 1, *this))
{
LOG_ERROR("Failed to load: %s", Err.getMessage().getCPtr());
return false;
}
return true;
}
void Finish()
{
Reader.close();
}
};
template <typename T> bool Save(const T* obj, uint32_t count, Serializer& serializer);
template <typename T> bool Load(T* obj, uint32_t count, Deserializer& serializer);
} // namespace Generated

68
src/dependency/minidef/src/Gen/Generated.cpp Normal file
View File

@@ -0,0 +1,68 @@
#include "Def.h"
#include "Generated.h"
namespace Generated
{
bool Save(const KnownType::Enum* obj, uint32_t count, Serializer& serializer)
{
bool isOk = true;
for (uint32_t i = 0; i < count; ++i)
{
auto val = (int32_t)obj[i];
isOk = Save(&val, 1, serializer) && isOk;
}
return isOk;
}
bool Load(KnownType::Enum* obj, uint32_t count, Deserializer& serializer)
{
bool isOk = true;
for (uint32_t i = 0; i < count; ++i)
{
int32_t& val = (int32_t&)obj[i];
isOk = Load(&val, 1, serializer) && isOk;
}
return isOk;
}
bool Save(const Test* obj, uint32_t count, Serializer& serializer)
{
bool isOk = true;
for (uint32_t i = 0; i < count; ++i)
{
isOk = Save(&obj[i].Number, 1, serializer) && isOk;
}
return isOk;
}
bool Load(Test* obj, uint32_t count, Deserializer& serializer)
{
bool isOk = true;
for (uint32_t i = 0; i < count; ++i)
{
isOk = Load(&obj[i].Number, 1, serializer) && isOk;
}
return isOk;
}
bool Save(const Texture* obj, uint32_t count, Serializer& serializer)
{
bool isOk = true;
for (uint32_t i = 0; i < count; ++i)
{
isOk = Save(&obj[i].Width, 1, serializer) && isOk;
isOk = Save(&obj[i].Height, 1, serializer) && isOk;
isOk = Save(obj[i].StrTest, 3, serializer) && isOk;
isOk = Save(&obj[i].T, 1, serializer) && isOk;
}
return isOk;
}
bool Load(Texture* obj, uint32_t count, Deserializer& serializer)
{
bool isOk = true;
for (uint32_t i = 0; i < count; ++i)
{
isOk = Load(&obj[i].Width, 1, serializer) && isOk;
isOk = Load(&obj[i].Height, 1, serializer) && isOk;
isOk = Load(obj[i].StrTest, 3, serializer) && isOk;
isOk = Load(&obj[i].T, 1, serializer) && isOk;
}
return isOk;
}
}

15
src/dependency/minidef/src/Gen/Generated.h
View File

@@ -1,12 +1,15 @@
#pragma once
#include "Def.h"
#include <cstdint>
namespace Generated
{
struct Serializer;
struct Deserializer;
struct KnownType
{
static constexpr int32_t EntryCount = 12;
enum class Enum : int32_t
static constexpr uint32_t Hash = 2024002654;
enum Enum : int32_t
{
i8,
i16,
@@ -54,13 +57,21 @@ namespace Generated
};
struct Test
{
static constexpr uint32_t Hash = 273256278;
uint32_t Number = {};
};
struct Texture
{
static constexpr uint32_t Hash = 992460010;
uint32_t Width = {};
uint32_t Height = {};
char StrTest[3] = {};
Test T = {};
};
bool Save(const KnownType::Enum* obj, uint32_t count, Serializer& serializer);
bool Load(KnownType::Enum* obj, uint32_t count, Deserializer& serializer);
bool Save(const Test* obj, uint32_t count, Serializer& serializer);
bool Load(Test* obj, uint32_t count, Deserializer& serializer);
bool Save(const Texture* obj, uint32_t count, Serializer& serializer);
bool Load(Texture* obj, uint32_t count, Deserializer& serializer);
}

BIN
src/dependency/minidef/src/Gen/TypeData.bin LFS Normal file
View File

Binary file not shown.

4
src/dependency/minidef/src/MiniDef.cpp
View File

@@ -519,5 +519,9 @@ int main(int argc, const char** argv)
FileParser.CalculateHashes();
Writer.GenerateCpp(outPath, FileParser.Definitions);
LOG(0, "Writing type data file");
Writer.WriteTypeDataFile(outPath, FileParser.Definitions);
LOG(0, "Finished writing type data file!");
return 0;
}