include/fggl/modules/service.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 25/03/23.
+//
+
+#ifndef FGGL_MODULES_SERVICE_HPP
+#define FGGL_MODULES_SERVICE_HPP
+
+#include <map>
+#include <memory>
+
+#include "fggl/util/safety.hpp"
+
+namespace fggl::modules {
+
+	using ServiceName = util::OpaqueName<std::string_view, struct ModuleServiceTag>;
+	constexpr ServiceName make_service(const std::string_view name) {
+		return ServiceName::make(name);
+	}
+
+	template<typename T>
+	concept ServiceType = requires(T* type) {
+		{ T::service };
+	};
+
+	template<typename T, typename U>
+	concept Derived = std::is_base_of<U, T>::value;
+
+	class Services {
+		public:
+			template<ServiceType Svc, Derived<Svc> Impl, typename ...Args>
+			void bind(Args... args) {
+				m_services[Svc::service] = std::make_shared<Impl>(args...);
+			}
+
+			template<ServiceType Svc, typename ...Args>
+			Svc *create(Args... args) {
+				auto svc = std::make_shared<Svc>(args...);
+				m_services[Svc::service] = svc;
+				return svc.get();
+			}
+
+			template<ServiceType Svc>
+			void provide(std::shared_ptr<Svc> service) {
+				m_services[Svc::service] = service;
+			}
+
+			template<ServiceType S>
+			S *get() const {
+				auto serviceWrapper = m_services.at(S::service);
+				auto ptr = std::static_pointer_cast<S>(serviceWrapper);
+				return ptr.get();
+			}
+
+		private:
+			std::map<ServiceName, std::shared_ptr<void>> m_services;
+	};
+
+} // namespace fggl::modules
+
+
+
+#endif //FGGL_MODULES_SERVICE_HPP

include/fggl/phys/bullet/bullet.hpp

-/*
- * ${license.title}
- * Copyright (C) 2022 ${license.owner}
- * ${license.mailto}
- *
- * 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 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.
- */
-
-//
-// Created by webpigeon on 24/04/22.
-//
-
-#ifndef FGGL_PHYS_BULLET_BULLET_HPP
-#define FGGL_PHYS_BULLET_BULLET_HPP
-
-#include "fggl/ecs3/module/module.hpp"
-
-#include "fggl/phys/types.hpp"
-#include "fggl/phys/bullet/types.hpp"
-
-namespace fggl::phys::bullet {
-
-	/**
-	 * Bullet integration module.
-	 *
-	 * This provides the ability for FGGL to use bullet as a physics backened. Bullet is mature, stable physics
-	 * engine which makes it suitable for most use cases. For use with FGGL there is a reasonable amount of copying
-	 * back and forth to keep the two states in sync.
-	 */
-	struct BulletModule : ecs3::Module {
-		public:
-			BulletModule() = default;
-
-			[[nodiscard]]
-			std::string name() const override {
-				return "phys::Bullet3";
-			}
-
-			void onLoad(ecs3::ModuleManager & /*manager*/, ecs3::TypeRegistry &types) override {
-				// dependencies
-				types.make<phys::CollisionCallbacks>();
-				types.make<phys::CollisionCache>();
-
-				types.make<phys::RigidBody>();
-				types.make<phys::Dynamics>();
-
-				// my types
-				types.make<phys::bullet::BulletBody>();
-			}
-
-	};
-
-} // namespace fggl::phys::bullet
-
-namespace fggl::phys {
-
-	// allows using fggl::phys::Bullet3 as the module name
-	using Bullet3 = bullet::BulletModule;
-
-} // namespace fggl::phys
-
-#endif //FGGL_PHYS_BULLET_BULLET_HPP

include/fggl/phys/bullet/motion.hpp

