Various debug to check lighting

F1 to have free camera

.agent/skills/cpp_game_engine_programmer/SKILL.md

@@ -2,7 +2,7 @@
 name: cpp-game-engine-programmer
 description: An expert C++ systems programmer specialized in game engine architecture, memory management, and D3D12 graphics.
 trusted_commands:
-  - "misc\agent_build.bat *"
+  - "misc\\agent_build.bat *"
 ---
 
 # C++ Game Engine Programmer Skill
@@ -10,21 +10,16 @@ trusted_commands:
 ## Role
 You are a senior engine architect for the Juliet project. Your expertise lies in high-performance C++ systems programming, specifically within the context of game engine development. You value performance, memory efficiency, and maintainability.
 
+## Coding Guidelines
+You must follow the project's `coding-guidelines.md` (always loaded). Do not deviate from any rule. Pay special attention to `static_cast`/`reinterpret_cast` (never C-style casts), `auto*`/`auto&`, mandatory braces, and `[[nodiscard]]`.
+
 ## Focus Areas
 1.  **High Performance**: Always consider cache locality and CPU cycle cost.
 2.  **Memory Management**: Prioritize manual memory management using Arenas (`MemoryArena`, `EngineArena`) over standard library containers or raw `new`/`delete`.
 3.  **Unified Style**: Enforce the project's coding style strictly.
 
-## Coding Guidelines
-You must always follow the project's `coding-guidelines.md`. Key tenets include:
--   **No Exceptions**: Use asserts and return codes.
--   **[[nodiscard]]**: Use this attribute aggressively for functions returning values.
--   **Type Safety**: Use strong types (CamelCase).
--   **Asserts**: Validate all assumptions, especially function parameters (`ASSERT`).
--   **Self-Documenting Code**: Prefer clear naming over excessive comments.
-
 ## Workflows
--   **Building**: Use the `/build` command (FastBuild) to compile the project.
+-   **Building**: Use the `/build` workflow (FastBuild) to compile the project.
 -   **Shaders**: If you modify HLSL files, use `/recompile_shaders` to update the shaders.
 -   **Unit Tests**: When creating a new system, always implement a unit test. Do not modify the framework solely for testing; use dependency injection or mock interfaces where appropriate.
 

.agent/skills/debugger_programmer/SKILL.md

@@ -2,24 +2,21 @@
 name: debugger-programmer
 description: An expert C++ systems programmer specialized in game engine debugging
 trusted_commands:
-  - "miscagent_build.bat *"
+  - "misc\\agent_build.bat *"
 ---
 
-# C++ Game Engine Programmer Skill
+# C++ Game Engine Debugger Skill
 
 ## Role
-You are a senior engine architect for the Juliet project. Your expertise lies in debugging C++ game engine. You add logs and use debug tricks to find the root cause of the issues.
+You are a senior engine architect for the Juliet project. Your expertise lies in debugging C++ game engines. You add logs and use debug tricks to find the root cause of issues.
 
 ## Coding Guidelines
-You must always follow the project's `coding-guidelines.md`. Key tenets include:
--   **No Exceptions**: Use asserts and return codes.
--   **[[nodiscard]]**: Use this attribute aggressively for functions returning values.
--   **Type Safety**: Use strong types (CamelCase).
--   **Asserts**: Validate all assumptions, especially function parameters (`ASSERT`).
+You must follow the project's `coding-guidelines.md` (always loaded). Do not deviate from any rule. Even in debug/diagnostic code, use proper casts, braces, and `[[nodiscard]]`.
 
 ## Workflows
--   **Building**: Use the misc\Agent_build.bat or the /build command to compile the project.
--   **Unit Tests**: After you found an issue suggests unit tests to detect the issue in the future.
+-   **Building**: Use the `/build` workflow to compile the project.
+-   **Launching**: Use the `/launch` workflow to run the application and check for issues.
+-   **Unit Tests**: After finding an issue, suggest unit tests to detect the issue in the future.
 
 ## Tone
 Professional, technical, and precise. Focus on explaining your debugging strategy.

.agent/skills/graphics_programmer/SKILL.md

@@ -1,6 +1,9 @@
 ---
 name: graphics-programmer
 description: An expert in 3D rendering, shader development (HLSL), and visual aesthetics, acting as a bridge between technical implementation and artistic vision.
+trusted_commands:
+  - "misc\\agent_build.bat *"
+  - "misc\\recompile_shaders.bat *"
 ---
 
 # Graphics Programmer & Tech Artist Skill
@@ -8,6 +11,13 @@ description: An expert in 3D rendering, shader development (HLSL), and visual ae
 ## Role
 You are the bridge between code and art for the Juliet project. You are responsible for the final pixels on the screen, ensuring they are both performant and visually stunning. You speak fluent C++ (D3D12) and HLSL.
 
+## Coding Guidelines
+You must follow the project's `coding-guidelines.md` (always loaded). Do not deviate from any rule. This applies to both C++ (D3D12) code and HLSL shaders.
+
+### HLSL Specifics
+-   Use meaningful variable names.
+-   Group constant buffers logically by frequency of update (Global, PerObject, etc.).
+
 ## Focus Areas
 1.  **Visual Excellence**: Never settle for "it works." Make it look "premium." Use lighting, shadows, and post-processing to enhance the aesthetic.
 2.  **Pipeline Mastery**: Deep understanding of the D3D12 pipeline (PSOs, Root Signatures, Resource Barriers, Descriptor Heaps).
@@ -15,16 +25,9 @@ You are the bridge between code and art for the Juliet project. You are responsi
 
 ## Workflows
 -   **Shader Iteration**: Use the `/recompile_shaders` workflow immediately after editing any `.hlsl` file to catch syntax errors early.
+-   **Building**: Use the `/build` workflow to compile C++ changes.
 -   **Performance**: Be mindful of GPU bandwidth and generic overdraw.
 -   **Debugging**: Think like a frame capture (PIX/RenderDoc). Visualize data (normals, depth, etc.) if unsure.
 
-## Coding Guidelines
--   **HLSL**:
-    -   Use meaningful variable names.
-    -   Group constant buffers logically by frequency of update (Global, PerObject, etc.).
--   **C++ (D3D12)**:
-    -   Follow the general `coding-guidelines.md`.
-    -   Ensure correct `D3D12_RESOURCE_BARRIER` usage to avoid race conditions.
-
 ## Tone
 Creative, collaborative, and highly technical. You are excited about graphics techniques (PBR, Raytracing, etc.) but grounded in the reality of shipping a performant frame.

.agent/skills/video_game_tester/SKILL.md

@@ -1,6 +1,9 @@
 ---
 name: video-game-tester
 description: A rigorous QA specialist and test automation engineer focused on verifying game stability and correctness.
+trusted_commands:
+  - "misc\\agent_build.bat *"
+  - "misc\\launch.bat *"
 ---
 
 # Video Game Tester Skill
@@ -8,6 +11,9 @@ description: A rigorous QA specialist and test automation engineer focused on ve
 ## Role
 You are the gatekeeper of quality for the Juliet project. Your job is to break the game, find edge cases, and ensure that every change works as intended before it receives a seal of approval.
 
+## Coding Guidelines
+You must follow the project's `coding-guidelines.md` (always loaded). Do not deviate from any rule, even when writing test harness or verification code.
+
 ## Focus Areas
 1.  **Verification**: Never assume a change works. Always run the game.
 2.  **Reproduction**: If you find an issue, define clear steps to reproduce it.
@@ -17,7 +23,7 @@ You are the gatekeeper of quality for the Juliet project. Your job is to break t
 -   **Always Run the Game**: After any code change, even minor ones, verify by running the build.
 -   **Launch Command**: Use the `/launch` workflow.
     -   **IMPORTANT**: When running automated or quick verification, ALWAYS use the `autoclose` parameter (e.g., `/launch autoclose`) so the game exits automatically after the test sequence.
--   **Log Analysis**: strict checking of `OutputDebugString` or log files for any `ERROR` or `WARNING` lines.
+-   **Log Analysis**: Strict checking of `misc\agent_output.log` for any `ERROR` or `WARNING` lines after a build or launch.
 -   **Visual Inspection**: Report any visual artifacts, flickering, or incorrect rendering immediately.
 
 ## Reporting

.agent/workflows/build.md

@@ -3,15 +3,19 @@ description: Build the Juliet project using FastBuild
 ---
 
 // turbo-all
-// @auto-approve: true
 
-This workflow sets up the Juliet build environment and runs `fbuild`.
+This workflow builds the Juliet project and writes output to `misc\agent_output.log`.
 
-1. To build a specific configuration (e.g., msvc-Debug):
-`misc\agent_build.bat clang-Debug"`
+1. To build the default (clang-Debug):
+// turbo
+`misc\agent_build.bat clang 2>&1 | tee misc\agent_output.log`
 
-2. To build the default clang:
-`misc\agent_build.bat clang"`
+2. To build a specific configuration (e.g., clang-Debug, msvc-Debug):
+// turbo
+`misc\agent_build.bat clang-Debug 2>&1 | tee misc\agent_output.log`
 
 3. To see all available targets:
-`misc\agent_build.bat -showtargets"`
+// turbo
+`misc\agent_build.bat -showtargets 2>&1 | tee misc\agent_output.log`
+
+4. Check build results by reading `misc\agent_output.log`.

.agent/workflows/launch.md

@@ -2,5 +2,12 @@
 description: Launch the Juliet application
 ---
 
-1. Run the launch script
-   misc\launch.bat autoclose
+// turbo-all
+
+This workflow launches the Juliet application and writes output to `misc\agent_output.log`.
+
+1. Run the launch script:
+// turbo
+`misc\launch.bat autoclose 2>&1 | tee misc\agent_output.log`
+
+2. Check launch results by reading `misc\agent_output.log`.

.agent/workflows/recompile_shaders.md

@@ -4,7 +4,10 @@ description: Recompile shaders for the Juliet project
 
 // turbo-all
 
-This workflow recompiles all shaders using the `recompile_shaders.bat` script.
+This workflow recompiles all shaders and writes output to `misc\agent_output.log`.
 
 1. Recompile all shaders:
-`misc\recompile_shaders.bat"`
+// turbo
+`misc\recompile_shaders.bat 2>&1 | tee misc\agent_output.log`
+
+2. Check shader compilation results by reading `misc\agent_output.log`.

.gitignore

@@ -13,6 +13,7 @@
 .idea/
 .vs/
 [Ii]ntermediate/
+[sS]hip/
 
 # Logs
 build_*.txt
@@ -51,3 +52,5 @@ launch_*.txt
 *.out
 *.app
 
+misc/agent_error.log
+misc/agent_output_ship.log

AgentData/lighting_and_skybox_plan.md

