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

Removing named namespace from code base.

Browse Source
This commit is contained in:
Patedam
2026-08-22 21:39:21 -04:00
parent 678795b793
commit 4180622d6a
158 changed files with 12260 additions and 12648 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Game/Controller/DebugCameraController.cpp
+25 -25
View File
@@ -1,4 +1,4 @@
#include <Controller/DebugCameraController.h>
#include <Controller/DebugCameraController.h>
#include <Controller/ControllerUtils.h>
#include <Core/Common/CoreUtils.h>
@@ -24,10 +24,10 @@ void ActivateDebugController()
{
Assert(gIsDebugCameraActive == false);
Juliet::Camera* currentCam = Juliet::GetCurrentCamera();
Camera* currentCam = GetCurrentCamera();
gPreviousCameraIndex = currentCam->Index;
Juliet::SetCurrentCamera(kDebugCamera);
SetCurrentCamera(kDebugCamera);
gIsDebugCameraActive = true;
gFirstUpdate = true;
@@ -41,7 +41,7 @@ void DeactivateDebugController()
gIsDebugCameraActive = false;
Juliet::SetCurrentCamera(gPreviousCameraIndex);
SetCurrentCamera(gPreviousCameraIndex);
}
bool IsDebugControllerActive()
@@ -51,26 +51,26 @@ bool IsDebugControllerActive()
void UpdateDebugController(float dt)
{
Juliet::Camera* currentCam = Juliet::GetCurrentCamera();
Camera* currentCam = GetCurrentCamera();
if (gFirstUpdate)
{
Juliet::Vector3 dir = Juliet::Vector3{ 0.0f, 0.0f, 0.0f } - currentCam->Position;
dir = Juliet::Normalize(dir);
Vector3 dir = Vector3{ 0.0f, 0.0f, 0.0f } - currentCam->Position;
dir = Normalize(dir);
gPitch = asinf(dir.z);
gYaw = atan2f(dir.y, dir.x);
gFirstUpdate = false;
Juliet::Vector3 forward;
Vector3 forward;
forward.x = cosf(gPitch) * cosf(gYaw);
forward.y = cosf(gPitch) * sinf(gYaw);
forward.z = sinf(gPitch);
Juliet::Vector3 right = Juliet::Normalize(Juliet::Cross(Juliet::Vector3{ 0.0f, 0.0f, 1.0f }, forward));
Vector3 right = Normalize(Cross(Vector3{ 0.0f, 0.0f, 1.0f }, forward));
currentCam->Target = currentCam->Position + forward;
currentCam->Up = Juliet::Cross(forward, right);
currentCam->Up = Cross(forward, right);
}
bool isRightMouseButtonDown = Juliet::IsMouseButtonDown(Juliet::MouseButton::Right);
bool isRightMouseButtonDown = IsMouseButtonDown(MouseButton::Right);
if (isRightMouseButtonDown && !gWasRightMouseButtonDown)
{
gIsFpsModeActive = !gIsFpsModeActive;
@@ -82,7 +82,7 @@ void UpdateDebugController(float dt)
return;
}
Juliet::MousePosition mouseDelta = Juliet::GetMouseDelta();
MousePosition mouseDelta = GetMouseDelta();
float sensitivity = 0.005f;
gYaw += mouseDelta.X * sensitivity;
@@ -91,52 +91,52 @@ void UpdateDebugController(float dt)
gPitch = std::min(gPitch, 1.5f);
gPitch = std::max(gPitch, -1.5f);
if (Juliet::IsKeyDown(Juliet::ScanCode::Q))
if (IsKeyDown(ScanCode::Q))
{
gYaw -= 2.0f * dt;
}
if (Juliet::IsKeyDown(Juliet::ScanCode::E))
if (IsKeyDown(ScanCode::E))
{
gYaw += 2.0f * dt;
}
Juliet::Vector3 forward;
Vector3 forward;
forward.x = cosf(gPitch) * cosf(gYaw);
forward.y = cosf(gPitch) * sinf(gYaw);
forward.z = sinf(gPitch);
Juliet::Vector3 right = Juliet::Normalize(Juliet::Cross(Juliet::Vector3{ 0.0f, 0.0f, 1.0f }, forward));
Juliet::Vector3 defaultUp = Juliet::Cross(forward, right);
Vector3 right = Normalize(Cross(Vector3{ 0.0f, 0.0f, 1.0f }, forward));
Vector3 defaultUp = Cross(forward, right);
static const float kMovementPerFrame = 10.f; // 10m/s
float speedPerFrame = kMovementPerFrame;
if (Juliet::IsKeyDown(Juliet::ScanCode::LeftShift))
if (IsKeyDown(ScanCode::LeftShift))
{
speedPerFrame *= 10.f; // 100m/s
}
if (Juliet::IsKeyDown(Juliet::ScanCode::W))
if (IsKeyDown(ScanCode::W))
{
currentCam->Position = currentCam->Position + forward * (speedPerFrame * dt);
}
if (Juliet::IsKeyDown(Juliet::ScanCode::S))
if (IsKeyDown(ScanCode::S))
{
currentCam->Position = currentCam->Position - forward * (speedPerFrame * dt);
}
if (Juliet::IsKeyDown(Juliet::ScanCode::D))
if (IsKeyDown(ScanCode::D))
{
currentCam->Position = currentCam->Position + right * (speedPerFrame * dt);
}
if (Juliet::IsKeyDown(Juliet::ScanCode::A))
if (IsKeyDown(ScanCode::A))
{
currentCam->Position = currentCam->Position - right * (speedPerFrame * dt);
}
if (Juliet::IsKeyDown(Juliet::ScanCode::Space))
if (IsKeyDown(ScanCode::Space))
{
currentCam->Position = currentCam->Position + defaultUp * (speedPerFrame * dt);
}
if (Juliet::IsKeyDown(Juliet::ScanCode::LeftControl))
if (IsKeyDown(ScanCode::LeftControl))
{
currentCam->Position = currentCam->Position - defaultUp * (speedPerFrame * dt);
}
@@ -148,7 +148,7 @@ void UpdateDebugController(float dt)
#if JULIET_DEBUG
void RenderImGuiDebugController(float dt)
{
Juliet::Camera* currentCam = Juliet::GetCurrentCamera();
Camera* currentCam = GetCurrentCamera();
ImGui::Text("Delta time: %f", dt);
Game/Debug/DebugTopBar.cpp
+2 -3
View File
@@ -1,13 +1,12 @@
#include <Debug/DebugTopBar.h>
#include <Debug/DebugTopBar.h>
#include <game.h>
#include <imgui.h>
namespace
{
Juliet::String GetGameModeName(GameMode gameMode)
String GetGameModeName(GameMode gameMode)
{
using namespace Juliet;
switch (gameMode)
{
case GameMode::Editor: return WrapString("Editor");
Game/Entity/Entity.h
+7 -7
View File
@@ -1,4 +1,4 @@
#pragma once
#pragma once
#include <Core/Common/CoreUtils.h>
#include <Core/Memory/Allocator.h>
@@ -8,19 +8,19 @@
#define DECLARE_ENTITY() \
Entity* Base; \
static const Juliet::Class* Kind;
static const Class* Kind;
// Will register the class globally at launch
#define DEFINE_ENTITY(entity) \
constexpr Juliet::Class entityKind##entity(#entity, sizeof(#entity) / sizeof(char)); \
const Juliet::Class* entity::Kind = &entityKind##entity;
constexpr Class entityKind##entity(#entity, sizeof(#entity) / sizeof(char)); \
const Class* entity::Kind = &entityKind##entity;
using DerivedType = void*;
struct Entity final
{
EntityID ID;
const Juliet::Class* Kind;
const Class* Kind;
DerivedType Derived;
float X, Y;
index_t MeshInstance = indexMax;
@@ -28,7 +28,7 @@ struct Entity final
template <typename EntityType>
concept EntityConcept = requires(EntityType entity) {
requires std::same_as<decltype(entity.Kind), const Juliet::Class*>;
requires std::same_as<decltype(entity.Kind), const Class*>;
requires std::same_as<decltype(entity.Base), Entity*>;
};
@@ -44,7 +44,7 @@ template <typename EntityType>
EntityType* MakeEntity(EntityManager& manager, float x, float y)
{
auto* arena = manager.Arena;
EntityType* result = Juliet::ArenaPushStruct<EntityType>(arena);
EntityType* result = ArenaPushStruct<EntityType>(arena);
Entity base;
base.X = x;
base.Y = y;
Game/Entity/EntityManager.cpp
+6 -6
View File
@@ -1,18 +1,18 @@
#include <Entity/EntityManager.h>
#include <Entity/EntityManager.h>
#include <Entity/Entity.h>
#include <Graphics/MeshRenderer.h>
EntityID EntityManager::ID = 0;
void InitEntityManager(Juliet::NonNullPtr<World> world)
void InitEntityManager(NonNullPtr<World> world)
{
EntityManager* newManager = Juliet::ArenaPushStruct<EntityManager>(world->WorldArena);
EntityManager* newManager = ArenaPushStruct<EntityManager>(world->WorldArena);
world->EntityManager = newManager;
newManager->Entities.Create(world->WorldArena JULIET_DEBUG_PARAM("Entities"));
newManager->Arena = Juliet::ArenaAllocate({ .Name = "Entity Arena" });
newManager->Arena = ArenaAllocate({ .Name = "Entity Arena" });
}
void ShutdownEntityManager()
@@ -22,7 +22,7 @@ void ShutdownEntityManager()
EntityManager& GetEntityManager()
{
Juliet::NonNullPtr entityManager = GetGameState()->World->EntityManager;
NonNullPtr entityManager = GetGameState()->World->EntityManager;
return *entityManager;
}
@@ -37,7 +37,7 @@ void UpdateEntityManager(EntityManager& manager)
{
if (ent.MeshInstance != indexMax)
{
Juliet::SetMeshInstanceTransform(ent.MeshInstance, Juliet::MatrixTranslation(ent.X, ent.Y, 0.0f));
SetMeshInstanceTransform(ent.MeshInstance, MatrixTranslation(ent.X, ent.Y, 0.0f));
}
}
}
Game/Entity/EntityManager.h
+4 -4
View File
@@ -1,4 +1,4 @@
#pragma once
#pragma once
#include <Core/Common/CoreTypes.h>
#include <Core/Container/Vector.h>
@@ -11,13 +11,13 @@ struct EntityManager
{
static EntityID ID;
Juliet::Arena* Arena;
Arena* Arena;
// TODO: Should be a pool
Juliet::VectorArena<Entity, 1024> Entities;
VectorArena<Entity, 1024> Entities;
};
void InitEntityManager(Juliet::NonNullPtr<World> world);
void InitEntityManager(NonNullPtr<World> world);
void ShutdownEntityManager();
EntityManager& GetEntityManager();
void RegisterEntity(EntityManager& manager, Entity* entity);
Game/game.cpp
+2 -4
View File
@@ -1,4 +1,4 @@
#include <game.h>
#include <game.h>
#include <Controller/DebugCameraController.h>
#include <Core/HAL/Filesystem/Filesystem.h>
@@ -31,14 +31,12 @@ extern "C" JULIET_API void __cdecl GameShutdown()
{
printf("Shutting down game...\n");
using namespace Juliet;
ShutdownEntityManager();
}
extern "C" JULIET_API void __cdecl GameUpdate(Juliet::GameData* params, [[maybe_unused]] float deltaTime)
extern "C" JULIET_API void __cdecl GameUpdate(GameData* params, [[maybe_unused]] float deltaTime)
{
using namespace Juliet;
gGameState = params->GameState;
if (!gGameState)
Game/game.h
+3 -3
View File
@@ -1,4 +1,4 @@
#pragma once
#pragma once
#include <Core/Memory/MemoryArena.h>
@@ -6,7 +6,7 @@ struct EntityManager;
struct World
{
Juliet::Arena* WorldArena;
Arena* WorldArena;
EntityManager* EntityManager;
};
@@ -19,7 +19,7 @@ enum class GameMode
struct GameState
{
Juliet::Arena* TotalArena;
Arena* TotalArena;
World* World;
Juliet/include/Core/Application/ApplicationManager.h
+4 -7
View File
@@ -1,13 +1,10 @@
#pragma once
#pragma once
#include <Core/Application/IApplication.h>
#include <Core/Common/CoreTypes.h>
#include <Juliet.h>
namespace Juliet
{
enum class JulietInit_Flags : uint8;
enum class JulietInit_Flags : uint8;
struct Arena;
extern JULIET_API void StartApplication(IApplication& app, JulietInit_Flags flags);
} // namespace Juliet
struct Arena;
extern JULIET_API void StartApplication(IApplication& app, JulietInit_Flags flags);
Juliet/include/Core/Application/IApplication.h
+23 -26
View File
@@ -1,32 +1,29 @@
#pragma once
#pragma once
#include <Core/Common/NonNullPtr.h>
namespace Juliet
struct Camera;
struct RenderPass;
struct CommandList;
struct Texture;
struct ColorTargetInfo;
struct DepthStencilTargetInfo;
struct Arena;
class IApplication
{
struct Camera;
struct RenderPass;
struct CommandList;
struct Texture;
struct ColorTargetInfo;
struct DepthStencilTargetInfo;
struct Arena;
public:
virtual ~IApplication() = default;
virtual void Init(NonNullPtr<Arena> arena) = 0;
virtual void Shutdown() = 0;
virtual void Update(float deltaTime) = 0;
virtual bool IsRunning() = 0;
class IApplication
{
public:
virtual ~IApplication() = default;
virtual void Init(NonNullPtr<Arena> arena) = 0;
virtual void Shutdown() = 0;
virtual void Update(float deltaTime) = 0;
virtual bool IsRunning() = 0;
// Accessors for Engine Systems
virtual struct Window* GetPlatformWindow() = 0;
virtual struct GraphicsDevice* GetGraphicsDevice() = 0;
// Accessors for Engine Systems
virtual struct Window* GetPlatformWindow() = 0;
virtual struct GraphicsDevice* GetGraphicsDevice() = 0;
// Render Lifecycle (Engine-Managed Render Loop)
virtual ColorTargetInfo GetColorTargetInfo(Texture* swapchainTexture) = 0;
virtual DepthStencilTargetInfo* GetDepthTargetInfo() = 0;
};
} // namespace Juliet
// Render Lifecycle (Engine-Managed Render Loop)
virtual ColorTargetInfo GetColorTargetInfo(Texture* swapchainTexture) = 0;
virtual DepthStencilTargetInfo* GetDepthTargetInfo() = 0;
};
Juliet/include/Core/Common/CRC32.h
+46 -49
View File
@@ -1,58 +1,55 @@
#pragma once
#pragma once
// From https://web.mit.edu/freebsd/head/sys/libkern/crc32.c
namespace Juliet
namespace details
{
namespace details
{
constexpr uint32_t crc32_tab[] = {
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832,
0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 0x646ba8c0, 0xfd62f97a,
0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab,
0xb6662d3d, 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 0x6b6b51f4,
0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074,
0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525,
0x206f85b3, 0xb966d409, 0xce61e49f, 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, 0xfed41b76,
0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 0x36034af6,
0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7,
0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7,
0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 0xbdbdf21c, 0xcabac28a, 0x53b39330,
0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
};
}
constexpr uint32_t crc32_tab[] = {
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832,
0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 0x646ba8c0, 0xfd62f97a,
0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab,
0xb6662d3d, 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 0x6b6b51f4,
0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074,
0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525,
0x206f85b3, 0xb966d409, 0xce61e49f, 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, 0xfed41b76,
0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 0x36034af6,
0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7,
0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7,
0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 0xbdbdf21c, 0xcabac28a, 0x53b39330,
0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
};
}
consteval uint32 crc32(const char* str, size_t length)
consteval uint32 crc32(const char* str, size_t length)
{
const char* p = str;
uint32_t crc = ~0U;
while (length--)
{
const char* p = str;
uint32_t crc = ~0U;
while (length--)
{
crc = details::crc32_tab[(crc ^ static_cast<uint8>(*p++)) & 0xFF] ^ (crc >> 8);
}
return crc ^ ~0U;
crc = details::crc32_tab[(crc ^ static_cast<uint8>(*p++)) & 0xFF] ^ (crc >> 8);
}
return crc ^ ~0U;
}
consteval uint32 operator""_crc32(const char* str, size_t length)
{
return crc32(str, length);
}
consteval uint32 operator""_crc32(const char* str, size_t length)
{
return crc32(str, length);
}
} // namespace Juliet
Juliet/include/Core/Common/CoreUtils.h
+119 -122
View File
@@ -1,18 +1,16 @@
#pragma once
#pragma once
#include <Core/Common/CoreTypes.h>
#include <Juliet.h>
namespace Juliet
{
#define global static
// 1. Stringify helpers
// 1. Stringify helpers
#define JULIET_STR(x) #x
#define JULIET_TOSTRING(x) JULIET_STR(x)
// 2. Define the pragma operator based on compiler
// 2. Define the pragma operator based on compiler
#if defined(__clang__) || defined(__GNUC__)
#define JULIET_PRAGMA(x) _Pragma(#x)
#define JULIET_SUPPRESS_MSVC(id)
@@ -27,7 +25,7 @@ namespace Juliet
#define JULIET_SUPPRESS_CLANG(str)
#endif
// 3. The Agnostic "Push/Pop"
// 3. The Agnostic "Push/Pop"
#if defined(__clang__)
#define JULIET_WARNING_PUSH JULIET_PRAGMA(clang diagnostic push)
#define JULIET_WARNING_POP JULIET_PRAGMA(clang diagnostic pop)
@@ -40,10 +38,10 @@ namespace Juliet
#endif
#if defined(_MSC_VER)
// MSVC specific intrinsic
// MSVC specific intrinsic
#define JULIET_PLATFORM_BREAK() (__nop(), __debugbreak())
#elif defined(__clang__) || defined(__GNUC__)
// Clang/GCC specific intrinsic
// Clang/GCC specific intrinsic
#define JULIET_PLATFORM_BREAK() __builtin_trap()
#else
#include <signal.h>
@@ -52,40 +50,40 @@ namespace Juliet
#if JULIET_DEBUG
#define JULIET_ASSERT_INTERNAL(expression, message) \
JULIET_WARNING_PUSH \
JULIET_SUPPRESS_CLANG("-Wextra-semi-stmt") \
JULIET_SUPPRESS_MSVC(4127) \
JULIET_SUPPRESS_MSVC(4548) \
{ \
if (!(expression)) [[unlikely]] \
{ \
Juliet::JulietAssert(#expression, message); \
} \
} \
JULIET_WARNING_POP \
static_assert(true, "")
JULIET_WARNING_PUSH \
JULIET_SUPPRESS_CLANG("-Wextra-semi-stmt") \
JULIET_SUPPRESS_MSVC(4127) \
JULIET_SUPPRESS_MSVC(4548) \
{ \
if (!(expression)) [[unlikely]] \
{ \
JulietAssert(#expression, message); \
} \
} \
JULIET_WARNING_POP \
static_assert(true, "")
#define AssertHR(hr_expression, message) \
do \
{ \
long hr_val = (hr_expression); \
if (hr_val < 0) \
{ \
Juliet::JulietAssert(#hr_expression, message, std::source_location::current(), hr_val); \
} \
} \
while (0)
do \
{ \
long hr_val = (hr_expression); \
if (hr_val < 0) \
{ \
JulietAssert(#hr_expression, message, std::source_location::current(), hr_val); \
} \
} \
while (0)
#define GET_ASSERT_MACRO(_1, _2, NAME, ...) NAME
#define Assert(...) GET_ASSERT_MACRO(__VA_ARGS__, JULIET_ASSERT_INTERNAL, JULIET_ASSERT_NO_MSG)(__VA_ARGS__)
#define JULIET_ASSERT_NO_MSG(expression) JULIET_ASSERT_INTERNAL(expression, "No additional information provided.")
#define Unimplemented() \
do \
{ \
Juliet::JulietAssert("UNIMPLEMENTED", "This code path is not yet functional."); \
} \
while (0)
do \
{ \
JulietAssert("UNIMPLEMENTED", "This code path is not yet functional."); \
} \
while (0)
#else
#define Assert(...) ((void)0)
@@ -93,85 +91,85 @@ namespace Juliet
#define Unimplemented() ((void)0)
#endif
JULIET_API extern void JulietAssert(const char* expression, const char* message,
std::source_location location = std::source_location::current(), long handleResult = 0);
JULIET_API extern void JulietAssert(const char* expression, const char* message,
std::source_location location = std::source_location::current(), long handleResult = 0);
#define ZeroStruct(structInstance) ZeroSize(sizeof(structInstance), &(structInstance))
#define ZeroArray(array) ZeroSize(sizeof((array)), (array))
#define ZeroDynArray(Count, Pointer) ZeroSize((Count) * sizeof((Pointer)[0]), Pointer)
inline void ZeroSize(size_t size, void* ptr)
inline void ZeroSize(size_t size, void* ptr)
{
auto Byte = (uint8*)ptr;
while (size--)
{
auto Byte = (uint8*)ptr;
while (size--)
{
*Byte++ = 0;
}
*Byte++ = 0;
}
}
#define Restrict __restrict
template <class Function>
class DeferredFunction
template <class Function>
class DeferredFunction
{
public:
explicit DeferredFunction(const Function& otherFct) noexcept
: Callback(otherFct)
{
public:
explicit DeferredFunction(const Function& otherFct) noexcept
: Callback(otherFct)
{
}
explicit DeferredFunction(Function&& otherFct) noexcept
: Callback(std::move(otherFct))
{
}
~DeferredFunction() noexcept { Callback(); }
DeferredFunction(const DeferredFunction&) = delete;
DeferredFunction(const DeferredFunction&&) = delete;
void operator=(const DeferredFunction&) = delete;
void operator=(DeferredFunction&&) = delete;
private:
Function Callback;
};
template <class Function>
auto Defer(Function&& fct) noexcept
}
explicit DeferredFunction(Function&& otherFct) noexcept
: Callback(std::move(otherFct))
{
return DeferredFunction<std::decay_t<Function>>{ std::forward<Function>(fct) };
}
inline bool IsValid(ByteBuffer buffer)
{
return buffer.Size > 0 && buffer.Data;
}
~DeferredFunction() noexcept { Callback(); }
extern JULIET_API void Free(ByteBuffer& buffer);
DeferredFunction(const DeferredFunction&) = delete;
DeferredFunction(const DeferredFunction&&) = delete;
void operator=(const DeferredFunction&) = delete;
void operator=(DeferredFunction&&) = delete;
template <std::integral T>
[[nodiscard]] constexpr T AlignPow2(T x, T alignment)
{
// Safety Check:
Assert(std::has_single_bit(static_cast<size_t>(alignment)));
private:
Function Callback;
};
return (x + alignment - 1) & ~(alignment - 1);
}
template <class Function>
auto Defer(Function&& fct) noexcept
{
return DeferredFunction<std::decay_t<Function>>{ std::forward<Function>(fct) };
}
template <typename T>
inline void Swap(T* Restrict a, T* Restrict b)
{
T temp = std::move(*a);
*a = std::move(*b);
*b = std::move(temp);
}
inline bool IsValid(ByteBuffer buffer)
{
return buffer.Size > 0 && buffer.Data;
}
// Move to another file dedicated to those
extern JULIET_API void Free(ByteBuffer& buffer);
template <std::integral T>
[[nodiscard]] constexpr T AlignPow2(T x, T alignment)
{
// Safety Check:
Assert(std::has_single_bit(static_cast<size_t>(alignment)));
return (x + alignment - 1) & ~(alignment - 1);
}
template <typename T>
inline void Swap(T* Restrict a, T* Restrict b)
{
T temp = std::move(*a);
*a = std::move(*b);
*b = std::move(temp);
}
// Move to another file dedicated to those
#if defined(__clang__)
#define COMPILER_CLANG 1
#elif defined(_MSC_VER)
#define COMPILER_MSVC 1
#endif
// Undef anything not defined
// Undef anything not defined
#if !defined(COMPILER_CLANG)
#define COMPILER_CLANG 0
#endif
@@ -189,43 +187,42 @@ namespace Juliet
#error AlignOf not defined for this compiler.
#endif
template <typename T>
[[nodiscard]] constexpr const char* GetTypeName()
{
template <typename T>
[[nodiscard]] constexpr const char* GetTypeName()
{
#if COMPILER_CLANG
return __PRETTY_FUNCTION__;
return __PRETTY_FUNCTION__;
#elif COMPILER_MSVC
return __FUNCSIG__;
return __FUNCSIG__;
#elif COMPILER_GCC
return __PRETTY_FUNCTION__;
return __PRETTY_FUNCTION__;
#else
return "UnknownType";
return "UnknownType";
#endif
}
}
inline uint16 safe_cast_uint16(uint32 value)
{
Assert(value <= uint16Max);
uint16 result = (uint16)value;
return result;
}
inline uint16 safe_cast_uint16(uint32 value)
{
Assert(value <= uint16Max);
uint16 result = (uint16)value;
return result;
}
const uint32 bitmask1 = 0b0000'0001;
const uint32 bitmask2 = 0b0000'0011;
const uint32 bitmask3 = 0b0000'0111;
const uint32 bitmask4 = 0b0000'1111;
const uint32 bitmask5 = 0b0001'1111;
const uint32 bitmask6 = 0b0011'1111;
const uint32 bitmask7 = 0b0111'1111;
const uint32 bitmask8 = 0b1111'1111;
const uint32 bitmask9 = 0x0000'01ff;
const uint32 bitmask10 = 0x0000'03ff;
const uint32 bitmask11 = 0x0000'07ff;
const uint32 bitmask12 = 0x0000'0fff;
const uint32 bitmask13 = 0x0000'1fff;
const uint32 bitmask14 = 0x0000'3fff;
const uint32 bitmask15 = 0x0000'7fff;
const uint32 bitmask16 = 0x0000'ffff;
// ...
const uint32 bitmask32 = 0xffff'ffff;
} // namespace Juliet
const uint32 bitmask1 = 0b0000'0001;
const uint32 bitmask2 = 0b0000'0011;
const uint32 bitmask3 = 0b0000'0111;
const uint32 bitmask4 = 0b0000'1111;
const uint32 bitmask5 = 0b0001'1111;
const uint32 bitmask6 = 0b0011'1111;
const uint32 bitmask7 = 0b0111'1111;
const uint32 bitmask8 = 0b1111'1111;
const uint32 bitmask9 = 0x0000'01ff;
const uint32 bitmask10 = 0x0000'03ff;
const uint32 bitmask11 = 0x0000'07ff;
const uint32 bitmask12 = 0x0000'0fff;
const uint32 bitmask13 = 0x0000'1fff;
const uint32 bitmask14 = 0x0000'3fff;
const uint32 bitmask15 = 0x0000'7fff;
const uint32 bitmask16 = 0x0000'ffff;
// ...
const uint32 bitmask32 = 0xffff'ffff;
Juliet/include/Core/Common/EnumUtils.h
+72 -75
View File
@@ -1,89 +1,86 @@
#pragma once
#pragma once
namespace Juliet
template <typename T>
concept IsEnum = std::is_enum_v<T>;
template <IsEnum E>
constexpr E operator~(E lhs) noexcept
{
template <typename T>
concept IsEnum = std::is_enum_v<T>;
return static_cast<E>(~static_cast<std::underlying_type_t<E>>(lhs));
}
template <IsEnum E>
constexpr E operator~(E lhs) noexcept
{
return static_cast<E>(~static_cast<std::underlying_type_t<E>>(lhs));
}
template <IsEnum E>
constexpr E operator|(E lhs, E rhs) noexcept
{
return static_cast<E>(static_cast<std::underlying_type_t<E>>(lhs) | static_cast<std::underlying_type_t<E>>(rhs));
}
template <IsEnum E>
constexpr E operator|(E lhs, E rhs) noexcept
{
return static_cast<E>(static_cast<std::underlying_type_t<E>>(lhs) | static_cast<std::underlying_type_t<E>>(rhs));
}
template <IsEnum E>
constexpr E& operator|=(E& lhs, E rhs) noexcept
{
return lhs = (lhs | rhs);
}
template <IsEnum E>
constexpr E& operator|=(E& lhs, E rhs) noexcept
{
return lhs = (lhs | rhs);
}
template <IsEnum E>
constexpr E operator&(E lhs, E rhs) noexcept
{
return static_cast<E>(static_cast<std::underlying_type_t<E>>(lhs) & static_cast<std::underlying_type_t<E>>(rhs));
}
template <IsEnum E>
constexpr E operator&(E lhs, E rhs) noexcept
{
return static_cast<E>(static_cast<std::underlying_type_t<E>>(lhs) & static_cast<std::underlying_type_t<E>>(rhs));
}
template <IsEnum E>
constexpr E& operator&=(E& lhs, E rhs) noexcept
{
return lhs = (lhs & rhs);
}
template <IsEnum E>
constexpr E& operator&=(E& lhs, E rhs) noexcept
{
return lhs = (lhs & rhs);
}
template <IsEnum E>
constexpr E operator^(E lhs, E rhs) noexcept
{
return static_cast<E>(static_cast<std::underlying_type_t<E>>(lhs) ^ static_cast<std::underlying_type_t<E>>(rhs));
}
template <IsEnum E>
constexpr E operator^(E lhs, E rhs) noexcept
{
return static_cast<E>(static_cast<std::underlying_type_t<E>>(lhs) ^ static_cast<std::underlying_type_t<E>>(rhs));
}
template <IsEnum E>
constexpr E& operator^=(E& lhs, E rhs) noexcept
{
return lhs = (lhs ^ rhs);
}
template <IsEnum E>
constexpr E& operator^=(E& lhs, E rhs) noexcept
{
return lhs = (lhs ^ rhs);
}
template <IsEnum E>
constexpr std::underlying_type_t<E> operator-(E lhs, E rhs) noexcept
{
using T = std::underlying_type_t<E>;
return static_cast<T>(static_cast<T>(lhs) - static_cast<T>(rhs));
}
template <IsEnum E>
constexpr std::underlying_type_t<E> operator-(E lhs, E rhs) noexcept
{
using T = std::underlying_type_t<E>;
return static_cast<T>(static_cast<T>(lhs) - static_cast<T>(rhs));
}
template <IsEnum E>
constexpr std::underlying_type_t<E> operator+(E lhs, E rhs) noexcept
{
using T = std::underlying_type_t<E>;
return static_cast<T>(static_cast<T>(lhs) + static_cast<T>(rhs));
}
template <IsEnum E>
constexpr std::underlying_type_t<E> operator+(E lhs, E rhs) noexcept
{
using T = std::underlying_type_t<E>;
return static_cast<T>(static_cast<T>(lhs) + static_cast<T>(rhs));
}
template <IsEnum E>
constexpr E operator-(E lhs, std::underlying_type_t<E> rhs) noexcept
{
using T = std::underlying_type_t<E>;
return static_cast<E>(static_cast<T>(static_cast<T>(lhs) - rhs));
}
template <IsEnum E>
constexpr E operator-(E lhs, std::underlying_type_t<E> rhs) noexcept
{
using T = std::underlying_type_t<E>;
return static_cast<E>(static_cast<T>(static_cast<T>(lhs) - rhs));
}
template <IsEnum E>
constexpr E operator+(E lhs, std::underlying_type_t<E> rhs) noexcept
{
using T = std::underlying_type_t<E>;
return static_cast<E>(static_cast<T>(static_cast<T>(lhs) + rhs));
}
template <IsEnum E>
constexpr E operator+(E lhs, std::underlying_type_t<E> rhs) noexcept
{
using T = std::underlying_type_t<E>;
return static_cast<E>(static_cast<T>(static_cast<T>(lhs) + rhs));
}
template <IsEnum E>
constexpr std::underlying_type_t<E> ToUnderlying(E enm) noexcept
{
return static_cast<std::underlying_type_t<E>>(enm);
}
template <IsEnum E>
constexpr std::underlying_type_t<E> ToUnderlying(E enm) noexcept
{
return static_cast<std::underlying_type_t<E>>(enm);
}
template <IsEnum E>
constexpr E ToEnum(std::underlying_type_t<E> value) noexcept
{
return static_cast<E>(value);
}
} // namespace Juliet
template <IsEnum E>
constexpr E ToEnum(std::underlying_type_t<E> value) noexcept
{
return static_cast<E>(value);
}
Juliet/include/Core/Common/NonNullPtr.h
+90 -93
View File
@@ -1,113 +1,110 @@
#pragma once
#pragma once
#include <Core/Common/CoreUtils.h>
namespace Juliet
template <typename Type, typename OtherType>
concept NonNullPtr_Convertible = std::is_convertible_v<OtherType*, Type*>;
template <typename Type, typename OtherType>
concept NonNullPtr_SameType = std::is_same_v<OtherType*, Type*>;
template <typename Type>
class NonNullPtr
{
template <typename Type, typename OtherType>
concept NonNullPtr_Convertible = std::is_convertible_v<OtherType*, Type*>;
template <typename Type, typename OtherType>
concept NonNullPtr_SameType = std::is_same_v<OtherType*, Type*>;
template <typename Type>
class NonNullPtr
public:
constexpr NonNullPtr(Type* ptr)
: InternalPtr(ptr)
{
public:
constexpr NonNullPtr(Type* ptr)
: InternalPtr(ptr)
{
Assert(ptr, "Tried to initialize a NonNullPtr with a null pointer");
}
Assert(ptr, "Tried to initialize a NonNullPtr with a null pointer");
}
template <typename OtherType>
requires NonNullPtr_Convertible<OtherType*, Type*>
constexpr NonNullPtr(const NonNullPtr<OtherType>& otherPtr)
: InternalPtr(otherPtr.Get())
{
Assert(InternalPtr, "Fatal Error: Assigned a non null ptr using another NonNullPtr but its was null.");
}
template <typename OtherType>
requires NonNullPtr_Convertible<OtherType*, Type*>
constexpr NonNullPtr(const NonNullPtr<OtherType>& otherPtr)
: InternalPtr(otherPtr.Get())
{
Assert(InternalPtr, "Fatal Error: Assigned a non null ptr using another NonNullPtr but its was null.");
}
// Assignment
[[nodiscard]] constexpr NonNullPtr& operator=(Type* ptr)
{
Assert(ptr, "Tried to assign a null pointer to a NonNullPtr!");
InternalPtr = ptr;
return *this;
}
// Assignment
[[nodiscard]] constexpr NonNullPtr& operator=(Type* ptr)
{
Assert(ptr, "Tried to assign a null pointer to a NonNullPtr!");
InternalPtr = ptr;
return *this;
}
template <typename OtherType>
requires NonNullPtr_Convertible<OtherType*, Type*>
[[nodiscard]] constexpr NonNullPtr& operator=(const NonNullPtr<OtherType>& otherPtr)
{
InternalPtr = otherPtr.Get();
return *this;
}
template <typename OtherType>
requires NonNullPtr_Convertible<OtherType*, Type*>
[[nodiscard]] constexpr NonNullPtr& operator=(const NonNullPtr<OtherType>& otherPtr)
{
InternalPtr = otherPtr.Get();
return *this;
}
// Accessors
[[nodiscard]] constexpr operator Type*() const
{
Assert(InternalPtr, "NonNullPtr: Internal Pointer is Null");
return InternalPtr;
}
// Accessors
[[nodiscard]] constexpr operator Type*() const
{
Assert(InternalPtr, "NonNullPtr: Internal Pointer is Null");
return InternalPtr;
}
[[nodiscard]] constexpr Type* Get() const
{
Assert(InternalPtr, "NonNullPtr: Internal Pointer is Null");
return InternalPtr;
}
[[nodiscard]] constexpr Type* Get() const
{
Assert(InternalPtr, "NonNullPtr: Internal Pointer is Null");
return InternalPtr;
}
[[nodiscard]] constexpr Type& operator*() const
{
Assert(InternalPtr, "NonNullPtr: Internal Pointer is Null");
return *InternalPtr;
}
[[nodiscard]] constexpr Type& operator*() const
{
Assert(InternalPtr, "NonNullPtr: Internal Pointer is Null");
return *InternalPtr;
}
[[nodiscard]] constexpr Type* operator->() const
{
Assert(InternalPtr, "NonNullPtr: Internal Pointer is Null");
return InternalPtr;
}
[[nodiscard]] constexpr Type* operator->() const
{
Assert(InternalPtr, "NonNullPtr: Internal Pointer is Null");
return InternalPtr;
}
// Comparisons
[[nodiscard]] constexpr bool operator==(const NonNullPtr& otherPtr) const
{
return InternalPtr == otherPtr.InternalPtr;
}
// Comparisons
[[nodiscard]] constexpr bool operator==(const NonNullPtr& otherPtr) const
{
return InternalPtr == otherPtr.InternalPtr;
}
template <typename OtherType>
requires NonNullPtr_SameType<Type, OtherType>
[[nodiscard]] constexpr bool operator==(OtherType* otherRawPtr) const
{
return InternalPtr == otherRawPtr;
}
template <typename OtherType>
requires NonNullPtr_SameType<Type, OtherType>
[[nodiscard]] constexpr bool operator==(OtherType* otherRawPtr) const
{
return InternalPtr == otherRawPtr;
}
template <typename OtherType>
requires NonNullPtr_SameType<Type, OtherType>
[[nodiscard]] constexpr friend bool operator==(OtherType* otherRawPtr, const NonNullPtr& nonNullPtr)
{
return otherRawPtr == nonNullPtr.InternalPtr;
}
template <typename OtherType>
requires NonNullPtr_SameType<Type, OtherType>
[[nodiscard]] constexpr friend bool operator==(OtherType* otherRawPtr, const NonNullPtr& nonNullPtr)
{
return otherRawPtr == nonNullPtr.InternalPtr;
}
// Forbid assigning a nullptr at compile time
constexpr NonNullPtr(std::nullptr_t)
: InternalPtr(nullptr)
{
static_assert(sizeof(Type) == 0, "Trying to initialize a NonNullPtr with a nullptr value");
}
// Forbid assigning a nullptr at compile time
constexpr NonNullPtr(std::nullptr_t)
: InternalPtr(nullptr)
{
static_assert(sizeof(Type) == 0, "Trying to initialize a NonNullPtr with a nullptr value");
}
[[nodiscard]] constexpr NonNullPtr& operator=(std::nullptr_t)
{
static_assert(sizeof(Type) == 0, "Trying to assign a NonNullPtr with a nullptr value");
return *this;
}
[[nodiscard]] constexpr NonNullPtr& operator=(std::nullptr_t)
{
static_assert(sizeof(Type) == 0, "Trying to assign a NonNullPtr with a nullptr value");
return *this;
}
[[nodiscard]] constexpr explicit operator bool() const { return InternalPtr != nullptr; }
[[nodiscard]] constexpr explicit operator bool() const { return InternalPtr != nullptr; }
private:
Type* InternalPtr;
};
private:
Type* InternalPtr;
};
template <typename T>
NonNullPtr(T*) -> NonNullPtr<T>;
} // namespace Juliet
template <typename T>
NonNullPtr(T*) -> NonNullPtr<T>;
Juliet/include/Core/Common/String.h
+137 -140
View File
@@ -1,4 +1,4 @@
#pragma once
#pragma once
#include <Core/Common/NonNullPtr.h>
#include <Core/Math/MathUtils.h>
@@ -14,170 +14,167 @@
#undef RESTORE_GLOBAL
#endif
namespace Juliet
{
struct Arena;
struct Arena;
#define ConstString(str) { const_cast<char*>((str)), sizeof(str) - 1 }
#define CStr(str) ((str).Str)
#define InplaceString(name, size) \
char name##_[size]; \
MemSet(name##_, 0, sizeof(uint32)); \
String name = { name##_, 0 }
char name##_[size]; \
MemSet(name##_, 0, sizeof(uint32)); \
String name = { name##_, 0 }
// Everything is Little Endian
enum class StringEncoding : uint8
// Everything is Little Endian
enum class StringEncoding : uint8
{
Unknown = 0,
ASCII,
LATIN1,
UTF8,
UTF16,
UTF32,
UCS2,
UCS4,
};
// Represents a UTF-8 String.
// Not null terminated.
struct String8
{
char* Str;
size_t Size;
};
using String = String8;
struct String16
{
uint16* Str;
size_t Size;
};
struct StringBuffer : String
{
size_t Capacity;
};
struct UnicodeDecode
{
uint32 Increment;
uint32 Codepoint;
};
constexpr uint32 kInvalidUTF8 = 0xFFFD;
inline size_t StringLength(String str)
{
return str.Size;
}
inline size_t StringLength(const char* str)
{
size_t length = 0;
if (str)
{
Unknown = 0,
ASCII,
LATIN1,
UTF8,
UTF16,
UTF32,
UCS2,
UCS4,
};
// Represents a UTF-8 String.
// Not null terminated.
struct String8
{
char* Str;
size_t Size;
};
using String = String8;
struct String16
{
uint16* Str;
size_t Size;
};
struct StringBuffer : String
{
size_t Capacity;
};
struct UnicodeDecode
{
uint32 Increment;
uint32 Codepoint;
};
constexpr uint32 kInvalidUTF8 = 0xFFFD;
inline size_t StringLength(String str)
{
return str.Size;
}
inline size_t StringLength(const char* str)
{
size_t length = 0;
if (str)
while (*str)
{
while (*str)
{
++length;
++str;
}
++length;
++str;
}
return length;
}
inline bool IsValid(String str)
{
return str.Size > 0 && str.Str != nullptr && *str.Str;
}
return length;
}
inline String WrapString(const char* str)
{
String result = {};
result.Str = const_cast<char*>(str);
result.Size = str ? strlen(str) : 0;
return result;
}
inline bool IsValid(String str)
{
return str.Size > 0 && str.Str != nullptr && *str.Str;
}
inline String FindChar(String str, char c)
inline String WrapString(const char* str)
{
String result = {};
result.Str = const_cast<char*>(str);
result.Size = str ? strlen(str) : 0;
return result;
}
inline String FindChar(String str, char c)
{
String result = str;
while (result.Size)
{
String result = str;
while (result.Size)
if (*result.Str != c)
{
if (*result.Str != c)
{
++result.Str;
--result.Size;
}
else
{
return result;
}
++result.Str;
--result.Size;
}
return {};
}
inline bool ContainsChar(String str, char c)
{
return IsValid(FindChar(str, c));
}
// Return:
// - < 0 if str1 < str2
// - = 0 : Both strings are equals
// - > 0 if str1 > str2
inline int32 StringCompare(String str1, String str2)
{
size_t len1 = StringLength(str1);
size_t len2 = StringLength(str2);
size_t minLen = Min(len1, len2);
int32 result = MemCompare(CStr(str1), CStr(str2), minLen);
if (result == 0)
else
{
if (len1 > len2)
{
return 1;
}
if (len1 < len2)
{
return -1;
}
return 0;
return result;
}
return result;
}
return {};
}
JULIET_API uint32 StepUTF8(String& inStr);
JULIET_API String FindString(String strLeft, String strRight);
inline bool ContainsChar(String str, char c)
{
return IsValid(FindChar(str, c));
}
// Case insensitive compare. Supports ASCII only
// TODO: Support UNICODE
extern JULIET_API int8 StringCompareCaseInsensitive(String str1, String str2);
// Do not allocate anything, you must allocate your out buffer yourself
// TODO: Version taking arena that can allocate
// Do not take String type because we dont know the string encoding we are going from/to
// src and dst will be casted based on the encoding.
// size will correspond to the number of characters
// Will convert \0 character if present.
extern JULIET_API bool ConvertString(StringEncoding from, StringEncoding to, String src, StringBuffer& dst, bool nullTerminate);
extern JULIET_API bool ConvertString(String from, String to, String src, StringBuffer& dst, bool nullTerminate);
JULIET_API String StringCopy(NonNullPtr<Arena> arena, String str);
JULIET_API String16 str16_from_8(NonNullPtr<Arena> arena, String8 str);
template <typename... Args>
String Format(NonNullPtr<Arena> arena, const char* formatStr, Args&&... args)
// Return:
// - < 0 if str1 < str2
// - = 0 : Both strings are equals
// - > 0 if str1 > str2
inline int32 StringCompare(String str1, String str2)
{
size_t len1 = StringLength(str1);
size_t len2 = StringLength(str2);
size_t minLen = Min(len1, len2);
int32 result = MemCompare(CStr(str1), CStr(str2), minLen);
if (result == 0)
{
std::string result = std::vformat(formatStr, std::make_format_args(args...));
return StringCopy(arena, WrapString(result.c_str()));
if (len1 > len2)
{
return 1;
}
if (len1 < len2)
{
return -1;
}
return 0;
}
return result;
}
JULIET_API uint32 StepUTF8(String& inStr);
JULIET_API String FindString(String strLeft, String strRight);
// Case insensitive compare. Supports ASCII only
// TODO: Support UNICODE
extern JULIET_API int8 StringCompareCaseInsensitive(String str1, String str2);
// Do not allocate anything, you must allocate your out buffer yourself
// TODO: Version taking arena that can allocate
// Do not take String type because we dont know the string encoding we are going from/to
// src and dst will be casted based on the encoding.
// size will correspond to the number of characters
// Will convert \0 character if present.
extern JULIET_API bool ConvertString(StringEncoding from, StringEncoding to, String src, StringBuffer& dst, bool nullTerminate);
extern JULIET_API bool ConvertString(String from, String to, String src, StringBuffer& dst, bool nullTerminate);
JULIET_API String StringCopy(NonNullPtr<Arena> arena, String str);
JULIET_API String16 str16_from_8(NonNullPtr<Arena> arena, String8 str);
template <typename... Args>
String Format(NonNullPtr<Arena> arena, const char* formatStr, Args&&... args)
{
std::string result = std::vformat(formatStr, std::make_format_args(args...));
return StringCopy(arena, WrapString(result.c_str()));
}
#define juliet_snprintf snprintf
} // namespace Juliet
#ifdef UNIT_TEST
namespace Juliet::UnitTest
namespace UnitTest
{
inline void TestFindChar()
{
@@ -192,5 +189,5 @@ namespace Juliet::UnitTest
Assert(FindChar(s2, 'f').Str - s2.Str == 5);
Assert(FindChar(s3, '1').Str - s3.Str == 0);
}
} // namespace Juliet::UnitTest
} // namespace UnitTest
#endif
Juliet/include/Core/Container/Vector.h
+182 -185
View File
@@ -1,214 +1,211 @@
#pragma once
#pragma once
#include <Core/Common/NonNullPtr.h>
#include <Core/Memory/MemoryArena.h>
namespace Juliet
template <typename Type, size_t ReserveSize = 16>
struct VectorArena
{
template <typename Type, size_t ReserveSize = 16>
struct VectorArena
void Create(NonNullPtr<Arena> arena JULIET_DEBUG_PARAM(const char* name = nullptr))
{
void Create(NonNullPtr<Arena> arena JULIET_DEBUG_PARAM(const char* name = nullptr))
Assert(!Arena);
JULIET_DEBUG_ONLY(Name = name ? name : Name;)
DataFirst = DataLast = Data = nullptr;
Count = 0;
Capacity = 0;
Arena = arena;
Reserve(ReserveSize);
}
void Destroy()
{
DataFirst = DataLast = Data = nullptr;
Count = 0;
Capacity = 0;
Arena = nullptr;
}
void Reserve(size_t newCapacity)
{
Assert(Arena);
Assert(newCapacity <= ReserveSize && "VectorArena capacity should be <= ReserveSize.");
if (Data == nullptr)
{
Assert(!Arena);
Data = ArenaPushArray<Type>(Arena, newCapacity JULIET_DEBUG_PARAM(Name));
Capacity = newCapacity;
}
else
{
Unimplemented();
}
}
JULIET_DEBUG_ONLY(Name = name ? name : Name;)
void Resize(size_t newCount)
{
Assert(Arena);
if (newCount == Count)
{
return;
}
DataFirst = DataLast = Data = nullptr;
Count = 0;
Capacity = 0;
Arena = arena;
if (Data == nullptr)
{
size_t initialCapacity = newCount > ReserveSize ? newCount : ReserveSize;
Reserve(initialCapacity);
}
Assert(newCount <= Capacity && "VectorArena capacity exceeded!");
Count = newCount;
if (Count > 0)
{
DataFirst = Data;
DataLast = Data + Count - 1;
}
else
{
DataFirst = DataLast = nullptr;
}
}
void PushBack(const Type* buffer, size_t amount)
{
Assert(Arena);
Assert(buffer || amount == 0);
if (amount == 0)
{
return;
}
if (Data == nullptr)
{
size_t initialCapacity = amount > ReserveSize ? amount : ReserveSize;
Reserve(initialCapacity);
}
Assert(Count + amount <= Capacity && "VectorArena capacity exceeded!");
Type* dst = Data + Count;
MemCopy(dst, buffer, amount * sizeof(Type));
if (Count == 0)
{
DataFirst = dst;
}
DataLast = dst + amount - 1;
Count += amount;
}
void PushBack(const Type& value)
{
Assert(Arena);
if (Data == nullptr)
{
Reserve(ReserveSize);
}
void Destroy()
Assert(Count + 1 <= Capacity && "VectorArena capacity exceeded!");
Type* entry = Data + Count;
*entry = value;
if (Count == 0)
{
DataFirst = DataLast = Data = nullptr;
Count = 0;
Capacity = 0;
Arena = nullptr;
DataFirst = entry;
}
DataLast = entry;
++Count;
}
void PushBack(Type&& value)
{
Assert(Arena);
if (Data == nullptr)
{
Reserve(ReserveSize);
}
void Reserve(size_t newCapacity)
{
Assert(Arena);
Assert(newCapacity <= ReserveSize && "VectorArena capacity should be <= ReserveSize.");
Assert(Count + 1 <= Capacity && "VectorArena capacity exceeded!");
if (Data == nullptr)
{
Data = ArenaPushArray<Type>(Arena, newCapacity JULIET_DEBUG_PARAM(Name));
Capacity = newCapacity;
}
else
{
Unimplemented();
}
Type* entry = Data + Count;
*entry = std::move(value);
if (Count == 0)
{
DataFirst = entry;
}
DataLast = entry;
++Count;
}
void RemoveAtFast(index_t index)
{
Assert(Arena);
Assert(index < Count);
Assert(Count > 0);
Type* elementAdr = DataFirst + index;
// Swap DataLast and element
if (DataLast != elementAdr)
{
Swap(DataLast, elementAdr);
}
void Resize(size_t newCount)
--DataLast;
--Count;
if (Count == 0)
{
Assert(Arena);
if (newCount == Count)
{
return;
}
if (Data == nullptr)
{
size_t initialCapacity = newCount > ReserveSize ? newCount : ReserveSize;
Reserve(initialCapacity);
}
Assert(newCount <= Capacity && "VectorArena capacity exceeded!");
Count = newCount;
if (Count > 0)
{
DataFirst = Data;
DataLast = Data + Count - 1;
}
else
{
DataFirst = DataLast = nullptr;
}
}
void PushBack(const Type* buffer, size_t amount)
{
Assert(Arena);
Assert(buffer || amount == 0);
if (amount == 0)
{
return;
}
if (Data == nullptr)
{
size_t initialCapacity = amount > ReserveSize ? amount : ReserveSize;
Reserve(initialCapacity);
}
Assert(Count + amount <= Capacity && "VectorArena capacity exceeded!");
Type* dst = Data + Count;
MemCopy(dst, buffer, amount * sizeof(Type));
if (Count == 0)
{
DataFirst = dst;
}
DataLast = dst + amount - 1;
Count += amount;
}
void PushBack(const Type& value)
{
Assert(Arena);
if (Data == nullptr)
{
Reserve(ReserveSize);
}
Assert(Count + 1 <= Capacity && "VectorArena capacity exceeded!");
Type* entry = Data + Count;
*entry = value;
if (Count == 0)
{
DataFirst = entry;
}
DataLast = entry;
++Count;
}
void PushBack(Type&& value)
{
Assert(Arena);
if (Data == nullptr)
{
Reserve(ReserveSize);
}
Assert(Count + 1 <= Capacity && "VectorArena capacity exceeded!");
Type* entry = Data + Count;
*entry = std::move(value);
if (Count == 0)
{
DataFirst = entry;
}
DataLast = entry;
++Count;
}
void RemoveAtFast(index_t index)
{
Assert(Arena);
Assert(index < Count);
Assert(Count > 0);
Type* elementAdr = DataFirst + index;
// Swap DataLast and element
if (DataLast != elementAdr)
{
Swap(DataLast, elementAdr);
}
--DataLast;
--Count;
if (Count == 0)
{
DataFirst = DataLast = nullptr;
}
}
void Clear()
{
Assert(Arena);
DataFirst = DataLast = nullptr;
Count = 0;
}
}
[[nodiscard]] bool IsEmpty() const { return Count == 0; }
void Clear()
{
Assert(Arena);
// C++ Accessors for loop supports and Index based access
[[nodiscard]] Type& operator[](size_t index) { return DataFirst[index]; }
[[nodiscard]] const Type& operator[](size_t index) const { return DataFirst[index]; }
DataFirst = DataLast = nullptr;
Count = 0;
}
[[nodiscard]] Type* begin() { return DataFirst; }
[[nodiscard]] Type* end() { return DataFirst + Count; }
[[nodiscard]] bool IsEmpty() const { return Count == 0; }
[[nodiscard]] const Type* begin() const { return DataFirst; }
[[nodiscard]] const Type* end() const { return DataFirst + Count; }
// C++ Accessors for loop supports and Index based access
[[nodiscard]] Type& operator[](size_t index) { return DataFirst[index]; }
[[nodiscard]] const Type& operator[](size_t index) const { return DataFirst[index]; }
[[nodiscard]] Type* First() { return DataFirst; }
[[nodiscard]] Type* Front() { return DataFirst; }
[[nodiscard]] Type* Last() { return DataLast; }
[[nodiscard]] Type* Back() { return DataLast; }
[[nodiscard]] Type* DataPtr() { return Data; }
[[nodiscard]] const Type* DataPtr() const { return Data; }
[[nodiscard]] Type* begin() { return DataFirst; }
[[nodiscard]] Type* end() { return DataFirst + Count; }
[[nodiscard]] size_t Size() const { return Count; }
[[nodiscard]] const Type* begin() const { return DataFirst; }
[[nodiscard]] const Type* end() const { return DataFirst + Count; }
Arena* Arena = nullptr;
Type* DataFirst = nullptr;
Type* DataLast = nullptr;
Type* Data = nullptr;
size_t Count = 0;
size_t Capacity = 0;
JULIET_DEBUG_ONLY(const char* Name = "VectorArena";)
};
static_assert(std::is_standard_layout_v<VectorArena<int>>,
"VectorArena must have a standard layout to remain POD-like.");
static_assert(std::is_trivially_copyable_v<VectorArena<int>>,
"VectorArena must be trivially copyable (no custom destructors/assignment).");
} // namespace Juliet
[[nodiscard]] Type* First() { return DataFirst; }
[[nodiscard]] Type* Front() { return DataFirst; }
[[nodiscard]] Type* Last() { return DataLast; }
[[nodiscard]] Type* Back() { return DataLast; }
[[nodiscard]] Type* DataPtr() { return Data; }
[[nodiscard]] const Type* DataPtr() const { return Data; }
[[nodiscard]] size_t Size() const { return Count; }
Arena* Arena = nullptr;
Type* DataFirst = nullptr;
Type* DataLast = nullptr;
Type* Data = nullptr;
size_t Count = 0;
size_t Capacity = 0;
JULIET_DEBUG_ONLY(const char* Name = "VectorArena";)
};
static_assert(std::is_standard_layout_v<VectorArena<int>>,
"VectorArena must have a standard layout to remain POD-like.");
static_assert(std::is_trivially_copyable_v<VectorArena<int>>,
"VectorArena must be trivially copyable (no custom destructors/assignment).");
Juliet/include/Core/HAL/Display/Display.h
+9 -12
View File
@@ -1,21 +1,18 @@
#pragma once
#pragma once
#include <Core/Common/CoreTypes.h>
#include <Core/Common/NonNullPtr.h>
#include <Core/Common/String.h>
#include <Juliet.h>
namespace Juliet
{
struct Window;
struct Window;
using WindowID = uint8;
extern JULIET_API Window* CreatePlatformWindow(const char* title, uint16 width, uint16 height, int flags = 0 /* unused */);
extern JULIET_API void DestroyPlatformWindow(NonNullPtr<Window> window);
using WindowID = uint8;
extern JULIET_API Window* CreatePlatformWindow(const char* title, uint16 width, uint16 height, int flags = 0 /* unused */);
extern JULIET_API void DestroyPlatformWindow(NonNullPtr<Window> window);
extern JULIET_API void ShowWindow(NonNullPtr<Window> window);
extern JULIET_API void HideWindow(NonNullPtr<Window> window);
extern JULIET_API void ShowWindow(NonNullPtr<Window> window);
extern JULIET_API void HideWindow(NonNullPtr<Window> window);
extern JULIET_API WindowID GetWindowID(NonNullPtr<Window> window);
extern JULIET_API void SetWindowTitle(NonNullPtr<Window> window, String title);
} // namespace Juliet
extern JULIET_API WindowID GetWindowID(NonNullPtr<Window> window);
extern JULIET_API void SetWindowTitle(NonNullPtr<Window> window, String title);
Juliet/include/Core/HAL/DynLib/DynamicLibrary.h
+5 -8
View File
@@ -1,12 +1,9 @@
#pragma once
#pragma once
#include <Core/Common/NonNullPtr.h>
namespace Juliet
{
struct DynamicLibrary;
struct DynamicLibrary;
extern JULIET_API DynamicLibrary* LoadDynamicLibrary(const char* filename);
extern JULIET_API FunctionPtr LoadFunction(NonNullPtr<DynamicLibrary> lib, const char* functionName);
extern JULIET_API void UnloadDynamicLibrary(NonNullPtr<DynamicLibrary> lib);
} // namespace Juliet
extern JULIET_API DynamicLibrary* LoadDynamicLibrary(const char* filename);
extern JULIET_API FunctionPtr LoadFunction(NonNullPtr<DynamicLibrary> lib, const char* functionName);
extern JULIET_API void UnloadDynamicLibrary(NonNullPtr<DynamicLibrary> lib);
Juliet/include/Core/HAL/Event/SystemEvent.h
+93 -96
View File
@@ -1,4 +1,4 @@
#pragma once
#pragma once
#include <Core/HAL/Display/Display.h>
#include <Core/HAL/Keyboard/Keyboard.h>
@@ -9,115 +9,112 @@
// Handles all events from systems handling the Hardware
// Very inspired by SDL3
namespace Juliet
enum class EventType : uint32
{
enum class EventType : uint32
{
None = 0,
First = None,
None = 0,
First = None,
// Application Events
// User querying an exit
Application_Exit = 100,
// OS terminating the application
Application_OS_Terminate,
Application_Begin = Application_Exit,
Application_End = Application_OS_Terminate,
// Application Events
// User querying an exit
Application_Exit = 100,
// OS terminating the application
Application_OS_Terminate,
Application_Begin = Application_Exit,
Application_End = Application_OS_Terminate,
// Window Events
Window_Close_Request = 200,
Window_Begin = Window_Close_Request,
Window_End = Window_Close_Request,
// Window Events
Window_Close_Request = 200,
Window_Begin = Window_Close_Request,
Window_End = Window_Close_Request,
// Keyboard Event
Key_Down = 300,
Key_Up,
Keyboard_Begin = Key_Down,
Keyboard_End = Key_Up,
// Keyboard Event
Key_Down = 300,
Key_Up,
Keyboard_Begin = Key_Down,
Keyboard_End = Key_Up,
// Mouse Event
Mouse_Move = 400,
Mouse_ButtonPressed,
Mouse_ButtonReleased,
// Mouse Event
Mouse_Move = 400,
Mouse_ButtonPressed,
Mouse_ButtonReleased,
Mouse_Begin = Mouse_Move,
Mouse_End = Mouse_ButtonReleased,
Mouse_Begin = Mouse_Move,
Mouse_End = Mouse_ButtonReleased,
Last // Get value from the previous one
};
Last // Get value from the previous one
};
struct WindowEvent
{
WindowID AssociatedWindowID;
uint32 DataPadding[2]; // TODO : define how much data param we need
};
struct WindowEvent
{
WindowID AssociatedWindowID;
uint32 DataPadding[2]; // TODO : define how much data param we need
};
struct KeyboardEvent
{
KeyboardID AssociatedKeyboardID;
WindowID WindowID;
Key Key;
KeyState KeyState;
KeyMod KeyModeState;
};
struct KeyboardEvent
{
KeyboardID AssociatedKeyboardID;
WindowID WindowID;
Key Key;
KeyState KeyState;
KeyMod KeyModeState;
};
// =====================================================
// Mouse Events
// =====================================================
struct MouseMovementEvent
{
MouseID AssociatedMouseID;
WindowID WindowID;
float X;
float Y;
float X_Displacement;
float Y_Displacement;
MouseButton ButtonState;
};
// =====================================================
// Mouse Events
// =====================================================
struct MouseMovementEvent
{
MouseID AssociatedMouseID;
WindowID WindowID;
float X;
float Y;
float X_Displacement;
float Y_Displacement;
MouseButton ButtonState;
};
struct MouseButtonEvent
{
MouseID AssociatedMouseID;
WindowID WindowID;
float X;
float Y;
MouseButton ButtonState;
bool IsPressed : 1;
};
struct MouseButtonEvent
{
MouseID AssociatedMouseID;
WindowID WindowID;
float X;
float Y;
MouseButton ButtonState;
bool IsPressed : 1;
};
// Tagged union representing ALL possible system events + a bit of data for custom event if needed
union AllSystemEventUnion
{
WindowEvent Window;
KeyboardEvent Keyboard;
MouseMovementEvent MouseMovement;
MouseButtonEvent MouseButton;
uint8 Padding[128]; // Make sure that the union is fixed in size and big enough on all platforms.
};
// Make sure we do not bust the union size
static_assert(sizeof(AllSystemEventUnion) == sizeof(((AllSystemEventUnion*)nullptr)->Padding));
// Tagged union representing ALL possible system events + a bit of data for custom event if needed
union AllSystemEventUnion
{
WindowEvent Window;
KeyboardEvent Keyboard;
MouseMovementEvent MouseMovement;
MouseButtonEvent MouseButton;
uint8 Padding[128]; // Make sure that the union is fixed in size and big enough on all platforms.
};
// Make sure we do not bust the union size
static_assert(sizeof(AllSystemEventUnion) == sizeof(((AllSystemEventUnion*)nullptr)->Padding));
struct SystemEvent
{
EventType Type;
uint64 Timestamp;
AllSystemEventUnion Data;
};
struct SystemEvent
{
EventType Type;
uint64 Timestamp;
AllSystemEventUnion Data;
};
// Poll for any event, return false if no event is available.
// Equivalent to WaitEvent(event, 0);
// Will not block
extern JULIET_API bool GetEvent(SystemEvent& event);
// Poll for any event, return false if no event is available.
// Equivalent to WaitEvent(event, 0);
// Will not block
extern JULIET_API bool GetEvent(SystemEvent& event);
// TODO : use chrono to tag the timeout correctly with nanosec
// timeout == -1 means wait for any event before pursuing
// timeout == 0 means checking once for the frame and getting out
// timeout > 0 means wait until time is out
extern JULIET_API bool WaitEvent(SystemEvent& event, int32 timeoutInNS = -1);
// TODO : use chrono to tag the timeout correctly with nanosec
// timeout == -1 means wait for any event before pursuing
// timeout == 0 means checking once for the frame and getting out
// timeout > 0 means wait until time is out
extern JULIET_API bool WaitEvent(SystemEvent& event, int32 timeoutInNS = -1);
// Add an event onto the event queue.
// TODO : support array of events
extern JULIET_API bool AddEvent(SystemEvent& event);
// Add an event onto the event queue.
// TODO : support array of events
extern JULIET_API bool AddEvent(SystemEvent& event);
extern void Events_NewFrame(float deltaTime);
} // namespace Juliet
extern void Events_NewFrame(float deltaTime);
Juliet/include/Core/HAL/Filesystem/Filesystem.h
+11 -14
View File
@@ -1,20 +1,17 @@
#pragma once
#pragma once
#include <Core/Common/String.h>
namespace Juliet
{
// Returns the path to the application directory
[[nodiscard]] extern JULIET_API String GetBasePath();
// Returns the path to the application directory
[[nodiscard]] extern JULIET_API String GetBasePath();
// Returns the resolved base path to the compiled shaders directory.
// In dev, this resolves to ../../Assets/compiled/ relative to the exe.
// In shipping, this resolves to Assets/Shaders/ next to the exe.
[[nodiscard]] extern JULIET_API String GetAssetBasePath();
// Returns the resolved base path to the compiled shaders directory.
// In dev, this resolves to ../../Assets/compiled/ relative to the exe.
// In shipping, this resolves to Assets/Shaders/ next to the exe.
[[nodiscard]] extern JULIET_API String GetAssetBasePath();
// Builds a full path to an asset file given its filename (e.g. "Triangle.vert.dxil").
// The caller owns the returned buffer and must free it.
[[nodiscard]] extern JULIET_API String GetAssetPath(NonNullPtr<Arena> arena, String filename);
// Builds a full path to an asset file given its filename (e.g. "Triangle.vert.dxil").
// The caller owns the returned buffer and must free it.
[[nodiscard]] extern JULIET_API String GetAssetPath(NonNullPtr<Arena> arena, String filename);
[[nodiscard]] extern JULIET_API bool IsAbsolutePath(String path);
} // namespace Juliet
[[nodiscard]] extern JULIET_API bool IsAbsolutePath(String path);
Juliet/include/Core/HAL/IO/IOStream.h
+47 -50
View File
@@ -1,69 +1,66 @@
#pragma once
#pragma once
#include <Core/Common/NonNullPtr.h>
#include <Core/Common/String.h>
#include <Juliet.h>
namespace Juliet
// Opaque type
struct IOStream;
struct IOStreamDataPayload
{
// Opaque type
struct IOStream;
};
struct IOStreamDataPayload
{
};
enum class IOStreamStatus : uint8
{
Ready,
Error,
EndOfFile,
NotReady,
ReadOnly,
WriteOnly
};
enum class IOStreamStatus : uint8
{
Ready,
Error,
EndOfFile,
NotReady,
ReadOnly,
WriteOnly
};
enum class IOStreamSeekPivot : uint8
{
Begin,
Current,
End,
Count
};
enum class IOStreamSeekPivot : uint8
{
Begin,
Current,
End,
Count
};
// IOStream can be opened on a file or memory, or anything else.
// Use the interface to make it transparent to the user.
struct IOStreamInterface
{
uint32 Version;
// IOStream can be opened on a file or memory, or anything else.
// Use the interface to make it transparent to the user.
struct IOStreamInterface
{
uint32 Version;
int64 (*Size)(NonNullPtr<IOStreamDataPayload> data);
int64 (*Size)(NonNullPtr<IOStreamDataPayload> data);
int64 (*Seek)(NonNullPtr<IOStreamDataPayload> data, int64 offset, IOStreamSeekPivot pivot);
size_t (*Read)(NonNullPtr<IOStreamDataPayload> data, void* outBuffer, size_t size, NonNullPtr<IOStreamStatus> status);
size_t (*Write)(NonNullPtr<IOStreamDataPayload> data, ByteBuffer inBuffer, NonNullPtr<IOStreamStatus> status);
bool (*Flush)(NonNullPtr<IOStreamDataPayload> data, NonNullPtr<IOStreamStatus> status);
int64 (*Seek)(NonNullPtr<IOStreamDataPayload> data, int64 offset, IOStreamSeekPivot pivot);
size_t (*Read)(NonNullPtr<IOStreamDataPayload> data, void* outBuffer, size_t size, NonNullPtr<IOStreamStatus> status);
size_t (*Write)(NonNullPtr<IOStreamDataPayload> data, ByteBuffer inBuffer, NonNullPtr<IOStreamStatus> status);
bool (*Flush)(NonNullPtr<IOStreamDataPayload> data, NonNullPtr<IOStreamStatus> status);
bool (*Close)(NonNullPtr<IOStreamDataPayload> data);
};
bool (*Close)(NonNullPtr<IOStreamDataPayload> data);
};
extern JULIET_API IOStream* IOFromFile(NonNullPtr<Arena> arena, String filename, String mode);
extern JULIET_API IOStream* IOFromFile(NonNullPtr<Arena> arena, String filename, String mode);
// Let you use an interface to open any io. Is used internally by IOFromFile
extern JULIET_API IOStream* IOFromInterface(NonNullPtr<Arena> arena, NonNullPtr<const IOStreamInterface> streamInterface,
NonNullPtr<IOStreamDataPayload> payload);
// Let you use an interface to open any io. Is used internally by IOFromFile
extern JULIET_API IOStream* IOFromInterface(NonNullPtr<Arena> arena, NonNullPtr<const IOStreamInterface> streamInterface,
NonNullPtr<IOStreamDataPayload> payload);
// Write formatted string into the stream.
extern JULIET_API size_t IOPrintf(NonNullPtr<IOStream> stream, _Printf_format_string_ const char* format, ...);
extern JULIET_API size_t IOWrite(NonNullPtr<IOStream> stream, ByteBuffer inBuffer);
// Write formatted string into the stream.
extern JULIET_API size_t IOPrintf(NonNullPtr<IOStream> stream, _Printf_format_string_ const char* format, ...);
extern JULIET_API size_t IOWrite(NonNullPtr<IOStream> stream, ByteBuffer inBuffer);
extern JULIET_API size_t IORead(NonNullPtr<IOStream> stream, void* ptr, size_t size);
extern JULIET_API int64 IOSeek(NonNullPtr<IOStream> stream, int64 offset, IOStreamSeekPivot pivot);
extern JULIET_API size_t IORead(NonNullPtr<IOStream> stream, void* ptr, size_t size);
extern JULIET_API int64 IOSeek(NonNullPtr<IOStream> stream, int64 offset, IOStreamSeekPivot pivot);
extern JULIET_API int64 IOSize(NonNullPtr<IOStream> stream);
extern JULIET_API int64 IOSize(NonNullPtr<IOStream> stream);
extern JULIET_API ByteBuffer LoadFile(NonNullPtr<Arena> arena, String filename);
extern JULIET_API ByteBuffer LoadFile(NonNullPtr<Arena> arena, NonNullPtr<IOStream> stream, bool closeStreamWhenDone);
extern JULIET_API ByteBuffer LoadFile(NonNullPtr<Arena> arena, String filename);
extern JULIET_API ByteBuffer LoadFile(NonNullPtr<Arena> arena, NonNullPtr<IOStream> stream, bool closeStreamWhenDone);
extern JULIET_API bool IOClose(NonNullPtr<IOStream> stream);
} // namespace Juliet
extern JULIET_API bool IOClose(NonNullPtr<IOStream> stream);
Juliet/include/Core/HAL/Keyboard/KeyCode.h
+184 -187
View File
@@ -1,193 +1,190 @@
#pragma once
#pragma once
#include <Core/Common/CoreTypes.h>
namespace Juliet
// Represents a Virtual Key corresponding to the Physical key, but localized using the keyboard layout
// ScanCode reprensent US ASCII Keyboard
// WASD Scan codes are ZQSD in KeyCode for French keyboard
// We use the ASCII value of the generated character as value, when possible.
// Keys that do not produce a character are converted to an abritrary value high enough to not conflict
// Reference: https://www.asciitable.com/
// Reference: https://learn.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-6.0/aa299374(v=vs.60)
enum class KeyCode : uint32
{
// Represents a Virtual Key corresponding to the Physical key, but localized using the keyboard layout
// ScanCode reprensent US ASCII Keyboard
// WASD Scan codes are ZQSD in KeyCode for French keyboard
// We use the ASCII value of the generated character as value, when possible.
// Keys that do not produce a character are converted to an abritrary value high enough to not conflict
// Reference: https://www.asciitable.com/
// Reference: https://learn.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-6.0/aa299374(v=vs.60)
enum class KeyCode : uint32
{
Unknown = 0x0, // 0
Unsupported = 0x0, // 0
Return = 0X0Du, // '\r'
Escape = 0X1Bu, // '\X1B'
Backspace = 0X08u, // '\b'
Tab = 0X09u, // '\t'
Space = 0X20u, // ' '
ExclamationPoint = 0X21u, // '!'
DoubleApostrophe = 0X22u, // '"'
Hash = 0X23u, // '#'
Dollar = 0X24u, // '$'
Percent = 0X25u, // '%'
Ampersand = 0X26u, // '&'
Apostrophe = 0X27u, // '\''
LeftParenthesis = 0X28u, // '('
RightParenthesis = 0X29u, // ')'
Asterisk = 0X2Au, // '*'
Plus = 0X2Bu, // '+'
Comma = 0X2Cu, // ','
Minus = 0X2Du, // '-'
Period = 0X2Eu, // '.'
Slash = 0X2Fu, // '/'
Num0 = 0X30u, // '0'
Num1 = 0X31u, // '1'
Num2 = 0X32u, // '2'
Num3 = 0X33u, // '3'
Num4 = 0X34u, // '4'
Num5 = 0X35u, // '5'
Num6 = 0X36u, // '6'
Num7 = 0X37u, // '7'
Num8 = 0X38u, // '8'
Num9 = 0X39u, // '9'
Colon = 0X3Au, // ':'
Semicolon = 0X3Bu, // ';'
LessThan = 0X3Cu, // '<'
Equals = 0X3Du, // '='
GreaterThan = 0X3Eu, // '>'
QuestionMark = 0X3Fu, // '?'
CommercialAt = 0x40u, // '@'
LeftBracket = 0X5Bu, // '['
Backslash = 0X5Cu, // '\\'
RightBracket = 0X5DU, // ']'
Caret = 0X5Eu, // '^'
Underscore = 0X5Fu, // '_'
GraveAccent = 0X60u, // '`'
A = 0x61u, // 'a'
B = 0x62u, // 'b'
C = 0x63u, // 'c'
D = 0x64u, // 'd'
E = 0x65u, // 'e'
F = 0x66u, // 'f'
G = 0x67u, // 'g'
H = 0x68u, // 'h'
I = 0x69u, // 'i'
J = 0x6Au, // 'j'
K = 0x6Bu, // 'k'
L = 0x6CU, // 'l'
M = 0x6DU, // 'm'
N = 0x6Eu, // 'n'
O = 0x6Fu, // 'o'
P = 0x70u, // 'p'
Q = 0x71u, // 'q'
R = 0x72u, // 'r'
S = 0x73u, // 's'
T = 0x74u, // 't'
U = 0x75u, // 'y'
V = 0x76u, // 'v'
W = 0x77u, // 'w'
X = 0x78u, // 'x'
Y = 0x79u, // 'y'
Z = 0x7Au, // 'z'
LeftBrace = 0x7BU, // '{'
Pipe = 0x7CU, // '|'
RightBrace = 0x7DU, // '}'
Tilde = 0x7Eu, // '~'
Delete = 0x7Fu, // '\x7F'
PlusMinus = 0xb1u, // '\xB1'
Unknown = 0x0, // 0
Unsupported = 0x0, // 0
Return = 0X0Du, // '\r'
Escape = 0X1Bu, // '\X1B'
Backspace = 0X08u, // '\b'
Tab = 0X09u, // '\t'
Space = 0X20u, // ' '
ExclamationPoint = 0X21u, // '!'
DoubleApostrophe = 0X22u, // '"'
Hash = 0X23u, // '#'
Dollar = 0X24u, // '$'
Percent = 0X25u, // '%'
Ampersand = 0X26u, // '&'
Apostrophe = 0X27u, // '\''
LeftParenthesis = 0X28u, // '('
RightParenthesis = 0X29u, // ')'
Asterisk = 0X2Au, // '*'
Plus = 0X2Bu, // '+'
Comma = 0X2Cu, // ','
Minus = 0X2Du, // '-'
Period = 0X2Eu, // '.'
Slash = 0X2Fu, // '/'
Num0 = 0X30u, // '0'
Num1 = 0X31u, // '1'
Num2 = 0X32u, // '2'
Num3 = 0X33u, // '3'
Num4 = 0X34u, // '4'
Num5 = 0X35u, // '5'
Num6 = 0X36u, // '6'
Num7 = 0X37u, // '7'
Num8 = 0X38u, // '8'
Num9 = 0X39u, // '9'
Colon = 0X3Au, // ':'
Semicolon = 0X3Bu, // ';'
LessThan = 0X3Cu, // '<'
Equals = 0X3Du, // '='
GreaterThan = 0X3Eu, // '>'
QuestionMark = 0X3Fu, // '?'
CommercialAt = 0x40u, // '@'
LeftBracket = 0X5Bu, // '['
Backslash = 0X5Cu, // '\\'
RightBracket = 0X5DU, // ']'
Caret = 0X5Eu, // '^'
Underscore = 0X5Fu, // '_'
GraveAccent = 0X60u, // '`'
A = 0x61u, // 'a'
B = 0x62u, // 'b'
C = 0x63u, // 'c'
D = 0x64u, // 'd'
E = 0x65u, // 'e'
F = 0x66u, // 'f'
G = 0x67u, // 'g'
H = 0x68u, // 'h'
I = 0x69u, // 'i'
J = 0x6Au, // 'j'
K = 0x6Bu, // 'k'
L = 0x6CU, // 'l'
M = 0x6DU, // 'm'
N = 0x6Eu, // 'n'
O = 0x6Fu, // 'o'
P = 0x70u, // 'p'
Q = 0x71u, // 'q'
R = 0x72u, // 'r'
S = 0x73u, // 's'
T = 0x74u, // 't'
U = 0x75u, // 'y'
V = 0x76u, // 'v'
W = 0x77u, // 'w'
X = 0x78u, // 'x'
Y = 0x79u, // 'y'
Z = 0x7Au, // 'z'
LeftBrace = 0x7BU, // '{'
Pipe = 0x7CU, // '|'
RightBrace = 0x7DU, // '}'
Tilde = 0x7Eu, // '~'
Delete = 0x7Fu, // '\x7F'
PlusMinus = 0xb1u, // '\xB1'
// Keys not producing a character
// Based on SDL Algo: ScanCode | 0x40000000
CapsLock = 0x40000039u,
F1 = 0x4000003Au,
F2 = 0x4000003Bu,
F3 = 0x4000003CU,
F4 = 0x4000003DU,
F5 = 0x4000003Eu,
F6 = 0x4000003Fu,
F7 = 0x40000040u,
F8 = 0x40000041u,
F9 = 0x40000042u,
F10 = 0x40000043u,
F11 = 0x40000044u,
F12 = 0x40000045u,
PrintScreen = 0x40000046u,
ScrollLock = 0x40000047u,
Pause = 0x40000048u,
Insert = 0x40000049u,
Home = 0x4000004Au,
PageUp = 0x4000004Bu,
End = 0x4000004DU,
PageDown = 0x4000004Eu,
RightArrow = 0x4000004Fu,
LeftArrow = 0x40000050u,
DownArrow = 0x40000051u,
UpArrow = 0x40000052u,
NumlockClear = 0x40000053u,
KeyPad_Divide = 0x40000054u,
KeyPad_Multiply = 0x40000055u,
KeyPad_Minus = 0x40000056u,
KeyPad_Plus = 0x40000057u,
KeyPad_Enter = 0x40000058u,
KeyPad_Num1 = 0x40000059u,
KeyPad_Num2 = 0x4000005Au,
KeyPad_Num3 = 0x4000005Bu,
KeyPad_Num4 = 0x4000005Cu,
KeyPad_Num5 = 0x4000005Du,
KeyPad_Num6 = 0x4000005Eu,
KeyPad_Num7 = 0x4000005Fu,
KeyPad_Num8 = 0x40000060u,
KeyPad_Num9 = 0x40000061u,
KeyPad_Num0 = 0x40000062u,
KeyPad_Period = 0x40000063u,
Power = 0x40000066u,
KeyPad_Equals = 0x40000067u,
F13 = 0x40000068u,
F14 = 0x40000069u,
F15 = 0x4000006Au,
F16 = 0x4000006Bu,
F17 = 0x4000006Cu,
F18 = 0x4000006Du,
F19 = 0x4000006Eu,
F20 = 0x4000006Fu,
F21 = 0x40000070u,
F22 = 0x40000071u,
F23 = 0x40000072u,
F24 = 0x40000073u,
Mute = 0x4000007Fu,
VolumeUp = 0x40000080u,
VolumeDown = 0x40000081u,
KeyPad_Comma = 0x40000085u,
LeftControl = 0x400000E0u,
LeftShift = 0x400000E1u,
LeftAlt = 0x400000E2u,
LeftOSCommand = 0x400000E3u,
RightControl = 0x400000E4u,
RightShift = 0x400000E5u,
RightAlt = 0x400000E6u,
RightOSCommand = 0x400000E7u,
Sleep = 0x40000102u,
WakeUp = 0x40000103u,
Media_NextTrack = 0x4000010Bu,
Media_PreviousTrack = 0x4000010Cu,
Media_Stop = 0x4000010Du,
Media_Eject = 0x4000010Eu,
Media_PlayPause = 0x4000010Fu,
Media_Select = 0x40000110u,
};
// Keys not producing a character
// Based on SDL Algo: ScanCode | 0x40000000
CapsLock = 0x40000039u,
F1 = 0x4000003Au,
F2 = 0x4000003Bu,
F3 = 0x4000003CU,
F4 = 0x4000003DU,
F5 = 0x4000003Eu,
F6 = 0x4000003Fu,
F7 = 0x40000040u,
F8 = 0x40000041u,
F9 = 0x40000042u,
F10 = 0x40000043u,
F11 = 0x40000044u,
F12 = 0x40000045u,
PrintScreen = 0x40000046u,
ScrollLock = 0x40000047u,
Pause = 0x40000048u,
Insert = 0x40000049u,
Home = 0x4000004Au,
PageUp = 0x4000004Bu,
End = 0x4000004DU,
PageDown = 0x4000004Eu,
RightArrow = 0x4000004Fu,
LeftArrow = 0x40000050u,
DownArrow = 0x40000051u,
UpArrow = 0x40000052u,
NumlockClear = 0x40000053u,
KeyPad_Divide = 0x40000054u,
KeyPad_Multiply = 0x40000055u,
KeyPad_Minus = 0x40000056u,
KeyPad_Plus = 0x40000057u,
KeyPad_Enter = 0x40000058u,
KeyPad_Num1 = 0x40000059u,
KeyPad_Num2 = 0x4000005Au,
KeyPad_Num3 = 0x4000005Bu,
KeyPad_Num4 = 0x4000005Cu,
KeyPad_Num5 = 0x4000005Du,
KeyPad_Num6 = 0x4000005Eu,
KeyPad_Num7 = 0x4000005Fu,
KeyPad_Num8 = 0x40000060u,
KeyPad_Num9 = 0x40000061u,
KeyPad_Num0 = 0x40000062u,
KeyPad_Period = 0x40000063u,
Power = 0x40000066u,
KeyPad_Equals = 0x40000067u,
F13 = 0x40000068u,
F14 = 0x40000069u,
F15 = 0x4000006Au,
F16 = 0x4000006Bu,
F17 = 0x4000006Cu,
F18 = 0x4000006Du,
F19 = 0x4000006Eu,
F20 = 0x4000006Fu,
F21 = 0x40000070u,
F22 = 0x40000071u,
F23 = 0x40000072u,
F24 = 0x40000073u,
Mute = 0x4000007Fu,
VolumeUp = 0x40000080u,
VolumeDown = 0x40000081u,
KeyPad_Comma = 0x40000085u,
LeftControl = 0x400000E0u,
LeftShift = 0x400000E1u,
LeftAlt = 0x400000E2u,
LeftOSCommand = 0x400000E3u,
RightControl = 0x400000E4u,
RightShift = 0x400000E5u,
RightAlt = 0x400000E6u,
RightOSCommand = 0x400000E7u,
Sleep = 0x40000102u,
WakeUp = 0x40000103u,
Media_NextTrack = 0x4000010Bu,
Media_PreviousTrack = 0x4000010Cu,
Media_Stop = 0x4000010Du,
Media_Eject = 0x4000010Eu,
Media_PlayPause = 0x4000010Fu,
Media_Select = 0x40000110u,
};
enum class KeyMod : uint16
{
None = 0b0,
LeftShift = 0b0000'0000'0001u,
RightShift = 0b0000'0000'0010u,
LeftControl = 0b0000'0000'0100u,
RightControl = 0b0000'0000'1000u,
LeftAlt = 0b0000'0001'000u,
RightAlt = 0b0000'0010'0000u,
LeftOSCommand = 0b0000'0100'0000u,
RightOSCommand = 0b0000'1000'0000u,
NumLock = 0b0001'0000'0000u,
CapsLock = 0b0010'0000'0000u,
ScrollLock = 0b0100'0000'0000u,
Control = LeftControl | RightControl,
Shift = LeftShift | RightShift,
Alt = LeftAlt | RightAlt,
OSCommand = LeftOSCommand | RightOSCommand,
};
} // namespace Juliet
enum class KeyMod : uint16
{
None = 0b0,
LeftShift = 0b0000'0000'0001u,
RightShift = 0b0000'0000'0010u,
LeftControl = 0b0000'0000'0100u,
RightControl = 0b0000'0000'1000u,
LeftAlt = 0b0000'0001'000u,
RightAlt = 0b0000'0010'0000u,
LeftOSCommand = 0b0000'0100'0000u,
RightOSCommand = 0b0000'1000'0000u,
NumLock = 0b0001'0000'0000u,
CapsLock = 0b0010'0000'0000u,
ScrollLock = 0b0100'0000'0000u,
Control = LeftControl | RightControl,
Shift = LeftShift | RightShift,
Alt = LeftAlt | RightAlt,
OSCommand = LeftOSCommand | RightOSCommand,
};
Juliet/include/Core/HAL/Keyboard/Keyboard.h
+22 -25
View File
@@ -1,35 +1,32 @@
#pragma once
#pragma once
#include <Core/HAL/Keyboard/KeyCode.h>
#include <Core/HAL/Keyboard/ScanCode.h>
#include <Juliet.h>
namespace Juliet
using KeyboardID = uint8;
enum class KeyPosition : bool
{
using KeyboardID = uint8;
Up = false,
Down = true
};
enum class KeyPosition : bool
{
Up = false,
Down = true
};
struct KeyState
{
KeyPosition Position;
float Time;
};
struct KeyState
{
KeyPosition Position;
float Time;
};
struct Key
{
ScanCode ScanCode;
KeyCode KeyCode;
uint16 Raw;
};
struct Key
{
ScanCode ScanCode;
KeyCode KeyCode;
uint16 Raw;
};
extern JULIET_API bool IsKeyDown(ScanCode scanCode);
extern JULIET_API bool IsKeyPressed(ScanCode scanCode);
extern JULIET_API bool IsKeyDown(ScanCode scanCode);
extern JULIET_API bool IsKeyPressed(ScanCode scanCode);
extern JULIET_API KeyMod GetKeyModState();
extern JULIET_API KeyCode GetKeyCodeFromScanCode(ScanCode scanCode, KeyMod keyModState);
} // namespace Juliet
extern JULIET_API KeyMod GetKeyModState();
extern JULIET_API KeyCode GetKeyCodeFromScanCode(ScanCode scanCode, KeyMod keyModState);
Juliet/include/Core/HAL/Keyboard/ScanCode.h
+162 -165
View File
@@ -1,186 +1,183 @@
#pragma once
#pragma once
namespace Juliet
// Follow the HID Usage page for USB
// https://usb.org/sites/default/files/hut1_5.pdf
// 0 to 256 Is dedicated to Keyboard Usage Page (0x07)
// 257 to 286 Is dedicated to Consumer Usage Page (0xC)
// 287 to 511 Is not implemented. Could be used for Mobile or Consoles
// ScanCode reprensent Physical Keys and Buttons
enum class ScanCode : uint16
{
// Follow the HID Usage page for USB
// https://usb.org/sites/default/files/hut1_5.pdf
// 0 to 256 Is dedicated to Keyboard Usage Page (0x07)
// 257 to 286 Is dedicated to Consumer Usage Page (0xC)
// 287 to 511 Is not implemented. Could be used for Mobile or Consoles
// ScanCode reprensent Physical Keys and Buttons
enum class ScanCode : uint16
{
Unknown = 0,
Unsupported = 0,
Unknown = 0,
Unsupported = 0,
A = 4,
B = 5,
C = 6,
D = 7,
E = 8,
F = 9,
G = 10,
H = 11,
I = 12,
J = 13,
K = 14,
L = 15,
M = 16,
N = 17,
O = 18,
P = 19,
Q = 20,
R = 21,
S = 22,
T = 23,
U = 24,
V = 25,
W = 26,
X = 27,
Y = 28,
Z = 29,
A = 4,
B = 5,
C = 6,
D = 7,
E = 8,
F = 9,
G = 10,
H = 11,
I = 12,
J = 13,
K = 14,
L = 15,
M = 16,
N = 17,
O = 18,
P = 19,
Q = 20,
R = 21,
S = 22,
T = 23,
U = 24,
V = 25,
W = 26,
X = 27,
Y = 28,
Z = 29,
Num1 = 30,
Num2 = 31,
Num3 = 32,
Num4 = 33,
Num5 = 34,
Num6 = 35,
Num7 = 36,
Num8 = 37,
Num9 = 38,
Num0 = 39,
Num1 = 30,
Num2 = 31,
Num3 = 32,
Num4 = 33,
Num5 = 34,
Num6 = 35,
Num7 = 36,
Num8 = 37,
Num9 = 38,
Num0 = 39,
Return = 40,
Escape = 41,
Backspace = 42,
Tab = 43,
Space = 44,
Return = 40,
Escape = 41,
Backspace = 42,
Tab = 43,
Space = 44,
Minus = 45,
Equals = 46,
LeftBracket = 47,
RightBracket = 48,
Backslash = 49,
NonUSHash = 50, // Same as 49 but for ISO keyboards
Semicolon = 51,
Apostrophe = 52,
GraveAccent = 53,
Comma = 54,
Period = 55,
Slash = 56,
CapsLock = 57,
Minus = 45,
Equals = 46,
LeftBracket = 47,
RightBracket = 48,
Backslash = 49,
NonUSHash = 50, // Same as 49 but for ISO keyboards
Semicolon = 51,
Apostrophe = 52,
GraveAccent = 53,
Comma = 54,
Period = 55,
Slash = 56,
CapsLock = 57,
F1 = 58,
F2 = 59,
F3 = 60,
F4 = 61,
F5 = 62,
F6 = 63,
F7 = 64,
F8 = 65,
F9 = 66,
F10 = 67,
F11 = 68,
F12 = 69,
F1 = 58,
F2 = 59,
F3 = 60,
F4 = 61,
F5 = 62,
F6 = 63,
F7 = 64,
F8 = 65,
F9 = 66,
F10 = 67,
F11 = 68,
F12 = 69,
PrintScreen = 70,
ScrollLock = 71,
Pause = 72,
Insert = 73,
PrintScreen = 70,
ScrollLock = 71,
Pause = 72,
Insert = 73,
Home = 74,
PageUp = 75,
Delete = 76,
End = 77,
PageDown = 78,
RightArrow = 79,
LeftArrow = 80,
DownArrow = 81,
UpArrow = 82,
Home = 74,
PageUp = 75,
Delete = 76,
End = 77,
PageDown = 78,
RightArrow = 79,
LeftArrow = 80,
DownArrow = 81,
UpArrow = 82,
NumlockClear = 83, // Pc = Numlock / Mac = Clear
NumlockClear = 83, // Pc = Numlock / Mac = Clear
KeyPad_Divide = 84,
KeyPad_Multiply = 85,
KeyPad_Minus = 86,
KeyPad_Plus = 87,
KeyPad_Enter = 88,
KeyPad_Num1 = 89,
KeyPad_Num2 = 90,
KeyPad_Num3 = 91,
KeyPad_Num4 = 92,
KeyPad_Num5 = 93,
KeyPad_Num6 = 94,
KeyPad_Num7 = 95,
KeyPad_Num8 = 96,
KeyPad_Num9 = 97,
KeyPad_Num0 = 98,
KeyPad_Period = 99,
KeyPad_Divide = 84,
KeyPad_Multiply = 85,
KeyPad_Minus = 86,
KeyPad_Plus = 87,
KeyPad_Enter = 88,
KeyPad_Num1 = 89,
KeyPad_Num2 = 90,
KeyPad_Num3 = 91,
KeyPad_Num4 = 92,
KeyPad_Num5 = 93,
KeyPad_Num6 = 94,
KeyPad_Num7 = 95,
KeyPad_Num8 = 96,
KeyPad_Num9 = 97,
KeyPad_Num0 = 98,
KeyPad_Period = 99,
NonUSBackslash = 100, // ISO keyboards only
Power = 102, // Some mac have a Power key
NonUSBackslash = 100, // ISO keyboards only
Power = 102, // Some mac have a Power key
KeyPad_Equals = 103,
F13 = 104,
F14 = 105,
F15 = 106,
F16 = 107,
F17 = 108,
F18 = 109,
F19 = 110,
F20 = 111,
F21 = 112,
F22 = 113,
F23 = 114,
F24 = 115,
KeyPad_Equals = 103,
F13 = 104,
F14 = 105,
F15 = 106,
F16 = 107,
F17 = 108,
F18 = 109,
F19 = 110,
F20 = 111,
F21 = 112,
F22 = 113,
F23 = 114,
F24 = 115,
Mute = 127,
VolumeUp = 128,
VolumeDown = 129,
Mute = 127,
VolumeUp = 128,
VolumeDown = 129,
KeyPad_Comma = 133,
KeyPad_Comma = 133,
International1 = 135, // Mostly used on Asian keyboards
International2 = 136,
International3 = 137, // Yen Symbol
International4 = 138,
International5 = 139,
International6 = 140,
International7 = 141,
International8 = 142,
International9 = 143,
Lang1 = 144, // Hangul (Korean)
Lang2 = 145, // Hanja (Korean)
Lang3 = 146, // Katakana (Japanese)
Lang4 = 147, // Hiragana (Japanese)
Lang5 = 148, // Zenkaku/Hankaku (Japanese)
Lang6 = 149, // Unused
Lang7 = 150, // Unused
Lang8 = 151, // Unused
Lang9 = 152, // Unused
International1 = 135, // Mostly used on Asian keyboards
International2 = 136,
International3 = 137, // Yen Symbol
International4 = 138,
International5 = 139,
International6 = 140,
International7 = 141,
International8 = 142,
International9 = 143,
Lang1 = 144, // Hangul (Korean)
Lang2 = 145, // Hanja (Korean)
Lang3 = 146, // Katakana (Japanese)
Lang4 = 147, // Hiragana (Japanese)
Lang5 = 148, // Zenkaku/Hankaku (Japanese)
Lang6 = 149, // Unused
Lang7 = 150, // Unused
Lang8 = 151, // Unused
Lang9 = 152, // Unused
LeftControl = 224,
LeftShift = 225,
LeftAlt = 226, // Alt for PC, Option for Mac
LeftOSCommand = 227, // Window key for PC, Command for Mac
RightControl = 228,
RightShift = 229,
RightAlt = 230, // Alt Gr for PC, Option for Mac
RightOSCommand = 231, // Window key for PC, Command for Mac
LeftControl = 224,
LeftShift = 225,
LeftAlt = 226, // Alt for PC, Option for Mac
LeftOSCommand = 227, // Window key for PC, Command for Mac
RightControl = 228,
RightShift = 229,
RightAlt = 230, // Alt Gr for PC, Option for Mac
RightOSCommand = 231, // Window key for PC, Command for Mac
Sleep = 258,
WakeUp = 259,
Sleep = 258,
WakeUp = 259,
Media_NextTrack = 267,
Media_PreviousTrack = 268,
Media_Stop = 269,
Media_Eject = 270,
Media_PlayPause = 271,
Media_Select = 272,
Media_NextTrack = 267,
Media_PreviousTrack = 268,
Media_Stop = 269,
Media_Eject = 270,
Media_PlayPause = 271,
Media_Select = 272,
Reserved = 287,
Reserved = 287,
Count = 512
};
} // namespace Juliet
Count = 512
};
Juliet/include/Core/HAL/Mouse/Mouse.h
+21 -24
View File
@@ -1,28 +1,25 @@
#pragma once
#pragma once
namespace Juliet
using MouseID = uint8;
enum class MouseButton : uint8
{
using MouseID = uint8;
None = 0,
Left = 1 << 0,
Right = 1 << 1,
Middle = 1 << 2,
Button1 = 1 << 3,
Button2 = 1 << 4,
};
enum class MouseButton : uint8
{
None = 0,
Left = 1 << 0,
Right = 1 << 1,
Middle = 1 << 2,
Button1 = 1 << 3,
Button2 = 1 << 4,
};
// TODO : Replace by Vector2f
struct MousePosition
{
float X;
float Y;
};
// TODO : Replace by Vector2f
struct MousePosition
{
float X;
float Y;
};
JULIET_API extern bool IsMouseButtonDown(MouseButton button);
JULIET_API extern MousePosition GetMousePosition();
JULIET_API extern MousePosition GetMouseDelta();
JULIET_API extern MouseButton GetMouseButtonState();
} // namespace Juliet
JULIET_API extern bool IsMouseButtonDown(MouseButton button);
JULIET_API extern MousePosition GetMousePosition();
JULIET_API extern MousePosition GetMouseDelta();
JULIET_API extern MouseButton GetMouseButtonState();
Juliet/include/Core/HAL/OS/OS.h
+35 -38
View File
@@ -1,49 +1,46 @@
#pragma once
#pragma once
#include <Core/Common/CoreTypes.h>
#include <Juliet.h>
namespace Juliet
namespace Memory
{
namespace Memory
Byte* OS_Reserve(size_t size);
bool OS_Commit(Byte* ptr, size_t size);
void OS_Release(Byte* ptr, size_t size);
template <typename Type>
Type* OS_Reserve(size_t size)
{
Byte* OS_Reserve(size_t size);
bool OS_Commit(Byte* ptr, size_t size);
void OS_Release(Byte* ptr, size_t size);
return reinterpret_cast<Type*>(OS_Reserve(size));
}
template <typename Type>
Type* OS_Reserve(size_t size)
{
return reinterpret_cast<Type*>(OS_Reserve(size));
}
template <typename Type>
bool OS_Commit(Type* ptr, size_t size)
{
return OS_Commit(reinterpret_cast<Byte*>(ptr), size);
}
template <typename Type>
void OS_Release(Type* ptr, size_t size)
{
OS_Release(reinterpret_cast<Byte*>(ptr), size);
}
} // namespace Memory
namespace Time
template <typename Type>
bool OS_Commit(Type* ptr, size_t size)
{
uint64 Timestamp();
void ComputeDeltaTime();
float GetDeltaTime();
uint64 GetFrameNumber();
} // namespace Time
return OS_Commit(reinterpret_cast<Byte*>(ptr), size);
}
namespace Debug
template <typename Type>
void OS_Release(Type* ptr, size_t size)
{
JULIET_API bool IsDebuggerPresent();
} // namespace Debug
OS_Release(reinterpret_cast<Byte*>(ptr), size);
}
using EntryPointFunc = int (*)(int, wchar_t**);
JULIET_API int Bootstrap(EntryPointFunc entryPointFunc, int argc, wchar_t** argv);
} // namespace Juliet
} // namespace Memory
namespace Time
{
uint64 Timestamp();
void ComputeDeltaTime();
float GetDeltaTime();
uint64 GetFrameNumber();
} // namespace Time
namespace Debug
{
JULIET_API bool IsDebuggerPresent();
} // namespace Debug
using EntryPointFunc = int (*)(int, wchar_t**);
JULIET_API int Bootstrap(EntryPointFunc entryPointFunc, int argc, wchar_t** argv);
Juliet/include/Core/HotReload/HotReload.h
+23 -26
View File
@@ -1,38 +1,35 @@
#pragma once
#pragma once
#include <Core/Common/String.h>
namespace Juliet
// Fwd Declare
struct DynamicLibrary;
struct HotReloadCode
{
// Fwd Declare
struct DynamicLibrary;
String DLLFullPath;
String LockFullPath;
String TransientDLLName;
struct HotReloadCode
{
String DLLFullPath;
String LockFullPath;
String TransientDLLName;
uint64 LastWriteTime;
uint64 LastWriteTime;
DynamicLibrary* Dll;
DynamicLibrary* Dll;
void** Functions;
const char** FunctionNames;
uint32 FunctionCount;
void** Functions;
const char** FunctionNames;
uint32 FunctionCount;
uint32 UniqueID;
uint32 UniqueID;
bool IsValid : 1;
};
bool IsValid : 1;
};
extern JULIET_API void InitHotReloadCode(NonNullPtr<Arena> arena, HotReloadCode& code, String dllName,
String transientDllName, String lockFilename);
extern JULIET_API void ShutdownHotReloadCode(HotReloadCode& code);
extern JULIET_API void InitHotReloadCode(NonNullPtr<Arena> arena, HotReloadCode& code, String dllName,
String transientDllName, String lockFilename);
extern JULIET_API void ShutdownHotReloadCode(HotReloadCode& code);
extern JULIET_API void LoadCode(HotReloadCode& code);
extern JULIET_API void UnloadCode(HotReloadCode& code);
extern JULIET_API void LoadCode(HotReloadCode& code);
extern JULIET_API void UnloadCode(HotReloadCode& code);
extern JULIET_API void ReloadCode(HotReloadCode& code);
extern JULIET_API bool ShouldReloadCode(const HotReloadCode& code);
} // namespace Juliet
extern JULIET_API void ReloadCode(HotReloadCode& code);
extern JULIET_API bool ShouldReloadCode(const HotReloadCode& code);
Juliet/include/Core/ImGui/ImGuiService.h
+14 -17
View File
@@ -1,4 +1,4 @@
#pragma once
#pragma once
#include <Core/Common/CoreTypes.h>
#include <Core/Common/NonNullPtr.h>
@@ -7,25 +7,22 @@
struct ImGuiContext;
namespace Juliet
struct Window;
struct GraphicsDevice;
namespace ImGuiService
{
struct Window;
struct GraphicsDevice;
JULIET_API void Initialize(NonNullPtr<Window> window);
JULIET_API void Shutdown();
namespace ImGuiService
{
JULIET_API void Initialize(NonNullPtr<Window> window);
JULIET_API void Shutdown();
JULIET_API void NewFrame();
JULIET_API void Render();
JULIET_API void NewFrame();
JULIET_API void Render();
JULIET_API bool IsInitialized();
JULIET_API ImGuiContext* GetContext();
JULIET_API bool IsInitialized();
JULIET_API ImGuiContext* GetContext();
// Run internal unit tests
JULIET_API void RunTests();
} // namespace ImGuiService
} // namespace Juliet
// Run internal unit tests
JULIET_API void RunTests();
} // namespace ImGuiService
#endif // JULIET_ENABLE_IMGUI
Juliet/include/Core/ImGui/ImGuiTests.h
+2 -2
View File
@@ -1,4 +1,4 @@
#pragma once
#pragma once
#include <Core/Common/NonNullPtr.h>
#include <Core/HAL/Display/Window.h>
@@ -6,7 +6,7 @@
#include <Juliet.h>
namespace Juliet::UnitTest
namespace UnitTest
{
void TestImGui();
}
Juliet/include/Core/JulietInit.h
+16 -19
View File
@@ -1,26 +1,23 @@
#pragma once
#pragma once
#include <Core/Common/CoreTypes.h>
namespace Juliet
enum class JulietInit_Flags : uint8
{
enum class JulietInit_Flags : uint8
{
None = 0,
Display = 1 << 0,
Audio = 1 << 1,
Count = Audio,
All = 0xFb
};
None = 0,
Display = 1 << 0,
Audio = 1 << 1,
Count = Audio,
All = 0xFb
};
struct Arena;
struct Arena;
struct GameData
{
struct GameState* GameState;
Arena* ScratchArena;
};
struct GameData
{
struct GameState* GameState;
Arena* ScratchArena;
};
void JulietInit(JulietInit_Flags flags);
void JulietShutdown();
} // namespace Juliet
void JulietInit(JulietInit_Flags flags);
void JulietShutdown();
Juliet/include/Core/Logging/LogManager.h
+13 -16
View File
@@ -1,4 +1,4 @@
#pragma once
#pragma once
#include <Core/Common/CoreTypes.h>
#include <Core/Common/NonNullPtr.h>
@@ -9,21 +9,18 @@
// TODO Juliet Containers + Allocators...
// TODO: Juliet chrono, because it prevents me from doing #define global static
namespace Juliet
{
enum class LogLevel : uint8;
enum class LogCategory : uint8;
enum class LogLevel : uint8;
enum class LogCategory : uint8;
extern void JULIET_API InitializeLogManager();
extern void JULIET_API ShutdownLogManager();
extern void JULIET_API InitializeLogManager();
extern void JULIET_API ShutdownLogManager();
extern void JULIET_API LogScopeBegin();
// TODO everything that happened in there to export them to file or something
extern void JULIET_API LogScopeEnd();
extern void JULIET_API LogScopeBegin();
// TODO everything that happened in there to export them to file or something
extern void JULIET_API LogScopeEnd();
extern void JULIET_API Log(LogLevel level, LogCategory category, const char* fmt, ...);
extern void JULIET_API LogDebug(LogCategory category, const char* fmt, ...);
extern void JULIET_API LogMessage(LogCategory category, const char* fmt, ...);
extern void JULIET_API LogWarning(LogCategory category, const char* fmt, ...);
extern void JULIET_API LogError(LogCategory category, const char* fmt, ...);
} // namespace Juliet
extern void JULIET_API Log(LogLevel level, LogCategory category, const char* fmt, ...);
extern void JULIET_API LogDebug(LogCategory category, const char* fmt, ...);
extern void JULIET_API LogMessage(LogCategory category, const char* fmt, ...);
extern void JULIET_API LogWarning(LogCategory category, const char* fmt, ...);
extern void JULIET_API LogError(LogCategory category, const char* fmt, ...);
Juliet/include/Core/Logging/LogTypes.h
+16 -19
View File
@@ -1,22 +1,19 @@
#pragma once
#pragma once
namespace Juliet
enum class LogLevel : uint8
{
enum class LogLevel : uint8
{
Debug = 0,
Message = 1,
Warning = 2,
Error = 3,
};
Debug = 0,
Message = 1,
Warning = 2,
Error = 3,
};
enum class LogCategory : uint8
{
Core = 0,
Graphics = 1,
Networking = 2,
Engine = 3,
Tool = 4,
Game = 5,
};
} // namespace Juliet
enum class LogCategory : uint8
{
Core = 0,
Graphics = 1,
Networking = 2,
Engine = 3,
Tool = 4,
Game = 5,
};
Juliet/include/Core/Main.h
+4 -4
View File
@@ -1,4 +1,4 @@
#pragma once
#pragma once
#include <Core/HAL/OS/OS.h>
@@ -12,12 +12,12 @@ extern int JulietMain(int, wchar_t**);
#if UNICODE
int wmain(int argc, wchar_t** argv)
{
return Juliet::Bootstrap(JulietMain, argc, argv);
return Bootstrap(JulietMain, argc, argv);
}
#else
int main(int argc, char** argv)
{
return Juliet::Bootstrap(JulietMain, argc, argv);
return Bootstrap(JulietMain, argc, argv);
}
#endif
@@ -38,7 +38,7 @@ int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR szCmdLine, int sw)
(void)szCmdLine;
(void)sw;
return Juliet::Bootstrap(JulietMain, __argc, __wargv);
return Bootstrap(JulietMain, __argc, __wargv);
}
}
#else
Juliet/include/Core/Math/MathUtils.h
+35 -38
View File
@@ -1,52 +1,49 @@
#pragma once
#pragma once
#include <Core/Common/CoreTypes.h>
#include <Juliet.h>
namespace Juliet
extern JULIET_API float RoundF(float value);
inline int32 LRoundF(float value)
{
extern JULIET_API float RoundF(float value);
return static_cast<int32>(RoundF(value));
}
inline int32 LRoundF(float value)
{
return static_cast<int32>(RoundF(value));
}
template <typename Type>
constexpr Type Min(Type lhs, Type rhs)
{
return rhs < lhs ? rhs : lhs;
}
template <typename Type>
constexpr Type Min(Type lhs, Type rhs)
{
return rhs < lhs ? rhs : lhs;
}
template <typename Type>
constexpr Type Max(Type lhs, Type rhs)
{
return lhs < rhs ? rhs : lhs;
}
template <typename Type>
constexpr Type Max(Type lhs, Type rhs)
{
return lhs < rhs ? rhs : lhs;
}
template <typename Type>
constexpr Type ClampTop(Type value, Type X)
{
return Min(value, X);
}
template <typename Type>
constexpr Type ClampTop(Type value, Type X)
{
return Min(value, X);
}
template <typename Type>
constexpr Type ClampBottom(Type value, Type X)
{
return Max(value, X);
}
template <typename Type>
constexpr Type ClampBottom(Type value, Type X)
template <typename Type>
constexpr Type Clamp(Type val, Type min, Type max)
{
if (val < min)
{
return Max(value, X);
return min;
}
template <typename Type>
constexpr Type Clamp(Type val, Type min, Type max)
if (val > max)
{
if (val < min)
{
return min;
}
if (val > max)
{
return max;
}
return val;
return max;
}
} // namespace Juliet
return val;
}
Juliet/include/Core/Math/Matrix.h
+174 -177
View File
@@ -1,194 +1,191 @@
#pragma once
#pragma once
#include <Core/Math/Vector.h>
#include <math.h>
namespace Juliet
struct Matrix
{
struct Matrix
{
float m[4][4];
};
float m[4][4];
};
[[nodiscard]] inline Matrix MatrixIdentity()
{
Matrix result = {};
result.m[0][0] = 1.0f;
result.m[1][1] = 1.0f;
result.m[2][2] = 1.0f;
result.m[3][3] = 1.0f;
return result;
}
[[nodiscard]] inline Matrix MatrixIdentity()
{
Matrix result = {};
result.m[0][0] = 1.0f;
result.m[1][1] = 1.0f;
result.m[2][2] = 1.0f;
result.m[3][3] = 1.0f;
return result;
}
[[nodiscard]] inline Matrix operator*(const Matrix& lhs, const Matrix& rhs)
[[nodiscard]] inline Matrix operator*(const Matrix& lhs, const Matrix& rhs)
{
Matrix result = {};
for (int i = 0; i < 4; ++i)
{
Matrix result = {};
for (int i = 0; i < 4; ++i)
for (int j = 0; j < 4; ++j)
{
for (int j = 0; j < 4; ++j)
for (int k = 0; k < 4; ++k)
{
for (int k = 0; k < 4; ++k)
{
result.m[i][j] += lhs.m[i][k] * rhs.m[k][j];
}
result.m[i][j] += lhs.m[i][k] * rhs.m[k][j];
}
}
return result;
}
return result;
}
[[nodiscard]] inline Matrix MatrixTranslation(float x, float y, float z)
[[nodiscard]] inline Matrix MatrixTranslation(float x, float y, float z)
{
Matrix result = MatrixIdentity();
result.m[0][3] = x;
result.m[1][3] = y;
result.m[2][3] = z;
return result;
}
[[nodiscard]] inline Matrix MatrixScale(float x, float y, float z)
{
Matrix result = MatrixIdentity();
result.m[0][0] = x;
result.m[1][1] = y;
result.m[2][2] = z;
return result;
}
[[nodiscard]] inline Matrix MatrixRotationX(float radians)
{
float c = cosf(radians);
float s = sinf(radians);
Matrix result = MatrixIdentity();
result.m[1][1] = c;
result.m[1][2] = -s;
result.m[2][1] = s;
result.m[2][2] = c;
return result;
}
[[nodiscard]] inline Matrix MatrixRotationY(float radians)
{
float c = cosf(radians);
float s = sinf(radians);
Matrix result = MatrixIdentity();
result.m[0][0] = c;
result.m[0][2] = s;
result.m[2][0] = -s;
result.m[2][2] = c;
return result;
}
[[nodiscard]] inline Matrix MatrixRotationZ(float radians)
{
float c = cosf(radians);
float s = sinf(radians);
Matrix result = MatrixIdentity();
result.m[0][0] = c;
result.m[0][1] = -s;
result.m[1][0] = s;
result.m[1][1] = c;
return result;
}
inline void MatrixTranslate(Matrix& m, const Vector3& v)
{
m.m[0][3] += v.x;
m.m[1][3] += v.y;
m.m[2][3] += v.z;
}
[[nodiscard]] inline Matrix MatrixRotation(float x, float y, float z)
{
return MatrixRotationX(x) * MatrixRotationY(y) * MatrixRotationZ(z);
}
inline Matrix LookAt(const Vector3& eye, const Vector3& target, const Vector3& up)
{
// Left-Handed convention
Vector3 zaxis = Normalize(target - eye); // Forward is +z
Vector3 xaxis = Normalize(Cross(up, zaxis));
Vector3 yaxis = Cross(zaxis, xaxis);
Matrix result = {};
// Row 0
result.m[0][0] = xaxis.x;
result.m[0][1] = xaxis.y;
result.m[0][2] = xaxis.z;
result.m[0][3] = -Dot(xaxis, eye);
// Row 1
result.m[1][0] = yaxis.x;
result.m[1][1] = yaxis.y;
result.m[1][2] = yaxis.z;
result.m[1][3] = -Dot(yaxis, eye);
// Row 2
result.m[2][0] = zaxis.x;
result.m[2][1] = zaxis.y;
result.m[2][2] = zaxis.z;
result.m[2][3] = -Dot(zaxis, eye);
// Row 3
result.m[3][3] = 1.0f;
return result;
}
inline Matrix PerspectiveFov(float fovY, float aspectRatio, float nearZ, float farZ)
{
// Left-Handed Perspective
float yScale = 1.0f / tanf(fovY * 0.5f);
float xScale = yScale / aspectRatio;
Matrix result = {};
result.m[0][0] = xScale;
result.m[1][1] = yScale;
result.m[2][2] = farZ / (farZ - nearZ);
result.m[2][3] = (-nearZ * farZ) / (farZ - nearZ);
result.m[3][2] = 1.0f;
result.m[3][3] = 0.0f;
return result;
}
[[nodiscard]] inline Matrix MatrixInverse(const Matrix& m)
{
Matrix out = {};
float m00 = m.m[0][0], m01 = m.m[0][1], m02 = m.m[0][2], m03 = m.m[0][3];
float m10 = m.m[1][0], m11 = m.m[1][1], m12 = m.m[1][2], m13 = m.m[1][3];
float m20 = m.m[2][0], m21 = m.m[2][1], m22 = m.m[2][2], m23 = m.m[2][3];
float m30 = m.m[3][0], m31 = m.m[3][1], m32 = m.m[3][2], m33 = m.m[3][3];
out.m[0][0] = m11 * m22 * m33 - m11 * m23 * m32 - m21 * m12 * m33 + m21 * m13 * m32 + m31 * m12 * m23 - m31 * m13 * m22;
out.m[1][0] = -m10 * m22 * m33 + m10 * m23 * m32 + m20 * m12 * m33 - m20 * m13 * m32 - m30 * m12 * m23 + m30 * m13 * m22;
out.m[2][0] = m10 * m21 * m33 - m10 * m23 * m31 - m20 * m11 * m33 + m20 * m13 * m31 + m30 * m11 * m23 - m30 * m13 * m21;
out.m[3][0] = -m10 * m21 * m32 + m10 * m22 * m31 + m20 * m11 * m32 - m20 * m12 * m31 - m30 * m11 * m22 + m30 * m12 * m21;
out.m[0][1] = -m01 * m22 * m33 + m01 * m23 * m32 + m21 * m02 * m33 - m21 * m03 * m32 - m31 * m02 * m23 + m31 * m03 * m22;
out.m[1][1] = m00 * m22 * m33 - m00 * m23 * m32 - m20 * m02 * m33 + m20 * m03 * m32 + m30 * m02 * m23 - m30 * m03 * m22;
out.m[2][1] = -m00 * m21 * m33 + m00 * m23 * m31 + m20 * m01 * m33 - m20 * m03 * m31 - m30 * m01 * m23 + m30 * m03 * m21;
out.m[3][1] = m00 * m21 * m32 - m00 * m22 * m31 - m20 * m01 * m32 + m20 * m02 * m31 + m30 * m01 * m22 - m30 * m02 * m21;
out.m[0][2] = m01 * m12 * m33 - m01 * m13 * m32 - m11 * m02 * m33 + m11 * m03 * m32 + m31 * m02 * m13 - m31 * m03 * m12;
out.m[1][2] = -m00 * m12 * m33 + m00 * m13 * m32 + m10 * m02 * m33 - m10 * m03 * m32 - m30 * m02 * m13 + m30 * m03 * m12;
out.m[2][2] = m00 * m11 * m33 - m00 * m13 * m31 - m10 * m01 * m33 + m10 * m03 * m31 + m30 * m01 * m13 - m30 * m03 * m11;
out.m[3][2] = -m00 * m11 * m32 + m00 * m12 * m31 + m10 * m01 * m32 - m10 * m02 * m31 - m30 * m01 * m12 + m30 * m02 * m11;
out.m[0][3] = -m01 * m12 * m23 + m01 * m13 * m22 + m11 * m02 * m23 - m11 * m03 * m22 - m21 * m02 * m13 + m21 * m03 * m12;
out.m[1][3] = m00 * m12 * m23 - m00 * m13 * m22 - m10 * m02 * m23 + m10 * m03 * m22 + m20 * m02 * m13 - m20 * m03 * m12;
out.m[2][3] = -m00 * m11 * m23 + m00 * m13 * m21 + m10 * m01 * m23 - m10 * m03 * m21 - m20 * m01 * m13 + m20 * m03 * m11;
out.m[3][3] = m00 * m11 * m22 - m00 * m12 * m21 - m10 * m01 * m22 + m10 * m02 * m21 + m20 * m01 * m12 - m20 * m02 * m11;
float det = m00 * out.m[0][0] + m01 * out.m[1][0] + m02 * out.m[2][0] + m03 * out.m[3][0];
if (det != 0.0f)
{
Matrix result = MatrixIdentity();
result.m[0][3] = x;
result.m[1][3] = y;
result.m[2][3] = z;
return result;
float invDet = 1.0f / det;
for (int r = 0; r < 4; ++r)
for (int c = 0; c < 4; ++c)
out.m[r][c] *= invDet;
}
[[nodiscard]] inline Matrix MatrixScale(float x, float y, float z)
{
Matrix result = MatrixIdentity();
result.m[0][0] = x;
result.m[1][1] = y;
result.m[2][2] = z;
return result;
}
[[nodiscard]] inline Matrix MatrixRotationX(float radians)
{
float c = cosf(radians);
float s = sinf(radians);
Matrix result = MatrixIdentity();
result.m[1][1] = c;
result.m[1][2] = -s;
result.m[2][1] = s;
result.m[2][2] = c;
return result;
}
[[nodiscard]] inline Matrix MatrixRotationY(float radians)
{
float c = cosf(radians);
float s = sinf(radians);
Matrix result = MatrixIdentity();
result.m[0][0] = c;
result.m[0][2] = s;
result.m[2][0] = -s;
result.m[2][2] = c;
return result;
}
[[nodiscard]] inline Matrix MatrixRotationZ(float radians)
{
float c = cosf(radians);
float s = sinf(radians);
Matrix result = MatrixIdentity();
result.m[0][0] = c;
result.m[0][1] = -s;
result.m[1][0] = s;
result.m[1][1] = c;
return result;
}
inline void MatrixTranslate(Matrix& m, const Vector3& v)
{
m.m[0][3] += v.x;
m.m[1][3] += v.y;
m.m[2][3] += v.z;
}
[[nodiscard]] inline Matrix MatrixRotation(float x, float y, float z)
{
return MatrixRotationX(x) * MatrixRotationY(y) * MatrixRotationZ(z);
}
inline Matrix LookAt(const Vector3& eye, const Vector3& target, const Vector3& up)
{
// Left-Handed convention
Vector3 zaxis = Normalize(target - eye); // Forward is +z
Vector3 xaxis = Normalize(Cross(up, zaxis));
Vector3 yaxis = Cross(zaxis, xaxis);
Matrix result = {};
// Row 0
result.m[0][0] = xaxis.x;
result.m[0][1] = xaxis.y;
result.m[0][2] = xaxis.z;
result.m[0][3] = -Dot(xaxis, eye);
// Row 1
result.m[1][0] = yaxis.x;
result.m[1][1] = yaxis.y;
result.m[1][2] = yaxis.z;
result.m[1][3] = -Dot(yaxis, eye);
// Row 2
result.m[2][0] = zaxis.x;
result.m[2][1] = zaxis.y;
result.m[2][2] = zaxis.z;
result.m[2][3] = -Dot(zaxis, eye);
// Row 3
result.m[3][3] = 1.0f;
return result;
}
inline Matrix PerspectiveFov(float fovY, float aspectRatio, float nearZ, float farZ)
{
// Left-Handed Perspective
float yScale = 1.0f / tanf(fovY * 0.5f);
float xScale = yScale / aspectRatio;
Matrix result = {};
result.m[0][0] = xScale;
result.m[1][1] = yScale;
result.m[2][2] = farZ / (farZ - nearZ);
result.m[2][3] = (-nearZ * farZ) / (farZ - nearZ);
result.m[3][2] = 1.0f;
result.m[3][3] = 0.0f;
return result;
}
[[nodiscard]] inline Matrix MatrixInverse(const Matrix& m)
{
Matrix out = {};
float m00 = m.m[0][0], m01 = m.m[0][1], m02 = m.m[0][2], m03 = m.m[0][3];
float m10 = m.m[1][0], m11 = m.m[1][1], m12 = m.m[1][2], m13 = m.m[1][3];
float m20 = m.m[2][0], m21 = m.m[2][1], m22 = m.m[2][2], m23 = m.m[2][3];
float m30 = m.m[3][0], m31 = m.m[3][1], m32 = m.m[3][2], m33 = m.m[3][3];
out.m[0][0] = m11 * m22 * m33 - m11 * m23 * m32 - m21 * m12 * m33 + m21 * m13 * m32 + m31 * m12 * m23 - m31 * m13 * m22;
out.m[1][0] = -m10 * m22 * m33 + m10 * m23 * m32 + m20 * m12 * m33 - m20 * m13 * m32 - m30 * m12 * m23 + m30 * m13 * m22;
out.m[2][0] = m10 * m21 * m33 - m10 * m23 * m31 - m20 * m11 * m33 + m20 * m13 * m31 + m30 * m11 * m23 - m30 * m13 * m21;
out.m[3][0] = -m10 * m21 * m32 + m10 * m22 * m31 + m20 * m11 * m32 - m20 * m12 * m31 - m30 * m11 * m22 + m30 * m12 * m21;
out.m[0][1] = -m01 * m22 * m33 + m01 * m23 * m32 + m21 * m02 * m33 - m21 * m03 * m32 - m31 * m02 * m23 + m31 * m03 * m22;
out.m[1][1] = m00 * m22 * m33 - m00 * m23 * m32 - m20 * m02 * m33 + m20 * m03 * m32 + m30 * m02 * m23 - m30 * m03 * m22;
out.m[2][1] = -m00 * m21 * m33 + m00 * m23 * m31 + m20 * m01 * m33 - m20 * m03 * m31 - m30 * m01 * m23 + m30 * m03 * m21;
out.m[3][1] = m00 * m21 * m32 - m00 * m22 * m31 - m20 * m01 * m32 + m20 * m02 * m31 + m30 * m01 * m22 - m30 * m02 * m21;
out.m[0][2] = m01 * m12 * m33 - m01 * m13 * m32 - m11 * m02 * m33 + m11 * m03 * m32 + m31 * m02 * m13 - m31 * m03 * m12;
out.m[1][2] = -m00 * m12 * m33 + m00 * m13 * m32 + m10 * m02 * m33 - m10 * m03 * m32 - m30 * m02 * m13 + m30 * m03 * m12;
out.m[2][2] = m00 * m11 * m33 - m00 * m13 * m31 - m10 * m01 * m33 + m10 * m03 * m31 + m30 * m01 * m13 - m30 * m03 * m11;
out.m[3][2] = -m00 * m11 * m32 + m00 * m12 * m31 + m10 * m01 * m32 - m10 * m02 * m31 - m30 * m01 * m12 + m30 * m02 * m11;
out.m[0][3] = -m01 * m12 * m23 + m01 * m13 * m22 + m11 * m02 * m23 - m11 * m03 * m22 - m21 * m02 * m13 + m21 * m03 * m12;
out.m[1][3] = m00 * m12 * m23 - m00 * m13 * m22 - m10 * m02 * m23 + m10 * m03 * m22 + m20 * m02 * m13 - m20 * m03 * m12;
out.m[2][3] = -m00 * m11 * m23 + m00 * m13 * m21 + m10 * m01 * m23 - m10 * m03 * m21 - m20 * m01 * m13 + m20 * m03 * m11;
out.m[3][3] = m00 * m11 * m22 - m00 * m12 * m21 - m10 * m01 * m22 + m10 * m02 * m21 + m20 * m01 * m12 - m20 * m02 * m11;
float det = m00 * out.m[0][0] + m01 * out.m[1][0] + m02 * out.m[2][0] + m03 * out.m[3][0];
if (det != 0.0f)
{
float invDet = 1.0f / det;
for (int r = 0; r < 4; ++r)
for (int c = 0; c < 4; ++c)
out.m[r][c] *= invDet;
}
return out;
}
} // namespace Juliet
return out;
}
Juliet/include/Core/Math/Shape.h
+7 -10
View File
@@ -1,12 +1,9 @@
#pragma once
#pragma once
namespace Juliet
struct Rectangle
{
struct Rectangle
{
int32 X;
int32 Y;
int32 Width;
int32 Height;
};
} // namespace Juliet
int32 X;
int32 Y;
int32 Width;
int32 Height;
};
Juliet/include/Core/Math/Vector.h
+23 -26
View File
@@ -1,39 +1,36 @@
#pragma once
#pragma once
#include <Core/Common/CoreTypes.h>
#include <Juliet.h>
#include <math.h>
namespace Juliet
struct Vector3
{
struct Vector3
{
float x, y, z;
float x, y, z;
Vector3 operator+(const Vector3& rhs) const { return { x + rhs.x, y + rhs.y, z + rhs.z }; }
Vector3 operator-(const Vector3& rhs) const { return { x - rhs.x, y - rhs.y, z - rhs.z }; }
Vector3 operator*(float s) const { return { x * s, y * s, z * s }; }
};
Vector3 operator+(const Vector3& rhs) const { return { x + rhs.x, y + rhs.y, z + rhs.z }; }
Vector3 operator-(const Vector3& rhs) const { return { x - rhs.x, y - rhs.y, z - rhs.z }; }
Vector3 operator*(float s) const { return { x * s, y * s, z * s }; }
};
struct Vector4
{
float x, y, z, w;
};
struct Vector4
{
float x, y, z, w;
};
inline Vector3 Normalize(const Vector3& v)
inline Vector3 Normalize(const Vector3& v)
{
float len = sqrtf(v.x * v.x + v.y * v.y + v.z * v.z);
if (len > 0.0001f)
{
float len = sqrtf(v.x * v.x + v.y * v.y + v.z * v.z);
if (len > 0.0001f)
{
return { v.x / len, v.y / len, v.z / len };
}
return v;
return { v.x / len, v.y / len, v.z / len };
}
return v;
}
inline Vector3 Cross(const Vector3& a, const Vector3& b)
{
return { a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x };
}
inline Vector3 Cross(const Vector3& a, const Vector3& b)
{
return { a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x };
}
inline float Dot(const Vector3& a, const Vector3& b) { return a.x * b.x + a.y * b.y + a.z * b.z; }
} // namespace Juliet
inline float Dot(const Vector3& a, const Vector3& b) { return a.x * b.x + a.y * b.y + a.z * b.z; }
Juliet/include/Core/Memory/Allocator.h
+20 -23
View File
@@ -1,31 +1,28 @@
#pragma once
#pragma once
#include <Juliet.h>
#include <Core/Common/CoreUtils.h>
namespace Juliet
{
// Uninitialized allocation
JULIET_API void* Malloc(size_t elem_size);
// Initialized to 0 allocation
JULIET_API void* Calloc(size_t nb_elem, size_t elem_size);
JULIET_API void* Realloc(void* memory, size_t newSize);
// Uninitialized allocation
JULIET_API void* Malloc(size_t elem_size);
// Initialized to 0 allocation
JULIET_API void* Calloc(size_t nb_elem, size_t elem_size);
JULIET_API void* Realloc(void* memory, size_t newSize);
// Free
template <typename Type>
void Free(Type* memory)
// Free
template <typename Type>
void Free(Type* memory)
{
Assert(memory);
::free(memory);
}
// Free and Set the ptr to nullptr
template <typename Type>
void SafeFree(Type*& memory)
{
if (memory)
{
Assert(memory);
::free(memory);
memory = nullptr;
}
// Free and Set the ptr to nullptr
template <typename Type>
void SafeFree(Type*& memory)
{
if (memory)
{
::free(memory);
memory = nullptr;
}
}
} // namespace Juliet
}
Juliet/include/Core/Memory/MemoryArena.h
+108 -111
View File
@@ -1,4 +1,4 @@
#pragma once
#pragma once
#include <Core/Common/CoreTypes.h>
#include <Core/Common/CoreUtils.h>
@@ -10,122 +10,119 @@
#include <Core/Memory/MemoryArenaDebug.h>
#endif
namespace Juliet
constexpr global uint64 g_Arena_Default_Reserve_Size = Megabytes(64);
constexpr global uint64 g_Arena_Default_Commit_Size = Kilobytes(64);
constexpr global uint64 k_ArenaHeaderSize = 128;
#if JULIET_DEBUG
struct ArenaDebugInfo;
JULIET_API String FormatDebugTagV(const char* formatStr, std::format_args args);
#endif
struct Arena
{
constexpr global uint64 g_Arena_Default_Reserve_Size = Megabytes(64);
constexpr global uint64 g_Arena_Default_Commit_Size = Kilobytes(64);
constexpr global uint64 k_ArenaHeaderSize = 128;
Arena* Previous;
Arena* Current;
uint64 BasePosition;
uint64 Position;
uint64 Alignment;
uint64 CommitSize;
uint64 ReserveSize;
uint64 Committed;
uint64 Reserved;
Arena* FreeBlockLast;
JULIET_DEBUG_ONLY(uint16 LostNodeCount;)
JULIET_DEBUG_ONLY(bool CanReserveMore : 1;)
JULIET_DEBUG_ONLY(Arena* GlobalNext;)
JULIET_DEBUG_ONLY(Arena* GlobalPrev;)
JULIET_DEBUG_ONLY(ArenaDebugInfo* FirstDebugInfo;)
const char* Name;
};
static_assert(sizeof(Arena) <= k_ArenaHeaderSize);
struct TempArena
{
Arena* Arena;
index_t Position;
};
struct ArenaParams
{
uint64 ReserveSize = g_Arena_Default_Reserve_Size;
uint64 CommitSize = g_Arena_Default_Commit_Size;
const char* Name;
// When false, will assert if a new block is reserved.
JULIET_DEBUG_ONLY(bool CanReserveMore : 1 = true;)
};
[[nodiscard]] JULIET_API Arena* ArenaAllocate(const ArenaParams& params,
const std::source_location& loc = std::source_location::current());
JULIET_API void ArenaRelease(NonNullPtr<Arena> arena);
// Raw Push, can be used but templated helpers exists below
[[nodiscard]] JULIET_API void* ArenaPush(NonNullPtr<Arena> arena, size_t size, size_t align,
bool shouldBeZeroed JULIET_DEBUG_PARAM(const char* tag));
JULIET_API void ArenaPopTo(NonNullPtr<Arena> arena, size_t position);
JULIET_API void ArenaPop(NonNullPtr<Arena> arena, size_t amount);
JULIET_API void ArenaClear(NonNullPtr<Arena> arena);
[[nodiscard]] JULIET_API size_t ArenaPos(NonNullPtr<Arena> arena);
#if JULIET_DEBUG
struct ArenaDebugInfo;
JULIET_API String FormatDebugTagV(const char* formatStr, std::format_args args);
template <typename FirstDebugArg, typename... DebugArgs>
#endif
[[nodiscard]] inline void* ArenaPushSize(NonNullPtr<Arena> arena, size_t size, size_t align,
bool shouldBeZeroed JULIET_DEBUG_PARAM(FirstDebugArg&& firstDebugArg,
DebugArgs&&... debugArgs))
{
return ArenaPush(arena, size, align,
shouldBeZeroed JULIET_DEBUG_PARAM(
[&]() -> const char*
{
return Format(GetDebugInfoArena(), std::forward<FirstDebugArg>(firstDebugArg),
std::forward<DebugArgs>(debugArgs)...)
.Str;
}()));
}
struct Arena
{
Arena* Previous;
Arena* Current;
uint64 BasePosition;
uint64 Position;
uint64 Alignment;
uint64 CommitSize;
uint64 ReserveSize;
uint64 Committed;
uint64 Reserved;
Arena* FreeBlockLast;
JULIET_DEBUG_ONLY(uint16 LostNodeCount;)
JULIET_DEBUG_ONLY(bool CanReserveMore : 1;)
JULIET_DEBUG_ONLY(Arena* GlobalNext;)
JULIET_DEBUG_ONLY(Arena* GlobalPrev;)
JULIET_DEBUG_ONLY(ArenaDebugInfo* FirstDebugInfo;)
const char* Name;
};
static_assert(sizeof(Arena) <= k_ArenaHeaderSize);
struct TempArena
{
Arena* Arena;
index_t Position;
};
struct ArenaParams
{
uint64 ReserveSize = g_Arena_Default_Reserve_Size;
uint64 CommitSize = g_Arena_Default_Commit_Size;
const char* Name;
// When false, will assert if a new block is reserved.
JULIET_DEBUG_ONLY(bool CanReserveMore : 1 = true;)
};
[[nodiscard]] JULIET_API Arena* ArenaAllocate(const ArenaParams& params,
const std::source_location& loc = std::source_location::current());
JULIET_API void ArenaRelease(NonNullPtr<Arena> arena);
// Raw Push, can be used but templated helpers exists below
[[nodiscard]] JULIET_API void* ArenaPush(NonNullPtr<Arena> arena, size_t size, size_t align,
bool shouldBeZeroed JULIET_DEBUG_PARAM(const char* tag));
JULIET_API void ArenaPopTo(NonNullPtr<Arena> arena, size_t position);
JULIET_API void ArenaPop(NonNullPtr<Arena> arena, size_t amount);
JULIET_API void ArenaClear(NonNullPtr<Arena> arena);
[[nodiscard]] JULIET_API size_t ArenaPos(NonNullPtr<Arena> arena);
#if JULIET_DEBUG
template <typename FirstDebugArg, typename... DebugArgs>
#endif
[[nodiscard]] inline void* ArenaPushSize(NonNullPtr<Arena> arena, size_t size, size_t align,
bool shouldBeZeroed JULIET_DEBUG_PARAM(FirstDebugArg&& firstDebugArg,
DebugArgs&&... debugArgs))
{
return ArenaPush(arena, size, align,
shouldBeZeroed JULIET_DEBUG_PARAM(
[&]() -> const char*
{
return Format(GetDebugInfoArena(), std::forward<FirstDebugArg>(firstDebugArg),
std::forward<DebugArgs>(debugArgs)...)
.Str;
}()));
}
template <typename Type JULIET_DEBUG_ONLY(, typename... DebugArgs)>
[[nodiscard]] Type* ArenaPushStruct(NonNullPtr<Arena> arena JULIET_DEBUG_PARAM(DebugArgs&&... debugArgs))
{
return static_cast<Type*>(
ArenaPush(arena, sizeof(Type) * 1, AlignOf(Type),
true JULIET_DEBUG_PARAM(
[&]() -> const char*
template <typename Type JULIET_DEBUG_ONLY(, typename... DebugArgs)>
[[nodiscard]] Type* ArenaPushStruct(NonNullPtr<Arena> arena JULIET_DEBUG_PARAM(DebugArgs&&... debugArgs))
{
return static_cast<Type*>(
ArenaPush(arena, sizeof(Type) * 1, AlignOf(Type),
true JULIET_DEBUG_PARAM(
[&]() -> const char*
{
if constexpr (sizeof...(DebugArgs) > 0)
{
if constexpr (sizeof...(DebugArgs) > 0)
{
return Format(GetDebugInfoArena(), std::forward<DebugArgs>(debugArgs)...).Str;
}
return GetTypeName<Type>();
}())));
}
return Format(GetDebugInfoArena(), std::forward<DebugArgs>(debugArgs)...).Str;
}
return GetTypeName<Type>();
}())));
}
template <typename Type, bool shouldZero = true JULIET_DEBUG_ONLY(, typename... DebugArgs)>
[[nodiscard]] Type* ArenaPushArray(NonNullPtr<Arena> arena, size_t count JULIET_DEBUG_PARAM(DebugArgs&&... debugArgs))
{
return static_cast<Type*>(
ArenaPush(arena, sizeof(Type) * count, Max(8ull, AlignOf(Type)),
shouldZero JULIET_DEBUG_PARAM(
[&]() -> const char*
template <typename Type, bool shouldZero = true JULIET_DEBUG_ONLY(, typename... DebugArgs)>
[[nodiscard]] Type* ArenaPushArray(NonNullPtr<Arena> arena, size_t count JULIET_DEBUG_PARAM(DebugArgs&&... debugArgs))
{
return static_cast<Type*>(
ArenaPush(arena, sizeof(Type) * count, Max(8ull, AlignOf(Type)),
shouldZero JULIET_DEBUG_PARAM(
[&]() -> const char*
{
if constexpr (sizeof...(DebugArgs) > 0)
{
if constexpr (sizeof...(DebugArgs) > 0)
{
return Format(GetDebugInfoArena(), std::forward<DebugArgs>(debugArgs)...).Str;
}
return GetTypeName<Type>();
}())));
}
return Format(GetDebugInfoArena(), std::forward<DebugArgs>(debugArgs)...).Str;
}
return GetTypeName<Type>();
}())));
}
TempArena ArenaTempBegin(NonNullPtr<Arena> arena);
void ArenaTempEnd(TempArena temp);
} // namespace Juliet
TempArena ArenaTempBegin(NonNullPtr<Arena> arena);
void ArenaTempEnd(TempArena temp);
Juliet/include/Core/Memory/MemoryArenaDebug.h
+33 -36
View File
@@ -1,4 +1,4 @@
#pragma once
#pragma once
#include <Core/Common/CoreTypes.h>
#include <Core/Common/NonNullPtr.h>
@@ -7,46 +7,43 @@
#if JULIET_DEBUG
namespace Juliet
struct Arena;
struct MemoryBlock;
// Arena (Struct)
struct ArenaDebugInfo
{
struct Arena;
struct MemoryBlock;
const char* Tag;
size_t Offset;
size_t Size;
ArenaDebugInfo* Next;
};
// Arena (Struct)
struct ArenaDebugInfo
{
const char* Tag;
size_t Offset;
size_t Size;
ArenaDebugInfo* Next;
};
// MemoryArena (Pool-based)
struct ArenaAllocation
{
size_t Offset;
size_t Size;
String Tag;
ArenaAllocation* Next;
};
// MemoryArena (Pool-based)
struct ArenaAllocation
{
size_t Offset;
size_t Size;
String Tag;
ArenaAllocation* Next;
};
// Arena (Struct)
void DebugRegisterArena(NonNullPtr<Arena> arena);
void DebugUnregisterArena(NonNullPtr<Arena> arena);
void DebugArenaSetDebugName(NonNullPtr<Arena> arena, const char* name);
bool IsDebugInfoArena(const Arena* arena); // To prevent recursion
void DebugArenaFreeBlock(Arena* block); // To clear all debug infos in a block
void DebugArenaRemoveAllocation(Arena* block, size_t oldOffset);
void DebugArenaPopTo(Arena* block, size_t newPosition);
void DebugArenaAddDebugInfo(Arena* block, size_t size, size_t offset, const char* tag);
// Arena (Struct)
void DebugRegisterArena(NonNullPtr<Arena> arena);
void DebugUnregisterArena(NonNullPtr<Arena> arena);
void DebugArenaSetDebugName(NonNullPtr<Arena> arena, const char* name);
bool IsDebugInfoArena(const Arena* arena); // To prevent recursion
void DebugArenaFreeBlock(Arena* block); // To clear all debug infos in a block
void DebugArenaRemoveAllocation(Arena* block, size_t oldOffset);
void DebugArenaPopTo(Arena* block, size_t newPosition);
void DebugArenaAddDebugInfo(Arena* block, size_t size, size_t offset, const char* tag);
// MemoryArena (Pool-based)
void DebugFreeArenaAllocations(MemoryBlock* blk);
void DebugArenaAddAllocation(MemoryBlock* blk, size_t size, size_t offset, String tag);
void DebugArenaRemoveLastAllocation(MemoryBlock* blk);
// MemoryArena (Pool-based)
void DebugFreeArenaAllocations(MemoryBlock* blk);
void DebugArenaAddAllocation(MemoryBlock* blk, size_t size, size_t offset, String tag);
void DebugArenaRemoveLastAllocation(MemoryBlock* blk);
JULIET_API Arena* GetDebugInfoArena();
JULIET_API Arena* GetDebugInfoArena();
} // namespace Juliet
#endif
Juliet/include/Core/Memory/ScratchArena.h
View File
Juliet/include/Core/Memory/Utils.h
+57 -60
View File
@@ -1,78 +1,75 @@
#pragma once
#pragma once
#include <Core/Common/CoreTypes.h>
#define ArraySize(array) (sizeof(array) / sizeof(array[0]))
namespace Juliet
inline int32 MemCompare(const void* leftValue, const void* rightValue, size_t size)
{
inline int32 MemCompare(const void* leftValue, const void* rightValue, size_t size)
auto left = static_cast<const unsigned char*>(leftValue);
auto right = static_cast<const unsigned char*>(rightValue);
while (size && *left == *right)
{
auto left = static_cast<const unsigned char*>(leftValue);
auto right = static_cast<const unsigned char*>(rightValue);
while (size && *left == *right)
{
++left;
++right;
--size;
}
return size ? *left - *right : 0;
++left;
++right;
--size;
}
return size ? *left - *right : 0;
}
// Single linked list
void SingleLinkedListPushNext(auto*& stackTop, auto* node)
{
node->Next = stackTop;
stackTop = node;
}
void SingleLinkedListPushPrevious(auto*& stackTop, auto* node)
{
node->Previous = stackTop;
stackTop = node;
}
void SingleLinkedListPopNext(auto*& stackTop)
{
stackTop = stackTop->Next;
}
// Double linked list
template <typename QueueType, typename QueueTypeNode>
void Enqueue(QueueType& queue, QueueTypeNode* node)
{
if (queue.First == nullptr)
{
queue.First = queue.Last = node;
node->Next = nullptr;
}
else
{
queue.Last->Next = node, queue.Last = node;
node->Next = nullptr;
}
// Single linked list
void SingleLinkedListPushNext(auto*& stackTop, auto* node)
{
node->Next = stackTop;
stackTop = node;
}
queue.Nodecount += 1;
}
void SingleLinkedListPushPrevious(auto*& stackTop, auto* node)
{
node->Previous = stackTop;
stackTop = node;
}
void SingleLinkedListPopNext(auto*& stackTop)
{
stackTop = stackTop->Next;
}
// Double linked list
template <typename QueueType, typename QueueTypeNode>
void Enqueue(QueueType& queue, QueueTypeNode* node)
{
if (queue.First == nullptr)
{
queue.First = queue.Last = node;
node->Next = nullptr;
}
else
{
queue.Last->Next = node, queue.Last = node;
node->Next = nullptr;
}
queue.Nodecount += 1;
}
template <typename QueueType>
struct QueueNode
{
QueueType* Next;
};
template <typename QueueType>
struct QueueNode
{
QueueType* Next;
};
#define DECLARE_QUEUE(type) \
struct type##Queue \
{ \
type* First; \
type* Last; \
size_t Nodecount; \
size_t Size; \
};
struct type##Queue \
{ \
type* First; \
type* Last; \
size_t Nodecount; \
size_t Size; \
};
// TODO: homemade versions
#define MemSet memset
#define MemCopy memcpy
#define MemoryZero(dst, size) MemSet(dst, 0, size)
} // namespace Juliet
Juliet/include/Core/Networking/IPAddress.h
+5 -8
View File
@@ -1,11 +1,8 @@
#pragma once
#pragma once
#include <Core/Common/CoreTypes.h>
namespace Juliet
{
// TODO : Do something better.
constexpr uint32 kLocalhost = (127 << 3) | (0 << 2) | (0 << 1) | 1;
constexpr uint32 kAnyIp = 0;
constexpr uint32 kBroadcastIp = (255 << 3) | (255 << 2) | (255 << 1) | 255;
} // namespace Juliet
// TODO : Do something better.
constexpr uint32 kLocalhost = (127 << 3) | (0 << 2) | (0 << 1) | 1;
constexpr uint32 kAnyIp = 0;
constexpr uint32 kBroadcastIp = (255 << 3) | (255 << 2) | (255 << 1) | 255;
Juliet/include/Core/Networking/NetworkPacket.h
+22 -25
View File
@@ -1,36 +1,33 @@
#pragma once
#pragma once
#include <Core/Common/CoreTypes.h>
#include <Core/Container/Vector.h>
namespace Juliet
class NetworkPacket
{
class NetworkPacket
{
public:
NetworkPacket();
NetworkPacket(Arena& arena);
virtual ~NetworkPacket();
NetworkPacket(NetworkPacket&);
NetworkPacket& operator=(const NetworkPacket&);
NetworkPacket(NetworkPacket&&) noexcept;
NetworkPacket& operator=(NetworkPacket&&) noexcept;
public:
NetworkPacket();
NetworkPacket(Arena& arena);
virtual ~NetworkPacket();
NetworkPacket(NetworkPacket&);
NetworkPacket& operator=(const NetworkPacket&);
NetworkPacket(NetworkPacket&&) noexcept;
NetworkPacket& operator=(NetworkPacket&&) noexcept;
void Create(Arena& arena);
void Create(Arena& arena);
[[nodiscard]] ByteBuffer GetRawData();
[[nodiscard]] ByteBuffer GetRawData();
// Pack
NetworkPacket& operator<<(uint32 value);
NetworkPacket& operator<<(char* data);
// Pack
NetworkPacket& operator<<(uint32 value);
NetworkPacket& operator<<(char* data);
protected:
void Append(ByteBuffer buffer);
protected:
void Append(ByteBuffer buffer);
friend class TcpSocket;
friend class TcpSocket;
private:
VectorArena<Byte, 4096> Data;
size_t PartialSendIndex = 0;
};
} // namespace Juliet
private:
VectorArena<Byte, 4096> Data;
size_t PartialSendIndex = 0;
};
Juliet/include/Core/Networking/Socket.h
+47 -50
View File
@@ -1,56 +1,53 @@
#pragma once
#pragma once
#include <Core/Networking/SocketHandle.h>
namespace Juliet
class Socket
{
class Socket
public:
virtual ~Socket();
Socket(Socket&& other) noexcept;
Socket& operator=(Socket&& socket) noexcept;
Socket(const Socket&) = delete;
Socket& operator=(const Socket&) = delete;
bool IsValid() const;
enum class Status : uint8
{
public:
virtual ~Socket();
Socket(Socket&& other) noexcept;
Socket& operator=(Socket&& socket) noexcept;
Socket(const Socket&) = delete;
Socket& operator=(const Socket&) = delete;
bool IsValid() const;
enum class Status : uint8
{
Done,
Partial,
Ready,
NotReady,
Disconnected,
Error
};
protected:
enum class Protocol : uint8
{
TCP,
UDP
};
// To store the result of a send/receive on the socket
struct RequestStatus
{
Status Status = Status::Done;
size_t Length = 0;
};
explicit Socket(Protocol protocol);
SocketHandle GetHandle() const { return Handle; }
void Create();
void CreateFromHandle(SocketHandle handle);
void Close();
private:
SocketHandle Handle;
Protocol ProtocolType;
Done,
Partial,
Ready,
NotReady,
Disconnected,
Error
};
} // namespace Juliet
protected:
enum class Protocol : uint8
{
TCP,
UDP
};
// To store the result of a send/receive on the socket
struct RequestStatus
{
Status Status = Status::Done;
size_t Length = 0;
};
explicit Socket(Protocol protocol);
SocketHandle GetHandle() const { return Handle; }
void Create();
void CreateFromHandle(SocketHandle handle);
void Close();
private:
SocketHandle Handle;
Protocol ProtocolType;
};
Juliet/include/Core/Networking/SocketHandle.h
+3 -6
View File
@@ -1,14 +1,11 @@
#pragma once
#pragma once
#if JULIET_WIN32
#include <basetsd.h>
#endif
namespace Juliet
{
#if JULIET_WIN32
using SocketHandle = UINT_PTR;
using SocketHandle = UINT_PTR;
#else
using SocketHandle = int;
using SocketHandle = int;
#endif
} // namespace Juliet
Juliet/include/Core/Networking/TcpListener.h
+10 -13
View File
@@ -1,21 +1,18 @@
#pragma once
#pragma once
#include <Core/Networking/IPAddress.h>
#include <Core/Networking/Socket.h>
#include <Core/Networking/TcpSocket.h>
namespace Juliet
class TcpListener : public Socket
{
class TcpListener : public Socket
{
public:
TcpListener();
public:
TcpListener();
TcpListener(const TcpListener&) = delete;
TcpListener& operator=(const TcpListener&) = delete;
TcpListener(const TcpListener&) = delete;
TcpListener& operator=(const TcpListener&) = delete;
Status Listen(uint16 port, uint32 address = kAnyIp);
Status Accept(TcpSocket& socket);
void Close();
};
} // namespace Juliet
Status Listen(uint16 port, uint32 address = kAnyIp);
Status Accept(TcpSocket& socket);
void Close();
};
Juliet/include/Core/Networking/TcpSocket.h
+14 -17
View File
@@ -1,24 +1,21 @@
#pragma once
#pragma once
#include <Core/Networking/Socket.h>
namespace Juliet
class NetworkPacket;
class TcpSocket : public Socket
{
class NetworkPacket;
public:
TcpSocket();
class TcpSocket : public Socket
{
public:
TcpSocket();
TcpSocket(const TcpSocket&) = delete;
TcpSocket& operator=(const TcpSocket&) = delete;
TcpSocket(const TcpSocket&) = delete;
TcpSocket& operator=(const TcpSocket&) = delete;
RequestStatus Send(NetworkPacket& packet);
RequestStatus Send(ByteBuffer buffer);
Status Receive(NetworkPacket& outPacket);
RequestStatus Send(NetworkPacket& packet);
RequestStatus Send(ByteBuffer buffer);
Status Receive(NetworkPacket& outPacket);
private:
friend class TcpListener;
};
} // namespace Juliet
private:
friend class TcpListener;
};
Juliet/include/Core/PCH.h
+1 -1
View File
@@ -1,4 +1,4 @@
#pragma once
#pragma once
#include <algorithm>
#include <bit>
Juliet/include/Core/Thread/Mutex.h
+3 -6
View File
@@ -1,7 +1,4 @@
#pragma once
#pragma once
namespace Juliet
{
using Mutex = std::mutex;
using LockGuard = std::lock_guard<Mutex>;
} // namespace Juliet
using Mutex = std::mutex;
using LockGuard = std::lock_guard<Mutex>;
Juliet/include/Core/Thread/Thread.h
+10 -13
View File
@@ -1,19 +1,16 @@
#pragma once
#pragma once
#include <Core/Common/String.h>
namespace Juliet
uint32 thread_id();
void set_thread_name(String name);
// TODO : Proper wait
inline void wait_ms(int milliseconds)
{
uint32 thread_id();
void set_thread_name(String name);
// TODO : Proper wait
inline void wait_ms(int milliseconds)
clock_t start_time = clock();
while (clock() < start_time + milliseconds)
{
clock_t start_time = clock();
while (clock() < start_time + milliseconds)
{
}
}
} // namespace Juliet
}
Juliet/include/Core/Thread/ThreadContext.h
+13 -16
View File
@@ -1,24 +1,21 @@
#pragma once
#pragma once
#include <Core/Common/CoreTypes.h>
#include <Core/Memory/MemoryArena.h>
namespace Juliet
struct thread_context
{
struct thread_context
{
Arena* ScratchArenas[2];
Arena* ScratchArenas[2];
char ThreadName[64];
uint8 ThreadNameSize;
};
char ThreadName[64];
uint8 ThreadNameSize;
};
thread_context* thread_context_alloc();
void thread_context_release(NonNullPtr<thread_context> ctx);
void thread_context_select(NonNullPtr<thread_context> ctx);
thread_context* thread_context_current();
thread_context* thread_context_alloc();
void thread_context_release(NonNullPtr<thread_context> ctx);
void thread_context_select(NonNullPtr<thread_context> ctx);
thread_context* thread_context_current();
Arena* thread_context_get_scratch(Arena** conflicts, size_t count);
TempArena scratch_begin(Arena** conflicts, size_t count);
void scratch_end(TempArena scratch);
} // namespace Juliet
Arena* thread_context_get_scratch(Arena** conflicts, size_t count);
TempArena scratch_begin(Arena** conflicts, size_t count);
void scratch_end(TempArena scratch);
Juliet/include/Engine/Asset.h
+2 -5
View File
@@ -1,9 +1,6 @@
#pragma once
#pragma once
#include <Core/Common/String.h>
#include <Graphics/MeshRenderer.h>
namespace Juliet
{
JULIET_API extern MeshAssetID LoadMesh(String filename);
}
JULIET_API extern MeshAssetID LoadMesh(String filename);
Juliet/include/Engine/Class.h
+20 -23
View File
@@ -1,33 +1,30 @@
#pragma once
#pragma once
#include <Core/Common/CRC32.h>
#include <Juliet.h>
namespace Juliet
struct Class
{
struct Class
uint32 CRC;
#if JULIET_DEBUG
// TODO: string struct may be
const char* Name;
size_t Name_Length;
#endif
consteval Class(const char* className, size_t name_length)
{
uint32 CRC;
CRC = crc32(className, name_length);
#if JULIET_DEBUG
// TODO: string struct may be
const char* Name;
size_t Name_Length;
Name = className;
Name_Length = name_length;
#endif
consteval Class(const char* className, size_t name_length)
{
CRC = crc32(className, name_length);
#if JULIET_DEBUG
// TODO: string struct may be
Name = className;
Name_Length = name_length;
#endif
}
};
template <typename type>
bool IsA(Class& cls)
{
return cls.CRC == type::StaticClass->CRC;
}
} // namespace Juliet
};
template <typename type>
bool IsA(Class& cls)
{
return cls.CRC == type::StaticClass->CRC;
}
Juliet/include/Engine/Debug/MemoryDebugger.h
+3 -3
View File
@@ -1,12 +1,12 @@
#pragma once
#pragma once
#include <Juliet.h>
#if JULIET_DEBUG
namespace Juliet::Debug
namespace Debug
{
JULIET_API void DebugDrawMemoryArena();
} // namespace Juliet::Debug
} // namespace Debug
#endif
Juliet/include/Engine/Engine.h
+14 -17
View File
@@ -1,25 +1,22 @@
#pragma once
#pragma once
#include <Core/Application/IApplication.h>
namespace Juliet
enum class JulietInit_Flags : uint8;
struct Engine
{
enum class JulietInit_Flags : uint8;
IApplication* Application = nullptr;
Arena* PlatformArena = nullptr;
Arena* AssetArena = nullptr;
};
struct Engine
{
IApplication* Application = nullptr;
Arena* PlatformArena = nullptr;
Arena* AssetArena = nullptr;
};
void InitializeEngine(JulietInit_Flags flags);
void ShutdownEngine();
void InitializeEngine(JulietInit_Flags flags);
void ShutdownEngine();
void LoadApplication(IApplication& app);
void UnloadApplication();
void LoadApplication(IApplication& app);
void UnloadApplication();
void RunEngine();
void RunEngine();
extern Arena* GetPlatformArena();
} // namespace Juliet
extern Arena* GetPlatformArena();
Juliet/include/Graphics/Camera.h
+26 -29
View File
@@ -1,38 +1,35 @@
#pragma once
#pragma once
#include <Core/Math/Matrix.h>
#include <Juliet.h>
namespace Juliet
struct Camera
{
struct Camera
{
index_t Index;
Vector3 Position;
Vector3 Target;
Vector3 Up;
float FOV; // In radians
float AspectRatio;
float NearPlane;
float FarPlane;
};
index_t Index;
Vector3 Position;
Vector3 Target;
Vector3 Up;
float FOV; // In radians
float AspectRatio;
float NearPlane;
float FarPlane;
};
inline Matrix Camera_GetViewMatrix(const Camera& cam)
{
return LookAt(cam.Position, cam.Target, cam.Up);
}
inline Matrix Camera_GetViewMatrix(const Camera& cam)
{
return LookAt(cam.Position, cam.Target, cam.Up);
}
inline Matrix Camera_GetProjectionMatrix(const Camera& cam)
{
return PerspectiveFov(cam.FOV, cam.AspectRatio, cam.NearPlane, cam.FarPlane);
}
inline Matrix Camera_GetProjectionMatrix(const Camera& cam)
{
return PerspectiveFov(cam.FOV, cam.AspectRatio, cam.NearPlane, cam.FarPlane);
}
inline Matrix Camera_GetViewProjectionMatrix(const Camera& cam)
{
return Camera_GetProjectionMatrix(cam) * Camera_GetViewMatrix(cam);
}
inline Matrix Camera_GetViewProjectionMatrix(const Camera& cam)
{
return Camera_GetProjectionMatrix(cam) * Camera_GetViewMatrix(cam);
}
JULIET_API extern void ReserveCamera(size_t amount);
JULIET_API extern Camera* GetCurrentCamera();
JULIET_API extern void SetCurrentCamera(index_t index);
} // namespace Juliet
JULIET_API extern void ReserveCamera(size_t amount);
JULIET_API extern Camera* GetCurrentCamera();
JULIET_API extern void SetCurrentCamera(index_t index);
Juliet/include/Graphics/Colors.h
+10 -13
View File
@@ -1,16 +1,13 @@
#pragma once
#pragma once
namespace Juliet
template <typename Type>
struct ColorType
{
template <typename Type>
struct ColorType
{
Type R;
Type G;
Type B;
Type A;
};
Type R;
Type G;
Type B;
Type A;
};
using FColor = ColorType<float>;
using Color = ColorType<uint8>;
} // namespace Juliet
using FColor = ColorType<float>;
using Color = ColorType<uint8>;
Juliet/include/Graphics/DebugDisplay.h
+7 -10
View File
@@ -1,4 +1,4 @@
#pragma once
#pragma once
#include <Core/Math/Vector.h>
#include <Graphics/Camera.h>
@@ -6,12 +6,9 @@
#include <Graphics/Graphics.h>
#include <Juliet.h>
namespace Juliet
{
extern JULIET_API void DebugDisplay_Initialize(NonNullPtr<Arena> arena, GraphicsDevice* device);
extern JULIET_API void DebugDisplay_Shutdown(GraphicsDevice* device);
extern JULIET_API void DebugDisplay_DrawLine(const Vector3& start, const Vector3& end, const FColor& color, bool overlay);
extern JULIET_API void DebugDisplay_DrawSphere(const Vector3& center, float radius, const FColor& color, bool overlay);
extern JULIET_API void DebugDisplay_Prepare(CommandList* cmdList);
extern JULIET_API void DebugDisplay_Flush(CommandList* cmdList, RenderPass* renderPass, const Camera& camera);
} // namespace Juliet
extern JULIET_API void DebugDisplay_Initialize(NonNullPtr<Arena> arena, GraphicsDevice* device);
extern JULIET_API void DebugDisplay_Shutdown(GraphicsDevice* device);
extern JULIET_API void DebugDisplay_DrawLine(const Vector3& start, const Vector3& end, const FColor& color, bool overlay);
extern JULIET_API void DebugDisplay_DrawSphere(const Vector3& center, float radius, const FColor& color, bool overlay);
extern JULIET_API void DebugDisplay_Prepare(CommandList* cmdList);
extern JULIET_API void DebugDisplay_Flush(CommandList* cmdList, RenderPass* renderPass, const Camera& camera);
Juliet/include/Graphics/Graphics.h
+134 -137
View File
@@ -12,166 +12,163 @@
#include <Juliet.h>
// Graphics Interface
namespace Juliet
// Opaque types
struct CommandList;
struct GraphicsDevice;
struct Fence;
// Parameters of an indirect draw command
struct IndirectDrawCommand
{
// Opaque types
struct CommandList;
struct GraphicsDevice;
struct Fence;
uint32 VertexCount; // Number of vertices to draw
uint32 InstanceCount; // Number of instanced to draw
uint32 FirstVertex; // Index of the first vertex to draw
uint32 FirstInstance; // ID of the first instance to draw
};
// Parameters of an indirect draw command
struct IndirectDrawCommand
{
uint32 VertexCount; // Number of vertices to draw
uint32 InstanceCount; // Number of instanced to draw
uint32 FirstVertex; // Index of the first vertex to draw
uint32 FirstInstance; // ID of the first instance to draw
};
// Parameters of an INDEXED indirect draw command
struct IndexedIndirectDrawCommand
{
uint32 VertexCount; // Number of vertices to draw
uint32 InstanceCount; // Number of instanced to draw
uint32 FirstIndex; // Base Index within the index buffer
int32 VertexOffset; // Offset the vertex index into the buffer
uint32 FirstInstance; // ID of the first instance to draw
};
// Parameters of an INDEXED indirect draw command
struct IndexedIndirectDrawCommand
{
uint32 VertexCount; // Number of vertices to draw
uint32 InstanceCount; // Number of instanced to draw
uint32 FirstIndex; // Base Index within the index buffer
int32 VertexOffset; // Offset the vertex index into the buffer
uint32 FirstInstance; // ID of the first instance to draw
};
// Parameters of an INDEXED Indirect Dispatch Command
struct IndirectDispatchCommand
{
uint32 X_WorkGroupCount; // Number of Workgroup to dispatch on dimension X
uint32 Y_WorkGroupCount; // Number of Workgroup to dispatch on dimension Y
uint32 Z_WorkGroupCount; // Number of Workgroup to dispatch on dimension Z
};
// Parameters of an INDEXED Indirect Dispatch Command
struct IndirectDispatchCommand
{
uint32 X_WorkGroupCount; // Number of Workgroup to dispatch on dimension X
uint32 Y_WorkGroupCount; // Number of Workgroup to dispatch on dimension Y
uint32 Z_WorkGroupCount; // Number of Workgroup to dispatch on dimension Z
};
enum class QueueType : uint8
{
Graphics = 0,
Compute,
Copy,
Count
};
enum class QueueType : uint8
{
Graphics = 0,
Compute,
Copy,
Count
};
enum class IndexFormat : uint8
{
UInt16,
UInt32
};
enum class IndexFormat : uint8
{
UInt16,
UInt32
};
enum struct SwapChainComposition : uint8
{
SDR,
SDR_LINEAR,
HDR_EXTENDED_LINEAR,
HDR10_ST2084
};
enum struct SwapChainComposition : uint8
{
SDR,
SDR_LINEAR,
HDR_EXTENDED_LINEAR,
HDR10_ST2084
};
// PresentMode from highest to lowest latency
// Vsync prevents tearing. Enqueue ready images.
// Mailbox prevents tearing. When image is ready, replace any pending image
// Immediate replace current image as soon as possible. Can cause tearing
enum struct PresentMode : uint8
{
VSync,
Mailbox,
Immediate
};
// PresentMode from highest to lowest latency
// Vsync prevents tearing. Enqueue ready images.
// Mailbox prevents tearing. When image is ready, replace any pending image
// Immediate replace current image as soon as possible. Can cause tearing
enum struct PresentMode : uint8
{
VSync,
Mailbox,
Immediate
};
struct GraphicsViewPort
{
float X;
float Y;
float Width;
float Height;
float MinDepth;
float MaxDepth;
};
struct GraphicsViewPort
{
float X;
float Y;
float Width;
float Height;
float MinDepth;
float MaxDepth;
};
extern JULIET_API GraphicsDevice* CreateGraphicsDevice(GraphicsConfig config);
extern JULIET_API void DestroyGraphicsDevice(NonNullPtr<GraphicsDevice> device);
extern JULIET_API GraphicsDevice* CreateGraphicsDevice(GraphicsConfig config);
extern JULIET_API void DestroyGraphicsDevice(NonNullPtr<GraphicsDevice> device);
// Attach To Window
extern JULIET_API bool AttachToWindow(NonNullPtr<GraphicsDevice> device, NonNullPtr<Window> window);
extern JULIET_API void DetachFromWindow(NonNullPtr<GraphicsDevice> device, NonNullPtr<Window> window);
// Attach To Window
extern JULIET_API bool AttachToWindow(NonNullPtr<GraphicsDevice> device, NonNullPtr<Window> window);
extern JULIET_API void DetachFromWindow(NonNullPtr<GraphicsDevice> device, NonNullPtr<Window> window);
// SwapChain
extern JULIET_API bool AcquireSwapChainTexture(NonNullPtr<CommandList> commandList, NonNullPtr<Window> window,
Texture** swapChainTexture);
extern JULIET_API bool WaitAndAcquireSwapChainTexture(NonNullPtr<CommandList> commandList,
NonNullPtr<Window> window, Texture** swapChainTexture);
extern JULIET_API bool WaitForSwapchain(NonNullPtr<GraphicsDevice> device, NonNullPtr<Window> window);
extern JULIET_API TextureFormat GetSwapChainTextureFormat(NonNullPtr<GraphicsDevice> device, NonNullPtr<Window> window);
// SwapChain
extern JULIET_API bool AcquireSwapChainTexture(NonNullPtr<CommandList> commandList, NonNullPtr<Window> window,
Texture** swapChainTexture);
extern JULIET_API bool WaitAndAcquireSwapChainTexture(NonNullPtr<CommandList> commandList,
NonNullPtr<Window> window, Texture** swapChainTexture);
extern JULIET_API bool WaitForSwapchain(NonNullPtr<GraphicsDevice> device, NonNullPtr<Window> window);
extern JULIET_API TextureFormat GetSwapChainTextureFormat(NonNullPtr<GraphicsDevice> device, NonNullPtr<Window> window);
// Textures
extern JULIET_API Texture* CreateTexture(NonNullPtr<GraphicsDevice> device, const TextureCreateInfo& createInfo);
extern JULIET_API void DestroyTexture(NonNullPtr<GraphicsDevice> device, NonNullPtr<Texture> texture);
// Textures
extern JULIET_API Texture* CreateTexture(NonNullPtr<GraphicsDevice> device, const TextureCreateInfo& createInfo);
extern JULIET_API void DestroyTexture(NonNullPtr<GraphicsDevice> device, NonNullPtr<Texture> texture);
// Command List
extern JULIET_API CommandList* AcquireCommandList(NonNullPtr<GraphicsDevice> device, QueueType queueType = QueueType::Graphics);
extern JULIET_API void SubmitCommandLists(NonNullPtr<CommandList> commandList);
// Command List
extern JULIET_API CommandList* AcquireCommandList(NonNullPtr<GraphicsDevice> device, QueueType queueType = QueueType::Graphics);
extern JULIET_API void SubmitCommandLists(NonNullPtr<CommandList> commandList);
// RenderPass
extern JULIET_API RenderPass* BeginRenderPass(NonNullPtr<CommandList> commandList, ColorTargetInfo& colorTargetInfo,
DepthStencilTargetInfo* depthStencilTargetInfo = nullptr);
extern JULIET_API RenderPass* BeginRenderPass(NonNullPtr<CommandList> commandList,
NonNullPtr<const ColorTargetInfo> colorTargetInfos, uint32 colorTargetInfoCount,
DepthStencilTargetInfo* depthStencilTargetInfo = nullptr);
extern JULIET_API void EndRenderPass(NonNullPtr<RenderPass> renderPass);
// RenderPass
extern JULIET_API RenderPass* BeginRenderPass(NonNullPtr<CommandList> commandList, ColorTargetInfo& colorTargetInfo,
DepthStencilTargetInfo* depthStencilTargetInfo = nullptr);
extern JULIET_API RenderPass* BeginRenderPass(NonNullPtr<CommandList> commandList,
NonNullPtr<const ColorTargetInfo> colorTargetInfos, uint32 colorTargetInfoCount,
DepthStencilTargetInfo* depthStencilTargetInfo = nullptr);
extern JULIET_API void EndRenderPass(NonNullPtr<RenderPass> renderPass);
extern JULIET_API void SetGraphicsViewPort(NonNullPtr<RenderPass> renderPass, const GraphicsViewPort& viewPort);
extern JULIET_API void SetScissorRect(NonNullPtr<RenderPass> renderPass, const struct Rectangle& rectangle);
extern JULIET_API void SetBlendConstants(NonNullPtr<RenderPass> renderPass, FColor blendConstants);
extern JULIET_API void SetStencilReference(NonNullPtr<RenderPass> renderPass, uint8 reference);
extern JULIET_API void SetGraphicsViewPort(NonNullPtr<RenderPass> renderPass, const GraphicsViewPort& viewPort);
extern JULIET_API void SetScissorRect(NonNullPtr<RenderPass> renderPass, const Rectangle& rectangle);
extern JULIET_API void SetBlendConstants(NonNullPtr<RenderPass> renderPass, FColor blendConstants);
extern JULIET_API void SetStencilReference(NonNullPtr<RenderPass> renderPass, uint8 reference);
extern JULIET_API void BindGraphicsPipeline(NonNullPtr<RenderPass> renderPass, NonNullPtr<GraphicsPipeline> graphicsPipeline);
extern JULIET_API void DrawPrimitives(NonNullPtr<RenderPass> renderPass, uint32 numVertices, uint32 numInstances,
uint32 firstVertex, uint32 firstInstance);
extern JULIET_API void DrawIndexedPrimitives(NonNullPtr<RenderPass> renderPass, uint32 numIndices, uint32 numInstances,
uint32 firstIndex, uint32 vertexOffset, uint32 firstInstance);
extern JULIET_API void BindGraphicsPipeline(NonNullPtr<RenderPass> renderPass, NonNullPtr<GraphicsPipeline> graphicsPipeline);
extern JULIET_API void DrawPrimitives(NonNullPtr<RenderPass> renderPass, uint32 numVertices, uint32 numInstances,
uint32 firstVertex, uint32 firstInstance);
extern JULIET_API void DrawIndexedPrimitives(NonNullPtr<RenderPass> renderPass, uint32 numIndices, uint32 numInstances,
uint32 firstIndex, uint32 vertexOffset, uint32 firstInstance);
extern JULIET_API void SetIndexBuffer(NonNullPtr<CommandList> commandList, NonNullPtr<GraphicsBuffer> buffer,
IndexFormat format, size_t indexCount, index_t offset);
extern JULIET_API void SetIndexBuffer(NonNullPtr<CommandList> commandList, NonNullPtr<GraphicsBuffer> buffer,
IndexFormat format, size_t indexCount, index_t offset);
extern JULIET_API void SetPushConstants(NonNullPtr<CommandList> commandList, ShaderStage stage,
uint32 rootParameterIndex, uint32 numConstants, const void* constants);
extern JULIET_API void SetPushConstants(NonNullPtr<CommandList> commandList, ShaderStage stage,
uint32 rootParameterIndex, uint32 numConstants, const void* constants);
// Fences
extern JULIET_API bool WaitUntilGPUIsIdle(NonNullPtr<GraphicsDevice> device);
// Fences
extern JULIET_API bool WaitUntilGPUIsIdle(NonNullPtr<GraphicsDevice> device);
// Shaders
extern JULIET_API Shader* CreateShader(NonNullPtr<GraphicsDevice> device, String filename, ShaderCreateInfo& shaderCreateInfo);
extern JULIET_API void DestroyShader(NonNullPtr<GraphicsDevice> device, NonNullPtr<Shader> shader);
// Shaders
extern JULIET_API Shader* CreateShader(NonNullPtr<GraphicsDevice> device, String filename, ShaderCreateInfo& shaderCreateInfo);
extern JULIET_API void DestroyShader(NonNullPtr<GraphicsDevice> device, NonNullPtr<Shader> shader);
// Pipelines
extern JULIET_API GraphicsPipeline* CreateGraphicsPipeline(NonNullPtr<GraphicsDevice> device,
const GraphicsPipelineCreateInfo& createInfo);
extern JULIET_API void DestroyGraphicsPipeline(NonNullPtr<GraphicsDevice> device, NonNullPtr<GraphicsPipeline> graphicsPipeline);
// Pipelines
extern JULIET_API GraphicsPipeline* CreateGraphicsPipeline(NonNullPtr<GraphicsDevice> device,
const GraphicsPipelineCreateInfo& createInfo);
extern JULIET_API void DestroyGraphicsPipeline(NonNullPtr<GraphicsDevice> device, NonNullPtr<GraphicsPipeline> graphicsPipeline);
#if ALLOW_SHADER_HOT_RELOAD
// Allows updating the graphics pipeline shaders. Can update either one or both shaders.
extern JULIET_API bool UpdateGraphicsPipelineShaders(NonNullPtr<GraphicsDevice> device, NonNullPtr<GraphicsPipeline> graphicsPipeline,
Shader* optional_vertexShader, Shader* optional_fragmentShader);
// Allows updating the graphics pipeline shaders. Can update either one or both shaders.
extern JULIET_API bool UpdateGraphicsPipelineShaders(NonNullPtr<GraphicsDevice> device, NonNullPtr<GraphicsPipeline> graphicsPipeline,
Shader* optional_vertexShader, Shader* optional_fragmentShader);
#endif
// Buffers
extern JULIET_API GraphicsBuffer* CreateGraphicsBuffer(NonNullPtr<GraphicsDevice> device, const BufferCreateInfo& createInfo);
extern JULIET_API GraphicsTransferBuffer* CreateGraphicsTransferBuffer(NonNullPtr<GraphicsDevice> device,
const TransferBufferCreateInfo& createInfo);
extern JULIET_API void* MapGraphicsBuffer(NonNullPtr<GraphicsDevice> device, NonNullPtr<GraphicsBuffer> buffer);
extern JULIET_API void UnmapGraphicsBuffer(NonNullPtr<GraphicsDevice> device, NonNullPtr<GraphicsBuffer> buffer);
extern JULIET_API void* MapGraphicsTransferBuffer(NonNullPtr<GraphicsDevice> device, NonNullPtr<GraphicsTransferBuffer> buffer);
extern JULIET_API void UnmapGraphicsTransferBuffer(NonNullPtr<GraphicsDevice> device, NonNullPtr<GraphicsTransferBuffer> buffer);
extern JULIET_API void CopyBuffer(NonNullPtr<CommandList> commandList, NonNullPtr<GraphicsBuffer> dst,
NonNullPtr<GraphicsTransferBuffer> src, size_t size, size_t dstOffset = 0,
size_t srcOffset = 0);
extern JULIET_API void CopyBufferToTexture(NonNullPtr<CommandList> commandList, NonNullPtr<Texture> dst,
NonNullPtr<GraphicsTransferBuffer> src);
// Buffers
extern JULIET_API GraphicsBuffer* CreateGraphicsBuffer(NonNullPtr<GraphicsDevice> device, const BufferCreateInfo& createInfo);
extern JULIET_API GraphicsTransferBuffer* CreateGraphicsTransferBuffer(NonNullPtr<GraphicsDevice> device,
const TransferBufferCreateInfo& createInfo);
extern JULIET_API void* MapGraphicsBuffer(NonNullPtr<GraphicsDevice> device, NonNullPtr<GraphicsBuffer> buffer);
extern JULIET_API void UnmapGraphicsBuffer(NonNullPtr<GraphicsDevice> device, NonNullPtr<GraphicsBuffer> buffer);
extern JULIET_API void* MapGraphicsTransferBuffer(NonNullPtr<GraphicsDevice> device, NonNullPtr<GraphicsTransferBuffer> buffer);
extern JULIET_API void UnmapGraphicsTransferBuffer(NonNullPtr<GraphicsDevice> device, NonNullPtr<GraphicsTransferBuffer> buffer);
extern JULIET_API void CopyBuffer(NonNullPtr<CommandList> commandList, NonNullPtr<GraphicsBuffer> dst,
NonNullPtr<GraphicsTransferBuffer> src, size_t size, size_t dstOffset = 0,
size_t srcOffset = 0);
extern JULIET_API void CopyBufferToTexture(NonNullPtr<CommandList> commandList, NonNullPtr<Texture> dst,
NonNullPtr<GraphicsTransferBuffer> src);
extern JULIET_API void TransitionBufferToReadable(NonNullPtr<CommandList> commandList, NonNullPtr<GraphicsBuffer> buffer);
extern JULIET_API uint32 GetDescriptorIndex(NonNullPtr<GraphicsDevice> device, NonNullPtr<GraphicsBuffer> buffer);
extern JULIET_API uint32 GetDescriptorIndex(NonNullPtr<GraphicsDevice> device, NonNullPtr<Texture> texture);
extern JULIET_API void TransitionBufferToReadable(NonNullPtr<CommandList> commandList, NonNullPtr<GraphicsBuffer> buffer);
extern JULIET_API uint32 GetDescriptorIndex(NonNullPtr<GraphicsDevice> device, NonNullPtr<GraphicsBuffer> buffer);
extern JULIET_API uint32 GetDescriptorIndex(NonNullPtr<GraphicsDevice> device, NonNullPtr<Texture> texture);
extern JULIET_API void DestroyGraphicsBuffer(NonNullPtr<GraphicsDevice> device, NonNullPtr<GraphicsBuffer> buffer);
extern JULIET_API void DestroyGraphicsTransferBuffer(NonNullPtr<GraphicsDevice> device, NonNullPtr<GraphicsTransferBuffer> buffer);
} // namespace Juliet
extern JULIET_API void DestroyGraphicsBuffer(NonNullPtr<GraphicsDevice> device, NonNullPtr<GraphicsBuffer> buffer);
extern JULIET_API void DestroyGraphicsTransferBuffer(NonNullPtr<GraphicsDevice> device, NonNullPtr<GraphicsTransferBuffer> buffer);
Juliet/include/Graphics/GraphicsBuffer.h
+27 -30
View File
@@ -1,36 +1,33 @@
#pragma once
#pragma once
namespace Juliet
enum class BufferUsage : uint8
{
enum class BufferUsage : uint8
{
None = 0,
IndexBuffer = 1 << 0,
ConstantBuffer = 1 << 1,
StructuredBuffer = 1 << 2,
};
None = 0,
IndexBuffer = 1 << 0,
ConstantBuffer = 1 << 1,
StructuredBuffer = 1 << 2,
};
enum class TransferBufferUsage : uint8
{
Download,
Upload
};
enum class TransferBufferUsage : uint8
{
Download,
Upload
};
struct BufferCreateInfo
{
size_t Size;
size_t Stride;
BufferUsage Usage;
bool IsDynamic;
};
struct BufferCreateInfo
{
size_t Size;
size_t Stride;
BufferUsage Usage;
bool IsDynamic;
};
struct TransferBufferCreateInfo
{
size_t Size;
TransferBufferUsage Usage;
};
struct TransferBufferCreateInfo
{
size_t Size;
TransferBufferUsage Usage;
};
// Opaque
struct GraphicsBuffer;
struct GraphicsTransferBuffer;
} // namespace Juliet
// Opaque
struct GraphicsBuffer;
struct GraphicsTransferBuffer;
Juliet/include/Graphics/GraphicsConfig.h
+9 -12
View File
@@ -10,17 +10,14 @@
#define ALLOW_SHADER_HOT_RELOAD 0
#endif
namespace Juliet
enum class GraphicsDriverType : uint8
{
enum class DriverType : uint8
{
Any = 0,
DX12 = 1,
};
Any = 0,
DX12 = 1,
};
struct GraphicsConfig
{
DriverType PreferredDriver = DriverType::DX12;
bool EnableDebug;
};
} // namespace Juliet
struct GraphicsConfig
{
GraphicsDriverType PreferredDriver = GraphicsDriverType::DX12;
bool EnableDebug;
};
Juliet/include/Graphics/GraphicsPipeline.h
+187 -190
View File
@@ -1,225 +1,222 @@
#pragma once
#pragma once
#include <Graphics/Shader.h>
#include <Graphics/Texture.h>
namespace Juliet
// Forward Declare
struct ColorTargetDescription;
enum class FillMode : uint8
{
// Forward Declare
struct ColorTargetDescription;
Solid,
Wireframe,
Count
};
enum class FillMode : uint8
{
Solid,
Wireframe,
Count
};
enum class CullMode : uint8
{
None,
Front,
Back,
Count
};
enum class CullMode : uint8
{
None,
Front,
Back,
Count
};
enum class FrontFace : uint8
{
CounterClockwise,
Clockwise,
Count
};
enum class FrontFace : uint8
{
CounterClockwise,
Clockwise,
Count
};
enum class PrimitiveType : uint8
{
TriangleList,
TriangleStrip,
LineList,
LineStrip,
PointList,
Count
};
enum class PrimitiveType : uint8
{
TriangleList,
TriangleStrip,
LineList,
LineStrip,
PointList,
Count
};
struct RasterizerState
{
FillMode FillMode;
CullMode CullMode;
FrontFace FrontFace;
struct RasterizerState
{
FillMode FillMode;
CullMode CullMode;
FrontFace FrontFace;
float DepthBiasConstantFactor; // How much depth value is added to each fragment
float DepthBiasClamp; // Maximum depth bias
float DepthBiasSlopeFactor; // Scalar applied to Fragment's slope
bool EnableDepthBias; // Bias fragment depth values
bool EnableDepthClip; // True to clip, false to clamp
};
float DepthBiasConstantFactor; // How much depth value is added to each fragment
float DepthBiasClamp; // Maximum depth bias
float DepthBiasSlopeFactor; // Scalar applied to Fragment's slope
bool EnableDepthBias; // Bias fragment depth values
bool EnableDepthClip; // True to clip, false to clamp
};
enum class VertexInputRate : uint8
{
Vertex, // Use vertex index
Instance, // Use instance index
Count
};
enum class VertexInputRate : uint8
{
Vertex, // Use vertex index
Instance, // Use instance index
Count
};
struct VertexBufferDescription
{
uint32 Slot; // Binding Slot
uint32 PitchInBytes; // Pitch between two elements
VertexInputRate InputRate;
uint32 InstanceStepRate; // Only used when input rate == Instance. Number of instances to draw before advancing in the instance buffer by 1
};
struct VertexBufferDescription
{
uint32 Slot; // Binding Slot
uint32 PitchInBytes; // Pitch between two elements
VertexInputRate InputRate;
uint32 InstanceStepRate; // Only used when input rate == Instance. Number of instances to draw before advancing in the instance buffer by 1
};
enum class VertexElementFormat : uint8
{
Invalid,
enum class VertexElementFormat : uint8
{
Invalid,
/* 32-bit Signed Integers */
Int,
Int2,
Int3,
Int4,
/* 32-bit Signed Integers */
Int,
Int2,
Int3,
Int4,
/* 32-bit Unsigned Integers */
UInt,
UInt2,
UInt3,
UInt4,
/* 32-bit Unsigned Integers */
UInt,
UInt2,
UInt3,
UInt4,
/* 32-bit Floats */
Float,
Float2,
Float3,
Float4,
/* 32-bit Floats */
Float,
Float2,
Float3,
Float4,
/* 8-bit Signed Integers */
Byte2,
Byte4,
/* 8-bit Signed Integers */
Byte2,
Byte4,
/* 8-bit Unsigned Integers */
UByte2,
UByte4,
/* 8-bit Unsigned Integers */
UByte2,
UByte4,
/* 8-bit Signed Normalized */
Byte2_Norm,
Byte4_Norm,
/* 8-bit Signed Normalized */
Byte2_Norm,
Byte4_Norm,
/* 8-bit Unsigned Normalized */
UByte2_Norm,
UByte4_Norm,
/* 8-bit Unsigned Normalized */
UByte2_Norm,
UByte4_Norm,
/* 16-bit Signed Integers */
Short2,
Short4,
/* 16-bit Signed Integers */
Short2,
Short4,
/* 16-bit Unsigned Integers */
UShort2,
UShort4,
/* 16-bit Unsigned Integers */
UShort2,
UShort4,
/* 16-bit Signed Normalized */
Short2_Norm,
Short4_Norm,
/* 16-bit Signed Normalized */
Short2_Norm,
Short4_Norm,
/* 16-bit Unsigned Normalized */
UShort2_Norm,
UShort4_Norm,
/* 16-bit Unsigned Normalized */
UShort2_Norm,
UShort4_Norm,
/* 16-bit Floats */
Half2,
Half4,
/* 16-bit Floats */
Half2,
Half4,
//
Count
};
//
Count
};
struct VertexAttribute
{
uint32 Location; // Shader input location index
uint32 BufferSlot; // Binding slot of associated vertex buffer
VertexElementFormat Format; // Size and type of attribute
uint32 Offset; // Offset of this attribute relative to the start of the vertex element
};
struct VertexAttribute
{
uint32 Location; // Shader input location index
uint32 BufferSlot; // Binding slot of associated vertex buffer
VertexElementFormat Format; // Size and type of attribute
uint32 Offset; // Offset of this attribute relative to the start of the vertex element
};
struct VertexInputState
{
const VertexBufferDescription* VertexBufferDescriptions;
uint32 NumVertexBufferDescriptions;
const VertexAttribute* VertexAttributes;
uint32 NumVertexAttributes;
};
struct VertexInputState
{
const VertexBufferDescription* VertexBufferDescriptions;
uint32 NumVertexBufferDescriptions;
const VertexAttribute* VertexAttributes;
uint32 NumVertexAttributes;
};
struct GraphicsPipelineTargetInfo
{
const ColorTargetDescription* ColorTargetDescriptions;
size_t NumColorTargets;
TextureFormat DepthStencilFormat;
bool HasDepthStencilTarget;
};
struct GraphicsPipelineTargetInfo
{
const ColorTargetDescription* ColorTargetDescriptions;
size_t NumColorTargets;
TextureFormat DepthStencilFormat;
bool HasDepthStencilTarget;
};
enum class CompareOperation : uint8
{
Invalid,
Never, // The comparison always evaluates false.
Less, // The comparison evaluates reference < test.
Equal, // The comparison evaluates reference == test.
LessOrEqual, // The comparison evaluates reference <= test.
Greater, // The comparison evaluates reference > test.
NotEqual, // The comparison evaluates reference != test.
GreaterOrEqual, // The comparison evalutes reference >= test.
Always, // The comparison always evaluates true.
Count
};
enum class CompareOperation : uint8
{
Invalid,
Never, // The comparison always evaluates false.
Less, // The comparison evaluates reference < test.
Equal, // The comparison evaluates reference == test.
LessOrEqual, // The comparison evaluates reference <= test.
Greater, // The comparison evaluates reference > test.
NotEqual, // The comparison evaluates reference != test.
GreaterOrEqual, // The comparison evalutes reference >= test.
Always, // The comparison always evaluates true.
Count
};
enum class StencilOperation : uint8
{
Invalid,
Keep, // Keeps the current value.
Zero, // Sets the value to 0.
Replace, // Sets the value to reference.
IncrementAndClamp, // Increments the current value and clamps to the maximum value.
DecrementAndClamp, // Decrements the current value and clamps to 0.
Invert, // Bitwise-inverts the current value.
IncrementAndWrap, // Increments the current value and wraps back to 0.
DecrementAndWrap, // Decrements the current value and wraps to the maximum value.
Count
};
enum class StencilOperation : uint8
{
Invalid,
Keep, // Keeps the current value.
Zero, // Sets the value to 0.
Replace, // Sets the value to reference.
IncrementAndClamp, // Increments the current value and clamps to the maximum value.
DecrementAndClamp, // Decrements the current value and clamps to 0.
Invert, // Bitwise-inverts the current value.
IncrementAndWrap, // Increments the current value and wraps back to 0.
DecrementAndWrap, // Decrements the current value and wraps to the maximum value.
Count
};
struct StencilOperationState
{
StencilOperation FailOperation; // The action performed on samples that fail the stencil test.
StencilOperation PassOperation; // The action performed on samples that pass the depth and stencil tests.
StencilOperation DepthFailOperation; // The action performed on samples that pass the stencil test and fail the depth test.
StencilOperation CompareOperation; // The comparison operator used in the stencil test.
};
struct StencilOperationState
{
StencilOperation FailOperation; // The action performed on samples that fail the stencil test.
StencilOperation PassOperation; // The action performed on samples that pass the depth and stencil tests.
StencilOperation DepthFailOperation; // The action performed on samples that pass the stencil test and fail the depth test.
StencilOperation CompareOperation; // The comparison operator used in the stencil test.
};
struct DepthStencilState
{
CompareOperation CompareOperation; // The comparison operator used for depth testing.
StencilOperationState BackStencilState; // The stencil op state for back-facing triangles.
StencilOperationState FrontStencilState; // The stencil op state for front-facing triangles.
uint8 CompareMask; // Selects the bits of the stencil values participating in the stencil test.
uint8 WriteMask; // Selects the bits of the stencil values updated by the stencil test.
bool EnableDepthTest : 1; // true enables the depth test.
bool EnableDepthWrite : 1; // true enables depth writes. Depth writes are always disabled when enable_depth_test is false.
bool EnableStencilTest : 1; // true enables the stencil test.
};
struct DepthStencilState
{
CompareOperation CompareOperation; // The comparison operator used for depth testing.
StencilOperationState BackStencilState; // The stencil op state for back-facing triangles.
StencilOperationState FrontStencilState; // The stencil op state for front-facing triangles.
uint8 CompareMask; // Selects the bits of the stencil values participating in the stencil test.
uint8 WriteMask; // Selects the bits of the stencil values updated by the stencil test.
bool EnableDepthTest : 1; // true enables the depth test.
bool EnableDepthWrite : 1; // true enables depth writes. Depth writes are always disabled when enable_depth_test is false.
bool EnableStencilTest : 1; // true enables the stencil test.
};
struct MultisampleState
{
TextureSampleCount SampleCount;
uint32 SampleMask; // Which sample should be updated. If Enabled mask == false -> 0xFFFFFFFF
bool EnableMask;
};
struct MultisampleState
{
TextureSampleCount SampleCount;
uint32 SampleMask; // Which sample should be updated. If Enabled mask == false -> 0xFFFFFFFF
bool EnableMask;
};
struct GraphicsPipelineCreateInfo
{
Shader* VertexShader;
Shader* FragmentShader;
PrimitiveType PrimitiveType;
GraphicsPipelineTargetInfo TargetInfo;
RasterizerState RasterizerState;
MultisampleState MultisampleState;
VertexInputState VertexInputState;
DepthStencilState DepthStencilState;
};
struct GraphicsPipelineCreateInfo
{
Shader* VertexShader;
Shader* FragmentShader;
PrimitiveType PrimitiveType;
GraphicsPipelineTargetInfo TargetInfo;
RasterizerState RasterizerState;
MultisampleState MultisampleState;
VertexInputState VertexInputState;
DepthStencilState DepthStencilState;
};
// Opaque type
struct GraphicsPipeline;
} // namespace Juliet
// Opaque type
struct GraphicsPipeline;
Juliet/include/Graphics/ImGuiRenderer.h
+5 -8
View File
@@ -1,12 +1,9 @@
#pragma once
#pragma once
#include <Graphics/Graphics.h>
#include <Juliet.h>
namespace Juliet
{
extern bool ImGuiRenderer_Initialize(GraphicsDevice* device);
extern void ImGuiRenderer_Shutdown(GraphicsDevice* device);
extern void ImGuiRenderer_NewFrame();
extern JULIET_API void ImGuiRenderer_Render(CommandList* cmdList, RenderPass* renderPass);
} // namespace Juliet
extern bool ImGuiRenderer_Initialize(GraphicsDevice* device);
extern void ImGuiRenderer_Shutdown(GraphicsDevice* device);
extern void ImGuiRenderer_NewFrame();
extern JULIET_API void ImGuiRenderer_Render(CommandList* cmdList, RenderPass* renderPass);
Juliet/include/Graphics/Lighting.h
+7 -10
View File
@@ -1,15 +1,12 @@
#pragma once
#pragma once
#include <Juliet.h>
#include <Core/Math/Vector.h>
namespace Juliet
struct PointLight
{
struct PointLight
{
Vector3 Position;
float Radius;
Vector3 Color;
float Intensity;
};
} // namespace Juliet
Vector3 Position;
float Radius;
Vector3 Color;
float Intensity;
};
Juliet/include/Graphics/Mesh.h
+25 -28
View File
@@ -1,4 +1,4 @@
#pragma once
#pragma once
#include <Core/Common/CoreTypes.h>
#include <Core/Common/NonNullPtr.h>
@@ -7,34 +7,31 @@
#include <Core/Math/Vector.h>
#include <Juliet.h>
namespace Juliet
struct Arena;
struct Vertex;
using MeshAssetID = index_t;
using MaterialAssetID = index_t;
using MeshInstanceID = index_t;
struct MeshAsset
{
struct Arena;
struct Vertex;
String Name;
size_t VertexCount;
size_t IndexCount;
using MeshAssetID = index_t;
using MaterialAssetID = index_t;
using MeshInstanceID = index_t;
index_t VertexOffset;
index_t IndexOffset;
};
struct MeshAsset
{
String Name;
size_t VertexCount;
size_t IndexCount;
struct MaterialAsset
{
Vector4 AlbedoColor = {1.0f, 1.0f, 1.0f, 1.0f};
};
index_t VertexOffset;
index_t IndexOffset;
};
struct MaterialAsset
{
Vector4 AlbedoColor = {1.0f, 1.0f, 1.0f, 1.0f};
};
struct MeshInstance
{
MeshAssetID MeshAsset;
MaterialAssetID MaterialAsset;
Matrix Transform = MatrixIdentity();
};
} // namespace Juliet
struct MeshInstance
{
MeshAssetID MeshAsset;
MaterialAssetID MaterialAsset;
Matrix Transform = MatrixIdentity();
};
Juliet/include/Graphics/MeshRenderer.h
+38 -41
View File
@@ -1,4 +1,4 @@
#pragma once
#pragma once
#include <Core/Container/Vector.h>
#include <Core/Math/Matrix.h>
@@ -9,52 +9,49 @@
#include <Graphics/Mesh.h>
#include <Juliet.h>
namespace Juliet
{
struct GraphicsTransferBuffer;
struct RenderPass;
struct CommandList;
struct GraphicsBuffer;
struct Window;
struct GraphicsPipeline;
struct GraphicsDevice;
using LightID = index_t;
struct GraphicsTransferBuffer;
struct RenderPass;
struct CommandList;
struct GraphicsBuffer;
struct Window;
struct GraphicsPipeline;
struct GraphicsDevice;
using LightID = index_t;
constexpr size_t kGeometryPage = Megabytes(64);
constexpr size_t kIndexPage = Megabytes(32);
constexpr size_t kDefaultMeshNumber = 500;
constexpr size_t kDefaultVertexCount = 2'000'000; // Fit less than one geometry page
constexpr size_t kDefaultIndexCount = 16'000'000; // Fit less than one index page
constexpr size_t kDefaultLightCount = 1024;
constexpr size_t kGeometryPage = Megabytes(64);
constexpr size_t kIndexPage = Megabytes(32);
constexpr size_t kDefaultMeshNumber = 500;
constexpr size_t kDefaultVertexCount = 2'000'000; // Fit less than one geometry page
constexpr size_t kDefaultIndexCount = 16'000'000; // Fit less than one index page
constexpr size_t kDefaultLightCount = 1024;
JULIET_API void InitializeMeshRenderer(NonNullPtr<Arena> assetArena, NonNullPtr<Arena> instanceArena);
[[nodiscard]] JULIET_API bool InitializeMeshRendererGraphics(NonNullPtr<GraphicsDevice> device, NonNullPtr<Window> window);
JULIET_API void ShutdownMeshRendererGraphics();
JULIET_API void ShutdownMeshRenderer();
JULIET_API void LoadMeshesOnGPU(NonNullPtr<CommandList> cmdList);
JULIET_API void RenderMeshes(NonNullPtr<CommandList> cmdList, NonNullPtr<RenderPass> pass, const Matrix& viewProjection);
JULIET_API void InitializeMeshRenderer(NonNullPtr<Arena> assetArena, NonNullPtr<Arena> instanceArena);
[[nodiscard]] JULIET_API bool InitializeMeshRendererGraphics(NonNullPtr<GraphicsDevice> device, NonNullPtr<Window> window);
JULIET_API void ShutdownMeshRendererGraphics();
JULIET_API void ShutdownMeshRenderer();
JULIET_API void LoadMeshesOnGPU(NonNullPtr<CommandList> cmdList);
JULIET_API void RenderMeshes(NonNullPtr<CommandList> cmdList, NonNullPtr<RenderPass> pass, const Matrix& viewProjection);
// Lights
[[nodiscard]] JULIET_API LightID AddPointLight(const PointLight& light);
JULIET_API void SetPointLightPosition(LightID id, const Vector3& position);
JULIET_API void SetPointLightColor(LightID id, const Vector3& color);
JULIET_API void SetPointLightRadius(LightID id, float radius);
JULIET_API void SetPointLightIntensity(LightID id, float intensity);
JULIET_API void ClearPointLights();
JULIET_API void SetGlobalLight(const Vector3& direction, const Vector3& color, float ambientIntensity);
// Lights
[[nodiscard]] JULIET_API LightID AddPointLight(const PointLight& light);
JULIET_API void SetPointLightPosition(LightID id, const Vector3& position);
JULIET_API void SetPointLightColor(LightID id, const Vector3& color);
JULIET_API void SetPointLightRadius(LightID id, float radius);
JULIET_API void SetPointLightIntensity(LightID id, float intensity);
JULIET_API void ClearPointLights();
JULIET_API void SetGlobalLight(const Vector3& direction, const Vector3& color, float ambientIntensity);
// Assets & Instances
[[nodiscard]] JULIET_API MeshAssetID GetOrCreateMeshAsset(String name);
[[nodiscard]] JULIET_API MeshInstanceID CreateMeshInstance(MeshAssetID meshAsset, MaterialAssetID materialAsset, const Matrix& transform);
JULIET_API void SetMeshInstanceTransform(MeshInstanceID id, const Matrix& transform);
// Assets & Instances
[[nodiscard]] JULIET_API MeshAssetID GetOrCreateMeshAsset(String name);
[[nodiscard]] JULIET_API MeshInstanceID CreateMeshInstance(MeshAssetID meshAsset, MaterialAssetID materialAsset, const Matrix& transform);
JULIET_API void SetMeshInstanceTransform(MeshInstanceID id, const Matrix& transform);
// Primitives
JULIET_API MeshAssetID GetCubePrimitiveMeshAssetID();
JULIET_API MeshAssetID GetQuadPrimitiveMeshAssetID();
JULIET_API MeshAssetID GetSpherePrimitiveMeshAssetID();
// Primitives
JULIET_API MeshAssetID GetCubePrimitiveMeshAssetID();
JULIET_API MeshAssetID GetQuadPrimitiveMeshAssetID();
JULIET_API MeshAssetID GetSpherePrimitiveMeshAssetID();
#if ALLOW_SHADER_HOT_RELOAD
JULIET_API void ReloadMeshRendererShaders();
JULIET_API void ReloadMeshRendererShaders();
#endif
} // namespace Juliet
Juliet/include/Graphics/PushConstants.h
+19 -22
View File
@@ -1,32 +1,29 @@
#pragma once
#pragma once
#include <Core/Math/Matrix.h>
#include <Core/Math/Vector.h>
#include <Juliet.h>
namespace Juliet
struct PushData
{
struct PushData
{
Matrix ViewProjection;
uint32 MeshIndex;
uint32 TransformsBufferIndex;
uint32 BufferIndex;
uint32 TextureIndex;
uint32 VertexOffset;
uint32 LightBufferIndex;
uint32 ActiveLightCount;
float GlobalAmbientIntensity;
Matrix ViewProjection;
uint32 MeshIndex;
uint32 TransformsBufferIndex;
uint32 BufferIndex;
uint32 TextureIndex;
uint32 VertexOffset;
uint32 LightBufferIndex;
uint32 ActiveLightCount;
float GlobalAmbientIntensity;
Vector3 GlobalLightDirection;
uint32 Pad1;
Vector3 GlobalLightDirection;
uint32 Pad1;
Vector3 GlobalLightColor;
uint32 Pad2;
Vector3 GlobalLightColor;
uint32 Pad2;
float Scale[2];
float Translate[2];
float Scale[2];
float Translate[2];
Vector4 MeshAlbedo;
};
} // namespace Juliet
Vector4 MeshAlbedo;
};
Juliet/include/Graphics/RenderPass.h
+95 -98
View File
@@ -1,115 +1,112 @@
#pragma once
#pragma once
#include <Graphics/Colors.h>
#include <Graphics/Texture.h>
namespace Juliet
enum struct LoadOperation : uint8
{
enum struct LoadOperation : uint8
Load, // Load the texture from memory (preserve)
Clear, // Clear the texture
Ignore // Ignore the content of the texture (undefined)
};
enum struct StoreOperation : uint8
{
Store, // Store the result of the render pass into memory
Ignore, // Whatever is generated is ignored (undefined)
Resolve, // Resolve MipMaps into non mip map texture. Discard MipMap content
ResolveAndStore // Same but store the MipMap content to memory
};
struct ColorTargetInfo
{
Texture* TargetTexture;
uint32 MipLevel;
union
{
Load, // Load the texture from memory (preserve)
Clear, // Clear the texture
Ignore // Ignore the content of the texture (undefined)
uint32 DepthPlane;
uint32 LayerIndex;
};
bool CycleTexture; // Whether the texture should be cycled if already bound (and load operation != LOAD)
enum struct StoreOperation : uint8
{
Store, // Store the result of the render pass into memory
Ignore, // Whatever is generated is ignored (undefined)
Resolve, // Resolve MipMaps into non mip map texture. Discard MipMap content
ResolveAndStore // Same but store the MipMap content to memory
};
Texture* ResolveTexture;
uint32 ResolveMipLevel;
uint32 ResolveLayerIndex;
bool CycleResolveTexture;
struct ColorTargetInfo
{
Texture* TargetTexture;
uint32 MipLevel;
union
{
uint32 DepthPlane;
uint32 LayerIndex;
};
bool CycleTexture; // Whether the texture should be cycled if already bound (and load operation != LOAD)
FColor ClearColor;
LoadOperation LoadOperation;
StoreOperation StoreOperation;
};
Texture* ResolveTexture;
uint32 ResolveMipLevel;
uint32 ResolveLayerIndex;
bool CycleResolveTexture;
struct DepthStencilTargetInfo
{
Texture* TargetTexture;
uint32 MipLevel;
uint32 LayerIndex;
FColor ClearColor;
LoadOperation LoadOperation;
StoreOperation StoreOperation;
};
float ClearDepth;
uint8 ClearStencil;
LoadOperation LoadOperation;
StoreOperation StoreOperation;
};
struct DepthStencilTargetInfo
{
Texture* TargetTexture;
uint32 MipLevel;
uint32 LayerIndex;
enum class BlendFactor : uint8
{
Invalid,
Zero,
One,
Src_Color,
One_Minus_Src_Color,
Dst_Color,
One_Minus_Dst_Color,
Src_Alpha,
One_Minus_Src_Alpha,
Dst_Alpha,
One_Minus_Dst_Alpha,
Constant_Color,
One_MINUS_Constant_Color,
Src_Alpha_Saturate, // min(source alpha, 1 - destination alpha)
Count
};
float ClearDepth;
uint8 ClearStencil;
LoadOperation LoadOperation;
StoreOperation StoreOperation;
};
enum class BlendOperation : uint8
{
Invalid,
Add, // (source * source_factor) + (destination * destination_factor)
Subtract, // (source * source_factor) - (destination * destination_factor)
ReverseSubtract, // (destination * destination_factor) - (source * source_factor)
Min, // min(source, destination)
Max, // max(source, destination)
Count
};
enum class BlendFactor : uint8
{
Invalid,
Zero,
One,
Src_Color,
One_Minus_Src_Color,
Dst_Color,
One_Minus_Dst_Color,
Src_Alpha,
One_Minus_Src_Alpha,
Dst_Alpha,
One_Minus_Dst_Alpha,
Constant_Color,
One_MINUS_Constant_Color,
Src_Alpha_Saturate, // min(source alpha, 1 - destination alpha)
Count
};
enum class ColorComponentFlags : uint8
{
R = 1u << 0,
G = 1u << 1,
B = 1u << 2,
A = 1u << 3
};
enum class BlendOperation : uint8
{
Invalid,
Add, // (source * source_factor) + (destination * destination_factor)
Subtract, // (source * source_factor) - (destination * destination_factor)
ReverseSubtract, // (destination * destination_factor) - (source * source_factor)
Min, // min(source, destination)
Max, // max(source, destination)
Count
};
struct ColorTargetBlendState
{
BlendFactor SourceColorBlendFactor; // The value to be multiplied by the source RGB value.
BlendFactor DestinationColorBlendFactor; // The value to be multiplied by the destination RGB value.
BlendOperation ColorBlendOperation; // The blend operation for the RGB components.
BlendFactor SourceAlphaBlendFactor; // The value to be multiplied by the source alpha.
BlendFactor DestinationAlphaBlendFactor; // The value to be multiplied by the destination alpha.
BlendOperation AlphaBlendOperation; // The blend operation for the alpha component.
ColorComponentFlags ColorWriteMask; // A bitmask specifying which of the RGBA components are enabled for writing. Writes to all channels if enable_color_write_mask is false.
bool EnableBlend : 1; // Whether blending is enabled for the color target.
bool EnableColorWriteMask : 1; // Whether the color write mask is enabled.
};
enum class ColorComponentFlags : uint8
{
R = 1u << 0,
G = 1u << 1,
B = 1u << 2,
A = 1u << 3
};
struct ColorTargetDescription
{
TextureFormat Format;
ColorTargetBlendState BlendState;
};
struct ColorTargetBlendState
{
BlendFactor SourceColorBlendFactor; // The value to be multiplied by the source RGB value.
BlendFactor DestinationColorBlendFactor; // The value to be multiplied by the destination RGB value.
BlendOperation ColorBlendOperation; // The blend operation for the RGB components.
BlendFactor SourceAlphaBlendFactor; // The value to be multiplied by the source alpha.
BlendFactor DestinationAlphaBlendFactor; // The value to be multiplied by the destination alpha.
BlendOperation AlphaBlendOperation; // The blend operation for the alpha component.
ColorComponentFlags ColorWriteMask; // A bitmask specifying which of the RGBA components are enabled for writing. Writes to all channels if enable_color_write_mask is false.
bool EnableBlend : 1; // Whether blending is enabled for the color target.
bool EnableColorWriteMask : 1; // Whether the color write mask is enabled.
};
struct ColorTargetDescription
{
TextureFormat Format;
ColorTargetBlendState BlendState;
};
// Opaque Type
struct RenderPass;
} // namespace Juliet
// Opaque Type
struct RenderPass;
Juliet/include/Graphics/Shader.h
+14 -17
View File
@@ -1,23 +1,20 @@
#pragma once
#pragma once
#include <Core/Common/String.h>
namespace Juliet
// Opaque type
struct Shader;
enum class ShaderStage : uint8
{
// Opaque type
struct Shader;
Vertex,
Fragment,
Compute
};
enum class ShaderStage : uint8
{
Vertex,
Fragment,
Compute
};
struct ShaderCreateInfo
{
ShaderStage Stage;
String EntryPoint;
};
struct ShaderCreateInfo
{
ShaderStage Stage;
String EntryPoint;
};
} // namespace Juliet
Juliet/include/Graphics/SkyboxRenderer.h
+15 -18
View File
@@ -1,4 +1,4 @@
#pragma once
#pragma once
#include <Juliet.h>
@@ -6,26 +6,23 @@
#include <Core/Math/Matrix.h>
#include <Graphics/GraphicsConfig.h>
namespace Juliet
struct RenderPass;
struct CommandList;
struct Window;
struct GraphicsPipeline;
struct GraphicsDevice;
struct SkyboxRenderer
{
struct RenderPass;
struct CommandList;
struct Window;
struct GraphicsPipeline;
struct GraphicsDevice;
GraphicsDevice* Device;
GraphicsPipeline* Pipeline;
};
struct SkyboxRenderer
{
GraphicsDevice* Device;
GraphicsPipeline* Pipeline;
};
[[nodiscard]] JULIET_API bool InitializeSkyboxRenderer(NonNullPtr<GraphicsDevice> device, NonNullPtr<Window> window);
JULIET_API void ShutdownSkyboxRenderer();
JULIET_API void RenderSkybox(NonNullPtr<CommandList> cmdList, NonNullPtr<RenderPass> pass, const Matrix& viewProjection);
[[nodiscard]] JULIET_API bool InitializeSkyboxRenderer(NonNullPtr<GraphicsDevice> device, NonNullPtr<Window> window);
JULIET_API void ShutdownSkyboxRenderer();
JULIET_API void RenderSkybox(NonNullPtr<CommandList> cmdList, NonNullPtr<RenderPass> pass, const Matrix& viewProjection);
#if ALLOW_SHADER_HOT_RELOAD
JULIET_API void ReloadSkyboxShaders();
JULIET_API void ReloadSkyboxShaders();
#endif
} // namespace Juliet
Juliet/include/Graphics/Texture.h
+176 -179
View File
@@ -1,183 +1,180 @@
#pragma once
#pragma once
namespace Juliet
enum struct TextureFormat : uint8
{
enum struct TextureFormat : uint8
Invalid,
/* Unsigned Normalized Float Color Formats */
A8_UNORM,
R8_UNORM,
R8G8_UNORM,
R8G8B8A8_UNORM,
R16_UNORM,
R16G16_UNORM,
R16G16B16A16_UNORM,
R10G10B10A2_UNORM,
B5G6R5_UNORM,
B5G5R5A1_UNORM,
B4G4R4A4_UNORM,
B8G8R8A8_UNORM,
/* Compressed Unsigned Normalized Float Color Formats */
BC1_RGBA_UNORM,
BC2_RGBA_UNORM,
BC3_RGBA_UNORM,
BC4_R_UNORM,
BC5_RG_UNORM,
BC7_RGBA_UNORM,
/* Compressed Signed Float Color Formats */
BC6H_RGB_FLOAT,
/* Compressed Unsigned Float Color Formats */
BC6H_RGB_UFLOAT,
/* Signed Normalized Float Color Formats */
R8_SNORM,
R8G8_SNORM,
R8G8B8A8_SNORM,
R16_SNORM,
R16G16_SNORM,
R16G16B16A16_SNORM,
/* Signed Float Color Formats */
R16_FLOAT,
R16G16_FLOAT,
R16G16B16A16_FLOAT,
R32_FLOAT,
R32G32_FLOAT,
R32G32B32A32_FLOAT,
/* Unsigned Float Color Formats */
R11G11B10_UFLOAT,
/* Unsigned Integer Color Formats */
R8_UINT,
R8G8_UINT,
R8G8B8A8_UINT,
R16_UINT,
R16G16_UINT,
R16G16B16A16_UINT,
R32_UINT,
R32G32_UINT,
R32G32B32A32_UINT,
/* Signed Integer Color Formats */
R8_INT,
R8G8_INT,
R8G8B8A8_INT,
R16_INT,
R16G16_INT,
R16G16B16A16_INT,
R32_INT,
R32G32_INT,
R32G32B32A32_INT,
/* SRGB Unsigned Normalized Color Formats */
R8G8B8A8_UNORM_SRGB,
B8G8R8A8_UNORM_SRGB,
/* Compressed SRGB Unsigned Normalized Color Formats */
BC1_RGBA_UNORM_SRGB,
BC2_RGBA_UNORM_SRGB,
BC3_RGBA_UNORM_SRGB,
BC7_RGBA_UNORM_SRGB,
/* Depth Formats */
D16_UNORM,
D24_UNORM,
D32_FLOAT,
D24_UNORM_S8_UINT,
D32_FLOAT_S8_UINT,
/* Compressed ASTC Normalized Float Color Formats*/
ASTC_4x4_UNORM,
ASTC_5x4_UNORM,
ASTC_5x5_UNORM,
ASTC_6x5_UNORM,
ASTC_6x6_UNORM,
ASTC_8x5_UNORM,
ASTC_8x6_UNORM,
ASTC_8x8_UNORM,
ASTC_10x5_UNORM,
ASTC_10x6_UNORM,
ASTC_10x8_UNORM,
ASTC_10x10_UNORM,
ASTC_12x10_UNORM,
ASTC_12x12_UNORM,
/* Compressed SRGB ASTC Normalized Float Color Formats*/
ASTC_4x4_UNORM_SRGB,
ASTC_5x4_UNORM_SRGB,
ASTC_5x5_UNORM_SRGB,
ASTC_6x5_UNORM_SRGB,
ASTC_6x6_UNORM_SRGB,
ASTC_8x5_UNORM_SRGB,
ASTC_8x6_UNORM_SRGB,
ASTC_8x8_UNORM_SRGB,
ASTC_10x5_UNORM_SRGB,
ASTC_10x6_UNORM_SRGB,
ASTC_10x8_UNORM_SRGB,
ASTC_10x10_UNORM_SRGB,
ASTC_12x10_UNORM_SRGB,
ASTC_12x12_UNORM_SRGB,
/* Compressed ASTC Signed Float Color Formats*/
ASTC_4x4_FLOAT,
ASTC_5x4_FLOAT,
ASTC_5x5_FLOAT,
ASTC_6x5_FLOAT,
ASTC_6x6_FLOAT,
ASTC_8x5_FLOAT,
ASTC_8x6_FLOAT,
ASTC_8x8_FLOAT,
ASTC_10x5_FLOAT,
ASTC_10x6_FLOAT,
ASTC_10x8_FLOAT,
ASTC_10x10_FLOAT,
ASTC_12x10_FLOAT,
ASTC_12x12_FLOAT,
Count
};
enum struct TextureUsageFlag : uint8
{
None = 0,
Sampler = 1 << 0, // Textures supports sampling
ColorTarget = 1 << 1, // Texture is color render target
DepthStencilTarget = 1 << 2, // Texture is depth stencil target
GraphicsStorageRead = 1 << 3, // Support Storage read at graphics stage
ComputeStorageRead = 1 << 4, // Support Storage read at compute stage
ComputeStorageWrite = 1 << 5, // Support Storage Write at compute stage
ComputeStorageSimultaneousReadWrite =
1 << 6, // Supports reads and writes in the same compute shader. Not equivalent to ComputeStorageRead | ComputeStorageWrite
};
enum struct TextureType : uint8
{
Texture_2D,
Texture_2DArray,
Texture_3D,
Texture_3DArray,
Texture_Cube,
Texture_CubeArray,
};
enum struct TextureSampleCount : uint8
{
One,
Two,
Four,
Eight,
};
// Create Information structs
struct TextureCreateInfo
{
TextureType Type;
TextureFormat Format;
TextureUsageFlag Flags;
TextureSampleCount SampleCount;
uint32 Width;
uint32 Height;
union
{
Invalid,
uint32 LayerCount;
uint32 DepthPlane;
}; // LayerCount is used in 2d array textures and Depth for 3d textures
uint32 MipLevelCount;
};
/* Unsigned Normalized Float Color Formats */
A8_UNORM,
R8_UNORM,
R8G8_UNORM,
R8G8B8A8_UNORM,
R16_UNORM,
R16G16_UNORM,
R16G16B16A16_UNORM,
R10G10B10A2_UNORM,
B5G6R5_UNORM,
B5G5R5A1_UNORM,
B4G4R4A4_UNORM,
B8G8R8A8_UNORM,
/* Compressed Unsigned Normalized Float Color Formats */
BC1_RGBA_UNORM,
BC2_RGBA_UNORM,
BC3_RGBA_UNORM,
BC4_R_UNORM,
BC5_RG_UNORM,
BC7_RGBA_UNORM,
/* Compressed Signed Float Color Formats */
BC6H_RGB_FLOAT,
/* Compressed Unsigned Float Color Formats */
BC6H_RGB_UFLOAT,
/* Signed Normalized Float Color Formats */
R8_SNORM,
R8G8_SNORM,
R8G8B8A8_SNORM,
R16_SNORM,
R16G16_SNORM,
R16G16B16A16_SNORM,
/* Signed Float Color Formats */
R16_FLOAT,
R16G16_FLOAT,
R16G16B16A16_FLOAT,
R32_FLOAT,
R32G32_FLOAT,
R32G32B32A32_FLOAT,
/* Unsigned Float Color Formats */
R11G11B10_UFLOAT,
/* Unsigned Integer Color Formats */
R8_UINT,
R8G8_UINT,
R8G8B8A8_UINT,
R16_UINT,
R16G16_UINT,
R16G16B16A16_UINT,
R32_UINT,
R32G32_UINT,
R32G32B32A32_UINT,
/* Signed Integer Color Formats */
R8_INT,
R8G8_INT,
R8G8B8A8_INT,
R16_INT,
R16G16_INT,
R16G16B16A16_INT,
R32_INT,
R32G32_INT,
R32G32B32A32_INT,
/* SRGB Unsigned Normalized Color Formats */
R8G8B8A8_UNORM_SRGB,
B8G8R8A8_UNORM_SRGB,
/* Compressed SRGB Unsigned Normalized Color Formats */
BC1_RGBA_UNORM_SRGB,
BC2_RGBA_UNORM_SRGB,
BC3_RGBA_UNORM_SRGB,
BC7_RGBA_UNORM_SRGB,
/* Depth Formats */
D16_UNORM,
D24_UNORM,
D32_FLOAT,
D24_UNORM_S8_UINT,
D32_FLOAT_S8_UINT,
/* Compressed ASTC Normalized Float Color Formats*/
ASTC_4x4_UNORM,
ASTC_5x4_UNORM,
ASTC_5x5_UNORM,
ASTC_6x5_UNORM,
ASTC_6x6_UNORM,
ASTC_8x5_UNORM,
ASTC_8x6_UNORM,
ASTC_8x8_UNORM,
ASTC_10x5_UNORM,
ASTC_10x6_UNORM,
ASTC_10x8_UNORM,
ASTC_10x10_UNORM,
ASTC_12x10_UNORM,
ASTC_12x12_UNORM,
/* Compressed SRGB ASTC Normalized Float Color Formats*/
ASTC_4x4_UNORM_SRGB,
ASTC_5x4_UNORM_SRGB,
ASTC_5x5_UNORM_SRGB,
ASTC_6x5_UNORM_SRGB,
ASTC_6x6_UNORM_SRGB,
ASTC_8x5_UNORM_SRGB,
ASTC_8x6_UNORM_SRGB,
ASTC_8x8_UNORM_SRGB,
ASTC_10x5_UNORM_SRGB,
ASTC_10x6_UNORM_SRGB,
ASTC_10x8_UNORM_SRGB,
ASTC_10x10_UNORM_SRGB,
ASTC_12x10_UNORM_SRGB,
ASTC_12x12_UNORM_SRGB,
/* Compressed ASTC Signed Float Color Formats*/
ASTC_4x4_FLOAT,
ASTC_5x4_FLOAT,
ASTC_5x5_FLOAT,
ASTC_6x5_FLOAT,
ASTC_6x6_FLOAT,
ASTC_8x5_FLOAT,
ASTC_8x6_FLOAT,
ASTC_8x8_FLOAT,
ASTC_10x5_FLOAT,
ASTC_10x6_FLOAT,
ASTC_10x8_FLOAT,
ASTC_10x10_FLOAT,
ASTC_12x10_FLOAT,
ASTC_12x12_FLOAT,
Count
};
enum struct TextureUsageFlag : uint8
{
None = 0,
Sampler = 1 << 0, // Textures supports sampling
ColorTarget = 1 << 1, // Texture is color render target
DepthStencilTarget = 1 << 2, // Texture is depth stencil target
GraphicsStorageRead = 1 << 3, // Support Storage read at graphics stage
ComputeStorageRead = 1 << 4, // Support Storage read at compute stage
ComputeStorageWrite = 1 << 5, // Support Storage Write at compute stage
ComputeStorageSimultaneousReadWrite =
1 << 6, // Supports reads and writes in the same compute shader. Not equivalent to ComputeStorageRead | ComputeStorageWrite
};
enum struct TextureType : uint8
{
Texture_2D,
Texture_2DArray,
Texture_3D,
Texture_3DArray,
Texture_Cube,
Texture_CubeArray,
};
enum struct TextureSampleCount : uint8
{
One,
Two,
Four,
Eight,
};
// Create Information structs
struct TextureCreateInfo
{
TextureType Type;
TextureFormat Format;
TextureUsageFlag Flags;
TextureSampleCount SampleCount;
uint32 Width;
uint32 Height;
union
{
uint32 LayerCount;
uint32 DepthPlane;
}; // LayerCount is used in 2d array textures and Depth for 3d textures
uint32 MipLevelCount;
};
// Opaque Type
struct Texture;
} // namespace Juliet
// Opaque Type
struct Texture;
Juliet/include/Graphics/VertexData.h
+7 -10
View File
@@ -1,13 +1,10 @@
#pragma once
#pragma once
namespace Juliet
struct Vertex
{
struct Vertex
{
float Position[3];
float Normal[3];
float Color[4];
};
float Position[3];
float Normal[3];
float Color[4];
};
using Index = uint16;
} // namespace Juliet
using Index = uint16;
Juliet/src/Core/Application/ApplicationManager.cpp
+8 -11
View File
@@ -1,20 +1,17 @@
#include <Core/Application/ApplicationManager.h>
#include <Core/Application/ApplicationManager.h>
#include <Core/JulietInit.h>
#include <Engine/Engine.h>
namespace Juliet
void StartApplication(IApplication& app, JulietInit_Flags flags)
{
void StartApplication(IApplication& app, JulietInit_Flags flags)
{
InitializeEngine(flags);
InitializeEngine(flags);
LoadApplication(app);
LoadApplication(app);
RunEngine();
RunEngine();
UnloadApplication();
UnloadApplication();
ShutdownEngine();
}
} // namespace Juliet
ShutdownEngine();
}
Juliet/src/Core/Common/CoreUtils.cpp
+23 -26
View File
@@ -1,38 +1,35 @@
#include <Core/Logging/LogManager.h>
#include <Core/Logging/LogManager.h>
#include <Core/Logging/LogTypes.h>
#include <Core/Memory/Allocator.h>
#include <comdef.h> // For _com_error to decode HRESULTs
#include <intrin.h> // For __debugbreak
namespace Juliet
void JulietAssert(const char* expression, const char* message, std::source_location location, long handleResult)
{
void JulietAssert(const char* expression, const char* message, std::source_location location, long handleResult)
Log(LogLevel::Error, LogCategory::Core, "--- ASSERTION FAILED ---");
Log(LogLevel::Error, LogCategory::Core, "Expression: %s", expression);
Log(LogLevel::Error, LogCategory::Core, "Message: %s", message);
Log(LogLevel::Error, LogCategory::Core, "Location: %s(%u): %s", location.file_name(), location.line(),
location.function_name());
if (handleResult < 0)
{
Log(LogLevel::Error, LogCategory::Core, "--- ASSERTION FAILED ---");
Log(LogLevel::Error, LogCategory::Core, "Expression: %s", expression);
Log(LogLevel::Error, LogCategory::Core, "Message: %s", message);
Log(LogLevel::Error, LogCategory::Core, "Location: %s(%u): %s", location.file_name(), location.line(),
location.function_name());
if (handleResult < 0)
{
_com_error err(handleResult);
// Using %ls because ErrorMessage() returns a wide string (wchar_t*)
Log(LogLevel::Error, LogCategory::Graphics, "HRESULT: 0x%08X (%ls)", handleResult, err.ErrorMessage());
}
Log(LogLevel::Error, LogCategory::Core, "-------------------------");
JULIET_PLATFORM_BREAK();
_com_error err(handleResult);
// Using %ls because ErrorMessage() returns a wide string (wchar_t*)
Log(LogLevel::Error, LogCategory::Graphics, "HRESULT: 0x%08X (%ls)", handleResult, err.ErrorMessage());
}
void Free(ByteBuffer& buffer)
Log(LogLevel::Error, LogCategory::Core, "-------------------------");
JULIET_PLATFORM_BREAK();
}
void Free(ByteBuffer& buffer)
{
if (buffer.Data)
{
if (buffer.Data)
{
Free(buffer.Data);
}
buffer = {};
Free(buffer.Data);
}
} // namespace Juliet
buffer = {};
}
Juliet/src/Core/Common/String.cpp
+572 -575
View File
File diff suppressed because it is too large Load Diff
Juliet/src/Core/Container/Vector.cpp
+1 -4
View File
@@ -1,5 +1,2 @@
#include <Core/Container/Vector.h>
#include <Core/Container/Vector.h>
namespace Juliet
{
}
Juliet/src/Core/HAL/Display/Display.cpp
+133 -136
View File
@@ -1,162 +1,159 @@
#include <Core/Common/CoreTypes.h>
#include <Core/Common/CoreTypes.h>
#include <Core/HAL/Display/Display_cpp.h>
#include <Core/HAL/Display/DisplayDevice.h>
#include <Core/Memory/Allocator.h>
#include <Core/Memory/MemoryArena.h>
namespace Juliet
namespace
{
namespace
DisplayDevice* g_CurrentDisplayDevice = nullptr;
void DestroyPlatformWindow(index_t windowIndex);
} // namespace
namespace Internal::Display
{
// TODO : IfDef new factories that are not compatible
constexpr DisplayDeviceFactory* Factories[] = { &Win32DisplayDeviceFactory, nullptr };
} // namespace Internal::Display
void InitializeDisplaySystem()
{
Assert(!g_CurrentDisplayDevice);
Arena* arena = ArenaAllocate({ .Name = "Display System" });
DisplayDevice* candidateDevice = nullptr;
DisplayDeviceFactory* candidateFactory = nullptr;
for (DisplayDeviceFactory* factory : Internal::Display::Factories)
{
DisplayDevice* g_CurrentDisplayDevice = nullptr;
void DestroyPlatformWindow(index_t windowIndex);
} // namespace
namespace Internal::Display
{
// TODO : IfDef new factories that are not compatible
constexpr DisplayDeviceFactory* Factories[] = { &Win32DisplayDeviceFactory, nullptr };
} // namespace Internal::Display
void InitializeDisplaySystem()
{
Assert(!g_CurrentDisplayDevice);
Arena* arena = ArenaAllocate({ .Name = "Display System" });
DisplayDevice* candidateDevice = nullptr;
DisplayDeviceFactory* candidateFactory = nullptr;
for (DisplayDeviceFactory* factory : Internal::Display::Factories)
if (factory)
{
if (factory)
candidateDevice = factory->CreateDevice(arena);
if (candidateDevice)
{
candidateDevice = factory->CreateDevice(arena);
if (candidateDevice)
{
candidateFactory = factory;
break;
}
}
}
// TODO : handle error instead of crashing
Assert(candidateDevice);
g_CurrentDisplayDevice = candidateDevice;
g_CurrentDisplayDevice->Arena = arena;
g_CurrentDisplayDevice->Name = candidateFactory->Name;
if (!g_CurrentDisplayDevice->Initialize(g_CurrentDisplayDevice))
{
ShutdownDisplaySystem();
}
}
void ShutdownDisplaySystem()
{
if (!g_CurrentDisplayDevice)
{
return;
}
// Destroy all Windows that are still alive
for (index_t idx = g_CurrentDisplayDevice->Windows.Size(); idx-- > 0;)
{
DestroyPlatformWindow(idx);
}
g_CurrentDisplayDevice->Shutdown(g_CurrentDisplayDevice);
// Free anything that was freed by the shutdown and then free the display
// no op for now
g_CurrentDisplayDevice->Free(g_CurrentDisplayDevice);
ArenaRelease(g_CurrentDisplayDevice->Arena);
g_CurrentDisplayDevice = nullptr;
}
Window* CreatePlatformWindow(const char* title, uint16 width, uint16 height, int /*flags*/ /* = 0 unused */)
{
Assert(g_CurrentDisplayDevice->CreatePlatformWindow);
Window window = {};
window.Arena = ArenaAllocate({ .Name = "Window" });
window.Width = width;
window.Height = height;
window.Title = StringCopy(window.Arena, WrapString(title));
g_CurrentDisplayDevice->Windows.PushBack(window);
auto* pWindow = g_CurrentDisplayDevice->Windows.Last();
if (!g_CurrentDisplayDevice->CreatePlatformWindow(g_CurrentDisplayDevice, pWindow))
{
ArenaRelease(window.Arena);
return nullptr;
}
// TODO : make SHOW optional on creation with a flag
g_CurrentDisplayDevice->ShowWindow(g_CurrentDisplayDevice, pWindow);
return pWindow;
}
namespace
{
void DestroyPlatformWindow(index_t windowIndex)
{
VectorArena<Window>& windows = g_CurrentDisplayDevice->Windows;
Window* window = &windows[windowIndex];
HideWindow(window);
g_CurrentDisplayDevice->DestroyPlatformWindow(g_CurrentDisplayDevice, window);
ArenaClear(window->Arena);
ArenaRelease(window->Arena);
windows.RemoveAtFast(windowIndex);
}
} // namespace
void DestroyPlatformWindow(NonNullPtr<Window> window)
{
// Find and destroy
VectorArena<Window>& windows = g_CurrentDisplayDevice->Windows;
for (index_t idx = windows.Size(); idx-- > 0;)
{
Window& windowRef = windows[idx];
if (windowRef.ID == window->ID)
{
DestroyPlatformWindow(idx);
candidateFactory = factory;
break;
}
}
}
void ShowWindow(NonNullPtr<Window> window)
// TODO : handle error instead of crashing
Assert(candidateDevice);
g_CurrentDisplayDevice = candidateDevice;
g_CurrentDisplayDevice->Arena = arena;
g_CurrentDisplayDevice->Name = candidateFactory->Name;
if (!g_CurrentDisplayDevice->Initialize(g_CurrentDisplayDevice))
{
g_CurrentDisplayDevice->ShowWindow(g_CurrentDisplayDevice, window);
ShutdownDisplaySystem();
}
}
void ShutdownDisplaySystem()
{
if (!g_CurrentDisplayDevice)
{
return;
}
void HideWindow(NonNullPtr<Window> window)
// Destroy all Windows that are still alive
for (index_t idx = g_CurrentDisplayDevice->Windows.Size(); idx-- > 0;)
{
g_CurrentDisplayDevice->HideWindow(g_CurrentDisplayDevice, window);
DestroyPlatformWindow(idx);
}
WindowID GetWindowID(NonNullPtr<Window> window)
g_CurrentDisplayDevice->Shutdown(g_CurrentDisplayDevice);
// Free anything that was freed by the shutdown and then free the display
// no op for now
g_CurrentDisplayDevice->Free(g_CurrentDisplayDevice);
ArenaRelease(g_CurrentDisplayDevice->Arena);
g_CurrentDisplayDevice = nullptr;
}
Window* CreatePlatformWindow(const char* title, uint16 width, uint16 height, int /*flags*/ /* = 0 unused */)
{
Assert(g_CurrentDisplayDevice->CreatePlatformWindow);
Window window = {};
window.Arena = ArenaAllocate({ .Name = "Window" });
window.Width = width;
window.Height = height;
window.Title = StringCopy(window.Arena, WrapString(title));
g_CurrentDisplayDevice->Windows.PushBack(window);
auto* pWindow = g_CurrentDisplayDevice->Windows.Last();
if (!g_CurrentDisplayDevice->CreatePlatformWindow(g_CurrentDisplayDevice, pWindow))
{
return window->ID;
ArenaRelease(window.Arena);
return nullptr;
}
void SetWindowTitle(NonNullPtr<Window> window, String title)
{
g_CurrentDisplayDevice->SetWindowTitle(g_CurrentDisplayDevice, window, title);
}
// TODO : make SHOW optional on creation with a flag
g_CurrentDisplayDevice->ShowWindow(g_CurrentDisplayDevice, pWindow);
// Display Device Utils. Not exposed in the API
DisplayDevice* GetDisplayDevice()
return pWindow;
}
namespace
{
void DestroyPlatformWindow(index_t windowIndex)
{
return g_CurrentDisplayDevice;
VectorArena<Window>& windows = g_CurrentDisplayDevice->Windows;
Window* window = &windows[windowIndex];
HideWindow(window);
g_CurrentDisplayDevice->DestroyPlatformWindow(g_CurrentDisplayDevice, window);
ArenaClear(window->Arena);
ArenaRelease(window->Arena);
windows.RemoveAtFast(windowIndex);
}
} // namespace Juliet
} // namespace
void DestroyPlatformWindow(NonNullPtr<Window> window)
{
// Find and destroy
VectorArena<Window>& windows = g_CurrentDisplayDevice->Windows;
for (index_t idx = windows.Size(); idx-- > 0;)
{
Window& windowRef = windows[idx];
if (windowRef.ID == window->ID)
{
DestroyPlatformWindow(idx);
break;
}
}
}
void ShowWindow(NonNullPtr<Window> window)
{
g_CurrentDisplayDevice->ShowWindow(g_CurrentDisplayDevice, window);
}
void HideWindow(NonNullPtr<Window> window)
{
g_CurrentDisplayDevice->HideWindow(g_CurrentDisplayDevice, window);
}
WindowID GetWindowID(NonNullPtr<Window> window)
{
return window->ID;
}
void SetWindowTitle(NonNullPtr<Window> window, String title)
{
g_CurrentDisplayDevice->SetWindowTitle(g_CurrentDisplayDevice, window, title);
}
// Display Device Utils. Not exposed in the API
DisplayDevice* GetDisplayDevice()
{
return g_CurrentDisplayDevice;
}
Juliet/src/Core/HAL/Display/DisplayDevice.h
+30 -33
View File
@@ -1,47 +1,44 @@
#pragma once
#pragma once
#include <Core/Common/NonNullPtr.h>
#include <Core/Container/Vector.h>
#include <Core/HAL/Display/Window.h>
namespace Juliet
// Driver to the display device.
// Functions ptr will be set by the chosen factory
// Acts as a singleton after Initialize has been called and is freed in Shutdown.
struct DisplayDevice
{
// Driver to the display device.
// Functions ptr will be set by the chosen factory
// Acts as a singleton after Initialize has been called and is freed in Shutdown.
struct DisplayDevice
{
Arena* Arena;
Arena* Arena;
const char* Name = "Unknown";
const char* Name = "Unknown";
// Initialize all subsystems needed for the device to works
bool (*Initialize)(NonNullPtr<DisplayDevice> self);
void (*Shutdown)(NonNullPtr<DisplayDevice> self);
void (*Free)(NonNullPtr<DisplayDevice> self);
// Initialize all subsystems needed for the device to works
bool (*Initialize)(NonNullPtr<DisplayDevice> self);
void (*Shutdown)(NonNullPtr<DisplayDevice> self);
void (*Free)(NonNullPtr<DisplayDevice> self);
// Window management
bool (*CreatePlatformWindow)(NonNullPtr<DisplayDevice> self, NonNullPtr<Window> window);
void (*DestroyPlatformWindow)(NonNullPtr<DisplayDevice> self, NonNullPtr<Window> window);
void (*ShowWindow)(NonNullPtr<DisplayDevice> self, NonNullPtr<Window> window);
void (*HideWindow)(NonNullPtr<DisplayDevice> self, NonNullPtr<Window> window);
void (*SetWindowTitle)(NonNullPtr<DisplayDevice> self, NonNullPtr<Window> window, String title);
// Window management
bool (*CreatePlatformWindow)(NonNullPtr<DisplayDevice> self, NonNullPtr<Window> window);
void (*DestroyPlatformWindow)(NonNullPtr<DisplayDevice> self, NonNullPtr<Window> window);
void (*ShowWindow)(NonNullPtr<DisplayDevice> self, NonNullPtr<Window> window);
void (*HideWindow)(NonNullPtr<DisplayDevice> self, NonNullPtr<Window> window);
void (*SetWindowTitle)(NonNullPtr<DisplayDevice> self, NonNullPtr<Window> window, String title);
// Events
void (*PumpEvents)(NonNullPtr<DisplayDevice> self);
// Events
void (*PumpEvents)(NonNullPtr<DisplayDevice> self);
VectorArena<Window> Windows;
};
VectorArena<Window> Windows;
};
struct DisplayDeviceFactory
{
const char* Name = "Unknown";
DisplayDevice* (*CreateDevice)(Arena* arena);
};
struct DisplayDeviceFactory
{
const char* Name = "Unknown";
DisplayDevice* (*CreateDevice)(Arena* arena);
};
// TODO : Support more platforms
extern DisplayDeviceFactory Win32DisplayDeviceFactory;
// TODO : Support more platforms
extern DisplayDeviceFactory Win32DisplayDeviceFactory;
// Utils
extern DisplayDevice* GetDisplayDevice();
} // namespace Juliet
// Utils
extern DisplayDevice* GetDisplayDevice();
Juliet/src/Core/HAL/Display/Display_cpp.h
+3 -6
View File
@@ -1,7 +1,4 @@
#pragma once
#pragma once
namespace Juliet
{
void InitializeDisplaySystem();
void ShutdownDisplaySystem();
} // namespace Juliet
void InitializeDisplaySystem();
void ShutdownDisplaySystem();
Juliet/src/Core/HAL/Display/Win32/Win32DisplayDevice.cpp
+4 -7
View File
@@ -1,8 +1,8 @@
#include <Core/HAL/Display/DisplayDevice.h>
#include <Core/HAL/Display/DisplayDevice.h>
#include <Core/HAL/Display/Win32/Win32DisplayEvent.h>
#include <Core/HAL/Display/Win32/Win32Window.h>
namespace Juliet::Win32
namespace Win32
{
namespace
{
@@ -43,10 +43,7 @@ namespace Juliet::Win32
}
} // namespace
} // namespace Juliet::Win32
} // namespace Win32
// Factory cannot be in an anonymous/unknown namespace
namespace Juliet
{
DisplayDeviceFactory Win32DisplayDeviceFactory = { .Name = "Win32", .CreateDevice = Win32::CreateDevice };
}
DisplayDeviceFactory Win32DisplayDeviceFactory = { .Name = "Win32", .CreateDevice = Win32::CreateDevice };
Juliet/src/Core/HAL/Display/Win32/Win32DisplayEvent.cpp
+3 -3
View File
@@ -1,4 +1,4 @@
#include <Core/Common/EnumUtils.h>
#include <Core/Common/EnumUtils.h>
#include <Core/HAL/Display/DisplayDevice.h>
#include <Core/HAL/Display/Win32/Win32DisplayEvent.h>
#include <Core/HAL/Display/Win32/Win32Window.h>
@@ -20,7 +20,7 @@
extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
#endif
namespace Juliet::Win32
namespace Win32
{
namespace
{
@@ -276,4 +276,4 @@ namespace Juliet::Win32
return CallWindowProcA(DefWindowProcA, handle, message, wParam, lParam);
}
} // namespace Juliet::Win32
} // namespace Win32
Juliet/src/Core/HAL/Display/Win32/Win32DisplayEvent.h
+4 -7
View File
@@ -1,15 +1,12 @@
#pragma once
#pragma once
#include <Core/Common/NonNullPtr.h>
#include <Core/HAL/Win32.h>
namespace Juliet
{
struct DisplayDevice;
}
struct DisplayDevice;
namespace Juliet::Win32
namespace Win32
{
extern void PumpEvents(NonNullPtr<DisplayDevice> self);
extern LRESULT CALLBACK Win32MainWindowCallback(HWND Handle, UINT Message, WPARAM WParam, LPARAM LParam);
} // namespace Juliet::Win32
} // namespace Win32
Juliet/src/Core/HAL/Display/Win32/Win32Window.cpp
+3 -3
View File
@@ -1,10 +1,10 @@
#include <Core/HAL/Display/Win32/Win32DisplayEvent.h>
#include <Core/HAL/Display/Win32/Win32DisplayEvent.h>
#include <Core/HAL/Display/Win32/Win32Window.h>
#include <Core/HAL/Display/Window.h>
#include <Core/Memory/Allocator.h>
#include <Core/Memory/MemoryArena.h>
namespace Juliet::Win32
namespace Win32
{
namespace
{
@@ -101,4 +101,4 @@ namespace Juliet::Win32
auto& win32State = static_cast<Window32State&>(*window->State);
SetWindowTextA(win32State.Handle, CStr(title));
}
} // namespace Juliet::Win32
} // namespace Win32
Juliet/src/Core/HAL/Display/Win32/Win32Window.h
+5 -8
View File
@@ -1,16 +1,13 @@
#pragma once
#pragma once
#include <Core/Common/NonNullPtr.h>
#include <Core/HAL/Display/Window.h>
#include <Core/HAL/Win32.h>
namespace Juliet
{
struct DisplayDevice;
struct Window;
} // namespace Juliet
struct DisplayDevice;
struct Window;
namespace Juliet::Win32
namespace Win32
{
// TODO : Evaluate if its worth the burden of casting to Window32State all the time
struct Window32State : WindowState
@@ -26,4 +23,4 @@ namespace Juliet::Win32
extern void ShowWindow(NonNullPtr<DisplayDevice> self, NonNullPtr<Window> window);
extern void HideWindow(NonNullPtr<DisplayDevice> self, NonNullPtr<Window> window);
extern void SetWindowTitle(NonNullPtr<DisplayDevice> self, NonNullPtr<Window> window, String title);
} // namespace Juliet::Win32
} // namespace Win32
Juliet/src/Core/HAL/Display/Window.h
+14 -17
View File
@@ -1,24 +1,21 @@
#pragma once
#pragma once
#include <Core/Common/String.h>
#include <Core/HAL/Display/Display.h>
namespace Juliet
struct Window;
struct WindowState
{
struct Window;
struct WindowState
{
Window* Window;
};
Window* Window;
};
struct Window
{
WindowID ID;
WindowState* State;
Arena* Arena;
struct Window
{
WindowID ID;
WindowState* State;
Arena* Arena;
int32 Width;
int32 Height;
String Title;
};
} // namespace Juliet
int32 Width;
int32 Height;
String Title;
};
Juliet/src/Core/HAL/DynLib/Win32/DynamicLibrary.cpp
+28 -31
View File
@@ -1,44 +1,41 @@
#include <Core/HAL/DynLib/DynamicLibrary.h>
#include <Core/HAL/DynLib/DynamicLibrary.h>
#include <Core/HAL/Win32.h>
#include <Core/Logging/LogManager.h>
#include <Core/Logging/LogTypes.h>
namespace Juliet
DynamicLibrary* LoadDynamicLibrary(const char* filename)
{
DynamicLibrary* LoadDynamicLibrary(const char* filename)
if (!filename)
{
if (!filename)
{
Log(LogLevel::Error, LogCategory::Core, "Library filename is invalid (empty)");
return nullptr;
}
HMODULE handle = LoadLibraryA(filename);
// Generate an error message if all loads failed
if (!handle)
{
Log(LogLevel::Error, LogCategory::Core, "Failed loading %s", filename);
return nullptr;
}
return reinterpret_cast<DynamicLibrary*>(handle);
Log(LogLevel::Error, LogCategory::Core, "Library filename is invalid (empty)");
return nullptr;
}
FunctionPtr LoadFunction(NonNullPtr<DynamicLibrary> lib, const char* functionName)
HMODULE handle = LoadLibraryA(filename);
// Generate an error message if all loads failed
if (!handle)
{
Log(LogLevel::Error, LogCategory::Core, "Failed loading %s", filename);
return nullptr;
}
return reinterpret_cast<DynamicLibrary*>(handle);
}
FunctionPtr LoadFunction(NonNullPtr<DynamicLibrary> lib, const char* functionName)
{
#pragma warning(push)
#pragma warning(disable: 4191) // Disable "unsafe conversion from FARPROC"
auto function = reinterpret_cast<FunctionPtr>(GetProcAddress(reinterpret_cast<HMODULE>(lib.Get()), functionName));
if (!function)
{
Log(LogLevel::Error, LogCategory::Core, "Failed loading %s", functionName);
}
return function;
#pragma warning(pop)
}
void UnloadDynamicLibrary(NonNullPtr<DynamicLibrary> lib)
auto function = reinterpret_cast<FunctionPtr>(GetProcAddress(reinterpret_cast<HMODULE>(lib.Get()), functionName));
if (!function)
{
FreeLibrary(reinterpret_cast<HMODULE>(lib.Get()));
Log(LogLevel::Error, LogCategory::Core, "Failed loading %s", functionName);
}
} // namespace Juliet
return function;
#pragma warning(pop)
}
void UnloadDynamicLibrary(NonNullPtr<DynamicLibrary> lib)
{
FreeLibrary(reinterpret_cast<HMODULE>(lib.Get()));
}
Juliet/src/Core/HAL/Event/Keyboard.cpp
+127 -130
View File
@@ -1,165 +1,162 @@
#include <Core/Common/EnumUtils.h>
#include <Core/Common/EnumUtils.h>
#include <Core/HAL/Event/Keyboard_Private.h>
#include <Core/HAL/Event/KeyboardMapping.h>
#include <Core/HAL/Event/SystemEvent.h>
namespace Juliet
constexpr KeyboardID kGlobalKeyboardID = 0;
namespace
{
constexpr KeyboardID kGlobalKeyboardID = 0;
namespace
struct KeyboardState
{
struct KeyboardState
KeyState KeyState[ToUnderlying(ScanCode::Count)];
KeyMod KeyModState;
} KeyboardState;
bool SendKeyboardKey_Internal(uint64 timestamp, KeyboardID /*ID*/, Key key, KeyPosition keyPosition)
{
Assert(key.KeyCode == KeyCode::Unknown); // At this point Keycode is not yet extracted
auto& keyboardState = KeyboardState; // Needed because MSVC debugger ignores variable in anonymouse namespace
auto type = EventType::None;
const bool isKeyDown = keyPosition == KeyPosition::Down;
if (isKeyDown)
{
KeyState KeyState[ToUnderlying(ScanCode::Count)];
KeyMod KeyModState;
} KeyboardState;
bool SendKeyboardKey_Internal(uint64 timestamp, KeyboardID /*ID*/, Key key, KeyPosition keyPosition)
type = EventType::Key_Down;
}
else
{
Assert(key.KeyCode == KeyCode::Unknown); // At this point Keycode is not yet extracted
type = EventType::Key_Up;
}
auto& keyboardState = KeyboardState; // Needed because MSVC debugger ignores variable in anonymouse namespace
bool isKeyRepeat = false;
if (key.ScanCode > ScanCode::Unknown && key.ScanCode < ScanCode::Count)
{
auto& currentKeyState = keyboardState.KeyState[ToUnderlying(key.ScanCode)];
auto type = EventType::None;
const bool isKeyDown = keyPosition == KeyPosition::Down;
// If state didn't change, this is a key repeat
if (isKeyDown)
{
type = EventType::Key_Down;
if (currentKeyState.Position == KeyPosition::Down)
{
isKeyRepeat = true;
}
}
else
{
type = EventType::Key_Up;
}
bool isKeyRepeat = false;
if (key.ScanCode > ScanCode::Unknown && key.ScanCode < ScanCode::Count)
{
auto& currentKeyState = keyboardState.KeyState[ToUnderlying(key.ScanCode)];
// If state didn't change, this is a key repeat
if (isKeyDown)
if (currentKeyState.Position == KeyPosition::Up)
{
if (currentKeyState.Position == KeyPosition::Down)
{
isKeyRepeat = true;
}
return false;
}
else
{
if (currentKeyState.Position == KeyPosition::Up)
{
return false;
}
}
currentKeyState.Position = keyPosition;
key.KeyCode = GetKeyCodeFromScanCode(key.ScanCode, keyboardState.KeyModState);
}
else if (key.Raw == 0)
{
return false;
}
if (!isKeyRepeat)
{
KeyMod newModifier = {};
currentKeyState.Position = keyPosition;
key.KeyCode = GetKeyCodeFromScanCode(key.ScanCode, keyboardState.KeyModState);
}
else if (key.Raw == 0)
{
return false;
}
if (!isKeyRepeat)
{
KeyMod newModifier = {};
switch (key.KeyCode)
{
case KeyCode::LeftControl: newModifier = KeyMod::LeftControl; break;
case KeyCode::RightControl: newModifier = KeyMod::RightControl; break;
case KeyCode::LeftShift: newModifier = KeyMod::LeftShift; break;
case KeyCode::RightShift: newModifier = KeyMod::RightShift; break;
case KeyCode::LeftAlt: newModifier = KeyMod::LeftAlt; break;
case KeyCode::RightAlt: newModifier = KeyMod::RightAlt; break;
case KeyCode::LeftOSCommand: newModifier = KeyMod::LeftOSCommand; break;
case KeyCode::RightOSCommand: newModifier = KeyMod::RightOSCommand; break;
default: newModifier = KeyMod::None; break;
}
if (type == EventType::Key_Down)
{
switch (key.KeyCode)
{
case KeyCode::LeftControl: newModifier = KeyMod::LeftControl; break;
case KeyCode::RightControl: newModifier = KeyMod::RightControl; break;
case KeyCode::LeftShift: newModifier = KeyMod::LeftShift; break;
case KeyCode::RightShift: newModifier = KeyMod::RightShift; break;
case KeyCode::LeftAlt: newModifier = KeyMod::LeftAlt; break;
case KeyCode::RightAlt: newModifier = KeyMod::RightAlt; break;
case KeyCode::LeftOSCommand: newModifier = KeyMod::LeftOSCommand; break;
case KeyCode::RightOSCommand: newModifier = KeyMod::RightOSCommand; break;
default: newModifier = KeyMod::None; break;
}
if (type == EventType::Key_Down)
{
switch (key.KeyCode)
{
case KeyCode::NumlockClear: newModifier ^= KeyMod::NumLock; break;
case KeyCode::CapsLock: newModifier ^= KeyMod::CapsLock; break;
case KeyCode::ScrollLock: newModifier ^= KeyMod::ScrollLock; break;
default: keyboardState.KeyModState |= newModifier;
}
}
else
{
// Remove from any keymod not pressed from the modifier
keyboardState.KeyModState &= ~newModifier;
}
}
SystemEvent evt;
evt.Timestamp = timestamp;
evt.Type = type;
evt.Data.Keyboard.AssociatedKeyboardID = kGlobalKeyboardID;
evt.Data.Keyboard.Key = key;
evt.Data.Keyboard.KeyState = { keyPosition, 0.0f };
evt.Data.Keyboard.KeyModeState = keyboardState.KeyModState;
bool evtPosted = AddEvent(evt);
return evtPosted;
}
} // namespace
bool SendKeyboardKey(uint64 timestamp, KeyboardID ID, Key key, KeyPosition keyPosition)
{
return SendKeyboardKey_Internal(timestamp, ID, key, keyPosition);
}
void UpdateKeyboardstate(float deltaTime)
{
for (KeyState& state : KeyboardState.KeyState)
{
if (state.Position == KeyPosition::Down)
{
if (state.Time < 0.0f)
{
state.Time = 0.0f;
}
else
{
state.Time += deltaTime;
case KeyCode::NumlockClear: newModifier ^= KeyMod::NumLock; break;
case KeyCode::CapsLock: newModifier ^= KeyMod::CapsLock; break;
case KeyCode::ScrollLock: newModifier ^= KeyMod::ScrollLock; break;
default: keyboardState.KeyModState |= newModifier;
}
}
else
{
state.Time = -1.0f;
// Remove from any keymod not pressed from the modifier
keyboardState.KeyModState &= ~newModifier;
}
}
}
bool IsKeyDown(ScanCode scanCode)
SystemEvent evt;
evt.Timestamp = timestamp;
evt.Type = type;
evt.Data.Keyboard.AssociatedKeyboardID = kGlobalKeyboardID;
evt.Data.Keyboard.Key = key;
evt.Data.Keyboard.KeyState = { keyPosition, 0.0f };
evt.Data.Keyboard.KeyModeState = keyboardState.KeyModState;
bool evtPosted = AddEvent(evt);
return evtPosted;
}
} // namespace
bool SendKeyboardKey(uint64 timestamp, KeyboardID ID, Key key, KeyPosition keyPosition)
{
return SendKeyboardKey_Internal(timestamp, ID, key, keyPosition);
}
void UpdateKeyboardstate(float deltaTime)
{
for (KeyState& state : KeyboardState.KeyState)
{
return KeyboardState.KeyState[ToUnderlying(scanCode)].Position == KeyPosition::Down;
if (state.Position == KeyPosition::Down)
{
if (state.Time < 0.0f)
{
state.Time = 0.0f;
}
else
{
state.Time += deltaTime;
}
}
else
{
state.Time = -1.0f;
}
}
}
bool IsKeyPressed(ScanCode scanCode)
{
auto& keyState = KeyboardState.KeyState[ToUnderlying(scanCode)];
return keyState.Position == KeyPosition::Down && keyState.Time == 0.0f;
}
bool IsKeyDown(ScanCode scanCode)
{
return KeyboardState.KeyState[ToUnderlying(scanCode)].Position == KeyPosition::Down;
}
KeyMod GetKeyModState()
{
auto& keyboardState = KeyboardState;
return keyboardState.KeyModState;
}
bool IsKeyPressed(ScanCode scanCode)
{
auto& keyState = KeyboardState.KeyState[ToUnderlying(scanCode)];
return keyState.Position == KeyPosition::Down && keyState.Time == 0.0f;
}
KeyCode GetKeyCodeFromScanCode(ScanCode scanCode, KeyMod keyModState)
{
return GetKeyCodeFromDefaultMapping(scanCode, keyModState);
}
KeyMod GetKeyModState()
{
auto& keyboardState = KeyboardState;
return keyboardState.KeyModState;
}
static_assert(sizeof(KeyPosition) == sizeof(bool));
static_assert(ToUnderlying(KeyPosition::Down) == true);
static_assert(ToUnderlying(KeyPosition::Up) == false);
static_assert(sizeof(ScanCode) == sizeof(uint16));
static_assert(ToUnderlying(ScanCode::Count) == 512);
} // namespace Juliet
KeyCode GetKeyCodeFromScanCode(ScanCode scanCode, KeyMod keyModState)
{
return GetKeyCodeFromDefaultMapping(scanCode, keyModState);
}
static_assert(sizeof(KeyPosition) == sizeof(bool));
static_assert(ToUnderlying(KeyPosition::Down) == true);
static_assert(ToUnderlying(KeyPosition::Up) == false);
static_assert(sizeof(ScanCode) == sizeof(uint16));
static_assert(ToUnderlying(ScanCode::Count) == 512);
Juliet/src/Core/HAL/Event/KeyboardMapping.cpp
+191 -194
View File
@@ -1,204 +1,201 @@
#include <Core/Common/CoreUtils.h>
#include <Core/Common/CoreUtils.h>
#include <Core/Common/EnumUtils.h>
#include <Core/HAL/Event/KeyboardMapping.h>
#include <Core/HAL/Keyboard/KeyCode.h>
#include <Core/HAL/Keyboard/ScanCode.h>
namespace Juliet
namespace
{
namespace
// clang-format off
KeyCode UnshiftedDefaultSymbols[] = {
KeyCode::Num1,
KeyCode::Num2,
KeyCode::Num3,
KeyCode::Num4,
KeyCode::Num5,
KeyCode::Num6,
KeyCode::Num7,
KeyCode::Num8,
KeyCode::Num9,
KeyCode::Num0,
KeyCode::Return,
KeyCode::Escape,
KeyCode::Backspace,
KeyCode::Tab,
KeyCode::Space,
KeyCode::Minus,
KeyCode::Equals,
KeyCode::LeftBracket,
KeyCode::RightBracket,
KeyCode::Backslash,
KeyCode::Hash,
KeyCode::Semicolon,
KeyCode::Apostrophe,
KeyCode::GraveAccent,
KeyCode::Comma,
KeyCode::Period,
KeyCode::Slash,
};
KeyCode ShiftedDefaultSymbols[] = {
KeyCode::ExclamationPoint,
KeyCode::CommercialAt,
KeyCode::Hash,
KeyCode::Dollar,
KeyCode::Percent,
KeyCode::Caret,
KeyCode::Ampersand,
KeyCode::Asterisk,
KeyCode::LeftParenthesis,
KeyCode::RightParenthesis,
KeyCode::Return,
KeyCode::Escape,
KeyCode::Backspace,
KeyCode::Tab,
KeyCode::Space,
KeyCode::Underscore,
KeyCode::Plus,
KeyCode::LeftBrace,
KeyCode::RightBrace,
KeyCode::Pipe,
KeyCode::Hash,
KeyCode::Colon,
KeyCode::DoubleApostrophe,
KeyCode::Tilde,
KeyCode::LessThan,
KeyCode::GreaterThan,
KeyCode::QuestionMark,
};
// clang-format on
KeyCode GetNonPrintableKeys(ScanCode scanCode)
{
// clang-format off
KeyCode UnshiftedDefaultSymbols[] = {
KeyCode::Num1,
KeyCode::Num2,
KeyCode::Num3,
KeyCode::Num4,
KeyCode::Num5,
KeyCode::Num6,
KeyCode::Num7,
KeyCode::Num8,
KeyCode::Num9,
KeyCode::Num0,
KeyCode::Return,
KeyCode::Escape,
KeyCode::Backspace,
KeyCode::Tab,
KeyCode::Space,
KeyCode::Minus,
KeyCode::Equals,
KeyCode::LeftBracket,
KeyCode::RightBracket,
KeyCode::Backslash,
KeyCode::Hash,
KeyCode::Semicolon,
KeyCode::Apostrophe,
KeyCode::GraveAccent,
KeyCode::Comma,
KeyCode::Period,
KeyCode::Slash,
};
KeyCode ShiftedDefaultSymbols[] = {
KeyCode::ExclamationPoint,
KeyCode::CommercialAt,
KeyCode::Hash,
KeyCode::Dollar,
KeyCode::Percent,
KeyCode::Caret,
KeyCode::Ampersand,
KeyCode::Asterisk,
KeyCode::LeftParenthesis,
KeyCode::RightParenthesis,
KeyCode::Return,
KeyCode::Escape,
KeyCode::Backspace,
KeyCode::Tab,
KeyCode::Space,
KeyCode::Underscore,
KeyCode::Plus,
KeyCode::LeftBrace,
KeyCode::RightBrace,
KeyCode::Pipe,
KeyCode::Hash,
KeyCode::Colon,
KeyCode::DoubleApostrophe,
KeyCode::Tilde,
KeyCode::LessThan,
KeyCode::GreaterThan,
KeyCode::QuestionMark,
};
// clang-format on
KeyCode GetNonPrintableKeys(ScanCode scanCode)
switch (scanCode)
{
switch (scanCode)
{
case ScanCode::Delete: return KeyCode::Delete;
case ScanCode::CapsLock: return KeyCode::CapsLock;
case ScanCode::F1: return KeyCode::F1;
case ScanCode::F2: return KeyCode::F2;
case ScanCode::F3: return KeyCode::F3;
case ScanCode::F4: return KeyCode::F4;
case ScanCode::F5: return KeyCode::F5;
case ScanCode::F6: return KeyCode::F6;
case ScanCode::F7: return KeyCode::F7;
case ScanCode::F8: return KeyCode::F8;
case ScanCode::F9: return KeyCode::F9;
case ScanCode::F10: return KeyCode::F10;
case ScanCode::F11: return KeyCode::F11;
case ScanCode::F12: return KeyCode::F12;
case ScanCode::PrintScreen: return KeyCode::PrintScreen;
case ScanCode::ScrollLock: return KeyCode::ScrollLock;
case ScanCode::Pause: return KeyCode::Pause;
case ScanCode::Insert: return KeyCode::Insert;
case ScanCode::Home: return KeyCode::Home;
case ScanCode::PageUp: return KeyCode::PageUp;
case ScanCode::End: return KeyCode::End;
case ScanCode::PageDown: return KeyCode::PageDown;
case ScanCode::RightArrow: return KeyCode::RightArrow;
case ScanCode::LeftArrow: return KeyCode::LeftArrow;
case ScanCode::DownArrow: return KeyCode::DownArrow;
case ScanCode::UpArrow: return KeyCode::UpArrow;
case ScanCode::NumlockClear: return KeyCode::NumlockClear;
case ScanCode::KeyPad_Divide: return KeyCode::KeyPad_Divide;
case ScanCode::KeyPad_Multiply: return KeyCode::KeyPad_Multiply;
case ScanCode::KeyPad_Minus: return KeyCode::KeyPad_Minus;
case ScanCode::KeyPad_Plus: return KeyCode::KeyPad_Plus;
case ScanCode::KeyPad_Enter: return KeyCode::KeyPad_Enter;
case ScanCode::KeyPad_Num1: return KeyCode::KeyPad_Num1;
case ScanCode::KeyPad_Num2: return KeyCode::KeyPad_Num2;
case ScanCode::KeyPad_Num3: return KeyCode::KeyPad_Num3;
case ScanCode::KeyPad_Num4: return KeyCode::KeyPad_Num4;
case ScanCode::KeyPad_Num5: return KeyCode::KeyPad_Num5;
case ScanCode::KeyPad_Num6: return KeyCode::KeyPad_Num6;
case ScanCode::KeyPad_Num7: return KeyCode::KeyPad_Num7;
case ScanCode::KeyPad_Num8: return KeyCode::KeyPad_Num8;
case ScanCode::KeyPad_Num9: return KeyCode::KeyPad_Num9;
case ScanCode::KeyPad_Num0: return KeyCode::KeyPad_Num0;
case ScanCode::KeyPad_Period: return KeyCode::KeyPad_Period;
case ScanCode::Power: return KeyCode::Power;
case ScanCode::KeyPad_Equals: return KeyCode::KeyPad_Equals;
case ScanCode::F13: return KeyCode::F13;
case ScanCode::F14: return KeyCode::F14;
case ScanCode::F15: return KeyCode::F15;
case ScanCode::F16: return KeyCode::F16;
case ScanCode::F17: return KeyCode::F17;
case ScanCode::F18: return KeyCode::F18;
case ScanCode::F19: return KeyCode::F19;
case ScanCode::F20: return KeyCode::F20;
case ScanCode::F21: return KeyCode::F21;
case ScanCode::F22: return KeyCode::F22;
case ScanCode::F23: return KeyCode::F23;
case ScanCode::F24: return KeyCode::F24;
case ScanCode::Mute: return KeyCode::Mute;
case ScanCode::VolumeUp: return KeyCode::VolumeUp;
case ScanCode::VolumeDown: return KeyCode::VolumeDown;
case ScanCode::KeyPad_Comma: return KeyCode::KeyPad_Comma;
case ScanCode::LeftControl: return KeyCode::LeftControl;
case ScanCode::LeftShift: return KeyCode::LeftShift;
case ScanCode::LeftAlt: return KeyCode::LeftAlt;
case ScanCode::LeftOSCommand: return KeyCode::LeftOSCommand;
case ScanCode::RightControl: return KeyCode::RightControl;
case ScanCode::RightShift: return KeyCode::RightShift;
case ScanCode::RightAlt: return KeyCode::RightAlt;
case ScanCode::RightOSCommand: return KeyCode::RightOSCommand;
case ScanCode::Sleep: return KeyCode::Sleep;
case ScanCode::WakeUp: return KeyCode::WakeUp;
case ScanCode::Media_NextTrack: return KeyCode::Media_NextTrack;
case ScanCode::Media_PreviousTrack: return KeyCode::Media_PreviousTrack;
case ScanCode::Media_Stop: return KeyCode::Media_Stop;
case ScanCode::Media_Eject: return KeyCode::Media_Eject;
case ScanCode::Media_PlayPause: return KeyCode::Media_PlayPause;
case ScanCode::Media_Select: return KeyCode::Media_Select;
default: return KeyCode::Unknown;
}
case ScanCode::Delete: return KeyCode::Delete;
case ScanCode::CapsLock: return KeyCode::CapsLock;
case ScanCode::F1: return KeyCode::F1;
case ScanCode::F2: return KeyCode::F2;
case ScanCode::F3: return KeyCode::F3;
case ScanCode::F4: return KeyCode::F4;
case ScanCode::F5: return KeyCode::F5;
case ScanCode::F6: return KeyCode::F6;
case ScanCode::F7: return KeyCode::F7;
case ScanCode::F8: return KeyCode::F8;
case ScanCode::F9: return KeyCode::F9;
case ScanCode::F10: return KeyCode::F10;
case ScanCode::F11: return KeyCode::F11;
case ScanCode::F12: return KeyCode::F12;
case ScanCode::PrintScreen: return KeyCode::PrintScreen;
case ScanCode::ScrollLock: return KeyCode::ScrollLock;
case ScanCode::Pause: return KeyCode::Pause;
case ScanCode::Insert: return KeyCode::Insert;
case ScanCode::Home: return KeyCode::Home;
case ScanCode::PageUp: return KeyCode::PageUp;
case ScanCode::End: return KeyCode::End;
case ScanCode::PageDown: return KeyCode::PageDown;
case ScanCode::RightArrow: return KeyCode::RightArrow;
case ScanCode::LeftArrow: return KeyCode::LeftArrow;
case ScanCode::DownArrow: return KeyCode::DownArrow;
case ScanCode::UpArrow: return KeyCode::UpArrow;
case ScanCode::NumlockClear: return KeyCode::NumlockClear;
case ScanCode::KeyPad_Divide: return KeyCode::KeyPad_Divide;
case ScanCode::KeyPad_Multiply: return KeyCode::KeyPad_Multiply;
case ScanCode::KeyPad_Minus: return KeyCode::KeyPad_Minus;
case ScanCode::KeyPad_Plus: return KeyCode::KeyPad_Plus;
case ScanCode::KeyPad_Enter: return KeyCode::KeyPad_Enter;
case ScanCode::KeyPad_Num1: return KeyCode::KeyPad_Num1;
case ScanCode::KeyPad_Num2: return KeyCode::KeyPad_Num2;
case ScanCode::KeyPad_Num3: return KeyCode::KeyPad_Num3;
case ScanCode::KeyPad_Num4: return KeyCode::KeyPad_Num4;
case ScanCode::KeyPad_Num5: return KeyCode::KeyPad_Num5;
case ScanCode::KeyPad_Num6: return KeyCode::KeyPad_Num6;
case ScanCode::KeyPad_Num7: return KeyCode::KeyPad_Num7;
case ScanCode::KeyPad_Num8: return KeyCode::KeyPad_Num8;
case ScanCode::KeyPad_Num9: return KeyCode::KeyPad_Num9;
case ScanCode::KeyPad_Num0: return KeyCode::KeyPad_Num0;
case ScanCode::KeyPad_Period: return KeyCode::KeyPad_Period;
case ScanCode::Power: return KeyCode::Power;
case ScanCode::KeyPad_Equals: return KeyCode::KeyPad_Equals;
case ScanCode::F13: return KeyCode::F13;
case ScanCode::F14: return KeyCode::F14;
case ScanCode::F15: return KeyCode::F15;
case ScanCode::F16: return KeyCode::F16;
case ScanCode::F17: return KeyCode::F17;
case ScanCode::F18: return KeyCode::F18;
case ScanCode::F19: return KeyCode::F19;
case ScanCode::F20: return KeyCode::F20;
case ScanCode::F21: return KeyCode::F21;
case ScanCode::F22: return KeyCode::F22;
case ScanCode::F23: return KeyCode::F23;
case ScanCode::F24: return KeyCode::F24;
case ScanCode::Mute: return KeyCode::Mute;
case ScanCode::VolumeUp: return KeyCode::VolumeUp;
case ScanCode::VolumeDown: return KeyCode::VolumeDown;
case ScanCode::KeyPad_Comma: return KeyCode::KeyPad_Comma;
case ScanCode::LeftControl: return KeyCode::LeftControl;
case ScanCode::LeftShift: return KeyCode::LeftShift;
case ScanCode::LeftAlt: return KeyCode::LeftAlt;
case ScanCode::LeftOSCommand: return KeyCode::LeftOSCommand;
case ScanCode::RightControl: return KeyCode::RightControl;
case ScanCode::RightShift: return KeyCode::RightShift;
case ScanCode::RightAlt: return KeyCode::RightAlt;
case ScanCode::RightOSCommand: return KeyCode::RightOSCommand;
case ScanCode::Sleep: return KeyCode::Sleep;
case ScanCode::WakeUp: return KeyCode::WakeUp;
case ScanCode::Media_NextTrack: return KeyCode::Media_NextTrack;
case ScanCode::Media_PreviousTrack: return KeyCode::Media_PreviousTrack;
case ScanCode::Media_Stop: return KeyCode::Media_Stop;
case ScanCode::Media_Eject: return KeyCode::Media_Eject;
case ScanCode::Media_PlayPause: return KeyCode::Media_PlayPause;
case ScanCode::Media_Select: return KeyCode::Media_Select;
default: return KeyCode::Unknown;
}
} // namespace
KeyCode GetKeyCodeFromDefaultMapping(ScanCode scanCode, KeyMod keyModState)
{
if (scanCode <= ScanCode::Unknown || scanCode > ScanCode::Count)
{
Assert(false , "Unsupported KeyCode (out of bounds)");
return KeyCode::Unknown;
}
if (scanCode < ScanCode::A)
{
return KeyCode::Unknown;
}
// Handles A-Z characters
if (scanCode <= ScanCode::Z)
{
const auto index = scanCode - ScanCode::A;
bool isShiftPressed = (keyModState & KeyMod::Shift) != KeyMod::None;
if ((keyModState & KeyMod::CapsLock) != KeyMod::None)
{
isShiftPressed = !isShiftPressed;
}
if (isShiftPressed)
{
return ToEnum<KeyCode>(static_cast<uint32>('A') + index);
}
return ToEnum<KeyCode>(static_cast<uint32>('a') + index);
}
// Handles Num1 to Num0
if (scanCode <= ScanCode::Num0)
{
const auto index = scanCode - ScanCode::Num1;
const bool isShiftPressed = (keyModState & KeyMod::Shift) != KeyMod::None;
if (isShiftPressed)
{
return ShiftedDefaultSymbols[index];
}
return UnshiftedDefaultSymbols[index];
}
// Handle everything else (characters that do not convert to ASCII code)
return GetNonPrintableKeys(scanCode);
}
} // namespace Juliet
} // namespace
KeyCode GetKeyCodeFromDefaultMapping(ScanCode scanCode, KeyMod keyModState)
{
if (scanCode <= ScanCode::Unknown || scanCode > ScanCode::Count)
{
Assert(false , "Unsupported KeyCode (out of bounds)");
return KeyCode::Unknown;
}
if (scanCode < ScanCode::A)
{
return KeyCode::Unknown;
}
// Handles A-Z characters
if (scanCode <= ScanCode::Z)
{
const auto index = scanCode - ScanCode::A;
bool isShiftPressed = (keyModState & KeyMod::Shift) != KeyMod::None;
if ((keyModState & KeyMod::CapsLock) != KeyMod::None)
{
isShiftPressed = !isShiftPressed;
}
if (isShiftPressed)
{
return ToEnum<KeyCode>(static_cast<uint32>('A') + index);
}
return ToEnum<KeyCode>(static_cast<uint32>('a') + index);
}
// Handles Num1 to Num0
if (scanCode <= ScanCode::Num0)
{
const auto index = scanCode - ScanCode::Num1;
const bool isShiftPressed = (keyModState & KeyMod::Shift) != KeyMod::None;
if (isShiftPressed)
{
return ShiftedDefaultSymbols[index];
}
return UnshiftedDefaultSymbols[index];
}
// Handle everything else (characters that do not convert to ASCII code)
return GetNonPrintableKeys(scanCode);
}
Juliet/src/Core/HAL/Event/KeyboardMapping.h
+3 -6
View File
@@ -1,10 +1,7 @@
#pragma once
#pragma once
#include <Core/HAL/Keyboard/KeyCode.h>
#include <Core/HAL/Keyboard/ScanCode.h>
namespace Juliet
{
// Transforms ScanCode into KeyCode using the default US ASCII Mapping
extern KeyCode GetKeyCodeFromDefaultMapping(ScanCode scanCode, KeyMod keyModState);
} // namespace Juliet
// Transforms ScanCode into KeyCode using the default US ASCII Mapping
extern KeyCode GetKeyCodeFromDefaultMapping(ScanCode scanCode, KeyMod keyModState);
Juliet/src/Core/HAL/Event/Keyboard_Private.h
+4 -7
View File
@@ -1,12 +1,9 @@
#pragma once
#pragma once
#include <Core/HAL/Keyboard/Keyboard.h>
#include <Core/HAL/Keyboard/KeyCode.h>
namespace Juliet
{
extern bool SendKeyboardKey(uint64 timestamp, KeyboardID ID, Key key, KeyPosition keyPosition);
extern void UpdateKeyboardstate(float deltaTime);
extern bool SendKeyboardKey(uint64 timestamp, KeyboardID ID, Key key, KeyPosition keyPosition);
extern void UpdateKeyboardstate(float deltaTime);
extern const KeyboardID kGlobalKeyboardID;
} // namespace Juliet
extern const KeyboardID kGlobalKeyboardID;
Juliet/src/Core/HAL/Event/Mouse.cpp
+116 -119
View File
@@ -1,158 +1,155 @@
#include <Core/Common/EnumUtils.h>
#include <Core/Common/EnumUtils.h>
#include <Core/HAL/Display/Window.h>
#include <Core/HAL/Event/Mouse_Private.h>
#include <Core/HAL/Event/SystemEvent.h>
#include <Core/HAL/Mouse/Mouse.h>
namespace Juliet
namespace
{
namespace
Mouse MouseState;
void ConstraintMousePositionToWindow(Mouse& mouseState, Window* window, float& x, float& y)
{
Mouse MouseState;
float x_min = 0.f, x_max = (float)(window->Width - 1);
float y_min = 0.f, y_max = (float)(window->Height - 1);
void ConstraintMousePositionToWindow(Mouse& mouseState, Window* window, float& x, float& y)
if (x >= (x_max + 1))
{
float x_min = 0.f, x_max = (float)(window->Width - 1);
float y_min = 0.f, y_max = (float)(window->Height - 1);
if (x >= (x_max + 1))
{
x = std::max(x_max, mouseState.X_Previous);
}
x = std::max(x, x_min);
if (y >= (y_max + 1))
{
y = std::max(y_max, mouseState.Y_Previous);
}
y = std::max(y, y_min);
x = std::max(x_max, mouseState.X_Previous);
}
x = std::max(x, x_min);
void SendMouseMotion_Internal(uint64 timestamp, Window* window, MouseID mouseID, float x, float y)
if (y >= (y_max + 1))
{
auto& mouseState = GetMouseState();
float xDisplacement = 0.0f;
float yDisplacement = 0.0f;
ConstraintMousePositionToWindow(mouseState, window, x, y);
if (mouseState.HasPosition)
{
xDisplacement = x - mouseState.X_Previous;
yDisplacement = y - mouseState.Y_Previous;
}
if (mouseState.HasPosition && xDisplacement == 0.0f && yDisplacement == 0.0f)
{
// Skip it because state didnt change
return;
}
mouseState.X = x;
mouseState.Y = y;
mouseState.HasPosition = true;
mouseState.X_Previous = x;
mouseState.Y_Previous = y;
mouseState.DeltaX += xDisplacement;
mouseState.DeltaY += yDisplacement;
SystemEvent evt;
evt.Type = EventType::Mouse_Move;
evt.Timestamp = timestamp;
evt.Data.MouseMovement.WindowID = window->ID;
evt.Data.MouseMovement.AssociatedMouseID = mouseID;
evt.Data.MouseMovement.X = x;
evt.Data.MouseMovement.Y = y;
evt.Data.MouseMovement.X_Displacement = xDisplacement;
evt.Data.MouseMovement.Y_Displacement = yDisplacement;
evt.Data.MouseMovement.ButtonState = mouseState.ButtonState;
AddEvent(evt);
y = std::max(y_max, mouseState.Y_Previous);
}
} // namespace
constexpr MouseID kGlobalMouseID = 0;
Mouse& GetMouseState()
{
return MouseState;
y = std::max(y, y_min);
}
void SendMouseMotion(uint64 timestamp, NonNullPtr<Window> window, MouseID ID, float x, float y)
void SendMouseMotion_Internal(uint64 timestamp, Window* window, MouseID mouseID, float x, float y)
{
// TODO : Update Mouse focus and send Mouse Enter / Mouse Leave event
auto& mouseState = GetMouseState();
float xDisplacement = 0.0f;
float yDisplacement = 0.0f;
SendMouseMotion_Internal(timestamp, window, ID, x, y);
}
ConstraintMousePositionToWindow(mouseState, window, x, y);
void SendMouseButton(uint64 timestamp, NonNullPtr<Window> window, MouseID mouseID, MouseButton button, bool pressed)
{
Mouse& mouseState = GetMouseState();
MouseButton flags = mouseState.ButtonState;
auto type = EventType::None;
if (pressed)
if (mouseState.HasPosition)
{
type = EventType::Mouse_ButtonPressed;
flags |= button;
}
else
{
type = EventType::Mouse_ButtonReleased;
flags = flags & ~button;
xDisplacement = x - mouseState.X_Previous;
yDisplacement = y - mouseState.Y_Previous;
}
if (flags == mouseState.ButtonState)
if (mouseState.HasPosition && xDisplacement == 0.0f && yDisplacement == 0.0f)
{
// Skip it because state didnt change
return;
}
mouseState.ButtonState = flags;
mouseState.X = x;
mouseState.Y = y;
mouseState.HasPosition = true;
mouseState.X_Previous = x;
mouseState.Y_Previous = y;
mouseState.DeltaX += xDisplacement;
mouseState.DeltaY += yDisplacement;
// TODO : Send Event!
SystemEvent evt;
evt.Timestamp = timestamp;
evt.Type = type;
evt.Data.MouseButton.AssociatedMouseID = mouseID;
evt.Data.MouseButton.WindowID = window->ID;
evt.Data.MouseButton.ButtonState = button;
evt.Data.MouseButton.X = mouseState.X;
evt.Data.MouseButton.Y = mouseState.Y;
evt.Data.MouseButton.IsPressed = pressed;
evt.Type = EventType::Mouse_Move;
evt.Timestamp = timestamp;
evt.Data.MouseMovement.WindowID = window->ID;
evt.Data.MouseMovement.AssociatedMouseID = mouseID;
evt.Data.MouseMovement.X = x;
evt.Data.MouseMovement.Y = y;
evt.Data.MouseMovement.X_Displacement = xDisplacement;
evt.Data.MouseMovement.Y_Displacement = yDisplacement;
evt.Data.MouseMovement.ButtonState = mouseState.ButtonState;
AddEvent(evt);
}
bool IsMouseButtonDown(MouseButton button)
} // namespace
constexpr MouseID kGlobalMouseID = 0;
Mouse& GetMouseState()
{
return MouseState;
}
void SendMouseMotion(uint64 timestamp, NonNullPtr<Window> window, MouseID ID, float x, float y)
{
// TODO : Update Mouse focus and send Mouse Enter / Mouse Leave event
SendMouseMotion_Internal(timestamp, window, ID, x, y);
}
void SendMouseButton(uint64 timestamp, NonNullPtr<Window> window, MouseID mouseID, MouseButton button, bool pressed)
{
Mouse& mouseState = GetMouseState();
MouseButton flags = mouseState.ButtonState;
auto type = EventType::None;
if (pressed)
{
auto& mouseState = GetMouseState();
return (mouseState.ButtonState & button) != MouseButton::None;
type = EventType::Mouse_ButtonPressed;
flags |= button;
}
else
{
type = EventType::Mouse_ButtonReleased;
flags = flags & ~button;
}
MousePosition GetMousePosition()
if (flags == mouseState.ButtonState)
{
auto& mouseState = GetMouseState();
return { .X = mouseState.X, .Y = mouseState.Y };
return;
}
MousePosition GetMouseDelta()
{
auto& mouseState = GetMouseState();
return { .X = mouseState.DeltaX, .Y = mouseState.DeltaY };
}
mouseState.ButtonState = flags;
MouseButton GetMouseButtonState()
{
const auto& mouseState = GetMouseState();
return mouseState.ButtonState;
}
// TODO : Send Event!
SystemEvent evt;
evt.Timestamp = timestamp;
evt.Type = type;
evt.Data.MouseButton.AssociatedMouseID = mouseID;
evt.Data.MouseButton.WindowID = window->ID;
evt.Data.MouseButton.ButtonState = button;
evt.Data.MouseButton.X = mouseState.X;
evt.Data.MouseButton.Y = mouseState.Y;
evt.Data.MouseButton.IsPressed = pressed;
AddEvent(evt);
}
void UpdateMouseState()
{
auto& mouseState = GetMouseState();
mouseState.DeltaX = 0.0f;
mouseState.DeltaY = 0.0f;
}
bool IsMouseButtonDown(MouseButton button)
{
auto& mouseState = GetMouseState();
return (mouseState.ButtonState & button) != MouseButton::None;
}
MousePosition GetMousePosition()
{
auto& mouseState = GetMouseState();
return { .X = mouseState.X, .Y = mouseState.Y };
}
MousePosition GetMouseDelta()
{
auto& mouseState = GetMouseState();
return { .X = mouseState.DeltaX, .Y = mouseState.DeltaY };
}
MouseButton GetMouseButtonState()
{
const auto& mouseState = GetMouseState();
return mouseState.ButtonState;
}
void UpdateMouseState()
{
auto& mouseState = GetMouseState();
mouseState.DeltaX = 0.0f;
mouseState.DeltaY = 0.0f;
}
} // namespace Juliet
Juliet/src/Core/HAL/Event/Mouse_Private.h
+18 -21
View File
@@ -1,32 +1,29 @@
#pragma once
#pragma once
#include <Core/HAL/Mouse/Mouse.h>
namespace Juliet
struct Window;
struct Mouse
{
struct Window;
float X;
float Y;
struct Mouse
{
float X;
float Y;
float X_Previous;
float Y_Previous;
float X_Previous;
float Y_Previous;
float DeltaX;
float DeltaY;
float DeltaX;
float DeltaY;
MouseButton ButtonState;
MouseButton ButtonState;
bool HasPosition : 1;
};
bool HasPosition : 1;
};
Mouse& GetMouseState();
Mouse& GetMouseState();
extern void UpdateMouseState();
extern void SendMouseMotion(uint64 timestamp, NonNullPtr<Window> window, MouseID ID, float x, float y);
extern void SendMouseButton(uint64 timestamp, NonNullPtr<Window> window, MouseID mouseID, MouseButton button, bool pressed);
extern void UpdateMouseState();
extern void SendMouseMotion(uint64 timestamp, NonNullPtr<Window> window, MouseID ID, float x, float y);
extern void SendMouseButton(uint64 timestamp, NonNullPtr<Window> window, MouseID mouseID, MouseButton button, bool pressed);
extern const MouseID kGlobalMouseID;
} // namespace Juliet
extern const MouseID kGlobalMouseID;
Juliet/src/Core/HAL/Event/SystemEvent.cpp
+65 -68
View File
@@ -1,4 +1,4 @@
#include <Core/HAL/Display/DisplayDevice.h>
#include <Core/HAL/Display/DisplayDevice.h>
#include <Core/HAL/Event/SystemEvent.h>
#include <Core/HAL/Event/Keyboard_Private.h>
@@ -9,92 +9,89 @@
#pragma pop_macro("global")
namespace Juliet
namespace
{
namespace
// TODO : make my own queue / using vector
std::queue<SystemEvent> eventQueue;
// Update all systems event loops and gather events into the main queue
void PumpEvents()
{
// TODO : make my own queue / using vector
std::queue<SystemEvent> eventQueue;
// Update all systems event loops and gather events into the main queue
void PumpEvents()
if (DisplayDevice* displayDevice = GetDisplayDevice())
{
if (DisplayDevice* displayDevice = GetDisplayDevice())
{
displayDevice->PumpEvents(displayDevice);
}
displayDevice->PumpEvents(displayDevice);
}
bool AddEvent_Internal(const SystemEvent& event)
{
auto& newEvent = eventQueue.emplace();
newEvent = event;
// TODO : Logs
return true;
}
} // namespace
bool GetEvent(SystemEvent& event)
{
return WaitEvent(event, 0);
}
bool WaitEvent(SystemEvent& event, int32 timeoutInNS /* = -1 */)
bool AddEvent_Internal(const SystemEvent& event)
{
using namespace std::chrono;
auto& newEvent = eventQueue.emplace();
newEvent = event;
// Handle the "Infinite Wait" and "Timed Wait" logic
const bool isInfinite = (timeoutInNS < 0);
const nanoseconds timeout(timeoutInNS);
const auto startTime = steady_clock::now();
// TODO : Logs
while (true)
return true;
}
} // namespace
bool GetEvent(SystemEvent& event)
{
return WaitEvent(event, 0);
}
bool WaitEvent(SystemEvent& event, int32 timeoutInNS /* = -1 */)
{
using namespace std::chrono;
// Handle the "Infinite Wait" and "Timed Wait" logic
const bool isInfinite = (timeoutInNS < 0);
const nanoseconds timeout(timeoutInNS);
const auto startTime = steady_clock::now();
while (true)
{
PumpEvents();
if (!eventQueue.empty())
{
PumpEvents();
event = eventQueue.front();
eventQueue.pop();
return true;
}
if (!eventQueue.empty())
{
event = eventQueue.front();
eventQueue.pop();
return true;
}
// If timeout is 0, we only check once (PumpEvents already ran)
if (timeoutInNS == 0)
{
break;
}
// If timeout is 0, we only check once (PumpEvents already ran)
if (timeoutInNS == 0)
// Check if we have exceeded our time limit
if (!isInfinite)
{
auto elapsed = steady_clock::now() - startTime;
if (elapsed >= timeout)
{
break;
}
// Check if we have exceeded our time limit
if (!isInfinite)
{
auto elapsed = steady_clock::now() - startTime;
if (elapsed >= timeout)
{
break;
}
}
}
return false;
}
bool AddEvent(SystemEvent& event)
return false;
}
bool AddEvent(SystemEvent& event)
{
if (event.Timestamp == 0)
{
if (event.Timestamp == 0)
{
event.Timestamp = 1; // TODO : Clock::Now();
}
return AddEvent_Internal(event);
event.Timestamp = 1; // TODO : Clock::Now();
}
void Events_NewFrame(float deltaTime)
{
UpdateKeyboardstate(deltaTime);
UpdateMouseState();
}
return AddEvent_Internal(event);
}
void Events_NewFrame(float deltaTime)
{
UpdateKeyboardstate(deltaTime);
UpdateMouseState();
}
} // namespace Juliet
Juliet/src/Core/HAL/Event/Win32ScanCode.h
+3 -3
View File
@@ -1,8 +1,8 @@
#pragma once
#pragma once
#include <Core/HAL/Keyboard/ScanCode.h>
namespace Juliet::Win32
namespace Win32
{
// Conversion table from Win32 scan code to HID Usage Page (see Keyboard.h)
// https://learn.microsoft.com/en-us/windows/win32/inputdev/about-keyboard-input#extended-key-flag
@@ -267,4 +267,4 @@ namespace Juliet::Win32
};
// clang-format on
} // namespace Juliet::Win32
} // namespace Win32
Juliet/src/Core/HAL/Event/WindowEvent.cpp
+10 -13
View File
@@ -1,21 +1,18 @@
#include <Core/HAL/Display/Window.h>
#include <Core/HAL/Display/Window.h>
#include <Core/HAL/Event/SystemEvent.h>
#include <Core/HAL/Event/WindowEvent.h>
namespace Juliet
bool SendWindowEvent(Window* window, EventType type)
{
bool SendWindowEvent(Window* window, EventType type)
{
Assert(window);
Assert(window);
SystemEvent evt;
evt.Timestamp = 0;
evt.Type = type;
evt.Data.Window.AssociatedWindowID = window->ID;
SystemEvent evt;
evt.Timestamp = 0;
evt.Type = type;
evt.Data.Window.AssociatedWindowID = window->ID;
bool evtPosted = AddEvent(evt);
bool evtPosted = AddEvent(evt);
return evtPosted;
}
return evtPosted;
}
} // namespace Juliet
Juliet/src/Core/HAL/Event/WindowEvent.h
+4 -7
View File
@@ -1,9 +1,6 @@
#pragma once
#pragma once
namespace Juliet
{
struct Window;
enum class EventType : uint32;
struct Window;
enum class EventType : uint32;
extern bool SendWindowEvent(Window* window, EventType type);
} // namespace Juliet
extern bool SendWindowEvent(Window* window, EventType type);
Juliet/src/Core/HAL/Filesystem/Filesystem.cpp
+80 -83
View File
@@ -1,4 +1,4 @@
#include <Core/Common/CoreTypes.h>
#include <Core/Common/CoreTypes.h>
#include <Core/Common/CoreUtils.h>
#include <Core/Common/String.h>
#include <Core/HAL/Filesystem/Filesystem.h>
@@ -9,93 +9,90 @@
#include <Core/Logging/LogTypes.h>
#include <Core/Memory/Allocator.h>
namespace Juliet
namespace
{
namespace
{
String CachedBasePath = {};
String CachedAssetBasePath = {};
String CachedBasePath = {};
String CachedAssetBasePath = {};
bool DirectoryExists(const char* path)
bool DirectoryExists(const char* path)
{
Assert(path);
DWORD attributes = GetFileAttributesA(path);
return (attributes != INVALID_FILE_ATTRIBUTES) && (attributes & FILE_ATTRIBUTE_DIRECTORY);
}
} // namespace
String GetBasePath()
{
Assert(IsValid(CachedBasePath));
return CachedBasePath;
}
String GetAssetBasePath()
{
Assert(IsValid(CachedAssetBasePath));
return CachedAssetBasePath;
}
[[nodiscard]] String GetAssetPath(NonNullPtr<Arena> arena, String filename)
{
Assert(IsValid(CachedAssetBasePath));
Assert(IsValid(filename));
size_t totalSize = CachedAssetBasePath.Size + filename.Size + 1;
char* buffer = ArenaPushArray<char>(arena, totalSize);
Assert(buffer);
juliet_snprintf(buffer, totalSize, "%s%s", CStr(CachedAssetBasePath), CStr(filename));
return { buffer, totalSize - 1 };
}
bool IsAbsolutePath(String path)
{
if (!IsValid(path))
{
return false;
}
return Platform::IsAbsolutePath(path);
}
void InitFilesystem(NonNullPtr<Arena> arena)
{
CachedBasePath = Platform::GetBasePath(arena);
String basePath = GetBasePath();
Assert(IsValid(basePath));
// Probe candidate paths for compiled shader directory
// 1. Shipping layout: Assets/Shaders/ next to the exe
// 2. Dev layout: ../../Assets/compiled/ (exe is in bin/x64Clang-<Config>/)
constexpr const char* kCandidates[] = { "Assets/Shaders/", "../../Assets/compiled/" };
for (const char* candidate : kCandidates)
{
char probePath[512];
juliet_snprintf(probePath, sizeof(probePath), "%s%s", CStr(basePath), candidate);
if (DirectoryExists(probePath))
{
Assert(path);
DWORD attributes = GetFileAttributesA(path);
return (attributes != INVALID_FILE_ATTRIBUTES) && (attributes & FILE_ATTRIBUTE_DIRECTORY);
}
} // namespace
String GetBasePath()
{
Assert(IsValid(CachedBasePath));
return CachedBasePath;
}
String GetAssetBasePath()
{
Assert(IsValid(CachedAssetBasePath));
return CachedAssetBasePath;
}
[[nodiscard]] String GetAssetPath(NonNullPtr<Arena> arena, String filename)
{
Assert(IsValid(CachedAssetBasePath));
Assert(IsValid(filename));
size_t totalSize = CachedAssetBasePath.Size + filename.Size + 1;
char* buffer = ArenaPushArray<char>(arena, totalSize);
Assert(buffer);
juliet_snprintf(buffer, totalSize, "%s%s", CStr(CachedAssetBasePath), CStr(filename));
return { buffer, totalSize - 1 };
}
bool IsAbsolutePath(String path)
{
if (!IsValid(path))
{
return false;
}
return Platform::IsAbsolutePath(path);
}
void InitFilesystem(NonNullPtr<Arena> arena)
{
CachedBasePath = Platform::GetBasePath(arena);
String basePath = GetBasePath();
Assert(IsValid(basePath));
// Probe candidate paths for compiled shader directory
// 1. Shipping layout: Assets/Shaders/ next to the exe
// 2. Dev layout: ../../Assets/compiled/ (exe is in bin/x64Clang-<Config>/)
constexpr const char* kCandidates[] = { "Assets/Shaders/", "../../Assets/compiled/" };
for (const char* candidate : kCandidates)
{
char probePath[512];
juliet_snprintf(probePath, sizeof(probePath), "%s%s", CStr(basePath), candidate);
if (DirectoryExists(probePath))
size_t len = strlen(probePath);
if (char* buffer = ArenaPushArray<char>(arena, len + 1 JULIET_DEBUG_PARAM("CachedAssetBasePath")))
{
size_t len = strlen(probePath);
if (char* buffer = ArenaPushArray<char>(arena, len + 1 JULIET_DEBUG_PARAM("CachedAssetBasePath")))
{
juliet_snprintf(buffer, len + 1, "%s", probePath);
CachedAssetBasePath = { buffer, len };
Log(LogLevel::Message, LogCategory::Core, "Asset base path: %s", buffer);
}
return;
juliet_snprintf(buffer, len + 1, "%s", probePath);
CachedAssetBasePath = { buffer, len };
Log(LogLevel::Message, LogCategory::Core, "Asset base path: %s", buffer);
}
return;
}
Log(LogLevel::Error, LogCategory::Core, "Filesystem: Could not find Assets/compiled/ directory!");
}
void ShutdownFilesystem()
{
CachedBasePath.Size = 0;
CachedBasePath.Str = nullptr;
CachedAssetBasePath.Size = 0;
CachedAssetBasePath.Str = nullptr;
}
} // namespace Juliet
Log(LogLevel::Error, LogCategory::Core, "Filesystem: Could not find Assets/compiled/ directory!");
}
void ShutdownFilesystem()
{
CachedBasePath.Size = 0;
CachedBasePath.Str = nullptr;
CachedAssetBasePath.Size = 0;
CachedAssetBasePath.Str = nullptr;
}
Juliet/src/Core/HAL/Filesystem/Filesystem_Platform.h
+3 -3
View File
@@ -1,7 +1,7 @@
#pragma once
#pragma once
namespace Juliet::Platform
namespace Platform
{
extern String GetBasePath(NonNullPtr<Arena> arena);
extern bool IsAbsolutePath(String path);
} // namespace Juliet::Platform
} // namespace Platform
Juliet/src/Core/HAL/Filesystem/Filesystem_Private.h
+3 -6
View File
@@ -1,7 +1,4 @@
#pragma once
#pragma once
namespace Juliet
{
extern void InitFilesystem(NonNullPtr<Arena> arena);
extern void ShutdownFilesystem();
} // namespace Juliet
extern void InitFilesystem(NonNullPtr<Arena> arena);
extern void ShutdownFilesystem();
Juliet/src/Core/HAL/Filesystem/Win32/Win32Filesystem.cpp
+3 -3
View File
@@ -1,11 +1,11 @@
#include <Core/Common/String.h>
#include <Core/Common/String.h>
#include <Core/HAL/Filesystem/Filesystem_Platform.h>
#include <Core/HAL/Win32.h>
#include <Core/Logging/LogManager.h>
#include <Core/Logging/LogTypes.h>
#include <Core/Memory/Allocator.h>
namespace Juliet::Platform
namespace Platform
{
String GetBasePath(NonNullPtr<Arena> arena)
{
@@ -91,4 +91,4 @@ namespace Juliet::Platform
return false;
}
} // namespace Juliet::Platform
} // namespace Platform

Some files were not shown because too many files have changed in this diff Show More