-/*
- * ${license.title}
- * Copyright (C) 2022 ${license.owner}
- * ${license.mailto}
- *
- * 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 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.
- */
-
-//
-// Created by webpigeon on 11/06/22.
-//
-
-#ifndef FGGL_PHYS_BULLET_MOTION_HPP
-#define FGGL_PHYS_BULLET_MOTION_HPP
-
-#include "fggl/phys/bullet/types.hpp"
-
-namespace fggl::phys::bullet {
-
-	class FgglMotionState : public btMotionState {
-		public:
-			FgglMotionState(fggl::ecs3::World* world, fggl::ecs3::entity_t entity) : m_world(world), m_entity(entity) {
-			}
-			virtual ~FgglMotionState() = default;
-
-			void getWorldTransform(btTransform& worldTrans) const override {
-				const auto* transform = m_world->get<fggl::math::Transform>(m_entity);
-				worldTrans.setFromOpenGLMatrix( glm::value_ptr(transform->model()) );
-			}
-
-			void setWorldTransform(const btTransform& worldTrans) override {
-				auto* transform = m_world->get<fggl::math::Transform>(m_entity);
-
-				// set position
-				auto btOrigin = worldTrans.getOrigin();
-				transform->origin( {btOrigin.x(), btOrigin.y(), btOrigin.z()} );
-
-				// set rotation
-				math::vec3 angles;
-				worldTrans.getRotation().getEulerZYX(angles.x, angles.y, angles.z);
-				transform->euler(angles);
-			}
-
-		private:
-			fggl::ecs3::World* m_world;
-			fggl::ecs3::entity_t m_entity;
-	};
-
-} // namespace fggl::phys::bullet
-
-#endif //FGGL_PHYS_BULLET_INTEGRATIONS_HPP

include/fggl/phys/callbacks.hpp

 /*
- * ${license.title}
- * Copyright (C) 2022 ${license.owner}
- * ${license.mailto}
+ * This file is part of FGGL.
  *
- * 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.
+ * 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.
  *
- * 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.
+ * 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 this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
  */
 
 //
@@ -27,22 +21,23 @@
 
 #include <functional>
 #include <unordered_set>
+#include "fggl/entity/entity.hpp"
 
 namespace fggl::phys {
 
-	using CollisionCB = std::function<void(ecs3::entity_t, ecs3::entity_t)>;
+	using CollisionCB = std::function<void(entity::EntityID, entity::EntityID)>;
 
 	struct CollisionCallbacks {
-		constexpr static const char* name = "phys::Callbacks";
+		constexpr static const char *name = "phys::Callbacks";
 		CollisionCB onEnter = nullptr;
 		CollisionCB onExit = nullptr;
 		CollisionCB onStay = nullptr;
 	};
 
 	struct CollisionCache {
-		constexpr static const char* name = "phys::Cache";
-		std::unordered_set<ecs3::entity_t> collisions;
-		std::unordered_set<ecs3::entity_t> lastFrame;
+		constexpr static const char *name = "phys::Cache";
+		std::unordered_set<entity::EntityID> collisions;
+		std::unordered_set<entity::EntityID> lastFrame;
 	};
 
 } // namespace fggl::phys

include/fggl/phys/null.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/08/22.
+//
+
+#ifndef FGGL_PHYS_NULL_HPP
+#define FGGL_PHYS_NULL_HPP
+
+#include "fggl/phys/types.hpp"
+#include "fggl/phys/service.hpp"
+
+namespace fggl::phys {
+
+	inline void build_noop(const entity::ComponentSpec & /*config*/,
+						   entity::EntityManager &manager,
+						   const entity::EntityID &entity,
+						   modules::Services &/*services*/) {
+		manager.add<fggl::phys::RigidBody>(entity);
+		manager.add<fggl::phys::Dynamics>(entity);
+	}
+
+	class NullPhysicsEngine : public PhysicsEngine {
+		public:
+			inline void step() override {}
+
+			void setDebugDraw(bool /* enable */) override {}
+
+			inline std::vector<ContactPoint> scanCollisions(entity::EntityID /*entity*/) override {
+				return {};
+			}
+
+			inline entity::EntityID raycast(math::vec3 /*from*/, math::vec3 /*to*/) override {
+				return entity::INVALID;
+			}
+
+			inline std::vector<entity::EntityID> raycastAll(math::vec3 /*from*/, math::vec3 /*to*/) override {
+				return {};
+			}
+
+			inline std::vector<entity::EntityID> sweep(PhyShape & /*shape*/,
+													   math::Transform & /*from*/,
+													   math::Transform & /*to*/) override {
+				return {};
+			}
+	};
+
+	class NullPhysicsProvider : public PhysicsProvider {
+		public:
+			virtual ~NullPhysicsProvider() = default;
+
+			inline PhysicsEngine *create(entity::EntityManager * /*entityManager*/,
+										 entity::EntityFactory *factory) override {
+				factory->bind(util::make_guid("phys::Body"), build_noop);
+				return new NullPhysicsEngine();
+			}
+	};
+
+	struct NullPhysics {
+		constexpr static const char *name = "fggl::phys::null";
+		constexpr static const std::array<modules::ServiceName, 1> provides = {
+			phys::PhysicsProvider::service
+		};
+		constexpr static const std::array<modules::ServiceName, 1> depends = {
+			entity::EntityFactory::service
+		};
+		static bool factory(modules::ServiceName serviceName, modules::Services &serviceManager);
+	};
+
+} // namespace fggl::phys
+
+#endif //FGGL_PHYS_NULL_HPP

