include/fggl/animation/animator.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 03/09/22.
+//
+
+#ifndef FGGL_ANIMATION_ANIMATOR_H
+#define FGGL_ANIMATION_ANIMATOR_H
+
+#include <functional>
+#include <map>
+#include <cstdint>
+#include <cassert>
+
+namespace fggl::animation {
+
+	using AnimationCallback = std::function<void(void)>;
+	using CallbackHandle = uint32_t;
+
+	/**
+	 * Frame-based animation.
+	 *
+	 * Tries to maintain a constant framerate for things that care about that.
+	 */
+	class FrameAnimator {
+		public:
+			explicit inline FrameAnimator(float targetFPS) : m_target( 1.0F / targetFPS) {
+				assert( 0 <= m_target );
+			}
+
+			inline void reset() {
+				m_current = 0;
+			}
+
+			inline void update(float dt) {
+				assert(0 <= dt);
+				m_current += dt;
+				while ( m_current >= m_target) {
+					tick();
+					m_current -= m_target;
+				}
+				assert(0 <= m_current);
+			}
+
+			// tick the animation system, should be handled by update
+			inline void tick() {
+				for (auto& [k,v] : m_callbacks) {
+					v();
+				}
+			}
+
+			inline CallbackHandle add(AnimationCallback callback) {
+				auto myHandle = m_lastCallback++;
+				m_callbacks[myHandle] = callback;
+				return myHandle;
+			}
+
+			inline void remove(CallbackHandle handle) {
+				auto itr = m_callbacks.find(handle);
+				if ( itr != m_callbacks.end() ) {
+					m_callbacks.erase(itr);
+				}
+			}
+
+		private:
+			const float m_target;
+			float m_current = 0.0F;
+
+			CallbackHandle m_lastCallback = 0;
+			std::map<CallbackHandle, AnimationCallback> m_callbacks;
+	};
+
+} // namespace fggl::animation
+
+#endif //FGGL_ANIMATION_ANIMATOR_H

include/fggl/animation/skeleton.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/06/22.
+// Derived from Game Engine Architecture, 3rd Edition, Chapter 12
+//
+
+#ifndef FGGL_ANIMATION_SKELETON_HPP
+#define FGGL_ANIMATION_SKELETON_HPP
+
+#include <array>
+#include "fggl/math/types.hpp"
+
+namespace fggl::anim {
+
+	struct Joint {
+		math::mat4 m_invBindPose;
+		math::uint8 m_parent;
+	};
+
+	struct Skeleton {
+		std::size_t m_size;
+		std::array<Joint, 255> m_joints;
+	};
+
+	struct JointPose {
+		math::quat m_rot;
+		math::vec3 m_trans;
+		float m_scale;
+	};
+
+	struct SkeletonPose {
+		Skeleton *m_skel;
+		JointPose *m_localPose;
+		math::mat4 *m_globalPose;
+	};
+
+	struct SkinnedVertex {
+		math::vec3 m_pos;
+		math::vec3 m_normal;
+		math::vec2 m_tex;
+		std::array<math::uint8, 4> m_joint_idx;
+		std::array<float, 3> m_joint_weights;
+	};
+
+} // namespace fggl::anim
+
+#endif //FGGL_ANIMATION_SKELETON_HPP

include/fggl/app.hpp

-/**
- * FOSS Galaxy Game Library
- * Copyright (c) 2022 Joseph Walton-Rivers
- * webpigeon@fossgalaxy.com
- * 
- * This program 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.
+/*
+ * This file is part of FGGL.
  *
- * This program 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 this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ * 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/>.
  */
 
-#ifndef FGGL_APP_H
-#define FGGL_APP_H
+#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>
 #include <memory>
 #include <unordered_map>
 
-#include <fggl/ecs3/types.hpp>
-#include <fggl/ecs3/module/module.h>
-#include <fggl/gfx/window.hpp>
+#include "fggl/display/glfw/window.hpp"
 #include <fggl/gfx/paint.hpp>
 #include <fggl/util/states.hpp>