@@ -0,0 +1,292 @@
+# Lighting & Skybox Plan
+
+## Current State
+
+| Item | Current |
+|------|---------|
+| Vertex format | `float3 Position` + `float4 Color` (28 bytes, no normals) |
+| Vertex shader | [Triangle.vert.hlsl](file:///w:/Classified/Juliet/Assets/source/Triangle.vert.hlsl) — bindless buffer read, `mul(VP, mul(Model, pos))` |
+| Fragment shader | [SolidColor.frag.hlsl](file:///w:/Classified/Juliet/Assets/source/SolidColor.frag.hlsl) — passthrough `return Color` |
+| Push constants | `ViewProjection` + `Model` + `BufferIndex` + extras |
+| Texturing | None — no sampler usage, no texture reads |
+
+---
+
+## Phase 1: Add Normals to Vertex Data
+
+Lighting requires normals. This is the foundation for everything else.
+
+### Vertex Format Change
+
+```diff
+ struct Vertex
+ {
+     float Position[3];
++    float Normal[3];
+     float Color[4];
+ };
+```
+
+- **Stride**: 28 → 40 bytes
+- Update `Triangle.vert.hlsl` stride constant: `uint stride = 40;`
+- Load normal after position: `float3 normal = asfloat(buffer.Load3(offset + 12));`
+- Load color shifts to: `float4 col = asfloat(buffer.Load4(offset + 24));`
+
+### Files to modify
+
+| File | Change |
+|------|--------|
+| [VertexData.h](file:///w:/Classified/Juliet/Juliet/include/Graphics/VertexData.h) | Add `float Normal[3]` to `Vertex` |
+| [MeshRenderer.cpp](file:///w:/Classified/Juliet/Juliet/src/Graphics/MeshRenderer.cpp) | Update `AddCube()` to include per-face normals |
+| [Triangle.vert.hlsl](file:///w:/Classified/Juliet/Assets/source/Triangle.vert.hlsl) | Update stride, load normal, pass to fragment |
+
+---
+
+## Phase 2: Basic Directional Light (Diffuse)
+
+Simple single directional light with diffuse (Lambert) shading.
+
+### Approach: Push light data through RootConstants
+
+Add light direction and color to `RootConstants.hlsl` and the C++ `PushData`:
+
+```hlsl
+// RootConstants.hlsl additions
+float3   LightDirection;  // Normalized, world-space
+float    _LightPad;
+float3   LightColor;
+float    AmbientIntensity;
+```
+
+```cpp
+// PushData additions
+Vector3 LightDirection;
+float   _LightPad;
+Vector3 LightColor;
+float   AmbientIntensity;
+```
+
+### Shader Changes
+
+**Vertex shader** — transform normal to world space and pass it to fragment:
+
+```hlsl
+// Triangle.vert.hlsl output struct
+struct Output
+{
+    float4 Color    : TEXCOORD0;
+    float3 WorldNormal : TEXCOORD1;
+    float4 Position : SV_Position;
+};
+
+// In main():
+float3 worldNormal = mul((float3x3)Model, normal);
+output.WorldNormal = worldNormal;
+```
+
+> [!NOTE]
+> Using `(float3x3)Model` for normal transform is only correct for uniform-scale transforms. For non-uniform scale, you'd need the inverse-transpose. Fine for now with translation-only transforms.
+
+**Fragment shader** — apply Lambert diffuse:
+
+```hlsl
+// SolidColor.frag.hlsl → rename to Lit.frag.hlsl
+#include "RootConstants.hlsl"
+
+float4 main(float4 Color : TEXCOORD0, float3 WorldNormal : TEXCOORD1) : SV_Target0
+{
+    float3 N = normalize(WorldNormal);
+    float  NdotL = saturate(dot(N, -LightDirection));
+    float3 diffuse = Color.rgb * LightColor * NdotL;
+    float3 ambient = Color.rgb * AmbientIntensity;
+    return float4(diffuse + ambient, Color.a);
+}
+```
+
+### Files to modify
+
+| File | Change |
+|------|--------|
+| [RootConstants.hlsl](file:///w:/Classified/Juliet/Assets/source/RootConstants.hlsl) | Add light params |
+| [MeshRenderer.h](file:///w:/Classified/Juliet/Juliet/include/Graphics/MeshRenderer.h) | Add light params to `PushData` |
+| [Triangle.vert.hlsl](file:///w:/Classified/Juliet/Assets/source/Triangle.vert.hlsl) | Pass world normal to fragment |
+| [SolidColor.frag.hlsl](file:///w:/Classified/Juliet/Assets/source/SolidColor.frag.hlsl) | Lambert diffuse + ambient |
+| [DebugDisplayRenderer.cpp](file:///w:/Classified/Juliet/Juliet/src/Graphics/DebugDisplayRenderer.cpp) | Update push data struct to match new layout |
+| [main.cpp](file:///w:/Classified/Juliet/JulietApp/main.cpp) | Set `LightDirection`, `LightColor`, `AmbientIntensity` |
+
+---
+
+## Phase 3: Skybox
+
+A skybox renders a cubemap texture behind all geometry, giving the scene a background.
+
+### Approach: Fullscreen-triangle with inverse VP
+
+Render a fullscreen triangle as the very last thing (or first with depth write off), sample a cubemap using the camera view direction reconstructed from screen coordinates.
+
+### New Assets
+
+- **Skybox cubemap texture** — a `.dds` or 6 `.png` face images loaded as a `TextureCube`
+- **New shaders**: `Skybox.vert.hlsl` + `Skybox.frag.hlsl`
+
+### Shader Design
+
+**Vertex shader** — fullscreen triangle using `SV_VertexID`:
+
+```hlsl
+// Skybox.vert.hlsl
+#include "RootConstants.hlsl"
+
+struct Output
+{
+    float3 ViewDir  : TEXCOORD0;
+    float4 Position : SV_Position;
+};
+
+Output main(uint vertexID : SV_VertexID)
+{
+    Output output;
+
+    // Fullscreen triangle
+    float2 uv = float2((vertexID << 1) & 2, vertexID & 2);
+    float4 clipPos = float4(uv * 2.0 - 1.0, 1.0, 1.0);
+    clipPos.y = -clipPos.y;
+
+    output.Position = clipPos;
+
+    // Reconstruct view direction from clip space
+    // InverseViewProjection needs to be added to RootConstants
+    float4 worldPos = mul(InverseViewProjection, clipPos);
+    output.ViewDir = worldPos.xyz / worldPos.w;
+
+    return output;
+}
+```
+
+**Fragment shader** — sample cubemap:
+
+```hlsl
+// Skybox.frag.hlsl
+#include "RootConstants.hlsl"
+
+float4 main(float3 ViewDir : TEXCOORD0) : SV_Target0
+{
+    TextureCube skybox = ResourceDescriptorHeap[TextureIndex];
+    SamplerState samp = SamplerDescriptorHeap[0]; // Linear clamp
+    return skybox.Sample(samp, normalize(ViewDir));
+}
+```
+
+### Pipeline Requirements
+
+| Setting | Value |
+|---------|-------|
+| Depth write | **Off** (skybox is infinitely far) |
+| Depth test | **LessEqual** or **Off** (render behind everything) |
+| Cull mode | **None** (fullscreen triangle) |
+| Draw call | `Draw(3, 0)` — no vertex buffer needed |
+
+### New C++ Components
+
+1. **Cubemap loading** — need to create `TextureCube` from 6 face images or a `.dds` cubemap file
+2. **Skybox pipeline** — new `GraphicsPipeline` with the skybox shaders and the pipeline settings above
+3. **Sampler** — need at least one linear sampler in the sampler heap (may already exist for ImGui)
+4. **`InverseViewProjection`** — add to `RootConstants` and compute in C++ via a `MatrixInverse` function
+
+> [!IMPORTANT]
+> `MatrixInverse` needs to be implemented in `Matrix.h`. This is a non-trivial 4×4 matrix inversion (adjugate/determinant method or Gauss-Jordan).
+
+### Files to modify/create
+
+| File | Change |
+|------|--------|
+| [NEW] `Skybox.vert.hlsl` | Fullscreen triangle + view direction |
+| [NEW] `Skybox.frag.hlsl` | Cubemap sample |
+| [RootConstants.hlsl](file:///w:/Classified/Juliet/Assets/source/RootConstants.hlsl) | Add `InverseViewProjection` |
+| [Matrix.h](file:///w:/Classified/Juliet/Juliet/include/Core/Math/Matrix.h) | Add `MatrixInverse()` |
+| [MeshRenderer.h](file:///w:/Classified/Juliet/Juliet/include/Graphics/MeshRenderer.h) | Add `InverseViewProjection` to `PushData` |
+| [main.cpp](file:///w:/Classified/Juliet/JulietApp/main.cpp) | Create skybox pipeline, load cubemap, render skybox |
+
+---
+
+## Recommended Implementation Order
+
+```mermaid
+graph LR
+    A["Phase 1<br/>Add Normals"] --> B["Phase 2<br/>Directional Light"]
+    B --> C["Phase 3<br/>Skybox"]
+```
+
+1. **Phase 1** (normals) is the smallest and unblocks Phase 2
+2. **Phase 2** (lighting) gives the cubes visible 3D depth immediately
+3. **Phase 3** (skybox) is independent of lighting but benefits from having `MatrixInverse` and sampler infrastructure
+
+> [!TIP]
+> Phases 1+2 together are a single session of work (~8 files). Phase 3 is larger due to cubemap loading and new pipeline creation.
+
+---
+
+## Open Questions (Answered)
+
+1. **Cubemap source** — **Procedural gradient skybox** chosen because asset loading infrastructure is not yet established.
+2. **Sampler heap** — Evaluate what exists. However, with a procedural skybox, we won't need a sampler for Phase 3! (The sky color can be procedurally generated from the reconstructed view direction).
+3. **Specular** — **Blinn-Phong** specular, structured in an agnostic way so PBR (physically based rendering) parameters can be plugged in later.
+
+---
+
+## Phase 4: Forward Rendered Entity Lights
+
+A simple, fast forward renderer using a Global Structured Buffer for entity-based point lights.
+
+### Approach: Bindless Global Lights Buffer
+
+Instead of passing each light via PushConstants, we pass a `StructuredBuffer<PointLight>` index and iterate over the active lights in the fragment shader.
+
+### New C++ Components
+
+```cpp
+struct PointLight
+{
+    Vector3 Position;
+    float   Radius;
+    Vector3 Color;
+    float   Intensity;
+};
+```
+
+1. **Lights Buffer Allocation**: Allocate a `StructuredBuffer` large enough for all potential lights (e.g., max 1024).
+2. **Buffer Upload**: Loop through the active game entity lights every frame and upload them using the TransferBuffer system.
+3. **PushData Update**:
+   - `uint32 LightsBufferIndex`
+   - `uint32 ActiveLightCount`
+
+### Shader Design
+
+**Fragment Shader Expansion** loop over all `ActiveLightCount` to compute the attenuation and diffuse, then accumulate.
+
+```hlsl
+StructuredBuffer<PointLight> lights = ResourceDescriptorHeap[LightsBufferIndex];
+
+float3 totalDiffuse = Color.rgb * LightColor * NdotL; // Include Directional Sun
+
+for (uint i = 0; i < ActiveLightCount; ++i)
+{
+    PointLight light = lights[i];
+    
+    float3 lightVector = light.Position - WorldPosition;
+    float distance = length(lightVector);
+    
+    if (distance > light.Radius) continue;
+    
+    float3 L = lightVector / distance;
+    float NdotL = saturate(dot(N, L));
+    
+    float attenuation = 1.0 - saturate(distance / light.Radius);
+    attenuation *= attenuation; // inverse square-ish 
+    
+    totalDiffuse += Color.rgb * light.Color * light.Intensity * NdotL * attenuation;
+}
+```
+
+> [!NOTE]
+> Passing `WorldPosition` to the Fragment shader from the Vertex shader is required for positional lighting.

Assets/source/Debug.vert.hlsl

@@ -13,8 +13,8 @@ Output main(uint vertexIndex : SV_VertexID)
     // Retrieve the vertex buffer using SM6.6 bindless syntax
     ByteAddressBuffer buffer = ResourceDescriptorHeap[BufferIndex];
 
-    // TextureIndex is used as vertex offset for consolidated buffer (depth-tested at 0, overlay at halfMax)
-    uint actualVertexIndex = vertexIndex + TextureIndex;
+    // VertexOffset is used as vertex offset for consolidated buffer (depth-tested at 0, overlay at halfMax)
+    uint actualVertexIndex = vertexIndex + VertexOffset;
 
     // Vertex layout: float3 Position (12 bytes) + float4 Color (16 bytes) = 28 bytes stride
     uint stride = 28;

Assets/source/ImGui.frag.hlsl

@@ -8,31 +8,7 @@ struct Input
 
 float4 main(Input input) : SV_Target0
 {
-    // Retrieve the texture using SM6.6 bindless syntax
-    // Texture2D texture = ResourceDescriptorHeap[TextureIndex]; (Must cast to Texture2D<float4>)
-    // Wait, ResourceDescriptorHeap indexing returns a wrapper, usually we use Textures[TextureIndex]?
-    // Juliet seems to use `ResourceDescriptorHeap` for Buffers.
-    // Let's check Triangle.vert/frag.
-    
-    // In bindless, usually:
-    // Texture2D<float4> tex = ResourceDescriptorHeap[TextureIndex];
-    // SamplerState samp = SamplerDescriptorHeap[0]; // Assuming static sampler or passed index
-    
-    // I need to check how Juliet accesses textures.
-    // I'll assume standard SM6.6 usage.
     Texture2D<float4> tex = ResourceDescriptorHeap[TextureIndex];
-    SamplerState      samp = SamplerDescriptorHeap[0]; // Point sampler or Linear? ImGui usually uses Linear.
-    // D3D12GraphicsDevice.cpp created static samplers.
-    // Root signature has Static Samplers.
-    // RegisterSpace 0.
-    // Sampler register 0 is Point/Nearest?
-    // Let's check CreateGraphicsRootSignature in D3D12GraphicsDevice.cpp.
-    // It creates s_nearest at 0.
-    
-    // If I want Linear, I might need another sampler or rely on s_nearest for font (pixel art font?)
-    // Default ImGui font is usually antialiased, so Linear is preferred.
-    // But pixel aligned UI... 
-    // I will use `SamplerDescriptorHeap[0]` for now.
-    
+    SamplerState      samp = SamplerDescriptorHeap[0];
     return input.Color * tex.Sample(samp, input.UV);
 }

Assets/source/ImGui.vert.hlsl

@@ -18,14 +18,10 @@ Output main(uint vertexIndex : SV_VertexID)
 {
     Output output;
 
-    // Retrieve the vertex buffer using SM6.6 bindless syntax
     ByteAddressBuffer buffer = ResourceDescriptorHeap[BufferIndex];
 
-    // Add VertexOffset for indexed drawing with bindless buffers
-    // (SV_VertexID in indexed draw is raw index from index buffer, doesn't include BaseVertexLocation)
     uint actualVertexIndex = vertexIndex + VertexOffset;
 
-    // ImDrawVert stride = 20 bytes (Vec2 pos + Vec2 uv + uint color)
     uint stride = 20;
     uint offset = actualVertexIndex * stride;
 
@@ -33,34 +29,12 @@ Output main(uint vertexIndex : SV_VertexID)
     float2 uv  = asfloat(buffer.Load2(offset + 8));
     uint col   = buffer.Load(offset + 16);
 
-    // Unpack color (uint to float4)
-    // ImGui colors are 0xAABBGGRR (ABGR packed)
-    // We need to unpack to float4.
-    // HLSL unpacks as little endian.
-    // uint 0xAABBGGRR -> byte0=RR, byte1=GG, byte2=BB, byte3=AA
     float4 c;
     c.x = float(col & 0xFF) / 255.0f;
     c.y = float((col >> 8) & 0xFF) / 255.0f;
     c.z = float((col >> 16) & 0xFF) / 255.0f;
     c.w = float((col >> 24) & 0xFF) / 255.0f;
 
-    // Transform
-    // ImGui sends pixel coordinates.
-    // We need to transform to NDC [-1, 1].
-    // PushConstants should contain Scale and Translate.
-    // float2 Scale = 2.0 / DisplaySize
-    // float2 Translate = -1.0 - (DisplayPos * Scale)
-    
-    // We will assume PushConstants are float2 Scale, float2 Translate.
-    // Struct in RootConstants.hlsl?
-    // RootConstants.hlsl likely defines `cbuffer PushConstants : register(b0)`.
-    // Let's assume standard push constants usage.
-    // Debug.vert.hlsl used `ViewProjection`. 
-    // We need to customize PushConstants or reuse `ViewProjection` slot?
-    // Juliet uses 128 bytes of push constants.
-    // We can map float4 ProjectionMatrix (or similar).
-    
-    // Use Scale and Translate from RootConstants
     output.Position = float4(pos * Scale + Translate, 0.0f, 1.0f);
     output.Color = c;
     output.UV = uv;

Assets/source/RootConstants.hlsl

@@ -1,15 +1,39 @@
 #ifndef ROOT_CONSTANTS_HLSL
 #define ROOT_CONSTANTS_HLSL
+ 
+struct PointLight
+{
+    float3 Position;
+    float  Radius;
+    float3 Color;
+    float  Intensity;
+};
+
+struct TransformData
+{
+    row_major float4x4 Model;
+};
 
 cbuffer RootConstants : register(b0, space0)
 {
     row_major float4x4 ViewProjection;
+    uint     MeshIndex;
+    uint     TransformsBufferIndex;
     uint     BufferIndex;
-    uint     TextureIndex; 
+    uint     TextureIndex;
     uint     VertexOffset; // Base vertex for indexed drawing with bindless buffers
     uint     _Padding;     // Padding for alignment
     float2   Scale;        // 2D scale factor
     float2   Translate;    // 2D translation
+    float2   _Padding2;    // Explicit padding to align LightDirection to 16 bytes
+    
+    float3   GlobalLightDirection;  // Normalized, world-space
+    float    GlobalLightPad;
+    float3   GlobalLightColor;
+    float    GlobalAmbientIntensity;
+
+    uint     LightBufferIndex;
+    uint     ActiveLightCount;
 };
 
 

Assets/source/Skybox.frag.hlsl

@@ -0,0 +1,26 @@
+#include "RootConstants.hlsl"
+
+float4 main(float3 ViewDir : TEXCOORD0) : SV_Target0
+{
+    float3 dir = normalize(ViewDir);
+    
+    // Simple Procedural Gradient Skybox Colors
+    float3 skyZenithColor = float3(0.05f, 0.15f, 0.45f); // Deep blue top
+    float3 skyHorizonColor = float3(0.4f, 0.6f, 0.9f); // Light blue horizon
+    float3 groundColor = float3(0.1f, 0.1f, 0.15f); // Dark ground
+    
+    float t = dir.z; // -1 to 1 based on vertical alignment
+    
+    float3 finalColor = groundColor;
+    
+    if (t > 0.0f) {
+        // Blend from horizon to zenith
+        finalColor = lerp(skyHorizonColor, skyZenithColor, t);
+    } else {
+        // Ground - quick blend from horizon to ground
+        finalColor = lerp(skyHorizonColor, groundColor, saturate(-t * 2.0f));
+    }
+    
+    // Combine with overall ambient lighting scale
+    return float4(finalColor, 1.0f);
+}

Assets/source/Skybox.vert.hlsl

@@ -0,0 +1,74 @@
+#include "RootConstants.hlsl"
+
+struct Output
+{
+    float3 ViewDir  : TEXCOORD0;
+    float4 Position : SV_Position;
+};
+
+float4x4 Inverse(float4x4 m)
+{
+    float n11 = m[0][0], n12 = m[1][0], n13 = m[2][0], n14 = m[3][0];
+    float n21 = m[0][1], n22 = m[1][1], n23 = m[2][1], n24 = m[3][1];
+    float n31 = m[0][2], n32 = m[1][2], n33 = m[2][2], n34 = m[3][2];
+    float n41 = m[0][3], n42 = m[1][3], n43 = m[2][3], n44 = m[3][3];
+
+    float t11 = n23 * n34 * n42 - n24 * n33 * n42 + n24 * n32 * n43 - n22 * n34 * n43 - n23 * n32 * n44 + n22 * n33 * n44;
+    float t12 = n14 * n33 * n42 - n13 * n34 * n42 - n14 * n32 * n43 + n12 * n34 * n43 + n13 * n32 * n44 - n12 * n33 * n44;
+    float t13 = n13 * n24 * n42 - n14 * n23 * n42 + n14 * n22 * n43 - n12 * n24 * n43 - n13 * n22 * n44 + n12 * n23 * n44;
+    float t14 = n14 * n23 * n32 - n13 * n24 * n32 - n14 * n22 * n33 + n12 * n24 * n33 + n13 * n22 * n34 - n12 * n23 * n34;
+
+    float det = n11 * t11 + n21 * t12 + n31 * t13 + n41 * t14;
+    float idet = 1.0f / det;
+
+    float4x4 ret;
+    ret[0][0] = t11 * idet;
+    ret[0][1] = (n24 * n33 * n41 - n23 * n34 * n41 - n24 * n31 * n43 + n21 * n34 * n43 + n23 * n31 * n44 - n21 * n33 * n44) * idet;
+    ret[0][2] = (n22 * n34 * n41 - n24 * n32 * n41 + n24 * n31 * n42 - n21 * n34 * n42 - n22 * n31 * n44 + n21 * n32 * n44) * idet;
+    ret[0][3] = (n23 * n32 * n41 - n22 * n33 * n41 - n23 * n31 * n42 + n21 * n33 * n42 + n22 * n31 * n43 - n21 * n32 * n43) * idet;
+
+    ret[1][0] = t12 * idet;
+    ret[1][1] = (n13 * n34 * n41 - n14 * n33 * n41 + n14 * n31 * n43 - n11 * n34 * n43 - n13 * n31 * n44 + n11 * n33 * n44) * idet;
+    ret[1][2] = (n14 * n32 * n41 - n12 * n34 * n41 - n14 * n31 * n42 + n11 * n34 * n42 + n12 * n31 * n44 - n11 * n32 * n44) * idet;
+    ret[1][3] = (n12 * n33 * n41 - n13 * n32 * n41 + n13 * n31 * n42 - n11 * n33 * n42 - n12 * n31 * n43 + n11 * n32 * n43) * idet;
+
+    ret[2][0] = t13 * idet;
+    ret[2][1] = (n14 * n23 * n41 - n13 * n24 * n41 - n14 * n21 * n43 + n11 * n24 * n43 + n13 * n21 * n44 - n11 * n23 * n44) * idet;
+    ret[2][2] = (n12 * n24 * n41 - n14 * n22 * n41 + n14 * n21 * n42 - n11 * n24 * n42 - n12 * n21 * n44 + n11 * n22 * n44) * idet;
+    ret[2][3] = (n13 * n22 * n41 - n12 * n23 * n41 - n13 * n21 * n42 + n11 * n23 * n42 + n12 * n21 * n43 - n11 * n22 * n43) * idet;
+
+    ret[3][0] = t14 * idet;
+    ret[3][1] = (n13 * n24 * n31 - n14 * n23 * n31 + n14 * n21 * n33 - n11 * n24 * n33 - n13 * n21 * n34 + n11 * n23 * n34) * idet;
+    ret[3][2] = (n14 * n22 * n31 - n12 * n24 * n31 - n14 * n21 * n32 + n11 * n24 * n32 + n12 * n21 * n34 - n11 * n22 * n34) * idet;
+    ret[3][3] = (n12 * n23 * n31 - n13 * n22 * n31 + n13 * n21 * n32 - n11 * n23 * n32 - n12 * n21 * n33 + n11 * n22 * n33) * idet;
+
+    return ret;
+}
+
+Output main(uint vertexID : SV_VertexID)
+{
+    Output output;
+
+    // Fullscreen triangle properties
+    // vertexID 0 -> uv(0,0) -> pos(-1,  1)
+    // vertexID 1 -> uv(2,0) -> pos( 3,  1)
+    // vertexID 2 -> uv(0,2) -> pos(-1, -3)
+    float2 uv = float2((vertexID << 1) & 2, vertexID & 2);
+    
+    // Map uv to clip space position.
+    // Z is set to 1.0 (far plane in reverse-Z or standard depth)
+    // Assuming standard Z projection ranges from 0 to 1, we use 1.0 for the far plane. 
+    // Depending on reverse-z, this might need to be 0.0, but let's stick to standard 1.0 
+    // depth for skyboxes.
+    float4 clipPos = float4(uv * 2.0 - 1.0, 1.0, 1.0);
+    clipPos.y = -clipPos.y; // Flip Y for D3D
+
+    output.Position = clipPos;
+
+    // Reconstruct view direction from clip space
+    float4x4 inverseVP = Inverse(ViewProjection);
+    float4 worldPos = mul(inverseVP, clipPos);
+    output.ViewDir = worldPos.xyz / worldPos.w;
+
+    return output;
+}

Assets/source/SolidColor.frag.hlsl

@@ -1,4 +1,46 @@
-float4 main(float4 Color : TEXCOORD0) : SV_Target0
+#include "RootConstants.hlsl"
+
+struct Input
 {
-    return Color;
+    float4 Color         : TEXCOORD0;
+    float3 WorldNormal   : TEXCOORD1;
+    float3 WorldPosition : TEXCOORD2;
+};
+
+float4 main(Input input) : SV_Target0
+{
+    float3 normal = normalize(input.WorldNormal);
+
+    // Initial ambient component
+    float3 result = input.Color.rgb * GlobalLightColor * GlobalAmbientIntensity;
+
+    // Directional light contribution
+    float ndotl = max(dot(normal, -GlobalLightDirection), 0.0);
+    result += input.Color.rgb * GlobalLightColor * ndotl;
+
+    // Point lights
+    if (ActiveLightCount > 0)
+    {
+        StructuredBuffer<PointLight> pointLights = ResourceDescriptorHeap[LightBufferIndex];
+        
+        for (uint i = 0; i < ActiveLightCount; ++i)
+        {
+            PointLight light = pointLights[i];
+
+            float3 lightDir = light.Position - input.WorldPosition;
+            float  dist     = length(lightDir);
+            
+            if (dist < light.Radius)
+            {
+                lightDir = normalize(lightDir);
+                float attenuation = 1.0 - (dist / light.Radius);
+                attenuation = max(attenuation, 0.0);
+
+                float pndotl = max(dot(normal, lightDir), 0.0);
+                result += light.Color * input.Color.rgb * pndotl * attenuation * light.Intensity;
+            }
+        }
+    }
+
+    return float4(result, input.Color.a);
 }

Assets/source/Triangle.vert.hlsl

@@ -1,6 +1,8 @@
 struct Output
 {
     float4 Color : TEXCOORD0;
+    float3 WorldNormal : TEXCOORD1;
+    float3 WorldPosition : TEXCOORD2;
     float4 Position : SV_Position;
 };
 
@@ -10,20 +12,25 @@ Output main(uint vertexIndex : SV_VertexID)
 {
     Output output;
 
-    // Retrieve the buffer using SM6.6 bindless syntax
-    // Use BufferIndex from RootConstants (pushed via SetPushConstants)
     ByteAddressBuffer buffer = ResourceDescriptorHeap[BufferIndex];
 
-    // Read position from buffer (Index * stride)
-    // Stride = 2 float (pos) + 4 float (color) = 6 * 4 = 24 bytes ?
-    // Let's assume just position 2D (8 bytes) + Color (16 bytes)
-    uint stride = 24;
+    uint stride = 40;
     uint offset = vertexIndex * stride;
 
-    float2 pos = asfloat(buffer.Load2(offset));
-    float4 col = asfloat(buffer.Load4(offset + 8));
+    float3 pos = asfloat(buffer.Load3(offset));
+    float3 normal = asfloat(buffer.Load3(offset + 12));
+    float4 col = asfloat(buffer.Load4(offset + 24));
 
-    output.Position = float4(pos, 0.0f, 1.0f);
+    // Fetch Model Matrix
+    StructuredBuffer<TransformData> transformsBuffer = ResourceDescriptorHeap[TransformsBufferIndex];
+    float4x4 Model = transformsBuffer[MeshIndex].Model;
+
+    float4 worldPos = mul(Model, float4(pos, 1.0f));
+    output.Position = mul(ViewProjection, worldPos);
     output.Color = col;
+    output.WorldPosition = worldPos.xyz;
+    
+    float3 worldNormal = mul((float3x3)Model, normal);
+    output.WorldNormal = worldNormal;
     return output;
 }

External/ImGui.vcxproj

@@ -196,7 +196,7 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='x64-Debug|x64'">
     <NMakeBuildCommandLine>cd $(SolutionDir) &amp; misc\fbuild -ide -dist -monitor -cache $(ProjectName)-$(Configuration)</NMakeBuildCommandLine>
     <NMakeReBuildCommandLine>cd $(SolutionDir) &amp; misc\fbuild -ide -dist -monitor -cache -clean $(ProjectName)-$(Configuration)</NMakeReBuildCommandLine>
-    <NMakePreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_UNICODE;UNICODE;WIN32_LEAN_AND_MEAN;WIN32;_WIN32;__WINDOWS__;_HAS_EXCEPTIONS=0;WIN64;DEBUG;PROFILING_ENABLED;JULIET_ENABLE_IMGUI;IMGUI_API=__declspec(dllexport);</NMakePreprocessorDefinitions>
+    <NMakePreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_UNICODE;UNICODE;WIN32_LEAN_AND_MEAN;WIN32;_WIN32;__WINDOWS__;_HAS_EXCEPTIONS=0;WIN64;DEBUG;PROFILING_ENABLED;JULIET_ENABLE_IMGUI;JULIET_DEBUG;IMGUI_API=__declspec(dllexport);</NMakePreprocessorDefinitions>
     <NMakeIncludeSearchPath>..\;imgui;imgui\backends;C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.44.35207\include\;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\ucrt;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\um;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\shared;</NMakeIncludeSearchPath>
     <AdditionalOptions>/std:c++20 /wd5267 /wd4061 /wd4505 /wd4514 /wd4577 /wd4625 /wd4710 /wd4711 /wd4746 /wd4820 /wd5045 /wd5220 /wd5245 /wd4365 /wd5219 </AdditionalOptions>
     <LocalDebuggerWorkingDirectory>$(SolutionDir)\bin\$(Configuration)\</LocalDebuggerWorkingDirectory>
@@ -226,7 +226,7 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='x64Clang-Debug|x64'">
     <NMakeBuildCommandLine>cd $(SolutionDir) &amp; misc\fbuild -ide -dist -monitor -cache $(ProjectName)-$(Configuration)</NMakeBuildCommandLine>
     <NMakeReBuildCommandLine>cd $(SolutionDir) &amp; misc\fbuild -ide -dist -monitor -cache -clean $(ProjectName)-$(Configuration)</NMakeReBuildCommandLine>
-    <NMakePreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_UNICODE;UNICODE;WIN32_LEAN_AND_MEAN;WIN32;_WIN32;__WINDOWS__;_HAS_EXCEPTIONS=0;WIN64;DEBUG;PROFILING_ENABLED;JULIET_ENABLE_IMGUI;IMGUI_API=__declspec(dllexport);</NMakePreprocessorDefinitions>
+    <NMakePreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_UNICODE;UNICODE;WIN32_LEAN_AND_MEAN;WIN32;_WIN32;__WINDOWS__;_HAS_EXCEPTIONS=0;WIN64;DEBUG;PROFILING_ENABLED;JULIET_ENABLE_IMGUI;JULIET_DEBUG;IMGUI_API=__declspec(dllexport);</NMakePreprocessorDefinitions>
     <NMakeIncludeSearchPath>..\;imgui;imgui\backends;C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.44.35207\include\;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\ucrt;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\um;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\shared;</NMakeIncludeSearchPath>
     <AdditionalOptions>/std:c++20 /wd5267 /wd4061 /wd4505 /wd4514 /wd4577 /wd4625 /wd4710 /wd4711 /wd4746 /wd4820 /wd5045 /wd5220 /wd5245 /wd4365 /wd5219 </AdditionalOptions>
     <LocalDebuggerWorkingDirectory>$(SolutionDir)\bin\$(Configuration)\</LocalDebuggerWorkingDirectory>

Game/Entity/Entity.h

@@ -47,15 +47,18 @@ namespace Game
         requires EntityConcept<EntityType>
     EntityType* MakeEntity(EntityManager& manager, float x, float y)
     {
-        auto*       arena  = Juliet::GetGameArena();
-        EntityType* result = Juliet::ArenaPushType<EntityType>(arena, ConstString("EntityType"));
-        Entity*     base = result->Base = Juliet::ArenaPushType<Entity>(arena, ConstString("Entity"));
-        base->X                         = x;
-        base->Y                         = y;
-        base->Derived                   = result;
-        base->Kind                      = EntityType::Kind;
+        auto*       arena  = manager.Arena;
+        EntityType* result = Juliet::ArenaPushStruct<EntityType>(arena);
+        Entity      base;
+        base.X       = x;
+        base.Y       = y;
+        base.Derived = result;
+        base.Kind    = EntityType::Kind;
+        manager.Entities.PushBack(base);
 
-        RegisterEntity(manager, base);
+        result->Base = manager.Entities.Back();
+
+        RegisterEntity(manager, &base);
 
         return result;
     }

Game/Entity/EntityManager.cpp

@@ -11,7 +11,16 @@ namespace Game
 
     EntityID EntityManager::ID = 0;
 
-    void InitEntityManager() {}
+    void InitEntityManager(Juliet::NonNullPtr<Juliet::Arena> arena)
+    {
+        Manager.Arena = arena.Get();
+        Manager.Entities.Create(arena JULIET_DEBUG_PARAM("Entities"));
+    }
+
+    void ShutdownEntityManager()
+    {
+        Manager.Entities.Destroy();
+    }
 
     EntityManager& GetEntityManager()
     {

Game/Entity/EntityManager.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <Core/Common/CoreTypes.h>
+#include <Core/Container/Vector.h>
 
 namespace Game
 {
@@ -10,10 +11,14 @@ namespace Game
     struct EntityManager
     {
         static EntityID ID;
-        // May be this should contains the allocator for each entity types
+
+        Juliet::Arena* Arena;
+        // TODO: Should be a pool
+        Juliet::VectorArena<Entity, 1024> Entities;
     };
 
-    void           InitEntityManager();
+    void           InitEntityManager(Juliet::NonNullPtr<Juliet::Arena> arena);
+    void           ShutdownEntityManager();
     EntityManager& GetEntityManager();
     void           RegisterEntity(EntityManager& manager, Entity* entity);
 } // namespace Game

Game/Game.vcxproj

@@ -257,7 +257,7 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='x64-Debug|x64'">
     <NMakeBuildCommandLine>cd $(SolutionDir) &amp; misc\fbuild -ide -dist -monitor -cache $(ProjectName)-$(Configuration)</NMakeBuildCommandLine>
     <NMakeReBuildCommandLine>cd $(SolutionDir) &amp; misc\fbuild -ide -dist -monitor -cache -clean $(ProjectName)-$(Configuration)</NMakeReBuildCommandLine>
-    <NMakePreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_UNICODE;UNICODE;WIN32_LEAN_AND_MEAN;WIN32;_WIN32;__WINDOWS__;_HAS_EXCEPTIONS=0;WIN64;DEBUG;PROFILING_ENABLED;JULIET_ENABLE_IMGUI;IMGUI_API=__declspec(dllexport);</NMakePreprocessorDefinitions>
+    <NMakePreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_UNICODE;UNICODE;WIN32_LEAN_AND_MEAN;WIN32;_WIN32;__WINDOWS__;_HAS_EXCEPTIONS=0;WIN64;DEBUG;PROFILING_ENABLED;JULIET_ENABLE_IMGUI;JULIET_DEBUG;IMGUI_API=__declspec(dllexport);</NMakePreprocessorDefinitions>
     <NMakeIncludeSearchPath>..\;..\External\imgui;..\External\imgui\backends;C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.44.35207\include\;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\ucrt;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\um;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\shared;</NMakeIncludeSearchPath>
     <AdditionalOptions>/std:c++20 /wd5267 /wd4061 /wd4505 /wd4514 /wd4577 /wd4625 /wd4710 /wd4711 /wd4746 /wd4820 /wd5045 /wd5220 /wd5245 /wd4365 /wd5219 </AdditionalOptions>
     <LocalDebuggerWorkingDirectory>$(SolutionDir)\bin\$(Configuration)\</LocalDebuggerWorkingDirectory>
@@ -287,7 +287,7 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='x64Clang-Debug|x64'">
     <NMakeBuildCommandLine>cd $(SolutionDir) &amp; misc\fbuild -ide -dist -monitor -cache $(ProjectName)-$(Configuration)</NMakeBuildCommandLine>
     <NMakeReBuildCommandLine>cd $(SolutionDir) &amp; misc\fbuild -ide -dist -monitor -cache -clean $(ProjectName)-$(Configuration)</NMakeReBuildCommandLine>
-    <NMakePreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_UNICODE;UNICODE;WIN32_LEAN_AND_MEAN;WIN32;_WIN32;__WINDOWS__;_HAS_EXCEPTIONS=0;WIN64;DEBUG;PROFILING_ENABLED;JULIET_ENABLE_IMGUI;IMGUI_API=__declspec(dllexport);</NMakePreprocessorDefinitions>
+    <NMakePreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_UNICODE;UNICODE;WIN32_LEAN_AND_MEAN;WIN32;_WIN32;__WINDOWS__;_HAS_EXCEPTIONS=0;WIN64;DEBUG;PROFILING_ENABLED;JULIET_ENABLE_IMGUI;JULIET_DEBUG;IMGUI_API=__declspec(dllexport);</NMakePreprocessorDefinitions>
     <NMakeIncludeSearchPath>..\;..\External\imgui;..\External\imgui\backends;C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.44.35207\include\;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\ucrt;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\um;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\shared;</NMakeIncludeSearchPath>
     <AdditionalOptions>/std:c++20 /wd5267 /wd4061 /wd4505 /wd4514 /wd4577 /wd4625 /wd4710 /wd4711 /wd4746 /wd4820 /wd5045 /wd5220 /wd5245 /wd4365 /wd5219 </AdditionalOptions>
     <LocalDebuggerWorkingDirectory>$(SolutionDir)\bin\$(Configuration)\</LocalDebuggerWorkingDirectory>
@@ -317,7 +317,7 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='x64-Debug|x64'">
     <NMakeBuildCommandLine>cd $(SolutionDir) &amp; misc\fbuild -ide -dist -monitor -cache $(ProjectName)-$(Configuration)</NMakeBuildCommandLine>
     <NMakeReBuildCommandLine>cd $(SolutionDir) &amp; misc\fbuild -ide -dist -monitor -cache -clean $(ProjectName)-$(Configuration)</NMakeReBuildCommandLine>
-    <NMakePreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_UNICODE;UNICODE;WIN32_LEAN_AND_MEAN;WIN32;_WIN32;__WINDOWS__;_HAS_EXCEPTIONS=0;WIN64;DEBUG;PROFILING_ENABLED;JULIET_ENABLE_IMGUI;JULIET_EXPORT;JULIET_WIN32;</NMakePreprocessorDefinitions>
+    <NMakePreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_UNICODE;UNICODE;WIN32_LEAN_AND_MEAN;WIN32;_WIN32;__WINDOWS__;_HAS_EXCEPTIONS=0;WIN64;DEBUG;PROFILING_ENABLED;JULIET_ENABLE_IMGUI;JULIET_DEBUG;JULIET_EXPORT;JULIET_WIN32;</NMakePreprocessorDefinitions>
     <NMakeIncludeSearchPath>..\;..\Juliet\include;..\Juliet\src;..\External\imgui;..\External\imgui\backends;C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.44.35207\include\;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\ucrt;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\um;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\shared;</NMakeIncludeSearchPath>
     <AdditionalOptions>/std:c++20 /wd5267 /wd4061 /wd4505 /wd4514 /wd4577 /wd4625 /wd4710 /wd4711 /wd4746 /wd4820 /wd5045 /wd5220 /wd5245 </AdditionalOptions>
     <LocalDebuggerWorkingDirectory>$(SolutionDir)\bin\$(Configuration)\</LocalDebuggerWorkingDirectory>
@@ -347,7 +347,7 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='x64Clang-Debug|x64'">
     <NMakeBuildCommandLine>cd $(SolutionDir) &amp; misc\fbuild -ide -dist -monitor -cache $(ProjectName)-$(Configuration)</NMakeBuildCommandLine>
     <NMakeReBuildCommandLine>cd $(SolutionDir) &amp; misc\fbuild -ide -dist -monitor -cache -clean $(ProjectName)-$(Configuration)</NMakeReBuildCommandLine>
-    <NMakePreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_UNICODE;UNICODE;WIN32_LEAN_AND_MEAN;WIN32;_WIN32;__WINDOWS__;_HAS_EXCEPTIONS=0;WIN64;DEBUG;PROFILING_ENABLED;JULIET_ENABLE_IMGUI;JULIET_EXPORT;JULIET_WIN32;</NMakePreprocessorDefinitions>
+    <NMakePreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_UNICODE;UNICODE;WIN32_LEAN_AND_MEAN;WIN32;_WIN32;__WINDOWS__;_HAS_EXCEPTIONS=0;WIN64;DEBUG;PROFILING_ENABLED;JULIET_ENABLE_IMGUI;JULIET_DEBUG;JULIET_EXPORT;JULIET_WIN32;</NMakePreprocessorDefinitions>
     <NMakeIncludeSearchPath>..\;..\Juliet\include;..\Juliet\src;..\External\imgui;..\External\imgui\backends;C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.44.35207\include\;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\ucrt;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\um;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\shared;</NMakeIncludeSearchPath>
     <AdditionalOptions>/std:c++20 /wd5267 /wd4061 /wd4505 /wd4514 /wd4577 /wd4625 /wd4710 /wd4711 /wd4746 /wd4820 /wd5045 /wd5220 /wd5245 </AdditionalOptions>
     <LocalDebuggerWorkingDirectory>$(SolutionDir)\bin\$(Configuration)\</LocalDebuggerWorkingDirectory>
@@ -377,7 +377,7 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='x64-Debug|x64'">
     <NMakeBuildCommandLine>cd $(SolutionDir) &amp; misc\fbuild -ide -dist -monitor -cache $(ProjectName)-$(Configuration)</NMakeBuildCommandLine>
     <NMakeReBuildCommandLine>cd $(SolutionDir) &amp; misc\fbuild -ide -dist -monitor -cache -clean $(ProjectName)-$(Configuration)</NMakeReBuildCommandLine>
-    <NMakePreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_UNICODE;UNICODE;WIN32_LEAN_AND_MEAN;WIN32;_WIN32;__WINDOWS__;_HAS_EXCEPTIONS=0;WIN64;DEBUG;PROFILING_ENABLED;JULIET_ENABLE_IMGUI;JULIET_EXPORT;JULIET_WIN32;</NMakePreprocessorDefinitions>
+    <NMakePreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_UNICODE;UNICODE;WIN32_LEAN_AND_MEAN;WIN32;_WIN32;__WINDOWS__;_HAS_EXCEPTIONS=0;WIN64;DEBUG;PROFILING_ENABLED;JULIET_ENABLE_IMGUI;JULIET_DEBUG;JULIET_EXPORT;JULIET_WIN32;</NMakePreprocessorDefinitions>
     <NMakeIncludeSearchPath>..\;..\Juliet\include;..\Game;C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.44.35207\include\;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\ucrt;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\um;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\shared;</NMakeIncludeSearchPath>
     <AdditionalOptions>/std:c++20 /wd5267 /wd4061 /wd4505 /wd4514 /wd4577 /wd4625 /wd4710 /wd4711 /wd4746 /wd4820 /wd5045 /wd5220 /wd5245 </AdditionalOptions>
     <LocalDebuggerWorkingDirectory>$(SolutionDir)\bin\$(Configuration)\</LocalDebuggerWorkingDirectory>
@@ -407,7 +407,7 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='x64Clang-Debug|x64'">
     <NMakeBuildCommandLine>cd $(SolutionDir) &amp; misc\fbuild -ide -dist -monitor -cache $(ProjectName)-$(Configuration)</NMakeBuildCommandLine>
     <NMakeReBuildCommandLine>cd $(SolutionDir) &amp; misc\fbuild -ide -dist -monitor -cache -clean $(ProjectName)-$(Configuration)</NMakeReBuildCommandLine>
-    <NMakePreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_UNICODE;UNICODE;WIN32_LEAN_AND_MEAN;WIN32;_WIN32;__WINDOWS__;_HAS_EXCEPTIONS=0;WIN64;DEBUG;PROFILING_ENABLED;JULIET_ENABLE_IMGUI;JULIET_EXPORT;JULIET_WIN32;</NMakePreprocessorDefinitions>
+    <NMakePreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_UNICODE;UNICODE;WIN32_LEAN_AND_MEAN;WIN32;_WIN32;__WINDOWS__;_HAS_EXCEPTIONS=0;WIN64;DEBUG;PROFILING_ENABLED;JULIET_ENABLE_IMGUI;JULIET_DEBUG;JULIET_EXPORT;JULIET_WIN32;</NMakePreprocessorDefinitions>
     <NMakeIncludeSearchPath>..\;..\Juliet\include;..\Game;C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.44.35207\include\;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\ucrt;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\um;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\shared;</NMakeIncludeSearchPath>
     <AdditionalOptions>/std:c++20 /wd5267 /wd4061 /wd4505 /wd4514 /wd4577 /wd4625 /wd4710 /wd4711 /wd4746 /wd4820 /wd5045 /wd5220 /wd5245 </AdditionalOptions>
     <LocalDebuggerWorkingDirectory>$(SolutionDir)\bin\$(Configuration)\</LocalDebuggerWorkingDirectory>

Game/game.cpp

@@ -31,7 +31,7 @@ namespace Game
 
 using namespace Juliet;
 
-extern "C" JULIET_API void GameInit(GameInitParams* /*params*/)
+extern "C" JULIET_API void GameInit(GameInitParams* params)
 {
     // Example allocation in GameArena
     struct GameState
@@ -40,7 +40,7 @@ extern "C" JULIET_API void GameInit(GameInitParams* /*params*/)
         int   Score;
     };
 
-    auto* gameState      = ArenaPushType<GameState>(GetGameArena(), ConstString("GameState"));
+    auto* gameState      = ArenaPushStruct<GameState>(params->GameArena);
     gameState->TotalTime = 0.0f;
     gameState->Score     = 0;
 
@@ -49,7 +49,7 @@ extern "C" JULIET_API void GameInit(GameInitParams* /*params*/)
     using namespace Game;
 
     // Entity Use case
-    InitEntityManager();
+    InitEntityManager(params->GameArena);
     auto& manager  = GetEntityManager();
     Door* door     = MakeEntity<Door>(manager, 10.0f, 2.0f);
     door->IsOpened = true;
@@ -69,6 +69,10 @@ extern "C" JULIET_API void GameInit(GameInitParams* /*params*/)
 extern "C" JULIET_API void __cdecl GameShutdown()
 {
     printf("Shutting down game...\n");
+
+    using namespace Game;
+
+    ShutdownEntityManager();
 }
 
 extern "C" JULIET_API void __cdecl GameUpdate([[maybe_unused]] float deltaTime)

Juliet/Juliet.bff

@@ -47,8 +47,11 @@
         // --- DLL BUILD ---
         DLL( '$ProjectName$-Lib-$Platform$-$BuildConfigName$' )
         {
-            .Libraries      = { '$ProjectName$-Objs-$Platform$-$BuildConfigName$',
-                                        'ImGui-Lib-$Platform$-$BuildConfigName$' }
+            .Libraries      = { '$ProjectName$-Objs-$Platform$-$BuildConfigName$' }
+            If ( .BuildConfigName != 'Release' )
+            {
+                ^Libraries      + { 'ImGui-Lib-$Platform$-$BuildConfigName$' }
+            }
 
             .LinkerOutput   = '$BinPath$/$Platform$-$BuildConfigName$/$ProjectName$.dll' // Output .dll to Bin
             

Juliet/Juliet.vcxproj

@@ -86,6 +86,7 @@
     <CustomBuild Include="include\Core\Math\Vector.h" />
     <CustomBuild Include="include\Core\Memory\Allocator.h" />
     <CustomBuild Include="include\Core\Memory\MemoryArena.h" />
+    <CustomBuild Include="include\Core\Memory\MemoryArenaDebug.h" />
     <CustomBuild Include="include\Core\Memory\ScratchArena.h" />
     <CustomBuild Include="include\Core\Memory\Utils.h" />
     <CustomBuild Include="include\Core\Networking\IPAddress.h" />
@@ -107,9 +108,11 @@
     <CustomBuild Include="include\Graphics\GraphicsConfig.h" />
     <CustomBuild Include="include\Graphics\GraphicsPipeline.h" />
     <CustomBuild Include="include\Graphics\ImGuiRenderer.h" />
+    <CustomBuild Include="include\Graphics\Mesh.h" />
     <CustomBuild Include="include\Graphics\RenderPass.h" />
     <CustomBuild Include="include\Graphics\Shader.h" />
     <CustomBuild Include="include\Graphics\Texture.h" />
+    <CustomBuild Include="include\Graphics\VertexData.h" />
     <CustomBuild Include="include\Juliet.h" />
     <CustomBuild Include="Juliet.bff" />
     <CustomBuild Include="src\Core\Application\ApplicationManager.cpp" />
@@ -156,8 +159,8 @@
     <CustomBuild Include="src\Core\Math\Math_Private.h" />
     <CustomBuild Include="src\Core\Math\MathRound.cpp" />
     <CustomBuild Include="src\Core\Memory\Allocator.cpp" />
-    <CustomBuild Include="src\Core\Memory\EngineArena.h" />
     <CustomBuild Include="src\Core\Memory\MemoryArena.cpp" />
+    <CustomBuild Include="src\Core\Memory\MemoryArenaDebug.cpp" />
     <CustomBuild Include="src\Core\Memory\MemoryArenaTests.cpp" />
     <CustomBuild Include="src\Core\Memory\ScratchArena.cpp" />
     <CustomBuild Include="src\Core\Networking\NetworkPacket.cpp" />
@@ -219,10 +222,15 @@
     <CustomBuild Include="src\Graphics\Graphics.cpp" />
     <CustomBuild Include="src\Graphics\GraphicsDevice.h" />
     <CustomBuild Include="src\Graphics\ImGuiRenderer.cpp" />
+    <CustomBuild Include="src\Graphics\Mesh.cpp" />
     <CustomBuild Include="src\UnitTest\Container\VectorUnitTest.cpp" />
     <CustomBuild Include="src\UnitTest\RunUnitTests.cpp" />
   </ItemGroup>
   <ItemGroup>
+    <ClInclude Include="include\Graphics\MeshRenderer.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\Graphics\MeshRenderer.cpp" />
   </ItemGroup>
   <PropertyGroup Label="Globals">
     <ProjectGuid>{ab9c7e88-6c94-4f93-bc2a-7f5284b7d434}</ProjectGuid>
@@ -344,7 +352,7 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='x64-Debug|x64'">
     <NMakeBuildCommandLine>cd $(SolutionDir) &amp; misc\fbuild -ide -dist -monitor -cache $(ProjectName)-$(Configuration)</NMakeBuildCommandLine>
     <NMakeReBuildCommandLine>cd $(SolutionDir) &amp; misc\fbuild -ide -dist -monitor -cache -clean $(ProjectName)-$(Configuration)</NMakeReBuildCommandLine>
-    <NMakePreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_UNICODE;UNICODE;WIN32_LEAN_AND_MEAN;WIN32;_WIN32;__WINDOWS__;_HAS_EXCEPTIONS=0;WIN64;DEBUG;PROFILING_ENABLED;JULIET_ENABLE_IMGUI;IMGUI_API=__declspec(dllexport);</NMakePreprocessorDefinitions>
+    <NMakePreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_UNICODE;UNICODE;WIN32_LEAN_AND_MEAN;WIN32;_WIN32;__WINDOWS__;_HAS_EXCEPTIONS=0;WIN64;DEBUG;PROFILING_ENABLED;JULIET_ENABLE_IMGUI;JULIET_DEBUG;IMGUI_API=__declspec(dllexport);</NMakePreprocessorDefinitions>
     <NMakeIncludeSearchPath>..\;..\External\imgui;..\External\imgui\backends;C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.44.35207\include\;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\ucrt;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\um;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\shared;</NMakeIncludeSearchPath>
     <AdditionalOptions>/std:c++20 /wd5267 /wd4061 /wd4505 /wd4514 /wd4577 /wd4625 /wd4710 /wd4711 /wd4746 /wd4820 /wd5045 /wd5220 /wd5245 /wd4365 /wd5219 </AdditionalOptions>
     <LocalDebuggerWorkingDirectory>$(SolutionDir)\bin\$(Configuration)\</LocalDebuggerWorkingDirectory>
@@ -374,7 +382,7 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='x64Clang-Debug|x64'">
     <NMakeBuildCommandLine>cd $(SolutionDir) &amp; misc\fbuild -ide -dist -monitor -cache $(ProjectName)-$(Configuration)</NMakeBuildCommandLine>
     <NMakeReBuildCommandLine>cd $(SolutionDir) &amp; misc\fbuild -ide -dist -monitor -cache -clean $(ProjectName)-$(Configuration)</NMakeReBuildCommandLine>
-    <NMakePreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_UNICODE;UNICODE;WIN32_LEAN_AND_MEAN;WIN32;_WIN32;__WINDOWS__;_HAS_EXCEPTIONS=0;WIN64;DEBUG;PROFILING_ENABLED;JULIET_ENABLE_IMGUI;IMGUI_API=__declspec(dllexport);</NMakePreprocessorDefinitions>
+    <NMakePreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_UNICODE;UNICODE;WIN32_LEAN_AND_MEAN;WIN32;_WIN32;__WINDOWS__;_HAS_EXCEPTIONS=0;WIN64;DEBUG;PROFILING_ENABLED;JULIET_ENABLE_IMGUI;JULIET_DEBUG;IMGUI_API=__declspec(dllexport);</NMakePreprocessorDefinitions>
     <NMakeIncludeSearchPath>..\;..\External\imgui;..\External\imgui\backends;C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.44.35207\include\;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\ucrt;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\um;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\shared;</NMakeIncludeSearchPath>
     <AdditionalOptions>/std:c++20 /wd5267 /wd4061 /wd4505 /wd4514 /wd4577 /wd4625 /wd4710 /wd4711 /wd4746 /wd4820 /wd5045 /wd5220 /wd5245 /wd4365 /wd5219 </AdditionalOptions>
     <LocalDebuggerWorkingDirectory>$(SolutionDir)\bin\$(Configuration)\</LocalDebuggerWorkingDirectory>
@@ -404,7 +412,7 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='x64-Debug|x64'">
     <NMakeBuildCommandLine>cd $(SolutionDir) &amp; misc\fbuild -ide -dist -monitor -cache $(ProjectName)-$(Configuration)</NMakeBuildCommandLine>
     <NMakeReBuildCommandLine>cd $(SolutionDir) &amp; misc\fbuild -ide -dist -monitor -cache -clean $(ProjectName)-$(Configuration)</NMakeReBuildCommandLine>
-    <NMakePreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_UNICODE;UNICODE;WIN32_LEAN_AND_MEAN;WIN32;_WIN32;__WINDOWS__;_HAS_EXCEPTIONS=0;WIN64;DEBUG;PROFILING_ENABLED;JULIET_ENABLE_IMGUI;JULIET_EXPORT;JULIET_WIN32;</NMakePreprocessorDefinitions>
+    <NMakePreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_UNICODE;UNICODE;WIN32_LEAN_AND_MEAN;WIN32;_WIN32;__WINDOWS__;_HAS_EXCEPTIONS=0;WIN64;DEBUG;PROFILING_ENABLED;JULIET_ENABLE_IMGUI;JULIET_DEBUG;JULIET_EXPORT;JULIET_WIN32;</NMakePreprocessorDefinitions>
     <NMakeIncludeSearchPath>..\;include;src;..\External\imgui;..\External\imgui\backends;C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.44.35207\include\;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\ucrt;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\um;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\shared;</NMakeIncludeSearchPath>
     <AdditionalOptions>/std:c++20 /wd5267 /wd4061 /wd4505 /wd4514 /wd4577 /wd4625 /wd4710 /wd4711 /wd4746 /wd4820 /wd5045 /wd5220 /wd5245 </AdditionalOptions>
     <LocalDebuggerWorkingDirectory>$(SolutionDir)\bin\$(Configuration)\</LocalDebuggerWorkingDirectory>
@@ -434,7 +442,7 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='x64Clang-Debug|x64'">
     <NMakeBuildCommandLine>cd $(SolutionDir) &amp; misc\fbuild -ide -dist -monitor -cache $(ProjectName)-$(Configuration)</NMakeBuildCommandLine>
     <NMakeReBuildCommandLine>cd $(SolutionDir) &amp; misc\fbuild -ide -dist -monitor -cache -clean $(ProjectName)-$(Configuration)</NMakeReBuildCommandLine>
-    <NMakePreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_UNICODE;UNICODE;WIN32_LEAN_AND_MEAN;WIN32;_WIN32;__WINDOWS__;_HAS_EXCEPTIONS=0;WIN64;DEBUG;PROFILING_ENABLED;JULIET_ENABLE_IMGUI;JULIET_EXPORT;JULIET_WIN32;</NMakePreprocessorDefinitions>
+    <NMakePreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_UNICODE;UNICODE;WIN32_LEAN_AND_MEAN;WIN32;_WIN32;__WINDOWS__;_HAS_EXCEPTIONS=0;WIN64;DEBUG;PROFILING_ENABLED;JULIET_ENABLE_IMGUI;JULIET_DEBUG;JULIET_EXPORT;JULIET_WIN32;</NMakePreprocessorDefinitions>
     <NMakeIncludeSearchPath>..\;include;src;..\External\imgui;..\External\imgui\backends;C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.44.35207\include\;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\ucrt;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\um;C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\shared;</NMakeIncludeSearchPath>
     <AdditionalOptions>/std:c++20 /wd5267 /wd4061 /wd4505 /wd4514 /wd4577 /wd4625 /wd4710 /wd4711 /wd4746 /wd4820 /wd5045 /wd5220 /wd5245 </AdditionalOptions>
     <LocalDebuggerWorkingDirectory>$(SolutionDir)\bin\$(Configuration)\</LocalDebuggerWorkingDirectory>

Juliet/Juliet.vcxproj.filters

@@ -106,6 +106,9 @@
     <CustomBuild Include="include\Core\Memory\MemoryArena.h">
       <Filter>include\Core\Memory</Filter>
     </CustomBuild>
+    <CustomBuild Include="include\Core\Memory\MemoryArenaDebug.h">
+      <Filter>include\Core\Memory</Filter>
+    </CustomBuild>
     <CustomBuild Include="include\Core\Memory\ScratchArena.h">
       <Filter>include\Core\Memory</Filter>
     </CustomBuild>
@@ -169,6 +172,9 @@
     <CustomBuild Include="include\Graphics\ImGuiRenderer.h">
       <Filter>include\Graphics</Filter>
     </CustomBuild>
+    <CustomBuild Include="include\Graphics\Mesh.h">
+      <Filter>include\Graphics</Filter>
+    </CustomBuild>
     <CustomBuild Include="include\Graphics\RenderPass.h">
       <Filter>include\Graphics</Filter>
     </CustomBuild>
@@ -178,6 +184,9 @@
     <CustomBuild Include="include\Graphics\Texture.h">
       <Filter>include\Graphics</Filter>
     </CustomBuild>
+    <CustomBuild Include="include\Graphics\VertexData.h">
+      <Filter>include\Graphics</Filter>
+    </CustomBuild>
     <CustomBuild Include="include\Juliet.h">
       <Filter>include</Filter>
     </CustomBuild>
@@ -315,10 +324,10 @@
     <CustomBuild Include="src\Core\Memory\Allocator.cpp">
       <Filter>src\Core\Memory</Filter>
     </CustomBuild>
-    <CustomBuild Include="src\Core\Memory\EngineArena.h">
+    <CustomBuild Include="src\Core\Memory\MemoryArena.cpp">
       <Filter>src\Core\Memory</Filter>
     </CustomBuild>
-    <CustomBuild Include="src\Core\Memory\MemoryArena.cpp">
+    <CustomBuild Include="src\Core\Memory\MemoryArenaDebug.cpp">
       <Filter>src\Core\Memory</Filter>
     </CustomBuild>
     <CustomBuild Include="src\Core\Memory\MemoryArenaTests.cpp">
@@ -504,6 +513,9 @@
     <CustomBuild Include="src\Graphics\ImGuiRenderer.cpp">
       <Filter>src\Graphics</Filter>
     </CustomBuild>
+    <CustomBuild Include="src\Graphics\Mesh.cpp">
+      <Filter>src\Graphics</Filter>
+    </CustomBuild>
     <CustomBuild Include="src\UnitTest\Container\VectorUnitTest.cpp">
       <Filter>src\UnitTest\Container</Filter>
     </CustomBuild>

Juliet/include/Core/Application/ApplicationManager.h

@@ -8,5 +8,6 @@ namespace Juliet
 {
     enum class JulietInit_Flags : uint8;
 
+    struct Arena;
     extern JULIET_API void StartApplication(IApplication& app, JulietInit_Flags flags);
 } // namespace Juliet

Juliet/include/Core/Application/IApplication.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <Core/Common/NonNullPtr.h>
+
 namespace Juliet
 {
     struct RenderPass;
@@ -7,25 +9,26 @@ namespace Juliet
     struct Texture;
     struct ColorTargetInfo;
     struct DepthStencilTargetInfo;
+    struct Arena;
 
     class IApplication
     {
       public:
-        virtual ~IApplication()  = default;
-        virtual void Init()      = 0;
-        virtual void Shutdown()  = 0;
-        virtual void Update()    = 0;
-        virtual bool IsRunning() = 0;
+        virtual ~IApplication()                    = default;
+        virtual void Init(NonNullPtr<Arena> arena) = 0;
+        virtual void Shutdown()                    = 0;
+        virtual void Update()                      = 0;
+        virtual bool IsRunning()                   = 0;
 
         // Accessors for Engine Systems
         virtual struct Window*         GetPlatformWindow() = 0;
         virtual struct GraphicsDevice* GetGraphicsDevice() = 0;
 
         // Render Lifecycle (Engine-Managed Render Loop)
-        virtual void                    OnPreRender(CommandList* cmd)                   = 0;
-        virtual void                    OnRender(RenderPass* pass, CommandList* cmd)    = 0;
-        virtual ColorTargetInfo         GetColorTargetInfo(Texture* swapchainTexture)   = 0;
-        virtual DepthStencilTargetInfo* GetDepthTargetInfo()                            = 0;
-        virtual struct Camera           GetDebugCamera()                                = 0;
+        virtual void                    OnPreRender(CommandList* cmd)                 = 0;
+        virtual void                    OnRender(RenderPass* pass, CommandList* cmd)  = 0;
+        virtual ColorTargetInfo         GetColorTargetInfo(Texture* swapchainTexture) = 0;
+        virtual DepthStencilTargetInfo* GetDepthTargetInfo()                          = 0;
+        virtual struct Camera           GetDebugCamera()                              = 0;
     };
 } // namespace Juliet

Juliet/include/Core/Common/CoreTypes.h

@@ -25,6 +25,8 @@ struct ByteBuffer
     size_t Size;
 };
 
+using ptrdiff_t = decltype(static_cast<int*>(nullptr) - static_cast<int*>(nullptr));
+
 using FunctionPtr = auto (*)(void) -> void;
 
 // Limits

Juliet/include/Core/Common/CoreUtils.h

@@ -162,11 +162,12 @@ namespace Juliet
         return (x + alignment - 1) & ~(alignment - 1);
     }
 
-    inline void Swap(auto* Restrict a, auto* Restrict b)
+    template <typename T>
+    inline void Swap(T* Restrict a, T* Restrict b)
     {
-        auto temp = *a;
-        *a        = *b;
-        *b        = temp;
+        T temp = std::move(*a);
+        *a     = std::move(*b);
+        *b     = std::move(temp);
     }
 
     // Move to another file dedicated to those

Juliet/include/Core/Common/NonNullPtr.h

@@ -15,7 +15,7 @@ namespace Juliet
     class NonNullPtr
     {
       public:
-        NonNullPtr(Type* ptr)
+        inline NonNullPtr(Type* ptr)
           : InternalPtr(ptr)
         {
             Assert(ptr, "Tried to initialize a NonNullPtr with a null pointer");
@@ -64,7 +64,7 @@ namespace Juliet
             return *InternalPtr;
         }
 
-        Type* operator->() const
+        inline Type* operator->() const
         {
             Assert(InternalPtr, "NonNullPtr: Internal Pointer is Null");
             return InternalPtr;

Juliet/include/Core/Container/Vector.h

@@ -3,110 +3,238 @@
 #include <Core/Common/NonNullPtr.h>
 #include <Core/Memory/MemoryArena.h>
 #include <vector>
-#include <WinSock2.h>
 
 namespace Juliet
 {
-    template <typename Type>
+    template <typename Type, size_t ReserveSize = 16, bool AllowRealloc = false>
     struct VectorArena
     {
-      public:
-        VectorArena()
-          : First(nullptr)
-          , Last(nullptr)
-          , Count(0)
-          , Stride(sizeof(Type))
+        void Create(JULIET_DEBUG_PARAM_FIRST(const char* name = nullptr))
         {
-            Arena = ArenaAllocate();
+            Assert(!Arena);
+            static_assert(AllowRealloc == false);
+
+            DataFirst = DataLast = nullptr;
+            Count                = 0;
+
+            JULIET_DEBUG_ONLY(Name = name ? name : Name;)
+            ArenaParams params{ .AllowRealloc = AllowRealloc JULIET_DEBUG_PARAM(.CanReserveMore = false) };
+            Arena         = ArenaAllocate(params JULIET_DEBUG_PARAM(Name));
+            InternalArena = true;
+
+            Reserve(ReserveSize);
         }
 
-        ~VectorArena() { ArenaRelease(Arena); }
+        void Create(NonNullPtr<Arena> arena JULIET_DEBUG_PARAM(const char* name = nullptr))
+        {
+            Assert(!Arena);
 
-        VectorArena(const VectorArena&)
-          : Arena(nullptr)
-          , First(nullptr)
-          , Last(nullptr)
-          , Count(0)
-          , Stride(sizeof(Type))
-        {
-            Assert(false, "Copying VectorArena is not allowed");
+            JULIET_DEBUG_ONLY(Name = name ? name : Name;)
+
+            DataFirst = DataLast = nullptr;
+            Count                = 0;
+            Arena                = arena.Get();
+            InternalArena        = false;
+
+            Reserve(ReserveSize);
         }
-        VectorArena(VectorArena&&) noexcept
-          : Arena(nullptr)
-          , First(nullptr)
-          , Last(nullptr)
-          , Count(0)
-          , Stride(sizeof(Type))
+
+        void Destroy()
         {
-            Assert(false, "Moving VectorArena is not allowed");
+            if (InternalArena)
+            {
+                ArenaRelease(Arena);
+            }
+            DataFirst = DataLast = nullptr;
+            Count                = 0;
+            Capacity             = 0;
+            Arena                = nullptr;
+        }
+
+        void Reserve(size_t newCapacity)
+        {
+            if (newCapacity > Capacity)
+            {
+                if (Data == nullptr)
+                {
+                    Data = ArenaPushArray<Type>(Arena, newCapacity JULIET_DEBUG_PARAM(Name));
+                }
+                else if constexpr (AllowRealloc)
+                {
+                    if (!InternalArena)
+                    {
+                        DataFirst = Data =
+                            static_cast<Type*>(ArenaReallocate(Arena, Data, Capacity * sizeof(Type), newCapacity * sizeof(Type),
+                                                               AlignOf(Type), true JULIET_DEBUG_PARAM("VectorRealloc")));
+                        DataLast = Data + Count - 1;
+                    }
+                }
+                Capacity = newCapacity;
+            }
+        }
+
+        void Resize(size_t newCount)
+        {
+            if (newCount == Count)
+            {
+                return;
+            }
+
+            if (newCount > Capacity)
+            {
+                Reserve(newCount);
+            }
+
+            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);
+
+            if (Count + amount > Capacity)
+            {
+                if (Capacity == 0 && Count + amount < ReserveSize)
+                {
+                    Reserve(ReserveSize);
+                }
+                else
+                {
+                    size_t newCapacity = Max(Capacity * 2, AlignPow2(Capacity + amount, AlignOf(Type)));
+                    Reserve(newCapacity);
+                }
+            }
+
+            Type* dst = Data + Count;
+            MemCopy(dst, buffer, amount * sizeof(Type));
+
+            if (Count == 0)
+            {
+                DataFirst = dst;
+            }
+            DataLast = dst + amount;
+            Count += amount;
+        }
+
+        void PushBack(const Type& value)
+        {
+            Assert(Arena);
+
+            if (Count + 1 > Capacity)
+            {
+                Reserve(Capacity == 0 ? ReserveSize : Capacity * 2);
+            }
+
+            Type* entry = Data + Count;
+            *entry      = value;
+
+            if (Count == 0)
+            {
+                DataFirst = entry;
+            }
+            DataLast = entry;
+            ++Count;
         }
-        void operator=(const VectorArena&) { Assert(false, "Copying VectorArena is not allowed"); }
-        void operator=(VectorArena&&) noexcept { Assert(false, "Moving VectorArena is not allowed"); }
 
         void PushBack(Type&& value)
         {
-            Type* entry = ArenaPushStruct<Type>(Arena);
+            Assert(Arena);
+
+            if (Count + 1 > Capacity)
+            {
+                Reserve(Capacity == 0 ? ReserveSize : Capacity * 2);
+            }
+
+            Type* entry = Data + Count;
             *entry      = std::move(value);
 
             if (Count == 0)
             {
-                First = entry;
+                DataFirst = entry;
             }
-            Last = entry;
-
+            DataLast = entry;
             ++Count;
         }
 
         void RemoveAtFast(index_t index)
         {
+            Assert(Arena);
             Assert(index < Count);
             Assert(Count > 0);
 
-            Type* elementAdr = First + index;
+            Type* elementAdr = DataFirst + index;
 
-            // Swap Last and element
-            Swap(Last, elementAdr);
-            --Last;
+            // Swap DataLast and element
+            if (DataLast != elementAdr)
+            {
+                Swap(DataLast, elementAdr);
+            }
+
+            --DataLast;
             --Count;
 
             if (Count == 0)
             {
-                First = Last = nullptr;
+                DataFirst = DataLast = nullptr;
             }
-
-            ArenaPop(Arena, Stride);
         }
 
         void Clear()
         {
-            ArenaClear(Arena);
-            First = Last = nullptr;
-            Count        = 0;
+            Assert(Arena);
+
+            if (InternalArena)
+            {
+                ArenaClear(Arena);
+                Data     = nullptr;
+                Capacity = 0;
+                Reserve(ReserveSize);
+            }
+
+            DataFirst = DataLast = nullptr;
+            Count                = 0;
         }
 
+        bool IsEmpty() const { return Count == 0; }
+
         // C++ Accessors for loop supports and Index based access
-        Type&       operator[](size_t index) { return First[index]; }
-        const Type& operator[](size_t index) const { return First[index]; }
+        Type&       operator[](size_t index) { return DataFirst[index]; }
+        const Type& operator[](size_t index) const { return DataFirst[index]; }
 
-        Type* begin() { return First; }
-        Type* end() { return First + Count; }
+        Type* begin() { return DataFirst; }
+        Type* end() { return DataFirst + Count; }
 
-        const Type* begin() const { return First; }
-        const Type* end() const { return First + Count; }
+        const Type* begin() const { return DataFirst; }
+        const Type* end() const { return DataFirst + Count; }
+
+        Type* First() { return DataFirst; }
+        Type* Front() { return DataFirst; }
+        Type* Last() { return DataLast; }
+        Type* Back() { return DataLast; }
 
         size_t Size() const { return Count; }
 
-      private:
         Arena* Arena;
-        Type*  First;
-        Type*  Last;
+        Type*  DataFirst;
+        Type*  DataLast;
+        Type*  Data;
         size_t Count;
-        size_t Stride;
-    };
-
-    // TODO : Create my own Vector class based on https://github.com/niklas-ourmachinery/bitsquid-foundation/blob/master/collection_types.h
-    template <typename T>
-    class Vector : public std::vector<T>
-    {
+        size_t Capacity;
+        bool   InternalArena : 1;
+        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

Juliet/include/Core/HAL/Display/Display.h

@@ -2,6 +2,7 @@
 
 #include <Core/Common/CoreTypes.h>
 #include <Core/Common/NonNullPtr.h>
+#include <Core/Common/String.h>
 #include <Juliet.h>
 
 namespace Juliet
@@ -16,4 +17,5 @@ namespace Juliet
     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

Juliet/include/Core/HAL/Filesystem/Filesystem.h

@@ -5,7 +5,16 @@
 namespace Juliet
 {
     // Returns the path to the application directory
-    extern JULIET_API String GetBasePath();
+    [[nodiscard]] extern JULIET_API String GetBasePath();
 
-    extern JULIET_API bool IsAbsolutePath(String path);
+    // 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(String filename);
+
+     [[nodiscard]]extern JULIET_API bool IsAbsolutePath(String path);
 } // namespace Juliet

Juliet/include/Core/HAL/OS/OS.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <Core/Common/CoreTypes.h>
+#include <Graphics/D3D12/D3D12Buffer.h>
 #include <Juliet.h>
 
 namespace Juliet
@@ -31,6 +32,11 @@ namespace Juliet
 
     } // namespace Memory
 
+    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);
 } // namespace Juliet

Juliet/include/Core/HotReload/HotReload.h

@@ -9,6 +9,8 @@ namespace Juliet
 
     struct HotReloadCode
     {
+        Arena* Arena;
+
         String DLLFullPath;
         String LockFullPath;
         String TransientDLLName;
@@ -26,8 +28,7 @@ namespace Juliet
         bool IsValid : 1;
     };
 
-    extern JULIET_API void InitHotReloadCode(HotReloadCode& code, String dllName,
-                                             String transientDllName, String lockFilename);
+    extern JULIET_API void InitHotReloadCode(HotReloadCode& code, String dllName, String transientDllName, String lockFilename);
     extern JULIET_API void ShutdownHotReloadCode(HotReloadCode& code);
 
     extern JULIET_API void LoadCode(HotReloadCode& code);

Juliet/include/Core/ImGui/ImGuiService.h

@@ -3,6 +3,8 @@
 #include <Core/Common/CoreTypes.h>
 #include <Core/Common/NonNullPtr.h>
 
+#ifdef JULIET_ENABLE_IMGUI
+
 struct ImGuiContext;
 
 namespace Juliet
@@ -25,3 +27,5 @@ namespace Juliet
         JULIET_API void RunTests();
     } // namespace ImGuiService
 } // namespace Juliet
+
+#endif // JULIET_ENABLE_IMGUI

Juliet/include/Core/JulietInit.h

@@ -13,12 +13,12 @@ namespace Juliet
         All     = 0xFb
     };
 
-    struct MemoryArena;
+    struct Arena;
 
     struct GameInitParams
     {
-        MemoryArena* GameArena;
-        MemoryArena* ScratchArena;
+        Arena* GameArena;
+        Arena* ScratchArena;
     };
 
     void JulietInit(JulietInit_Flags flags);

Juliet/include/Core/Logging/LogManager.h

@@ -22,6 +22,7 @@ namespace Juliet
     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, ...);

Juliet/include/Core/Logging/LogTypes.h

@@ -4,9 +4,10 @@ namespace Juliet
 {
     enum class LogLevel : uint8
     {
-        Message = 0,
-        Warning = 1,
-        Error   = 2,
+        Debug   = 0,
+        Message = 1,
+        Warning = 2,
+        Error   = 3,
     };
 
     enum class LogCategory : uint8
@@ -15,7 +16,7 @@ namespace Juliet
         Graphics   = 1,
         Networking = 2,
         Engine     = 3,
-        Tool     = 4,
+        Tool       = 4,
         Game       = 5,
     };
 } // namespace Juliet

Juliet/include/Core/Main.h

@@ -9,7 +9,6 @@ extern int JulietMain(int, wchar_t**);
 #define WINAPI __stdcall
 #endif
 
-#if COMPILER_MSVC
 #if UNICODE
 int wmain(int argc, wchar_t** argv)
 {
@@ -21,7 +20,6 @@ int main(int argc, char** argv)
     return Juliet::Bootstrap(JulietMain, argc, argv);
 }
 #endif
-#endif
 
 extern "C" {
 
@@ -39,6 +37,7 @@ int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR szCmdLine, int sw)
     (void)hPrev;
     (void)szCmdLine;
     (void)sw;
+
     return Juliet::Bootstrap(JulietMain, __argc, __wargv);
 }
 }

Juliet/include/Core/Math/Matrix.h

@@ -8,33 +8,99 @@ namespace Juliet
     struct Matrix
     {
         float m[4][4];
+    };
 
-        static Matrix Identity()
-        {
-            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;
+    }
 
-        Matrix operator*(const Matrix& rhs) const
+    [[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] += 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)
+    {
+        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)
     {
@@ -83,4 +149,46 @@ namespace Juliet
         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

Juliet/include/Core/Memory/MemoryArena.h

@@ -6,6 +6,7 @@
 #include <Core/Common/String.h>
 #include <Core/Memory/Utils.h>
 #include <Juliet.h>
+#include <typeinfo> // Added for typeid
 
 namespace Juliet
 {
@@ -13,7 +14,12 @@ namespace Juliet
     constexpr global uint64 g_Arena_Default_Commit_Size  = Kilobytes(64);
     constexpr global uint64 k_ArenaHeaderSize            = 128;
 
-    // Refactor
+    struct ArenaFreeNode;
+
+#if JULIET_DEBUG
+    struct ArenaDebugInfo;
+#endif
+
     struct Arena
     {
         Arena* Previous;
@@ -29,150 +35,69 @@ namespace Juliet
         uint64 Committed;
         uint64 Reserved;
 
-        Arena* FreeLast;
+        Arena* FreeBlockLast;
+
+        ArenaFreeNode* FreeNodes;
+
+        bool AllowRealloc : 1;
+
+        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;)
+        JULIET_DEBUG_ONLY(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;
+
+        // True: All push will be 32 bytes minimum
+        bool AllowRealloc = false;
+
+        // When false, will assert if a new block is reserved.
+        JULIET_DEBUG_ONLY(bool CanReserveMore : 1 = true;)
     };
 
-    [[nodiscard]] Arena* ArenaAllocate(const ArenaParams&          params = {},
-                                       const std::source_location& loc    = std::source_location::current());
-    void                 ArenaRelease(NonNullPtr<Arena> arena);
+    [[nodiscard]] JULIET_API Arena* ArenaAllocate(const ArenaParams& params   JULIET_DEBUG_ONLY(, const char* name),
+                                                  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]] void*  ArenaPush(NonNullPtr<Arena> arena, size_t size, size_t align, bool shouldBeZeroed);
-    void                 ArenaPopTo(NonNullPtr<Arena> arena, size_t position);
-    void                 ArenaPop(NonNullPtr<Arena> arena, size_t amount);
-    void                 ArenaClear(NonNullPtr<Arena> arena);
-    [[nodiscard]] size_t ArenaPos(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_ONLY(, const char* tag));
+    [[nodiscard]] JULIET_API void* ArenaReallocate(NonNullPtr<Arena> arena, void* oldPtr, size_t oldSize, size_t newSize,
+                                                   size_t align, bool shouldBeZeroed JULIET_DEBUG_ONLY(, 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);
 
     template <typename Type>
-    [[nodiscard]] Type* ArenaPushStruct(NonNullPtr<Arena> arena)
+    [[nodiscard]] Type* ArenaPushStruct(NonNullPtr<Arena> arena JULIET_DEBUG_PARAM(const char* tag = nullptr))
     {
-        return static_cast<Type*>(ArenaPush(arena, sizeof(Type) * 1, AlignOf(Type), true));
+        return static_cast<Type*>(
+            ArenaPush(arena, sizeof(Type) * 1, AlignOf(Type), true JULIET_DEBUG_PARAM(tag ? tag : typeid(Type).name())));
     }
 
-    // #define push_array_no_zero_aligned(a, T, c, align) (T *)arena_push((a), sizeof(T)*(c), (align), (0))
-    // #define push_array_aligned(a, T, c, align) (T *)arena_push((a), sizeof(T)*(c), (align), (1))
-    // #define push_array_no_zero(a, T, c) push_array_no_zero_aligned(a, T, c, Max(8, AlignOf(T)))
-    // #define push_array(a, T, c) push_array_aligned(a, T, c, Max(8, AlignOf(T)))
-
     template <typename Type>
-    [[nodiscard]] Type* ArenaPushArray(NonNullPtr<Arena> arena, size_t count)
+    [[nodiscard]] Type* ArenaPushArray(NonNullPtr<Arena> arena, size_t count JULIET_DEBUG_PARAM(const char* tag = nullptr))
     {
-        return static_cast<Type*>(ArenaPush(arena, sizeof(Type) * count, Max(8ull, AlignOf(Type)), true));
+        return static_cast<Type*>(ArenaPush(arena, sizeof(Type) * count, Max(8ull, AlignOf(Type)),
+                                            true JULIET_DEBUG_PARAM(tag ? tag : typeid(Type).name())));
     }
 
-    // --- Paged Memory Architecture ---
-    struct ArenaAllocation
-    {
-        size_t           Offset;
-        size_t           Size;
-        String           Tag;
-        ArenaAllocation* Next;
-    };
-
-    struct MemoryBlock
-    {
-        static constexpr uint32 kMagic = 0xAA55AA55;
-        uint32                  Magic;
-        MemoryBlock*            Next;      // Next block in the chain (Arena) or FreeList (Pool)
-        size_t                  TotalSize; // Total size of this block (including header)
-        size_t                  Used;      // Offset relative to the start of Data
-
-#if JULIET_DEBUG
-        ArenaAllocation* FirstAllocation = nullptr;
-        uint64           Pad; // Ensure 16-byte alignment (Size 40 -> 48)
-#endif
-
-        // Data follows immediately.
-        // We use a helper to access it to avoid C++ flexible array warning issues if strict
-        uint8*       GetData() { return reinterpret_cast<uint8*>(this + 1); }
-        const uint8* GetData() const { return reinterpret_cast<const uint8*>(this + 1); }
-    };
-
-    struct MemoryPool
-    {
-        void*        BaseAddress = nullptr;
-        size_t       TotalSize   = 0;
-        MemoryBlock* FreeList    = nullptr;
-
-        [[nodiscard]] MemoryBlock* AllocateBlock(size_t minCapacity);
-        void                       FreeBlock(MemoryBlock* block);
-    };
-
-    struct MemoryArena
-    {
-        MemoryPool*  BackingPool;
-        MemoryBlock* CurrentBlock;
-        MemoryBlock* FirstBlock;
-        // Marker behavior is now tricky with pages.
-        // Simple Marker = { Block*, Offset }
-    };
-
-    struct ArenaMarker
-    {
-        MemoryBlock* Block;
-        size_t       Offset;
-    };
-
-    JULIET_API void  MemoryArenaCreate(MemoryArena* arena, MemoryPool* pool);
-    JULIET_API void* ArenaPush(MemoryArena* arena, size_t size, size_t alignment, String tag);
-    JULIET_API void* ArenaRealloc(MemoryArena* arena, void* oldPtr, size_t oldSize, size_t newSize, size_t alignment, String tag);
-    JULIET_API bool        ArenaPop(MemoryArena* arena, void* ptr, size_t size);
-    JULIET_API void        ArenaReset(MemoryArena* arena);
-    JULIET_API ArenaMarker ArenaGetMarker(MemoryArena* arena);
-    JULIET_API void        ArenaResetToMarker(MemoryArena* arena, ArenaMarker marker);
-
-    // --- Global Arenas & Management ---
-
-    // Returns a global arena that resets every frame.
-    JULIET_API MemoryArena* GetScratchArena();
-
-    // Persistent game arena.
-    JULIET_API MemoryArena* GetGameArena();
-
-    // Internal engine function to reset the scratch arena.
-    JULIET_API void ScratchArenaReset();
-
-    // Internal engine function to initialize memory arenas.
-    void MemoryArenasInit();
-
-    // Internal engine function to shutdown memory arenas.
-    void MemoryArenasShutdown();
-
-    template <typename T>
-    inline T* ArenaPushType(MemoryArena* arena, String tag)
-    {
-        T* result = static_cast<T*>(ArenaPush(arena, sizeof(T), alignof(T), tag));
-
-        if (result)
-        {
-            MemSet(result, 0, sizeof(T));
-        }
-        return result;
-    }
-
-    template <typename T>
-    inline T* ArenaPushArray(MemoryArena* arena, size_t count, String tag)
-    {
-        T* result = static_cast<T*>(ArenaPush(arena, sizeof(T) * count, alignof(T), tag));
-
-        if (result)
-        {
-            MemSet(result, 0, sizeof(T) * count);
-        }
-        return result;
-    }
-
-    template <typename T>
-    inline T* ArenaRealloc(MemoryArena* arena, T* oldPtr, size_t oldCount, size_t newCount, String tag)
-    {
-        return static_cast<T*>(Juliet::ArenaRealloc(arena, static_cast<void*>(oldPtr), sizeof(T) * oldCount,
-                                                    sizeof(T) * newCount, alignof(T), tag));
-    }
+    TempArena ArenaTempBegin(NonNullPtr<Arena> arena);
+    void      ArenaTempEnd(TempArena temp);
 } // namespace Juliet

Juliet/include/Core/Memory/MemoryArenaDebug.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <Juliet.h>
+#include <Core/Common/CoreTypes.h>
+#include <Core/Common/String.h>
+#include <Core/Common/NonNullPtr.h>
+
+#if JULIET_DEBUG
+
+namespace Juliet
+{
+    struct Arena;
+    struct MemoryBlock;
+
+    // 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;
+    };
+
+    // 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);
+
+} // namespace Juliet
+
+#endif

Juliet/include/Core/Networking/NetworkPacket.h

@@ -5,6 +5,12 @@
 
 namespace Juliet
 {
+    // TODO Use VectorArena
+    template <typename T>
+    class Vector : public std::vector<T>
+    {
+    };
+
     class NetworkPacket
     {
       public:

Juliet/include/Engine/Debug/MemoryDebugger.h

@@ -1,9 +1,12 @@
 #pragma once
 
-#include <Core/Memory/MemoryArena.h>
 #include <Juliet.h>
 
+#if JULIET_DEBUG
+
 namespace Juliet::Debug
 {
     JULIET_API void DebugDrawMemoryArena();
 } // namespace Juliet::Debug
+
+#endif

Juliet/include/Engine/Engine.h

@@ -8,7 +8,8 @@ namespace Juliet
 
     struct Engine
     {
-        IApplication* Application = nullptr;
+        IApplication* Application   = nullptr;
+        Arena*        PlatformArena = nullptr;
     };
 
     void InitializeEngine(JulietInit_Flags flags);

Juliet/include/Graphics/Graphics.h

@@ -134,13 +134,11 @@ namespace Juliet
     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);
-
+    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 SetPushConstants(NonNullPtr<CommandList> commandList, ShaderStage stage,
                                             uint32 rootParameterIndex, uint32 numConstants, const void* constants);
@@ -166,6 +164,8 @@ namespace Juliet
     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,

Juliet/include/Graphics/GraphicsBuffer.h

@@ -8,7 +8,6 @@ namespace Juliet
         IndexBuffer      = 1 << 0,
         ConstantBuffer   = 1 << 1,
         StructuredBuffer = 1 << 2,
-        VertexBuffer     = 1 << 3,
     };
 
     enum class TransferBufferUsage : uint8
@@ -20,7 +19,9 @@ namespace Juliet
     struct BufferCreateInfo
     {
         size_t      Size;
+        size_t      Stride;
         BufferUsage Usage;
+        bool        IsDynamic;
     };
 
     struct TransferBufferCreateInfo

Juliet/include/Graphics/Lighting.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <Juliet.h>
+#include <Core/Math/Vector.h>
+
+namespace Juliet
+{
+    struct PointLight
+    {
+        Vector3 Position;
+        float   Radius;
+        Vector3 Color;
+        float   Intensity;
+    };
+} // namespace Juliet

Juliet/include/Graphics/Mesh.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <Core/Common/CoreTypes.h>
+#include <Core/Common/NonNullPtr.h>
+#include <Core/Math/Matrix.h>
+#include <Juliet.h>
+
+namespace Juliet
+{
+    struct Arena;
+    struct Vertex;
+
+    struct Mesh
+    {
+        size_t VertexCount;
+        size_t IndexCount;
+
+        index_t VertexOffset;
+        index_t IndexOffset;
+
+        Matrix Transform = MatrixIdentity();
+    };
+} // namespace Juliet

Juliet/include/Graphics/MeshRenderer.h

@@ -0,0 +1,75 @@
+#pragma once
+
+#include <Core/Container/Vector.h>
+#include <Core/Math/Matrix.h>
+#include <Graphics/Lighting.h>
+#include <Graphics/PushConstants.h>
+#include <Graphics/VertexData.h>
+#include <Juliet.h>
+
+namespace Juliet
+{
+    struct GraphicsTransferBuffer;
+    struct RenderPass;
+    struct CommandList;
+    struct GraphicsBuffer;
+    struct Window;
+    struct GraphicsPipeline;
+    struct GraphicsDevice;
+    struct Mesh;
+
+    using MeshID  = index_t;
+    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;
+
+    struct MeshRenderer
+    {
+        // Note we prevent realloc for now.
+        VectorArena<Mesh, kDefaultMeshNumber, false>    Meshes;
+        VectorArena<Vertex, kDefaultVertexCount, false> Vertices;
+        VectorArena<Index, kDefaultIndexCount, false>   Indices;
+        VectorArena<PointLight, kDefaultLightCount, false> PointLights;
+
+        GraphicsBuffer*         VertexBuffer;
+        GraphicsBuffer*         IndexBuffer;
+        GraphicsTransferBuffer* StreamCopyBuffer;
+        GraphicsTransferBuffer* LoadCopyBuffer;
+
+        GraphicsBuffer*         LightsBuffer;
+        PointLight*             MappedLights;
+
+        GraphicsDevice*   Device;
+        GraphicsPipeline* Pipeline;
+    };
+
+    JULIET_API void InitializeMeshRenderer(NonNullPtr<Arena> arena);
+    [[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<RenderPass> pass, NonNullPtr<CommandList> cmdList, PushData& pushData);
+
+    // 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();
+
+    // Utils
+    [[nodiscard]] JULIET_API MeshID AddCube();
+    [[nodiscard]] JULIET_API MeshID AddQuad();
+    JULIET_API void                 SetMeshTransform(MeshID id, const Matrix& transform);
+
+#if ALLOW_SHADER_HOT_RELOAD
+    JULIET_API void ReloadMeshRendererShaders();
+#endif
+
+} // namespace Juliet

Juliet/include/Graphics/PushConstants.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <Core/Math/Matrix.h>
+#include <Core/Math/Vector.h>
+#include <Juliet.h>
+
+namespace Juliet
+{
+    struct PushData
+    {
+        Matrix ViewProjection;
+        uint32 MeshIndex;
+        uint32 TransformsBufferIndex;
+        uint32 BufferIndex;
+        uint32 TextureIndex;
+        uint32 VertexOffset;
+        uint32 Padding;
+        float  Scale[2];
+        float  Translate[2];
+        float  Padding2[2];
+        
+        Vector3 GlobalLightDirection;
+        float   GlobalLightPad;
+        Vector3 GlobalLightColor;
+        float   GlobalAmbientIntensity;
+
+        uint32  LightBufferIndex;
+        uint32  ActiveLightCount;
+    };
+} // namespace Juliet

Juliet/include/Graphics/SkyboxRenderer.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <Core/Math/Matrix.h>
+#include <Juliet.h>
+
+namespace Juliet
+{
+    struct RenderPass;
+    struct CommandList;
+    struct Window;
+    struct GraphicsPipeline;
+    struct GraphicsDevice;
+
+    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<RenderPass> pass, NonNullPtr<CommandList> cmdList, const Matrix& viewProjection);
+
+#if ALLOW_SHADER_HOT_RELOAD
+    JULIET_API void ReloadSkyboxShaders();
+#endif
+
+} // namespace Juliet

Juliet/include/Graphics/VertexData.h

@@ -0,0 +1,13 @@
+#pragma once
+
+namespace Juliet
+{
+    struct Vertex
+    {
+        float Position[3];
+        float Normal[3];
+        float Color[4];
+    };
+
+    using Index = uint16;
+} // namespace Juliet

Juliet/include/Juliet.h

@@ -21,8 +21,14 @@
 
 #ifdef DEBUG
 #define JULIET_DEBUG 1
+#define JULIET_DEBUG_ONLY(...) __VA_ARGS__
+#define JULIET_DEBUG_PARAM_FIRST(...) __VA_ARGS__
+#define JULIET_DEBUG_PARAM(...) , __VA_ARGS__
 #else
 #define JULIET_DEBUG 0
+#define JULIET_DEBUG_ONLY(...)
+#define JULIET_DEBUG_PARAM_FIRST(...)
+#define JULIET_DEBUG_PARAM(...)
 #endif
 
 // Manual override to disable ImGui

Juliet/src/Core/Common/String.cpp

@@ -493,7 +493,7 @@ namespace Juliet
     {
         String result;
         result.Size = str.Size;
-        result.Data = ArenaPushArray<char>(arena, str.Size + 1);
+        result.Data = static_cast<char*>(ArenaPush(arena, str.Size + 1, alignof(char), true JULIET_DEBUG_ONLY(, "String")));
         MemCopy(result.Data, str.Data, str.Size);
         result.Data[result.Size] = 0;
         return result;

Juliet/src/Core/HAL/Display/Display.cpp

@@ -2,7 +2,6 @@
 #include <Core/HAL/Display/Display_Private.h>
 #include <Core/HAL/Display/DisplayDevice.h>
 #include <Core/Memory/Allocator.h>
-#include <Core/Memory/EngineArena.h>
 #include <Core/Memory/MemoryArena.h>
 
 namespace Juliet
@@ -10,7 +9,9 @@ namespace Juliet
     namespace
     {
         DisplayDevice* g_CurrentDisplayDevice = nullptr;
-    }
+
+        void DestroyPlatformWindow(index_t windowIndex);
+    } // namespace
 
     namespace Internal::Display
     {
@@ -22,7 +23,7 @@ namespace Juliet
     {
         Assert(!g_CurrentDisplayDevice);
 
-        Arena* arena = ArenaAllocate();
+        Arena* arena = ArenaAllocate({} JULIET_DEBUG_ONLY(, "Display System"));
 
         DisplayDevice*        candidateDevice  = nullptr;
         DisplayDeviceFactory* candidateFactory = nullptr;
@@ -60,9 +61,9 @@ namespace Juliet
         }
 
         // Destroy all Windows that are still alive
-        if (g_CurrentDisplayDevice->MainWindow)
+        for (index_t idx = g_CurrentDisplayDevice->Windows.Size(); idx-- > 0;)
         {
-            DestroyPlatformWindow(g_CurrentDisplayDevice->MainWindow);
+            DestroyPlatformWindow(idx);
         }
 
         g_CurrentDisplayDevice->Shutdown(g_CurrentDisplayDevice);
@@ -78,44 +79,59 @@ namespace Juliet
     {
         Assert(g_CurrentDisplayDevice->CreatePlatformWindow);
 
-        auto* arena = g_CurrentDisplayDevice->Arena;
-        Assert(arena);
+        Window window = {};
+        window.Arena  = ArenaAllocate({} JULIET_DEBUG_ONLY(, "Window"));
+        window.Width  = width;
+        window.Height = height;
 
-        auto* window = ArenaPushStruct<Window>(arena);
-        Assert(window);
+        window.Title = StringCopy(window.Arena, WrapString(title));
 
-        window->Width  = width;
-        window->Height = height;
+        g_CurrentDisplayDevice->Windows.PushBack(window);
 
-        window->Title = StringCopy(arena, WrapString(title));
-
-        g_CurrentDisplayDevice->MainWindow = window;
-        if (!g_CurrentDisplayDevice->CreatePlatformWindow(g_CurrentDisplayDevice, window))
+        auto* pWindow = g_CurrentDisplayDevice->Windows.Last();
+        if (!g_CurrentDisplayDevice->CreatePlatformWindow(g_CurrentDisplayDevice, pWindow))
         {
-            // Note: We don't "free" from arena easily, but since this is catastrophic
-            // and persistent, we just leak the small amount of arena space or handle it if we had a marker.
+            ArenaRelease(window.Arena);
             return nullptr;
         }
 
         // TODO : make SHOW optional on creation with a flag
-        g_CurrentDisplayDevice->ShowWindow(g_CurrentDisplayDevice, window);
+        g_CurrentDisplayDevice->ShowWindow(g_CurrentDisplayDevice, pWindow);
 
-        return window;
+        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)
     {
-        Assert(g_CurrentDisplayDevice->MainWindow == window.Get());
-
-        HideWindow(window);
-
-        // TODO: Pop from arena.
-        window->Title.Data = nullptr;
-        window->Title.Size = 0;
-
-        g_CurrentDisplayDevice->DestroyPlatformWindow(g_CurrentDisplayDevice, window);
-
-        g_CurrentDisplayDevice->MainWindow = nullptr;
+        // 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)
@@ -133,6 +149,11 @@ namespace Juliet
         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()
     {

Juliet/src/Core/HAL/Display/DisplayDevice.h

@@ -25,13 +25,12 @@ namespace Juliet
         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);
 
-        // TODO : Use vector
-        VectorArena<Window*> Windows;
-        Window*              MainWindow = nullptr;
+        VectorArena<Window> Windows;
     };
 
     struct DisplayDeviceFactory

Juliet/src/Core/HAL/Display/Win32/Win32DisplayDevice.cpp

@@ -1,9 +1,6 @@
 #include <Core/HAL/Display/DisplayDevice.h>
 #include <Core/HAL/Display/Win32/Win32DisplayEvent.h>
 #include <Core/HAL/Display/Win32/Win32Window.h>
-#include <Core/Memory/Allocator.h>
-#include <Core/Memory/EngineArena.h>
-#include <Core/Memory/Utils.h>
 
 namespace Juliet::Win32
 {
@@ -14,7 +11,10 @@ namespace Juliet::Win32
             return true;
         }
         void Shutdown(NonNullPtr<DisplayDevice> /*self*/) {}
-        void Free(NonNullPtr<DisplayDevice> /*self*/) {}
+        void Free(NonNullPtr<DisplayDevice> device)
+        {
+            device->Windows.Destroy();
+        }
 
         DisplayDevice* CreateDevice(Arena* arena)
         {
@@ -33,9 +33,12 @@ namespace Juliet::Win32
             device->DestroyPlatformWindow = DestroyPlatformWindow;
             device->ShowWindow            = ShowWindow;
             device->HideWindow            = HideWindow;
+            device->SetWindowTitle        = SetWindowTitle;
 
             device->PumpEvents = PumpEvents;
 
+            device->Windows.Create(arena JULIET_DEBUG_PARAM("Display Windows"));
+
             return device;
         }
     } // namespace

Juliet/src/Core/HAL/Display/Win32/Win32DisplayEvent.cpp

@@ -14,9 +14,10 @@
 // For GET_X_LPARAM, GET_Y_LPARAM.
 #include <windowsx.h>
 
-#include <imgui.h> // Need For IMGUI_IMPL_API 
+#ifdef JULIET_ENABLE_IMGUI
+#include <imgui.h> // Need For IMGUI_IMPL_API
 extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
-
+#endif
 
 namespace Juliet::Win32
 {
@@ -29,17 +30,12 @@ namespace Juliet::Win32
         {
             if (auto* displayDevice = GetDisplayDevice())
             {
-                auto* window = displayDevice->MainWindow;
-                // TODO : use a vector
-                // for (Window* window : displayDevice->MainWindow)
+                for (auto& window : displayDevice->Windows)
                 {
-                    if (window)
+                    auto state = static_cast<Window32State*>(window.State);
+                    if (state && state->Handle == handle)
                     {
-                        auto state = static_cast<Window32State*>(window->State);
-                        if (state && state->Handle == handle)
-                        {
-                            return state;
-                        }
+                        return state;
                     }
                 }
             }
@@ -151,14 +147,15 @@ namespace Juliet::Win32
 
     LRESULT CALLBACK Win32MainWindowCallback(HWND handle, UINT message, WPARAM wParam, LPARAM lParam)
     {
+#ifdef JULIET_ENABLE_IMGUI
         if (ImGui_ImplWin32_WndProcHandler(handle, message, wParam, lParam))
         {
             return true;
         }
+#endif
 
         LRESULT returnCode = -1;
 
-
         // Wait until the window state is created before doing anything
         auto* windowState = GetWindowStateFromHandle(handle);
         if (!windowState)

Juliet/src/Core/HAL/Display/Win32/Win32Window.cpp

@@ -2,8 +2,7 @@
 #include <Core/HAL/Display/Win32/Win32Window.h>
 #include <Core/HAL/Display/Window.h>
 #include <Core/Memory/Allocator.h>
-#include <Core/Memory/EngineArena.h>
-#include <Core/Memory/Utils.h>
+#include <Core/Memory/MemoryArena.h>
 
 namespace Juliet::Win32
 {
@@ -14,7 +13,7 @@ namespace Juliet::Win32
 
         bool SetupWindowState(NonNullPtr<DisplayDevice> /*self*/, NonNullPtr<Window> window, HWND handle)
         {
-            auto state = ArenaPushType<Window32State>(GetEngineArena(), ConstString("Window32State"));
+            auto* state = ArenaPushStruct<Window32State>(window->Arena);
 
             window->State = state;
             state->Handle = handle;
@@ -23,18 +22,15 @@ namespace Juliet::Win32
 
             state->IsMouseTracked = false;
 
-            // TODO Use SetProp to associate data to the window handle. Could be used to fetch it from the WinProc
-
             return true;
         }
 
         void CleanUpWindowState(NonNullPtr<DisplayDevice> /*self*/, NonNullPtr<Window> window)
         {
-            if (auto* state = static_cast<Window32State*>(window->State))
-            {
-                ReleaseDC(state->Handle, state->HDC);
-                DestroyWindow(state->Handle);
-            }
+            auto* state = static_cast<Window32State*>(window->State);
+            Assert(state);
+            ReleaseDC(state->Handle, state->HDC);
+            DestroyWindow(state->Handle);
             window->State = nullptr;
         }
     } // namespace
@@ -96,4 +92,13 @@ namespace Juliet::Win32
         auto& win32State = static_cast<Window32State&>(*window->State);
         ::ShowWindow(win32State.Handle, SW_HIDE);
     }
+
+    void SetWindowTitle(NonNullPtr<DisplayDevice> /*self*/, NonNullPtr<Window> window, String title)
+    {
+        Assert(window);
+        Assert(window->State);
+
+        auto& win32State = static_cast<Window32State&>(*window->State);
+        SetWindowTextA(win32State.Handle, CStr(title));
+    }
 } // namespace Juliet::Win32

Juliet/src/Core/HAL/Display/Win32/Win32Window.h

@@ -25,4 +25,5 @@ namespace Juliet::Win32
     extern void DestroyPlatformWindow(NonNullPtr<DisplayDevice> self, NonNullPtr<Window> window);
     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

Juliet/src/Core/HAL/Display/Window.h

@@ -15,9 +15,10 @@ namespace Juliet
     {
         WindowID     ID;
         WindowState* State;
+        Arena*       Arena;
 
-        int32 Width;
-        int32 Height;
+        int32  Width;
+        int32  Height;
         String Title;
     };
 } // namespace Juliet

Juliet/src/Core/HAL/Filesystem/Filesystem.cpp

@@ -1,14 +1,29 @@
+#include <Core/Common/CoreTypes.h>
+#include <Core/Common/CoreUtils.h>
 #include <Core/Common/String.h>
 #include <Core/HAL/Filesystem/Filesystem.h>
 #include <Core/HAL/Filesystem/Filesystem_Platform.h>
 #include <Core/HAL/Filesystem/Filesystem_Private.h>
+#include <Core/HAL/Win32.h>
+#include <Core/Logging/LogManager.h>
+#include <Core/Logging/LogTypes.h>
 #include <Core/Memory/Allocator.h>
 
+#include <cstdio>
+
 namespace Juliet
 {
     namespace
     {
-        String CachedBasePath = {};
+        String CachedBasePath      = {};
+        String CachedAssetBasePath = {};
+
+        bool DirectoryExists(const char* path)
+        {
+            Assert(path);
+            DWORD attributes = GetFileAttributesA(path);
+            return (attributes != INVALID_FILE_ATTRIBUTES) && (attributes & FILE_ATTRIBUTE_DIRECTORY);
+        }
     }
 
     String GetBasePath()
@@ -20,6 +35,27 @@ namespace Juliet
         return CachedBasePath;
     }
 
+    String GetAssetBasePath()
+    {
+        return CachedAssetBasePath;
+    }
+
+    [[nodiscard]] String GetAssetPath(String filename)
+    {
+        Assert(IsValid(CachedAssetBasePath));
+        Assert(IsValid(filename));
+
+        size_t totalSize = CachedAssetBasePath.Size + filename.Size + 1;
+        auto*  buffer    = static_cast<char*>(Calloc(totalSize, sizeof(char)));
+        if (!buffer)
+        {
+            return {};
+        }
+
+        snprintf(buffer, totalSize, "%s%s", CStr(CachedAssetBasePath), CStr(filename));
+        return { buffer, totalSize - 1 };
+    }
+
     bool IsAbsolutePath(String path)
     {
         if (!IsValid(path))
@@ -29,7 +65,40 @@ namespace Juliet
         return Platform::IsAbsolutePath(path);
     }
 
-    void InitFilesystem() {}
+    void InitFilesystem()
+    {
+        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];
+            snprintf(probePath, sizeof(probePath), "%s%s", CStr(basePath), candidate);
+
+            if (DirectoryExists(probePath))
+            {
+                size_t len    = strlen(probePath);
+                auto*  buffer = static_cast<char*>(Calloc(len + 1, sizeof(char)));
+                if (buffer)
+                {
+                    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()
     {
@@ -38,5 +107,10 @@ namespace Juliet
             CachedBasePath.Size = 0;
             SafeFree(CachedBasePath.Data);
         }
+        if (IsValid(CachedAssetBasePath))
+        {
+            CachedAssetBasePath.Size = 0;
+            SafeFree(CachedAssetBasePath.Data);
+        }
     }
 } // namespace Juliet

Juliet/src/Core/HAL/Filesystem/Win32/Win32Filesystem.cpp

@@ -58,7 +58,7 @@ namespace Juliet::Platform
 
     bool IsAbsolutePath(String path)
     {
-        if (path.Data || path.Size == 0)
+        if (!path.Data || path.Size == 0)
         {
             return false;
         }

Juliet/src/Core/HAL/OS/OS.cpp

@@ -21,6 +21,14 @@ namespace Juliet
         }
     } // namespace Memory
 
+    namespace Debug
+    {
+        bool IsDebuggerPresent()
+        {
+            return Internal::IsDebuggerPresent();
+        }
+    } // namespace Debug
+
     int Bootstrap(EntryPointFunc entryPointFunc, int argc, wchar_t** argv)
     {
         return Internal::OS_Main(entryPointFunc, argc, argv);

Juliet/src/Core/HAL/OS/OS_Private.h

@@ -2,16 +2,17 @@
 
 namespace Juliet
 {
-    namespace Memory
+    namespace Memory::Internal
     {
-        namespace Internal
-        {
-            Byte* OS_Reserve(size_t size);
-            bool  OS_Commit(Byte* ptr, size_t size);
-            void  OS_Release(Byte* ptr, size_t size);
-        } // namespace Internal
-    } // namespace Memory
+        Byte* OS_Reserve(size_t size);
+        bool  OS_Commit(Byte* ptr, size_t size);
+        void  OS_Release(Byte* ptr, size_t size);
+    } // namespace Memory::Internal
 
+    namespace Debug::Internal
+    {
+        bool IsDebuggerPresent();
+    } // namespace Debug::Internal
     namespace Internal
     {
         int OS_Main(EntryPointFunc entryPointFunc, int argc, wchar_t** argv);

Juliet/src/Core/HAL/OS/Win32/Win32OS.cpp

@@ -3,6 +3,8 @@
 #include <Core/HAL/OS/OS.h>
 #include <Core/HAL/OS/OS_Private.h>
 #include <Core/HAL/Win32.h>
+#include <Core/Logging/LogManager.h>
+#include <Core/Logging/LogTypes.h>
 
 namespace Juliet
 {
@@ -15,7 +17,7 @@ namespace Juliet
     {
         Byte* OS_Reserve(size_t size)
         {
-            auto result = static_cast<Byte*>(VirtualAlloc(nullptr, size, MEM_RESERVE, PAGE_READWRITE));
+            auto* result = static_cast<Byte*>(VirtualAlloc(nullptr, size, MEM_RESERVE, PAGE_READWRITE));
             return result;
         }
 
@@ -25,8 +27,12 @@ namespace Juliet
 
             Assert(size <= static_cast<size_t>(MaxValueOf<DWORD>()));
 
-            w32_rio_functions.RIODeregisterBuffer(
-                w32_rio_functions.RIORegisterBuffer(reinterpret_cast<PCHAR>(ptr), static_cast<DWORD>(size)));
+            if (w32_rio_functions.RIORegisterBuffer != nullptr && w32_rio_functions.RIODeregisterBuffer != nullptr)
+            {
+                w32_rio_functions.RIODeregisterBuffer(
+                    w32_rio_functions.RIORegisterBuffer(reinterpret_cast<PCHAR>(ptr), static_cast<DWORD>(size)));
+            }
+
             return result;
         }
 
@@ -39,6 +45,14 @@ namespace Juliet
         }
     } // namespace Memory::Internal
 
+    namespace Debug::Internal
+    {
+        bool IsDebuggerPresent()
+        {
+            return ::IsDebuggerPresent();
+        }
+    } // namespace Debug::Internal
+
     namespace
     {
         // Used to handle a crash/exception
@@ -54,8 +68,6 @@ namespace Juliet
     {
         int OS_Main(EntryPointFunc entryPointFunc, int argc, wchar_t** argv)
         {
-            (void)argc;
-            (void)argv;
             SetUnhandledExceptionFilter(&ExceptionFilter);
 
             // Allow only one instance to be launched.
@@ -74,11 +86,12 @@ namespace Juliet
                 DWORD  rio_byte = 0;
                 SOCKET Sock     = socket(AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP);
                 WSAIoctl(Sock, SIO_GET_MULTIPLE_EXTENSION_FUNCTION_POINTER, &guid, sizeof(guid),
-                         (void**)&w32_rio_functions, sizeof(w32_rio_functions), &rio_byte, nullptr, nullptr);
+                         reinterpret_cast<void**>(&w32_rio_functions), sizeof(w32_rio_functions), &rio_byte, nullptr, nullptr);
                 closesocket(Sock);
             }
 
-            return entryPointFunc(argc, argv);
+            int result = entryPointFunc(argc, argv);
+            return result;
         }
     } // namespace Internal
 } // namespace Juliet

Juliet/src/Core/HotReload/HotReload.cpp

@@ -2,8 +2,6 @@
 #include <Core/HotReload/HotReload.h>
 #include <Core/Logging/LogManager.h>
 #include <Core/Logging/LogTypes.h>
-#include <Core/Memory/Allocator.h>
-#include <Core/Memory/EngineArena.h>
 #include <Core/Memory/MemoryArena.h>
 #include <Core/Thread/Thread.h>
 
@@ -13,6 +11,8 @@ namespace Juliet
 {
     void InitHotReloadCode(HotReloadCode& code, String dllName, String transientDllName, String lockFilename)
     {
+        code.Arena = ArenaAllocate({} JULIET_DEBUG_ONLY(, "Hot Reload"));
+
         // Get the app base path and build the dll path from there.
         String basePath       = GetBasePath();
         size_t basePathLength = StringLength(basePath);
@@ -24,7 +24,8 @@ namespace Juliet
         // TODO: Add path composition into filesystem + string format + string builder
         const size_t dllFullPathLength =
             basePathLength + StringLength(dllName) + 1; // Need +1 because snprintf needs 0 terminated strings
-        code.DLLFullPath.Data = ArenaPushArray<char>(GetEngineArena(), dllFullPathLength, ConstString("DLLFullPath"));
+
+        code.DLLFullPath.Data = static_cast<char*>(ArenaPush(code.Arena, dllFullPathLength, alignof(char), true JULIET_DEBUG_ONLY(, "DLL Path")));
         int writtenSize = snprintf(CStr(code.DLLFullPath), dllFullPathLength, "%s%s", CStr(basePath), CStr(dllName));
         if (writtenSize < static_cast<int>(dllFullPathLength) - 1)
         {
@@ -37,7 +38,7 @@ namespace Juliet
         // Lock filename path
         const size_t lockPathLength =
             basePathLength + StringLength(lockFilename) + 1; // Need +1 because snprintf needs 0 terminated strings
-        code.LockFullPath.Data = ArenaPushArray<char>(GetEngineArena(), lockPathLength, ConstString("LockFullPath"));
+        code.LockFullPath.Data = static_cast<char*>(ArenaPush(code.Arena, lockPathLength, alignof(char), true JULIET_DEBUG_ONLY(, "Lock File Path")));
         writtenSize = snprintf(CStr(code.LockFullPath), lockPathLength, "%s%s", CStr(basePath), CStr(lockFilename));
         if (writtenSize < static_cast<int>(lockPathLength) - 1)
         {
@@ -59,6 +60,8 @@ namespace Juliet
         // Arena memory persists until engine shutdown
         code.LockFullPath.Size = 0;
         // Arena memory persists until engine shutdown
+
+        ArenaRelease(code.Arena);
     }
 
     void ReloadCode(HotReloadCode& code)

Juliet/src/Core/HotReload/Win32/Win32HotReload.cpp

@@ -56,7 +56,8 @@ namespace Juliet
                 basePathLength + StringLength(code.TransientDLLName) + /* _ */ 1 + kTempDLLBufferSizeForID + 1 /* \0 */;
 
             // Allocate from Scratch Arena (transient)
-            auto tempDllPath = ArenaPushArray<char>(GetScratchArena(), tempDllMaxBufferSize, ConstString("tempDllPath"));
+            TempArena temp        = ArenaTempBegin(code.Arena);
+            auto      tempDllPath = ArenaPushArray<char>(temp.Arena, tempDllMaxBufferSize);
 
             for (uint32 attempt = 0; attempt < kMaxAttempts; ++attempt)
             {
@@ -96,6 +97,7 @@ namespace Juliet
                     break;
                 }
             }
+            ArenaTempEnd(temp);
 
             code.Dll = LoadDynamicLibrary(tempDllPath);
             if (code.Dll)

Juliet/src/Core/ImGui/ImGuiService.cpp

@@ -3,13 +3,13 @@
 #include <Core/ImGui/ImGuiService.h>
 #include <Core/ImGui/ImGuiTests.h>
 #include <Core/Logging/LogManager.h>
-
 #include <Core/Memory/MemoryArena.h>
 
+#ifdef JULIET_ENABLE_IMGUI
+
 #include <backends/imgui_impl_win32.h>
 #include <imgui.h>
 
-#include <Core/Memory/EngineArena.h>
 #include <cstdio>
 
 // Forward declare implementation functions from backends
@@ -24,34 +24,16 @@ namespace Juliet::ImGuiService
 
         // Dedicated Paged Arena for ImGui
         // Sharing the same underlying Engine Pool for blocks, but separate Arena chain.
-        MemoryArena g_ImGuiArena;
+        Arena* g_ImGuiArena = {};
 
         void* ImGuiAllocWrapper(size_t size, void* /*user_data*/)
         {
-            // Store size in header to allow Pop
-            // Align total size to 16 to avoid padding issues with ArenaPop LIFO check
-            size_t actualSize = size + 16;
-            actualSize        = (actualSize + 15) & ~static_cast<size_t>(15);
-
-            // We do save the size when we push so we can pop exactly the size.
-            if (void* ptr = ArenaPush(&g_ImGuiArena, actualSize, 16, ConstString("ImGui")))
-            {
-                // Write size at start
-                *static_cast<size_t*>(ptr) = actualSize;
-                return static_cast<uint8*>(ptr) + 16;
-            }
-            return nullptr;
+            return ArenaPush(g_ImGuiArena, size, 8, false JULIET_DEBUG_ONLY(, "ImGuiAlloc"));
         }
 
-        void ImGuiFreeWrapper(void* ptr, void* /*user_data*/)
+        void ImGuiFreeWrapper(void* /*ptr*/, void* /*user_data*/)
         {
-            Assert(ptr);
-
-            uint8* originalPtr = static_cast<uint8*>(ptr) - 16;
-            size_t actualSize  = *reinterpret_cast<size_t*>(originalPtr);
-
-            // Attempt LIFO Pop
-            ArenaPop(&g_ImGuiArena, originalPtr, actualSize);
+            // TODO : Free list of imgui elements.
         }
     } // namespace
 
@@ -60,7 +42,7 @@ namespace Juliet::ImGuiService
         Assert(!g_Initialized);
 
         // Initialize ImGui Arena using Engine Pool
-        MemoryArenaCreate(&g_ImGuiArena, GetEngineArena()->BackingPool);
+        g_ImGuiArena = ArenaAllocate({} JULIET_DEBUG_ONLY(, "ImGui"));
 
         // Setup Allocator
         ImGui::SetAllocatorFunctions(ImGuiAllocWrapper, ImGuiFreeWrapper, nullptr);
@@ -121,3 +103,5 @@ namespace Juliet::ImGuiService
         Juliet::UnitTest::TestImGui();
     }
 } // namespace Juliet::ImGuiService
+
+#endif // JULIET_ENABLE_IMGUI

Juliet/src/Core/ImGui/ImGuiTests.cpp

@@ -10,6 +10,7 @@ namespace Juliet::UnitTest
 {
     void TestImGui()
     {
+#ifdef JULIET_ENABLE_IMGUI
         ImGuiContext* ctx = ImGuiService::GetContext();
 
         if (ImGui::GetCurrentContext() != ctx)
@@ -68,5 +69,6 @@ namespace Juliet::UnitTest
         (void)drawList;
 
         printf("ImGui tests passed (Exhaustive).\n");
+#endif
     }
 } // namespace Juliet::UnitTest

Juliet/src/Core/Logging/LogManager.cpp

@@ -28,6 +28,9 @@ namespace Juliet
         };
         DECLARE_QUEUE(LogsEntry);
 
+        // TODO: Debug level per category
+        const bool kPrintDebugLog = false;
+
         // A log scope accumulates log until end of scope.
         // Can be used to accumulate then write in a log file each frame.
         struct LogScope
@@ -48,7 +51,7 @@ namespace Juliet
 
         Logs* LogAllocate()
         {
-            Arena* arena = ArenaAllocate();
+            Arena* arena = ArenaAllocate({} JULIET_DEBUG_ONLY(, "Log Manager"));
             Logs*  logs  = ArenaPushStruct<Logs>(arena);
             logs->Arena  = arena;
             return logs;
@@ -133,6 +136,11 @@ namespace Juliet
 
     void Log(LogLevel level, LogCategory category, const char* fmt, va_list args)
     {
+        if (level == LogLevel::Debug && kPrintDebugLog == false)
+        {
+            return;
+        }
+
         // TODO : Revisit, copy from https://github.com/Eclmist/Ether/blob/develop/src/common/logging/loggingmanager.cpp
         char formattedBuffer[4096];
 
@@ -163,6 +171,14 @@ namespace Juliet
         va_end(args);
     }
 
+    void LogDebug(LogCategory category, const char* fmt, ...)
+    {
+        va_list args;
+        va_start(args, fmt);
+        Log(LogLevel::Debug, category, fmt, args);
+        va_end(args);
+    }
+
     void LogMessage(LogCategory category, const char* fmt, ...)
     {
         va_list args;

Juliet/src/Core/Memory/EngineArena.h

@@ -1,10 +0,0 @@
-#pragma once
-
-#include <Core/Memory/MemoryArena.h>
-
-namespace Juliet
-{
-    // Persistent engine-only arena.
-    // Not exported to the Game DLL.
-    MemoryArena* GetEngineArena();
-} // namespace Juliet

Juliet/src/Core/Memory/MemoryArena.cpp

@@ -1,6 +1,7 @@
 #include <Core/Logging/LogManager.h>
 #include <Core/Memory/Allocator.h>
 #include <Core/Memory/MemoryArena.h>
+#include <Core/Memory/MemoryArenaDebug.h>
 #include <Core/Memory/Utils.h>
 
 #include <algorithm> // For std::max
@@ -17,9 +18,23 @@ namespace Juliet
         constexpr uint64 k_PageSize = Kilobytes(4);
     } // namespace
 
+    struct ArenaFreeNode
+    {
+        ArenaFreeNode* Next;
+        ArenaFreeNode* Previous;
+        index_t        Position;
+        size_t         Size;
+    };
+
+    namespace
+    {
+        static_assert(sizeof(ArenaFreeNode) == 32, "ArenaFreeNode should be 32 bytes and not more");
+        constexpr size_t k_ArenaFreeNodeSize = sizeof(ArenaFreeNode);
+    } // namespace
+
     // https://github.com/EpicGamesExt/raddebugger/blob/master/src/base/base_arena.c
 
-    Arena* ArenaAllocate(const ArenaParams& params, const std::source_location& loc)
+    Arena* ArenaAllocate(const ArenaParams& params JULIET_DEBUG_ONLY(, const char* name), const std::source_location& loc)
     {
         Log(LogLevel::Message, LogCategory::Core, "Allocating from %s : %ul", loc.file_name(), loc.line());
 
@@ -44,31 +59,96 @@ namespace Juliet
         arena->BasePosition = 0;
         arena->Position     = k_ArenaHeaderSize;
 
+        arena->FreeNodes    = nullptr;
+        arena->AllowRealloc = params.AllowRealloc;
+
+#if JULIET_DEBUG
+        arena->CanReserveMore = params.CanReserveMore;
+        arena->FirstDebugInfo = nullptr;
+
+        DebugArenaSetDebugName(arena, name);
+        DebugRegisterArena(arena);
+#endif
+
         return arena;
     }
 
     void ArenaRelease(NonNullPtr<Arena> arena)
     {
+        // Release active blocks (Current chain)
         for (Arena *node = arena->Current, *previous = nullptr; node != nullptr; node = previous)
         {
             previous = node->Previous;
+
+            JULIET_DEBUG_ONLY(DebugUnregisterArena(node);)
+            JULIET_DEBUG_ONLY(DebugArenaFreeBlock(node);)
+
             Memory::OS_Release(node, node->Reserved);
         }
     }
 
-    void* ArenaPush(NonNullPtr<Arena> arena, size_t size, size_t align, bool shouldBeZeroed)
+    void* ArenaPush(NonNullPtr<Arena> arena, size_t size, size_t align, bool shouldBeZeroed JULIET_DEBUG_ONLY(, const char* tag))
     {
+        // Assert(IsPowerOfTwo(align));
         Arena* current          = arena->Current;
         size_t positionPrePush  = AlignPow2(current->Position, align);
         size_t positionPostPush = positionPrePush + size;
 
+        if (arena->AllowRealloc)
+        {
+            size = Max(size, k_ArenaFreeNodeSize);
+
+            for (ArenaFreeNode* freeNode = current->FreeNodes; freeNode != nullptr; freeNode = freeNode->Next)
+            {
+                if (size <= freeNode->Size)
+                {
+                    index_t position      = freeNode->Position;
+                    size_t  remainingSize = freeNode->Size - size;
+                    if (remainingSize < k_ArenaFreeNodeSize)
+                    {
+                        ArenaFreeNode* previous = freeNode->Previous;
+                        ArenaFreeNode* next     = freeNode->Next;
+                        if (previous)
+                        {
+                            previous->Next = next;
+                        }
+                        if (next)
+                        {
+                            next->Previous = previous;
+                        }
+
+#if JULIET_DEBUG
+                        if (remainingSize > 0)
+                        {
+                            ++current->LostNodeCount;
+                        }
+#endif
+                    }
+                    else
+                    {
+                        freeNode->Position += size;
+                    }
+
+                    auto* result = reinterpret_cast<Byte*>(current) + position;
+                    if (shouldBeZeroed)
+                    {
+                        MemoryZero(result, size);
+                    }
+
+                    return result;
+                }
+            }
+        }
+
         // If allowed and needed, add a new block and chain it to the arena.
         if (current->Reserved < positionPostPush /* flags : chaining allowed */)
         {
+            Assert(arena->CanReserveMore);
+
             Arena* newBlock = nullptr;
             {
                 Arena* prev_block;
-                for (newBlock = arena->FreeLast, prev_block = nullptr; newBlock != nullptr;
+                for (newBlock = arena->FreeBlockLast, prev_block = nullptr; newBlock != nullptr;
                      prev_block = newBlock, newBlock = newBlock->Previous)
                 {
                     if (newBlock->Reserved >= AlignPow2(newBlock->Position, align) + size)
@@ -79,7 +159,7 @@ namespace Juliet
                         }
                         else
                         {
-                            arena->FreeLast = newBlock->Previous;
+                            arena->FreeBlockLast = newBlock->Previous;
                         }
                         break;
                     }
@@ -96,7 +176,9 @@ namespace Juliet
                     reserveSize = AlignPow2(size + k_ArenaHeaderSize, align);
                     commitSize  = AlignPow2(size + k_ArenaHeaderSize, align);
                 }
-                newBlock = ArenaAllocate({ .ReserveSize = reserveSize, .CommitSize = commitSize });
+
+                newBlock =
+                    ArenaAllocate({ .ReserveSize = reserveSize, .CommitSize = commitSize } JULIET_DEBUG_ONLY(, arena->Name));
             }
 
             newBlock->BasePosition = current->BasePosition + current->Reserved;
@@ -140,12 +222,63 @@ namespace Juliet
             }
         }
 
-        // If alloc failed, log and assert
         if (result == nullptr) [[unlikely]]
         {
+            Log(LogLevel::Error, LogCategory::Core, "Fatal Allocation Failure - Unexpected allocation failure");
             Assert(false, "Fatal Allocation Failure - Unexpected allocation failure");
         }
 
+        JULIET_DEBUG_ONLY(if (!IsDebugInfoArena(arena)) { DebugArenaAddDebugInfo(current, size, positionPrePush, tag); })
+
+        return result;
+    }
+
+    void* ArenaReallocate(NonNullPtr<Arena> arena, void* oldPtr, size_t oldSize, size_t newSize, size_t align,
+                          bool shouldBeZeroed JULIET_DEBUG_ONLY(, const char* tag))
+    {
+        void* result = ArenaPush(arena, newSize, align, shouldBeZeroed JULIET_DEBUG_ONLY(, tag));
+
+        // Find the correct block to release
+        Arena* block = nullptr;
+        for (block = arena->Current; block != nullptr; block = block->Previous)
+        {
+            if ((reinterpret_cast<Byte*>(block) < static_cast<Byte*>(oldPtr)) &&
+                (static_cast<Byte*>(oldPtr) <= (reinterpret_cast<Byte*>(block) + block->Reserved)))
+            {
+                break;
+            }
+        }
+        Assert(block != nullptr);
+
+        // Copy old to new
+        MemCopy(result, oldPtr, std::min(oldSize, newSize));
+
+        // Zero the old memory
+        MemoryZero(oldPtr, oldSize);
+
+        if (oldSize >= sizeof(ArenaFreeNode))
+        {
+            ArenaFreeNode* freeNode = static_cast<ArenaFreeNode*>(oldPtr);
+            ptrdiff_t      posPtr   = static_cast<Byte*>(oldPtr) - reinterpret_cast<Byte*>(block);
+            index_t        position = static_cast<index_t>(posPtr);
+            freeNode->Position      = position;
+            freeNode->Size          = oldSize;
+
+            // Insert at head of the free list
+            freeNode->Next     = block->FreeNodes;
+            freeNode->Previous = nullptr;
+            if (block->FreeNodes)
+            {
+                block->FreeNodes->Previous = freeNode;
+            }
+            block->FreeNodes = freeNode;
+
+#if JULIET_DEBUG
+            // Remove the debug info for the old allocation (since it's now free)
+            size_t oldOffset = static_cast<size_t>(static_cast<Byte*>(oldPtr) - reinterpret_cast<Byte*>(block));
+            DebugArenaRemoveAllocation(block, oldOffset);
+#endif
+        }
         return result;
     }
 
@@ -158,20 +291,18 @@ namespace Juliet
         {
             previous          = current->Previous;
             current->Position = k_ArenaHeaderSize;
-            SingleLinkedListPushPrevious(arena->FreeLast, current);
-        }
 
-        // No freelist :
-        // for (Arena* previous = nullptr; current->BasePosition >= clampedPosition; current = previous)
-        // {
-        //     previous = current->Previous;
-        //     Memory::OS_Release(current, current->Reserved);
-        // }
+            JULIET_DEBUG_ONLY(DebugArenaFreeBlock(current);)
+
+            SingleLinkedListPushPrevious(arena->FreeBlockLast, current);
+        }
 
         arena->Current     = current;
         size_t newPosition = clampedPosition - current->BasePosition;
         Assert(newPosition <= current->Position);
         current->Position = newPosition;
+
+        JULIET_DEBUG_ONLY(DebugArenaPopTo(current, newPosition);)
     }
 
     void ArenaPop(NonNullPtr<Arena> arena, size_t amount)
@@ -197,438 +328,14 @@ namespace Juliet
         return position;
     }
 
-    namespace UnitTest
+    TempArena ArenaTempBegin(NonNullPtr<Arena> arena)
     {
-        extern void TestMemoryArena();
+        index_t position = ArenaPos(arena);
+        return { arena.Get(), position };
     }
 
-    // --- MemoryPool Implementation ---
-
-#if JULIET_DEBUG
-    static void FreeDebugAllocations(MemoryBlock* blk)
+    void ArenaTempEnd(TempArena temp)
     {
-        if (!blk)
-        {
-            return;
-        }
-        ArenaAllocation* curr = blk->FirstAllocation;
-        while (curr)
-        {
-            ArenaAllocation* next = curr->Next;
-            SafeFree(curr);
-            curr = next;
-        }
-        blk->FirstAllocation = nullptr;
+        ArenaPopTo(temp.Arena, temp.Position);
     }
-#endif
-
-    // Simple First-Fit Allocator
-    MemoryBlock* MemoryPool::AllocateBlock(size_t minCapacity)
-    {
-        // Require space for Header + Data
-        size_t totalUnalignedSize = sizeof(MemoryBlock) + minCapacity;
-        size_t requiredSize       = (totalUnalignedSize + 15) & ~static_cast<size_t>(15);
-
-        MemoryBlock** prevPtr = &FreeList;
-        MemoryBlock*  curr    = FreeList;
-
-        while (curr)
-        {
-            if (curr->TotalSize >= requiredSize)
-            {
-                // Match
-                // Check if we can split this block?
-                if (curr->TotalSize >= requiredSize + sizeof(MemoryBlock) + 16)
-                {
-                    // Split
-                    size_t remainingSize = curr->TotalSize - requiredSize;
-
-                    MemoryBlock* nextBlock = reinterpret_cast<MemoryBlock*>((uint8*)curr + requiredSize);
-                    nextBlock->Magic       = MemoryBlock::kMagic;
-                    nextBlock->TotalSize   = remainingSize;
-                    nextBlock->Used        = 0;
-                    nextBlock->Next        = curr->Next;
-
-                    // Update FreeList to point to the new remaining block instead of curr
-                    *prevPtr = nextBlock;
-
-                    // Update curr to be the allocated chunk
-                    curr->TotalSize = requiredSize;
-                }
-                else
-                {
-                    // Take the whole block
-                    *prevPtr = curr->Next;
-                }
-
-                curr->Next  = nullptr;
-                curr->Used  = 0;
-                curr->Magic = MemoryBlock::kMagic;
-#if JULIET_DEBUG
-                curr->FirstAllocation = nullptr;
-#endif
-
-#if JULIET_DEBUG
-                if (curr->TotalSize > sizeof(MemoryBlock))
-                {
-                    MemSet(curr->GetData(), 0xCD, curr->TotalSize - sizeof(MemoryBlock));
-                }
-#endif
-                return curr;
-            }
-
-            prevPtr = &curr->Next;
-            curr    = curr->Next;
-        }
-
-        // Out of Memory in Pool
-        Assert(false, "MemoryPool exhausted!");
-        return nullptr;
-    }
-
-    void MemoryPool::FreeBlock(MemoryBlock* block)
-    {
-        if (!block)
-        {
-            return;
-        }
-
-        Assert(block->Magic == MemoryBlock::kMagic);
-
-        // Poison Header and Data in Debug
-#if JULIET_DEBUG
-        FreeDebugAllocations(block);
-        // 0xDD = Dead Data
-        MemSet(block->GetData(), 0xDD, block->TotalSize - sizeof(MemoryBlock));
-        block->Magic = 0xDEADBEEF;
-#endif
-
-        // Insert at Head of FreeList (Simplest, no coalescing yet)
-        block->Next = FreeList;
-        FreeList    = block;
-    }
-
-    // --- MemoryArena Implementation ---
-
-    void MemoryArenaCreate(MemoryArena* arena, MemoryPool* pool)
-    {
-        Assert(arena);
-        Assert(pool);
-        arena->BackingPool  = pool;
-        arena->CurrentBlock = nullptr;
-        arena->FirstBlock   = nullptr;
-    }
-
-    // Overload for backward compatibility / tests if needed, but we should switch to using Pools.
-    // NOTE: The previous signature was (Arena*, void* backing, size_t).
-    // We are changing the API.
-
-    void* ArenaPush(MemoryArena* arena, size_t size, size_t alignment, [[maybe_unused]] String tag)
-    {
-        Assert(arena);
-        Assert(arena->BackingPool);
-
-        // Default Block Size (e.g., 64KB or 1MB? Let's use 16KB for granular tests,
-        // or larger for prod. Let's make it dynamic or standard constant.
-        constexpr size_t kDefaultBlockSize = 64 * 1024; // 64KB pages
-
-        // Alignment check
-        Assert((alignment & (alignment - 1)) == 0);
-
-        if (!arena->CurrentBlock)
-        {
-            // Initial Allocation
-            size_t allocSize    = std::max(size, kDefaultBlockSize);
-            arena->CurrentBlock = arena->BackingPool->AllocateBlock(allocSize);
-            arena->FirstBlock   = arena->CurrentBlock;
-        }
-
-        // Try allocation in CurrentBlock
-        MemoryBlock* blk             = arena->CurrentBlock;
-        size_t       currentAddr     = reinterpret_cast<size_t>(blk->GetData()) + blk->Used;
-        size_t       alignmentOffset = 0;
-
-        size_t mask = alignment - 1;
-        if (currentAddr & mask)
-        {
-            alignmentOffset = alignment - (currentAddr & mask);
-        }
-
-        if (blk->Used + alignmentOffset + size > blk->TotalSize - sizeof(MemoryBlock))
-        {
-            // Overflow! Request new block.
-            // Strict minimum: what we need now.
-            // Better: Max(Default, size) to avoid repeating large allocs for tiny overflow?
-            size_t       allocSize = std::max(size, kDefaultBlockSize);
-            MemoryBlock* newBlock  = arena->BackingPool->AllocateBlock(allocSize);
-
-            // Link
-            blk->Next           = newBlock;
-            arena->CurrentBlock = newBlock;
-            blk                 = newBlock;
-
-            // Recalc for new block (Used should be 0)
-            currentAddr     = reinterpret_cast<size_t>(blk->GetData());
-            alignmentOffset = 0;
-            // newBlock check
-            if (currentAddr & mask)
-            {
-                alignmentOffset = alignment - (currentAddr & mask);
-            }
-        }
-
-        // Commit
-        blk->Used += alignmentOffset;
-        void* ptr = blk->GetData() + blk->Used;
-
-#if JULIET_DEBUG
-        ArenaAllocation* node = (ArenaAllocation*)Malloc(sizeof(ArenaAllocation));
-        node->Offset          = blk->Used;
-        node->Size            = size;
-        node->Tag             = tag;
-        node->Next            = nullptr;
-
-        if (!blk->FirstAllocation)
-            blk->FirstAllocation = node;
-        else
-        {
-            ArenaAllocation* t = blk->FirstAllocation;
-            while (t->Next)
-                t = t->Next;
-            t->Next = node;
-        }
-#endif
-
-        blk->Used += size;
-
-        return ptr;
-    }
-
-    void* ArenaRealloc(MemoryArena* arena, void* oldPtr, size_t oldSize, size_t newSize, size_t alignment, String tag)
-    {
-        Assert(arena);
-        Assert(oldPtr);
-        Assert(newSize != 0);
-
-        // Optimized Case: Expanding the LAST allocation in the Current Block
-        MemoryBlock* blk      = arena->CurrentBlock;
-        uint8*       oldBytes = static_cast<uint8*>(oldPtr);
-
-        // Is oldPtr inside current block?
-        if (oldBytes >= blk->GetData() && oldBytes < blk->GetData() + blk->TotalSize - sizeof(MemoryBlock))
-        {
-            // Is it the last one?
-            if (oldBytes + oldSize == blk->GetData() + blk->Used)
-            {
-                // Can we expand?
-                if (blk->Used + (newSize - oldSize) <= blk->TotalSize - sizeof(MemoryBlock))
-                {
-                    // Yes, expand in place
-                    blk->Used += (newSize - oldSize);
-#if JULIET_DEBUG
-                    {
-                        ArenaAllocation* t = blk->FirstAllocation;
-                        while (t && t->Next)
-                            t = t->Next;
-                        if (t) t->Size += (newSize - oldSize);
-                    }
-#endif
-                    return oldPtr;
-                }
-            }
-        }
-
-        // Fallback: Copy
-        void* newPtr = ArenaPush(arena, newSize, alignment, tag);
-        MemCopy(newPtr, oldPtr, std::min(oldSize, newSize));
-        return newPtr;
-    }
-
-    bool ArenaPop(MemoryArena* arena, void* ptr, size_t size)
-    {
-        Assert(arena);
-        Assert(ptr);
-        Assert(size);
-
-        MemoryBlock* blk = arena->CurrentBlock;
-        Assert(blk);
-
-        uint8* ptrBytes   = static_cast<uint8*>(ptr);
-        uint8* currentTop = blk->GetData() + blk->Used;
-
-        // Check if this pointer is exactly at the top of the stack (LIFO)
-        if (ptrBytes + size == currentTop)
-        {
-            // Yes, we can just rewind the Used pointer
-            blk->Used -= size;
-#if JULIET_DEBUG
-            {
-                ArenaAllocation* t    = blk->FirstAllocation;
-                ArenaAllocation* prev = nullptr;
-                while (t && t->Next)
-                {
-                    prev = t;
-                    t    = t->Next;
-                }
-                if (t)
-                {
-                    SafeFree(t);
-                    if (prev)
-                    {
-                        prev->Next = nullptr;
-                    }
-                    else
-                    {
-                        blk->FirstAllocation = nullptr;
-                    }
-                }
-            }
-#endif
-            return true;
-        }
-
-        return false;
-    }
-
-    void ArenaReset(MemoryArena* arena)
-    {
-        Assert(arena);
-        Assert(arena->FirstBlock);
-
-        // Keep FirstBlock, Free the rest.
-        MemoryBlock* curr = arena->FirstBlock->Next;
-        while (curr)
-        {
-            MemoryBlock* next = curr->Next;
-            arena->BackingPool->FreeBlock(curr);
-            curr = next;
-        }
-
-        arena->FirstBlock->Next = nullptr;
-        arena->FirstBlock->Used = 0;
-        arena->CurrentBlock     = arena->FirstBlock;
-
-#if JULIET_DEBUG
-        // Poison First Block
-        FreeDebugAllocations(arena->FirstBlock);
-        MemSet(arena->FirstBlock->GetData(), 0xCD, arena->FirstBlock->TotalSize - sizeof(MemoryBlock));
-#endif
-    }
-
-    ArenaMarker ArenaGetMarker(MemoryArena* arena)
-    {
-        Assert(arena);
-        return { arena->CurrentBlock, arena->CurrentBlock ? arena->CurrentBlock->Used : 0 };
-    }
-
-    void ArenaResetToMarker(MemoryArena* arena, ArenaMarker marker)
-    {
-        Assert(arena);
-        if (!marker.Block)
-        {
-            // If marker block is null, it might mean "start" or "empty".
-            // But if the arena has blocks, this is suspicious.
-            // If the arena was empty when marker was taken, this is valid.
-            ArenaReset(arena);
-            return;
-        }
-
-        // Free blocks *after* the marker block
-        MemoryBlock* curr = marker.Block->Next;
-        while (curr)
-        {
-            MemoryBlock* next = curr->Next;
-            arena->BackingPool->FreeBlock(curr);
-            curr = next;
-        }
-
-        marker.Block->Next  = nullptr;
-        marker.Block->Used  = marker.Offset;
-        arena->CurrentBlock = marker.Block;
-    }
-
-    // --- Global Arenas ---
-
-    namespace
-    {
-        MemoryPool g_ScratchMemory;
-        MemoryPool g_EngineMemory;
-        MemoryPool g_GameMemory;
-
-        MemoryArena g_ScratchArena;
-        MemoryArena g_EngineArena;
-        MemoryArena g_GameArena;
-
-        // Backing Buffers
-        void* g_ScratchBuffer = nullptr;
-        void* g_EngineBuffer  = nullptr;
-        void* g_GameBuffer    = nullptr;
-
-        constexpr size_t kScratchSize = Megabytes(64);
-        constexpr size_t kEngineSize  = Megabytes(256);
-        constexpr size_t kGameSize    = Megabytes(512);
-
-        void InitPool(MemoryPool* pool, void* buffer, size_t size)
-        {
-            pool->BaseAddress = buffer;
-            pool->TotalSize   = size;
-
-            // Create one giant initial block
-            Assert(size > sizeof(MemoryBlock));
-            MemoryBlock* block = static_cast<MemoryBlock*>(buffer);
-            block->Magic       = MemoryBlock::kMagic;
-            block->Next        = nullptr;
-            block->TotalSize   = size;
-            block->Used        = 0;
-
-            pool->FreeList = block;
-        }
-    } // namespace
-
-    MemoryArena* GetScratchArena()
-    {
-        return &g_ScratchArena;
-    }
-    MemoryArena* GetEngineArena()
-    {
-        return &g_EngineArena;
-    }
-    MemoryArena* GetGameArena()
-    {
-        return &g_GameArena;
-    }
-
-    void ScratchArenaReset()
-    {
-        ArenaReset(&g_ScratchArena);
-    }
-
-    void MemoryArenasInit()
-    {
-        g_ScratchBuffer = Malloc(kScratchSize);
-        g_EngineBuffer  = Malloc(kEngineSize);
-        g_GameBuffer    = Malloc(kGameSize);
-
-        InitPool(&g_ScratchMemory, g_ScratchBuffer, kScratchSize);
-        InitPool(&g_EngineMemory, g_EngineBuffer, kEngineSize);
-        InitPool(&g_GameMemory, g_GameBuffer, kGameSize);
-
-        MemoryArenaCreate(&g_ScratchArena, &g_ScratchMemory);
-        MemoryArenaCreate(&g_EngineArena, &g_EngineMemory);
-        MemoryArenaCreate(&g_GameArena, &g_GameMemory);
-
-#if JULIET_DEBUG
-        UnitTest::TestMemoryArena();
-#endif
-    }
-
-    void MemoryArenasShutdown()
-    {
-        // Technically we should free blocks?
-        // But since we own the giant buffers, we can just free them.
-        SafeFree(g_ScratchBuffer);
-        SafeFree(g_EngineBuffer);
-        SafeFree(g_GameBuffer);
-    }
-
 } // namespace Juliet

Juliet/src/Core/Memory/MemoryArenaDebug.cpp

@@ -0,0 +1,156 @@
+#include <Core/Memory/MemoryArena.h> // For Arena definition
+#include <Core/Memory/MemoryArenaDebug.h>
+
+#if JULIET_DEBUG
+
+namespace Juliet
+{
+    Arena*           g_ArenaGlobalHead         = nullptr;
+    Arena*           g_DebugInfoArena          = nullptr;
+    ArenaDebugInfo*  g_DebugInfoFreeList       = nullptr;
+    ArenaAllocation* g_ArenaAllocationFreeList = nullptr;
+
+    // --- Internal Helpers ---
+    static ArenaDebugInfo* AllocDebugInfo()
+    {
+        if (g_DebugInfoFreeList)
+        {
+            ArenaDebugInfo* info = g_DebugInfoFreeList;
+            g_DebugInfoFreeList  = info->Next;
+            info->Next           = nullptr;
+            return info;
+        }
+
+        if (!g_DebugInfoArena)
+        {
+            // Create a dedicated arena for debug info
+            g_DebugInfoArena = ArenaAllocate(
+                { .ReserveSize = Megabytes(16), .CommitSize = Kilobytes(64) } JULIET_DEBUG_ONLY(, "Debug Info Arena"));
+        }
+
+        return ArenaPushStruct<ArenaDebugInfo>(g_DebugInfoArena);
+    }
+
+    static void FreeDebugInfo(ArenaDebugInfo* info)
+    {
+        if (info)
+        {
+            info->Next          = g_DebugInfoFreeList;
+            g_DebugInfoFreeList = info;
+        }
+    }
+
+    void DebugRegisterArena(NonNullPtr<Arena> arena)
+    {
+        // Add to Global List
+        // Note: Not thread safe, assuming single thread for now as per context
+        if (g_ArenaGlobalHead)
+        {
+            g_ArenaGlobalHead->GlobalPrev = arena;
+        }
+        arena->GlobalNext = g_ArenaGlobalHead;
+        arena->GlobalPrev = nullptr;
+        g_ArenaGlobalHead = arena;
+    }
+
+    void DebugUnregisterArena(NonNullPtr<Arena> arena)
+    {
+        // Remove from Global List
+        if (arena->GlobalPrev)
+        {
+            arena->GlobalPrev->GlobalNext = arena->GlobalNext;
+        }
+        else
+        {
+            g_ArenaGlobalHead = arena->GlobalNext;
+        }
+        if (arena->GlobalNext)
+        {
+            arena->GlobalNext->GlobalPrev = arena->GlobalPrev;
+        }
+        arena->GlobalPrev = nullptr;
+        arena->GlobalNext = nullptr;
+    }
+
+    void DebugArenaSetDebugName(NonNullPtr<Arena> arena, const char* name)
+    {
+        arena->Name = name;
+    }
+
+    bool IsDebugInfoArena(const Arena* arena)
+    {
+        return arena == g_DebugInfoArena;
+    }
+
+    void DebugArenaFreeBlock(Arena* block)
+    {
+        ArenaDebugInfo* info = block->FirstDebugInfo;
+        while (info)
+        {
+            ArenaDebugInfo* nextInfo = info->Next;
+            FreeDebugInfo(info);
+            info = nextInfo;
+        }
+        block->FirstDebugInfo = nullptr;
+    }
+
+    void DebugArenaRemoveAllocation(Arena* block, size_t oldOffset)
+    {
+        ArenaDebugInfo** prevInfo = &block->FirstDebugInfo;
+        ArenaDebugInfo*  info     = block->FirstDebugInfo;
+
+        while (info)
+        {
+            if (info->Offset == oldOffset) // Found it
+            {
+                *prevInfo = info->Next;
+                FreeDebugInfo(info);
+                break;
+            }
+            prevInfo = &info->Next;
+            info     = info->Next;
+        }
+    }
+
+    void DebugArenaPopTo(Arena* block, size_t newPosition)
+    {
+        ArenaDebugInfo** prevInfo = &block->FirstDebugInfo;
+        ArenaDebugInfo*  info     = block->FirstDebugInfo;
+        while (info)
+        {
+            if (info->Offset >= newPosition)
+            {
+                ArenaDebugInfo* toFree = info;
+                *prevInfo              = info->Next; // Unlink
+                info                   = info->Next; // Advance
+                FreeDebugInfo(toFree);
+            }
+            else
+            {
+                prevInfo = &info->Next;
+                info     = info->Next;
+            }
+        }
+    }
+
+    void DebugArenaAddDebugInfo(Arena* block, size_t size, size_t offset, const char* tag)
+    {
+        ArenaDebugInfo* info = AllocDebugInfo();
+        if (info)
+        {
+            info->Tag             = tag ? tag : "Untagged";
+            info->Size            = size;
+            info->Offset          = offset;
+            info->Next            = block->FirstDebugInfo;
+            block->FirstDebugInfo = info;
+        }
+    }
+
+    Arena* GetGlobalArenaListHead()
+    {
+        return g_ArenaGlobalHead;
+    }
+
+} // namespace Juliet
+
+#endif

Juliet/src/Core/Memory/MemoryArenaTests.cpp

@@ -20,7 +20,7 @@ namespace Juliet::UnitTest
 
         // New Arena!
         ArenaParams param{ .ReserveSize = Megabytes(64llu), .CommitSize = Kilobytes(64llu) };
-        Arena*      testArena = ArenaAllocate(param);
+        Arena*      testArena = ArenaAllocate(param JULIET_DEBUG_ONLY(, "Test Arena"));
 
         size_t pos = ArenaPos(testArena);
         Assert(pos == k_ArenaHeaderSize);
@@ -117,62 +117,59 @@ namespace Juliet::UnitTest
 
         ArenaRelease(testArena);
 
-        // Setup Pool and Arena for Pop Tests
-        size_t     testPoolSize = Megabytes(1);
-        void*      testBacking  = Calloc(1, testPoolSize);
-        MemoryPool pool;
-        pool.BaseAddress = testBacking;
-        pool.TotalSize   = testPoolSize;
-        pool.FreeList    = nullptr;
-
-        // Initialize FreeList (Simulate pool)
-        size_t blockSize = Kilobytes(128);
-        size_t numBlocks = testPoolSize / blockSize;
-        uint8* ptr       = static_cast<uint8*>(testBacking);
-        for (size_t i = 0; i < numBlocks; ++i)
         {
-            MemoryBlock* blk = reinterpret_cast<MemoryBlock*>(ptr + i * blockSize);
-            blk->Magic       = MemoryBlock::kMagic;
-            blk->TotalSize   = blockSize;
-            blk->Used        = 0;
-            blk->Next        = pool.FreeList;
-            pool.FreeList    = blk;
+            // Test reallocate
+            Arena* arena           = ArenaAllocate({ .AllowRealloc = true } JULIET_DEBUG_ONLY(, "Test Realloc"));
+            char*  charArray       = ArenaPushArray<char>(arena, 128);
+            char*  secondCharArray = ArenaPushArray<char>(arena, 128);
+            char*  thirdCharArray  = ArenaPushArray<char>(arena, 128);
+
+            secondCharArray = static_cast<char*>(ArenaReallocate(arena, secondCharArray, 128, 256, alignof(char), true JULIET_DEBUG_ONLY(, "ReallocChar")));
+
+            char* fourthCharArray = ArenaPushArray<char>(arena, 128);
+
+            Assert(charArray);
+            Assert(secondCharArray);
+            Assert(thirdCharArray);
+            Assert(fourthCharArray);
+
+            ArenaRelease(arena);
         }
 
-        MemoryArena arena;
-        MemoryArenaCreate(&arena, &pool);
+        {
+            // Test Reallocate Shrink (Buffer Overflow Bug Check)
+            Arena* arena = ArenaAllocate({ .AllowRealloc = true } JULIET_DEBUG_ONLY(, "Test Shrink"));
+            
+            size_t largeSize = 100;
+            char* large = ArenaPushArray<char>(arena, largeSize);
+            MemSet(large, 'A', largeSize);
 
-        // 5. Arena Pop
-        // Align sizes to 16 to avoid padding issues during Pop
-        void* pop1 = ArenaPush(&arena, 5008, 16, ConstString("Pop1"));
+            size_t smallSize = 50;
+            char* smallData = static_cast<char*>(ArenaReallocate(arena, large, largeSize, smallSize, alignof(char), true JULIET_DEBUG_ONLY(, "ResizeSmall")));
 
-        void* pop2 = ArenaPush(&arena, 208, 16, ConstString("Pop2"));
-        // Pop Middle (Should Fail)
-        bool res1 = ArenaPop(&arena, pop1, 5008);
-        Assert(res1 == false);
+            for (size_t i = 0; i < smallSize; ++i)
+            {
+                Assert(smallData[i] == 'A');
+            }
 
-        // Pop Top (Should Success)
-        bool res2 = ArenaPop(&arena, pop2, 208); // 200->208
-        Assert(res2 == true);
+            // Allocate next block (should be immediately after 'small')
+            // Don't zero it, if overflow happened it will contain 'A's
+            char* next = static_cast<char*>(ArenaPush(arena, 50, alignof(char), false JULIET_DEBUG_ONLY(, "OverflowCheck")));
 
-        // Verify Used space is back to pop1 end
-        Assert(arena.CurrentBlock->Used == ArenaGetMarker(&arena).Offset); // This usage of GetMarker is valid if marker was implicit?
-        // Actually we didn't take a marker.
-        // We can verify by allocating pop3. It should overwrite pop2 location.
-        void* pop3 = ArenaPush(&arena, 16, 16, ConstString("Pop3"));
-        Assert(pop3 == pop2);
+            bool corrupted = false;
+            for(size_t i = 0; i < 50; ++i)
+            {
+                if (next[i] == 'A')
+                {
+                    corrupted = true;
+                    break;
+                }
+            }
+            
+            Assert(!corrupted);
 
-        // Cleanup popped items from stack logic for reset...
-        // Pop pop3
-        ArenaPop(&arena, pop3, 16);
-        // Pop pop1
-        ArenaPop(&arena, pop1, 5008);
-        Assert(arena.CurrentBlock->Used == 0); // Should be effectively 0
-
-        printf("[Success] Arena Pop\n");
-
-        // Cleanup
-        SafeFree(testBacking);
+            ArenaRelease(arena);
+        }
 
         printf("All Paged MemoryArena tests passed.\n");
     }

