Rename: ImageViewManager -> ViewManager

aster/include/aster/core/buffer.h

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: buffer.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once

aster/include/aster/core/config.h

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: config.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once
@@ -15,6 +15,7 @@
 #define VULKAN_HPP_NO_STRUCT_CONSTRUCTORS
 #define VULKAN_HPP_DISABLE_ENHANCED_MODE 1
 #define VULKAN_HPP_NO_EXCEPTIONS 1
+#define VULKAN_HPP_NO_SMART_HANDLE 1
 
 #define VMA_STATIC_VULKAN_FUNCTIONS 0
 #define VMA_DYNAMIC_VULKAN_FUNCTIONS 1

aster/include/aster/core/constants.h

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: constants.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once

aster/include/aster/core/context.h

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: context.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once

aster/include/aster/core/device.h

@@ -1,14 +1,14 @@
 // =============================================
 //  Aster: device.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once
 
 #include "global.h"
 
-#include <EASTL/vector.h>
 #include <EASTL/span.h>
+#include <EASTL/vector.h>
 
 struct QueueAllocation;
 struct Context;
@@ -31,8 +31,8 @@ struct Device final
     vk::PipelineCache m_PipelineCache = nullptr;
     bool m_ValidationEnabled = true;
 
-    template <typename T>
+    template <concepts::VkHandle T>
-    requires vk::isVulkanHandleType<T>::value void SetName(const T &object, cstr name) const;
+    void SetName(const T &object, cstr name) const;
     [[nodiscard]] vk::Queue GetQueue(u32 familyIndex, u32 queueIndex) const;
 
     [[nodiscard]] eastl::vector<u8> DumpPipelineCache() const;
@@ -43,7 +43,8 @@ struct Device final
     Device(const Context *context, PhysicalDevice *physicalDevice, Features *enabledFeatures,
            const eastl::vector<QueueAllocation> &queueAllocations, NameString &&name);
     Device(const Context *context, PhysicalDevice *physicalDevice, Features *enabledFeatures,
-           const eastl::vector<QueueAllocation> &queueAllocations, eastl::span<u8> &&pipelineCacheData, NameString &&name);
+           const eastl::vector<QueueAllocation> &queueAllocations, eastl::span<u8> &&pipelineCacheData,
+           NameString &&name);
     ~Device();
 
     // Move
@@ -53,8 +54,8 @@ struct Device final
     DISALLOW_COPY_AND_ASSIGN(Device);
 };
 
-template <typename T>
+template <concepts::VkHandle T>
-requires vk::isVulkanHandleType<T>::value void
+void
 Device::SetName(const T &object, cstr name) const
 {
     if (!m_ValidationEnabled || !name || !object)

aster/include/aster/core/global.h

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: global.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once
@@ -27,8 +27,8 @@
 #define VULKAN_HPP_ASSERT(expr) DEBUG_IF(!(expr), "Vulkan assert failed")
 #endif
 
-#include "type_traits.h"
 #include "EASTL/intrusive_ptr.h"
+#include "type_traits.h"
 
 #include <EASTL/fixed_string.h>
 #include <EASTL/string.h>
@@ -61,6 +61,12 @@ Failed(const vk::Result result)
     return result != vk::Result::eSuccess;
 }
 
+namespace concepts
+{
+template <typename T>
+concept VkHandle = vk::isVulkanHandleType<T>::value;
+}
+
 using NameString = eastl::fixed_string<char, 32, false>;
 
 template <typename TFlagBits>

aster/include/aster/core/image.h

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: image.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once
@@ -119,7 +119,7 @@ struct Image
 namespace concepts
 {
 template <typename T>
-concept Image = std::derived_from<T, ::Image> and Manageable<T>;
+concept Image = std::derived_from<T, Image> and Manageable<T>;
 
 template <typename T>
 concept ImageRef = Derefencable<T> and Image<DereferencesTo<T>>;

aster/include/aster/core/image_view.h

@@ -8,7 +8,7 @@
 #include "global.h"
 #include "image.h"
 
-template <concepts::Image TImage = Image>
+template <concepts::Image TImage>
 struct View
 {
     using ImageType = TImage;
@@ -69,18 +69,38 @@ struct View
     }
 };
 
-struct ImageView : View<> {};
+struct ImageView : View<Image>
-struct ImageCubeView : View<ImageCube> {};
+{
-struct TextureView : View<Texture> {};
+};
-struct TextureCubeView : View<TextureCube> {};
+
-struct StorageImageView : View<StorageImage> {};
+struct ImageCubeView : View<ImageCube>
-struct StorageTextureView : View<StorageTexture> {};
+{
-struct StorageTextureCubeView : View<StorageTextureCube> {};
+};
+
+struct TextureView : View<Texture>
+{
+};
+
+struct TextureCubeView : View<TextureCube>
+{
+};
+
+struct StorageImageView : View<StorageImage>
+{
+};
+
+struct StorageTextureView : View<StorageTexture>
+{
+};
+
+struct StorageTextureCubeView : View<StorageTextureCube>
+{
+};
 
 namespace concepts
 {
 template <typename TView>
-concept View = std::derived_from<TView, ::View<typename TView::ImageType>>;
+concept View = std::derived_from<TView, View<typename TView::ImageType>>;
 
 template <typename T>
 concept ViewRef = Derefencable<T> and View<DereferencesTo<T>>;

aster/include/aster/core/physical_device.h

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: physical_device.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once

aster/include/aster/core/pipeline.h

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: pipeline.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once

aster/include/aster/core/queue_allocation.h

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: queue_allocation.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once

aster/include/aster/core/sampler.h

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: sampler.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once

aster/include/aster/core/size.h

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: size.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once

aster/include/aster/core/surface.h

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: surface.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once

aster/include/aster/core/swapchain.h

@@ -1,6 +1,6 @@
 /// =============================================
 //  Aster: swapchain.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // ==============================================
 
 #pragma once

aster/include/aster/core/type_traits.h

@@ -1,10 +1,12 @@
 // =============================================
 //  Aster: type_traits.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once
 
+#include "constants.h"
+
 struct Device;
 struct Image;
 
@@ -37,6 +39,7 @@ concept SelfDestructible = requires(T a) {
 };
 
 template <typename T>
-concept Manageable = std::is_default_constructible_v<T> and (DeviceDestructible<T> or SelfDestructible<T>) and RefCounted<T>;
+concept Manageable =
+    std::is_default_constructible_v<T> and (DeviceDestructible<T> or SelfDestructible<T>) and RefCounted<T>;
 
 } // namespace concepts

aster/include/aster/core/window.h

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: window.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once

aster/include/aster/systems/CMakeLists.txt

@@ -7,7 +7,7 @@ INTERFACE
 	"manager.h"
 	"buffer_manager.h"
 	"image_manager.h"
-	"image_view_manager.h"
+	"view_manager.h"
 	"sampler_manager.h"
 	"resource.h"
 	"resource_manager.h"

aster/include/aster/systems/buffer_manager.h

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: buffer_manager.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once

aster/include/aster/systems/commit_manager.h

@@ -1,30 +1,27 @@
 // =============================================
 //  Aster: render_resource_manager.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once
 
 #include "aster/aster.h"
 #include "buffer_manager.h"
-#include "image_manager.h"
 #include "sampler_manager.h"
+#include "view_manager.h"
 
-#include "aster/util/intrusive_slist.h"
+#include "aster/util/freelist.h"
 
 #include "EASTL/deque.h"
 #include "EASTL/intrusive_hash_map.h"
-#include "EASTL/bonus/fixed_ring_buffer.h"
 
 #include "resource.h"