+#include "fggl/modules/manager.hpp"
 
 namespace fggl {
 
@@ -51,10 +44,13 @@ 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.
 			 */
 			explicit AppState(App &owner) : m_owner(owner) {}
+
 			virtual ~AppState() = default;
 
 			/**
@@ -64,7 +60,7 @@ namespace fggl {
 			 * multiple updates per render or vice-versa depending on requriements. Update is intended for
 			 * dispatching game-system related infomation.
 			 */
-			virtual void update() = 0;
+			virtual void update(float dt) = 0;
 
 			/**
 			 * Perform actions neccerary for rendering the scene.
@@ -78,62 +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(const Identifer &name);
-			App(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;
-
-			inline void setWindow(std::unique_ptr<gfx::Window>&& window) {
-				m_window = std::move(window);
+			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 *add_state(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);
 			}
 
-			template<typename T, typename... Args>
-			T &use(Args &&...args) {
-				auto ptr = m_modules->load<T>(args...);
-				return *ptr;
-			}
-
+            /**
+             * 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_states.active().deactivate();
-				m_states.change(name);
-				m_states.active().activate();
+				m_expectedScene = name;
 			}
 
-			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();
 			}
 
-			inline ecs3::TypeRegistry* registry() {
-				return m_types.get();
+            /**
+             * 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 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.get());
+					return nullptr;
+				}
+			}
+
+			inline auto services() -> modules::Services& {
+				return m_subsystems->services();
 			}
 
-			inline bool running() const {
+			inline auto running() const -> bool {
 				return m_running;
 			}
 
@@ -143,10 +215,10 @@ namespace fggl {
 
 		private:
 			bool m_running;
-			std::unique_ptr<ecs3::TypeRegistry> m_types;
-			std::unique_ptr<ecs3::ModuleManager> m_modules;
-			std::unique_ptr<gfx::Window> m_window;
+			display::Window *m_window;
 			AppMachine m_states;
+			Identifer m_expectedScene;
+			modules::Manager *m_subsystems;
 	};
 
 }

include/fggl/assets/loader.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 03/07/22.
+//
+
+#ifndef FGGL_ASSETS_LOADER_HPP
+#define FGGL_ASSETS_LOADER_HPP
+
+#include <map>
+#include <string>
+#include <memory>
+#include <functional>
+#include <queue>
+#include <variant>
+
+#include "fggl/assets/types.hpp"
+#include "fggl/assets/packed/adapter.hpp"
+#include "fggl/data/storage.hpp"
+
+namespace fggl::assets {
+
+	enum class LoadType {
+		DIRECT, // given pointer to persistent memory
+		STAGED, // given pointer to temp memory
+		PATH // given filesystem::path
+	};
+
+	struct ResourceRequest {
+		AssetGUID m_guid;
+		AssetTypeID m_type;
+	};
+
+
+	class Loader {
+		public:
+			constexpr const static auto service = modules::make_service("fggl::assets::Loader");
+
+			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) {};
+
+			// no move, no copy.
+			Loader(const Loader &) = delete;
+			Loader &operator=(const Loader &) = delete;
+			Loader(Loader &&) = delete;
+			Loader &operator=(Loader &&) = delete;
+
+			inline void setFactory(AssetTypeID type, Checkin fn, LoadType loading = LoadType::DIRECT) {
+				m_factories[type] = std::make_pair(fn, loading);
+			}
+
+			inline void unsetFactory(AssetTypeID type) {
+				m_factories.erase(type);
+			}
+
+			inline void request(const AssetGUID &guid, const AssetTypeID &type) {
+				m_requests.push(ResourceRequest{guid, type});
+			}
+
+			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() {
+				if (m_requests.empty()) {
+					return;
+				}
+				auto &request = m_requests.front();
+				load(request.m_guid, request.m_type);
+				m_requests.pop();
+			}
+
+			[[nodiscard]]
+			inline bool done() const {
+				return m_requests.empty();
+			}
+
+			/**
+			 * Complete all remaining loading requests, blocking until complete.
+			 */
+			inline void finish() {
+				while (!done()) {
+					progress();
+				}
+			}
+
+		private:
+			Loader *m_parent = nullptr;
+			using Config = std::pair<Checkin, LoadType>;
+			data::Storage *m_storage;
+			CheckinAdapted *m_checkin;
+			std::queue<ResourceRequest> m_requests;
+			std::map<AssetTypeID, Config> m_factories;
+	};
+
+} // namespace fggl::assets
+
+#endif //FGGL_ASSETS_LOADER_HPP