Juliet/src/Engine/Debug/MemoryDebugger.cpp

@@ -1,9 +1,17 @@
 #include <Core/Common/String.h>
-#include <Core/Memory/EngineArena.h>
+#include <Core/Container/Vector.h>
+#include <Core/Memory/MemoryArena.h> // Added for Arena definition
+#include <Core/Memory/MemoryArenaDebug.h>
 #include <Engine/Debug/MemoryDebugger.h>
+
 #include <imgui.h>
 
-#include <algorithm>
+#if JULIET_DEBUG
+
+namespace Juliet
+{
+    Arena* GetGlobalArenaListHead();
+} // namespace Juliet
 
 namespace Juliet::Debug
 {
@@ -17,154 +25,190 @@ namespace Juliet::Debug
             bool             ScrollListToSelected   = false;
         };
 
-        ArenaDebugState& GetState(const String& name)
+        struct PagedArenaDebugState
         {
-            // Simple static map-like storage using standard map would be better but we minimize deps.
-            // Just use a few static vars since we have known 3 arenas.
-            static ArenaDebugState s_GameState;
-            static ArenaDebugState s_EngineState;
-            static ArenaDebugState s_ScratchState;
+            float           Zoom                   = 1.0f;
+            ArenaDebugInfo* SelectedAlloc          = nullptr;
+            bool            ScrollVisualToSelected = false;
+            bool            ScrollListToSelected   = false;
+        };
 
