SHADE_Application/src/Scenes/SBTestScene.cpp

@@ -1,4 +1,4 @@
-#include "SBpch.h"
+ #include "SBpch.h"
 #include "SBTestScene.h"
 
 #include "ECS_Base/Managers/SHSystemManager.h"
@@ -14,6 +14,7 @@
 #include "Physics/Components/SHColliderComponent.h"
 
 #include "Assets/SHAssetManager.h"
+#include "Resource/SHResourceManager.h"
 
 using namespace SHADE;
 
@@ -40,34 +41,22 @@ namespace Sandbox
     const auto CUBE_MESH = SHADE::SHPrimitiveGenerator::Cube(*graphicsSystem);
 
     //Test Racoon mesh
-    auto meshes = SHADE::SHAssetManager::GetAllMeshes();
     std::vector<Handle<SHMesh>> handles;
-    for (auto const& mesh : meshes)
+    std::vector<Handle<SHTexture>> texHandles;
+    for (const auto& asset : SHAssetManager::GetAllAssets())
     {
-      if (mesh.header.meshName == "Cube.012")
+      switch (asset.type)
       {
-        handles.push_back(graphicsSystem->AddMesh(
+        case AssetType::MESH:
-          mesh.header.vertexCount,
+          if (asset.name == "Cube.012")
-          mesh.vertexPosition.data(),
+          handles.emplace_back(SHResourceManager::LoadOrGet<SHMesh>(asset.id));
-          mesh.texCoords.data(),
+          break;
-          mesh.vertexTangent.data(),
+        case AssetType::TEXTURE:
-          mesh.vertexNormal.data(),
+          texHandles.emplace_back(SHResourceManager::LoadOrGet<SHTexture>(asset.id));
-          mesh.header.indexCount,
+          break;
-          mesh.indices.data()
-        ));
       }
     }
-    graphicsSystem->BuildMeshBuffers();
+    SHResourceManager::FinaliseChanges();
-
-    // Load Textures
-    auto textures = SHADE::SHAssetManager::GetAllTextures();
-    std::vector<Handle<SHTexture>> texHandles;
-    for (const auto& tex : textures)
-    {
-      auto texture = graphicsSystem->Add(tex);
-      texHandles.push_back(texture);
-    }
-    graphicsSystem->BuildTextures();
 
     // Create Materials
     auto matInst = graphicsSystem->AddOrGetBaseMaterialInstance();
@@ -78,8 +67,8 @@ namespace Sandbox
 
     // Create Stress Test Objects
     static const SHVec3 TEST_OBJ_SCALE = SHVec3::One * 0.5f;
-    constexpr int NUM_ROWS = 10;
+    constexpr int NUM_ROWS = 0;
-    constexpr int NUM_COLS = 10;
+    constexpr int NUM_COLS = 0;
     static const SHVec3 TEST_OBJ_SPACING = { 0.1f, 0.1f, 0.1f };
     static const SHVec3 TEST_OBJ_START_POS = { -(NUM_COLS / 2 * TEST_OBJ_SPACING.x) + 1.0f, -2.0f, -1.0f };
 

SHADE_Engine/src/Assets/SHAssetManager.cpp

@@ -62,7 +62,12 @@ namespace SHADE
 		}
 	}
 