include/fggl/assets/manager.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_MANAGER_HPP
+#define FGGL_ASSETS_MANAGER_HPP
+
+#include <string_view>
+#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::ServiceName service = modules::make_service("fggl::assets::Manager");
+
+			AssetManager() = default;
+			virtual ~AssetManager() = default;
+
+			// no move, no copy.
+			AssetManager(const AssetManager &) = delete;
+			AssetManager &operator=(const AssetManager &) = delete;
+			AssetManager(AssetManager &&) = delete;
+			AssetManager &operator=(AssetManager &&) = delete;
+
+			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>
+			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 AssetID &/*guid*/) {
+				//m_registry.at(guid).refCount++;
+			}
+
+			inline bool has(const AssetID &guid) {
+				return m_registry.contains(guid);
+			}
+
+			inline void release(const AssetGUID &/*guid*/) {
+				//m_registry.at(guid).refCount--;
+			}
+
+			inline std::vector<AssetID> known() {
+				std::vector<AssetID> assetList;
+				for ( auto& itr : m_registry ) {
+					assetList.push_back(itr.first);
+				}
+				return assetList;
+			}
+
+		private:
+			std::map<AssetID, std::shared_ptr<AssetBox>> m_registry;
+	};
+
+} // namespace fggl::assets
+
+#endif //FGGL_ASSETS_MANAGER_HPP

include/fggl/assets/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_MODULE_HPP
+#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"
+
+namespace fggl::assets {
+
+	struct AssetFolders {
+		constexpr static const char *name = "fggl::assets::Folders";
+		constexpr static const std::array<modules::ServiceName, 2> provides = {
+			Loader::service,
+			AssetManager::service
+		};
+		constexpr static const std::array<modules::ServiceName, 2> depends = {
+			data::Storage::service,
+			CheckinAdapted::service
+		};
+		static bool factory(modules::ServiceName name, modules::Services &serviceManager);
+	};
+
+} // namespace fggl::assets
+
+#endif //FGGL_ASSETS_MODULE_HPP

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