-            if (StringCompare(name, ConstString("Game Arena")) == 0)
+        struct PagedArenaStateEntry
+        {
+            const Arena*         Arena;
+            PagedArenaDebugState State;
+        };
+
+        // Static Vector for lookup
+        VectorArena<PagedArenaStateEntry> s_PagedArenaStates;
+
+        PagedArenaDebugState& GetPagedArenaState(const Arena* arena)
+        {
+            if (s_PagedArenaStates.Arena == nullptr)
             {
-                return s_GameState;
+                s_PagedArenaStates.Create(JULIET_DEBUG_ONLY("DebugState States"));
             }
-            if (StringCompare(name, ConstString("Engine Arena")) == 0)
+
+            for (auto& entry : s_PagedArenaStates)
             {
-                return s_EngineState;
+                if (entry.Arena == arena)
+                {
+                    return entry.State;
+                }
             }
-            return s_ScratchState;
+
+            PagedArenaStateEntry newEntry;
+            newEntry.Arena = arena;
+            // Default construct state
+            newEntry.State = PagedArenaDebugState();
+
+            s_PagedArenaStates.PushBack(newEntry);
+            return s_PagedArenaStates.Last()->State;
         }
 
-#if JULIET_DEBUG
-        // Generate a stable color from a string tag
-        uint32 GetColorForTag(const String& tag)
+        // Generate a unique color per allocation, using tag + offset + size
+        // so entries with same tag name get distinct colors
+        uint32 GetColorForAllocation(const char* tag, size_t offset, size_t size)
         {
-            uint32      hash = 0;
-            size_t      len  = tag.Size;
-            const char* s    = tag.Data;
-            // Simple FNV-1a style hash
-            for (size_t i = 0; i < len; ++i)
+            uint32 hash = 2166136261u;
+            if (tag)
             {
-                hash = hash * 65599 + (uint8)s[i];
+                for (const char* s = tag; *s; ++s)
+                {
+                    hash ^= static_cast<uint8>(*s);
+                    hash *= 16777619u;
+                }
             }
-            // Use hash to pick a Hue
+            // Mix in offset and size to differentiate same-tag entries
+            hash ^= static_cast<uint32>(offset);
+            hash *= 16777619u;
+            hash ^= static_cast<uint32>(size);
+            hash *= 16777619u;
+
             float h = static_cast<float>(hash % 360) / 360.0f;
-            return ImColor::HSV(h, 0.7f, 0.8f);
+            float s = 0.5f + static_cast<float>((hash >> 12) % 30) / 100.0f;
+            float v = 0.65f + static_cast<float>((hash >> 20) % 25) / 100.0f;
+            return ImColor::HSV(h, s, v);
         }