-	AssetPath SHAssetManager::GenerateLocalPath(AssetPath path) noexcept
+    void SHAssetManager::Unload(AssetID assetId) noexcept
+    {
+		// TODO
+    }
+
+    AssetPath SHAssetManager::GenerateLocalPath(AssetPath path) noexcept
 	{
 		if (!IsRecognised(path.extension().string().c_str()))
 		{

SHADE_Engine/src/Assets/SHAssetManager.h

@@ -32,6 +32,7 @@ namespace SHADE
 		 * \brief   Deallocate all memory used by resource data
 		****************************************************************************/
 		static void Unload() noexcept;
+		static void Unload(AssetID assetId) noexcept;
 
 		/****************************************************************************
 		 * \brief   Load all resources that are in the folder

SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsSystem.cpp

@@ -585,19 +585,19 @@ namespace SHADE
   /*---------------------------------------------------------------------------------*/
   /* Texture Registration Functions                                                  */
   /*---------------------------------------------------------------------------------*/
-  Handle<SHTexture> SHGraphicsSystem::Add(const SHTextureAsset& texAsset)
+  Handle<SHTexture> SHGraphicsSystem::AddTexture(const SHTextureAsset& texAsset)
   {
       auto sampler = samplerCache.GetSampler(device, SHVkSamplerParams { .maxLod = static_cast<float>(texAsset.mipOffsets.size()) });
       return texLibrary.Add(texAsset, sampler);
   }
 
-  SHADE::Handle<SHADE::SHTexture> SHGraphicsSystem::Add(uint32_t pixelCount, const SHTexture::PixelChannel* const pixelData, uint32_t width, uint32_t height, SHTexture::TextureFormat format, std::vector<uint32_t> mipOffsets)
+  SHADE::Handle<SHADE::SHTexture> SHGraphicsSystem::AddTexture(uint32_t pixelCount, const SHTexture::PixelChannel* const pixelData, uint32_t width, uint32_t height, SHTexture::TextureFormat format, std::vector<uint32_t> mipOffsets)
   {
       auto sampler = samplerCache.GetSampler(device, SHVkSamplerParams{ .maxLod = static_cast<float>(mipOffsets.size()) });
       return texLibrary.Add(pixelCount, pixelData, width, height, format, mipOffsets, sampler);
   }
 
-  void SHGraphicsSystem::Remove(Handle<SHTexture> tex)
+  void SHGraphicsSystem::RemoveTexture(Handle<SHTexture> tex)
   {
     texLibrary.Remove(tex);
   }

SHADE_Engine/src/Graphics/MiddleEnd/Interface/SHGraphicsSystem.h

@@ -231,8 +231,8 @@ namespace SHADE
     
     */ 
     /*******************************************************************************/
-    Handle<SHTexture> Add(const SHTextureAsset& texAsset);
+    Handle<SHTexture> AddTexture(const SHTextureAsset& texAsset);
-    Handle<SHTexture> Add(uint32_t pixelCount, const SHTexture::PixelChannel* const pixelData, uint32_t width, uint32_t height, SHTexture::TextureFormat format, std::vector<uint32_t> mipOffsets);
+    Handle<SHTexture> AddTexture(uint32_t pixelCount, const SHTexture::PixelChannel* const pixelData, uint32_t width, uint32_t height, SHTexture::TextureFormat format, std::vector<uint32_t> mipOffsets);
     /*******************************************************************************/
     /*! 
      
@@ -246,7 +246,7 @@ namespace SHADE
 
     */ 
     /*******************************************************************************/
-    void Remove(Handle<SHTexture> tex);
+    void RemoveTexture(Handle<SHTexture> tex);
     /***************************************************************************/
     /*! 
      

SHADE_Engine/src/Resource/SHHandle.h

@@ -8,6 +8,7 @@ namespace SHADE
     /*---------------------------------------------------------------------------------*/
     /* Forward Declarations                                                            */
     /*---------------------------------------------------------------------------------*/
+    class SHResourceLibraryBase;
     template<typename T>
     class SHResourceLibrary;
     
@@ -25,6 +26,20 @@ namespace SHADE
         using std::runtime_error::runtime_error;
     };
 
+    /// <summary>
+    /// Exception thrown when a generic Handle is being casted to the wrong type.
+    /// </summary>
+    class BadHandleCastException : std::runtime_error
+    {
+      public:
+        /*-----------------------------------------------------------------------------*/
+        /* Constructors                                                                */
+        /*-----------------------------------------------------------------------------*/
+        BadHandleCastException() 
+        : std::runtime_error("Attempted to cast a generic Handle to the wrong type. ") 
+        {}
+    };
+
     /// <summary>
     /// Base implementation of the Handle that is not templated to allow for holding
     /// generic non-type-specific Handles.
@@ -80,7 +95,7 @@ namespace SHADE
     /// Generic implementation of a Handle object 
     /// </summary>
     /// <typeparam name="T">Type of the handle.</typeparam>
-    template<typename T>
+    template<typename T = void>
     class Handle : public HandleBase
     {
       public:
@@ -88,6 +103,16 @@ namespace SHADE
         /* Constructors                                                                */
         /*-----------------------------------------------------------------------------*/
         Handle() = default;
+        /// <summary>
+        /// Converts a generic/void Handle to a specific type.
+        /// Runtime type checking is enabled to ensure that Handles are only being casted
+        /// to the correct type.
+        /// </summary>
+        /// <param name="genericHandle">Generic handle to convert.</param>
+        /// <exception cref="std::bad_cast">
+        /// Thrown if an invalid conversion is made.
+        /// </exception>
+        explicit Handle(const Handle<void>& genericHandle);
         ~Handle() = default;
         
         /*-----------------------------------------------------------------------------*/
@@ -146,6 +171,41 @@ namespace SHADE
         /* Friend Declarations                                                         */
         /*-----------------------------------------------------------------------------*/
         friend class SHResourceLibrary<T>;
+        friend class Handle<void>;
+    };
+
+    /// <summary>
+    /// Template Specialization for Handle that represents a type-less Handle.
+    /// </summary>
+    template<>
+    class Handle<void> : public HandleBase
+    {
+      public:
+        /*-----------------------------------------------------------------------------*/
+        /* Constructors                                                                */
+        /*-----------------------------------------------------------------------------*/
+        Handle() = default;
+        template<typename T>
+        explicit Handle(const Handle<T>& handle);
+        ~Handle() = default;
+
+        /*-----------------------------------------------------------------------------*/
+        /* Overloaded Operators                                                        */
+        /*-----------------------------------------------------------------------------*/
+        template<typename T>
+        inline bool operator==(const Handle<T>& rhs) const noexcept;
+
+      protected:        
+        /*-----------------------------------------------------------------------------*/
+        /* Data Members                                                                */
+        /*-----------------------------------------------------------------------------*/
+        SHResourceLibraryBase* library = nullptr;
+
+        /*-----------------------------------------------------------------------------*/
+        /* Friend Declarations                                                         */
+        /*-----------------------------------------------------------------------------*/
+        template<typename T>
+        friend class Handle;
     };
 
     /// <summary>

SHADE_Engine/src/Resource/SHHandle.hpp

@@ -21,6 +21,20 @@ namespace SHADE
         return id.Raw != INVALID_ID.Raw;
     }
 