-#include "aster/core/image_view.h"
 
 namespace systems
 {
 
 class CommitManager
 {
-  private:
     template <concepts::Manageable T>
     struct HandleMapper
     {
@@ -33,7 +30,7 @@ class CommitManager
         using Handle = typename Manager::Handle;
         using Resource = ResId<Type>;
 
-        struct Entry : public eastl::intrusive_hash_node_key<Handle>
+        struct Entry : eastl::intrusive_hash_node_key<Handle>
         {
             std::atomic<u32> m_CommitCount;
 
@@ -51,7 +48,7 @@ class CommitManager
                 assert(rc < MaxValue<u32>);
             }
 
-            bool
+            u32
             IsReferenced() const
             {
                 return m_CommitCount;
@@ -84,12 +81,13 @@ class CommitManager
                 }
             };
         };
+
         static_assert(sizeof(Entry) == 24);
 
         eastl::vector<Entry> m_Data;
-        IntrusiveStack<Entry> m_FreeList;
+        FreeList<Entry> m_FreeList;
         eastl::intrusive_hash_map<typename Entry::key_type, Entry, 31, typename Entry::Hash> m_InUse;
-        std::array<IntrusiveStack<Entry>, 4> m_ToDelete;
+        std::array<FreeList<Entry>, 4> m_ToDelete;
         u8 m_ToDeleteIndex = 0;
 
         explicit HandleMapper(const u32 maxCount)
@@ -130,7 +128,7 @@ class CommitManager
             Entry &data = m_FreeList.Pop();
 
             data.mKey = object;
-            data.m_CommitCount = 1;
+            data.m_CommitCount = 0;
 
             m_InUse.insert(data);
 
@@ -189,11 +187,11 @@ class CommitManager
         }
 
         void
-        ClearEntries(IntrusiveStack<Entry>& entries)
+        ClearEntries(FreeList<Entry> &entries)
         {
-            while (auto item = entries.TryPop())
+            while (!entries.Empty())
             {
-                Entry &entry = item.value();
+                Entry &entry = entries.Pop();
                 entry.mKey.reset();
                 entry.m_CommitCount = 0;
             }
@@ -227,10 +225,12 @@ class CommitManager
     ResId<Buffer> CommitBuffer(const Ref<Buffer> &buffer);
 
     // Commit Storage Images
-    ResId<StorageImageView> CommitStorageImage(const concepts::StorageImageViewRef auto &image)
+    ResId<StorageImageView>
+    CommitStorageImage(const concepts::StorageImageViewRef auto &image)
     {
         return CommitStorageImage(CastView<StorageImageView>(image));
     }
+
     ResId<StorageImageView> CommitStorageImage(const Ref<StorageImageView> &image);
 
     // Sampled Images
@@ -283,7 +283,8 @@ class CommitManager
         return m_DescriptorSet;
     }
 
-    static CommitManager &Instance()
+    static CommitManager &
+    Instance()
     {
         assert(m_Instance);
         return *m_Instance;
@@ -318,11 +319,13 @@ class CommitManager
     {
         m_Buffers.AddRef(handle);
     }
+
     void
     AddRef(const ResId<TextureView> &handle)
     {
         m_Images.AddRef(handle);
     }
+
     void
     AddRef(const ResId<StorageImageView> &handle)
     {
@@ -334,11 +337,13 @@ class CommitManager
     {
         m_Buffers.Release(handle);
     }
+
     void
     Release(const ResId<TextureView> &handle)
     {
         m_Images.Release(handle);
     }
+
     void
     Release(const ResId<StorageImageView> &handle)
     {

aster/include/aster/systems/image_manager.h

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: image_manager.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once
@@ -57,7 +57,7 @@ struct DepthStencilImageCreateInfo
 class ImageManager final : public Manager<Image>
 {
   public:
-    ImageManager(const Device *device, const u32 maxCount);
+    ImageManager(const Device *device, u32 maxCount);
 
     template <concepts::Image T>
     [[nodiscard]] Ref<T>

aster/include/aster/systems/manager.h

@@ -1,12 +1,13 @@
 // =============================================
 //  Aster: manager.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once
 
 #include "aster/aster.h"
 #include "aster/core/type_traits.h"
+#include "aster/util/freelist.h"
 
 #include <EASTL/intrusive_ptr.h>
 #include <EASTL/vector.h>
@@ -32,10 +33,9 @@ class Manager
         : m_Data{maxCount}
         , m_Device{device}
     {
-        u32 i = 0;
         for (auto &element : m_Data)
         {
-            *Recast<u32 *>(&element) = ++i;
+            m_FreeList.Push(element);
         }
     }
 
@@ -49,7 +49,6 @@ class Manager
             }
         }
 
-        m_FreeHead = 0;
         m_Device = nullptr;
     }
 
@@ -60,11 +59,24 @@ class Manager
     {
         for (i64 i = m_Data.size() - 1; i >= 0; --i)
         {
-            if (auto *pIter = &m_Data[i]; !pIter->IsValid())
+            if (auto *pIter = &m_Data[i]; !pIter->IsReferenced())
             {
                 pIter->Destroy(m_Device);
-                *Recast<u32 *>(pIter) = m_FreeHead;
+                m_FreeList.Push(*pIter);
-                m_FreeHead = i;
+            }
+        }
+    }
+
+    void
+    Sweep()
+        requires concepts::SelfDestructible<Type>
+    {
+        for (i64 i = m_Data.size() - 1; i >= 0; --i)
+        {
+            if (auto *pIter = &m_Data[i]; !pIter->IsValid())
+            {
+                pIter->Destroy();
+                m_FreeList.Push(*pIter);
             }
         }
     }
@@ -73,7 +85,7 @@ class Manager
 
   private:
     eastl::vector<Type> m_Data; // Data also keeps the freelist during 'not use'.
-    u32 m_FreeHead = 0;
+    FreeList<Type> m_FreeList;
 
   protected:
     const Device *m_Device;
@@ -85,17 +97,15 @@ class Manager
     [[nodiscard]] Handle
     Alloc()
     {
-        ERROR_IF(m_FreeHead >= m_Data.size(), "Max buffers allocated.") THEN_ABORT(-1);
+        ERROR_IF(m_FreeList.Empty(), "Max buffers allocated.") THEN_ABORT(-1);
 
-        const auto index = m_FreeHead;
+        Type &pAlloc = m_FreeList.Pop();
-        Type *pAlloc = &m_Data[index];
+        memset(&pAlloc, 0, sizeof pAlloc);
-        m_FreeHead = *Recast<u32 *>(pAlloc);
-        memset(pAlloc, 0, sizeof *pAlloc);
         if constexpr (concepts::SelfDestructible<Type>)
         {
-            pAlloc->m_Device = m_Device;
+            pAlloc.m_Device = m_Device;
         }
-        return {pAlloc};
+        return {&pAlloc};
     }
 };
 } // namespace systems

aster/include/aster/systems/resource.h

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: resource.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once

aster/include/aster/systems/resource_manager.h

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: resource_manager.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once
@@ -9,8 +9,8 @@
 
 #include "buffer_manager.h"
 #include "image_manager.h"
-#include "image_view_manager.h"
 #include "sampler_manager.h"