+/*
+ * 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 03/07/22.
+//
+
+#ifndef FGGL_ASSETS_TYPES_HPP
+#define FGGL_ASSETS_TYPES_HPP
+
+#include <filesystem>
+#include <variant>
+#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;
+
+	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 {
+		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<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();
+		}
+
+		inline assets::AssetID makeRef(const char* name) const {
+			return assets::make_asset_id_rt(pack, relParent() / name );
+		}
+	};
+
+	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

+/*
+ * 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/>.
+ */
+
+#ifndef FGGL_AUDIO_AUDIO_HPP
+#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 {
+
+	/**
+	 * AudioClip is bit of audio loaded into memory.
+	 *
+	 * If the sampleCount is -1, the clip is invalid.
+	 */
+	 template<typename T>
+	 struct AudioClip {
+		int channels = 0;
+		int sampleRate = 0;
+		int sampleCount = -1;
+		T *data = nullptr;
+
+		AudioClip() = default;
+		AudioClip(const AudioClip&) = delete;
+
+		inline ~AudioClip() {
+			std::free(data);
+			data = nullptr;
+		}
+
+		[[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");
+
+	/**
+	 *
+	 * \ingroup services
+	 */
+	class AudioService {
+		public:
+			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;
+	};
+
+} // namespace fggl::audio
+
+#endif //FGGL_AUDIO_AUDIO_HPP

include/fggl/audio/null_audio.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_AUDIO_NULL_AUDIO_HPP
+#define FGGL_AUDIO_NULL_AUDIO_HPP
+
+#include "fggl/audio/audio.hpp"
+
+namespace fggl::audio {
+
+	class NullAudioService : public AudioService {
+		public:
+			NullAudioService() = default;
+			~NullAudioService() override = default;
+
+			NullAudioService(NullAudioService&) = delete;
+			NullAudioService(NullAudioService&&) = delete;
+			NullAudioService& operator=(const NullAudioService&) = delete;
+			NullAudioService& operator=(NullAudioService&&) = delete;
+
+			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::ServiceName, 1> provides = {
+			SERVICE_AUDIO_PLAYBACK
+		};
+		constexpr static const std::array<modules::ServiceName, 0> depends = {};
+		bool factory(modules::ServiceName, modules::Services&);
+	};
+
+
+} // namespace fggl::audio
+
+#endif //FGGL_AUDIO_NULL_AUDIO_HPP

include/fggl/audio/openal/audio.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 01/05/22.
+//
+
+#ifndef FGGL_AUDIO_OPENAL_AUDIO_HPP
+#define FGGL_AUDIO_OPENAL_AUDIO_HPP
+
+#include <AL/al.h>
+#include <AL/alc.h>
+
+#include "fggl/audio/audio.hpp"
+#include "fggl/assets/manager.hpp"
+
+#include "fggl/data/storage.hpp"
+#include "fggl/math/types.hpp"
+
+#include <string>
+#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,
+		STEREO_8 = AL_FORMAT_STEREO8,
+		STEREO_16 = AL_FORMAT_STEREO16
+	};
+
+	static void check_error(const std::string& context) {
+		auto code = alGetError();
+		if (code == AL_NO_ERROR) {
+			return;
+		}
+
+		// 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";
+		}
+
+		debug::error("OpenAL error: context={}, error={}", context, error);
+	}
+
+	class AudioBuffer {
+		public:
+			AudioBuffer() : m_buffer(NULL_BUFFER_ID) {
+				alGenBuffers(1, &m_buffer);
+			}
+
+			~AudioBuffer() {
+				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() const {
+				return m_buffer;
+			}
+
+		private:
+			ALuint m_buffer = 0;
+	};
+
+	class AudioSource {
+		public:
+			AudioSource() : m_source(0), m_splat() {
+				alGenSources(1, &m_source);
+			}
+
+			~AudioSource() {
+				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);
+			}
+
+			inline void stop() {
+				alSourceStop(m_source);
+			}
+
+			inline void pause() {
+				alSourcePause(m_source);
+			}
+
+			inline void rewind() {
+				alSourceRewind(m_source);
+			}
+
+			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(const AudioClipShort &clip, bool looping = false);
+
+			inline void velocity(math::vec3 &value) {
+				alSource3f(m_source, AL_VELOCITY, value.x, value.y, value.z);
+			}
+
+			inline void position(math::vec3 &value) {
+				alSource3f(m_source, AL_POSITION, value.x, value.y, value.z);
+			}
+
+			void direction(math::vec3 &value) {
+				alSource3f(m_source, AL_DIRECTION, value.x, value.y, value.z);
+			}
+
+		private:
+			ALuint m_source;
+			AudioBuffer m_splat;
+	};
+
+	class AudioServiceOAL : public AudioService {
+		public:
+			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);
+					check_error("context setup");
+
+					m_defaultSource = std::make_unique<AudioSource>();
+					check_error("default source setup");
+				}
+			}
+
+			~AudioServiceOAL() override {
+				if (m_device != nullptr) {
+					release();
+				}
+			}
+
+			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};
+			assets::AssetManager* m_assets;
+
+			void release();
+	};
+
+} // namespace fggl::audio::openal
+
+namespace fggl::audio {
+	using openAL = openal::AudioServiceOAL;
+
+} // namepace fggl::audio
+
+#endif //FGGL_AUDIO_OPENAL_AUDIO_HPP