+    /*---------------------------------------------------------------------------------*/
+    /* Handle<T> - Constructors                                                        */
+    /*---------------------------------------------------------------------------------*/
+    template<typename T>
+    Handle<T>::Handle(const Handle<void>& genericHandle)
+    : library { reinterpret_cast<SHResourceLibrary<T>*>(genericHandle.library) }
+    {
+        id = genericHandle.id;
+
+        // Check if valid
+        if (library != nullptr && library->GetType() != typeid(T))
+            throw BadHandleCastException();
+    }
+
     /*---------------------------------------------------------------------------------*/
     /* Handle<T> - Usage Functions                                                     */
     /*---------------------------------------------------------------------------------*/
@@ -63,6 +77,28 @@ namespace SHADE
         return &library->Get(*this);
     }
 
+    /*---------------------------------------------------------------------------------*/
+    /* Handle<void> - Constructors                                                     */
+    /*---------------------------------------------------------------------------------*/
+    template<typename T>
+    Handle<void>::Handle(const Handle<T>& handle)
+    : library{ static_cast<SHResourceLibraryBase*>(handle.library) }
+    {
+        id = handle.id;
+    }
+
+    /*---------------------------------------------------------------------------------*/
+    /* Handle<void> - Overloaded Operators                                             */
+    /*---------------------------------------------------------------------------------*/
+    template<typename T>
+    bool SHADE::Handle<void>::operator==(const Handle<T>& rhs) const noexcept
+    {
+        return id.Raw == rhs.id.Raw && library == static_cast<void*>(rhs.library);
+    }
+
+    /*---------------------------------------------------------------------------------*/
+    /* ISelfHandle<T> - Constructors                                                   */
+    /*---------------------------------------------------------------------------------*/
     template<typename T>
     inline ISelfHandle<T>::ISelfHandle(const ISelfHandle& rhs)
     : handle { rhs.handle }
