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

working sockets

Browse Source
This commit is contained in:
Asuro
2025-05-11 22:32:50 +02:00
parent 1616704c50
commit 0d91ec1ebb
17 changed files with 252 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
assets/blender/Channels.blend LFS
View File

Binary file not shown.

8
src/game/Gen.cpp
View File

@@ -320,6 +320,14 @@ namespace Gen
return mat;
}
Mat4 RotationFromQuaternion(const Vec4& quaternion)
{
Mat4 mat;
bx::Quaternion quat{quaternion.x, quaternion.y, quaternion.z, quaternion.w};
bx::mtxFromQuaternion(mat.M, quat);
return mat;
}
float Magnitude(const Vec4& vec)
{
return bx::sqrt(vec.x * vec.x + vec.y * vec.y + vec.z * vec.z + vec.w * vec.w);

1
src/game/Gen.h
View File

@@ -75,6 +75,7 @@ namespace Gen
Vec3 EulerFromRotation(const Mat4& rotation);
Mat4 RotationFromEuler(const Vec3& euler);
Mat4 RotationFromQuaternion(const Vec4& quaternion);
float DotProduct(Vec3 a, Vec3 b);
Vec3 CrossProduct(Vec3 a, Vec3 b);

32
src/game/Level.cpp
View File

@@ -113,6 +113,7 @@ namespace Game
needReset |= Cubes.Setup(storagePtr, needReset);
needReset |= Tests.Setup(storagePtr, needReset);
needReset |= PuzzleTiles.Setup(storagePtr, needReset);
needReset |= PuzzleTileCovers.Setup(storagePtr, needReset);
needReset |= UIQuads.Setup(storagePtr, needReset);
needReset |= LevelEntities.Setup(storagePtr, needReset);
@@ -179,6 +180,7 @@ namespace Game
UIQuads.Count = 0;
PuzzleTiles.Count = 0;
PuzzleTileCovers.Count = 0;
for (int32_t i = 0; i < BX_COUNTOF(Puzzles); ++i)
{
if (Puzzles[i].Data.ID != UINT16_MAX)
@@ -324,6 +326,7 @@ namespace Game
Cubes.Render(models, materials, textures);
Tests.Render(models, materials, textures);
PuzzleTiles.Render(models, materials, textures);
PuzzleTileCovers.Render(models, materials, textures);
if (player.InteractionM == InteractionMode::ReadTablet)
{
UIQuads.Render(models, materials, textures);
@@ -358,6 +361,14 @@ namespace Game
auto& tile = level.PuzzleTiles.Get(TileHandles[i]);
tile.EData.MaterialHandle = EMaterial::Default;
for (int32_t j = 0; j < Puzzle::Config::MaxCoversInTile; ++j)
{
int32_t idx = i * Puzzle::Config::MaxCoversInTile + j;
CoverHandles[idx] = level.PuzzleTileCovers.New();
auto& cover = level.PuzzleTileCovers.Get(CoverHandles[idx]);
cover.EData.Visible = false;
}
UIPlacedCards[i] = level.UIQuads.New();
auto& quad = level.UIQuads.Get(UIPlacedCards[i]);
quad.EData.ModelH = GameRendering::Get().GetModelHandleFromPath("models/plane.glb");
@@ -518,11 +529,12 @@ namespace Game
auto& quad = level.UIQuads.Get(UIPlacedCards[cardIdx]);
bool isValid = Puzzle::IsValid(card.RefCard);
auto& staticCard = isValid ? staticCards[card.RefCard.Idx] : staticCards[0];
// World Tile
tile.EData.Visible = IsActive;
tile.EData.ModelH =
isValid ? staticCards[card.RefCard.Idx].BaseModelHandle : staticCards[0].BaseModelHandle;
tile.EData.ModelH = staticCard.BaseModelHandle;
tile.EData.DotColor = visuals.TileDotColor;
tile.EData.BaseColor = visuals.TileBaseColor;
@@ -538,6 +550,22 @@ namespace Game
tile.EData.Transform.Position = cardPos;
bx::mtxRotateY(tile.EData.Transform.Rotation.M, card.Rotation * bx::kPi * 0.5f);
// Covers
if (IsValid(staticCard.BaseModelHandle))
{
auto& model = GameRendering::Get().Models[staticCard.BaseModelHandle.ModelIdx];
for (int32_t i = 0; i < model.SocketCount; ++i)
{
auto& cover =
level.PuzzleTileCovers.Get(CoverHandles[cardIdx * Puzzle::Config::MaxCoversInTile + i]);
cover.EData.Visible = true;
cover.EData.ModelH = staticCard.Sockets[i].Model;
cover.EData.Transform = tile.EData.Transform;
Gen::TranslateLocal(cover.EData.Transform, model.Sockets[i].Pos);
Gen::RotateLocal(cover.EData.Transform, Gen::EulerFromRotation(model.Sockets[i].Rot));
}
}
// UI Quad
quad.EData.Visible = isValid && IsActive;
quad.EData.TextureHandle =

14
src/game/Level.h
View File

@@ -57,6 +57,12 @@ namespace Game
EntityRenderData EData;
};
ENTITY_HANDLE(PuzzleTileCoverHandle);
struct PuzzleTileCover
{
EntityRenderData EData;
};
ENTITY_HANDLE(UIQuadEntityHandle);
struct UIQuadEntity
{
@@ -148,6 +154,7 @@ namespace Game
Gen::PuzzleData Data;
Gen::Vec3 WorldPosition;
PuzzleTileEntityHandle TileHandles[Puzzle::Config::MaxCardsInPuzzle];
PuzzleTileCoverHandle CoverHandles[Puzzle::Config::MaxCardsInPuzzle * Puzzle::Config::MaxCoversInTile];
UIQuadEntityHandle UIPlacedCards[Puzzle::Config::MaxCardsInPuzzle];
UIQuadEntityHandle UIAvailableCards[Puzzle::Config::MaxAvailableStacks * UIAvailableCardMaxStackPreview];
Gen::PuzPos DraggedCard{-1, -1};
@@ -164,8 +171,9 @@ namespace Game
public:
EntityManager<Cube, CubeHandle, 1024> Cubes;
EntityManager<TestEntity, TestEntityHandle, 32> Tests;
EntityManager<PuzzleTileEntity, PuzzleTileEntityHandle, 1024> PuzzleTiles;
EntityManager<UIQuadEntity, UIQuadEntityHandle, 1024> UIQuads;
EntityManager<PuzzleTileEntity, PuzzleTileEntityHandle, Puzzle::Config::MaxTilesTotal> PuzzleTiles;
EntityManager<PuzzleTileCover, PuzzleTileCoverHandle, Puzzle::Config::MaxCoversTotal> PuzzleTileCovers;
EntityManager<UIQuadEntity, UIQuadEntityHandle, Puzzle::Config::MaxTilesInPuzzle * 2> UIQuads;
EntityManager<LevelEntity, LevelEntityHandle, 64> LevelEntities;
CubeHandle PlayerOutsideViewCube;
@@ -173,7 +181,7 @@ namespace Game
public:
Gen::StaticPuzzleData PuzzleData;
WorldPuzzle Puzzles[3];
WorldPuzzle Puzzles[Puzzle::Config::MaxVisiblePuzzles];
public:
void Setup(GameData& data);

34
src/game/Mesh.cpp
View File

@@ -1,3 +1,4 @@
#include "Gen.h"
#include "Global.h"
#include "Log.h"
#include "Mesh.h"
@@ -92,6 +93,39 @@ namespace Game
}
mesh.VertexBuffer = bgfx::createVertexBuffer(vbMem, mesh.VertLayout);
}
for (auto& node : model.nodes)
{
if (bx::strFindI(node.name.c_str(), "_slot_").getLength() > 0)
{
if (mesh.SocketCount >= mesh.MaxSocketCount)
{
LOG_WARN("Too many sockets on mesh!");
break;
}
auto& socket = mesh.Sockets[mesh.SocketCount];
if (node.translation.size() >= 3)
{
socket.Pos.x = node.translation[0];
socket.Pos.y = node.translation[1];
socket.Pos.z = node.translation[2];
}
if (node.rotation.size() >= 4)
{
socket.Rot = Gen::RotationFromQuaternion({static_cast<float>(node.rotation[0]),
static_cast<float>(node.rotation[1]),
static_cast<float>(node.rotation[2]),
static_cast<float>(node.rotation[3])});
}
if (node.matrix.size() >= 0)
{
LOG_WARN("TODO: support matrix!");
}
bx::strCopy(&socket.Name[0], socket.MaxSocketNameLength, node.name.c_str());
++mesh.SocketCount;
}
}
return true;
}