include/fggl/phys/service.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/08/22.
+//
+
+#ifndef FGGL_PHYS_SERVICE_HPP
+#define FGGL_PHYS_SERVICE_HPP
+
+#include "fggl/modules/module.hpp"
+#include "fggl/entity/module.hpp"
+#include "fggl/phys/types.hpp"
+
+namespace fggl::phys {
+
+	class PhysicsProvider {
+		public:
+			constexpr static const auto service = modules::make_service("fggl::phys::service");
+			virtual ~PhysicsProvider() = default;
+			virtual PhysicsEngine *create(entity::EntityManager *entityManager, entity::EntityFactory *factory) = 0;
+	};
+
+}
+
+#endif //FGGL_PHYS_SERVICE_HPP

include/fggl/phys/types.hpp

 /*
- * ${license.title}
- * Copyright (C) 2022 ${license.owner}
- * ${license.mailto}
+ * This file is part of FGGL.
  *
- * 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.
+ * 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.
  *
- * 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.
+ * 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 this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
  */
 
 //
@@ -25,6 +19,7 @@
 #ifndef FGGL_PHYS_TYPES_HPP
 #define FGGL_PHYS_TYPES_HPP
 
+#include "fggl/math/types.hpp"
 #include "fggl/phys/callbacks.hpp"
 
 namespace fggl::phys {
@@ -33,9 +28,9 @@ namespace fggl::phys {
 	constexpr math::vec3 UNIT_EXTENTS{0.5F, 0.5F, 0.5F};
 
 	enum class ShapeType {
-			UNSET,
-			BOX,
-			SPHERE
+		UNSET,
+		BOX,
+		SPHERE
 	};
 
 	struct PhyShape {
@@ -47,22 +42,24 @@ namespace fggl::phys {
 
 	struct Box : public PhyShape {
 		math::vec3 extents;
+
 		explicit inline Box(math::vec3 ext) : PhyShape(ShapeType::BOX), extents(ext) {}
 	};
 
 	struct Sphere : public PhyShape {
 		float radius = 1.0F;
+
 		explicit inline Sphere(float rad) : PhyShape(ShapeType::SPHERE), radius(rad) {}
 	};
 
 	enum class BodyType {
-			STATIC, KINEMATIC, DYNAMIC
+		STATIC, KINEMATIC, DYNAMIC
 	};
 
 	struct RigidBody {
-		constexpr static const char* name = "phys::Body";
+		constexpr static const char *name = "phys::Body";
 		float mass = MASS_DEFAULT;
-		PhyShape* shape = nullptr;
+		PhyShape *shape = nullptr;
 		BodyType type = BodyType::DYNAMIC;
 
 		[[nodiscard]]
@@ -72,13 +69,13 @@ namespace fggl::phys {
 	};
 
 	struct Dynamics {
-		constexpr static const char* name = "phys::Dynamics";
+		constexpr static const char *name = "phys::Dynamics";
 		math::vec3 force = math::VEC3_ZERO;
 	};
 
 	struct ContactPoint {
-		ecs3::entity_t entityA;
-		ecs3::entity_t entityB;
+		entity::EntityID entityA;
+		entity::EntityID entityB;
 		math::vec3 localA;
 		math::vec3 localB;
 		math::vec3 normal;
@@ -103,19 +100,30 @@ namespace fggl::phys {
 			virtual ~PhysicsEngine() = default;
 
 			// no copy and no move
-			PhysicsEngine(PhysicsEngine&) = delete;
-			PhysicsEngine(PhysicsEngine&&) = delete;
-			PhysicsEngine& operator=(PhysicsEngine&) = delete;
-			PhysicsEngine& operator=(PhysicsEngine&&) = delete;
+			PhysicsEngine(PhysicsEngine &) = delete;
+			PhysicsEngine(PhysicsEngine &&) = delete;
+			PhysicsEngine &operator=(PhysicsEngine &) = delete;
+			PhysicsEngine &operator=(PhysicsEngine &&) = delete;
 
 			// query methods (first cut - unstable APIs)
-			virtual std::vector<ContactPoint> scanCollisions(ecs3::entity_t entity) = 0;
-			virtual ecs3::entity_t raycast(math::vec3 from, math::vec3 to) = 0;
-			virtual std::vector<ecs3::entity_t> raycastAll(math::vec3 from, math::vec3 to) = 0;
-			virtual std::vector<ecs3::entity_t> sweep(PhyShape& shape, math::Transform& from, math::Transform& to) = 0;
+			virtual std::vector<ContactPoint> scanCollisions(entity::EntityID entity) = 0;
+
+			virtual entity::EntityID raycast(math::vec3 from, math::vec3 to) = 0;
+
+			inline entity::EntityID raycast(math::Ray ray, float maxDist = 1000.0F) {
+				return raycast(ray.origin, ray.origin + ray.direction * maxDist);
+			}
+
+			virtual std::vector<entity::EntityID> raycastAll(math::vec3 from, math::vec3 to) = 0;
+			virtual std::vector<entity::EntityID> sweep(PhyShape &shape,
+														math::Transform &from,
+														math::Transform &to) = 0;
 
 			// update
 			virtual void step() = 0;
+
+			// debug
+			virtual void setDebugDraw(bool enable) = 0;
 	};
 
 } // namespace fggl::phys

include/fggl/platform/fallback/file.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/09/22.
+//
+
+#ifndef FGGL_PLATFORM_FALLBACK_FILE_HPP
+#define FGGL_PLATFORM_FALLBACK_FILE_HPP
+
+#include <cstdio>
+#include <cassert>
+
+namespace fggl::platform {
+
+	class File {
+		public:
+			inline File(FILE* filePtr) : m_handle(filePtr) {
+				assert(filePtr != nullptr);
+			}
+
+			inline ~File() {
+				release();
+			}
+
+			template<typename T>
+			inline void write(const T* dataPtr) {
+				assert( m_handle != nullptr );
+				int status = fwrite(dataPtr, sizeof(T), 1, m_handle );
+				assert( status == 1);
+			}
+
+			template<typename T>
+			inline void writeArr(const T* dataPtr, std::size_t numElms) {
+				assert( m_handle != nullptr);
+				int status = fwrite(dataPtr, sizeof(T), numElms, m_handle );
+				assert( status == 1);
+			}
+
+		private:
+			std::FILE* m_handle;
+
+			inline void release() {
+				if ( m_handle != NULL) {
+					fclose(m_handle);
+				}
+			}
+	};
+
+} // namespace fggl::platform
+
+#endif //FGGL_PLATFORM_FALLBACK_FILE_HPP

include/fggl/platform/fallback/paths.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/>.
+ */
+
+//
+// Low-Level Linux-specific path management
+// Created by webpigeon on 23/06/22.
+// see https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html
+//
+
+#ifndef FGGL_PLATFORM_FALLBACK_PATHS_HPP
+#define FGGL_PLATFORM_FALLBACK_PATHS_HPP
+
+#include "fggl/platform/paths.hpp"
+
+#include <filesystem>
+#include <array>
+
+#include <vector>
+
+namespace fggl::platform {
+
+	/**
+	 * The environment variable used for containing user configurations.
+	 *
+	 * The directory mentioned by this environment variable should be read/writeable.
+	 * The directory should be used for storing user-editable configuration options (eg. preferences).
+	 */
+	constexpr const char *ENV_USER_CONFIG = "FGGL_CONFIG_HOME";
+
+	/**
+	 * Fallback user configuration directory.
+	 *
+	 * Default user configuration directory if none is set by the environment variable.
+	 */
+	constexpr const char *DEFAULT_USER_CONFIG = "user_config";
+
+	/**
+	 * The environment variable used for containing engine data.
+	 *
+	 * This directory is used for storing persistent user data and therefore should be read/writable.
+	 * The directory should be used for storing user-modifiable state (eg, save files) or downloaded modifications.
+	 */
+	constexpr const char *ENV_USER_DATA = "FGGL_DATA_HOME";
+
+	/**
+	 * Fallback user data directory.
+	 *
+	 * Default user data directory if none is set by the environment variable.
+	 */
+	constexpr const char *DEFAULT_USER_DATA = "user_data";
+
+	/**
+	 * The environment variable used for containing semi-persistent user data.
+	 *
+	 * The application should be able to expect this directory to exist while the application is running, but otherwise
+	 * cannot expect the data to be persistent. It MAY be persistent but the application should not rely on this.
+	 * It should be used for resources which can be re-generated if needed, but can be useful if already present.
+	 */
+	constexpr const char *ENV_USER_CACHE = "FGGL_CACHE_HOME";
+
+	struct EnginePaths {
+		std::filesystem::path userConfig;
+		std::filesystem::path userData;
+		std::filesystem::path userCache;
+	};
+
+	/**
+	 * Fallback implementation of calc engine paths.
+	 *
+	 * For operating systems we don't know about, this simply uses the environment variables defined above and some
+	 * sane defaults to construct the paths used to locate our data and user configuration.
+	 *
+	 * @param base an application-unique string used to construct the paths.
+	 * @return the generated paths, for use with the rest of the engine.
+	 */
+	EnginePaths calc_engine_paths(const char *base);
+
+	// search routines for finding data and configuration files
+	std::filesystem::path locate_data(const EnginePaths &paths, const std::filesystem::path &relPath);
+	std::filesystem::path locate_config(const EnginePaths &paths, const std::filesystem::path &relPath);
+	std::filesystem::path locate_cache(const EnginePaths &paths, const std::filesystem::path &relPath);
+
+}
+
+#endif //FGGL_PLATFORM_FALLBACK_PATHS_HPP

include/fggl/platform/linux/paths.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/>.
+ */
+
+//
+// Low-Level Linux-specific path management
+// Created by webpigeon on 23/06/22.
+// see https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html
+//
+
+#ifndef FGGL_PLATFORM_LINUX_PATHS_HPP
+#define FGGL_PLATFORM_LINUX_PATHS_HPP
+
+#include "fggl/platform/paths.hpp"
+
+#include <filesystem>
+#include <array>
+
+#include <vector>
+
+namespace fggl::platform {
+
+	constexpr const char *ENV_USER_CONFIG = "XDG_CONFIG_HOME";
+	constexpr const char *ENV_USER_DATA = "XDG_DATA_HOME";
+	constexpr const char *ENV_USER_CACHE = "XDG_CACHE_HOME";
+
+	constexpr const char *ENV_DATA_DIRS = "XDG_DATA_DIRS";
+	constexpr const char *ENV_CONFIG_DIRS = "XDG_CONFIG_DIRS";
+
+	// fallback user paths defined in the XDG spec
+	constexpr const char *DEFAULT_USER_CONFIG = "~/.config";
+	constexpr const char *DEFAULT_USER_DATA = "~/.local/share";
+	constexpr const char *DEFAULT_USER_CACHE = "~/.cache";
+
+	// fallback search paths defined in the XDG spec
+	constexpr const std::array<const char *, 2> DEFAULT_DATA_DIRS = {"/usr/local/share/", "/usr/share/"};
+	constexpr const std::array<const char *, 1> DEFAULT_CONFIG_DIRS = {"/etc/xdg"};
+
+	struct EnginePaths {
+		std::filesystem::path userConfig;
+		std::filesystem::path userData;
+		std::filesystem::path userCache;
+		std::vector<std::filesystem::path> dataDirs;
+		std::vector<std::filesystem::path> configDirs;
+	};
+
+	EnginePaths calc_engine_paths(const char *base);
+
+	// search routines for finding data and configuration files
+	std::filesystem::path locate_data(const EnginePaths &paths, const std::filesystem::path &relPath);
+	std::filesystem::path locate_config(const EnginePaths &paths, const std::filesystem::path &relPath);
+	std::filesystem::path locate_cache(const EnginePaths &paths, const std::filesystem::path &relPath);
+
+}
+
+#endif //FGGL_PLATFORM_LINUX_PATHS_HPP

include/fggl/platform/paths.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 26/06/22.
+//
+
+#ifndef FGGL_PLATFORM_PATHS_HPP
+#define FGGL_PLATFORM_PATHS_HPP
+
+#include <filesystem>
+#include <vector>
+
+#ifdef __linux__
+	#define FGGL_PLATFORM_PATHS linux
+	#include "fggl/platform/linux/paths.hpp"
+#else
+	#define FGGL_PLATFORM_PATHS fallback
+	#include "fggl/platform/fallback/paths.hpp"
+#endif
+
+#endif //FGGL_PLATFORM_PATHS_HPP

include/fggl/scenes/Scene.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_SCENE_H
-#define FGGL_SCENE_H
+#ifndef FGGL_SCENES_SCENE_HPP
+#define FGGL_SCENES_SCENE_HPP
 
 #include <memory>
 #include <string>
@@ -50,4 +64,4 @@ namespace fggl::scenes {
 
 }
 
-#endif //FGGL_SCENE_H
+#endif //FGGL_SCENES_SCENE_HPP

include/fggl/scenes/game.hpp

 /*
- * ${license.title}
- * Copyright (C) 2022 ${license.owner}
- * ${license.mailto}
+ * This file is part of FGGL.
  *
- * 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.
+ * 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.
  *
- * 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.
+ * 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 this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
  */
 
 //
@@ -26,33 +20,68 @@
 #define FGGL_SCENES_GAME_HPP
 
 #include "fggl/app.hpp"
+#include "fggl/entity/entity.hpp"
 #include "fggl/phys/types.hpp"
 
 namespace fggl::scenes {
 
+	class GameBase : public fggl::AppState {
+
+		public:
+			explicit GameBase(fggl::App &app);
+
+			void update(float dt) override;
+			void render(fggl::gfx::Graphics &gfx) override = 0;
+
+		protected:
+			inline auto input() -> input::Input & {
+				return *m_input;
+			}
+
+			inline void returnToMenu() {
+				m_owner.change_state(m_previous);
+			}
+
+		private:
+			input::Input *m_input;
+			std::string m_previous = "menu";
+	};
+
 	class Game : public fggl::AppState {
 
 		public:
-			explicit Game(fggl::App& app);
+			explicit Game(fggl::App &app);
 
 			void activate() override;
 			void deactivate() override;
 
-			void update() override;
-			void render(fggl::gfx::Graphics& gfx) override;
+			void update(float dt) override;
+			void render(fggl::gfx::Graphics &gfx) override;
 
-		protected:
-			inline auto world() -> ecs3::World& {
+			inline auto world() -> entity::EntityManager & {
 				return *m_world;
 			}
 
-			inline auto input() -> input::Input& {
+
+		protected:
+			bool hasPhys() const {
+				return m_phys != nullptr;
+			}
+
+			inline auto phys() -> phys::PhysicsEngine & {
+				assert(m_phys != nullptr);
+				return *m_phys;
+			}
+
+			inline auto input() -> input::Input & {
 				return *m_input;
 			}
 
+			bool m_debug;
+
 		private:
-			std::shared_ptr<input::Input> m_input;
-			std::unique_ptr<ecs3::World> m_world;
+			input::Input *m_input;
+			std::unique_ptr<entity::EntityManager> m_world;
 			std::unique_ptr<phys::PhysicsEngine> m_phys;
 			std::string m_previous = "menu";
 	};

include/fggl/scenes/menu.hpp

-#ifndef FGGL_SCENES_MENU_H
-#define FGGL_SCENES_MENU_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_SCENES_MENU_HPP
+#define FGGL_SCENES_MENU_HPP
 
 #include <functional>
 #include <map>
@@ -12,29 +26,29 @@
 
 namespace fggl::scenes {
 
-	using callback = std::function<void(void)>;
+	using Callback = std::function<void(void)>;
 
 	class BasicMenu : public AppState {
 		public:
 			explicit BasicMenu(App &owner);
 
-			void update() override;
+			void update(float dt) override;
 			void render(gfx::Graphics &paint) override;
 
 			void activate() override;
 			void deactivate() override;
 
-			void add(const std::string &label, callback cb);
+			void add(const std::string &label, const Callback& /*cb*/);
 
 		private:
-			std::shared_ptr<input::Input> m_inputs;
-			std::map<const std::string, callback> m_items;
+			input::Input *m_inputs;
+			std::map<const std::string, Callback> m_items;
 
 			// menu state
 			std::string m_active;
 			math::vec2 m_cursorPos;
 			gui::Container m_canvas;
-			gui::Widget* m_hover;
+			gui::Widget *m_hover;
 	};
 
 } // namepace fggl::scenes

include/fggl/script/engine.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 15/10/22.
+//
+
+#ifndef FGGL_SCRIPT_ENGINE_H
+#define FGGL_SCRIPT_ENGINE_H
+
+#include "fggl/modules/module.hpp"
+
+namespace fggl::script {
+
+	class ScriptEngine {
+		public:
+			virtual ~ScriptEngine() = default;
+
+			// TODO use protected virtual pattern
+
+			// scene callbacks
+			virtual void onActivate() = 0;
+			virtual void onDeactivate() = 0;
+			virtual void onUpdate() = 0;
+
+			// trigger callback
+			virtual void onEvent(const std::string& name) = 0;
+
+			// run code in engine
+			virtual bool run(const char* script) = 0;
+			virtual bool load(const char* filename) = 0;
+
+			virtual void setGlobal(const char* name, void* ptr) = 0;
+	};
+
+	class ScriptProvider {
+		public:
+			constexpr static const modules::ServiceName service = modules::make_service("fggl::script::service");
+			virtual ScriptEngine* create() = 0;
+	};
+
+}
+
+#endif //FGGL_SCRIPT_ENGINE_H

include/fggl/util/chrono.hpp

-#ifndef FGGL_UTIL_CHRONO_H
-#define FGGL_UTIL_CHRONO_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_UTIL_CHRONO_HPP
+#define FGGL_UTIL_CHRONO_HPP
 
 namespace fggl::util {
 

include/fggl/util/guid.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 23/07/22.
+// See http://www.isthe.com/chongo/tech/comp/fnv/
+//
+
+#ifndef FGGL_UTIL_GUID_HPP
+#define FGGL_UTIL_GUID_HPP
+
+#include <cstdint>
+#include <cassert>
+
+#include "fggl/util/safety.hpp"
+#include "fggl/debug/logging.hpp"
+
+namespace fggl::util {
+
+	using GUID = OpaqueName<std::uint64_t, struct GuidTag>;
+
+	constexpr uint32_t FNV_PRIME_32 = 0x01000193;
+	constexpr uint32_t FNV_OFFSET_BASIS_32 = 0x811c9dc5;
+	constexpr uint64_t FNV_PRIME_64 = 0x00000100000001B3;
+	constexpr uint64_t FNV_OFFSET_BASIS_64 = 0xcbf29ce484222325;
+
+	/**
+	 * Folwer-Noll-Vo 32-bit hash function.
+	 *
+	 * @param str the string to hash.
+	 * @return the hashed value
+	 */
+	constexpr uint32_t hash_fnv1a_32(const char *str) {
+		assert(str != nullptr);
+		uint32_t hash = FNV_OFFSET_BASIS_32;
+		for (int i = 0; str[i] != '\0'; i++) {
+			hash = hash ^ str[i];
+			hash = hash * FNV_PRIME_32;
+		}
+		return hash;
+	}
+
+	/**
+	 * Folwer-Noll-Vo 64-bit hash function.
+	 *
+	 * @param str the string to be hashed
+	 * @return the hashed value
+	 */
+	constexpr uint64_t hash_fnv1a_64(const char *str) {
+		assert(str != nullptr);
+		uint64_t hash = FNV_OFFSET_BASIS_64;
+		for (int i = 0; str[i] != '\0'; i++) {
+			hash = hash ^ str[i];
+			hash = hash * FNV_PRIME_64;
+		}
+		return hash;
+	}
+
+	template<unsigned N>
+	struct FString {
+		char c[N];
+	};
+
+	// https://stackoverflow.com/a/65440575
+	template<unsigned ...Len>
+	constexpr auto cat(const char (&...strings)[Len]) {
+		constexpr unsigned N = (... + Len) - sizeof...(Len);
+		FString<N + 1> result = {};
+		result.c[N] = '\0';
+
+		char* dst = result.c;
+		for (const char* src : {strings...}) {
+			for (; *src != '\0'; src++, dst++) {
+				*dst = *src;
+			}
+		}
+		return result;
+	}
+
+	// debug-only functions
+	#ifndef NDEBUG
+	GUID intern_string(const char *str);
+	std::string guid_to_string(GUID guid);
+	#endif
+
+	constexpr GUID make_guid(const char *str) {
+		return GUID(hash_fnv1a_64(str));
+	}
+
+	inline GUID make_guid_rt(const char* str) {
+		#ifndef NDEBUG
+		return intern_string(str);
+		#else
+		return make_guid(str);
+		#endif
+	}
+
+	inline GUID make_guid_rt(const std::string &str) {
+		return make_guid_rt(str.c_str());
+	}
+
+} // namespace fggl::util
+
+// formatter
+template<> struct fmt::formatter<fggl::util::GUID> {
+	constexpr auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
+		return ctx.begin();
+	}
+
+	template <typename FormatContext>
+	auto format(const fggl::util::GUID& guid, FormatContext& ctx) const -> decltype(ctx.out()) {
+		#ifndef NDEBUG
+		return fmt::format_to(ctx.out(), "GUID[{}]", guid_to_string(guid));
+		#else
+		return fmt::format_to(ctx.out(), "GUID[{}]", guid.get());
+		#endif
+	}
+};
+
+
+fggl::util::GUID operator "" _fid(const char *str);
+fggl::util::GUID operator "" _fid(const char *str, std::size_t);
+
+#endif //FGGL_UTIL_GUID_HPP

include/fggl/util/ownership.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 17/04/22.
 //

include/fggl/util/safety.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_UTIL_SAFETY_HPP
+#define FGGL_UTIL_SAFETY_HPP
+
+#include <string>
+
+namespace fggl::util {
+
+	/**
+	 * A type-safe opaque handle.
+	 *
+	 * Lots of low-level libraries we use pass around handles as some primative type. It's fairly easy to accidentally
+	 * mix these up. This wrapper's job is to make sure that mixing up handle types is impossible (and results in
+	 * compiler errors).
+	 *
+	 * @tparam T the underling type of the handle.
+	 * @tparam Tag a unique tag used to identify the handle type.
+	 */
+	template<typename T, typename Tag>
+	struct OpaqueName {
+		private:
+			T m_value;
+
+		public:
+			explicit constexpr OpaqueName(T value) : m_value(value) {}
+
+			constexpr OpaqueName() : m_value() {}
+
+			constexpr T get() const {
+				return m_value;
+			}
+
+			/**
+			 * Check for equality of two handles.
+			 *
+			 * Two values are considered the same of the values contained inside them are considered equal, and both
+			 * types share the same tagging interface.
+			 *
+			 * @param other the value being compared against.
+			 * @return true iff the contained values are equal
+			 */
+			bool operator==(const OpaqueName<T, Tag> &other) const {
+				return m_value == other.m_value;
+			}
+
+			/**
+			 * Check for equality of two handles.
+			 *
+			 * Two values are considered the same of the values contained inside them are considered equal, and both
+			 * types share the same tagging interface.
+			 *
+			 * @param other the value being compared against.
+			 * @return true iff the contained values are not equal
+			 */
+			bool operator!=(const OpaqueName<T, Tag> &other) const {
+				return m_value != other.m_value;
+			}
+
+			bool operator<(const OpaqueName<T, Tag> &other) const {
+				return m_value < other.m_value;
+			}
+
+			std::strong_ordering operator<=>(const OpaqueName<T, Tag> &other) const noexcept {
+				return m_value <=> other.m_value;
+			}
+
+			/**
+			 * Generate a new tagged instance of a handle.
+			 */
+			constexpr static OpaqueName<T, Tag> make(T value) {
+				return OpaqueName<T, Tag>(value);
+			}
+	};
+
+} // namespace fggl::util
+
+#endif //FGGL_UTIL_SAFETY_HPP

include/fggl/util/service.hpp

-//
-// Created by webpigeon on 20/11/2021.
-//
-
-#ifndef FGGL_SERVICE_H
-#define FGGL_SERVICE_H
-
-#include <memory>
-#include <typeindex>
-#include <unordered_map>
-#include <stdexcept>
-#include <iostream>
-
-namespace fggl::util {
-
-	class ServiceLocator {
-			inline static ServiceLocator *s_instance;
-			std::unordered_map<std::type_index, std::shared_ptr<void>> m_services;
-			ServiceLocator() = default;
-
-		public:
-			// don't allow copying or moving
-			ServiceLocator(ServiceLocator &other) = delete;
-			ServiceLocator(ServiceLocator &&other) = delete;
-
-			static ServiceLocator &instance() {
-				if (s_instance == nullptr) {
-					s_instance = new ServiceLocator();
-				}
-				return *s_instance;
-			}
-
-			template<typename T>
-			std::shared_ptr<T> supply(std::shared_ptr<T> ptr) {
-				auto info = std::type_index(typeid(T));
-				m_services[info] = ptr;
-				return ptr;
-			}
-
-			template<typename T>
-			std::shared_ptr<T> get() {
-				try {
-					auto info = std::type_index(typeid(T));
-					return std::static_pointer_cast<T>(m_services.at(info));
-				} catch ( std::out_of_range& e ){
-					std::cerr << "someone requested a service that doesn't exist!" << std::endl;
-					return nullptr;
-				}
-			}
-
-			template<typename T>
-			std::shared_ptr<T> providePtr() {
-				return get<T>();
-			}
-
-	};
-
-}
-
-#endif //FGGL_SERVICE_H