@@ -73,6 +109,9 @@ namespace SHADE
     : handle { rhs.handle }
     {}
 
+    /*---------------------------------------------------------------------------------*/
+    /* ISelfHandle<T> - Overloaded Operators                                           */
+    /*---------------------------------------------------------------------------------*/
     template<typename T>
     inline ISelfHandle<T>& ISelfHandle<T>::operator=(const ISelfHandle& rhs)
     {

SHADE_Engine/src/Resource/SHResourceLibrary.h

@@ -11,13 +11,31 @@
 
 namespace SHADE
 {
+    /// <summary>
+    /// Base class for SHResourceLibrary that holds information about the library type.
+    /// </summary>
+    class SHResourceLibraryBase
+    {
+      public:
+        /*-----------------------------------------------------------------------------*/
+        /* Getter Functions                                                            */
+        /*-----------------------------------------------------------------------------*/
+        inline std::type_index GetType() { return libraryType; }
+
+      protected:
+        /*-----------------------------------------------------------------------------*/
+        /* Data Members                                                                */
+        /*-----------------------------------------------------------------------------*/
+        std::type_index libraryType = typeid(void);
+    };
+
     /// <summary>
     /// Generic Resource Library for a specified type of Resource. This object will own
     /// any resources created using it.
     /// </summary>
     /// <typeparam name="T">Type of resources that this library stores.</typeparam>
     template<typename T>
-    class SHResourceLibrary
+    class SHResourceLibrary : public SHResourceLibraryBase
     {
       public:
         /*-----------------------------------------------------------------------------*/

SHADE_Engine/src/Resource/SHResourceLibrary.hpp

@@ -13,10 +13,11 @@ namespace SHADE
     SHResourceLibrary<T>::SHResourceLibrary()
     {
         // Type Checking
-        //static_assert(std::is_copy_assignable_v<T>, "Resource Library's resources must be copy assignable.");
-        //static_assert(std::is_copy_constructible_v<T>, "Resource Library's resources must be copy constructible.");
         static_assert(std::is_move_assignable_v<T>, "Resource Library's resources must be move assignable.");
         static_assert(std::is_move_constructible_v<T>, "Resource Library's resources must be move constructible.");
+
+        // Keep track of the type for conversions
+        libraryType = typeid(T);
     }
 
     /*---------------------------------------------------------------------------------*/

SHADE_Engine/src/Resource/SHResourceManager.cpp

@@ -0,0 +1,95 @@
+/************************************************************************************//*!
+\file           SHResourceManager.cpp
+\author         Tng Kah Wei, kahwei.tng, 390009620
+\par            email: kahwei.tng\@digipen.edu
+\date           Oct 21, 2022
+\brief          Contains the definition of the functions of the SHResourceManager static 
+                class.
+
+Copyright (C) 2022 DigiPen Institute of Technology.
+Reproduction or disclosure of this file or its contents without the prior written consent
+of DigiPen Institute of Technology is prohibited.
+*//*************************************************************************************/
+#include  "SHpch.h"
+// Primary Include
+#include "SHResourceManager.h"
+
+namespace SHADE
+{
+  /*-----------------------------------------------------------------------------------*/
+  /* Static Data Member Definitions                                                    */
+  /*-----------------------------------------------------------------------------------*/
+  SHResourceHub SHResourceManager::resourceHub;
+  std::unordered_map<std::type_index, std::unordered_map<AssetID, Handle<void>>> SHResourceManager::handlesMap;
+  std::unordered_map<std::type_index, SHADE::SHResourceManager::HandleAssetMap> SHResourceManager::assetIdMap;
+  std::unordered_map<std::type_index, std::function<void(AssetID)>> SHResourceManager::typedFreeFuncMap;
+  std::vector<AssetID> SHResourceManager::loadedAssetData;
+
+  /*-----------------------------------------------------------------------------------*/
+  /* Function Definitions                                                              */
+  /*-----------------------------------------------------------------------------------*/
+  void SHResourceManager::Unload(AssetID assetId)
+  {
+    // Search each library for the asset ID and try to free it
+    Handle handle;
+    for (auto& typedHandleMap : handlesMap)
+    {
+      if (typedHandleMap.second.contains(assetId))
+      {
+        // Save handle for later
+        handle = typedHandleMap.second[assetId];
+        // Dispose
+        typedFreeFuncMap[typedHandleMap.first](assetId);
+        typedHandleMap.second.erase(assetId);
+      }
+    }
+
+    // No handles were found
+    if (!handle)
+      return;
+
+    for (auto& typedAssetIdsMap : assetIdMap)
+    {
+      if (typedAssetIdsMap.second.contains(handle))
+      {
+        // Dispose
+        typedAssetIdsMap.second.erase(handle);
+      }
+    }
+  }
+
+  void SHResourceManager::FinaliseChanges()
+  {
+    SHGraphicsSystem* gfxSystem = SHSystemManager::GetSystem<SHGraphicsSystem>();
+    if (gfxSystem == nullptr)
+      throw std::runtime_error("[SHResourceManager] Attempted to load graphics resource without a SHGraphicsSystem installed.");
+    gfxSystem->BuildMeshBuffers();
+    gfxSystem->BuildTextures();
+
+    // Free CPU Resources
+    for (auto assetId : loadedAssetData)
+    {
+      SHAssetManager::Unload(assetId);
+    }
+    loadedAssetData.clear();
+  }
+
+  /*-----------------------------------------------------------------------------------*/
+  /* Query Functions                                                                   */
+  /*-----------------------------------------------------------------------------------*/
+  std::optional<AssetID> SHResourceManager::GetAssetID(Handle<void> handle)
+  {
+    const Handle GENERIC_HANDLE = Handle(handle);
+
+    // Search each library for the asset ID and try to free it
+    for (auto& typedAssetIdsMap : assetIdMap)
+    {
+      if (typedAssetIdsMap.second.contains(GENERIC_HANDLE))
+      {
+        return typedAssetIdsMap.second[GENERIC_HANDLE];
+      }
+    }
+
+    return {};
+  }
+}

SHADE_Engine/src/Resource/SHResourceManager.h

@@ -0,0 +1,130 @@
+/************************************************************************************//*!
+\file           SHResourceManager.h
+\author         Tng Kah Wei, kahwei.tng, 390009620
+\par            email: kahwei.tng\@digipen.edu
+\date           Oct 21, 2022
+\brief          Contains the definition of the SHResourceManager static class.
+
+Copyright (C) 2022 DigiPen Institute of Technology.
+Reproduction or disclosure of this file or its contents without the prior written consent
+of DigiPen Institute of Technology is prohibited.
+*//*************************************************************************************/
+#pragma once
+
+// STL Includes
+#include <unordered_map>
+// Project Includes
+#include "SH_API.h"
+#include "SHResourceLibrary.h"
+#include "Assets/SHAssetMacros.h"
+
+namespace SHADE
+{
+  /// <summary>
+  /// Static class responsible for loading and caching runtime resources from their
+  /// serialised Asset IDs.
+  /// </summary>
+  class SH_API SHResourceManager
+  {
+    public:
+    /*---------------------------------------------------------------------------------*/
+    /* Loading Functions                                                               */
+    /*---------------------------------------------------------------------------------*/
+    /// <summary>
+    /// Loads or retrieves an existing loaded object of the specified type with the
+    /// specified asset ID.
+    /// Note that for specific types, the retrieved Handle may not be valid until after
+    /// FinaliseChanges() is called.
+    /// </summary>
+    /// <typeparam name="ResourceType">
+    /// Type of resource to load.
+    /// </typeparam>
+    /// <param name="assetId">Asset ID of the resource to load.</param>
+    /// <returns>Handle to a loaded runtime asset.</returns>
+    template<typename ResourceType>
+    static Handle<ResourceType> LoadOrGet(AssetID assetId);
+    /// <summary>
+    /// Unloads an existing loaded asset. Attempting to unload an invalid Handle will 
+    /// simply do nothing except emit a warning.
+    /// Faster than the untemplated version.
+    /// </summary>
+    /// <typeparam name="ResourceType">Type of resource to unload.</typeparam>
+    /// <param name="assetId">Handle to the resource to unload.</param>
+    template<typename ResourceType>
+    static void Unload(Handle<ResourceType> assetId);
+    /// <summary>
+    /// Unloads an existing loaded asset. Attempting to unload an invalid Handle will 
+    /// simply do nothing except emit a warning.
+    /// Compared to the templated version, this function is slower as it requires
+    /// searching through the storage of all resource types.
+    /// </summary>
+    /// <param name="assetId">Handle to the resource to unload.</param>
+    static void Unload(AssetID assetId);
+    /// <summary>
+    /// Needs to be called to finalise all changes to loads.
+    /// </summary>
+    static void FinaliseChanges();
+
+    /*---------------------------------------------------------------------------------*/
+    /* Query Functions                                                                 */
+    /*---------------------------------------------------------------------------------*/
+    /// <summary>
+    /// Retrieves the AssetID associated with a specified Handle.
+    /// Faster than the untemplated version.
+    /// </summary>
+    /// <typeparam name="ResourceType">Type of resource to get the ID of.</typeparam>
+    /// <param name="handle">Handle to get the AssetID of.</param>
+    /// <return>
+    /// AssetID for the specified Handle. If the Handle is invalid, there will be no 
+    /// value.
+    /// </return>
+    template<typename T>
+    static std::optional<AssetID> GetAssetID(Handle<T> handle);
+    /// <summary>
+    /// Retrieves the AssetID associated with a specified Handle.
+    /// Compared to the templated version, this function is slower as it requires
+    /// searching through the storage of all resource types.
+    /// </summary>
+    /// <param name="handle">Handle to get the AssetID of.</param>
+    /// <return>
+    /// AssetID for the specified Handle. If the Handle is invalid, there will be no 
+    /// value.
+    /// </return>
+    static std::optional<AssetID> GetAssetID(Handle<void> handle);
+
+    private:
+    /*---------------------------------------------------------------------------------*/
+    /* Type Definitions                                                                */
+    /*---------------------------------------------------------------------------------*/
+    using AssetHandleMap = std::unordered_map<AssetID, Handle<void>>;
+    using HandleAssetMap = std::unordered_map<Handle<void>, AssetID>;
+    using AssetHandleMapRef = std::reference_wrapper<AssetHandleMap>;
+    using HandleAssetMapRef = std::reference_wrapper<HandleAssetMap>;
+
+    /*---------------------------------------------------------------------------------*/
+    /* Data Members                                                                    */
+    /*---------------------------------------------------------------------------------*/
+    // Handles
+    static SHResourceHub resourceHub;
+    static std::unordered_map<std::type_index, AssetHandleMap> handlesMap;
+    static std::unordered_map<std::type_index, HandleAssetMap> assetIdMap;
+    static std::unordered_map<std::type_index, std::function<void(AssetID)>> typedFreeFuncMap;
+    // Pointers to temp CPU resources
+    static std::vector<AssetID> loadedAssetData;
+
+    /*---------------------------------------------------------------------------------*/
+    /* Helper Functions                                                                */
+    /*---------------------------------------------------------------------------------*/
+    /// <summary>
+    /// Retrieves or creates the AssetHandleMap for the specific type if it doesn't exist
+    /// </summary>
+    /// <typeparam name="ResourceType">
+    /// The type of AssetHandleMap to retrieve.
+    /// </typeparam>
+    /// <returns>Reference to the AssetHandleMap of the specified type.</returns>
+    template<typename ResourceType>
+    static std::pair<AssetHandleMapRef, HandleAssetMapRef> getAssetHandleMap();
+  };
+}
+
+#include "SHResourceManager.hpp"

SHADE_Engine/src/Resource/SHResourceManager.hpp

@@ -0,0 +1,171 @@
+/************************************************************************************//*!
+\file           SHResourceManager.hpp
+\author         Tng Kah Wei, kahwei.tng, 390009620
+\par            email: kahwei.tng\@digipen.edu
+\date           Oct 21, 2022
+\brief          Contains the definition of the function templates of the 
+                SHResourceManager static class.
+
+Copyright (C) 2022 DigiPen Institute of Technology.
+Reproduction or disclosure of this file or its contents without the prior written consent
+of DigiPen Institute of Technology is prohibited.
+*//*************************************************************************************/
+#pragma once
+// Primary Include
+#include "SHResourceManager.h"
+// Project Includes
+#include "Assets/SHAssetManager.h"
+#include "Graphics/MiddleEnd/Interface/SHGraphicsSystem.h"
+#include "ECS_Base/Managers/SHSystemManager.h"
+#include "Tools/SHLog.h"
+
+namespace SHADE
+{
+  /*-----------------------------------------------------------------------------------*/
+  /* Loading Functions                                                                 */
+  /*-----------------------------------------------------------------------------------*/
+  template<typename ResourceType>
+  Handle<ResourceType> SHResourceManager::LoadOrGet(AssetID assetId)
+  {
+    // Check if it is an unsupported type
+    if (!std::is_same_v<ResourceType, SHMesh> && !std::is_same_v<ResourceType, SHTexture>)
+    {
+      static_assert(true, "Unsupported Resource Type specified for SHResourceManager.");
+    }
+
+    /* Attempt to get existing loaded asset */
+    auto [typedHandleMap, typedAssetIdMap] = getAssetHandleMap<ResourceType>();
+    if (typedHandleMap.get().contains(assetId))
+      return Handle<ResourceType>(typedHandleMap.get()[assetId]);
+
+    /* Otherwise, we need to load it! */
+    // Meshes
+    if constexpr (std::is_same_v<ResourceType, SHMesh>)
+    {
+      // Get system
+      SHGraphicsSystem* gfxSystem = SHSystemManager::GetSystem<SHGraphicsSystem>();
+      if (gfxSystem == nullptr)
+        throw std::runtime_error("[SHResourceManager] Attempted to load graphics resource without a SHGraphicsSystem installed.");
+
+      // Load
+      const SHMeshAsset* assetData = SHAssetManager::GetMesh(assetId);
+      if (assetData == nullptr)
+      {
+        SHLog::Warning("[SHResourceManager] Attempted to load an asset with an invalid Asset ID.");
+        return {};
+      }
+      loadedAssetData.emplace_back(assetId);
+
+      Handle<SHMesh> meshHandle = gfxSystem->AddMesh
+      (
+        assetData->vertexPosition.size(), 
+        assetData->vertexPosition.data(),
+        assetData->texCoords.data(),
+        assetData->vertexTangent.data(),
+        assetData->vertexNormal.data(),
+        assetData->indices.size(),
+        assetData->indices.data()
+      );
+      Handle genericHandle = Handle(meshHandle);
+      typedHandleMap.get().emplace(assetId, genericHandle);
+      typedAssetIdMap.get().emplace(genericHandle, assetId);
+      return meshHandle;
+    }
+    // Textures
+    else if constexpr (std::is_same_v<ResourceType, SHTexture>)
+    {
+      // Get system
+      SHGraphicsSystem* gfxSystem = SHSystemManager::GetSystem<SHGraphicsSystem>();
+      if (gfxSystem == nullptr)
+        throw std::runtime_error("[SHResourceManager] Attempted to load graphics resource without a SHGraphicsSystem installed.");
+
+      // Load
+      const SHTextureAsset* assetData = SHAssetManager::GetTexture(assetId);
+      if (assetData == nullptr)
+      {
+        SHLog::Warning("[SHResourceManager] Attempted to load an asset with an invalid Asset ID.");
+        return {};
+      }
+      loadedAssetData.emplace_back(assetId);
+
+      Handle<SHTexture> texHandle = gfxSystem->AddTexture
+      (
+        assetData->numBytes,
+        assetData->pixelData,
+        assetData->width,
+        assetData->height,
+        assetData->format,
+        assetData->mipOffsets
+      );
+      typedHandleMap.get().emplace(assetId, Handle(texHandle));
+      return texHandle;
+    }
+  }
+
+  template<typename ResourceType>
+  void SHResourceManager::Unload(Handle<ResourceType> assetId)
+  {
+    // Check if it is an unsupported type
+    if (!std::is_same_v<ResourceType, SHMesh> && !std::is_same_v<ResourceType, SHTexture>)
+    {
+      static_assert(true, "Unsupported Resource Type specified for SHResourceManager.");
+    }
+
+    /* Attempt to get existing loaded asset */
+    auto [typedHandleMap, typedAssetIdMap] = getAssetHandleMap<ResourceType>();
+    if (typedHandleMap.get().contains(assetId))
+    {
+      // Dispose
+      Handle handle = typedHandleMap.get()[assetId];
+      Handle<ResourceType> typedHandle = static_cast<Handle<ResourceType>>(handle);
+      typedHandle.Free();
+      typedAssetIdMap.get().erase(handle);
+      typedHandleMap.get().erase(assetId);
+    }
+    else
+    {
+      // There's nothing to remove
+      SHLog::Warning("[SHResourceManager] Attempted to unload an invalid resource. Ignoring.");
+    }
+  }
+
+  /*-----------------------------------------------------------------------------------*/
+  /* Query Functions                                                                   */
+  /*-----------------------------------------------------------------------------------*/
+  template<typename T>
+  static std::optional<AssetID> SHResourceManager::GetAssetID(Handle<T> handle)
+  {
+    const Handle GENERIC_HANDLE = Handle(handle);
+    auto [typedHandleMap, typedAssetIdMap] = getAssetHandleMap<T>();
+    if (typedAssetIdMap.get().contains(GENERIC_HANDLE))
+    {
+      return typedAssetIdMap.GetId()[GENERIC_HANDLE];
+    }
+
+    return {};
+  }
+
+  /*-----------------------------------------------------------------------------------*/
+  /* Helper Functions                                                                  */
+  /*-----------------------------------------------------------------------------------*/
+  template<typename ResourceType>
+  std::pair<SHResourceManager::AssetHandleMapRef, SHResourceManager::HandleAssetMapRef> SHResourceManager::getAssetHandleMap()
+  {
+     const std::type_index TYPE = typeid(ResourceType);
+
+    if (!handlesMap.contains(TYPE))
+    {
+      handlesMap.emplace(TYPE, AssetHandleMap{});
+      assetIdMap.emplace(TYPE, HandleAssetMap{});
+      typedFreeFuncMap.emplace
+      (
+        TYPE, 
+        [TYPE](AssetID assetId)
+        {
+          static_cast<Handle<ResourceType>>(SHResourceManager::handlesMap[TYPE][assetId]).Free();
+        }
+      );
+    }
+    return std::make_pair(std::ref(handlesMap[TYPE]), std::ref(assetIdMap[TYPE]));
+  }
+}