include/fggl/audio/openal/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_AUDIO_OPENAL_MODULE_HPP
+#define FGGL_AUDIO_OPENAL_MODULE_HPP
+
+#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::ServiceName, 1> provides = {
+			SERVICE_AUDIO_PLAYBACK
+		};
+		constexpr static const std::array<modules::ServiceName, 2> depends = {
+			assets::AssetManager::service,
+			assets::CheckinAdapted::service
+		};
+		static bool factory(modules::ServiceName name, modules::Services &serviceManager);
+	};
+
+
+} // namespace fggl::audio
+
+#endif //FGGL_AUDIO_OPENAL_MODULE_HPP

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/geom.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 11/06/22.
+//
+
+#ifndef FGGL_DATA_GEOM_HPP
+#define FGGL_DATA_GEOM_HPP
+
+#include <assimp/Importer.hpp>
+#include <assimp/scene.h>
+#include <assimp/postprocess.h>
+
+#include <filesystem>
+#include "storage.hpp"
+#include "model.hpp"
+
+namespace fggl::data {
+
+	static inline math::vec3 aiVec3ToFggl(aiVector3D vec) {
+		return {vec.x, vec.y, vec.z};
+	}
+
+	static inline math::vec2 aiVec2ToFggl(aiVector3D vec) {
+		return {vec.x, vec.y};
+	}
+
+	static void process_mesh(aiMesh *mesh, data::Mesh &meshRecord) {
+		// process vertices
+		std::vector<data::Mesh::IndexType> indexList;
+		for (auto idx = 0; idx < mesh->mNumVertices; ++idx) {
+			auto idxVal = meshRecord.pushVertex({
+													.posititon = aiVec3ToFggl(mesh->mVertices[idx]),
+													.normal = aiVec3ToFggl(mesh->mNormals[idx]),
+													.texPos = aiVec2ToFggl(mesh->mTextureCoords[0][idx])
+												});
+			indexList.push_back(idxVal);
+		}
+
+		if (mesh->HasFaces()) {
+			// if there is face data, that's our index list
+			for (auto face = 0; face < mesh->mNumFaces; ++face) {
+				auto &facePtr = mesh->mFaces[face];
+				meshRecord.pushIndex(indexList[facePtr.mIndices[0]]);
+				meshRecord.pushIndex(indexList[facePtr.mIndices[1]]);
+				meshRecord.pushIndex(indexList[facePtr.mIndices[2]]);
+			}
+		}
+	}
+
+	static void process_model(aiScene *scene, aiNode *node, data::Mesh &mesh) {
+		auto ptr = node->mMeshes;
+		for (auto j = 0; j < node->mNumMeshes; ++j) {
+			for (int meshCount = 0; node->mNumMeshes; ++meshCount) {
+				auto aiMeshIdx = node->mMeshes[meshCount];
+
+				data::Mesh mesh;
+				auto *aiMesh = scene->mMeshes[aiMeshIdx];
+				process_mesh(aiMesh, mesh);
+			}
+		}
+
+		// process child meshes
+		for (int i = 0; i < node->mNumChildren; ++i) {
+			auto *child = node->mChildren[i];
+			process_model(child);
+		}
+	}
+
+	template<>
+	bool fggl_deserialize(std::filesystem::path &data, StaticMesh *out) {
+		Assimp::Importer importer;
+		const aiScene *scene = importer.ReadFile(data.c_str(), aiProcess_Triangulate | aiProcess_FlipUVs);
+
+		// check if the import worked
+		if (scene == nullptr || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode) {
+			return false;
+		}
+
+		// figure out the meshes
+		process_model(scene->mRootNode);
+
+		//TODO implement the rest of this
+		return false;
+	}
+
+} // namespace fggl::data
+
+#endif //FGGL_DATA_GEOM_HPP

include/fggl/data/heightmap.h → include/fggl/data/heightmap.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 20/11/2021.
 //
 
-#ifndef FGGL_HEIGHTMAP_H
-#define FGGL_HEIGHTMAP_H
+#ifndef FGGL_DATA_HEIGHTMAP_HPP
+#define FGGL_DATA_HEIGHTMAP_HPP
 
 #include <cstdint>