5
src/game/Puzzle.h
View File

@@ -12,16 +12,19 @@ namespace Puzzle
struct Config
{
static constexpr uint32_t MaxVisiblePuzzles = 3;
static constexpr uint32_t CardSize = 2;
static constexpr uint32_t NodesPerCard = CardSize * CardSize;
static constexpr uint32_t MaxElementsPerTile = 4;
static constexpr uint32_t MaxPuzzleSizeCards = 16;
static constexpr uint32_t MaxCardsInPuzzle = MaxPuzzleSizeCards * MaxPuzzleSizeCards;
static constexpr uint32_t MaxPuzzleSizeTiles = 16 * CardSize;
static constexpr uint32_t MaxTilesInPuzzle = MaxPuzzleSizeTiles * MaxPuzzleSizeTiles;
static constexpr uint32_t MaxTilesTotal = MaxTilesInPuzzle * MaxVisiblePuzzles;
static constexpr uint32_t MaxAvailableStacks = 16;
static constexpr uint32_t MaxGoalPositions = 16;
static constexpr float CardScaleWorld = 10.0f;
static constexpr uint32_t MaxCoversInTile = 8;
static constexpr uint32_t MaxCoversTotal = MaxCoversInTile * MaxTilesTotal;
};
void Setup();

17
src/game/Tools.cpp
View File