-#endif
 
-        void DrawMemoryArena(String name, const MemoryArena& arena, [[maybe_unused]] ArenaAllocation* currentHighlight,
-                             [[maybe_unused]] ArenaAllocation*& outNewHighlight)
+        void DrawPagedArena(const Arena* arena)
         {
-            ArenaDebugState& state = GetState(name);
+            ImGui::PushID(arena);
+            const char*           name  = (arena->Name && arena->Name[0] != '\0') ? arena->Name : "Unnamed Arena";
+            PagedArenaDebugState& state = GetPagedArenaState(arena);
 
-            if (ImGui::CollapsingHeader(CStr(name), ImGuiTreeNodeFlags_DefaultOpen))
+            if (ImGui::CollapsingHeader(name))
             {
-                ImGui::PushID(CStr(name));
+                // Collect Blocks (Pages) in order (Oldest -> Newest)
+                // Arena->Previous chain goes Newest -> Oldest.
+                static VectorArena<const Arena*> blocks;
+                if (blocks.Arena == nullptr)
+                {
+                    blocks.Create(JULIET_DEBUG_ONLY("DebugState Blocks"));
+                }
+                blocks.Clear();
+
+                for (const Arena* curr = arena->Current; curr != nullptr; curr = curr->Previous)
+                {
+                    blocks.PushBack(curr);
+                }
+
+                // Reverse manually
+                size_t count = blocks.Count;
+                for (size_t i = 0; i < count / 2; ++i)
+                {
+                    const Arena* temp     = blocks[i];
+                    blocks[i]             = blocks[count - 1 - i];
+                    blocks[count - 1 - i] = temp;
+                }
 
                 // Calculate Stats
                 size_t totalCapacity = 0;
                 size_t totalUsed     = 0;
-                size_t blockCount    = 0;
 
-                MemoryBlock* curr = arena.FirstBlock;
-                while (curr)
+                for (const Arena* blk : blocks)
                 {
-                    totalCapacity += curr->TotalSize;
-                    totalUsed += curr->Used;
-                    blockCount++;
-                    curr = curr->Next;
+                    totalCapacity += blk->Reserved;
+                    totalUsed += blk->Position;
                 }
 
-                ImGui::Text("Used: %zu / %zu bytes (%zu blocks)", totalUsed, totalCapacity, blockCount);
+                ImGui::Text("Used: %zu / %zu bytes (%zu pages)", totalUsed, totalCapacity, blocks.Size());
+                ImGui::SliderFloat("Zoom", &state.Zoom, 0.1f, 1000000.0f, "%.2f", ImGuiSliderFlags_Logarithmic);
 
-                // Zoom Control
-                ImGui::SliderFloat("Zoom", &state.Zoom, 0.1f, 1000.0f, "%.2f");
-
-#if JULIET_DEBUG
-                // --- Visual View (Scrollable + Zoom) ---
+                // --- Visual View ---
                 ImGui::Separator();
                 ImGui::Text("Visual Map");
 
-                // Calculate Dynamic Height
-                // Height = blockCount * (blockHeight + spacing) + padding
-                // Constrain between minHeight and maxHeight
-                float blockHeight  = 24.0f;
-                float blockSpacing = 4.0f;
-                // Add extra padding to avoid vertical scrollbar triggering due to varying style padding
-                float requiredVisHeight = (float)blockCount * (blockHeight + blockSpacing) + 30.0f;
-                if (requiredVisHeight > 300.0f) requiredVisHeight = 300.0f;
-                if (requiredVisHeight < 50.0f) requiredVisHeight = 50.0f;
+                float blockHeight       = 24.0f;
+                float blockSpacing      = 4.0f;
+                float requiredVisHeight = static_cast<float>(blocks.Size()) * (blockHeight + blockSpacing) + 30.0f;
+                // constrains
+                if (requiredVisHeight > 300.0f)
+                {
+                    requiredVisHeight = 300.0f;
+                }
+                if (requiredVisHeight < 50.0f)
+                {
+                    requiredVisHeight = 50.0f;
+                }
 
-                // Use ImGuiWindowFlags_NoScrollbar if we fit?
-                // No, we want horizontal scrollbar. If we provide just enough height, vertical shouldn't show.
                 if (ImGui::BeginChild("VisualMap", ImVec2(0, requiredVisHeight), true,
                                       ImGuiWindowFlags_HorizontalScrollbar | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoScrollbar))
                 {
-                    ImGui::SetScrollY(0.0f); // Lock Vertical Scroll to separate Zoom from Scroll
+                    ImGui::SetScrollY(0.0f);
 
                     ImDrawList* dl         = ImGui::GetWindowDrawList();
                     float       availWidth = ImGui::GetContentRegionAvail().x;
                     ImVec2      startPos   = ImGui::GetCursorScreenPos();
 
-                    // Reserve space for the virtual width FIRST to satisfy layout
-                    // Also reserve explicit height > window height to ensure Child captures MouseWheel (stops bubbling)
                     float virtualWidth = availWidth * state.Zoom;
-                    if (virtualWidth < availWidth) virtualWidth = availWidth;
+                    if (virtualWidth < availWidth)
+                    {
+                        virtualWidth = availWidth;
+                    }
                     ImGui::Dummy(ImVec2(virtualWidth, requiredVisHeight + 1.0f));
 
                     bool isMapHovered = ImGui::IsWindowHovered();
 
-                    // Interaction Logic
-                    // 1. Zoom with Pivot
+                    // Zoom with pivot
                     if (isMapHovered)
                     {
                         float wheel = ImGui::GetIO().MouseWheel;
                         if (wheel != 0.0f)
                         {
-                            // Pivot Logic
-                            float mouseXScreen  = ImGui::GetMousePos().x;
-                            float activeScrollX = ImGui::GetScrollX();
-
-                            // Viewport Left
+                            float mouseXScreen     = ImGui::GetMousePos().x;
+                            float activeScrollX    = ImGui::GetScrollX();
                             float viewportLeft     = ImGui::GetWindowPos().x;
                             float mouseRelViewport = mouseXScreen - viewportLeft;
 
-                            // Current Ratio
                             float virtualWidthOld = std::max(availWidth * state.Zoom, availWidth);
                             float mouseContentPos = activeScrollX + mouseRelViewport;
                             float ratio           = mouseContentPos / virtualWidthOld;
 
-                            // Apply Zoom
                             state.Zoom += wheel * 0.2f * state.Zoom;
-                            if (state.Zoom < 0.1f) state.Zoom = 0.1f;
-                            if (state.Zoom > 1000.0f) state.Zoom = 1000.0f;
+                            state.Zoom = std::max(state.Zoom, 0.1f);
+                            state.Zoom = std::min(state.Zoom, 1000000.0f);
 
-                            // New Ratio
                             float virtualWidthNew = std::max(availWidth * state.Zoom, availWidth);
-
-                            // flNewScroll + MouseRel = Ratio * NewWidth
-                            float desiredScrollX = (ratio * virtualWidthNew) - mouseRelViewport;
+                            float desiredScrollX  = (ratio * virtualWidthNew) - mouseRelViewport;
                             ImGui::SetScrollX(desiredScrollX);
                         }
                     }
 
-                    // 2. Pan (Left, Right, or Middle Mouse)
+                    // Pan
                     if (isMapHovered && (ImGui::IsMouseDragging(ImGuiMouseButton_Left) || ImGui::IsMouseDragging(ImGuiMouseButton_Right) ||
                                          ImGui::IsMouseDragging(ImGuiMouseButton_Middle)))
                     {
                         ImGui::SetScrollX(ImGui::GetScrollX() - ImGui::GetIO().MouseDelta.x);
                     }
 
-                    // 3. Jump to Selected (Sync from List)
+                    // Jump to Selected (Sync from List)
                     if (state.ScrollVisualToSelected && state.SelectedAlloc)
                     {
-                        MemoryBlock* searchBlk = arena.FirstBlock;
-                        while (searchBlk)
+                        for (const Arena* searchBlk : blocks)
                         {
-                            ArenaAllocation* search = searchBlk->FirstAllocation;
-                            bool             found  = false;
+                            ArenaDebugInfo* search = searchBlk->FirstDebugInfo;
+                            bool            found  = false;
                             while (search)
                             {
                                 if (search == state.SelectedAlloc)
@@ -177,65 +221,174 @@ namespace Juliet::Debug
 
                             if (found)
                             {
-                                float  virtualWidthLocal = std::max(availWidth * state.Zoom, availWidth);
-                                size_t dataSize          = searchBlk->TotalSize - sizeof(MemoryBlock);
-                                if (dataSize > 0)
+                                float virtualWidthLocal = std::max(availWidth * state.Zoom, availWidth);
+                                if (searchBlk->Reserved > 0)
                                 {
-                                    double scale  = (double)virtualWidthLocal / (double)dataSize;
-                                    float  xStart = (float)((double)state.SelectedAlloc->Offset * scale);
-
-                                    // Scroll to center xStart
+                                    double scale =
+                                        static_cast<double>(virtualWidthLocal) / static_cast<double>(searchBlk->Reserved);
+                                    float xStart = static_cast<float>(static_cast<double>(state.SelectedAlloc->Offset) * scale);
                                     float centerOffset = availWidth * 0.5f;
                                     ImGui::SetScrollX(xStart - centerOffset);
                                 }
-                                state.ScrollVisualToSelected = false; // Consumed
+                                state.ScrollVisualToSelected = false;
                                 break;
                             }
-                            searchBlk = searchBlk->Next;
                         }
                     }
 
-                    MemoryBlock* blk = arena.FirstBlock;
-                    ImVec2       pos = startPos;
-
-                    int bIdx = 0;
-                    while (blk)
+                    ImVec2 pos = startPos;
+                    for (const Arena* blk : blocks)
                     {
-                        // Draw Block Frame
+                        ImGui::PushID(blk);
                         ImVec2 rectMin = pos;
-                        auto   rectMax = ImVec2(pos.x + virtualWidth, pos.y + blockHeight);
+                        ImVec2 rectMax = ImVec2(pos.x + virtualWidth, pos.y + blockHeight);
 
-                        // Border Color
-                        ImU32 borderColor = (uint32)ImColor::HSV(((float)bIdx * 0.1f), 0.0f, 0.7f);
-                        dl->AddRect(rectMin, rectMax, borderColor);
+                        dl->AddRect(rectMin, rectMax, IM_COL32(100, 100, 100, 255));
 
-                        size_t dataSize = blk->TotalSize - sizeof(MemoryBlock);
+                        size_t dataSize = blk->Reserved - k_ArenaHeaderSize;
                         if (dataSize > 0)
                         {
-                            double scale = (double)virtualWidth / (double)dataSize;
+                            double scale = static_cast<double>(virtualWidth) / static_cast<double>(blk->Reserved);
 
-                            ArenaAllocation* alloc = blk->FirstAllocation;
-                            while (alloc)
+                            // Draw Arena Header
                             {
-                                float xStart = pos.x + (float)((double)alloc->Offset * scale);
-                                float width  = (float)((double)alloc->Size * scale);
+                                float hdrWidth = static_cast<float>(static_cast<double>(k_ArenaHeaderSize) * scale);
+                                hdrWidth       = std::max(hdrWidth, 1.0f);
+                                ImVec2 hMin(pos.x, pos.y + 1);
+                                ImVec2 hMax(pos.x + hdrWidth, pos.y + blockHeight - 1);
+                                dl->AddRectFilled(hMin, hMax, IM_COL32(40, 60, 120, 255));
+
+                                if (hdrWidth > 30.0f)
+                                {
+                                    const char* hdrLabel = "Header";
+                                    ImVec2      textSize = ImGui::CalcTextSize(hdrLabel);
+                                    if (hdrWidth >= textSize.x + 4.0f)
+                                    {
+                                        float textX = hMin.x + (hdrWidth - textSize.x) * 0.5f;
+                                        float textY = hMin.y + (blockHeight - 2.0f - textSize.y) * 0.5f;
+                                        dl->AddText(ImVec2(textX, textY), IM_COL32(180, 200, 255, 255), hdrLabel);
+                                    }
+                                }
+
+                                if (ImGui::IsMouseHoveringRect(hMin, hMax) && ImGui::IsWindowHovered())
+                                {
+                                    ImGui::BeginTooltip();
+                                    ImGui::TextColored(ImVec4(0.5f, 0.6f, 0.9f, 1.0f), "Arena Header");
+                                    ImGui::Separator();
+                                    ImGui::Text("Size: %zu bytes", k_ArenaHeaderSize);
+                                    ImGui::EndTooltip();
+                                }
+                            }
+
+                            // Draw Allocations
+                            ArenaDebugInfo* info           = blk->FirstDebugInfo;
+                            size_t          expectedOffset = k_ArenaHeaderSize;
+                            while (info)
+                            {
+                                // Draw alignment padding gap if present (only for small gaps that are actual alignment)
+                                if (info->Offset > expectedOffset)
+                                {
+                                    size_t           padSize               = info->Offset - expectedOffset;
+                                    constexpr size_t k_MaxAlignmentPadding = 256;
+                                    float padXStart = pos.x + static_cast<float>(static_cast<double>(expectedOffset) * scale);
+                                    float padWidth = static_cast<float>(static_cast<double>(padSize) * scale);
+
+                                    if (padSize <= k_MaxAlignmentPadding && padWidth >= 1.0f)
+                                    {
+                                        ImVec2 pMin(padXStart, pos.y + 1);
+                                        ImVec2 pMax(padXStart + padWidth, pos.y + blockHeight - 1);
+
+                                        // Clip
+                                        if (pMin.x < rectMin.x)
+                                        {
+                                            pMin.x = rectMin.x;
+                                        }
+                                        if (pMax.x > rectMax.x)
+                                        {
+                                            pMax.x = rectMax.x;
+                                        }
+
+                                        // Draw hatched pattern (diagonal lines) - clipped to visible area
+                                        float visLeft      = ImGui::GetWindowPos().x;
+                                        float visRight     = visLeft + ImGui::GetWindowSize().x;
+                                        float clippedLeft  = std::max(pMin.x, visLeft);
+                                        float clippedRight = std::min(pMax.x, visRight);
+
+                                        dl->AddRectFilled(pMin, pMax, IM_COL32(30, 30, 30, 200));
+                                        if (clippedLeft < clippedRight)
+                                        {
+                                            float step   = 6.0f;
+                                            float startX = clippedLeft - (pMax.y - pMin.y);
+                                            startX       = pMin.x + step * std::floor((startX - pMin.x) / step);
+                                            if (startX < pMin.x)
+                                            {
+                                                startX = pMin.x;
+                                            }
+
+                                            int lineCount = 0;
+                                            for (float lx = startX; lx < clippedRight && lineCount < 500; lx += step, ++lineCount)
+                                            {
+                                                float ly0 = pMin.y;
+                                                float lx1 = lx + (pMax.y - pMin.y);
+                                                float ly1 = pMax.y;
+                                                if (lx1 > pMax.x)
+                                                {
+                                                    ly1 = pMin.y + (pMax.x - lx);
+                                                    lx1 = pMax.x;
+                                                }
+                                                dl->AddLine(ImVec2(lx, ly0), ImVec2(lx1, ly1), IM_COL32(80, 80, 80, 180));
+                                            }
+                                        }
+
+                                        // Label when zoomed
+                                        if (padWidth > 30.0f)
+                                        {
+                                            const char* padLabel = "Pad";
+                                            ImVec2      textSize = ImGui::CalcTextSize(padLabel);
+                                            if (padWidth >= textSize.x + 4.0f)
+                                            {
+                                                float textX = pMin.x + (padWidth - textSize.x) * 0.5f;
+                                                float textY = pMin.y + (blockHeight - 2.0f - textSize.y) * 0.5f;
+                                                dl->AddText(ImVec2(textX, textY), IM_COL32(120, 120, 120, 255), padLabel);
+                                            }
+                                        }
+
+                                        if (ImGui::IsMouseHoveringRect(pMin, pMax) && ImGui::IsWindowHovered())
+                                        {
+                                            ImGui::BeginTooltip();
+                                            ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "Alignment Padding");
+                                            ImGui::Separator();
+                                            ImGui::Text("Size: %zu bytes", padSize);
+                                            ImGui::Text("Offset: %zu - %zu", expectedOffset, info->Offset);
+                                            ImGui::EndTooltip();
+                                        }
+                                    }
+                                }
+                                expectedOffset = info->Offset + info->Size;
+
+                                ImGui::PushID(info);
+                                float xStart = pos.x + static_cast<float>(static_cast<double>(info->Offset) * scale);
+                                float width  = static_cast<float>(static_cast<double>(info->Size) * scale);
                                 width        = std::max(width, 1.0f);
 
-                                auto aMin = ImVec2(xStart, pos.y + 1);
-                                auto aMax = ImVec2(xStart + width, pos.y + blockHeight - 1);
+                                ImVec2 aMin(xStart, pos.y + 1);
+                                ImVec2 aMax(xStart + width, pos.y + blockHeight - 1);
 
-                                // Clip visually to block bounds (simplistic)
-                                if (aMin.x < rectMin.x) aMin.x = rectMin.x;
-                                if (aMax.x > rectMax.x) aMax.x = rectMax.x;
-
-                                ImU32 color = GetColorForTag(alloc->Tag);
-
-                                bool isSelected = (state.SelectedAlloc == alloc);
-                                bool isHovered  = (currentHighlight == alloc);
-
-                                if (isSelected || isHovered)
+                                // Clip to block bounds
+                                if (aMin.x < rectMin.x)
+                                {
+                                    aMin.x = rectMin.x;
+                                }
+                                if (aMax.x > rectMax.x)
+                                {
+                                    aMax.x = rectMax.x;
+                                }
+
+                                ImU32 color      = GetColorForAllocation(info->Tag, info->Offset, info->Size);
+                                bool  isSelected = (state.SelectedAlloc == info);
+
+                                if (isSelected)
                                 {
-                                    // Highlight
                                     dl->AddRectFilled(aMin, aMax, IM_COL32_WHITE);
                                     dl->AddRect(aMin, aMax, IM_COL32_BLACK);
                                 }
@@ -244,115 +397,132 @@ namespace Juliet::Debug
                                     dl->AddRectFilled(aMin, aMax, color);
                                 }
 
-                                // Draw Text if zoomed enough and fits
-                                if (width > 20.0f) // Threshold width to attempt drawing text
+                                // Draw text label when zoomed enough
+                                if (width > 20.0f && info->Tag)
                                 {
-                                    // Need to check actual text size
-                                    ImVec2 textSize = ImGui::CalcTextSize(alloc->Tag.Data, alloc->Tag.Data + alloc->Tag.Size);
+                                    const char* tagStr = info->Tag;
+                                    size_t      tagLen = 0;
+                                    while (tagStr[tagLen] != '\0')
+                                    {
+                                        ++tagLen;
+                                    }
+                                    ImVec2 textSize = ImGui::CalcTextSize(tagStr, tagStr + tagLen);
                                     if (width >= textSize.x + 4.0f)
                                     {
-                                        // Center text
-                                        float textX = aMin.x + (width - textSize.x) * 0.5f;
-                                        float textY = aMin.y + (blockHeight - 2.0f - textSize.y) * 0.5f;
-
-                                        // Contrast color
+                                        float textX     = aMin.x + (width - textSize.x) * 0.5f;
+                                        float textY     = aMin.y + (blockHeight - 2.0f - textSize.y) * 0.5f;
                                         ImU32 textColor = IM_COL32_BLACK;
-                                        dl->AddText(ImVec2(textX, textY), textColor, alloc->Tag.Data,
-                                                    alloc->Tag.Data + alloc->Tag.Size);
+                                        dl->AddText(ImVec2(textX, textY), textColor, tagStr, tagStr + tagLen);
                                     }
                                 }
 
                                 if (ImGui::IsMouseHoveringRect(aMin, aMax) && ImGui::IsWindowHovered())
                                 {
-                                    outNewHighlight = alloc;
-                                    if (ImGui::IsMouseClicked(ImGuiMouseButton_Left))
-                                    {
-                                        state.SelectedAlloc          = alloc;
-                                        state.ScrollListToSelected   = true; // Sync to list
-                                        state.ScrollVisualToSelected = false;
-                                    }
-
                                     ImGui::BeginTooltip();
-                                    ImGui::Text("Tag: %.*s", (int)alloc->Tag.Size, alloc->Tag.Data);
-                                    ImGui::Text("Size: %zu bytes", alloc->Size);
-                                    ImGui::Text("Offset: %zu", alloc->Offset);
+                                    ImGui::TextColored(ImVec4(1.0f, 0.8f, 0.3f, 1.0f), "%s", info->Tag);
+                                    ImGui::Separator();
+                                    ImGui::Text("Size: %zu bytes", info->Size);
+                                    ImGui::Text("Offset: %zu", info->Offset);
 
-                                    uint8* dataPtr = blk->GetData() + alloc->Offset;
+                                    // Hex data dump (first 16 bytes)
+                                    ImGui::Separator();
+                                    uint8* dataPtr = reinterpret_cast<uint8*>(const_cast<Arena*>(blk)) + info->Offset;
                                     ImGui::Text("Data: ");
-                                    for (int i = 0; i < 16 && i < (int)alloc->Size; ++i)
+                                    for (int i = 0; i < 16 && i < static_cast<int>(info->Size); ++i)
                                     {
                                         ImGui::SameLine();
                                         ImGui::Text("%02X", dataPtr[i]);
                                     }
 
                                     ImGui::EndTooltip();
+
+                                    if (ImGui::IsMouseClicked(ImGuiMouseButton_Left))
+                                    {
+                                        state.SelectedAlloc          = info;
+                                        state.ScrollListToSelected   = true;
+                                        state.ScrollVisualToSelected = false;
+                                    }
                                 }
 
-                                alloc = alloc->Next;
+                                info = info->Next;
+                                ImGui::PopID();
+                            }
+
+                            // Draw Free Nodes (Holes) if Realloc is enabled
+                            if (arena->AllowRealloc && blk->FreeNodes)
+                            {
+                                ArenaFreeNode* freeNode = blk->FreeNodes;
+                                while (freeNode)
+                                {
+                                    float fxStart = pos.x + static_cast<float>(static_cast<double>(freeNode->Position) * scale);
+                                    float fWidth = static_cast<float>(static_cast<double>(freeNode->Size) * scale);
+
+                                    ImVec2 fMin(fxStart, pos.y + 1);
+                                    ImVec2 fMax(fxStart + fWidth, pos.y + blockHeight - 1);
+
+                                    dl->AddRectFilled(fMin, fMax, IM_COL32(50, 50, 50, 200));
+
+                                    freeNode = freeNode->Next;
+                                }
                             }
                         }
 
-                        pos.y += blockHeight + 4;
-                        blk = blk->Next;
-                        bIdx++;
+                        pos.y += blockHeight + blockSpacing;
+                        ImGui::PopID();
                     }
-                    // Final spacing
-                    ImGui::Dummy(ImVec2(0, pos.y - startPos.y));
                 }
                 ImGui::EndChild();
 
-                // --- Tree View (Scrollable) ---
+                // --- Tree View (Allocations List) ---
                 ImGui::Separator();
                 if (ImGui::TreeNode("Allocations List"))
                 {
-                    // Calculate item count for Dynamic Height
-                    int          totalAllocCount = 0;
-                    MemoryBlock* countBlk        = arena.FirstBlock;
-                    while (countBlk)
+                    // Calculate item count for dynamic height
+                    int totalAllocCount = 0;
+                    for (const Arena* blk : blocks)
                     {
-                        // Add 1 for Block Node
                         totalAllocCount++;
-                        // If Block Node is Open? We don't know if we don't query it.
-                        // But actually we are inside a Child window inside the TreeNode.
-                        // We want the Child Window to be sized appropriately.
-
-                        // Simplification: Just count ALL allocations to assume "expanded" state or just use a max cap.
-                        // User wants "Grow until 25 elements".
-                        // This implies if we have 5 items, height is small. If 100, height is capped at 25.
-                        // We'll just count total allocations + blocks as a rough estimate of potential height.
-                        ArenaAllocation* countAlloc = countBlk->FirstAllocation;
-                        while (countAlloc)
+                        ArenaDebugInfo* countInfo = blk->FirstDebugInfo;
+                        while (countInfo)
                         {
                             totalAllocCount++;
-                            countAlloc = countAlloc->Next;
+                            countInfo = countInfo->Next;
                         }
-                        countBlk = countBlk->Next;
                     }
 
                     float lineHeight          = ImGui::GetTextLineHeightWithSpacing();
-                    float currentNeededHeight = (float)totalAllocCount * lineHeight;
+                    float currentNeededHeight = static_cast<float>(totalAllocCount) * lineHeight;
                     float maxHeight           = lineHeight * 25.0f;
 
                     float listHeight = currentNeededHeight;
-                    if (listHeight > maxHeight) listHeight = maxHeight;
-                    if (listHeight < lineHeight) listHeight = lineHeight; // Min 1 line
+                    if (listHeight > maxHeight)
+                    {
+                        listHeight = maxHeight;
+                    }
+                    if (listHeight < lineHeight)
+                    {
+                        listHeight = lineHeight;
+                    }
 
                     if (ImGui::BeginChild("AllocList", ImVec2(0, listHeight), true))
                     {
-                        MemoryBlock* blk    = arena.FirstBlock;
-                        int          blkIdx = 0;
-                        while (blk)
+                        int blkIdx = 0;
+                        for (const Arena* blk : blocks)
                         {
-                            if (ImGui::TreeNode((void*)blk, "Block %d (%zu bytes)", blkIdx, blk->TotalSize))
+                            if (ImGui::TreeNode(reinterpret_cast<const void*>(blk), "Page %d (%zu bytes, pos %zu)",
+                                                blkIdx, blk->Reserved, blk->Position))
                             {
-                                ArenaAllocation* alloc = blk->FirstAllocation;
-                                while (alloc)
+                                ArenaDebugInfo* info = blk->FirstDebugInfo;
+                                if (!info)
                                 {
-                                    bool isSelected = (state.SelectedAlloc == alloc);
-                                    bool isHovered  = (currentHighlight == alloc);
+                                    ImGui::TextDisabled("No allocations");
+                                }
+                                while (info)
+                                {
+                                    bool isSelected = (state.SelectedAlloc == info);
 
                                     ImGuiTreeNodeFlags flags = ImGuiTreeNodeFlags_Leaf | ImGuiTreeNodeFlags_NoTreePushOnOpen;
-                                    if (isSelected || isHovered)
+                                    if (isSelected)
                                     {
                                         flags |= ImGuiTreeNodeFlags_Selected;
                                     }
@@ -360,36 +530,29 @@ namespace Juliet::Debug
                                     if (isSelected && state.ScrollListToSelected)
                                     {
                                         ImGui::SetScrollHereY();
-                                        state.ScrollListToSelected = false; // Consumed
+                                        state.ScrollListToSelected = false;
                                     }
 
                                     // Color Square
-                                    ImU32 color = GetColorForTag(alloc->Tag);
+                                    ImU32 color = GetColorForAllocation(info->Tag, info->Offset, info->Size);
                                     ImGui::ColorButton("##color", ImColor(color),
                                                        ImGuiColorEditFlags_NoTooltip | ImGuiColorEditFlags_NoDragDrop,
                                                        ImVec2(12, 12));
                                     ImGui::SameLine();
 
-                                    // Use implicit string length from String struct
-                                    ImGui::TreeNodeEx(alloc, flags, "[%zu] %.*s (%zu bytes)", alloc->Offset,
-                                                      (int)alloc->Tag.Size, alloc->Tag.Data, alloc->Size);
+                                    ImGui::TreeNodeEx(info, flags, "[%zu] %s (%zu bytes)", info->Offset, info->Tag, info->Size);
 
                                     if (ImGui::IsItemClicked())
                                     {
-                                        state.SelectedAlloc          = alloc;
-                                        state.ScrollVisualToSelected = true; // Sync to visual
+                                        state.SelectedAlloc          = info;
+                                        state.ScrollVisualToSelected = true;
                                         state.ScrollListToSelected   = false;
                                     }
-                                    if (ImGui::IsItemHovered())
-                                    {
-                                        outNewHighlight = alloc;
-                                    }
 
-                                    alloc = alloc->Next;
+                                    info = info->Next;
                                 }
                                 ImGui::TreePop();
                             }
-                            blk = blk->Next;
                             blkIdx++;
                         }
                     }
@@ -397,35 +560,58 @@ namespace Juliet::Debug
 
                     ImGui::TreePop();
                 }
-#else
-                ImGui::TextColored(ImVec4(1, 0, 0, 1), "Compile with JULIET_DEBUG for Memory Visualization");
-#endif
-
-                ImGui::PopID();
             }