+#include <array>
+
+#include "fggl/data/model.hpp"
 
 namespace fggl::data {
 
@@ -15,7 +32,7 @@ namespace fggl::data {
 
 	struct HeightMap {
 		constexpr static const char name[] = "Heightmap";
-		float heightValues[heightMaxX * heightMaxZ];
+		std::array<float, heightMaxX * heightMaxZ> heightValues;
 
 		void clear() {
 			for (float &heightValue : heightValues) {
@@ -25,11 +42,11 @@ namespace fggl::data {
 
 		[[nodiscard]]
 		inline float getValue(std::size_t x, std::size_t z) const {
-			return heightValues[x * heightMaxZ + z];
+			return heightValues.at(x * heightMaxZ + z);
 		}
 
 		inline void setValue(std::size_t x, std::size_t z, float value) {
-			heightValues[x * heightMaxZ + z] = value;
+			heightValues.at(x * heightMaxZ + z) = value;
 		}
 	};
 
@@ -37,7 +54,7 @@ namespace fggl::data {
 		return x * zMax + z;
 	}
 
-	void generateHeightMesh(const data::HeightMap *heights, data::Mesh &mesh);
+	void generateHeightMesh(const data::HeightMap &heights, data::Mesh &mesh);
 }
 
-#endif //FGGL_HEIGHTMAP_H
+#endif //FGGL_DATA_HEIGHTMAP_HPP

include/fggl/data/model.hpp

-#ifndef FGGL_DATA_MODEL_H
-#define FGGL_DATA_MODEL_H
+/*
+ * 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/>.
+ */
+
+#ifndef FGGL_DATA_MODEL_HPP
+#define FGGL_DATA_MODEL_HPP
 
 #include <tuple>
 #include <vector>
 #include <string>
+#include <climits>
 
 #include <fggl/math/types.hpp>
 
 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) {
+			return {
+				pos,
+				ILLEGAL_NORMAL,
+				DEFAULT_COLOUR,
+				{0.0F, 0.0F}
+			};
+		}
 	};
 
+	// 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;
@@ -36,25 +81,11 @@ 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;
+			constexpr static const IndexType INVALID_IDX = IndexType(UINT_MAX);
+
 			Mesh();
 			~Mesh() = default;
 
@@ -66,7 +97,7 @@ namespace fggl::data {
 			 */
 			inline void push(Vertex vert) {
 				auto idx = indexOf(vert);
-				if (idx == -1) {
+				if (idx == INVALID_IDX) {
 					idx = pushVertex(vert);
 					pushIndex(idx);
 				} else {
@@ -79,14 +110,14 @@ namespace fggl::data {
 			 *
 			 * Don't push non-existant indexes, it'll make the rendering backend sad.
 			 */
-			void pushIndex(unsigned int idx);
+			void pushIndex(IndexType idx);
 
 			/**
 			 * Force push a vertex duplicate.
 			 *
 			 * If the vetex already exists, it will be duplicated.
 			 */
-			unsigned int pushVertex(Vertex vert);
+			IndexType pushVertex(Vertex vert);
 
 			/**
 			 * remove Duplicate verticies
@@ -101,59 +132,46 @@ namespace fggl::data {
 			 *
 			 * Returns the index of a vert, else returns -1.
 			 */
-			int indexOf(Vertex vert);
+			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<uint32_t> &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();
 			}
 
-			inline Vertex &vertex(int idx) {
+			inline Vertex &vertex(IndexType idx) {
 				return m_verts[idx];
 			}
 
-			unsigned int restartVertex;
-
+			IndexType restartVertex;
 		private:
 			std::vector<Vertex> m_verts;
-			std::vector<unsigned int> m_index;
+			std::vector<IndexType> m_index;
 	};
 
 	struct StaticMesh {
 		constexpr static const char name[] = "StaticMesh";
+		constexpr static const util::GUID guid = util::make_guid("StaticMesh");
+
 		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

+/*
+ * 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_DATA_MODULE_HPP
+#define FGGL_DATA_MODULE_HPP
+
+#include "fggl/modules/module.hpp"
+#include "fggl/data/storage.hpp"
+#include "fggl/platform/paths.hpp"
+
+namespace fggl::data {
+
+	struct LocalStorage {
+		constexpr static const char *name = "fggl::data::Storage";
+		constexpr static const std::array<modules::ServiceName, 1> provides = {
+			SERVICE_STORAGE
+		};
+		constexpr static const std::array<modules::ServiceName, 0> depends = {};
+		static bool factory(modules::ServiceName service, modules::Services &serviceManager);
+	};
+
+} // namespace fggl::data
+
+#endif //FGGL_DATA_MODULE_HPP