@@ -421,14 +421,17 @@ namespace Tools
Tools::ModelDropdown(card.BaseModelHandle);
Tools::TextureDropdown(card.BoardTextureHandle);
if (ImGui::TreeNodeEx("Covers"))
if (IsValid(card.BaseModelHandle))
{
Tools::ModelDropdown(card.NorthCoverHandle, "North Cover");
Tools::ModelDropdown(card.EastCoverHandle, "East Cover");
Tools::ModelDropdown(card.SouthCoverHandle, "South Cover");
Tools::ModelDropdown(card.WestCoverHandle, "West Cover");
ImGui::TreePop();
auto& mdl = rendering.Models[card.BaseModelHandle.ModelIdx];
if (mdl.SocketCount > 0 && ImGui::TreeNodeEx("Slots"))
{
for (int32_t sIdx = 0; sIdx < mdl.SocketCount; ++sIdx)
{
Tools::ModelDropdown(card.Sockets[sIdx].Model, mdl.Sockets[sIdx].Name);
}
ImGui::TreePop();
}
}
ImGui::Text("Card");

BIN
src/game/data/puzzles/0.pzl LFS
View File

Binary file not shown.

BIN
src/game/data/static/puzzle.dat
View File

Binary file not shown.

6
src/game/mini.def
View File

@@ -82,6 +82,11 @@ enum PuzzleElementType(u8)
Bridge GameName("Bridge") ShortName("#")
}
type CardSocket
{
ModelHandle Model
}
type StaticPuzzleCard
{
PuzzleElementType Elements Arr(4)
@@ -90,6 +95,7 @@ type StaticPuzzleCard
ModelHandle EastCoverHandle
ModelHandle SouthCoverHandle
ModelHandle WestCoverHandle
CardSocket Sockets Arr(16)
TextureHandle ModelTextureHandle
TextureHandle BoardTextureHandle
}

11
src/game/rendering/Rendering.h
View File

@@ -32,12 +32,23 @@ namespace Game
Gen::TextureHandle TexHandle;
};
struct ModelSocket
{
static constexpr uint16_t MaxSocketNameLength = 64;
Gen::Vec3 Pos;
Gen::Mat4 Rot;
char Name[MaxSocketNameLength]{};
};
struct Model
{
static constexpr uint16_t MaxSocketCount = 16;
bgfx::VertexBufferHandle VertexBuffer = {bgfx::kInvalidHandle};
bgfx::IndexBufferHandle IndexBuffer = {bgfx::kInvalidHandle};
bgfx::VertexLayout VertLayout;
Gen::ModelHandle Handle;
uint16_t SocketCount = 0;
ModelSocket Sockets[MaxSocketCount];
};
struct Material

98
src/gen/Generated.cpp
View File

