include/fggl/app.hpp

@@ -15,7 +15,7 @@
 #ifndef FGGL_INCLUDE_FGGL_APP_HPP
 #define FGGL_INCLUDE_FGGL_APP_HPP
 
-#define assertm(exp, msg) assert(((void)msg, exp))
+#define ASSERT_MSG(exp, msg) assert(((void)(msg), exp))
 
 #include <cassert>
 #include <string>
@@ -44,6 +44,8 @@ namespace fggl {
 			 * A state is responsible for managing user interaction with the app. When created, the appstate
 			 * is passed a reference to the application that owns it. The lifetime of the state is bounded
 			 * by the lifetype of this object.
+             *
+             * Ie. the lifetime of reference to the App is at least that of the AppState.
 			 *
 			 * @param owner a non-owned reference to the owner of the state.
 			 */
@@ -72,63 +74,138 @@ namespace fggl {
 			 */
 			virtual void render(gfx::Graphics &paint) = 0;
 
+            /**
+             * Notify the State it has just been switched to.
+             *
+             * This state should perform any setup it requires (eg, registering callbacks, requesting 
+             * resources, etc...).
+             *
+             * FIXME: This should probably be RAII
+             */
 			virtual void activate() {}
 
+            /**
+             * Notify the State it is about to be switched from.
+             *
+             * This state should perform any cleanup it requires (eg, unregistering callbacks, freeing
+             * resources, etc...).
+             *
+             * FIXME: This should probably be RAII
+             */
 			virtual void deactivate() {}
 
+			[[nodiscard]] inline auto owner() const -> App& {
+				return m_owner;
+			}
+
 		protected:
 			App &m_owner;
 	};
 
+    /*! \class App app.hpp fggl/app.hpp
+     *
+     * Main entrypoint to the game framework.
+     */
 	class App {
 		public:
-			explicit App(modules::Manager *serivces, const Identifer &name);
-			App(modules::Manager *services, const Identifer &name, const Identifer &folderName);
+            /**
+             * Create an instance of an application, with a set of modules and name.
+             *
+             * The name is used to derrive verious settings, such as the location of same games and user
+             * configuration and content.
+             */
+			explicit App(modules::Manager *manager, const Identifer &name);
+
+            /**
+             * Create an instance of an application, with a set of modules and name.
+             *
+             * This version of the constructor allows explicitly setting the name used for user-data rather
+             * than derriving it from the application name. This is useful if you want to use a shortened
+             * version of your application name for configuration.
+             */
+			App(modules::Manager *manager, const Identifer &name, const Identifer &folderName);
 
 			// class is non copy-able
 			App(const App &app) = delete;
 			App(const App &&app) = delete;
 
-			App &operator=(const App &other) = delete;
-			App &operator=(App &&other) = delete;
+			auto operator=(const App &other) -> App & = delete;
+			auto operator=(App &&other) -> App & = delete;
 
+            /**
+             * Set the currently active window.
+             *
+             * FIXME: this is a nasty hack to get round the setup order for windows, graphics APIs and
+             * screen refreshes. Should be fixed with observer pattern.
+             */
 			inline void setWindow(display::Window *window) {
 				m_window = window;
 			}
 
 			/**
 			 * Perform main game loop functions.
+             *
+             * You should pass in argc and argv used to invoke main to this method. At the moment it does
+             * not use these, but in the future they will be used to provide game-agnostic options.
 			 */
-			int run(int argc, const char **argv);
-
+			auto run(int argc, const char **argv) -> int;
+
+            /**
+             * Register a new state with the application.
+             * 
+             * States are intended to be a block of code which can be started, will execute a single frame
+             * of work, and can be invoked repeatedly. For example, a main menu, options menu, 
+             * single-player game and multi-player game might be all be suitable to be states. When a state
+             * change is requested, the currently running state is stopped and garabage collected.
+             *
+             * This is similar to the concept of an 'activity' in Android.
+             */
 			template<typename T>
-			T *addState(const Identifer &name) {
+			auto addState(const Identifer &name) -> T * {
 				static_assert(std::is_base_of<AppState, T>::value, "States must be AppStates");
 				return m_states.put<T>(name, *this);
 			}
 
+            /**
+             * Request the game changes states.
+             *
+             * This will be executed at the next opporunity (most likley next iteration of the game loop).
+             * Identifer should be an identifier used when calling addState, and the state should previouslly
+             * been registered using addState.
+             */
 			inline void change_state(const Identifer &name) {
 				m_expectedScene = name;
-				/*m_states.active().deactivate();
-				m_states.change(name);
-				m_states.active().activate();*/
 			}
 
-			inline AppState &active_state() const {
+            /**
+             * Return the currently active state (the state that is currently executing).
+             */
+			inline auto active_state() const -> AppState & {
 				return m_states.active();
 			}
 
+            /**
+             * Get a pointer to a service.
+             *
+             * This is the primary way in which states can get access to resources they require.
+             *
+             * returns nullptr if the service does not exist, or cannot be provided.
+             */
 			template<typename T>
-			inline T *service() {
+			inline auto service() -> T * {
 				try {
 					return m_subsystems->template get<T>();
 				} catch (std::out_of_range &e) {
-					debug::log(debug::Level::error, "Service not found: {}", T::service);
+					debug::log(debug::Level::error, "Service not found: {}", T::service.get());
 					return nullptr;
 				}
 			}
 
-			inline bool running() const {
+			inline auto services() -> modules::Services& {
+				return m_subsystems->services();
+			}
+
+			inline auto running() const -> bool {
 				return m_running;
 			}
 

include/fggl/assets/loader.hpp

@@ -27,6 +27,7 @@
 #include <variant>
 
 #include "fggl/assets/types.hpp"
+#include "fggl/assets/packed/adapter.hpp"
 #include "fggl/data/storage.hpp"
 
 namespace fggl::assets {
@@ -39,14 +40,15 @@ namespace fggl::assets {
 
 	struct ResourceRequest {
 		AssetGUID m_guid;
-		AssetType m_type;
+		AssetTypeID m_type;
 	};
 
+
 	class Loader {
 		public:
-			constexpr const static modules::ModuleService service = modules::make_service("fggl::assets::Loader");
+			constexpr const static auto service = modules::make_service("fggl::assets::Loader");
 
-			explicit inline Loader(data::Storage *storage) : m_storage(storage) {}
+			explicit inline Loader(data::Storage *storage, CheckinAdapted *checkin) : m_storage(storage), m_checkin(checkin) {}
 
 			explicit Loader(Loader *parent, data::Storage *storage) : m_parent(parent), m_storage(storage) {};
 
@@ -56,34 +58,100 @@ namespace fggl::assets {
 			Loader(Loader &&) = delete;
 			Loader &operator=(Loader &&) = delete;
 
-			inline void setFactory(AssetType type, Checkin fn, LoadType loading = LoadType::DIRECT) {
+			inline void setFactory(AssetTypeID type, Checkin fn, LoadType loading = LoadType::DIRECT) {
 				m_factories[type] = std::make_pair(fn, loading);
 			}
 
-			inline void unsetFactory(AssetType type) {
+			inline void unsetFactory(AssetTypeID type) {
 				m_factories.erase(type);
 			}
 
-			inline void request(const AssetGUID &guid, const AssetType &type) {
+			inline void request(const AssetGUID &guid, const AssetTypeID &type) {
 				m_requests.push(ResourceRequest{guid, type});
 			}
 
-			void load(const AssetGUID &guid, const AssetType &type) {
-				auto path = m_storage->resolvePath(data::StorageType::Data, guid);
-
-				auto &config = m_factories.at(type);
-				switch (config.second) {
-				case LoadType::DIRECT:
-					// TODO we load the data into main memory and give a pointer to it.
-					debug::log(debug::Level::error, "Tried to load direct asset - no one wrote that yet!");
-					break;
-				case LoadType::STAGED:
-					// TODO we load the data into temp memory and give a pointer to it.
-					debug::log(debug::Level::error, "Tried to load staged asset - no one wrote that yet!");
-					break;
-				case LoadType::PATH: config.first(guid, AssetData(&path));
-					break;
+			void loadChain(const AssetGUID &guid, const std::string& pack = "core") {
+				loadChain( assets::make_asset_id_rt(pack, guid) );
+			}
+
+			void loadChain(AssetID asset, void* userPtr = nullptr) {
+				if (!m_checkin->exists(asset)) {
+					debug::warning("attempted to chain load unknown assetID {}", asset);
+					return;
+				}
+
+
+				std::queue<AssetID> loadOrder;
+				m_checkin->loadOrder(asset, loadOrder);
+				processChain(loadOrder, userPtr);
+			}
+
+			void processChain( std::queue<AssetID>& loadOrder, void* userPtr = nullptr ) {
+				if ( loadOrder.empty() ) {
+					return;
 				}
+
+				debug::info("Starting chain load");
+				while( !loadOrder.empty() ) {
+					auto it = loadOrder.front();
+					debug::info(" CHAIN -> loading {}", it );
+					load( it, userPtr );
+					loadOrder.pop();
+				}
+				debug::info("Ended chain loader");
+			}
+
+			inline void load(const AssetGUID& guid, const AssetTypeID& type, void* userPtr = nullptr, const std::string& pack = "core" ) {
+				auto assetID = assets::make_asset_id_rt(pack, guid);
+
+				// try checkin load first, falling back if it fails
+				bool checkinLoad = load( assetID, userPtr );
+				if ( !checkinLoad ) {
+					debug::info("could not perform checkin load for {} - missing loaders?", guid);
+
+					auto path = m_storage->resolvePath(data::StorageType::Data, guid);
+					loadDirect(path, assetID, type, pack, userPtr);
+				}
+			}
+
+			bool loadDirect( const std::filesystem::path& path, AssetID asset, AssetTypeID assetType, const std::string& pack, void* userPtr = nullptr ){
+				// check if we know how to load this asset (using old loaders)
+				auto factoryItr = m_factories.find( assetType );
+				if ( factoryItr == m_factories.end() ) {
+					debug::error("attempted to load asset with unknown type: {}", assetType.get() );
+					return false;
+				}
+
+				// perform loading
+				LoaderContext ctx {
+					.pack = pack,
+					.packRoot = m_checkin->getPackPath(pack),
+					.assetPath = path
+				};
+
+				// perform loading
+				const auto& [callback, callbackType] = factoryItr->second;
+				if ( callbackType == LoadType::PATH ) {
+					callback(this, asset, ctx, userPtr);
+					return true;
+				}
+
+				debug::log(debug::Level::error, "Tried to use old/unsupported loading method");
+				return false;
+			}
+
+			bool load(const AssetID &assetId, void* userPtr = nullptr) {
+				if ( !m_checkin->exists(assetId) ) {
+					#ifndef NDEBUG
+						debug::warning("asked to load unknown asset: {}", util::guid_to_string( util::GUID::make(assetId.get()) ) );
+					#else
+						debug::warning("asked to load unknown asset: {}", assetId.get());
+					#endif
+					return false;
+				}
+
+				const auto& record = m_checkin->find( assetId );
+				return loadDirect( record.m_path, assetId, record.m_assetType, record.m_pack, userPtr );
 			}
 
 			void progress() {
@@ -113,8 +181,9 @@ namespace fggl::assets {
 			Loader *m_parent = nullptr;
 			using Config = std::pair<Checkin, LoadType>;
 			data::Storage *m_storage;
+			CheckinAdapted *m_checkin;
 			std::queue<ResourceRequest> m_requests;
-			std::map<AssetType, Config> m_factories;
+			std::map<AssetTypeID, Config> m_factories;
 	};
 
 } // namespace fggl::assets

include/fggl/assets/manager.hpp

@@ -23,16 +23,50 @@
 #include <map>
 #include <functional>
 #include <memory>
+#include <vector>
 
+#include "fggl/debug/logging.hpp"
 #include "fggl/assets/types.hpp"
 #include "fggl/util/safety.hpp"
+#include "fggl/modules/module.hpp"
 
 namespace fggl::assets {
 
+	struct AssetBox {
+		virtual ~AssetBox() = default;
+		virtual void release() = 0;
+	};
+
+	template<typename T>
+	struct AssetBoxT : public AssetBox {
+		T* asset = nullptr;
+
+		explicit inline AssetBoxT(T* aasset) : asset(aasset) {}
+
+		// no copy: we own our resource!
+		AssetBoxT(const AssetBoxT&) = delete;
+		AssetBoxT& operator=(const AssetBoxT&) = delete;
+
+		// move OK - we can steal the asset
+		AssetBoxT(AssetBoxT&& other) : asset(other.asset) {
+			other.asset = nullptr;
+		}
+
+		inline ~AssetBoxT() override {
+			if ( asset != nullptr ) {
+				delete asset;
+				asset = nullptr;
+			}
+		}
+
+		inline void release() override {
+			asset = nullptr;
+		}
+	};
+
 	class AssetManager {
 		public:
-			constexpr const static modules::ModuleService service = modules::make_service("fggl::assets::Manager");
-			using AssetGUID = std::string;
+			constexpr const static modules::ServiceName service = modules::make_service("fggl::assets::Manager");
 
 			AssetManager() = default;
 			virtual ~AssetManager() = default;
@@ -43,36 +77,63 @@ namespace fggl::assets {
 			AssetManager(AssetManager &&) = delete;
 			AssetManager &operator=(AssetManager &&) = delete;
 
-			inline AssetRefRaw getRaw(const AssetGUID &guid) const {
-				return m_registry.at(guid).asset;
+			template<typename T>
+			T* get(const AssetID &guid) const {
+				try {
+					const auto &assetRecord = m_registry.at(guid);
+					std::shared_ptr<AssetBoxT<T>> casted = std::dynamic_pointer_cast<AssetBoxT<T>>(assetRecord);
+					if ( casted == nullptr ) {
+						debug::error("Asset type requested did not match loaded asset type!");
+						return nullptr;
+					}
+					return casted->asset;
+				} catch (std::out_of_range& e) {
+					return nullptr;
+				}
 			}
 
+			/**
+			 * Pass ownership of the asset to the asset system.
+			 *
+			 * Once this method is called, the asset system owns the asset, and will free
+			 * it when it is no longer required. The asset system assumes it is fully aware
+			 * of all usages of the assets it manages via its graph.
+			 *
+			 * @tparam T the asset type to be managed
+			 * @param guid the asset name
+			 * @param assetRef the asset itself
+			 * @return the owned asset pointer
+			 */
 			template<typename T>
-			AssetRef<T> get(const AssetGUID &guid) const {
-				return std::dynamic_pointer_cast<T>(getRaw(guid));
+			T* set(const AssetID &guid, T* assetRef) {
+				auto ptr = std::make_shared<AssetBoxT<T>>(assetRef);
+
+				m_registry[guid] = ptr;
+				return (*ptr).asset;
 			}
 
-			inline void require(const AssetGUID &guid) {
-				m_registry.at(guid).refCount++;
+			inline void require(const AssetID &/*guid*/) {
+				//m_registry.at(guid).refCount++;
 			}
 
-			inline void release(const AssetGUID &guid) {
-				m_registry.at(guid).refCount--;
+			inline bool has(const AssetID &guid) {
+				return m_registry.contains(guid);
 			}
 
-		private:
-			struct AssetRecord {
-				std::shared_ptr<Asset> asset = nullptr;
-				std::size_t refCount;
+			inline void release(const AssetGUID &/*guid*/) {
+				//m_registry.at(guid).refCount--;
+			}
 
-				inline ~AssetRecord() {
-					if (asset != nullptr) {
-						asset->release();
-					}
+			inline std::vector<AssetID> known() {
+				std::vector<AssetID> assetList;
+				for ( auto& itr : m_registry ) {
+					assetList.push_back(itr.first);
 				}
-			};
+				return assetList;
+			}
 
-			std::map<AssetGUID, AssetRecord> m_registry;
+		private:
+			std::map<AssetID, std::shared_ptr<AssetBox>> m_registry;
 	};
 
 } // namespace fggl::assets

include/fggl/assets/module.hpp

@@ -20,7 +20,10 @@
 #define FGGL_ASSETS_MODULE_HPP
 
 #include "fggl/modules/module.hpp"
+
 #include "fggl/data/module.hpp"
+
+#include "fggl/assets/packed/module.hpp"
 #include "fggl/assets/manager.hpp"
 #include "fggl/assets/loader.hpp"
 
@@ -28,14 +31,15 @@ namespace fggl::assets {
 
 	struct AssetFolders {
 		constexpr static const char *name = "fggl::assets::Folders";
-		constexpr static const std::array<modules::ModuleService, 2> provides = {
+		constexpr static const std::array<modules::ServiceName, 2> provides = {
 			Loader::service,
 			AssetManager::service
 		};
-		constexpr static const std::array<modules::ModuleService, 1> depends = {
-			data::Storage::service
+		constexpr static const std::array<modules::ServiceName, 2> depends = {
+			data::Storage::service,
+			CheckinAdapted::service
 		};
-		static bool factory(modules::ModuleService name, modules::Services &serviceManager);
+		static bool factory(modules::ServiceName name, modules::Services &serviceManager);
 	};
 
 } // namespace fggl::assets

include/fggl/assets/packed/adapter.hpp

+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+//
+// Created by webpigeon on 19/11/22.
+//
+
+#ifndef FGGL_ASSETS_PACKED_ADAPTER_HPP
+#define FGGL_ASSETS_PACKED_ADAPTER_HPP
+
+#include <stack>
+#include <ranges>
+#include <algorithm>
+
+#include "fggl/assets/packed/direct.hpp"
+#include "fggl/data/storage.hpp"
+#include "fggl/ds/graph.hpp"
+
+namespace fggl::assets {
+
+	using ResourceType = util::OpaqueName<uint64_t, struct ResourceTypeStruct>;
+	constexpr ResourceType from_mime(const char* mime) {
+		return ResourceType::make( util::hash_fnv1a_64(mime) );
+	};
+
+	struct ResourceRecord {
+		std::filesystem::path m_path;
+		AssetID assetID;
+		ResourceType m_fileType;
+		AssetTypeID m_assetType;
+		std::string m_pack;
+		std::vector<AssetID> m_requires;
+	};
+
+	struct ManifestHeader {
+		uint64_t assetID;
+		uint64_t fileType;
+		uint64_t assetType;
+		uint64_t stringSize;
+	};
+
+	[[maybe_unused]]
+	inline bool NEEDS_CHECKIN(const std::filesystem::path&, MemoryBlock) {
+		debug::error("attempted to load asset which does not have a valid checkin yet");
+		return false;
+	}
+
+	/**
+	 * Adapter for Raw Checkin.
+	 *
+	 * For debugging/development it's a pain to have to pack assets directly. Although its much slower, it can be useful
+	 * to be able to load non-optimised formats at runtime. This adapter allows injecting these non-optimised formats
+	 * into the production checkin system.
+	 */
+	class CheckinAdapted {
+		public:
+			constexpr const static auto service = modules::make_service("fggl::assets::checkin::debug");
+
+			using FilePredicate = std::function<AssetTypeID(const std::filesystem::path&)>;
+			using FileLoader = std::function<bool(const std::filesystem::path&, MemoryBlock& block)>;
+			using AssetMetadata = std::function<bool(const std::string& pack, const std::filesystem::path& packRoot, ResourceRecord&)>;
+
+			CheckinAdapted(data::Storage* storage, RawCheckin* checkSvc) : m_storage(storage), m_checkin(checkSvc) {};
+
+			// asset loading
+			void load(AssetID asset) {
+				auto& assetRef = m_files.at(asset);
+				auto& loader = m_loaders.at(assetRef.m_fileType);
+
+				MemoryBlock block;
+				auto result = loader(assetRef.m_path, block);
+				if ( !result ) {
+					return;
+				}
+
+				m_checkin->check(assetRef.assetID, assetRef.m_assetType, block);
+			}
+
+			inline bool exists(AssetID asset) const {
+				return m_files.find(asset) != m_files.end();
+			}
+
+			inline std::filesystem::path getPath(AssetID asset) const {
+				const auto& file = m_files.at(asset);
+				return file.m_path;
+			}
+
+			void loadOrder( AssetID id, std::queue<AssetID>& order) {
+				m_requires.getOrderPartialRev(id, order);
+			}
+
+			void discover( const char* packName, bool useCache = false, bool updateCache = true) {
+				if ( m_packs.contains(packName) ) {
+					return;
+				}
+
+				std::string packRoot = "packs/";
+				auto packDir = m_storage->resolvePath( data::StorageType::Data, packRoot + packName );
+				discover(packDir, useCache, updateCache);
+			}
+
+			// asset discovery
+			void discover( std::filesystem::path& packDir, bool useCache=true, bool updateCache=false ) {
+				// note we're loading this pack
+				auto packName = packDir.filename();
+				m_packs[packName].rootDir = packDir;
+
+				if ( useCache && has_manifest(packDir)) {
+					// check if we've cached the search
+					load_manifest(packName, packDir);
+					return;
+				}
+
+				std::vector<AssetID> packFiles;
+				std::stack< std::filesystem::path > paths;
+				paths.push(packDir);
+
+				while ( !paths.empty() ) {
+					auto path = paths.top();
+					paths.pop();
+
+					if ( std::filesystem::is_directory(path) ) {
+						std::ranges::for_each( std::filesystem::directory_iterator{path}, [&paths](auto& path) {
+							paths.push(path);
+						});
+					} else if ( std::filesystem::is_regular_file(path) ) {
+						process_file( path, packDir, packFiles );
+					}
+				}
+
+				// update the cache and remember what pack maps to what asset
+				if ( updateCache ) {
+					save_manifest(packDir.filename(), packDir, packFiles);
+				}
+				m_packs[ packDir.filename() ].assets = packFiles;
+			}
+
+			inline void setLoader(ResourceType type, const CheckinAdapted::FileLoader& loader, CheckinAdapted::FilePredicate predicate = nullptr) {
+				assert( loader != nullptr );
+				m_loaders[type] = loader;
+
+				if ( predicate != nullptr ) {
+					m_predicates[type] = predicate;
+				}
+			}
+
+			inline void setProcessor(ResourceType type, AssetMetadata metaFunc) {
+				m_metadata[type] = metaFunc;
+			}
+
+			inline const ResourceRecord& find(AssetID asset) const {
+				return m_files.at(asset);
+			}
+
+			inline std::filesystem::path getPackPath(const std::string& name) const {
+				auto& info = m_packs.at(name);
+				return info.rootDir;
+			}
+
+		private:
+			data::Storage* m_storage;
+			RawCheckin* m_checkin;
+			std::map<AssetID, ResourceRecord> m_files;
+			ds::DirectedGraph<AssetID> m_requires;
+
+			struct PackInfo {
+				std::filesystem::path rootDir;
+				std::vector<AssetID> assets;
+			};
+
+			std::map<ResourceType, FilePredicate> m_predicates;
+			std::map<ResourceType, FileLoader> m_loaders;
+			std::map<ResourceType, AssetMetadata> m_metadata;
+			std::map<std::string, PackInfo> m_packs;
+
+			void process_file(std::filesystem::path path, std::filesystem::path packDir, std::vector<AssetID> packFiles) {
+				for( auto& [rType, pred] : m_predicates ) {
+					// check the predicate, is this valid?
+					auto aType = pred(path);
+					if ( aType != INVALID_ASSET_TYPE ) {
+						// it was, so we can finish processing
+						auto packName = packDir.filename();
+						auto relPath = std::filesystem::relative(path, packDir);
+						ResourceRecord rr{
+							.m_path = path,
+							.assetID = make_asset_id_rt(packName, relPath.generic_string()),
+							.m_fileType = rType,
+							.m_assetType = aType,
+							.m_pack = packName,
+							.m_requires = {}
+						};
+
+						// processors (for stuff like dependencies)
+						auto metaProc = m_metadata.find(rType);
+						if ( metaProc != m_metadata.end() ) {
+							metaProc->second( packName, packDir, rr );
+						}
+
+						// store the resulting data
+						m_files[rr.assetID] = rr;
+						packFiles.push_back( rr.assetID );
+						m_requires.addEdges( rr.assetID, rr.m_requires );
+
+						debug::trace("discovered {} ({}) from pack '{}'", rr.assetID, relPath.c_str(), packName.c_str() );
+						break;
+					}
+				}
+			}
+
+			inline bool has_manifest(const std::string& packName) {
+				auto packManifest = m_storage->resolvePath( data::StorageType::Cache, packName + "_manifest.bin" );
+				return std::filesystem::exists(packManifest);
+			}
+
+			void load_manifest_entry(FILE* file, const std::string& packName, const std::filesystem::path& packRoot) {
+				// read our entry ( id, ftype, atype, pathLen )
+				ManifestHeader header{};
+				std::fread(&header, sizeof(ManifestHeader), 1, file);
+
+				// read the relative asset path
+				char* relPath = new char[header.stringSize + 1];
+				std::fread( relPath, sizeof(char), header.stringSize, file );
+				relPath[ header.stringSize + 1 ] = '\0';
+
+				// read the dependency list
+				uint64_t nDeps = 0;
+				std::fread( &nDeps, sizeof(uint64_t), 1, file);
+				uint64_t *deps = new uint64_t[nDeps];
+				std::fread( deps, sizeof(uint64_t), nDeps, file );
+
+				std::vector<AssetID> depList;
+				for ( uint64_t i = 0; i < nDeps; ++i ) {
+					depList.push_back( AssetID::make(deps[i]) );
+				}
+
+				// calculate and verify path
+				std::filesystem::path fullPath = packRoot / relPath;
+				delete[] relPath;
+
+				if ( !std::filesystem::exists(fullPath) ) {
+					debug::warning("pack manifest for {} contained invalid path {}", packName, fullPath.c_str());
+					return;
+				}
+
+				// entry seems valid, load it
+				ResourceRecord rr {
+					.m_path = fullPath,
+					.assetID = AssetID::make(header.assetID),
+					.m_fileType = ResourceType::make(header.fileType),
+					.m_assetType = AssetTypeID::make(header.assetType),
+					.m_pack = packName,
+					.m_requires = depList
+				};
+				m_files[ rr.assetID ] = rr;
+				m_packs[ packRoot.filename() ].assets.push_back( rr.assetID );
+				m_requires.addEdges( rr.assetID, depList );
+				debug::trace("discovered {} ({}) from pack {}", rr.assetID.get(), fullPath.c_str(), packRoot.filename().c_str() );
+			}
+
+			void load_manifest(const std::string& packName, const std::filesystem::path& packRoot) {
+				auto packManifest = m_storage->resolvePath( data::StorageType::Cache, packName + "_manifest.bin" );
+				if ( !std::filesystem::exists(packManifest) ) {
+					return;
+				}
+
+				// open the manifest file and start extracting entries
+				FILE* file = std::fopen(packManifest.c_str(), "r");
+				if ( file == nullptr ) {
+					debug::warning("error opening manifest: {}", packManifest.c_str());
+					return;
+				}
+
+				// read the number of entries
+				uint64_t entries{0};
+				std::fread(&entries, sizeof(uint64_t), 1, file);
+				for ( uint64_t i = 0; i < entries; ++i) {
+					load_manifest_entry(file, packName, packRoot);
+				}
+
+				std::fclose( file );
+			}
+
+			void save_manifest(const std::string& packName, const std::filesystem::path& packRoot, const std::vector<AssetID>& assets) {
+				auto packManifest = m_storage->resolvePath( data::StorageType::Cache, packName + "_manifest.bin", true);
+
+				FILE* file = std::fopen(packManifest.c_str(), "w");
+				if ( file == nullptr) {
+					debug::warning("error saving manifest {}, missing dir?", packManifest.c_str());
+					return;
+				}
+
+				const uint64_t entries{ assets.size() };
+				std::fwrite( &entries, sizeof(uint64_t), 1, file);
+
+				// write the entries
+				for ( uint64_t i = 0; i < entries; ++i ) {
+					auto& assetID = assets[i];
+
+					auto& assetRecord = m_files.at(assetID);
+					auto relPath = std::filesystem::relative(assetRecord.m_path, packRoot);
+					auto relPathStr = relPath.generic_string();
+
+					ManifestHeader mh {
+						.assetID = assetRecord.assetID.get(),
+						.fileType = assetRecord.m_fileType.get(),
+						.assetType = assetRecord.m_assetType.get(),
+						.stringSize = relPathStr.size()
+					};
+					std::fwrite( &mh, sizeof(ManifestHeader), 1, file );
+					std::fwrite( relPathStr.c_str(), sizeof(char), relPathStr.size(), file );
+				}
+
+				std::fclose(file);
+			}
+	};
+
+}
+
+#endif //FGGL_ASSETS_PACKED_ADAPTER_HPP

include/fggl/assets/packed/direct.hpp

+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+//
+// Created by webpigeon on 19/11/22.
+//
+
+#ifndef FGGL_ASSETS_PACKED_DIRECT_HPP
+#define FGGL_ASSETS_PACKED_DIRECT_HPP
+
+#include <functional>
+#include <map>
+
+#include "fggl/assets/types.hpp"
+#include "fggl/util/safety.hpp"
+#include "fggl/util/guid.hpp"
+#include "fggl/modules/module.hpp"
+
+/**
+ * Raw Checkin.
+ *
+ * This is a version of the checkin system where the check-in functions are shown a raw block of memory and its their
+ * job to parse and load something meaningful from that.
+ */
+namespace fggl::assets {
+
+	class RawCheckin {
+		public:
+			constexpr const static auto service = modules::make_service("fggl::assets::checkin");
+			using DecodeAndCheckFunc = std::function<void(AssetGUID, MemoryBlock& block)>;
+
+			void check(AssetID, AssetTypeID, MemoryBlock& block) const;
+
+			inline void check(int64_t id, uint64_t type, MemoryBlock& block ) const {
+				check( AssetID::make(id), AssetTypeID::make(type), block );
+			}
+
+			inline void setCheckin(AssetTypeID type, DecodeAndCheckFunc func) {
+				m_check[type] = func;
+			}
+
+		private:
+			std::map<AssetTypeID, DecodeAndCheckFunc> m_check;
+	};
+
+}
+
+#endif //FGGL_ASSETS_PACKED_DIRECT_HPP

include/fggl/assets/packed/module.hpp

+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+//
+// Created by webpigeon on 27/06/22.
+//
+
+#ifndef FGGL_ASSETS_PACKED_MODULE_HPP
+#define FGGL_ASSETS_PACKED_MODULE_HPP
+
+#include "fggl/modules/module.hpp"
+#include "fggl/data/module.hpp"
+#include "fggl/assets/loader.hpp"
+
+#include "fggl/assets/packed/adapter.hpp"
+#include "fggl/assets/packed/direct.hpp"
+
+namespace fggl::assets {
+
+	struct PackedAssets {
+		constexpr static const char *name = "fggl::assets::packed";
+		constexpr static const std::array<modules::ServiceName, 2> provides = {
+			RawCheckin::service,
+			CheckinAdapted::service
+		};
+		constexpr static const std::array<modules::ServiceName, 1> depends = {
+			data::Storage::service
+		};
+		static bool factory(modules::ServiceName name, modules::Services &serviceManager);
+	};
+
+} // namespace fggl::assets
+
+#endif //FGGL_ASSETS_PACKED_MODULE_HPP

include/fggl/assets/packed/packed.hpp

+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+//
+// Created by webpigeon on 19/11/22.
+//
+
+#ifndef FGGL_ASSETS_PACKED_PACKED_HPP
+#define FGGL_ASSETS_PACKED_PACKED_HPP
+
+#include <cstdint>
+#include <cstdio>
+#include <memory>
+
+#include "fggl/assets/types.hpp"
+#include "fggl/assets/packed/direct.hpp"
+
+/**
+ * Packed file reader.
+ *
+ * Read assets stored as sequential [header,data] blocks. This reader does not care about dependencies, it assumes this
+ * was handled before storage (ie, asset dependencies are assumed to be stored before the asset that relies on them).
+ * The caller is also responsible for ensuring that assets in other archives are already loaded by the time the system
+ * assembles the composite assets into something usable.
+ *
+ * If either of these constraints are violated, the results are undefined.
+ */
+namespace fggl::assets {
+
+	struct Header {
+		uint64_t name;
+		uint64_t type;
+		std::size_t size;
+	};
+
+	bool read_header(std::FILE* stream, Header* header) {
+		constexpr auto headerSize = sizeof(Header);
+		auto readBytes = std::fread(header, headerSize, 1, stream);
+		return readBytes == headerSize;
+	}
+
+	bool read_data(std::FILE* stream, void* block, std::size_t size) {
+		auto readBytes = std::fread(block, size, 1, stream);
+		return readBytes == size;
+	}
+
+	void read_archive(RawCheckin* checkin, std::FILE* stream) {
+		while ( !std::feof(stream) ) {
+			Header header;
+			bool headRead = read_header(stream, &header);
+			if ( headRead && header.size != 0 ) {
+				// header has data
+				void* memBlock = std::malloc( header.size );
+				bool valid = read_data( stream, memBlock, header.size );
+
+				// read the data, check it in
+				if (valid) {
+					MemoryBlock block{
+						.data = (std::byte*)memBlock,
+						.size = header.size
+					};
+					checkin->check(header.name, header.type, block);
+				}
+			}
+		}
+	}
+}
+
+#endif //FGGL_ASSETS_PACKED_PACKED_HPP

include/fggl/assets/types.hpp

@@ -24,30 +24,83 @@
 #include <functional>
 
 #include "fggl/util/safety.hpp"
+#include "fggl/util/guid.hpp"
 
 namespace fggl::assets {
 	using AssetType = util::OpaqueName<std::string_view, struct AssetTag>;
 	using AssetGUID = std::string;
 	using AssetPath = std::filesystem::path;
 
-	struct Asset {
-		AssetType m_type;
-		virtual void release() = 0;
-		virtual bool active() = 0;
-	};
+	using AssetID = util::OpaqueName<uint64_t, struct AssetIDTag>;
+
+	template<unsigned L1, unsigned L2>
+	constexpr AssetID make_asset_id(const char (&pack)[L1], const char (&path)[L2]) {
+		auto hash = util::hash_fnv1a_64( util::cat( pack, ":", path ).c );
+		return AssetID::make( hash );
+	}
+
+	template<unsigned L1, unsigned L2, unsigned L3>
+	constexpr AssetID make_asset_id(const char (&pack)[L1], const char (&path)[L2], const char (&view)[L3]) {
+		auto hash = util::hash_fnv1a_64( util::cat( pack, ":", path, "[", view, "]").c );
+		return AssetID::make( hash );
+	}
+
+	AssetID make_asset_id_rt(const std::string &pack, const std::string &path, const std::string &view = "");
+	AssetID asset_from_user(const std::string &input, const std::string &pack = "core");
+
+	using AssetTypeID = util::OpaqueName<uint64_t, struct AssetTypeTag>;
+	constexpr auto INVALID_ASSET_TYPE = AssetTypeID::make(0);
+
+	constexpr AssetTypeID make_asset_type(const char* type) {
+		return AssetTypeID::make( util::hash_fnv1a_64(type) );
+	}
+
 
 	struct MemoryBlock {
-		void *data;
+		std::byte *data;
 		std::size_t size;
+
+		template<typename T>
+		T* viewAs(std::size_t offset = 0) {
+			static_assert( std::is_standard_layout<T>::value );
+			return (T*)( data[offset] );
+		}
 	};
 
-	using AssetRefRaw = std::shared_ptr<Asset>;
+	using AssetRefRaw = std::shared_ptr<void>;
+
+	struct LoaderContext {
+		std::string pack;
+		std::filesystem::path packRoot;
+		std::filesystem::path assetPath;
+
+		inline std::filesystem::path relParent() const {
+			return std::filesystem::relative( assetPath, packRoot ).parent_path();
+		}
 
-	template<typename T>
-	using AssetRef = std::shared_ptr<T>;
+		inline assets::AssetID makeRef(const char* name) const {
+			return assets::make_asset_id_rt(pack, relParent() / name );
+		}
+	};
 
-	using AssetData = std::variant<MemoryBlock, AssetPath *, FILE *>;
-	using Checkin = std::function<AssetRefRaw(const AssetGUID &, const AssetData &)>;
+	class Loader;
+	using Checkin = std::function<AssetRefRaw(Loader* loader, const AssetID &, const LoaderContext &, void* userPtr)>;
 }
 
+// formatter
+template<> struct fmt::formatter<fggl::assets::AssetID> {
+	constexpr auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
+		return ctx.begin();
+	}
+
+	template <typename FormatContext>
+	auto format(const fggl::assets::AssetID & guid, FormatContext& ctx) const -> decltype(ctx.out()) {
+		#ifndef NDEBUG
+		return fmt::format_to(ctx.out(), "ASSET[{}]", guid_to_string( fggl::util::GUID::make( guid.get() ) ));
+		#else
+		return fmt::format_to(ctx.out(), "ASSET[{}]", guid.get());
+		#endif
+	}
+};
+
 #endif //FGGL_ASSETS_TYPES_HPP

include/fggl/audio/audio.hpp

@@ -16,8 +16,11 @@
 #define FGGL_AUDIO_AUDIO_HPP
 
 #include <string>
+
 #include "fggl/data/storage.hpp"
 #include "fggl/modules/module.hpp"
+#include "fggl/assets/module.hpp"
+#include "fggl/assets/packed/module.hpp"
 
 //! backend independent audio interface
 namespace fggl::audio {
@@ -27,14 +30,34 @@ namespace fggl::audio {
 	 *
 	 * If the sampleCount is -1, the clip is invalid.
 	 */
-	struct AudioClip {
+	 template<typename T>
+	 struct AudioClip {
 		int channels = 0;
 		int sampleRate = 0;
 		int sampleCount = -1;
-		short *data = nullptr;
-	};
+		T *data = nullptr;
+
+		AudioClip() = default;
+		AudioClip(const AudioClip&) = delete;
+
+		inline ~AudioClip() {
+			std::free(data);
+			data = nullptr;
+		}
 
-	constexpr modules::ModuleService SERVICE_AUDIO_PLAYBACK = modules::make_service("fggl::audio::AudioService");
+		[[nodiscard]]
+		inline int size() const {
+			return sampleCount * sizeof(T);
+		}
+	 };
+
+	 using AudioClipShort = AudioClip<short>;
+	 using AudioClipByte = AudioClip<char>;
+
+	 constexpr auto ASSET_CLIP_SHORT = assets::make_asset_type("Audio:Clip:Short");
+	 constexpr auto ASSET_CLIP_BYTE = assets::make_asset_type("Audio:Clip:Byte");
+
+	constexpr auto SERVICE_AUDIO_PLAYBACK = modules::make_service("fggl::audio::AudioService");
 
 	/**
 	 *
@@ -42,9 +65,10 @@ namespace fggl::audio {
 	 */
 	class AudioService {
 		public:
-			constexpr static const modules::ModuleService service = SERVICE_AUDIO_PLAYBACK;
-			virtual void play(const std::string &filename, bool looping = false) = 0;
-			virtual void play(AudioClip &clip, bool looping = false) = 0;
+			constexpr static const modules::ServiceName service = SERVICE_AUDIO_PLAYBACK;
+
+			virtual void play(const assets::AssetGUID &asset, bool looping = false) = 0;
+			virtual void play(const AudioClipShort &clip, bool looping = false) = 0;
 
 			virtual ~AudioService() = default;
 	};

include/fggl/audio/null_audio.hpp

@@ -26,31 +26,27 @@ namespace fggl::audio {
 	class NullAudioService : public AudioService {
 		public:
 			NullAudioService() = default;
-			virtual ~NullAudioService() = default;
+			~NullAudioService() override = default;
 
-			void play(const std::string & /*filename*/, bool /*looping = false*/) override {}
+			NullAudioService(NullAudioService&) = delete;
+			NullAudioService(NullAudioService&&) = delete;
+			NullAudioService& operator=(const NullAudioService&) = delete;
+			NullAudioService& operator=(NullAudioService&&) = delete;
 
-			void play(AudioClip & /*clip*/, bool /*looping = false*/) override {}
+			void play(const std::string & /*filename*/, bool /*looping = false*/) override;
+			void play(const AudioClipShort & /*clip*/, bool /*looping = false*/) override;
 	};
 
+    //! A dummy audio module that does nothing
 	struct NullAudio {
 		constexpr static const char *name = "fggl::audio::NULL";
-		constexpr static const std::array<modules::ModuleService, 1> provides = {
+		constexpr static const std::array<modules::ServiceName, 1> provides = {
 			SERVICE_AUDIO_PLAYBACK
 		};
-		constexpr static const std::array<modules::ModuleService, 0> depends = {};
-		static const modules::ServiceFactory factory;
+		constexpr static const std::array<modules::ServiceName, 0> depends = {};
+		bool factory(modules::ServiceName, modules::Services&);
 	};
 
-	bool null_factory(modules::ModuleService service, modules::Services &services) {
-		if (service == SERVICE_AUDIO_PLAYBACK) {
-			services.bind<audio::AudioService, audio::NullAudioService>();
-			return true;
-		}
-		return false;
-	}
-
-	const modules::ServiceFactory NullAudio::factory = null_factory;
 
 } // namespace fggl::audio
 

include/fggl/audio/openal/audio.hpp

@@ -23,6 +23,8 @@
 #include <AL/alc.h>
 
 #include "fggl/audio/audio.hpp"
+#include "fggl/assets/manager.hpp"
+
 #include "fggl/data/storage.hpp"
 #include "fggl/math/types.hpp"
 
@@ -30,8 +32,16 @@
 #include <iostream>
 #include <memory>
 
+//! Audio backed by openal-soft
 namespace fggl::audio::openal {
 
+	constexpr uint32_t NULL_BUFFER_ID = 0;
+
+	assets::AssetRefRaw load_vorbis(assets::Loader* loader, const assets::AssetID &, const assets::LoaderContext &, void* userPtr);
+
+	bool load_vorbis_short(std::filesystem::path path, assets::MemoryBlock& block);
+	assets::AssetTypeID check_vorbis( const std::filesystem::path& path );
+
 	enum class AudioType {
 		MONO_8 = AL_FORMAT_MONO8,
 		MONO_16 = AL_FORMAT_MONO16,
@@ -39,7 +49,7 @@ namespace fggl::audio::openal {
 		STEREO_16 = AL_FORMAT_STEREO16
 	};
 
-	static void checkError(std::string context) {
+	static void check_error(const std::string& context) {
 		auto code = alGetError();
 		if (code == AL_NO_ERROR) {
 			return;
@@ -48,25 +58,25 @@ namespace fggl::audio::openal {
 		// now we check the error message
 		std::string error = "unknown";
 		switch (code) {
-		case ALC_INVALID_DEVICE: error = "Invalid Device";
-			break;
-		case ALC_INVALID_CONTEXT: error = "Invalid Context";
-			break;
-		case ALC_INVALID_ENUM: error = "Invalid enum";
-			break;
-		case ALC_INVALID_VALUE: error = "Invalid value";
-			break;
-		case ALC_OUT_OF_MEMORY: error = "Out of memory";
-			break;
-		default: error = "unknown error";
+			case ALC_INVALID_DEVICE: error = "Invalid Device";
+				break;
+			case ALC_INVALID_CONTEXT: error = "Invalid Context";
+				break;
+			case ALC_INVALID_ENUM: error = "Invalid enum";
+				break;
+			case ALC_INVALID_VALUE: error = "Invalid value";
+				break;
+			case ALC_OUT_OF_MEMORY: error = "Out of memory";
+				break;
+			default: error = "unknown error";
 		}
 
-		std::cerr << "OpenAL error: " << context << ": " << error << std::endl;
+		debug::error("OpenAL error: context={}, error={}", context, error);
 	}
 
 	class AudioBuffer {
 		public:
-			AudioBuffer() : m_buffer(0) {
+			AudioBuffer() : m_buffer(NULL_BUFFER_ID) {
 				alGenBuffers(1, &m_buffer);
 			}
 
@@ -74,16 +84,24 @@ namespace fggl::audio::openal {
 				alDeleteBuffers(1, &m_buffer);
 			}
 
+			AudioBuffer(const AudioBuffer&) = delete;
+			AudioBuffer(const AudioBuffer&&) = delete;
+
+			AudioBuffer& operator=(const AudioBuffer&) = delete;
+			AudioBuffer& operator=(const AudioBuffer&&) = delete;
+
 			inline void setData(AudioType type, void *data, ALsizei size, ALsizei frequency) {
+				assert( m_buffer != 0 );
+				assert( data != nullptr );
 				alBufferData(m_buffer, (ALenum) type, data, size, frequency);
 			}
 
-			inline ALuint value() {
+			inline ALuint value() const {
 				return m_buffer;
 			}
 
 		private:
-			ALuint m_buffer;
+			ALuint m_buffer = 0;
 	};
 
 	class AudioSource {
@@ -96,6 +114,11 @@ namespace fggl::audio::openal {
 				alDeleteSources(1, &m_source);
 			}
 
+			AudioSource(const AudioSource& source) = delete;
+			AudioSource(const AudioSource&& source) = delete;
+			AudioSource& operator=(const AudioSource&) = delete;
+			AudioSource& operator=(AudioSource&&) = delete;
+
 			inline void play() {
 				alSourcePlay(m_source);
 			}
@@ -115,21 +138,10 @@ namespace fggl::audio::openal {
 			inline void play(AudioBuffer &buffer, bool looping) {
 				alSourcei(m_source, AL_BUFFER, buffer.value());
 				alSourcei(m_source, AL_LOOPING, looping ? AL_TRUE : AL_FALSE);
+				alSourcePlay(m_source);
 			}
 
-			inline void play(AudioClip &clip, bool looping) {
-				checkError("pre play");
-
-				AudioType format = clip.channels == 1 ? AudioType::MONO_8 : AudioType::STEREO_8;
-				m_splat.setData(format, clip.data, clip.sampleCount, clip.sampleRate);
-				checkError("saving to buffer");
-
-				alSourcei(m_source, AL_BUFFER, m_splat.value());
-				alSourcei(m_source, AL_LOOPING, looping ? AL_TRUE : AL_FALSE);
-				checkError("setting parameters");
-
-				play();
-			}
+			inline void play(const AudioClipShort &clip, bool looping = false);
 
 			inline void velocity(math::vec3 &value) {
 				alSource3f(m_source, AL_VELOCITY, value.x, value.y, value.z);
@@ -150,32 +162,33 @@ namespace fggl::audio::openal {
 
 	class AudioServiceOAL : public AudioService {
 		public:
-			explicit AudioServiceOAL(data::Storage *storage) : m_device(alcOpenDevice(nullptr)), m_storage(storage) {
+			explicit AudioServiceOAL(assets::AssetManager *assets) : m_device(alcOpenDevice(nullptr)), m_assets(assets) {
 				if (m_device != nullptr) {
 					m_context = alcCreateContext(m_device, nullptr);
 					alcMakeContextCurrent(m_context);
-					checkError("context setup");
+					check_error("context setup");
 
 					m_defaultSource = std::make_unique<AudioSource>();
-					checkError("default source setup");
+					check_error("default source setup");
 				}
 			}
 
 			~AudioServiceOAL() override {
 				if (m_device != nullptr) {
-					alcDestroyContext(m_context);
-					alcCloseDevice(m_device);
+					release();
 				}
 			}
 
-			void play(const std::string &filename, bool looping = false) override;
-			void play(AudioClip &clip, bool looping = false) override;
+			void play(const assets::AssetGUID &filename, bool looping = false) override;
+			void play(const AudioClipShort &clip, bool looping = false) override;
 
 		private:
 			ALCdevice *m_device;
 			ALCcontext *m_context{nullptr};
 			std::unique_ptr<AudioSource> m_defaultSource{nullptr};
-			data::Storage *m_storage = nullptr;
+			assets::AssetManager* m_assets;
+
+			void release();
 	};
 
 } // namespace fggl::audio::openal

include/fggl/audio/openal/module.hpp

@@ -21,30 +21,31 @@
 
 #include <array>
 #include <string>
+
+#include "fggl/assets/module.hpp"
+#include "fggl/assets/packed/module.hpp"
+
 #include "fggl/audio/audio.hpp"
 #include "fggl/audio/openal/audio.hpp"
 
 namespace fggl::audio {
 
+	constexpr auto OGG_VORBIS = assets::AssetType::make("audio/vorbis");
+	constexpr auto RES_OGG_VORBIS = assets::from_mime("audio/vorbis");
+
+    //! an audio module which uses openal(-soft) as a backend.
 	struct OpenAL {
 		constexpr static const char *name = "fggl::audio::OpenAL";
-		constexpr static const std::array<modules::ModuleService, 1> provides = {
+		constexpr static const std::array<modules::ServiceName, 1> provides = {
 			SERVICE_AUDIO_PLAYBACK
 		};
-		constexpr static const std::array<modules::ModuleService, 1> depends = {
-			modules::make_service("fggl::data::Storage")
+		constexpr static const std::array<modules::ServiceName, 2> depends = {
+			assets::AssetManager::service,
+			assets::CheckinAdapted::service
 		};
-		static bool factory(modules::ModuleService name, modules::Services &serviceManager);
+		static bool factory(modules::ServiceName name, modules::Services &serviceManager);
 	};
 
-	bool OpenAL::factory(modules::ModuleService service, modules::Services &services) {
-		if (service == SERVICE_AUDIO_PLAYBACK) {
-			auto storage = services.get<data::Storage>();
-			services.bind<audio::AudioService, openal::AudioServiceOAL>(storage);
-			return true;
-		}
-		return false;
-	}
 
 } // namespace fggl::audio
 

include/fggl/data/assimp/module.hpp

+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+//
+// Created by webpigeon on 18/10/22.
+//
+
+#ifndef FGGL_DATA_ASSIMP_MODULE_HPP
+#define FGGL_DATA_ASSIMP_MODULE_HPP
+
+#include "fggl/modules/module.hpp"
+#include "fggl/assets/loader.hpp"
+#include "fggl/assets/packed/module.hpp"
+#include "fggl/data/texture.hpp"
+
+namespace fggl::data::models {
+
+	constexpr auto MODEL_PROVIDER = modules::make_service("fggl::data::Model");
+	constexpr auto ASSIMP_MODEL = assets::AssetType::make("model::assimp");
+
+	constexpr auto MIME_JPG = assets::from_mime("image/jpeg");
+	constexpr auto MIME_PNG = assets::from_mime("image/png");
+	constexpr auto MIME_OBJ = assets::from_mime("model/obj");
+	constexpr auto MIME_FBX = assets::from_mime("model/fbx");
+
+	constexpr auto MODEL_MULTI3D = assets::make_asset_type("model/multi3D");
+	constexpr auto TEXTURE_RGBA = assets::make_asset_type("texture/rgba");
+
+	// old-style loaders
+	assets::AssetRefRaw load_assimp_model(assets::Loader* loader, const assets::AssetID& guid, const assets::LoaderContext& data, void* userPtr);
+	assets::AssetRefRaw load_assimp_texture(assets::Loader* loader, const assets::AssetID& guid, const assets::LoaderContext& data, void* userPtr);
+
+	// new style loaders (textures)
+	bool load_tex_stb(const std::filesystem::path& filePath, assets::MemoryBlock& block);
+	assets::AssetTypeID is_tex_stb(const std::filesystem::path& filePath);
+
+	// new style loaders (models)
+	assets::AssetTypeID is_model_assimp(const std::filesystem::path& filePath);
+	bool extract_requirements(const std::string& packName, const std::filesystem::path& packRoot, assets::ResourceRecord& rr);
+
+	struct AssimpModule {
+		constexpr static const char *name = "fggl::data::Assimp";
+		constexpr static const std::array<modules::ServiceName, 1> provides = {
+			MODEL_PROVIDER
+		};
+		constexpr static const std::array<modules::ServiceName, 2> depends = {
+			assets::Loader::service,
+			assets::CheckinAdapted::service
+		};
+		static bool factory(modules::ServiceName service, modules::Services &serviceManager);
+	};
+
+}
+
+namespace fggl::data {
+	using AssimpLoader = models::AssimpModule;
+}
+
+#endif //FGGL_DATA_ASSIMP_MODULE_HPP

include/fggl/data/model.hpp

@@ -27,10 +27,11 @@ namespace fggl::data {
 	constexpr math::vec3 ILLEGAL_NORMAL{0.0F, 0.0F, 0.F};
 	constexpr math::vec3 DEFAULT_COLOUR{1.0F, 1.0F, 1.0F};
 
+
 	struct Vertex {
 		math::vec3 posititon;
-		math::vec3 normal;
-		math::vec3 colour;
+		math::vec3 normal = ILLEGAL_NORMAL;
+		math::vec3 colour = DEFAULT_COLOUR;
 		math::vec2 texPos;
 
 		inline static Vertex from_pos(math::vec3 pos) {
@@ -43,6 +44,22 @@ namespace fggl::data {
 		}
 	};
 
+	// comparison operators
+	inline bool operator<(const Vertex &lhs, const Vertex &rhs) {
+		return std::tie(lhs.posititon, lhs.normal, lhs.colour)
+			< std::tie(rhs.posititon, rhs.normal, rhs.colour);
+	}
+
+	inline bool operator==(const Vertex &lhs, const Vertex &rhs) {
+		return lhs.posititon == rhs.posititon
+			&& lhs.colour == rhs.colour
+			&& lhs.normal == rhs.normal;
+	}
+
+	inline bool operator!=(const Vertex &lhs, const Vertex &rhs) {
+		return !(lhs == rhs);
+	}
+
 	struct Vertex2D {
 		fggl::math::vec2 position;
 		fggl::math::vec3 colour;
@@ -64,23 +81,6 @@ namespace fggl::data {
 	};
 
 
-	// comparison operators
-
-	inline bool operator<(const Vertex &lhs, const Vertex &rhs) {
-		return std::tie(lhs.posititon, lhs.normal, lhs.colour)
-			< std::tie(rhs.posititon, rhs.normal, rhs.colour);
-	}
-
-	inline bool operator==(const Vertex &lhs, const Vertex &rhs) {
-		return lhs.posititon == rhs.posititon
-			&& lhs.colour == rhs.colour
-			&& lhs.normal == rhs.normal;
-	}
-
-	inline bool operator!=(const Vertex &lhs, const Vertex &rhs) {
-		return !(lhs == rhs);
-	}
-
 	class Mesh {
 		public:
 			using IndexType = unsigned int;
@@ -134,19 +134,19 @@ namespace fggl::data {
 			 */
 			IndexType indexOf(Vertex vert);
 
-			inline std::vector<Vertex> &vertexList() {
+			inline const std::vector<Vertex> &vertexList() const {
 				return m_verts;
 			}
 
-			inline std::size_t vertexCount() {
+			inline std::size_t vertexCount() const {
 				return m_verts.size();
 			}
 
-			inline std::vector<IndexType> &indexList() {
+			inline const std::vector<IndexType> &indexList() const {
 				return m_index;
 			}
 
-			inline std::size_t indexCount() {
+			inline std::size_t indexCount() const {
 				return m_index.size();
 			}
 
@@ -167,25 +167,11 @@ namespace fggl::data {
 		data::Mesh mesh;
 		std::string pipeline;
 
-		inline StaticMesh() : mesh(), pipeline() {}
-
+		inline StaticMesh() = default;
 		inline StaticMesh(const data::Mesh &aMesh, std::string aPipeline) :
 			mesh(aMesh), pipeline(std::move(aPipeline)) {}
 	};
 
-	class Model {
-		public:
-			Model() = default;
-			~Model() = default;
-
-			inline void append(const Mesh &mesh) {
-				m_meshes.push_back(mesh);
-			}
-
-		private:
-			std::vector<Mesh> m_meshes;
-	};
-
 }
 
 #endif

include/fggl/data/module.hpp

@@ -27,11 +27,11 @@ namespace fggl::data {
 
 	struct LocalStorage {
 		constexpr static const char *name = "fggl::data::Storage";
-		constexpr static const std::array<modules::ModuleService, 1> provides = {
+		constexpr static const std::array<modules::ServiceName, 1> provides = {
 			SERVICE_STORAGE
 		};
-		constexpr static const std::array<modules::ModuleService, 0> depends = {};
-		static bool factory(modules::ModuleService service, modules::Services &serviceManager);
+		constexpr static const std::array<modules::ServiceName, 0> depends = {};
+		static bool factory(modules::ServiceName service, modules::Services &serviceManager);
 	};
 
 } // namespace fggl::data

include/fggl/data/procedural.hpp

@@ -16,6 +16,7 @@
 #define FGGL_DATA_PROCEDURAL_HPP
 
 #include "model.hpp"
+#include "fggl/mesh/mesh.hpp"
 
 namespace fggl::data {
 
@@ -28,7 +29,7 @@ namespace fggl::data {
 
 	// platonic solids
 	void make_tetrahedron(Mesh &mesh, const math::mat4 &offset = OFFSET_NONE);
-	Mesh make_cube(Mesh &mesh, const math::mat4 &offset = OFFSET_NONE);
+	mesh::Mesh3D make_cube(mesh::Mesh3D &mesh, const math::mat4 &offset = OFFSET_NONE);
 	void make_octahedron(Mesh &mesh, const math::mat4 &offset = OFFSET_NONE);
 	void make_icosahedron(Mesh &mesh, const math::mat4 &offset = OFFSET_NONE);
 	void make_dodecahedron(Mesh &mesh, const math::mat4 &offset = OFFSET_NONE);
@@ -38,13 +39,13 @@ namespace fggl::data {
 	void make_sphere_iso(Mesh &mesh, const math::mat4 &offset = OFFSET_NONE);
 
 	// level block-out shapes
-	Mesh make_slope(Mesh &mesh, const math::mat4 &offset = OFFSET_NONE);
-	Mesh make_ditch(Mesh &mesh, const math::mat4 &offset = OFFSET_NONE);
-	Mesh make_point(Mesh &mesh, const math::mat4 &offset = OFFSET_NONE);
+	mesh::Mesh3D make_slope(mesh::Mesh3D &mesh, const math::mat4 &offset = OFFSET_NONE);
+	mesh::Mesh3D make_ditch(mesh::Mesh3D &mesh, const math::mat4 &offset = OFFSET_NONE);
+	mesh::Mesh3D make_point(mesh::Mesh3D &mesh, const math::mat4 &offset = OFFSET_NONE);
 
 	// other useful types people expect
 	void make_capsule(Mesh &mesh);
-	void make_sphere(Mesh &mesh, const math::mat4 &offset = OFFSET_NONE, uint32_t stacks = 16U, uint32_t slices = 16U);
+	void make_sphere(mesh::Mesh3D &mesh, const math::mat4 &offset = OFFSET_NONE, uint32_t stacks = 16U, uint32_t slices = 16U);
 }
 
 #endif
\ No newline at end of file

include/fggl/data/storage.hpp

@@ -35,11 +35,11 @@ namespace fggl::data {
 
 	enum StorageType { Data, Config, Cache };
 
-	constexpr const modules::ModuleService SERVICE_STORAGE = modules::make_service("fggl::data::Storage");
+	constexpr const auto SERVICE_STORAGE = modules::make_service("fggl::data::Storage");
 
 	class Storage {
 		public:
-			constexpr static modules::ModuleService service = SERVICE_STORAGE;
+			constexpr static auto service = SERVICE_STORAGE;
 
 			Storage(fggl::platform::EnginePaths paths) : m_paths(std::move(paths)) {}
 

include/fggl/data/texture.hpp

+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+//
+// Created by webpigeon on 22/10/22.
+//
+
+#ifndef FGGL_DATA_TEXTURE_HPP
+#define FGGL_DATA_TEXTURE_HPP
+
+#include "fggl/assets/module.hpp"
+#include "fggl/math/types.hpp"
+
+namespace fggl::data {
+	constexpr auto DATA_TEXTURE2D = assets::AssetType::make("gfx::texture");
+
+	struct Texture2D {
+		math::vec2i size;
+		int channels;
+		unsigned char* data;
+
+		Texture2D() = default;
+		Texture2D(const Texture2D& other) = delete;
+
+		inline ~Texture2D() {
+			delete data;
+		}
+	};
+
+}
+
+#endif //FGGL_DATA_TEXTURE_HPP

include/fggl/debug/impl/logging_fmt.hpp

@@ -20,6 +20,8 @@
 #define FGGL_DEBUG_IMPL_LOGGING_FMT_HPP
 
 #include <fmt/format.h>
+#include <fmt/color.h>
+
 #include <iostream>
 #include <string>
 #include <string_view>
@@ -61,7 +63,7 @@ namespace fggl::debug {
 
 	template<typename S, typename... Args>
 	void logf(const char *file, int line, const S &format, Args &&... args) {
-		vlog(file, line, format, fmt::make_args_checked<Args...>(format, args...));
+		vlog(file, line, format, fmt::make_format_args(format, args...));
 	}
 
 	#define info_va(format, ...) \
@@ -78,13 +80,13 @@ namespace fggl::debug {
 	template<typename ...T>
 	inline void error(FmtType fmt, T &&...args) {
 		auto fmtStr = fmt::format(fmt::runtime(fmt), args...);
-		fmt::print(CERR_FMT, level_to_string(Level::error), fmtStr);
+		fmt::print(fg(fmt::color::red), CERR_FMT, level_to_string(Level::error), fmtStr);
 	}
 
 	template<typename ...T>
 	inline void warning(FmtType fmt, T &&...args) {
 		auto fmtStr = fmt::format(fmt::runtime(fmt), args...);
-		fmt::print(CERR_FMT, level_to_string(Level::warning), fmtStr);
+		fmt::print(fg(fmt::color::orange), CERR_FMT, level_to_string(Level::warning), fmtStr);
 	}
 
 	template<typename ...T>