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

1
.gitattributes vendored
View File

@@ -6,3 +6,4 @@
*.blend filter=lfs diff=lfs merge=lfs -text
*.pzl filter=lfs diff=lfs merge=lfs -text
*.exe filter=lfs diff=lfs merge=lfs -text
*.glb filter=lfs diff=lfs merge=lfs -text

1
src/.gitattributes vendored
View File

@@ -1 +0,0 @@
*.glb filter=lfs diff=lfs merge=lfs -text

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

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

@@ -1,2 +1,125 @@
#pragma once
#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;
}

4
src/game/Level.cpp
View File

@@ -1,9 +1,12 @@
#include "../gen/Def.h"
#include "Global.h"
#include "Input.h"
#include "Instance.h"
#include "Level.h"
#include "Log.h"
#include "Puzzle.h"
#include "rendering/Rendering.h"
#include "SDL3/SDL_mouse.h"
#include "bgfx/bgfx.h"
#include "bx/error.h"
@@ -11,7 +14,6 @@
#include "bx/filepath.h"
#include "bx/string.h"
#include "imgui.h"
#include "rendering/Rendering.h"
#include <SDL3/SDL.h>
#include <bx/math.h>
#include <cstdint>

5
src/game/Puzzle.cpp
View File

@@ -1,3 +1,4 @@
#include "../gen/Def.h"
#include "Global.h"
#include "Instance.h"
#include "Log.h"
@@ -192,10 +193,6 @@ namespace Puzzle
continue;
if (IsValidGoalConnection(puzzle, nextPos, currentPos, goalType))
{
if (nextPos.X == 0 && nextPos.Y == 4)
{
LOG("test");
}
if (IsValidSource(GetNodeAt(puzzle, nextPos), goalType))
{
return true;

16
src/game/Tools.cpp
View File

@@ -1,6 +1,7 @@
#include "Global.h"
#include "Instance.h"
#include "Tools.h"
#include "bx/string.h"
#include "rendering/Rendering.h"
#include <imgui.h>
@@ -20,15 +21,24 @@ namespace Tools
return "---";
}
void ModelDropdown(uint16_t& modelHandle)
void ModelDropdown(uint32_t& modelHandle)
{
auto& R = Game::GameRendering::Get();
const char* name = GetAssetPath(R.Models[modelHandle].AssetHandle);
const char* name = GetAssetPath(modelHandle);
int32_t idx = -1;
for (int32_t i = 0; i < R.ModelCount; ++i)
{
if (R.Models[i].AssetHandle == modelHandle)
{
idx = i;
break;
}
}
if (ImGui::BeginCombo("Models", name))
{
for (int32_t i = 0; i < R.ModelCount; ++i)
{
if (ImGui::Selectable(GetAssetPath(R.Models[i].AssetHandle), i == modelHandle))
if (ImGui::Selectable(GetAssetPath(R.Models[i].AssetHandle), i == idx))
{
modelHandle = i;
}

2
src/game/Tools.h
View File

@@ -3,5 +3,5 @@
namespace Tools
{
void ModelDropdown(uint16_t& modelHandle);
void ModelDropdown(uint32_t& modelHandle);
} // namespace Tools

2
src/game/mini.def
View File

@@ -59,7 +59,7 @@ enum PuzzleElementType(u8)
type StaticPuzzleCard
{
PuzzleElementType Elements Arr(4)
u16 ModelHandle
u32 ModelHandle
}
type StaticPuzzleCardHandle

7
src/gen/Def.h
View File

@@ -1,4 +1,5 @@
#pragma once
#include "../dependency/minidef/src/TypeDef.h"
#include "../game/Log.h"
#include "bx/string.h"
@@ -7,6 +8,12 @@
namespace Generated
{
struct EmbeddedTypeDef
{
uint32_t Size = sizeof(Def::DefinitionFile);
Def::DefinitionFile Data;
};
struct Serializer
{
bx::Error Err;

1
src/gen/Generated.cpp
View File

@@ -1,3 +1,4 @@
#include "Def.h"
#include "Generated.h"
namespace Generated

12
src/gen/Generated.h
View File

@@ -1,12 +1,14 @@
#pragma once
#include "Def.h"
#include <cstdint>
namespace Generated
{
struct Serializer;
struct Deserializer;
struct PuzzleElementType
{
static constexpr uint32_t Hash = 2024002654;
static constexpr int32_t EntryCount = 8;
static constexpr uint32_t Hash = 2024002654;
enum Enum : int32_t
{
None,
@@ -100,9 +102,9 @@ namespace Generated
};
struct StaticPuzzleCard
{
static constexpr uint32_t Hash = 2507139249;
static constexpr uint32_t Hash = 1414289929;
PuzzleElementType::Enum Elements[4] = {};
uint16_t ModelHandle = {};
uint32_t ModelHandle = {};
};
struct StaticPuzzleCardHandle
{
@@ -111,7 +113,7 @@ namespace Generated
};
struct StaticPuzzleData
{
static constexpr uint32_t Hash = 3210954810;
static constexpr uint32_t Hash = 84985581;
StaticPuzzleCard Cards[64] = {};
};
struct PuzzleCardStack

BIN
src/gen/TypeData.bin LFS Normal file
View File

Binary file not shown.