@@ -1275,6 +1275,92 @@ namespace Gen
assert(isOk);
return isOk;
}
bool Save(const CardSocket* obj, uint32_t count, Serializer& serializer)
{
bool isOk = true;
for (uint32_t i = 0; i < count; ++i)
{
isOk = Save(&obj[i].Model, 1, serializer) && isOk;
}
return isOk;
}
bool Load(CardSocket* obj, uint32_t count, Deserializer& serializer)
{
const char* typeName = Meta::Metadata.TypeDefinitions[CardSocket::TypeIdx].Name;
// Quick match
int32_t matchedHashIdx =
serializer.TypeBuf.FindHash(Meta::Metadata.TypeDefinitions[CardSocket::TypeIdx].Hash);
if (matchedHashIdx >= 0)
{
assert(bx::strCmp(serializer.TypeBuf.Defs[matchedHashIdx].Name, typeName) == 0);
bool isOk = true;
for (uint32_t i = 0; i < count; ++i)
{
isOk = Load(&obj[i].Model, 1, serializer) && isOk;
}
// if we're not ok here, something went really wrong
assert(isOk);
return isOk;
}
// Failed to resolve hash, the type definition chaned since the file was saved! try to match by name.
int32_t nameMatchIdx = serializer.TypeBuf.FindDefByName(typeName);
if (nameMatchIdx < 0)
{
// Name match failed, caller has to handle this and potentially skip some bytes
return false;
}
// Successfully matched name, but we need to follow the definition of the file now!
const Meta::TypeDef& matchedDef = serializer.TypeBuf.Defs[nameMatchIdx];
// Figure out new member mapping
uint64_t WriteDestinations[64];
for (int32_t i = 0; i < BX_COUNTOF(WriteDestinations); ++i)
{
WriteDestinations[i] = UINT64_MAX;
}
for (uint32_t i = 0; i < matchedDef.ChildCount; ++i)
{
const bx::StringView memberName = {&serializer.MemberNameBuf[matchedDef.MemberNameIndices[i].Offset], matchedDef.MemberNameIndices[i].Size};
const char* memberTypeName = serializer.TypeBuf.Defs[matchedDef.ChildIndices[i]].Name;
if (bx::strCmp(memberName, "Model") == 0 && bx::strCmp(memberTypeName, "ModelHandle") == 0)
{
WriteDestinations[i] = offsetof(CardSocket, Model);
}
}
// Start reading in file order, skipping things that we don't know by name and type
bool isOk = true;
for (uint32_t i = 0; i < count; ++i)
{
uint8_t* objBasePtr = reinterpret_cast<uint8_t*>(&obj[i]);
for (uint32_t j = 0; j < matchedDef.ChildCount; ++j)
{
const Meta::TypeDef& childDef = serializer.TypeBuf.Defs[matchedDef.ChildIndices[j]];
const bx::StringView memberName = {&serializer.MemberNameBuf[matchedDef.MemberNameIndices[j].Offset], matchedDef.MemberNameIndices[j].Size};
if (WriteDestinations[j] == UINT64_MAX)
{
// Unknown member name or type changed
uint16_t count = bx::max(1, matchedDef.ChildArraySizes[matchedDef.ChildIndices[j]]);
serializer.Skip(childDef.Size * count);
continue;
}
if (bx::strCmp(memberName, "Model") == 0)
{
auto* fieldPtr = reinterpret_cast<ModelHandle*>(objBasePtr + WriteDestinations[j]);
isOk = Load(fieldPtr, 1, serializer) && isOk;
continue;
}
assert(false);
}
}
assert(isOk);
return isOk;
}
bool Save(const StaticPuzzleCard* obj, uint32_t count, Serializer& serializer)
{
bool isOk = true;
@@ -1286,6 +1372,7 @@ namespace Gen
isOk = Save(&obj[i].EastCoverHandle, 1, serializer) && isOk;
isOk = Save(&obj[i].SouthCoverHandle, 1, serializer) && isOk;
isOk = Save(&obj[i].WestCoverHandle, 1, serializer) && isOk;
isOk = Save(obj[i].Sockets, 16, serializer) && isOk;
isOk = Save(&obj[i].ModelTextureHandle, 1, serializer) && isOk;
isOk = Save(&obj[i].BoardTextureHandle, 1, serializer) && isOk;
}
@@ -1310,6 +1397,7 @@ namespace Gen
isOk = Load(&obj[i].EastCoverHandle, 1, serializer) && isOk;
isOk = Load(&obj[i].SouthCoverHandle, 1, serializer) && isOk;
isOk = Load(&obj[i].WestCoverHandle, 1, serializer) && isOk;
isOk = Load(obj[i].Sockets, 16, serializer) && isOk;
isOk = Load(&obj[i].ModelTextureHandle, 1, serializer) && isOk;
isOk = Load(&obj[i].BoardTextureHandle, 1, serializer) && isOk;
}
@@ -1363,6 +1451,10 @@ namespace Gen
{
WriteDestinations[i] = offsetof(StaticPuzzleCard, WestCoverHandle);
}
if (bx::strCmp(memberName, "Sockets") == 0 && bx::strCmp(memberTypeName, "CardSocket") == 0)
{
WriteDestinations[i] = offsetof(StaticPuzzleCard, Sockets);
}
if (bx::strCmp(memberName, "ModelTextureHandle") == 0 && bx::strCmp(memberTypeName, "TextureHandle") == 0)
{
WriteDestinations[i] = offsetof(StaticPuzzleCard, ModelTextureHandle);
@@ -1427,6 +1519,12 @@ namespace Gen
isOk = Load(fieldPtr, 1, serializer) && isOk;
continue;
}
if (bx::strCmp(memberName, "Sockets") == 0)
{
auto* fieldPtr = reinterpret_cast<CardSocket*>(objBasePtr + WriteDestinations[j]);
isOk = Load(fieldPtr, 16, serializer) && isOk;
continue;
}
if (bx::strCmp(memberName, "ModelTextureHandle") == 0)
{
auto* fieldPtr = reinterpret_cast<TextureHandle*>(objBasePtr + WriteDestinations[j]);

49
src/gen/Generated.h
View File

@@ -7,7 +7,7 @@ namespace Gen
struct Deserializer;
struct PuzzleElementType
{
static constexpr uint16_t TypeIdx = 30;
static constexpr uint16_t TypeIdx = 31;
static constexpr int32_t EntryCount = 8;
enum Enum : uint8_t
{
@@ -56,7 +56,7 @@ namespace Gen
};
struct EMaterial
{
static constexpr uint16_t TypeIdx = 31;
static constexpr uint16_t TypeIdx = 32;
static constexpr int32_t EntryCount = 2;
enum Enum : int32_t
{
@@ -141,26 +141,32 @@ namespace Gen
int8_t X = {};
int8_t Y = {};
};
struct StaticPuzzleCard
struct CardSocket
{
static constexpr uint16_t TypeIdx = 22;
ModelHandle Model = {};
};
struct StaticPuzzleCard
{
static constexpr uint16_t TypeIdx = 23;
PuzzleElementType::Enum Elements[4] = {};
ModelHandle BaseModelHandle = {};
ModelHandle NorthCoverHandle = {};
ModelHandle EastCoverHandle = {};
ModelHandle SouthCoverHandle = {};
ModelHandle WestCoverHandle = {};
CardSocket Sockets[16] = {};
TextureHandle ModelTextureHandle = {};
TextureHandle BoardTextureHandle = {};
};
struct StaticPuzzleCardHandle
{
static constexpr uint16_t TypeIdx = 23;
static constexpr uint16_t TypeIdx = 24;
uint16_t Idx = UINT16_MAX;
};
struct PuzzleVisualSettings
{
static constexpr uint16_t TypeIdx = 24;
static constexpr uint16_t TypeIdx = 25;
Vec4 TileBaseColor = {};
Vec4 TileDotColor = {};
Vec3 Test = {};
@@ -168,20 +174,20 @@ namespace Gen
};
struct StaticPuzzleData
{
static constexpr uint16_t TypeIdx = 25;
static constexpr uint16_t TypeIdx = 26;
StaticPuzzleCard Cards[64] = {};
PuzzleVisualSettings Visuals = {};
};
struct PuzzleCardStack
{
static constexpr uint16_t TypeIdx = 26;
static constexpr uint16_t TypeIdx = 27;
StaticPuzzleCardHandle RefCard = {};
uint8_t MaxAvailableCount = {};
uint8_t UsedCount = {};
};
struct PlacedPuzzleCard
{
static constexpr uint16_t TypeIdx = 27;
static constexpr uint16_t TypeIdx = 28;
StaticPuzzleCardHandle RefCard = {};
PuzPos Position = {};
uint8_t Rotation = {};
@@ -189,7 +195,7 @@ namespace Gen
};
struct PuzzleData
{
static constexpr uint16_t TypeIdx = 28;
static constexpr uint16_t TypeIdx = 29;
uint16_t ID = {};
char PuzzleName[64] = {};
uint8_t WidthTiles = {};
@@ -203,7 +209,7 @@ namespace Gen
};
struct SavedEntityRenderData
{
static constexpr uint16_t TypeIdx = 29;
static constexpr uint16_t TypeIdx = 30;
Vec4 BaseColor = {};
Vec4 HighlightColor = {};
Transform TF = {};
@@ -260,6 +266,8 @@ namespace Gen
bool Load(TextureHandle* obj, uint32_t count, Deserializer& serializer);
bool Save(const PuzPos* obj, uint32_t count, Serializer& serializer);
bool Load(PuzPos* obj, uint32_t count, Deserializer& serializer);
bool Save(const CardSocket* obj, uint32_t count, Serializer& serializer);
bool Load(CardSocket* obj, uint32_t count, Deserializer& serializer);
bool Save(const StaticPuzzleCard* obj, uint32_t count, Serializer& serializer);
bool Load(StaticPuzzleCard* obj, uint32_t count, Deserializer& serializer);
bool Save(const StaticPuzzleCardHandle* obj, uint32_t count, Serializer& serializer);
@@ -299,7 +307,7 @@ namespace Gen
struct MetadataTable
{
TypeDef TypeDefinitions[32]
TypeDef TypeDefinitions[33]
{
TypeDef{sizeof(int8_t), 0, "i8", 0, {}, {}, {}},
TypeDef{sizeof(int16_t), 1, "i16", 0, {}, {}, {}},
@@ -323,18 +331,19 @@ namespace Gen
TypeDef{sizeof(ModelHandle), 298089627, "ModelHandle", 2, {5, 18}, {0, 0}, {{38, 8}, {46, 5}}},
TypeDef{sizeof(TextureHandle), 1633273761, "TextureHandle", 2, {5, 18}, {0, 0}, {{51, 10}, {61, 5}}},
TypeDef{sizeof(PuzPos), 1834398141, "PuzPos", 2, {0, 0}, {0, 0}, {{66, 1}, {67, 1}}},
TypeDef{sizeof(StaticPuzzleCard), 3247750075, "StaticPuzzleCard", 8, {30, 19, 19, 19, 19, 19, 20, 20}, {4, 0, 0, 0, 0, 0, 0, 0}, {{68, 8}, {76, 15}, {91, 16}, {107, 15}, {122, 16}, {138, 15}, {153, 18}, {171, 18}}},
TypeDef{sizeof(StaticPuzzleCardHandle), 1742502768, "StaticPuzzleCardHandle", 1, {5}, {0}, {{189, 3}}},
TypeDef{sizeof(PuzzleVisualSettings), 2302077481, "PuzzleVisualSettings", 4, {14, 14, 13, 14}, {0, 0, 0, 0}, {{192, 13}, {205, 12}, {217, 4}, {221, 16}}},
TypeDef{sizeof(StaticPuzzleData), 2707133860, "StaticPuzzleData", 2, {22, 24}, {64, 0}, {{237, 5}, {242, 7}}},
TypeDef{sizeof(PuzzleCardStack), 53538532, "PuzzleCardStack", 3, {23, 4, 4}, {0, 0, 0}, {{249, 7}, {256, 17}, {273, 9}}},
TypeDef{sizeof(PlacedPuzzleCard), 3555575973, "PlacedPuzzleCard", 4, {23, 21, 4, 8}, {0, 0, 0, 0}, {{282, 7}, {289, 8}, {297, 8}, {305, 8}}},
TypeDef{sizeof(PuzzleData), 3349686056, "PuzzleData", 10, {5, 11, 4, 4, 6, 26, 27, 30, 6, 21}, {0, 64, 0, 0, 0, 16, 256, 1024, 0, 16}, {{313, 2}, {315, 10}, {325, 10}, {335, 11}, {346, 18}, {364, 14}, {378, 11}, {389, 15}, {404, 17}, {421, 13}}},
TypeDef{sizeof(SavedEntityRenderData), 3172756855, "SavedEntityRenderData", 7, {14, 14, 17, 31, 20, 19, 8}, {0, 0, 0, 0, 0, 0, 0}, {{434, 9}, {443, 14}, {457, 2}, {459, 8}, {467, 7}, {474, 5}, {479, 7}}},
TypeDef{sizeof(CardSocket), 3485485756, "CardSocket", 1, {19}, {0}, {{68, 5}}},
TypeDef{sizeof(StaticPuzzleCard), 1947091475, "StaticPuzzleCard", 9, {31, 19, 19, 19, 19, 19, 22, 20, 20}, {4, 0, 0, 0, 0, 0, 16, 0, 0}, {{73, 8}, {81, 15}, {96, 16}, {112, 15}, {127, 16}, {143, 15}, {158, 7}, {165, 18}, {183, 18}}},
TypeDef{sizeof(StaticPuzzleCardHandle), 1742502768, "StaticPuzzleCardHandle", 1, {5}, {0}, {{201, 3}}},
TypeDef{sizeof(PuzzleVisualSettings), 2302077481, "PuzzleVisualSettings", 4, {14, 14, 13, 14}, {0, 0, 0, 0}, {{204, 13}, {217, 12}, {229, 4}, {233, 16}}},
TypeDef{sizeof(StaticPuzzleData), 19690459, "StaticPuzzleData", 2, {23, 25}, {64, 0}, {{249, 5}, {254, 7}}},
TypeDef{sizeof(PuzzleCardStack), 53538532, "PuzzleCardStack", 3, {24, 4, 4}, {0, 0, 0}, {{261, 7}, {268, 17}, {285, 9}}},
TypeDef{sizeof(PlacedPuzzleCard), 3555575973, "PlacedPuzzleCard", 4, {24, 21, 4, 8}, {0, 0, 0, 0}, {{294, 7}, {301, 8}, {309, 8}, {317, 8}}},
TypeDef{sizeof(PuzzleData), 3349686056, "PuzzleData", 10, {5, 11, 4, 4, 6, 27, 28, 31, 6, 21}, {0, 64, 0, 0, 0, 16, 256, 1024, 0, 16}, {{325, 2}, {327, 10}, {337, 10}, {347, 11}, {358, 18}, {376, 14}, {390, 11}, {401, 15}, {416, 17}, {433, 13}}},
TypeDef{sizeof(SavedEntityRenderData), 3172756855, "SavedEntityRenderData", 7, {14, 14, 17, 32, 20, 19, 8}, {0, 0, 0, 0, 0, 0, 0}, {{446, 9}, {455, 14}, {469, 2}, {471, 8}, {479, 7}, {486, 5}, {491, 7}}},
TypeDef{sizeof(PuzzleElementType::Enum), 2983807453, "PuzzleElementType", 0, {}, {}, {}},
TypeDef{sizeof(EMaterial::Enum), 2024002654, "EMaterial", 0, {}, {}, {}},
};
char MemberNameBuffer[64*64*64]{"xyxyzxyzwMMMMIPositionRotationScaleIdxModelIdxAssetTextureIdxAssetXYElementsBaseModelHandleNorthCoverHandleEastCoverHandleSouthCoverHandleWestCoverHandleModelTextureHandleBoardTextureHandleIdxTileBaseColorTileDotColorTestDisabledCardTintCardsVisualsRefCardMaxAvailableCountUsedCountRefCardPositionRotationIsLockedIDPuzzleNameWidthTilesHeightTilesAvailableCardCountAvailableCardsPlacedCardsBackgroundTilesGoalPositionCountGoalPositionsBaseColorHighlightColorTFMaterialTextureModelVisible"};
char MemberNameBuffer[64*64*64]{"xyxyzxyzwMMMMIPositionRotationScaleIdxModelIdxAssetTextureIdxAssetXYModelElementsBaseModelHandleNorthCoverHandleEastCoverHandleSouthCoverHandleWestCoverHandleSocketsModelTextureHandleBoardTextureHandleIdxTileBaseColorTileDotColorTestDisabledCardTintCardsVisualsRefCardMaxAvailableCountUsedCountRefCardPositionRotationIsLockedIDPuzzleNameWidthTilesHeightTilesAvailableCardCountAvailableCardsPlacedCardsBackgroundTilesGoalPositionCountGoalPositionsBaseColorHighlightColorTFMaterialTextureModelVisible"};
};
constexpr MetadataTable Metadata;

BIN
src/models/channel_cover_big.glb LFS
View File

Binary file not shown.

BIN
src/models/channel_cover_small.glb LFS
View File

Binary file not shown.

BIN
src/models/w straight.glb LFS
View File

Binary file not shown.