include/fggl/scenes/game.hpp

@@ -77,6 +77,8 @@ namespace fggl::scenes {
 				return *m_input;
 			}
 
+			bool m_debug;
+
 		private:
 			input::Input *m_input;
 			std::unique_ptr<entity::EntityManager> m_world;

include/fggl/scenes/menu.hpp

@@ -26,7 +26,7 @@
 
 namespace fggl::scenes {
 
-	using callback = std::function<void(void)>;
+	using Callback = std::function<void(void)>;
 
 	class BasicMenu : public AppState {
 		public:
@@ -38,11 +38,11 @@ namespace fggl::scenes {
 			void activate() override;
 			void deactivate() override;
 
-			void add(const std::string &label, callback cb);
+			void add(const std::string &label, const Callback& /*cb*/);
 
 		private:
 			input::Input *m_inputs;
-			std::map<const std::string, callback> m_items;
+			std::map<const std::string, Callback> m_items;
 
 			// menu state
 			std::string m_active;

include/fggl/script/engine.hpp

@@ -46,7 +46,7 @@ namespace fggl::script {
 
 	class ScriptProvider {
 		public:
-			constexpr static const modules::ModuleService service = modules::make_service("fggl::script::service");
+			constexpr static const modules::ServiceName service = modules::make_service("fggl::script::service");
 			virtual ScriptEngine* create() = 0;
 	};
 

include/fggl/util/guid.hpp

@@ -67,10 +67,31 @@ namespace fggl::util {
 		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 internString(const char *str);
-	std::string guidToString(GUID guid);
+	GUID intern_string(const char *str);
+	std::string guid_to_string(GUID guid);
 	#endif
 
 	constexpr GUID make_guid(const char *str) {
@@ -79,7 +100,7 @@ namespace fggl::util {
 
 	inline GUID make_guid_rt(const char* str) {
 		#ifndef NDEBUG
-		return internString(str);
+		return intern_string(str);
 		#else
 		return make_guid(str);
 		#endif
@@ -94,14 +115,13 @@ namespace fggl::util {
 // formatter
 template<> struct fmt::formatter<fggl::util::GUID> {
 	constexpr auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
-		auto it = ctx.begin(), end = ctx.end();
-		return it;
+		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[{}]", guidToString(guid));
+		return fmt::format_to(ctx.out(), "GUID[{}]", guid_to_string(guid));
 		#else
 		return fmt::format_to(ctx.out(), "GUID[{}]", guid.get());
 		#endif

include/fggl/util/states.hpp

@@ -63,7 +63,7 @@ namespace fggl::util {
 			}
 
 			StateType &active() const {
-				assertm(m_states.find(m_active) != m_states.end(), "active state does not exist!");
+				ASSERT_MSG(m_states.find(m_active) != m_states.end(), "active state does not exist!");
 				return *(m_states.at(m_active).get());
 			}
 

integrations/README.md

+# Integration Modules
+This adds support for 3rd party libraries to the engine. These can be included in projects
+to expose modules which can then be used in your applications.
+
+## Integrations Provided
+The following integration modules are povided in this folder. For more information please see the readme for that module.
+
+| Integration | Module Name           | Description                                        |
+|-------------|-----------------------|----------------------------------------------------|
+| Bullet      | `fggl::phys::Bullet3` | Provides Bullet3 integration into the game engine. |
+| Lua         | `fggl::script::Lua`   | Provides LUA scripting support for the engine      |
+
+Modules that cannot be included for legal reasons will be packaged independently of this repository.
\ No newline at end of file

integrations/entt/CMakeLists.txt

-target_include_directories( fggl
-        PUBLIC
-            $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>
-            $<INSTALL_INTERFACE:include>
-)

integrations/lua/CMakeLists.txt

@@ -2,6 +2,7 @@ add_library(fggl-lua)
 
 find_package(Lua REQUIRED)
 target_link_libraries(fggl-lua PUBLIC ${LUA_LIBRARIES})
+target_include_directories(fggl-lua INTERFACE ${LUA_INCLUDE_DIR})
 
 # Link to FGGL
 target_link_libraries(fggl-lua PUBLIC fggl)

integrations/lua/include/fggl/script/lua/engine.hpp

@@ -23,9 +23,9 @@
 #include "fggl/data/storage.hpp"
 
 extern "C" {
-	#include <lua.h>
-	#include <lauxlib.h>
-	#include <lualib.h>
+	#include "lua.h"
+	#include "lauxlib.h"
+	#include "lualib.h"
 };
 
 namespace fggl::script::lua {

integrations/lua/include/fggl/script/lua/module.hpp

@@ -19,21 +19,30 @@
 #ifndef FGGL_INTEGRATIONS_LUA_SCRIPT_LUA_MODULE_HPP
 #define FGGL_INTEGRATIONS_LUA_SCRIPT_LUA_MODULE_HPP
 
+#define FGGL_HAS_LUA
+
 #include "fggl/modules/module.hpp"
 #include "fggl/entity/module.hpp"
 #include "fggl/script/engine.hpp"
 #include "fggl/data/module.hpp"
+#include "fggl/assets/packed/adapter.hpp"
+
 
 namespace fggl::script::lua {
+
+	constexpr auto MIME_LUA = assets::from_mime("text/lua");
+	constexpr auto SCRIPT_LUA = assets::make_asset_type("script/lua");
+
 	struct Lua {
 		constexpr static const char* name = "fggl::script::lua";
-		constexpr static const std::array<modules::ModuleService, 1> provides = {
+		constexpr static const std::array<modules::ServiceName, 1> provides = {
 			script::ScriptProvider::service
 		};
-		constexpr static const std::array<modules::ModuleService, 1> depends = {
-			data::SERVICE_STORAGE
+		constexpr static const std::array<modules::ServiceName, 2> depends = {
+			data::SERVICE_STORAGE,
+			assets::CheckinAdapted::service
 		};
-		static bool factory(modules::ModuleService name, modules::Services& serviceManager);
+		static bool factory(modules::ServiceName name, modules::Services& serviceManager);
 	};
 
 } // namespace fggl::script::lua

integrations/lua/src/engine.cpp

@@ -19,11 +19,40 @@
 #include "fggl/script/lua/engine.hpp"
 #include "fggl/debug/logging.hpp"
 
+#include "fggl/scenes/game.hpp"
+#include "fggl/entity/loader/loader.hpp"
+
 #include <cassert>
 
+extern "C" {
+	int lua_switch_scene(lua_State *L) {
+		auto *scene = lua_tostring(L, -1);
+		auto *statePtr = (fggl::AppState *) (lua_topointer(L, -2));
+		statePtr->owner().change_state(scene);
+		return 0;
+	}
+
+	int lua_create_entity(lua_State *L) {
+		/*auto *prototype = lua_tostring(L, -1);
+		auto *statePtr = (fggl::scenes::Game*) (lua_topointer(L, -2));
+
+		auto *factory = statePtr->owner().service<fggl::entity::EntityFactory>();
+		//factory->create( statePtr->world(), , [](){} );
+		*/
+		return 0;
+	}
+
+	static void open_lua_fggl(lua_State *L) {
+		// switch scene
+		lua_pushcfunction(L, lua_switch_scene);
+		lua_setglobal(L, "switch_scene");
+	}
+}
+
 namespace fggl::script::lua {
 
 	LuaScriptProvider::LuaScriptProvider(data::Storage *storage) : m_storage(storage) {
+
 	}
 
 	LuaScriptEngine *LuaScriptProvider::create() {
@@ -32,6 +61,7 @@ namespace fggl::script::lua {
 
 	LuaScriptEngine::LuaScriptEngine(data::Storage* storage) : m_state(luaL_newstate()), m_storage(storage) {
 		luaL_openlibs(m_state);
+		open_lua_fggl(m_state);
 	}
 
 	LuaScriptEngine::~LuaScriptEngine() {

integrations/lua/src/module.cpp

@@ -21,11 +21,22 @@
 
 namespace fggl::script::lua {
 
-	bool Lua::factory(modules::ModuleService service, modules::Services &serviceManager) {
+	static assets::AssetTypeID is_lua(std::filesystem::path path) {
+		if ( path.extension() == ".lua" ) {
+			return SCRIPT_LUA;
+		}
+		return assets::INVALID_ASSET_TYPE;
+	}
+
+	bool Lua::factory(modules::ServiceName service, modules::Services &serviceManager) {
 
 		if ( service == ScriptProvider::service ) {
-			auto storageService = serviceManager.get<data::Storage>();
+			auto *storageService = serviceManager.get<data::Storage>();
 			serviceManager.bind<ScriptProvider,LuaScriptProvider>(storageService);
+
+			auto *assetPacker = serviceManager.get<assets::CheckinAdapted>();
+			assetPacker->setLoader(MIME_LUA, assets::NEEDS_CHECKIN, is_lua);
+
 			return true;
 		}
 

tools/pack/src/binary.hpp

@@ -30,8 +30,8 @@
 // Created by webpigeon on 11/09/22.
 //
 
-#ifndef FGGL_TOOLS_PACK_INCLUDES_BINARY_HPP
-#define FGGL_TOOLS_PACK_INCLUDES_BINARY_HPP
+#ifndef FGGL_TOOLS_PACK_SRC_BINARY_HPP
+#define FGGL_TOOLS_PACK_SRC_BINARY_HPP
 
 #include <cstdint>
 #include <iostream>
@@ -132,4 +132,4 @@ namespace fggl::data {
 
 }
 
-#endif //FGGL_TOOLS_PACK_INCLUDES_BINARY_HPP
+#endif //FGGL_TOOLS_PACK_SRC_BINARY_HPP

vendor/README.md

+# Vendor Libraries
+This folder contains 3rd party code we need to ship with our build.
+Compile-time only dependencies, or dependencies which can be included using cmake directly will not be included within this folder.
+
+| Library    | Purpose                                          | Licence |
+|------------|--------------------------------------------------|---------|
+| GLAD       | Allow loading of OpenGL libraries and extentions | MIT     |
+| Dear IMGUI | Debugging UI/Editor windows                      | MIT     |
\ No newline at end of file

vendor/entt/CMakeLists.txt

+add_library( entt INTERFACE )
+
+target_include_directories( entt
+        INTERFACE
+            $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>
+            $<INSTALL_INTERFACE:include>
+)
+
+install(
+        FILES
+            include/fggl/vendor/entt.hpp
+        DESTINATION
+            ${CMAKE_INSTALL_INCLUDEDIR}/fggl/vendor/entt.hpp
+)
+
+install(TARGETS entt
+        EXPORT fgglTargets
+        DESTINATION
+            ${CMAKE_INSTALL_LIBDIR}/fggl/entt
+)

vendor/imgui/CMakeLists.txt

@@ -23,5 +23,5 @@ include(GNUInstallDirs)
 install(TARGETS imgui
 		EXPORT fgglTargets
 		PUBLIC_HEADER
-		  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/fggl/imgui
+		DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/fggl/imgui
 )
\ No newline at end of file