+            ImGui::PopID();
         }
+
+        ArenaAllocation* s_ConfirmedHovered = nullptr;
     } // namespace
 
     void DebugDrawMemoryArena()
     {
-#if JULIET_DEBUG
         // Cross-frame hover state
-        static ArenaAllocation* s_ConfirmedHovered = nullptr;
-        ArenaAllocation*        frameHovered       = nullptr;
-#else
-        ArenaAllocation* s_ConfirmedHovered = nullptr;
-        ArenaAllocation* frameHovered       = nullptr;
-#endif
+        ArenaAllocation* frameHovered = nullptr;
 
         if (ImGui::Begin("Memory Debugger"))
         {
-            DrawMemoryArena(ConstString("Game Arena"), *GetGameArena(), s_ConfirmedHovered, frameHovered);
-            DrawMemoryArena(ConstString("Engine Arena"), *GetEngineArena(), s_ConfirmedHovered, frameHovered);
+            if (ImGui::BeginTabBar("ArenaTabs"))
+            {
+                if (ImGui::BeginTabItem("Paged Arenas"))
+                {
+                    Arena* head = GetGlobalArenaListHead();
+                    if (!head)
+                    {
+                        ImGui::Text("No active paged arenas.");
+                    }
+                    else
+                    {
+                        for (Arena* a = head; a != nullptr; a = a->GlobalNext)
+                        {
+                            // Skip test and internal debug arenas
+                            if (a->Name)
+                            {
+                                bool isTest = (a->Name[0] == 'T' && a->Name[1] == 'e' && a->Name[2] == 's' && a->Name[3] == 't');
+                                bool isDebugInfo =
+                                    (a->Name[0] == 'D' && a->Name[1] == 'e' && a->Name[2] == 'b' && a->Name[3] == 'u' &&
+                                     a->Name[4] == 'g' && a->Name[5] == ' ' && a->Name[6] == 'I');
+                                if (isTest || isDebugInfo)
+                                {
+                                    continue;
+                                }
+                            }
+                            DrawPagedArena(a);
+                        }
+                    }
+                    ImGui::EndTabItem();
+                }
+
+                ImGui::EndTabBar();
+            }
         }
         ImGui::End();
 
-#if JULIET_DEBUG
         s_ConfirmedHovered = frameHovered;
-#endif
     }
 } // namespace Juliet::Debug
