Patedam/Juliet
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Using memory arena in the game that supports hot reload

Browse Source
This commit is contained in:
Patedam
2026-07-28 15:44:41 -04:00
parent 39586c968a
commit 4081539ee4
24 changed files with 219 additions and 217 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Game/Entity/Entity.h
+42 -46
View File
@@ -18,57 +18,53 @@
constexpr Juliet::Class entityKind##entity(#entity, sizeof(#entity) / sizeof(char)); \
const Juliet::Class* entity::Kind = &entityKind##entity;
namespace Game
using DerivedType = void*;
struct Entity final
{
using DerivedType = void*;
EntityID ID;
const Juliet::Class* Kind;
DerivedType Derived;
float X, Y;
};
struct Entity final
{
EntityID ID;
const Juliet::Class* Kind;
DerivedType Derived;
float X, Y;
};
template <typename EntityType>
concept EntityConcept = requires(EntityType entity) {
requires std::same_as<decltype(entity.Kind), const Juliet::Class*>;
requires std::same_as<decltype(entity.Base), Entity*>;
};
template <typename EntityType>
concept EntityConcept = requires(EntityType entity) {
requires std::same_as<decltype(entity.Kind), const Juliet::Class*>;
requires std::same_as<decltype(entity.Base), Entity*>;
};
template <typename EntityType>
requires EntityConcept<EntityType>
bool IsA(const Entity* entity)
{
return entity->Kind == EntityType::Kind;
}
template <typename EntityType>
requires EntityConcept<EntityType>
bool IsA(const Entity* entity)
{
return entity->Kind == EntityType::Kind;
}
template <typename EntityType>
requires EntityConcept<EntityType>
EntityType* MakeEntity(EntityManager& manager, float x, float y)
{
auto* arena = manager.Arena;
EntityType* result = Juliet::ArenaPushStruct<EntityType>(arena);
Entity base;
base.X = x;
base.Y = y;
base.Derived = result;
base.Kind = EntityType::Kind;
manager.Entities.PushBack(base);
template <typename EntityType>
requires EntityConcept<EntityType>
EntityType* MakeEntity(EntityManager& manager, float x, float y)
{
auto* arena = manager.Arena;
EntityType* result = Juliet::ArenaPushStruct<EntityType>(arena);
Entity base;
base.X = x;
base.Y = y;
base.Derived = result;
base.Kind = EntityType::Kind;
manager.Entities.PushBack(base);
result->Base = manager.Entities.Back();
result->Base = manager.Entities.Back();
RegisterEntity(manager, &base);
RegisterEntity(manager, &base);
return result;
}
return result;
}
template <typename EntityType>
requires EntityConcept<EntityType>
EntityType* DownCast(Entity* entity)
{
Assert(IsA<EntityType>(entity));
return static_cast<EntityType*>(entity->Derived);
}
} // namespace Game
template <typename EntityType>
requires EntityConcept<EntityType>
EntityType* DownCast(Entity* entity)
{
Assert(IsA<EntityType>(entity));
return static_cast<EntityType*>(entity->Derived);
}
Game/Entity/EntityManager.cpp
+21 -24
View File
@@ -2,33 +2,30 @@
#include <Entity/Entity.h>
namespace Game
EntityID EntityManager::ID = 0;
void InitEntityManager(Juliet::NonNullPtr<World> world)
{
namespace
{
EntityManager Manager;
}
EntityManager* newManager = Juliet::ArenaPushStruct<EntityManager>(world->WorldArena);
world->EntityManager = newManager;
EntityID EntityManager::ID = 0;
newManager->Entities.Create(world->WorldArena JULIET_DEBUG_PARAM("Entities"));
void InitEntityManager(Juliet::NonNullPtr<Juliet::Arena> arena)
{
Manager.Arena = arena.Get();
Manager.Entities.Create(arena JULIET_DEBUG_PARAM("Entities"));
}
newManager->Arena = Juliet::ArenaAllocate({} JULIET_DEBUG_PARAM("Entity Arena"));
}
void ShutdownEntityManager()
{
Manager.Entities.Destroy();
}
void ShutdownEntityManager()
{
GetEntityManager().Entities.Destroy();
}
EntityManager& GetEntityManager()
{
return Manager;
}
EntityManager& GetEntityManager()
{
Juliet::NonNullPtr entityManager = GetGameState()->World->EntityManager;
return *entityManager;
}
void RegisterEntity(EntityManager& /*manager*/, Entity* entity)
{
entity->ID = EntityManager::ID++;
}
} // namespace Game
void RegisterEntity(EntityManager& /*manager*/, Entity* entity)
{
entity->ID = EntityManager::ID++;
}
Game/Entity/EntityManager.h
+14 -15
View File
@@ -2,23 +2,22 @@
#include <Core/Common/CoreTypes.h>
#include <Core/Container/Vector.h>
#include <game.h>
namespace Game
using EntityID = uint64_t;
struct Entity;
struct EntityManager
{
using EntityID = uint64_t;
static EntityID ID;
struct Entity;
struct EntityManager
{
static EntityID ID;
Juliet::Arena* Arena;
Juliet::Arena* Arena;
// TODO: Should be a pool
Juliet::VectorArena<Entity, 1024> Entities;
};
// TODO: Should be a pool
Juliet::VectorArena<Entity, 1024> Entities;
};
void InitEntityManager(Juliet::NonNullPtr<Juliet::Arena> arena);
void ShutdownEntityManager();
EntityManager& GetEntityManager();
void RegisterEntity(EntityManager& manager, Entity* entity);
} // namespace Game
void InitEntityManager(Juliet::NonNullPtr<World> world);
void ShutdownEntityManager();
EntityManager& GetEntityManager();
void RegisterEntity(EntityManager& manager, Entity* entity);
Game/Game.vcxproj
+1
View File
@@ -84,6 +84,7 @@
<ClCompile Include="game.cpp" />
<ClInclude Include="Entity\Entity.h" />
<ClInclude Include="Entity\EntityManager.h" />
<ClInclude Include="game.h" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
Game/Game.vcxproj.filters
+1
View File
@@ -15,5 +15,6 @@
<ClInclude Include="Entity\EntityManager.h">
<Filter>Entity</Filter>
</ClInclude>
<ClInclude Include="game.h" />
</ItemGroup>
</Project>
Game/game.cpp
+50 -39
View File
@@ -3,6 +3,8 @@
#undef min
#undef max
#include <game.h>
#include <Core/HAL/Filesystem/Filesystem.h>
#include <Core/JulietInit.h>
#include <Core/Logging/LogManager.h>
@@ -10,6 +12,12 @@
#include <Entity/Entity.h>
#include <Entity/EntityManager.h>
GameState* gGameState = nullptr;
GameState* GetGameState()
{
return gGameState;
}
// Test code
namespace Game
{
@@ -26,56 +34,59 @@ namespace Game
int Health;
};
DEFINE_ENTITY(Rock);
} // namespace Game
using namespace Juliet;
extern "C" JULIET_API void GameInit(GameInitParams* params)
{
// Example allocation in GameArena
struct GameState
{
float TotalTime;
int Score;
};
auto* gameState = ArenaPushStruct<GameState>(params->GameArena);
gameState->TotalTime = 0.0f;
gameState->Score = 0;
printf("Game Arena Allocated: %p\n", static_cast<void*>(gameState));
using namespace Game;
// Entity Use case
InitEntityManager(params->GameArena);
auto& manager = GetEntityManager();
Door* door = MakeEntity<Door>(manager, 10.0f, 2.0f);
door->IsOpened = true;
Entity* ent = door->Base;
[[maybe_unused]] Door* stillDoor = DownCast<Door>(ent);
Assert(door == stillDoor);
Rock* rock = MakeEntity<Rock>(manager, 1.f, 2.f);
rock->Health = 100;
Assert(door->Base != rock->Base);
printf("Door is %s\n", door->IsOpened ? "Opened" : "Closed");
printf("Rock has %d health points\n", rock->Health);
}
extern "C" JULIET_API void __cdecl GameShutdown()
{
printf("Shutting down game...\n");
using namespace Juliet;
using namespace Game;
ShutdownEntityManager();
}
extern "C" JULIET_API void __cdecl GameUpdate([[maybe_unused]] float deltaTime)
extern "C" JULIET_API void __cdecl GameUpdate(Juliet::GameData* params, [[maybe_unused]] float deltaTime)
{
using namespace Juliet;
using namespace Game;
gGameState = params->GameState;
if (!gGameState)
{
Arena* gameStateArena = ArenaAllocate({ .ReserveSize = Megabytes(1) } JULIET_DEBUG_PARAM("Game Total Arena"));
auto* gameState = ArenaPushStruct<GameState>(gameStateArena);
gGameState = params->GameState = gameState;
gameState->TotalArena = gameStateArena;
gameState->TotalTime = 0.0f;
gameState->Score = 0;
printf("Game Arena Allocated: %p\n", static_cast<void*>(gameState));
// Bootstrap world
auto* worldArena = ArenaAllocate({ .ReserveSize = Megabytes(1) } JULIET_DEBUG_PARAM("World Arena"));
World* world = ArenaPushStruct<World>(worldArena JULIET_DEBUG_PARAM("World"));
gameState->World = world;
gameState->World->WorldArena = worldArena;
// Entity Use case
InitEntityManager(gameState->World);
auto& manager = GetEntityManager();
Door* door = MakeEntity<Door>(manager, 10.0f, 2.0f);
door->IsOpened = true;
Entity* ent = door->Base;
[[maybe_unused]] Door* stillDoor = DownCast<Door>(ent);
Assert(door == stillDoor);
Rock* rock = MakeEntity<Rock>(manager, 1.f, 2.f);
rock->Health = 100;
Assert(door->Base != rock->Base);
printf("Door is %s\n", door->IsOpened ? "Opened" : "Closed");
printf("Rock has %d health points\n", rock->Health);
}
// printf("Updating game...\n");
}
Game/game.h
+23
View File
@@ -0,0 +1,23 @@
#pragma once
#include <Core/Memory/MemoryArena.h>
struct EntityManager;
struct World
{
Juliet::Arena* WorldArena;
EntityManager* EntityManager;
};
struct GameState
{
Juliet::Arena* TotalArena;
World* World;
float TotalTime;
int Score;
};
extern GameState* GetGameState();