+#include "view_manager.h"
 
 namespace systems
 {
@@ -20,9 +20,9 @@ class ResourceManager
     struct CombinedImageViewManager
     {
         ImageManager *m_ImageManager;
-        ImageViewManager *m_ViewManager;
+        ViewManager *m_ViewManager;
 
-        CombinedImageViewManager(ImageManager *imageManager, ImageViewManager *viewManager)
+        CombinedImageViewManager(ImageManager *imageManager, ViewManager *viewManager)
             : m_ImageManager{imageManager}
             , m_ViewManager{viewManager}
         {
@@ -44,7 +44,8 @@ class ResourceManager
             return CastView<T>(handle);
         }
 
-        [[nodiscard]] Ref<TextureView> CreateTexture2D(const Texture2DCreateInfo &createInfo) const
+        [[nodiscard]] Ref<TextureView>
+        CreateTexture2D(const Texture2DCreateInfo &createInfo) const
         {
             return m_ViewManager->CreateView<TextureView>({
                 .m_Image = CastImage<Texture>(m_ImageManager->CreateTexture2D(createInfo)),
@@ -53,7 +54,9 @@ class ResourceManager
                 .m_AspectMask = vk::ImageAspectFlagBits::eColor,
             });
         }
-        [[nodiscard]] Ref<ImageCubeView> CreateTextureCube(const TextureCubeCreateInfo &createInfo) const
+
+        [[nodiscard]] Ref<ImageCubeView>
+        CreateTextureCube(const TextureCubeCreateInfo &createInfo) const
         {
             return m_ViewManager->CreateView<ImageCubeView>({
                 .m_Image = m_ImageManager->CreateTextureCube(createInfo),
@@ -63,7 +66,8 @@ class ResourceManager
             });
         }
 
-        [[nodiscard]] Ref<ImageView> CreateAttachment(const AttachmentCreateInfo &createInfo) const
+        [[nodiscard]] Ref<ImageView>
+        CreateAttachment(const AttachmentCreateInfo &createInfo) const
         {
             return m_ViewManager->CreateView({
                 .m_Image = m_ImageManager->CreateAttachment(createInfo),
@@ -73,7 +77,8 @@ class ResourceManager
             });
         }
 
-        [[nodiscard]] Ref<ImageView> CreateDepthStencilImage(const DepthStencilImageCreateInfo &createInfo) const
+        [[nodiscard]] Ref<ImageView>
+        CreateDepthStencilImage(const DepthStencilImageCreateInfo &createInfo) const
         {
             return m_ViewManager->CreateView({
                 .m_Image = m_ImageManager->CreateDepthStencilImage(createInfo),
@@ -87,7 +92,7 @@ class ResourceManager
     BufferManager m_Buffers;
     ImageManager m_Images;
     SamplerManager m_Samplers;
-    ImageViewManager m_Views;
+    ViewManager m_Views;
     CombinedImageViewManager m_CombinedImageViews;
 
   public:
@@ -112,7 +117,7 @@ class ResourceManager
         return m_Images;
     }
 
-    ImageViewManager &
+    ViewManager &
     Views()
     {
         return m_Views;
@@ -124,11 +129,21 @@ class ResourceManager
         return m_Samplers;
     }
 
-    CombinedImageViewManager &CombinedImageViews()
+    CombinedImageViewManager &
+    CombinedImageViews()
     {
         return m_CombinedImageViews;
     }
 
+    void
+    Update()
+    {
+        m_Views.Sweep();
+        m_Images.Sweep();
+        m_Buffers.Sweep();
+        m_Samplers.Sweep();
+    }
+
     ~ResourceManager() = default;
 
     PIN_MEMORY(ResourceManager);

aster/include/aster/systems/sampler_manager.h

@@ -1,12 +1,12 @@
 // =============================================
 //  Aster: sampler_manager.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once
 
-#include "manager.h"
 #include "EASTL/hash_map.h"
+#include "manager.h"
 
 #include "aster/aster.h"
 #include "aster/core/sampler.h"
@@ -67,7 +67,8 @@ struct SamplerCreateInfo
     bool m_CompareEnable = false;
     bool m_NormalizedCoordinates = true;
 
-    explicit operator vk::SamplerCreateInfo() const
+    explicit
+    operator vk::SamplerCreateInfo() const
     {
         return {
             .flags = m_Flags,
@@ -100,7 +101,7 @@ class SamplerManager final : public Manager<Sampler>
     eastl::hash_map<vk::SamplerCreateInfo, Handle> m_HashToSamplerIdx;
 
   public:
-    SamplerManager(const Device *device, const u32 maxCount);
+    SamplerManager(const Device *device, u32 maxCount);
     ~SamplerManager() override;
 
     Ref<Sampler> CreateSampler(const SamplerCreateInfo &createInfo);

aster/include/aster/systems/view_manager.h

@@ -1,6 +1,6 @@
 // =============================================
-//  Aster: image_manager.h
+//  Aster: view_manager.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once
@@ -86,10 +86,10 @@ struct ViewCreateInfo
     }
 };
 
-class ImageViewManager final : public Manager<ImageView>
+class ViewManager final : public Manager<ImageView>
 {
   public:
-    ImageViewManager(const Device *device, const u32 maxCount);
+    ViewManager(const Device *device, u32 maxCount);
 
     template <concepts::ImageView TImageView>
     Ref<TImageView>

aster/include/aster/util/CMakeLists.txt

@@ -5,4 +5,4 @@ cmake_minimum_required(VERSION 3.13)
 target_sources(aster_core 
 INTERFACE
 	"logger.h"
-	"intrusive_slist.h")
+	"freelist.h")

aster/include/aster/util/freelist.h

@@ -0,0 +1,96 @@
+// =============================================
+//  Aster: freelist.h
+//  Copyright (c) 2020-2025 Anish Bhobe
+// =============================================
+
+#pragma once
+
+#include <optional>
+
+struct FreeListNode
+{
+    FreeListNode *m_Next;
+};
+
+template <typename T>
+concept FreeListCapable = sizeof(T) >= sizeof(FreeListNode);
+
+template <FreeListCapable T>
+struct FreeList
+{
+    using Value = T;
+    using Reference = T &;
+    using ConstReference = const T &;
+    using Pointer = T *;
+
+    FreeListNode *m_Top;
+
+    FreeList()
+        : m_Top{nullptr}
+    {
+    }
+
+    FreeList(FreeList &&other) noexcept
+        : m_Top{Take(other.m_Top)}
+    {
+    }
+
+    FreeList &
+    operator=(FreeList &&other) noexcept
+    {
+        if (this == &other)
+            return *this;
+        m_Top = Take(other.m_Top);
+        return *this;
+    }
+
+    DISALLOW_COPY_AND_ASSIGN(FreeList);
+
+    ~FreeList()
+    {
+        m_Top = nullptr;
+    }
+
+    [[nodiscard]] bool
+    Empty() const
+    {
+        return !m_Top;
+    }
+
+    [[nodiscard]] Reference
+    Pop()
+    {
+        assert(m_Top);
+        Reference ref = *Recast<Pointer>(m_Top);
+        m_Top = m_Top->m_Next;
+        return ref;
+    }
+
+    void
+    Push(Reference ref)
+    {
+        auto next = Recast<FreeListNode *>(&ref);
+        next->m_Next = m_Top;
+        m_Top = next;
+    }
+
+    [[nodiscard]] ConstReference
+    Peek() const
+    {
+        assert(m_Top);
+        return *m_Top;
+    }
+
+    [[nodiscard]] Reference
+    Peek()
+    {
+        assert(m_Top);
+        return *m_Top;
+    }
+
+    void
+    Clear()
+    {
+        m_Top = nullptr;
+    }
+};

aster/include/aster/util/intrusive_slist.h

@@ -1,127 +0,0 @@
-// =============================================
-//  Aster: intrusive_slist.h
-//  Copyright (c) 2020-2024 Anish Bhobe
-// =============================================
-
-#pragma once
-
-#include <optional>
-
-template <typename T>
-concept HasNext = requires(T &a) {
-    { a.Next() } -> std::same_as<T *>;
-    { a.SetNext(a) };
-};
-
-struct IntrusiveStackNode
-{
-    IntrusiveStackNode *m_Next;
-
-    IntrusiveStackNode *
-    Next() const
-    {
-        return m_Next;
-    }
-
-    void
-    SetNext(IntrusiveStackNode &a)
-    {
-        m_Next = &a;
-    }
-};
-
-template <HasNext T = IntrusiveStackNode>
-struct IntrusiveStack
-{
-    using Value = T;
-    using Reference = T &;
-    using OptionalRef = std::optional<std::reference_wrapper<T>>;
-    using ConstReference = const T &;
-    using Pointer = T *;
-
-    Pointer m_Top;
-
-    IntrusiveStack()
-        : m_Top{nullptr}
-    {
-    }
-
-    IntrusiveStack(IntrusiveStack &&other) noexcept
-        : m_Top{Take(other.m_Top)}
-    {
-    }
-
-    IntrusiveStack &
-    operator=(IntrusiveStack &&other) noexcept
-    {
-        if (this == &other)
-            return *this;
-        m_Top = Take(other.m_Top);
-        return *this;
-    }
-
-    DISALLOW_COPY_AND_ASSIGN(IntrusiveStack);
-
-    ~IntrusiveStack()
-    {
-        m_Top = nullptr;
-    }
-
-    [[nodiscard]] bool
-    Empty() const
-    {
-        return !m_Top;
-    }
-
-    [[nodiscard]] Reference
-    Pop()
-    {
-        assert(m_Top);
-        Reference ref = *m_Top;
-        m_Top = m_Top->Next();
-        return ref;
-    }
-
-    [[nodiscard]] OptionalRef
-    TryPop()
-    {
-        if (m_Top)
-            return Pop();
-        return std::nullopt;
-    }
-
-    void
-    Push(Reference ref)
-    {
-        ref.SetNext(*m_Top);
-        m_Top = &ref;
-    }
-
-    [[nodiscard]] ConstReference
-    Peek() const
-    {
-        assert(m_Top);
-        return *m_Top;
-    }
-
-    [[nodiscard]] Reference
-    Peek()
-    {
-        assert(m_Top);
-        return *m_Top;
-    }
-
-    [[nodiscard]] OptionalRef
-    TryPeek()
-    {
-        if (m_Top)
-            return Peek();
-        return std::nullopt;
-    }
-
-    void
-    Clear()
-    {
-        m_Top = nullptr;
-    }
-};

aster/src/aster/core/buffer.cpp

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: buffer.cpp
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #include "core/buffer.h"
@@ -125,8 +125,7 @@ StorageBuffer::Init(const Device *device, usize size, bool hostVisible, bool dev
     else
     {
         usage |= vk::BufferUsageFlagBits::eTransferDst;
-        Allocate(device, size, usage, 0,
+        Allocate(device, size, usage, 0, VMA_MEMORY_USAGE_AUTO, name);
-                 VMA_MEMORY_USAGE_AUTO, name);
     }
 }
 
@@ -155,7 +154,8 @@ StorageIndexBuffer::Init(const Device *device, usize size, bool hostVisible, boo
 void
 IndirectBuffer::Init(const Device *device, usize size, bool hostVisible, cstr name)
 {
-    vk::BufferUsageFlags usage = vk::BufferUsageFlagBits::eStorageBuffer | vk::BufferUsageFlagBits::eIndirectBuffer | vk::BufferUsageFlagBits::eShaderDeviceAddress;
+    vk::BufferUsageFlags usage = vk::BufferUsageFlagBits::eStorageBuffer | vk::BufferUsageFlagBits::eIndirectBuffer |
+                                 vk::BufferUsageFlagBits::eShaderDeviceAddress;
     if (hostVisible)
     {
         Allocate(device, size, usage,
@@ -173,15 +173,15 @@ IndirectBuffer::Init(const Device *device, usize size, bool hostVisible, cstr na
 void
 VertexBuffer::Init(const Device *device, usize size, cstr name)
 {
-    Allocate(device, size, vk::BufferUsageFlagBits::eVertexBuffer | vk::BufferUsageFlagBits::eTransferDst,
+    Allocate(device, size, vk::BufferUsageFlagBits::eVertexBuffer | vk::BufferUsageFlagBits::eTransferDst, 0,
-             0, VMA_MEMORY_USAGE_AUTO, name);
+             VMA_MEMORY_USAGE_AUTO, name);
 }
 
 void
 IndexBuffer::Init(const Device *device, usize size, cstr name)
 {
-    Allocate(device, size, vk::BufferUsageFlagBits::eIndexBuffer | vk::BufferUsageFlagBits::eTransferDst,
+    Allocate(device, size, vk::BufferUsageFlagBits::eIndexBuffer | vk::BufferUsageFlagBits::eTransferDst, 0,
-             0, VMA_MEMORY_USAGE_AUTO, name);
+             VMA_MEMORY_USAGE_AUTO, name);
 }
 
 void

aster/src/aster/core/context.cpp

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: context.cpp
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #include "core/context.h"

aster/src/aster/core/device.cpp

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: device.cpp
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #include "core/device.h"

aster/src/aster/core/global.cpp

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: global.cpp
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #include "core/global.h"
@@ -51,7 +51,7 @@ struct fmt::formatter<MemorySize>
     template <typename Context>
     // ReSharper disable once CppInconsistentNaming
     constexpr auto
-    format(MemorySize const &mem, Context &ctx) const
+    format(const MemorySize &mem, Context &ctx) const
     {
         // return format_to(ctx.out(), "({}, {})", foo.a, foo.b); // --== KEY LINE ==--
         if (mem.m_Gigabytes > 0)

aster/src/aster/core/image.cpp

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: image.cpp
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #include "core/image.h"
@@ -220,7 +220,8 @@ Image::DestroyView(const vk::ImageView imageView) const
 //             },
 //     };
 //     result = device->m_Device.createImageView(&imageViewCreateInfo, nullptr, &view);
-//    ERROR_IF(Failed(result), "Could not create attachment image view {}. Cause: {}", name, result) THEN_ABORT(result);
+//     ERROR_IF(Failed(result), "Could not create attachment image view {}. Cause: {}", name, result)
+//     THEN_ABORT(result);
 //
 //     m_Device = device;
 //     m_Image = image;
@@ -297,10 +298,12 @@ Image::DestroyView(const vk::ImageView imageView) const
 //     // Transfer Src and Dst to copy to and from the buffer since Storage will often be loaded with info, and read for
 //     // results.
 //     auto usage =
-//        vk::ImageUsageFlagBits::eStorage | vk::ImageUsageFlagBits::eTransferSrc | vk::ImageUsageFlagBits::eTransferDst;
+//         vk::ImageUsageFlagBits::eStorage | vk::ImageUsageFlagBits::eTransferSrc |
+//         vk::ImageUsageFlagBits::eTransferDst;
 //     if (isSampled)
 //     {
-//        WARN_IF(!IsPowerOfTwo(extent.width) || !IsPowerOfTwo(extent.width), "Image {2} is {0}x{1} (Non Power of Two)",
+//         WARN_IF(!IsPowerOfTwo(extent.width) || !IsPowerOfTwo(extent.width), "Image {2} is {0}x{1} (Non Power of
+//         Two)",
 //                 extent.width, extent.height, name ? name : "<unnamed>");
 //         usage |= vk::ImageUsageFlagBits::eSampled;
 //     }
@@ -358,14 +361,16 @@ Image::DestroyView(const vk::ImageView imageView) const
 // }
 //
 // void
-//StorageTextureCube::Init(const Device *device, u32 cubeSide, vk::Format imageFormat, bool isSampled, bool isMipMapped,
+// StorageTextureCube::Init(const Device *device, u32 cubeSide, vk::Format imageFormat, bool isSampled, bool
+// isMipMapped,
 //                          cstr name)
 //{
 //     // Reasoning:
 //     // Transfer Src and Dst to copy to and from the buffer since Storage will often be loaded with info, and read for
 //     // results.
 //     auto usage =
-//        vk::ImageUsageFlagBits::eStorage | vk::ImageUsageFlagBits::eTransferSrc | vk::ImageUsageFlagBits::eTransferDst;
+//         vk::ImageUsageFlagBits::eStorage | vk::ImageUsageFlagBits::eTransferSrc |
+//         vk::ImageUsageFlagBits::eTransferDst;
 //     if (isSampled)
 //     {
 //         WARN_IF(!IsPowerOfTwo(cubeSide), "Image {1} is {0}x{0} (Non Power of Two)", cubeSide,

aster/src/aster/core/physical_device.cpp

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: physical_device.cpp
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #include "core/physical_device.h"

aster/src/aster/core/pipeline.cpp

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: pipeline.cpp
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #include "core/pipeline.h"

aster/src/aster/core/sampler.cpp

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: sampler.cpp
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #include "core/sampler.h"

aster/src/aster/core/surface.cpp

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: surface.cpp
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #include "core/surface.h"

aster/src/aster/core/swapchain.cpp

@@ -1,6 +1,6 @@
 /// =============================================
 //  Aster: swapchain.cpp
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // ==============================================
 
 #include "core/swapchain.h"
@@ -67,7 +67,7 @@ Swapchain::Create(const Surface *surface, Size2D size)
     auto presentModes = GetSurfacePresentModes(m_Device->m_PhysicalDevice, surface->m_Surface);
 
     m_Format = vk::Format::eUndefined;
-    vk::ColorSpaceKHR swapchainColorSpace = vk::ColorSpaceKHR::eSrgbNonlinear;
+    auto swapchainColorSpace = vk::ColorSpaceKHR::eSrgbNonlinear;
     for (auto [format, colorSpace] : surfaceFormats)
     {
         if (format == vk::Format::eB8G8R8A8Srgb && colorSpace == vk::ColorSpaceKHR::eSrgbNonlinear)
@@ -84,7 +84,7 @@ Swapchain::Create(const Surface *surface, Size2D size)
         swapchainColorSpace = colorSpace;
     }
 
-    vk::PresentModeKHR swapchainPresentMode = vk::PresentModeKHR::eFifo;
+    auto swapchainPresentMode = vk::PresentModeKHR::eFifo;
     for (const auto presentMode : presentModes)
     {
         if (presentMode == vk::PresentModeKHR::eMailbox)

aster/src/aster/core/window.cpp

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: window.cpp
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #include "core/window.h"

aster/src/aster/systems/CMakeLists.txt

@@ -7,6 +7,6 @@ PRIVATE
 "manager.cpp"
 "buffer_manager.cpp"
 "image_manager.cpp"
-"image_view_manager.cpp"
+"view_manager.cpp"
 "sampler_manager.cpp"
 "commit_manager.cpp")

aster/src/aster/systems/commit_manager.cpp

@@ -36,8 +36,8 @@ using namespace systems;
 
 CommitManager *CommitManager::m_Instance = nullptr;
 
-CommitManager::CommitManager(const Device *device, u32 const maxBuffers, const u32 maxImages, const u32 maxStorageImages,
+CommitManager::CommitManager(const Device *device, const u32 maxBuffers, const u32 maxImages,
-                             Ref<Sampler> defaultSampler)
+                             const u32 maxStorageImages, Ref<Sampler> defaultSampler)
     : m_Device{device}
     , m_Buffers{maxBuffers}
     , m_Images{maxImages}
@@ -55,10 +55,10 @@ CommitManager::CommitManager(const Device *device, u32 const maxBuffers, const u
             .type = vk::DescriptorType::eCombinedImageSampler,
             .descriptorCount = maxImages,
         },
-        // vk::DescriptorPoolSize{
+        vk::DescriptorPoolSize{
-        //     .type = vk::DescriptorType::eStorageImage,
+            .type = vk::DescriptorType::eStorageImage,
-        //     .descriptorCount = storageTexturesCount,
+            .descriptorCount = maxStorageImages,
-        // },
+        },
     };
 
     const vk::DescriptorPoolCreateInfo poolCreateInfo = {

aster/src/aster/systems/image_manager.cpp

@@ -1,5 +1,5 @@
 // =============================================
-//  Aster: buffer_manager.cpp
+//  Aster: image_manager.cpp
 //  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
@@ -225,7 +225,7 @@ ToImageCreateInfo(const DepthStencilImageCreateInfo &createInfo)
 {
     auto &[extent, name] = createInfo;
 
-    constexpr vk::Format format = vk::Format::eD24UnormS8Uint;
+    constexpr auto format = vk::Format::eD24UnormS8Uint;
     constexpr auto usage = usage_flags::DEPTH_STENCIL_ATTACHMENT;
 
     return {

aster/src/aster/systems/view_manager.cpp

@@ -1,29 +1,27 @@
 // =============================================
-//  Aster: image_view_manager.cpp
+//  Aster: view_manager.cpp
 //  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
-#include "systems/image_view_manager.h"
+#include "systems/view_manager.h"
 
 #include "core/device.h"
 
 using namespace systems;
 
-ImageViewManager::ImageViewManager(const Device *device, const u32 maxCount)
+ViewManager::ViewManager(const Device *device, const u32 maxCount)
     : Manager{device, maxCount}
 {
 }
 
 Ref<ImageView>
-ImageViewManager::CreateView(const ViewCreateInfo<> &createInfo)
+ViewManager::CreateView(const ViewCreateInfo<> &createInfo)
 {
     const auto layerCount = createInfo.GetLayerCount();
     const auto mipCount = createInfo.GetMipLevelCount();
-    ERROR_IF((createInfo.m_BaseLayer + layerCount) > createInfo.m_Image->m_LayerCount,
+    ERROR_IF((createInfo.m_BaseLayer + layerCount) > createInfo.m_Image->m_LayerCount, "Invalid Layer Access")
-             "Invalid Layer Access")
     THEN_ABORT(-1);
-    ERROR_IF((createInfo.m_BaseMipLevel + mipCount) > createInfo.m_Image->m_MipLevels,
+    ERROR_IF((createInfo.m_BaseMipLevel + mipCount) > createInfo.m_Image->m_MipLevels, "Invalid Mip Level Access")
-             "Invalid Mip Level Access")
     THEN_ABORT(-1);
 
     vk::ImageView view;

aster/src/aster/util/logger.cpp

@@ -1,11 +1,11 @@
 // =============================================
 //  Aster: logger.cpp
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #include "util/logger.h"
 
-Logger g_Logger = Logger();
+auto g_Logger = Logger();
 // ReSharper disable once CppInconsistentNaming
 
 /* Credits to Const-me */

samples/00_util/frame.cpp

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: frame.cpp
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #include "frame.h"

samples/00_util/frame.h

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: frame.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once
@@ -31,7 +31,7 @@ struct Frame
     // Transient
     u32 m_ImageIdx;
 
-    void Present(const vk::Queue commandQueue, Swapchain* swapchain, const Surface* surface, Size2D size);
+    void Present(vk::Queue commandQueue, Swapchain *swapchain, const Surface *surface, Size2D size);
 
     Frame(const Device *device, u32 queueFamilyIndex, u32 frameCount);
     ~Frame();

samples/00_util/gui.cpp

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: gui.cpp
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #include "gui.h"

samples/00_util/gui.h

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: gui.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once

samples/00_util/helpers.cpp

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: helpers.cpp
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #include "helpers.h"

samples/00_util/helpers.h

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: helpers.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once

samples/01_triangle/triangle.cpp

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: triangle.cpp
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #include "aster/aster.h"

samples/02_box/box.cpp

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: box.cpp
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #include "aster/aster.h"
@@ -19,12 +19,12 @@
 
 #define STB_IMAGE_IMPLEMENTATION
 #include "aster/systems/buffer_manager.h"
-#include "aster/systems/image_manager.h"
 #include "aster/systems/commit_manager.h"
+#include "aster/systems/image_manager.h"
+#include "aster/systems/resource_manager.h"
+#include "aster/systems/view_manager.h"
 #include "frame.h"
 #include "stb_image.h"
-#include "aster/systems/image_view_manager.h"
-#include "aster/systems/resource_manager.h"
 
 #include <EASTL/array.h>
 
@@ -139,7 +139,7 @@ main(int, char **)
 
     Camera camera = {
         .m_Model = {1.0f},
-        .m_View = glm::lookAt(vec3(0.0f, 2.0f, 2.0f), vec3(0.0f), vec3(0.0f, 1.0f, 0.0f)),
+        .m_View = lookAt(vec3(0.0f, 2.0f, 2.0f), vec3(0.0f), vec3(0.0f, 1.0f, 0.0f)),
         .m_Perspective = glm::perspective(
             70_deg, Cast<f32>(swapchain.m_Extent.width) / Cast<f32>(swapchain.m_Extent.height), 0.1f, 100.0f),
     };
@@ -214,8 +214,7 @@ main(int, char **)
     auto vbo = resourceManager.Buffers().CreateStorageBuffer(vertices.size() * sizeof vertices[0], "Vertex Buffer");
     vbo->Write(0, vertices.size() * sizeof vertices[0], vertices.data());
 
-    auto crate = resourceManager.CombinedImageViews()
+    auto crate = resourceManager.CombinedImageViews().CreateTexture2D({
-                     .CreateTexture2D({
         .m_Format = vk::Format::eR8G8B8A8Srgb,
         .m_Extent = {imageFile.m_Width, imageFile.m_Height},
         .m_Name = "Crate Texture",
@@ -427,6 +426,7 @@ main(int, char **)
     {
         Time::Update();
         commitManager.Update();
+        resourceManager.Update();
 
         camera.m_Model *= rotate(mat4{1.0f}, Cast<f32>(45.0_deg * Time::m_Delta), vec3(0.0f, 1.0f, 0.0f));
         ubo->Write(0, sizeof camera, &camera);

samples/03_model_render/asset_loader.cpp

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: asset_loader.cpp
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #include "aster/core/buffer.h"
@@ -553,8 +553,8 @@ AssetLoader::LoadModelToGpu(cstr path, cstr name)
     if (!model.materials.empty())
     {
         // TODO("Something broken on load here.");
-        auto getTextureHandle = [this, &textureHandleMap, &stagingBuffers, &model](i32 index,
+        auto getTextureHandle = [this, &textureHandleMap, &stagingBuffers,
-                                                                  const bool isSrgb) -> systems::ResId<TextureView> {
+                                 &model](i32 index, const bool isSrgb) -> systems::ResId<TextureView> {
             if (index < 0)
             {
                 return systems::NullId{};
@@ -642,12 +642,12 @@ AssetLoader::LoadModelToGpu(cstr path, cstr name)
 
                 if (posAccessor->type == TINYGLTF_TYPE_VEC4)
                 {
-                    vec4 *data = Recast<vec4 *>(posBuffer->data.data() + byteOffset);
+                    auto data = Recast<vec4 *>(posBuffer->data.data() + byteOffset);
                     vertexPositions.insert(vertexPositions.end(), data, data + vertexCount);
                 }
                 else if (posAccessor->type == TINYGLTF_TYPE_VEC3)
                 {
-                    vec3 *data = Recast<vec3 *>(posBuffer->data.data() + byteOffset);
+                    auto data = Recast<vec3 *>(posBuffer->data.data() + byteOffset);
                     for (u32 i = 0; i < vertexCount; ++i)
                     {
                         vertexPositions.push_back(vec4(data[i], 1.0f));
@@ -655,7 +655,7 @@ AssetLoader::LoadModelToGpu(cstr path, cstr name)
                 }
                 else if (posAccessor->type == TINYGLTF_TYPE_VEC2)
                 {
-                    vec2 *data = Recast<vec2 *>(posBuffer->data.data() + byteOffset);
+                    auto data = Recast<vec2 *>(posBuffer->data.data() + byteOffset);
                     for (u32 i = 0; i < vertexCount; ++i)
                     {
                         vertexPositions.push_back(vec4(data[i], 0.0f, 1.0f));
@@ -679,7 +679,7 @@ AssetLoader::LoadModelToGpu(cstr path, cstr name)
 
                 if (normAccessor->type == TINYGLTF_TYPE_VEC4)
                 {
-                    vec4 *data = Recast<vec4 *>(normBuffer->data.data() + byteOffset);
+                    auto data = Recast<vec4 *>(normBuffer->data.data() + byteOffset);
 
                     vec4 *end = data + vertexCount;
                     u32 idx = vertexOffset;
@@ -691,7 +691,7 @@ AssetLoader::LoadModelToGpu(cstr path, cstr name)
                 }
                 else if (normAccessor->type == TINYGLTF_TYPE_VEC3)
                 {
-                    vec3 *data = Recast<vec3 *>(normBuffer->data.data() + byteOffset);
+                    auto data = Recast<vec3 *>(normBuffer->data.data() + byteOffset);
                     for (u32 i = 0; i < vertexCount; ++i)
                     {
                         auto norm = vec4(data[i], 0.0f);
@@ -700,7 +700,7 @@ AssetLoader::LoadModelToGpu(cstr path, cstr name)
                 }
                 else if (normAccessor->type == TINYGLTF_TYPE_VEC2)
                 {
-                    vec2 *data = Recast<vec2 *>(normBuffer->data.data() + byteOffset);
+                    auto data = Recast<vec2 *>(normBuffer->data.data() + byteOffset);
                     for (u32 i = 0; i < vertexCount; ++i)
                     {
                         auto norm = vec4(data[i], 0.0f, 0.0f);
@@ -723,7 +723,7 @@ AssetLoader::LoadModelToGpu(cstr path, cstr name)
                 assert(uvAccessor->type == TINYGLTF_TYPE_VEC2 &&
                        uvAccessor->componentType == TINYGLTF_COMPONENT_TYPE_FLOAT);
                 {
-                    vec2 *data = Recast<vec2 *>(uvBuffer->data.data() + byteOffset);
+                    auto data = Recast<vec2 *>(uvBuffer->data.data() + byteOffset);
                     vec2 *end = data + vertexCount;
                     u32 idx = vertexOffset;
                     vec2 *it = data;
@@ -746,7 +746,7 @@ AssetLoader::LoadModelToGpu(cstr path, cstr name)
 
                 if (colorAccessor->type == TINYGLTF_TYPE_VEC4)
                 {
-                    vec4 *data = Recast<vec4 *>(colorBuffer->data.data() + byteOffset);
+                    auto data = Recast<vec4 *>(colorBuffer->data.data() + byteOffset);
 
                     vec4 *end = data + vertexCount;
                     u32 idx = vertexOffset;
@@ -758,7 +758,7 @@ AssetLoader::LoadModelToGpu(cstr path, cstr name)
                 }
                 else if (colorAccessor->type == TINYGLTF_TYPE_VEC3)
                 {
-                    vec3 *data = Recast<vec3 *>(colorBuffer->data.data() + byteOffset);
+                    auto data = Recast<vec3 *>(colorBuffer->data.data() + byteOffset);
                     for (u32 i = 0; i < vertexCount; ++i)
                     {
                         auto color = vec4(data[i], 1.0f);
@@ -784,17 +784,17 @@ AssetLoader::LoadModelToGpu(cstr path, cstr name)
 
                 if (indexAccessor->componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT)
                 {
-                    u32 *data = Recast<u32 *>(indexBuffer->data.data() + byteOffset);
+                    auto data = Recast<u32 *>(indexBuffer->data.data() + byteOffset);
                     indices.insert(indices.end(), data, data + indexCount);
                 }
                 else if (indexAccessor->componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT)
                 {
-                    u16 *data = Recast<u16 *>(indexBuffer->data.data() + byteOffset);
+                    auto data = Recast<u16 *>(indexBuffer->data.data() + byteOffset);
                     indices.insert(indices.end(), data, data + indexCount);
                 }
                 else if (indexAccessor->componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE)
                 {
-                    u8 *data = Recast<u8 *>(indexBuffer->data.data() + byteOffset);
+                    auto data = Recast<u8 *>(indexBuffer->data.data() + byteOffset);
                     indices.insert(indices.end(), data, data + indexCount);
                 }
             }
@@ -831,10 +831,10 @@ AssetLoader::LoadModelToGpu(cstr path, cstr name)
                                                            &meshPrimitives](i32 idx, i32 parent) -> void {
                 const auto *node = &model.nodes[idx];
 
-                vec3 nodeTranslation = vec3{0.0f};
+                auto nodeTranslation = vec3{0.0f};
-                quat nodeRotation = quat{1.0f, 0.0f, 0.0f, 0.0f};
+                auto nodeRotation = quat{1.0f, 0.0f, 0.0f, 0.0f};
-                vec3 nodeScale = vec3{1.0f};
+                auto nodeScale = vec3{1.0f};
-                mat4 nodeMatrix = mat4{1.0f};
+                auto nodeMatrix = mat4{1.0f};
                 if (node->translation.size() == 3)
                 {
                     nodeTranslation = glm::make_vec3(node->translation.data());

samples/03_model_render/asset_loader.h

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: asset_loader.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once
@@ -9,11 +9,11 @@
 
 #include "aster/core/buffer.h"
 
+#include "aster/systems/image_manager.h"
+#include "aster/systems/resource.h"
+#include "aster/systems/view_manager.h"
 #include "nodes.h"
 #include "tiny_gltf.h"
-#include "aster/systems/image_manager.h"
-#include "aster/systems/image_view_manager.h"
-#include "aster/systems/resource.h"
 
 namespace systems
 {
@@ -22,7 +22,7 @@ class SamplerManager;
 class BufferManager;
 class ImageManager;
 class CommitManager;
-}
+} // namespace systems
 
 namespace tinygltf
 {
@@ -88,8 +88,9 @@ struct Model
     void SetModelTransform(const mat4 &transform);
     void Update();
 
-    Model(systems::CommitManager *resourceManager, eastl::vector<systems::ResId<TextureView>> &textureHandles, Nodes &&nodes, Ref<Buffer> nodeBuffer,
+    Model(systems::CommitManager *resourceManager, eastl::vector<systems::ResId<TextureView>> &textureHandles,
-          ModelHandles &handles, Ref<Buffer> indexBuffer, const eastl::vector<MeshPrimitive> &meshPrimitives);
+          Nodes &&nodes, Ref<Buffer> nodeBuffer, ModelHandles &handles, Ref<Buffer> indexBuffer,
+          const eastl::vector<MeshPrimitive> &meshPrimitives);
     ~Model() = default;
 
     Model(Model &&other) noexcept = default;
@@ -124,8 +125,7 @@ struct AssetLoader
     constexpr static auto AWeights0 = "WEIGHTS_0";
 
     AssetLoader(systems::ResourceManager *resourceManager, systems::CommitManager *commitManager,
-                vk::Queue transferQueue, u32 transferQueueIndex,
+                vk::Queue transferQueue, u32 transferQueueIndex, u32 graphicsQueueIndex);
-                u32 graphicsQueueIndex);
     ~AssetLoader();
 
     AssetLoader(AssetLoader &&other) noexcept;
@@ -138,7 +138,6 @@ void
 GenerateMipMaps(vk::CommandBuffer commandBuffer, const Ref<Texture> &textureView, vk::ImageLayout initialLayout,
                 vk::ImageLayout finalLayout, vk::PipelineStageFlags2 prevStage, vk::PipelineStageFlags2 finalStage);
 
-
 void
 GenerateMipMaps(vk::CommandBuffer commandBuffer, concepts::SampledImageRef auto &texture, vk::ImageLayout initialLayout,
                 vk::ImageLayout finalLayout,
@@ -150,8 +149,8 @@ GenerateMipMaps(vk::CommandBuffer commandBuffer, concepts::SampledImageRef auto
 }
 
 void
-GenerateMipMaps(vk::CommandBuffer commandBuffer, concepts::SampledImageViewRef auto &texture, vk::ImageLayout initialLayout,
+GenerateMipMaps(vk::CommandBuffer commandBuffer, concepts::SampledImageViewRef auto &texture,
-                vk::ImageLayout finalLayout,
+                vk::ImageLayout initialLayout, vk::ImageLayout finalLayout,
                 vk::PipelineStageFlags2 prevStage = vk::PipelineStageFlagBits2::eAllCommands,
                 vk::PipelineStageFlags2 finalStage = vk::PipelineStageFlagBits2::eAllCommands)
 {

samples/03_model_render/ibl_helpers.cpp

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: ibl_helpers.cpp
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #include "ibl_helpers.h"
@@ -18,10 +18,10 @@
 #include <EASTL/fixed_vector.h>
 #include <EASTL/tuple.h>
 
-constexpr cstr EQUIRECT_TO_CUBE_SHADER_FILE = "shader/eqrect_to_cube.cs.hlsl.spv";
+constexpr auto EQUIRECT_TO_CUBE_SHADER_FILE = "shader/eqrect_to_cube.cs.hlsl.spv";
-constexpr cstr DIFFUSE_IRRADIANCE_SHADER_FILE = "shader/diffuse_irradiance.cs.hlsl.spv";
+constexpr auto DIFFUSE_IRRADIANCE_SHADER_FILE = "shader/diffuse_irradiance.cs.hlsl.spv";
-constexpr cstr PREFILTER_SHADER_FILE = "shader/prefilter.cs.hlsl.spv";
+constexpr auto PREFILTER_SHADER_FILE = "shader/prefilter.cs.hlsl.spv";
-constexpr cstr BRDF_LUT_SHADER_FILE = "shader/brdf_lut.cs.hlsl.spv";
+constexpr auto BRDF_LUT_SHADER_FILE = "shader/brdf_lut.cs.hlsl.spv";
 
 Environment
 CreateCubeFromHdrEnv(AssetLoader *assetLoader, vk::Queue computeQueue, const u32 cubeSide,

samples/03_model_render/ibl_helpers.h

@@ -1,14 +1,14 @@
 // =============================================
 //  Aster: ibl_helpers.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once
 
 #include "aster/aster.h"
-#include "aster/systems/resource.h"
 #include "aster/core/image.h"
 #include "aster/core/image_view.h"
+#include "aster/systems/resource.h"
 
 struct Pipeline;
 struct Texture;
@@ -23,5 +23,5 @@ struct Environment
     systems::ResId<TextureView> m_BrdfLut;
 };
 
-Environment CreateCubeFromHdrEnv(AssetLoader *assetLoader, vk::Queue computeQueue, u32 cubeSide, systems::ResId<TextureView> hdrEnv,
+Environment CreateCubeFromHdrEnv(AssetLoader *assetLoader, vk::Queue computeQueue, u32 cubeSide,
-                                 cstr name = nullptr);
+                                 systems::ResId<TextureView> hdrEnv, cstr name = nullptr);

samples/03_model_render/light_manager.cpp

@@ -1,14 +1,14 @@
 // =============================================
 //  Aster: light_manager.cpp
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #include "light_manager.h"
 
 #include "aster/core/buffer.h"
+#include "aster/systems/commit_manager.h"
 #include "aster/systems/resource.h"
 #include "aster/systems/resource_manager.h"
-#include "aster/systems/commit_manager.h"
 #include "glm/ext/matrix_transform.hpp"
 
 // Static Checks
@@ -60,7 +60,7 @@ LightManager::LightManager(systems::ResourceManager *resourceManager, systems::C
     , m_CommitManager{commitManager}
     , m_DirectionalLightCount{}
     , m_PointLightCount{}
-    , m_MetaInfo{.m_LightBuffer = systems::ResId<Buffer>::Null() }
+    , m_MetaInfo{.m_LightBuffer = systems::NullId()}
     , m_GpuBufferCapacity_{0}
 {
 }
@@ -210,7 +210,8 @@ LightManager::Update()
     const u16 requiredBufferCapacity = eastl::min(Cast<u16>(m_Lights.capacity()), MAX_LIGHTS);
     if ((m_GpuBufferCapacity_ & CAPACITY_MASK) < requiredBufferCapacity)
     {
-        auto newBuffer = m_ResourceManager->Buffers().CreateStorageBuffer(requiredBufferCapacity * sizeof m_Lights[0], "Light Buffer");
+        auto newBuffer = m_ResourceManager->Buffers().CreateStorageBuffer(requiredBufferCapacity * sizeof m_Lights[0],
+                                                                          "Light Buffer");
         m_GpuBufferCapacity_ = requiredBufferCapacity | UPDATE_REQUIRED_BIT;
 
         m_MetaInfo.m_LightBuffer = m_CommitManager->CommitBuffer(newBuffer);

samples/03_model_render/light_manager.h

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: light_manager.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once
@@ -8,8 +8,8 @@
 #include "aster/aster.h"
 
 // TODO: Separate files so you only import handles.
-#include "aster/systems/resource.h"
 #include "aster/core/buffer.h"
+#include "aster/systems/resource.h"
 
 #include <EASTL/vector.h>
 
@@ -48,6 +48,7 @@ struct Light
         vec3 um_Position;
         vec3 um_Direction;
     };
+
     f32 m_Range;  // < 0.0 for invalid
     u32 m_Color_; // LSB is used for flags. (R G B Flags)
     f32 m_Intensity;
@@ -67,6 +68,7 @@ struct Light
 struct LightManager
 {
     constexpr static u16 MAX_LIGHTS = MaxValue<u16>;
+
     struct LightMetaInfo
     {
         // The number of directional lights is relatively low (1 - 2) and will almost never change in a scene.

samples/03_model_render/model_render.cpp

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: model_render.cpp
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #include "aster/aster.h"
@@ -57,7 +57,7 @@ struct Camera
 
 struct CameraController
 {
-    constexpr static vec3 UP = vec3(0.0f, 1.0f, 0.0f);
+    constexpr static auto UP = vec3(0.0f, 1.0f, 0.0f);
 
     f32 m_Fov;
     f32 m_Pitch;
@@ -98,7 +98,7 @@ struct CameraController
         m_Camera.m_Position = vec4(position, 1.0f);
 
         f32 cosPitch = cos(m_Pitch);
-        const vec3 target = vec3(sin(m_Yaw) * cosPitch, sin(m_Pitch), -cos(m_Yaw) * cosPitch);
+        const auto target = vec3(sin(m_Yaw) * cosPitch, sin(m_Pitch), -cos(m_Yaw) * cosPitch);
         m_Camera.m_View = lookAt(position, position + target, UP);
 
         m_Camera.CalculateInverses();
@@ -111,7 +111,7 @@ struct CameraController
         m_Yaw = yaw;
 
         f32 cosPitch = cos(m_Pitch);
-        const vec3 target = vec3(sin(m_Yaw) * cosPitch, sin(m_Pitch), -cos(m_Yaw) * cosPitch);
+        const auto target = vec3(sin(m_Yaw) * cosPitch, sin(m_Pitch), -cos(m_Yaw) * cosPitch);
         const vec3 position = m_Camera.m_Position;
         m_Camera.m_View = lookAt(position, position + target, UP);
 
@@ -179,11 +179,12 @@ main(int, char **)
     Swapchain swapchain = {&surface, &device, window.GetSize(), "Primary Chain"};
 
     systems::ResourceManager resourceManager = {&device, 1000, 1000, 10, 1000};
-    systems::CommitManager commitManager = {&device, 1000, 1000, 1000, resourceManager.Samplers().CreateSampler({.m_Name = "Default Sampler"})};
+    systems::CommitManager commitManager = {&device, 1000, 1000, 1000,
+                                            resourceManager.Samplers().CreateSampler({.m_Name = "Default Sampler"})};
 
     AssetLoader assetLoader = {&resourceManager, &commitManager, graphicsQueue, queueAllocation.m_Family,
                                queueAllocation.m_Family};
-    LightManager lightManager = LightManager{&resourceManager, &commitManager};
+    auto lightManager = LightManager{&resourceManager, &commitManager};
 
     Model model = assetLoader.LoadModelToGpu(MODEL_FILE);
     auto environmentHdri = assetLoader.LoadHdrImage(BACKDROP_FILE);
@@ -191,7 +192,7 @@ main(int, char **)
 
     auto environment = CreateCubeFromHdrEnv(&assetLoader, graphicsQueue, 512, envHdriHandle, "Cube Env");
 
-    vk::Format attachmentFormat = vk::Format::eR8G8B8A8Srgb;
+    auto attachmentFormat = vk::Format::eR8G8B8A8Srgb;
 
     Pipeline pipeline = CreatePipeline(&device, attachmentFormat, &commitManager);
     Pipeline backGroundPipeline = CreateBackgroundPipeline(&device, attachmentFormat, &commitManager);
@@ -238,7 +239,7 @@ main(int, char **)
     usize lightingSize = sizeof environment + sizeof lightManager.m_MetaInfo;
     uboSize += ClosestMultiple(lightingSize, physicalDeviceOffsetAlignment);
 
-    u8 *data = new u8[uboSize];
+    auto data = new u8[uboSize];
     memcpy(data, &cameraController.m_Camera, cameraSize);
     memcpy(data + lightOffset, &environment, sizeof environment);
     memcpy(data + lightOffset + sizeof environment, &lightManager.m_MetaInfo, sizeof lightManager.m_MetaInfo);
@@ -432,6 +433,8 @@ main(int, char **)
     while (window.Poll())
     {
         Time::Update();
+        commitManager.Update();
+        resourceManager.Update();
 
         gui::StartBuild();
 

samples/03_model_render/nodes.cpp

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: nodes.cpp
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #include "nodes.h"

samples/03_model_render/nodes.h

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: nodes.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once
@@ -41,13 +41,13 @@ struct Nodes
     constexpr static u32 DIRTY_BIT = 1u << 30;
     constexpr static u32 PARENT_MASK = ~(ROOT_BIT | DIRTY_BIT);
 
-    u32 Add(const mat4 &transform, const i32 parent = -1);
+    u32 Add(const mat4 &transform, i32 parent = -1);
-    [[nodiscard]] const mat4 &Get(const u32 index) const;
+    [[nodiscard]] const mat4 &Get(u32 index) const;
-    void Set(const u32 index, const mat4 &transform);
+    void Set(u32 index, const mat4 &transform);
     [[nodiscard]] u32 Count() const;
 
-    [[nodiscard]] const mat4 &operator[](const u32 index) const;
+    [[nodiscard]] const mat4 &operator[](u32 index) const;
-    [[nodiscard]] mat4 &operator[](const u32 index);
+    [[nodiscard]] mat4 &operator[](u32 index);
 
     [[nodiscard]] usize GetGlobalTransformByteSize() const;
     [[nodiscard]] const Transform *GetGlobalTransformPtr() const;

samples/03_model_render/pipeline_utils.cpp

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: pipeline_utils.cpp
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #include "pipeline_utils.h"

samples/03_model_render/pipeline_utils.h

@@ -1,6 +1,6 @@
 // =============================================
 //  Aster: pipeline_utils.h
-//  Copyright (c) 2020-2024 Anish Bhobe
+//  Copyright (c) 2020-2025 Anish Bhobe
 // =============================================
 
 #pragma once
@@ -24,6 +24,7 @@ constexpr auto BACKGROUND_VERTEX_SHADER_FILE = "shader/background.vs.hlsl.spv";
 constexpr auto BACKGROUND_FRAGMENT_SHADER_FILE = "shader/background.ps.hlsl.spv";
 
 vk::ShaderModule CreateShader(const Device *device, cstr shaderFile);
-Pipeline CreatePipeline(const Device *device, vk::Format attachmentFormat, const systems::CommitManager *resourceManager);
 Pipeline
-CreateBackgroundPipeline(const Device *device, vk::Format attachmentFormat, const systems::CommitManager *resourceManager);
+CreatePipeline(const Device *device, vk::Format attachmentFormat, const systems::CommitManager *resourceManager);
+Pipeline CreateBackgroundPipeline(const Device *device, vk::Format attachmentFormat,
+                                  const systems::CommitManager *resourceManager);

samples/03_model_render/tiny_gltf_setup.cpp

@@ -1,4 +1,7 @@
-
+// =============================================
+//  Aster: tiny_gltf_setup.cpp
+//  Copyright (c) 2020-2025 Anish Bhobe
+// =============================================
 
 #define TINYGLTF_NOEXCEPTION
 #define JSON_NOEXCEPTION