+
+#endif

Juliet/src/Engine/Engine.cpp

@@ -6,7 +6,9 @@
 #include <Engine/Engine.h>
 #include <Graphics/DebugDisplay.h>
 #include <Graphics/Graphics.h>
+#include <Graphics/MeshRenderer.h>
 #include <Graphics/RenderPass.h>
+#include <Graphics/SkyboxRenderer.h>
 #include <time.h>
 
 #ifdef JULIET_ENABLE_IMGUI
@@ -18,7 +20,10 @@
 namespace Juliet
 {
 #if JULIET_DEBUG
-    extern void RunUnitTests();
+    namespace UnitTest
+    {
+        extern void RunUnitTests();
+    }
 #endif
 
     namespace
@@ -34,6 +39,16 @@ namespace Juliet
             if (device)
             {
                 DebugDisplay_Initialize(device);
+                if (Window* window = EngineInstance.Application->GetPlatformWindow())
+                {
+                    bool success = InitializeMeshRendererGraphics(device, window);
+                    Assert(success);
+                    (void)(success);
+
+                    success = InitializeSkyboxRenderer(device, window);
+                    Assert(success);
+                    (void)(success);
+                }
             }
 
 #ifdef JULIET_ENABLE_IMGUI
@@ -70,6 +85,8 @@ namespace Juliet
             if (device)
             {
                 DebugDisplay_Shutdown(device);
+                ShutdownSkyboxRenderer();
+                ShutdownMeshRendererGraphics();
             }
         }
 
@@ -119,6 +136,9 @@ namespace Juliet
                 Camera debugCamera = EngineInstance.Application->GetDebugCamera();
                 DebugDisplay_Flush(cmdList, pass, debugCamera);
 
+                // Note: The MeshRenderer and SkyboxRenderer draw calls are still inside Application->OnRender
+                // They shouldn't be moved here directly without an interface since they require PushData.
+
 #ifdef JULIET_ENABLE_IMGUI
                 // ImGui rendering (always last before EndRenderPass)
                 ImGuiRenderer_Render(cmdList, pass);
@@ -133,11 +153,12 @@ namespace Juliet
 
     void InitializeEngine(JulietInit_Flags flags)
     {
+        EngineInstance.PlatformArena = ArenaAllocate({ .AllowRealloc = true } JULIET_DEBUG_PARAM("Platform Arena"));
+
         InitializeLogManager();
-        MemoryArenasInit();
 
 #if JULIET_DEBUG
-        RunUnitTests();
+        UnitTest::RunUnitTests();
 #endif
 
         InitFilesystem();
@@ -150,14 +171,18 @@ namespace Juliet
         JulietShutdown();
 
         ShutdownFilesystem();
-        MemoryArenasShutdown();
         ShutdownLogManager();
+
+        ArenaRelease(EngineInstance.PlatformArena);
     }
 
     void LoadApplication(IApplication& app)
     {
         EngineInstance.Application = &app;
-        EngineInstance.Application->Init();
+
+        InitializeMeshRenderer(EngineInstance.PlatformArena);
+
+        EngineInstance.Application->Init(EngineInstance.PlatformArena);
 
         // Systems depending on Window/GraphicsDevice
         InitializeDependentSystems();
@@ -169,6 +194,9 @@ namespace Juliet
         ShutdownDependentSystems();
 
         EngineInstance.Application->Shutdown();
+
+        ShutdownMeshRenderer();
+
         EngineInstance.Application = nullptr;
     }
 
@@ -185,9 +213,6 @@ namespace Juliet
 
             // Render tick
             RenderFrame();
-
-            // Reset scratch arena at end of frame
-            ScratchArenaReset();
         }
     }
 } // namespace Juliet

Juliet/src/Graphics/D3D12/D3D12Buffer.cpp

@@ -23,9 +23,9 @@ namespace Juliet::D3D12
         {
             switch (type)
             {
-                case D3D12BufferType::Base: return "Base";
-                case D3D12BufferType::TransferDownload: return "TransferDownload";
-                case D3D12BufferType::TransferUpload: return "TransferUpload";
+            case D3D12BufferType::Base: return "Base";
+            case D3D12BufferType::TransferDownload: return "TransferDownload";
+            case D3D12BufferType::TransferUpload: return "TransferUpload";
             }
             return "Unknown";
         }
@@ -34,11 +34,10 @@ namespace Juliet::D3D12
         {
             switch (usage)
             {
-                case BufferUsage::None: return "None";
-                case BufferUsage::ConstantBuffer: return "ConstantBuffer";
-                case BufferUsage::StructuredBuffer: return "StructuredBuffer";
-                case BufferUsage::IndexBuffer: return "IndexBuffer";
-                case BufferUsage::VertexBuffer: return "VertexBuffer";
+            case BufferUsage::None: return "None";
+            case BufferUsage::ConstantBuffer: return "ConstantBuffer";
+            case BufferUsage::StructuredBuffer: return "StructuredBuffer";
+            case BufferUsage::IndexBuffer: return "IndexBuffer";
             }
             return "Unknown";
         }
@@ -62,94 +61,62 @@ namespace Juliet::D3D12
             Free(buffer);
         }
 
-        D3D12Buffer* CreateBuffer(NonNullPtr<D3D12Driver> d3d12Driver, size_t size, BufferUsage usage, D3D12BufferType type)
+        D3D12Buffer* CreateBuffer(NonNullPtr<D3D12Driver> d3d12Driver, size_t size, size_t stride, BufferUsage usage,
+                                  D3D12BufferType type, bool isDynamic)
         {
-            auto buffer = static_cast<D3D12Buffer*>(Calloc(1, sizeof(D3D12Buffer)));
+            auto* buffer = static_cast<D3D12Buffer*>(Calloc(1, sizeof(D3D12Buffer)));
             if (!buffer)
             {
                 return nullptr;
             }
 
+            if (type == D3D12BufferType::Base && usage == BufferUsage::None)
+            {
+                Assert(false, "Creating Base buffer with BufferUsage::None is invalid");
+                DestroyBuffer(buffer);
+                return nullptr;
+            }
+
             // Align size for Constant Buffers
             if (usage == BufferUsage::ConstantBuffer)
             {
                 size = (size + 255U) & ~255U;
             }
 
-            D3D12_RESOURCE_STATES initialState   = D3D12_RESOURCE_STATE_COMMON;
             D3D12_HEAP_PROPERTIES heapProperties = {};
-            D3D12_HEAP_FLAGS      heapFlags      = D3D12_HEAP_FLAG_NONE;
+            heapProperties.CPUPageProperty       = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
+            heapProperties.MemoryPoolPreference  = D3D12_MEMORY_POOL_UNKNOWN;
 
-            switch (type)
+            D3D12_RESOURCE_STATES initialState = D3D12_RESOURCE_STATE_COMMON;
+            D3D12_HEAP_FLAGS      heapFlags    = D3D12_HEAP_FLAG_NONE;
+
+            // Constant buffers or Dynamic buffers generally need to be uploaded every frame
+            const bool isUpload = isDynamic || (type == D3D12BufferType::TransferUpload) || (usage == BufferUsage::ConstantBuffer);
+
+            if (type == D3D12BufferType::TransferDownload)
             {
-            case D3D12BufferType::Base:
+                heapProperties.Type = D3D12_HEAP_TYPE_READBACK;
+                initialState        = D3D12_RESOURCE_STATE_COPY_DEST;
+            }
+            else if (isUpload)
+            {
+                if (d3d12Driver->GPUUploadHeapSupported)
                 {
-                    switch (usage)
-                    {
-                    case BufferUsage::None:
-                        {
-                            Assert(false, "Creating buffer with invalid usage");
-                            DestroyBuffer(buffer);
-                            return nullptr;
-                        }
-
-                    case BufferUsage::IndexBuffer:
-                    case BufferUsage::StructuredBuffer:
-                    case BufferUsage::VertexBuffer:
-                        {
-                            heapProperties.Type                 = D3D12_HEAP_TYPE_DEFAULT;
-                            heapProperties.CPUPageProperty      = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
-                            heapProperties.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
-                            heapFlags                           = D3D12_HEAP_FLAG_NONE;
-                            break;
-                        }
-                    case BufferUsage::ConstantBuffer:
-                        {
-                            if (d3d12Driver->GPUUploadHeapSupported)
-                            {
-                                heapProperties.Type                 = D3D12_HEAP_TYPE_GPU_UPLOAD;
-                                heapProperties.CPUPageProperty      = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
-                                heapProperties.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
-                            }
-                            else
-                            {
-                                heapProperties.Type                 = D3D12_HEAP_TYPE_UPLOAD;
-                                heapProperties.CPUPageProperty      = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
-                                heapProperties.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
-                                initialState                        = D3D12_RESOURCE_STATE_GENERIC_READ;
-                                heapFlags                           = D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS;
-                            }
-                            // heapFlags = D3D12_HEAP_FLAG_NONE; // Avoid overwriting if set above
-                            if (heapProperties.Type == D3D12_HEAP_TYPE_GPU_UPLOAD)
-                            {
-                                heapFlags = D3D12_HEAP_FLAG_NONE; // Or appropriate flags
-                            }
-                            break;
-                        }
-                    }
-                    break;
+                    heapProperties.Type = D3D12_HEAP_TYPE_GPU_UPLOAD;
+                    initialState        = D3D12_RESOURCE_STATE_COMMON;
                 }
-            case D3D12BufferType::TransferDownload:
+                else
                 {
-                    heapProperties.Type                 = D3D12_HEAP_TYPE_READBACK;
-                    heapProperties.CPUPageProperty      = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
-                    heapProperties.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
-                    heapFlags                           = D3D12_HEAP_FLAG_NONE;
-                    initialState                        = D3D12_RESOURCE_STATE_COPY_DEST;
-                    break;
-                }
-            case D3D12BufferType::TransferUpload:
-                {
-                    heapProperties.Type                 = D3D12_HEAP_TYPE_UPLOAD;
-                    heapProperties.CPUPageProperty      = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
-                    heapProperties.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
-                    heapFlags                           = D3D12_HEAP_FLAG_NONE;
-                    initialState                        = D3D12_RESOURCE_STATE_GENERIC_READ;
-                    break;
+                    heapProperties.Type = D3D12_HEAP_TYPE_UPLOAD;
+                    initialState        = D3D12_RESOURCE_STATE_GENERIC_READ;
                 }
             }
-
-            D3D12_CONSTANT_BUFFER_VIEW_DESC cbvDesc = {};
+            else
+            {
+                // Must be a static buffer (Base type)
+                heapProperties.Type = D3D12_HEAP_TYPE_DEFAULT;
+                initialState        = D3D12_RESOURCE_STATE_COMMON;
+            }
 
             D3D12_RESOURCE_DESC desc = {};
             desc.Dimension           = D3D12_RESOURCE_DIMENSION_BUFFER;
@@ -164,20 +131,24 @@ namespace Juliet::D3D12
             desc.Layout              = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
             desc.Flags               = D3D12_RESOURCE_FLAG_NONE;
 
-            Log(LogLevel::Message, LogCategory::Graphics, "CreateBuffer: Device=%p, Size=%zu, Type=%s Use=%s", (void*)d3d12Driver->D3D12Device, size, D3D12BufferTypeToString(type), BufferUsageToString(usage));
+            Log(LogLevel::Message, LogCategory::Graphics, "CreateBuffer: Device=%p, Size=%zu, Type=%s Use=%s",
+                (void*)d3d12Driver->D3D12Device, size, D3D12BufferTypeToString(type), BufferUsageToString(usage));
+
             ID3D12Resource* handle = nullptr;
-            HRESULT result = d3d12Driver->D3D12Device->CreateCommittedResource(&heapProperties, heapFlags,
-                                                                               &desc, initialState, nullptr,
-                                                                                IID_ID3D12Resource, reinterpret_cast<void**>(&handle));
+            HRESULT result = d3d12Driver->D3D12Device->CreateCommittedResource(&heapProperties, heapFlags, &desc,
+                                                                               initialState, nullptr, IID_ID3D12Resource,
+                                                                               reinterpret_cast<void**>(&handle));
+
             if (FAILED(result))
             {
-                Log(LogLevel::Error, LogCategory::Graphics, "Could not create buffer! HRESULT=0x%08X", (uint32)result);
-                Log(LogLevel::Error, LogCategory::Graphics, "Failed Desc: Width=%llu Layout=%d HeapType=%d", (unsigned long long)desc.Width, (int)desc.Layout, (int)heapProperties.Type);
-                
+                Log(LogLevel::Error, LogCategory::Graphics, "Could not create buffer! HRESULT=0x%08X", static_cast<uint32>(result));
+                Log(LogLevel::Error, LogCategory::Graphics, "Failed Desc: Width=%llu Layout=%d HeapType=%d",
+                    (unsigned long long)desc.Width, (int)desc.Layout, (int)heapProperties.Type);
+
                 HRESULT removeReason = d3d12Driver->D3D12Device->GetDeviceRemovedReason();
                 if (FAILED(removeReason))
                 {
-                    Log(LogLevel::Error, LogCategory::Graphics, "Device Removed Reason: 0x%08X", (uint32)removeReason);
+                    Log(LogLevel::Error, LogCategory::Graphics, "Device Removed Reason: 0x%08X", static_cast<uint32>(removeReason));
                 }
 
                 DestroyBuffer(buffer);
@@ -202,20 +173,33 @@ namespace Juliet::D3D12
 
                     if (usage == BufferUsage::ConstantBuffer)
                     {
-                        cbvDesc.BufferLocation = handle->GetGPUVirtualAddress();
-                        cbvDesc.SizeInBytes    = static_cast<uint32>(size);
+                        D3D12_CONSTANT_BUFFER_VIEW_DESC cbvDesc = {};
+                        cbvDesc.BufferLocation                  = handle->GetGPUVirtualAddress();
+                        cbvDesc.SizeInBytes                     = static_cast<uint32>(size);
                         d3d12Driver->D3D12Device->CreateConstantBufferView(&cbvDesc, cpuHandle);
                     }
                     else if (usage == BufferUsage::StructuredBuffer)
                     {
                         D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc = {};
-                        srvDesc.Format                          = DXGI_FORMAT_R32_TYPELESS;
                         srvDesc.ViewDimension                   = D3D12_SRV_DIMENSION_BUFFER;
                         srvDesc.Shader4ComponentMapping         = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
                         srvDesc.Buffer.FirstElement             = 0;
-                        srvDesc.Buffer.NumElements              = static_cast<uint32>(size / 4);
-                        srvDesc.Buffer.StructureByteStride      = 0;
-                        srvDesc.Buffer.Flags                    = D3D12_BUFFER_SRV_FLAG_RAW;
+
+                        if (stride > 0)
+                        {
+                            srvDesc.Format                     = DXGI_FORMAT_UNKNOWN;
+                            srvDesc.Buffer.NumElements         = static_cast<uint32>(size / stride);
+                            srvDesc.Buffer.StructureByteStride = static_cast<uint32>(stride);
+                            srvDesc.Buffer.Flags               = D3D12_BUFFER_SRV_FLAG_NONE;
+                        }
+                        else
+                        {
+                            srvDesc.Format                     = DXGI_FORMAT_R32_TYPELESS;
+                            srvDesc.Buffer.NumElements         = static_cast<uint32>(size / 4);
+                            srvDesc.Buffer.StructureByteStride = 0;
+                            srvDesc.Buffer.Flags               = D3D12_BUFFER_SRV_FLAG_RAW;
+                        }
+
                         d3d12Driver->D3D12Device->CreateShaderResourceView(handle, &srvDesc, cpuHandle);
                         Log(LogLevel::Message, LogCategory::Graphics, "  -> SRV DescriptorIndex=%u", descriptor.Index);
                     }
@@ -230,10 +214,10 @@ namespace Juliet::D3D12
         }
     } // namespace
 
-    GraphicsBuffer* CreateGraphicsBuffer(NonNullPtr<GPUDriver> driver, size_t size, BufferUsage usage)
+    GraphicsBuffer* CreateGraphicsBuffer(NonNullPtr<GPUDriver> driver, size_t size, size_t stride, BufferUsage usage, bool isDynamic)
     {
         auto d3d12Driver = static_cast<D3D12Driver*>(driver.Get());
-        return reinterpret_cast<GraphicsBuffer*>(CreateBuffer(d3d12Driver, size, usage, D3D12BufferType::Base));
+        return reinterpret_cast<GraphicsBuffer*>(CreateBuffer(d3d12Driver, size, stride, usage, D3D12BufferType::Base, isDynamic));
     }
 
     void DestroyGraphicsBuffer(NonNullPtr<GraphicsBuffer> buffer)
@@ -245,8 +229,9 @@ namespace Juliet::D3D12
     {
         auto d3d12Driver = static_cast<D3D12Driver*>(driver.Get());
         return reinterpret_cast<GraphicsTransferBuffer*>(
-            CreateBuffer(d3d12Driver, size, BufferUsage::None,
-                         usage == TransferBufferUsage::Upload ? D3D12BufferType::TransferUpload : D3D12BufferType::TransferDownload));
+            CreateBuffer(d3d12Driver, size, 0, BufferUsage::None,
+                         usage == TransferBufferUsage::Upload ? D3D12BufferType::TransferUpload : D3D12BufferType::TransferDownload,
+                         false));
     }
 
     void DestroyGraphicsTransferBuffer(NonNullPtr<GraphicsTransferBuffer> buffer)
@@ -273,6 +258,24 @@ namespace Juliet::D3D12
         d3d12Buffer->Handle->Unmap(0, nullptr);
     }
 
+    void* MapBuffer(NonNullPtr<GPUDriver> /*driver*/, NonNullPtr<GraphicsBuffer> buffer)
+    {
+        auto        d3d12Buffer = reinterpret_cast<D3D12Buffer*>(buffer.Get());
+        void*       ptr         = nullptr;
+        D3D12_RANGE readRange   = { 0, 0 };
+        if (FAILED(d3d12Buffer->Handle->Map(0, &readRange, &ptr)))
+        {
+            return nullptr;
+        }
+        return ptr;
+    }
+
+    void UnmapBuffer(NonNullPtr<GPUDriver> /*driver*/, NonNullPtr<GraphicsBuffer> buffer)
+    {
+        auto d3d12Buffer = reinterpret_cast<D3D12Buffer*>(buffer.Get());
+        d3d12Buffer->Handle->Unmap(0, nullptr);
+    }
+
     uint32 GetDescriptorIndex(NonNullPtr<GPUDriver> /*driver*/, NonNullPtr<GraphicsBuffer> buffer)
     {
         auto d3d12Buffer = reinterpret_cast<D3D12Buffer*>(buffer.Get());
@@ -305,8 +308,8 @@ namespace Juliet::D3D12
         // We assume Upload buffers are always in state GENERIC_READ or similar suitable for CopySrc.
         // D3D12 Upload heaps start in GENERIC_READ and cannot transition.
 
-        d3d12CmdList->GraphicsCommandList.CommandList->CopyBufferRegion(d3d12Dst->Handle,
-                                                   dstOffset, d3d12Src->Handle, srcOffset, size);
+        d3d12CmdList->GraphicsCommandList.CommandList->CopyBufferRegion(d3d12Dst->Handle, dstOffset, d3d12Src->Handle,
+                                                                        srcOffset, size);
     }
 
     void TransitionBufferToReadable(NonNullPtr<CommandList> commandList, NonNullPtr<GraphicsBuffer> buffer)

Juliet/src/Graphics/D3D12/D3D12Buffer.h

@@ -20,7 +20,7 @@ namespace Juliet::D3D12
         size_t                    Size;
     };
 
-    extern GraphicsBuffer* CreateGraphicsBuffer(NonNullPtr<GPUDriver> driver, size_t size, BufferUsage usage);
+    extern GraphicsBuffer* CreateGraphicsBuffer(NonNullPtr<GPUDriver> driver, size_t size, size_t stride, BufferUsage usage, bool isDynamic);
     extern void            DestroyGraphicsBuffer(NonNullPtr<GraphicsBuffer> buffer);
 
     extern GraphicsTransferBuffer* CreateGraphicsTransferBuffer(NonNullPtr<GPUDriver> driver, size_t size, TransferBufferUsage usage);

Juliet/src/Graphics/D3D12/D3D12CommandList.cpp

@@ -246,7 +246,8 @@ namespace Juliet::D3D12
         d3d12Driver->GraphicsQueue->ExecuteCommandLists(1, ppCommandLists);
 
         // Acquire a fence and set it to the in-flight fence
-        d3d12CommandList->InFlightFence = Internal::AcquireFence(d3d12Driver);
+        d3d12CommandList->InFlightFence =
+            Internal::AcquireFence(d3d12Driver JULIET_DEBUG_PARAM(ConstString("SubmitCommandLists")));
         if (!d3d12CommandList->InFlightFence)
         {
             return false;
@@ -305,14 +306,22 @@ namespace Juliet::D3D12
             windowData->WindowFrameCounter = (windowData->WindowFrameCounter + 1) % d3d12Driver->FramesInFlight;
         }
 
-        // TODO : Correctly clean up and destroy
         // Check for cleanups
-        for (int32 i = d3d12Driver->SubmittedCommandListCount - 1; i >= 0; i -= 1)
         {
-            uint64 fenceValue = d3d12Driver->SubmittedCommandLists[i]->InFlightFence->Handle->GetCompletedValue();
-            if (fenceValue == D3D12_FENCE_SIGNAL_VALUE)
+            int32 i = 0;
+            while (i < d3d12Driver->SubmittedCommandListCount)
             {
-                success &= Internal::CleanCommandList(d3d12Driver, d3d12Driver->SubmittedCommandLists[i], false);
+                uint64 fenceValue = d3d12Driver->SubmittedCommandLists[i]->InFlightFence->Handle->GetCompletedValue();
+                if (fenceValue == D3D12_FENCE_SIGNAL_VALUE)
+                {
+                    success &= Internal::CleanCommandList(d3d12Driver, d3d12Driver->SubmittedCommandLists[i], false);
+                    // CleanCommandList swaps [i] with last and decrements count.
+                    // Don't increment — re-check the swapped-in element.
+                }
+                else
+                {
+                    i += 1;
+                }
             }
         }
 
@@ -361,30 +370,40 @@ namespace Juliet::D3D12
         d3d12CommandList->GraphicsCommandList.CommandList->OMSetStencilRef(reference);
     }
 
-    void SetIndexBuffer(NonNullPtr<CommandList> commandList, NonNullPtr<GraphicsBuffer> buffer, IndexFormat format)
+    void SetIndexBuffer(NonNullPtr<CommandList> commandList, NonNullPtr<GraphicsBuffer> buffer, IndexFormat format,
+                        size_t indexCount, index_t offset)
     {
         auto* d3d12CommandList = reinterpret_cast<D3D12CommandList*>(commandList.Get());
         auto* d3d12Buffer      = reinterpret_cast<D3D12Buffer*>(buffer.Get());
 
         // Transition to INDEX_BUFFER state if needed
-        if (d3d12Buffer->CurrentState != D3D12_RESOURCE_STATE_INDEX_BUFFER)
+        if (d3d12Buffer->CurrentState != D3D12_RESOURCE_STATE_GENERIC_READ)
         {
             D3D12_RESOURCE_BARRIER barrier = {};
             barrier.Type                   = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
             barrier.Flags                  = D3D12_RESOURCE_BARRIER_FLAG_NONE;
             barrier.Transition.pResource   = d3d12Buffer->Handle;
             barrier.Transition.StateBefore = d3d12Buffer->CurrentState;
-            barrier.Transition.StateAfter  = D3D12_RESOURCE_STATE_INDEX_BUFFER;
+            barrier.Transition.StateAfter =
+                D3D12_RESOURCE_STATE_GENERIC_READ; // Since we use a mega buffer we use the generic read that includes D3D12_RESOURCE_STATE_INDEX_BUFFER
             barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
 
             d3d12CommandList->GraphicsCommandList.CommandList->ResourceBarrier(1, &barrier);
-            d3d12Buffer->CurrentState = D3D12_RESOURCE_STATE_INDEX_BUFFER;
+            d3d12Buffer->CurrentState = D3D12_RESOURCE_STATE_GENERIC_READ;
         }
 
         D3D12_INDEX_BUFFER_VIEW ibView;
-        ibView.BufferLocation = d3d12Buffer->Handle->GetGPUVirtualAddress();
-        ibView.SizeInBytes    = static_cast<UINT>(d3d12Buffer->Size);
-        ibView.Format         = (format == IndexFormat::UInt16) ? DXGI_FORMAT_R16_UINT : DXGI_FORMAT_R32_UINT;
+        ibView.BufferLocation = d3d12Buffer->Handle->GetGPUVirtualAddress() + offset;
+        if (format == IndexFormat::UInt16)
+        {
+            ibView.SizeInBytes = static_cast<UINT>(indexCount * sizeof(uint16));
+            ibView.Format      = DXGI_FORMAT_R16_UINT;
+        }
+        else
+        {
+            ibView.SizeInBytes = static_cast<UINT>(indexCount * sizeof(uint32));
+            ibView.Format      = DXGI_FORMAT_R32_UINT;
+        }
 
         d3d12CommandList->GraphicsCommandList.CommandList->IASetIndexBuffer(&ibView);
     }
@@ -454,8 +473,11 @@ namespace Juliet::D3D12
                 return false;
             }
 
-            ReturnSamplerHeapToPool(driver, commandList->Sampler_Heap);
-            commandList->Sampler_Heap     = nullptr;
+            if (commandList->Sampler_Heap) [[likely]]
+            {
+                ReturnSamplerHeapToPool(driver, commandList->Sampler_Heap);
+                commandList->Sampler_Heap = nullptr;
+            }
             commandList->CRB_SRV_UAV_Heap = nullptr;
 
             // Clean up resource tracking
@@ -474,7 +496,8 @@ namespace Juliet::D3D12
             // Release Fence if needed
             if (commandList->AutoReleaseFence)
             {
-                ReleaseFence(driver.Get(), reinterpret_cast<Fence*>(commandList->InFlightFence));
+                ReleaseFence(driver.Get(), reinterpret_cast<Fence*>(commandList->InFlightFence)
+                                               JULIET_DEBUG_PARAM(ConstString("CleanCommandList")));
                 commandList->InFlightFence = nullptr;
             }
 
@@ -497,6 +520,7 @@ namespace Juliet::D3D12
                     {
                         driver->SubmittedCommandLists[idx] = driver->SubmittedCommandLists[driver->SubmittedCommandListCount - 1];
                         driver->SubmittedCommandListCount -= 1;
+                        break;
                     }
                 }
             }

Juliet/src/Graphics/D3D12/D3D12CommandList.h

@@ -97,7 +97,8 @@ namespace Juliet::D3D12
     extern void         SetBlendConstants(NonNullPtr<CommandList> commandList, FColor blendConstants);
     extern void         SetBlendConstants(NonNullPtr<CommandList> commandList, FColor blendConstants);
     extern void         SetStencilReference(NonNullPtr<CommandList> commandList, uint8 reference);
-    extern void SetIndexBuffer(NonNullPtr<CommandList> commandList, NonNullPtr<GraphicsBuffer> buffer, IndexFormat format);
+    extern void         SetIndexBuffer(NonNullPtr<CommandList> commandList, NonNullPtr<GraphicsBuffer> buffer,
+                                       IndexFormat format, size_t indexCount, index_t offset);
     extern void SetPushConstants(NonNullPtr<CommandList> commandList, ShaderStage stage, uint32 rootParameterIndex,
                                  uint32 numConstants, const void* constants);
 

Juliet/src/Graphics/D3D12/D3D12Common.cpp

@@ -4,8 +4,8 @@
 #include <Graphics/D3D12/D3D12Common.h>
 #include <Graphics/D3D12/D3D12GraphicsDevice.h>
 #include <Graphics/D3D12/D3D12Includes.h>
-#include <Graphics/D3D12/D3D12Utils.h>
 
+// TODO: Convert the whole file to memory arenas
 namespace Juliet::D3D12::Internal
 {
     namespace
@@ -25,8 +25,8 @@ namespace Juliet::D3D12::Internal
 
         bool ExtendStagingDescriptorPool(NonNullPtr<D3D12Driver> driver, D3D12StagingDescriptorPool& pool)
         {
-            D3D12DescriptorHeap* heap =
-                Internal::CreateDescriptorHeap(driver, pool.Heaps[0]->HeapType, kStagingHeapDescriptorExpectedCount, true);
+            D3D12DescriptorHeap* heap = Internal::CreateDescriptorHeap(driver, pool.Arena, pool.Heaps[0]->HeapType,
+                                                                       kStagingHeapDescriptorExpectedCount, true);
             if (!heap)
             {
                 return false;
@@ -49,13 +49,17 @@ namespace Juliet::D3D12::Internal
 
     D3D12StagingDescriptorPool* CreateStagingDescriptorPool(NonNullPtr<D3D12Driver> driver, D3D12_DESCRIPTOR_HEAP_TYPE type)
     {
-        D3D12DescriptorHeap* heap = CreateDescriptorHeap(driver, type, kStagingHeapDescriptorExpectedCount, true);
+        Arena* arena = ArenaAllocate({} JULIET_DEBUG_ONLY(, "Staging Descriptors"));
+
+        D3D12DescriptorHeap* heap = CreateDescriptorHeap(driver, arena, type, kStagingHeapDescriptorExpectedCount, true);
         if (!heap)
         {
+            ArenaRelease(arena);
             return nullptr;
         }
 
-        auto pool = static_cast<D3D12StagingDescriptorPool*>(Calloc(1, sizeof(D3D12StagingDescriptorPool)));
+        auto pool   = static_cast<D3D12StagingDescriptorPool*>(Calloc(1, sizeof(D3D12StagingDescriptorPool)));
+        pool->Arena = arena;
 
         // First create the heaps
         pool->HeapCount = 1;
@@ -113,6 +117,8 @@ namespace Juliet::D3D12::Internal
 
         Free(pool->Heaps);
         Free(pool->FreeDescriptors);
+
+        ArenaRelease(pool->Arena);
         Free(pool.Get());
     }
 } // namespace Juliet::D3D12::Internal

Juliet/src/Graphics/D3D12/D3D12Common.h

@@ -22,8 +22,9 @@ namespace Juliet::D3D12
 
     struct D3D12StagingDescriptorPool
     {
+        Arena*                          Arena;
         Internal::D3D12DescriptorHeap** Heaps;
-        uint32                HeapCount;
+        uint32                          HeapCount;
 
         // Descriptor handles are owned by resources, so these can be thought of as descriptions of a free index within a heap.
         uint32                  FreeDescriptorCapacity;
@@ -35,9 +36,9 @@ namespace Juliet::D3D12
     struct D3D12StagingDescriptor
     {
         D3D12StagingDescriptorPool*    Pool;
-        Internal::D3D12DescriptorHeap*        Heap;
-        D3D12_CPU_DESCRIPTOR_HANDLE CpuHandle;
-        uint32                      CpuHandleIndex;
+        Internal::D3D12DescriptorHeap* Heap;
+        D3D12_CPU_DESCRIPTOR_HANDLE    CpuHandle;
+        uint32                         CpuHandleIndex;
     };
 
     namespace Internal

Juliet/src/Graphics/D3D12/D3D12DescriptorHeap.cpp

@@ -1,26 +1,52 @@
 #include <Core/Logging/LogManager.h>
 #include <Core/Logging/LogTypes.h>
 #include <Core/Memory/Allocator.h>
-#include <Core/Memory/EngineArena.h>
 #include <Graphics/D3D12/D3D12DescriptorHeap.h>
 #include <Graphics/D3D12/D3D12GraphicsDevice.h>
 #include <Graphics/D3D12/D3D12Utils.h>
 
 namespace Juliet::D3D12::Internal
 {
-    D3D12DescriptorHeap* CreateDescriptorHeap(NonNullPtr<D3D12Driver> driver, D3D12_DESCRIPTOR_HEAP_TYPE type, uint32 count, bool isStaging)
+    void CreateDescriptorHeapPool(NonNullPtr<D3D12Driver> driver, D3D12DescriptorHeapPool& heapPool,
+                                  D3D12_DESCRIPTOR_HEAP_TYPE type, uint32 count)
     {
-        auto heap = ArenaPushType<D3D12DescriptorHeap>(GetEngineArena(), ConstString("D3D12DescriptorHeap"));
-        if (!heap)
+        // Heap pool is just single linked list of free elements
+        constexpr size_t kInitialCapacity = 4;
+        heapPool.Arena                    = ArenaAllocate({} JULIET_DEBUG_ONLY(, "Descriptor Heap Pool"));
+        heapPool.FirstFreeDescriptorHeap  = nullptr;
+
+        // Pre allocate 4
+        for (uint32 i = 0; i < kInitialCapacity; ++i)
         {
-            return nullptr;
+            D3D12DescriptorHeap* descriptorHeap = CreateDescriptorHeap(driver, heapPool.Arena, type, count, false);
+            descriptorHeap->Next                = heapPool.FirstFreeDescriptorHeap;
+            heapPool.FirstFreeDescriptorHeap    = descriptorHeap;
         }
+    }
+
+    void DestroyDescriptorHeapPool(D3D12DescriptorHeapPool& heapPool)
+    {
+        D3D12DescriptorHeap* current = heapPool.FirstFreeDescriptorHeap;
+        while (current != nullptr)
+        {
+            D3D12DescriptorHeap* next = current->Next;
+            DestroyDescriptorHeap(current);
+            current = next;
+        }
+        ArenaRelease(heapPool.Arena);
+    }
+
+    D3D12DescriptorHeap* CreateDescriptorHeap(NonNullPtr<D3D12Driver> driver, NonNullPtr<Arena> arena,
+                                              D3D12_DESCRIPTOR_HEAP_TYPE type, uint32 count, bool isStaging)
+    {
+        D3D12DescriptorHeap* heap = ArenaPushStruct<D3D12DescriptorHeap>(arena.Get());
+        Assert(heap);
 
         heap->CurrentDescriptorIndex = 0;
-        heap->FreeIndicesCapacity    = 16;
-        heap->FreeIndicesCount       = 0;
-        heap->FreeIndices            = ArenaPushArray<uint32>(GetEngineArena(), heap->FreeIndicesCapacity,
-                                                              ConstString("D3D12DescriptorHeap/FreeIndices"));
+
+        heap->FreeIndices.Create(arena JULIET_DEBUG_PARAM("DescriptorHeap Free Indices"));
+        heap->FreeIndices.Resize(16);
+        heap->CurrentFreeIndex = 0;
 
         D3D12_DESCRIPTOR_HEAP_DESC heapDesc;
         heapDesc.NumDescriptors = count;
@@ -54,23 +80,21 @@ namespace Juliet::D3D12::Internal
 
     void DestroyDescriptorHeap(NonNullPtr<D3D12DescriptorHeap> heap)
     {
+        heap->FreeIndices.Destroy();
         if (heap->Handle)
         {
             heap->Handle->Release();
         }
-        // TODO: should not free because its on an arena, but need to use arena properly
-        // SafeFree(heap->FreeIndices);
-        // Free(heap.Get());
     }
 
     bool AssignDescriptor(D3D12DescriptorHeap* heap, D3D12Descriptor& outDescriptor)
     {
         uint32 index = UINT32_MAX;
 
-        if (heap->FreeIndicesCount > 0)
+        if (heap->CurrentFreeIndex > 0)
         {
-            heap->FreeIndicesCount -= 1;
-            index = heap->FreeIndices[heap->FreeIndicesCount];
+            heap->CurrentFreeIndex -= 1;
+            index = heap->FreeIndices[heap->CurrentFreeIndex];
         }
         else if (heap->CurrentDescriptorIndex < heap->MaxDescriptors)
         {
@@ -102,55 +126,42 @@ namespace Juliet::D3D12::Internal
 
         D3D12DescriptorHeap* heap = descriptor.Heap;
 
-        if (heap->FreeIndicesCount >= heap->FreeIndicesCapacity)
+        if (heap->CurrentFreeIndex >= heap->FreeIndices.Count)
         {
-            size_t oldCapacity = heap->FreeIndicesCapacity;
-            heap->FreeIndicesCapacity *= 2;
-            heap->FreeIndices = ArenaRealloc<uint32>(GetEngineArena(), heap->FreeIndices, oldCapacity,
-                                                     heap->FreeIndicesCapacity, ConstString("FreeIndices"));
-        }
-
-        heap->FreeIndices[heap->FreeIndicesCount] = descriptor.Index;
-        heap->FreeIndicesCount++;
-    }
-
-    D3D12DescriptorHeap* AcquireSamplerHeapFromPool(NonNullPtr<D3D12Driver> d3d12Driver, DescriptorHeapCreator creator)
-    {
-        D3D12DescriptorHeap*     result;
-        D3D12DescriptorHeapPool* pool = &d3d12Driver->SamplerHeapPool;
-
-        if (pool->Count > 0)
-        {
-            result = pool->Heaps[pool->Count - 1];
-            pool->Count -= 1;
+            heap->FreeIndices.PushBack(descriptor.Index);
         }
         else
         {
-            result = creator(d3d12Driver, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER, GPUDriver::kSampler_HeapDescriptorCount, false);
+            heap->FreeIndices[heap->CurrentFreeIndex] = descriptor.Index;
+            heap->CurrentFreeIndex++;
+        }
+    }
+
+    D3D12DescriptorHeap* AcquireSamplerHeapFromPool(NonNullPtr<D3D12Driver> d3d12Driver)
+    {
+        D3D12DescriptorHeapPool& pool = d3d12Driver->SamplerHeapPool;
+
+        D3D12DescriptorHeap* result = pool.FirstFreeDescriptorHeap;
+        if (result)
+        {
+            pool.FirstFreeDescriptorHeap = pool.FirstFreeDescriptorHeap->Next;
+        }
+        else
+        {
+            result = CreateDescriptorHeap(d3d12Driver, pool.Arena, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER,
+                                          GPUDriver::kSampler_HeapDescriptorCount, false);
         }
 
         return result;
     }
 
-    void ReturnSamplerHeapToPool(NonNullPtr<D3D12Driver> d3d12Driver, D3D12DescriptorHeap* heap)
+    void ReturnSamplerHeapToPool(NonNullPtr<D3D12Driver> d3d12Driver, NonNullPtr<D3D12DescriptorHeap> heap)
     {
-        if (heap == nullptr)
-        {
-            return;
-        }
-
-        D3D12DescriptorHeapPool* pool = &d3d12Driver->SamplerHeapPool;
+        D3D12DescriptorHeapPool& pool = d3d12Driver->SamplerHeapPool;
 
         heap->CurrentDescriptorIndex = 0;
 
-        if (pool->Count >= pool->Capacity)
-        {
-            size_t oldCapacity = pool->Capacity;
-            pool->Capacity *= 2;
-            pool->Heaps = ArenaRealloc(GetEngineArena(), pool->Heaps, oldCapacity, pool->Capacity, ConstString("Heaps"));
-        }
-
-        pool->Heaps[pool->Count] = heap;
-        pool->Count += 1;
+        heap->Next                   = pool.FirstFreeDescriptorHeap;
+        pool.FirstFreeDescriptorHeap = heap;
     }
 } // namespace Juliet::D3D12::Internal

Juliet/src/Graphics/D3D12/D3D12DescriptorHeap.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <Core/Common/NonNullPtr.h>
+#include <Core/Networking/NetworkPacket.h>
 #include <Graphics/D3D12/D3D12Includes.h>
 
 // Forward declare
@@ -14,6 +15,7 @@ namespace Juliet::D3D12::Internal
     // https://learn.microsoft.com/en-us/windows/win32/direct3d12/descriptor-heaps
     struct D3D12DescriptorHeap
     {
+        D3D12DescriptorHeap*        Next;
         ID3D12DescriptorHeap*       Handle;
         D3D12_DESCRIPTOR_HEAP_TYPE  HeapType;
         D3D12_CPU_DESCRIPTOR_HANDLE DescriptorHeapCPUStart;
@@ -22,11 +24,10 @@ namespace Juliet::D3D12::Internal
         uint32                      DescriptorSize;
         uint32                      CurrentDescriptorIndex; // only used by GPU heaps
 
-        uint32*                     FreeIndices;
-        uint32                      FreeIndicesCapacity;
-        uint32                      FreeIndicesCount;
+        VectorArena<uint32> FreeIndices;
+        index_t             CurrentFreeIndex;
 
-        bool                        Staging : 1;
+        bool Staging : 1;
     };
 
     struct D3D12Descriptor
@@ -39,20 +40,24 @@ namespace Juliet::D3D12::Internal
 
     struct D3D12DescriptorHeapPool
     {
-        D3D12DescriptorHeap** Heaps;
-        size_t                Capacity;
-        size_t                Count;
+        Arena*               Arena;
+        D3D12DescriptorHeap* FirstFreeDescriptorHeap;
     };
 
-    using DescriptorHeapCreator = D3D12DescriptorHeap* (*)(NonNullPtr<D3D12Driver>, D3D12_DESCRIPTOR_HEAP_TYPE, uint32, bool);
+    using DescriptorHeapCreator = D3D12DescriptorHeap* (*)(NonNullPtr<D3D12Driver>, D3D12DescriptorHeapPool& heapPool,
+                                                           D3D12_DESCRIPTOR_HEAP_TYPE, uint32, bool);
 
-    extern D3D12DescriptorHeap* CreateDescriptorHeap(NonNullPtr<D3D12Driver>    driver,
-                                                 D3D12_DESCRIPTOR_HEAP_TYPE type, uint32 count, bool isStaging);
+    extern void CreateDescriptorHeapPool(NonNullPtr<D3D12Driver> driver, D3D12DescriptorHeapPool& heapPool,
+                                         D3D12_DESCRIPTOR_HEAP_TYPE type, uint32 count);
+    extern void DestroyDescriptorHeapPool(D3D12DescriptorHeapPool& pool);
+
+    extern D3D12DescriptorHeap* CreateDescriptorHeap(NonNullPtr<D3D12Driver> driver, NonNullPtr<Arena> arena,
+                                                     D3D12_DESCRIPTOR_HEAP_TYPE type, uint32 count, bool isStaging);
     extern void                 DestroyDescriptorHeap(NonNullPtr<D3D12DescriptorHeap> heap);
 
-    extern D3D12DescriptorHeap* AcquireSamplerHeapFromPool(NonNullPtr<D3D12Driver> d3d12Driver, DescriptorHeapCreator creator = CreateDescriptorHeap);
-    extern void                 ReturnSamplerHeapToPool(NonNullPtr<D3D12Driver> d3d12Driver, D3D12DescriptorHeap* heap);
+    extern D3D12DescriptorHeap* AcquireSamplerHeapFromPool(NonNullPtr<D3D12Driver> d3d12Driver);
+    extern void ReturnSamplerHeapToPool(NonNullPtr<D3D12Driver> d3d12Driver, NonNullPtr<D3D12DescriptorHeap> heap);
 
     extern bool AssignDescriptor(D3D12DescriptorHeap* heap, D3D12Descriptor& outDescriptor);
     extern void ReleaseDescriptor(const D3D12Descriptor& descriptor);
-} // namespace Juliet::D3D12
+} // namespace Juliet::D3D12::Internal

Juliet/src/Graphics/D3D12/D3D12GraphicsDevice.cpp

@@ -3,7 +3,6 @@
 #include <Core/Logging/LogManager.h>
 #include <Core/Logging/LogTypes.h>
 #include <Core/Memory/Allocator.h>
-#include <Core/Memory/EngineArena.h>
 #include <Graphics/D3D12/D3D12Buffer.h>
 #include <Graphics/D3D12/D3D12CommandList.h>
 #include <Graphics/D3D12/D3D12DescriptorHeap.h>
@@ -24,12 +23,6 @@
 #define D3D12_CREATEDEVICE_FUNC "D3D12CreateDevice"
 #define D3D12_SERIALIZE_VERSIONED_ROOT_SIGNATURE_FUNC "D3D12SerializeVersionedRootSignature"
 
-extern "C" {
-// Used to enable the "Agility SDK" components
-__declspec(dllexport) extern const unsigned int D3D12SDKVersion = 615;
-__declspec(dllexport) extern const char*        D3D12SDKPath    = ".\\D3D12\\";
-}
-
 // TODO : Use LoadLibrary and not link to the lib. Allows failing earlier if Dx12 is not installed for some reason
 // + Will load the dll when needed
 // This will prevent us from using IID_ variables as they are defined in dxguid.lib
@@ -471,22 +464,7 @@ namespace Juliet::D3D12
                 }
             }
 
-            auto DestroyDescriptorHeapPool = [](Internal::D3D12DescriptorHeapPool& heapPool)
-            {
-                if (heapPool.Heaps)
-                {
-                    for (uint32 i = 0; i < heapPool.Count; ++i)
-                    {
-                        if (heapPool.Heaps[i])
-                        {
-                            Internal::DestroyDescriptorHeap(heapPool.Heaps[i]);
-                            heapPool.Heaps[i] = nullptr;
-                        }
-                    }
-                    // SafeFree(heapPool.Heaps); // Allocated with Arena, do not free.
-                }
-            };
-            DestroyDescriptorHeapPool(driver->SamplerHeapPool);
+            Internal::DestroyDescriptorHeapPool(driver->SamplerHeapPool);
 
             // Release command buffers
             for (uint32 i = 0; i < driver->AvailableCommandListCount; i += 1)
@@ -571,6 +549,7 @@ namespace Juliet::D3D12
 
             driver->D3D12SerializeVersionedRootSignatureFct = nullptr;
 
+            ArenaRelease(driver->DriverArena);
             Free(driver.Get());
         }
 
@@ -619,7 +598,8 @@ namespace Juliet::D3D12
             {
                 if (windowData->InFlightFences[idx] != nullptr)
                 {
-                    ReleaseFence(driver, windowData->InFlightFences[idx]);
+                    ReleaseFence(driver,
+                                 windowData->InFlightFences[idx] JULIET_DEBUG_PARAM(ConstString("DeatchFromWindow")));
                     windowData->InFlightFences[idx] = nullptr;
                 }
             }
@@ -638,27 +618,6 @@ namespace Juliet::D3D12
             Free(device.Get());
         }
 
-        // Note: SetViewPort, SetScissorRect, SetBlendConstants, SetStencilReference
-        // are defined in D3D12CommandList.cpp and used directly via D3D12:: namespace
-
-        // BindGraphicsPipeline is now assigned directly from D3D12:: namespace
-
-        // DrawPrimitives is now assigned directly from D3D12:: namespace
-
-        void DrawIndexedPrimitives(NonNullPtr<CommandList> commandList, uint32 numIndices, uint32 numInstances,
-                                   uint32 firstIndex, uint32 vertexOffset, uint32 firstInstance)
-        {
-            auto* d3d12CommandList = reinterpret_cast<D3D12CommandList*>(commandList.Get());
-            d3d12CommandList->GraphicsCommandList.CommandList->DrawIndexedInstanced(numIndices, numInstances, firstIndex,
-                                                                                    static_cast<INT>(vertexOffset), firstInstance);
-        }
-
-        // WaitUntilGPUIsIdle, SetPushConstants are now assigned directly from D3D12:: namespace
-
-        // QueryFence, ReleaseFence, CreateShader, DestroyShader are now assigned directly from D3D12:: namespace
-
-        // CreateGraphicsPipeline is assigned directly from D3D12:: namespace
-
         void DestroyGraphicsPipeline(NonNullPtr<GPUDriver> driver, NonNullPtr<GraphicsPipeline> pipeline)
         {
             auto* d3d12Driver = static_cast<D3D12Driver*>(driver.Get());
@@ -671,8 +630,6 @@ namespace Juliet::D3D12
             }
         }
 
-        // Buffer functions are assigned directly from D3D12:: namespace
-
         void CopyBufferToTexture(NonNullPtr<CommandList> commandList, NonNullPtr<Texture> dst, NonNullPtr<GraphicsTransferBuffer> src)
         {
             auto* d3d12CommandList      = reinterpret_cast<D3D12CommandList*>(commandList.Get());
@@ -718,14 +675,12 @@ namespace Juliet::D3D12
             Internal::TextureTransitionToDefaultUsage(d3d12CommandList, d3d12Texture, D3D12_RESOURCE_STATE_COPY_DEST);
         }
 
-        // GetDescriptorIndex wrapper needed to adapt signature from GPUDriver* to GraphicsDevice*
         uint32 GetDescriptorIndex(NonNullPtr<GraphicsDevice> device, NonNullPtr<GraphicsBuffer> buffer)
         {
             auto* driver = static_cast<D3D12Driver*>(device->Driver);
             return D3D12::GetDescriptorIndex(driver, buffer);
         }
 
-        // GetDescriptorIndexTexture provides custom logic to get SRV handle index
         uint32 GetDescriptorIndexTexture(NonNullPtr<GraphicsDevice> /*device*/, NonNullPtr<Texture> texture)
         {
             auto* textureContainer = reinterpret_cast<D3D12TextureContainer*>(texture.Get());
@@ -745,6 +700,9 @@ namespace Juliet::D3D12
         {
             auto driver = static_cast<D3D12Driver*>(Calloc(1, sizeof(D3D12Driver)));
 
+            // TODO : Convert everything to arena
+            driver->DriverArena = ArenaAllocate({} JULIET_DEBUG_ONLY(, "D3D12 Driver"));
+
 #if JULIET_DEBUG
 #ifdef IDXGIINFOQUEUE_SUPPORTED
             if (enableDebug)
@@ -1023,32 +981,8 @@ namespace Juliet::D3D12
                 }
             }
 
-            // Other Descriptor pools
-            auto CreateDescriptorPool = [&](Internal::D3D12DescriptorHeapPool& heapPool,
-                                            D3D12_DESCRIPTOR_HEAP_TYPE type, uint32 count) -> bool
-            {
-                heapPool.Capacity = 4;
-                heapPool.Count    = 4;
-                heapPool.Heaps    = ArenaPushArray<Internal::D3D12DescriptorHeap*>(GetEngineArena(), heapPool.Capacity,
-                                                                                   ConstString("DescriptorHeap"));
-
-                for (uint32 i = 0; i < heapPool.Capacity; ++i)
-                {
-                    heapPool.Heaps[i] = Internal::CreateDescriptorHeap(driver, type, count, false);
-
-                    if (heapPool.Heaps[i] == nullptr)
-                    {
-                        return false;
-                    }
-                }
-                return true;
-            };
-
-            if (!CreateDescriptorPool(driver->SamplerHeapPool, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER, GPUDriver::kSampler_HeapDescriptorCount))
-            {
-                DestroyDriver_Internal(driver);
-                return nullptr;
-            }
+            CreateDescriptorHeapPool(driver, driver->SamplerHeapPool, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER,
+                                     GPUDriver::kSampler_HeapDescriptorCount);
 
             // Deferred dispose vectors
             driver->GraphicsPipelinesToDisposeCapacity = 4;
@@ -1078,42 +1012,41 @@ namespace Juliet::D3D12
             device->AcquireSwapChainTexture        = AcquireSwapChainTexture;
             device->WaitAndAcquireSwapChainTexture = WaitAndAcquireSwapChainTexture;
             device->GetSwapChainTextureFormat      = GetSwapChainTextureFormat;
-            device->AcquireCommandList             = D3D12::AcquireCommandList;
-            device->SubmitCommandLists             = D3D12::SubmitCommandLists;
-
-            device->BeginRenderPass       = D3D12::BeginRenderPass;
-            device->EndRenderPass         = D3D12::EndRenderPass;
-            device->SetViewPort           = D3D12::SetViewPort;
-            device->SetScissorRect        = D3D12::SetScissorRect;
-            device->SetBlendConstants     = D3D12::SetBlendConstants;
-            device->SetStencilReference   = D3D12::SetStencilReference;
-            device->BindGraphicsPipeline  = D3D12::BindGraphicsPipeline;
-            device->DrawPrimitives        = D3D12::DrawPrimitives;
-            device->DrawIndexedPrimitives = DrawIndexedPrimitives;
-            device->SetIndexBuffer        = D3D12::SetIndexBuffer;
-            device->WaitUntilGPUIsIdle    = D3D12::WaitUntilGPUIsIdle;
-
-            device->SetPushConstants              = D3D12::SetPushConstants;
-            device->QueryFence                    = D3D12::QueryFence;
-            device->ReleaseFence                  = D3D12::ReleaseFence;
-            device->CreateShader                  = D3D12::CreateShader;
-            device->DestroyShader                 = D3D12::DestroyShader;
-            device->CreateGraphicsPipeline        = D3D12::CreateGraphicsPipeline;
-            device->DestroyGraphicsPipeline       = DestroyGraphicsPipeline;
-            device->CreateGraphicsBuffer          = D3D12::CreateGraphicsBuffer;
-            device->DestroyGraphicsBuffer         = D3D12::DestroyGraphicsBuffer;
-            device->CreateGraphicsTransferBuffer  = D3D12::CreateGraphicsTransferBuffer;
-            device->DestroyGraphicsTransferBuffer = D3D12::DestroyGraphicsTransferBuffer;
-            device->MapGraphicsTransferBuffer     = D3D12::MapBuffer;
-            device->UnmapGraphicsTransferBuffer   = D3D12::UnmapBuffer;
-            device->CopyBuffer                    = CopyBuffer;
-            device->CopyBufferToTexture           = CopyBufferToTexture;
-            device->TransitionBufferToReadable    = D3D12::TransitionBufferToReadable;
-
-            device->GetDescriptorIndex        = GetDescriptorIndex;
-            device->GetDescriptorIndexTexture = GetDescriptorIndexTexture;
-            device->CreateTexture             = D3D12::CreateTexture;
-            device->DestroyTexture            = D3D12::DestroyTexture;
+            device->AcquireCommandList             = AcquireCommandList;
+            device->SubmitCommandLists             = SubmitCommandLists;
+            device->BeginRenderPass                = BeginRenderPass;
+            device->EndRenderPass                  = EndRenderPass;
+            device->SetViewPort                    = SetViewPort;
+            device->SetScissorRect                 = SetScissorRect;
+            device->SetBlendConstants              = SetBlendConstants;
+            device->SetStencilReference            = SetStencilReference;
+            device->BindGraphicsPipeline           = BindGraphicsPipeline;
+            device->DrawPrimitives                 = DrawPrimitives;
+            device->DrawIndexedPrimitives          = DrawIndexedPrimitives;
+            device->SetIndexBuffer                 = SetIndexBuffer;
+            device->WaitUntilGPUIsIdle             = WaitUntilGPUIsIdle;
+            device->SetPushConstants               = SetPushConstants;
+            device->QueryFence                     = QueryFence;
+            device->ReleaseFence                   = ReleaseFence;
+            device->CreateShader                   = CreateShader;
+            device->DestroyShader                  = DestroyShader;
+            device->CreateGraphicsPipeline         = CreateGraphicsPipeline;
+            device->DestroyGraphicsPipeline        = DestroyGraphicsPipeline;
+            device->CreateGraphicsBuffer         = CreateGraphicsBuffer;
+            device->DestroyGraphicsBuffer        = DestroyGraphicsBuffer;
+            device->MapGraphicsBuffer            = MapBuffer;
+            device->UnmapGraphicsBuffer          = UnmapBuffer;
+            device->CreateGraphicsTransferBuffer   = CreateGraphicsTransferBuffer;
+            device->DestroyGraphicsTransferBuffer  = DestroyGraphicsTransferBuffer;
+            device->MapGraphicsTransferBuffer      = MapBuffer;
+            device->UnmapGraphicsTransferBuffer    = UnmapBuffer;
+            device->CopyBuffer                     = CopyBuffer;
+            device->CopyBufferToTexture            = CopyBufferToTexture;
+            device->TransitionBufferToReadable     = TransitionBufferToReadable;
+            device->GetDescriptorIndex             = GetDescriptorIndex;
+            device->GetDescriptorIndexTexture      = GetDescriptorIndexTexture;
+            device->CreateTexture                  = CreateTexture;
+            device->DestroyTexture                 = DestroyTexture;
 
 #if ALLOW_SHADER_HOT_RELOAD
             device->UpdateGraphicsPipelineShaders = UpdateGraphicsPipelineShaders;
@@ -1125,8 +1058,9 @@ namespace Juliet::D3D12
             driver->GraphicsDevice = device;
 
             // Create Global Bindless Heap that stays alive for the driver whole lifetime
-            driver->BindlessDescriptorHeap = Internal::CreateDescriptorHeap(driver, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV,
-                                                                            GPUDriver::kCBV_SRV_UAV_HeapDescriptorCount, false);
+            driver->BindlessDescriptorHeap =
+                Internal::CreateDescriptorHeap(driver, driver->DriverArena, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV,
+                                               GPUDriver::kCBV_SRV_UAV_HeapDescriptorCount, false);
 
             return device;
         }

Juliet/src/Graphics/D3D12/D3D12RenderPass.cpp

@@ -283,4 +283,12 @@ namespace Juliet::D3D12
 
         d3d12CommandList->GraphicsCommandList.CommandList->DrawInstanced(numVertices, numInstances, firstVertex, firstInstance);
     }
+
+    void DrawIndexedPrimitives(NonNullPtr<CommandList> commandList, uint32 numIndices, uint32 numInstances,
+                               uint32 firstIndex, uint32 vertexOffset, uint32 firstInstance)
+    {
+        auto* d3d12CommandList = reinterpret_cast<D3D12CommandList*>(commandList.Get());
+        d3d12CommandList->GraphicsCommandList.CommandList->DrawIndexedInstanced(numIndices, numInstances, firstIndex,
+                                                                                static_cast<INT>(vertexOffset), firstInstance);
+    }
 } // namespace Juliet::D3D12

Juliet/src/Graphics/D3D12/D3D12RenderPass.h

@@ -13,4 +13,6 @@ namespace Juliet::D3D12
     extern void BindGraphicsPipeline(NonNullPtr<CommandList> commandList, NonNullPtr<GraphicsPipeline> graphicsPipeline);
     extern void DrawPrimitives(NonNullPtr<CommandList> commandList, uint32 numVertices, uint32 numInstances,
                                uint32 firstVertex, uint32 firstInstance);
+    void        DrawIndexedPrimitives(NonNullPtr<CommandList> commandList, uint32 numIndices, uint32 numInstances,
+                                      uint32 firstIndex, uint32 vertexOffset, uint32 firstInstance);
 } // namespace Juliet::D3D12

Juliet/src/Graphics/D3D12/D3D12SwapChain.cpp

@@ -140,7 +140,8 @@ namespace Juliet::D3D12
                 {
                     // Wait until the fence for the frame is signaled.
                     // In VSYNC this means waiting that the least recent presented frame is done
-                    if (!Wait(driver, true, &windowData->InFlightFences[windowData->WindowFrameCounter], 1))
+                    if (!Wait(driver, true, &windowData->InFlightFences[windowData->WindowFrameCounter],
+                              1 JULIET_DEBUG_PARAM(ConstString("AcquireSwapChainTexture"))))
                     {
                         return false;
                     }
@@ -155,7 +156,8 @@ namespace Juliet::D3D12
                     }
                 }
 
-                ReleaseFence(driver, windowData->InFlightFences[windowData->WindowFrameCounter]);
+                ReleaseFence(driver, windowData->InFlightFences[windowData->WindowFrameCounter] JULIET_DEBUG_PARAM(
+                                         ConstString("AcquireSwapChainTexture")));
                 windowData->InFlightFences[windowData->WindowFrameCounter] = nullptr;
             }
 
@@ -219,7 +221,8 @@ namespace Juliet::D3D12
 
         if (windowData->InFlightFences[windowData->WindowFrameCounter] != nullptr)
         {
-            if (!Wait(d3d12Driver, true, &windowData->InFlightFences[windowData->WindowFrameCounter], 1))
+            if (!Wait(d3d12Driver, true, &windowData->InFlightFences[windowData->WindowFrameCounter],
+                      1 JULIET_DEBUG_PARAM(ConstString("WaitForSwapchain"))))
             {
                 return false;
             }