integrations/bullet/src/simulation.cpp

+/*
+ * 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/>.
+ */
+
+/*
+ * 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/>.
+ */
+
+#include "../include/fggl/phys/bullet/types.hpp"
+#include "../include/fggl/phys/bullet/motion.hpp"
+
+namespace fggl::phys::bullet {
+
+	inline btVector3 to_bullet(const math::vec3 fgglVec) {
+		return {fgglVec.x, fgglVec.y, fgglVec.z};
+	}
+
+	BulletPhysicsEngine::BulletPhysicsEngine(entity::EntityManager* world) : m_ecs(world), m_config(), m_world(nullptr), m_debug(nullptr) {
+		m_config.broadphase = new btDbvtBroadphase();
+		m_config.collisionConfiguration = new btDefaultCollisionConfiguration();
+		m_config.dispatcher = new btCollisionDispatcher(m_config.collisionConfiguration);
+		m_config.solver = new btSequentialImpulseConstraintSolver();
+
+		m_world = new btDiscreteDynamicsWorld(
+			m_config.dispatcher,
+			m_config.broadphase,
+			m_config.solver,
+			m_config.collisionConfiguration);
+
+
+		// callbacks (for handling bullet -> ecs)
+
+		// ensure we deal with ecs -> bullet changes
+		//m_ecs->addDeathListener( [this](auto entity) { this->onEntityDeath(entity);} );
+	}
+
+	void BulletPhysicsEngine::step() {
+		// this is now handled on creation
+		//checkForPhys();
+
+		auto dynamicEnts = m_ecs->find<phys::Dynamics, phys::bullet::BulletBody>();
+		for (auto& ent : dynamicEnts) {
+			auto& dynamicComp = m_ecs->get<phys::Dynamics>(ent);
+			auto& bulletProxy = m_ecs->get<phys::bullet::BulletBody>(ent);
+
+			const auto forceVec = dynamicComp.force;
+			if ( glm::length(forceVec) != 0.F ) {
+				bulletProxy.body->applyCentralForce({forceVec.x, forceVec.y, forceVec.z});
+				bulletProxy.body->activate();
+				dynamicComp.force = math::VEC3_ZERO;
+			}
+		}
+
+		m_world->stepSimulation(60.0F);
+		//syncToECS();
+		pollCollisions();
+
+		// if debug draw is enabled, trigger a draw call
+		if ( m_debug != nullptr ) {
+			m_world->debugDrawWorld();
+		}
+	}
+
+	void BulletPhysicsEngine::addBody(entity::EntityID /*entity*/, BulletBody &body) {
+		// ensure static objects are placed correctly by setting their transforms to the correct value
+		btTransform transform;
+		body.body->getMotionState()->getWorldTransform(transform);
+		body.body->setWorldTransform(transform);
+
+		m_world->addRigidBody(body.body);
+	}
+
+	void BulletPhysicsEngine::setDebugDraw(bool active)  {
+		if ( active ) {
+			m_debug = std::make_unique<debug::BulletDebugDrawList>();
+			m_world->setDebugDrawer(m_debug.get());
+			m_debug->setDebugMode(btIDebugDraw::DBG_DrawWireframe);
+		} else {
+			m_debug = nullptr;
+		}
+	}
+
+	void BulletPhysicsEngine::syncTransformToECS() {
+		const auto physEnts = m_ecs->find<math::Transform, BulletBody>();
+		for (const auto& ent : physEnts) {
+			auto& physBody = m_ecs->get<BulletBody>(ent);
+			// don't bother syncing things with motion states, it's not necessary
+			if ( physBody.motion != nullptr ) {
+				continue;
+			}
+
+			auto& transform = m_ecs->get<math::Transform>(ent);
+			if ( physBody.body->isKinematicObject() ) {
+				continue;
+			}
+
+			btTransform bTransform;
+			physBody.motion->getWorldTransform(bTransform);
+
+			// set calculate and set ecs position
+			auto& btPos = bTransform.getOrigin();
+			math::vec3 pos{btPos.x(), btPos.y(), btPos.z()};
+			transform.origin( pos );
+
+			// set the rotation
+			const auto& btRot = bTransform.getRotation();
+
+			math::vec3 rot;
+			btRot.getEulerZYX(rot.x, rot.y, rot.z);
+			transform.euler(rot);
+		}
+	}
+
+	BulletPhysicsEngine::~BulletPhysicsEngine() {
+		// clean up the rigid bodies
+		auto entRB = m_ecs->find<BulletBody>();
+		for (const auto& ent : entRB) {
+			auto& bulletBody = m_ecs->get<BulletBody>(ent);
+			if ( bulletBody.body != nullptr ) {
+				m_world->removeCollisionObject(bulletBody.body);
+			}
+
+			// release resources and delete
+			bulletBody.release();
+		}
+
+		// delete the world
+		delete m_world;
+
+		// cleanup the configuration object
+		delete m_config.solver;
+		delete m_config.broadphase;
+		delete m_config.dispatcher;
+		delete m_config.collisionConfiguration;
+	}
+
+	static void handleCollisionCallbacks(entity::EntityManager* world, entity::EntityID owner, entity::EntityID other) {
+		if ( !world->has<CollisionCallbacks>(owner) ) {
+			return;
+		}
+
+		auto* callbacks = world->tryGet<CollisionCallbacks>(owner);
+		auto* cache = world->tryGet<CollisionCache>(owner);
+		if ( cache != nullptr ) {
+			auto itr = cache->collisions.find(other);
+			if ( itr == cache->collisions.end() ) {
+				if ( callbacks->onEnter != nullptr ) {
+					callbacks->onEnter(owner, other);
+				}
+				cache->collisions.insert(  other );
+			} else {
+				if ( callbacks->onStay != nullptr ) {
+					callbacks->onStay(owner, other);
+				}
+			}
+		}
+	}
+
+	void BulletPhysicsEngine::pollCollisions() {
+		// flush collision caches
+		auto caches = m_ecs->find<CollisionCache>();
+		for( const auto& ent : caches) {
+			auto& cache = m_ecs->get<CollisionCache>(ent);
+			std::swap(cache.collisions, cache.lastFrame);
+			cache.collisions.clear();
+		}
+
+		// deal with the number of manifolds
+		const auto numManifolds = m_config.dispatcher->getNumManifolds();
+		for ( int i=0; i< numManifolds; ++i) {
+			auto* contactManifold = m_config.dispatcher->getManifoldByIndexInternal(i);
+
+			const auto* body0 = contactManifold->getBody0();
+			const auto* body1 = contactManifold->getBody1();
+
+			int numContacts = contactManifold->getNumContacts();
+			for ( auto contactIdx = 0; contactIdx < numContacts; ++contactIdx ) {
+				auto& point = contactManifold->getContactPoint(contactIdx);
+				if ( point.getDistance() < 0.0F ) {
+					auto worldPosA = point.getPositionWorldOnA();
+					auto worldPosB = point.getPositionWorldOnB();
+					auto normal = point.m_normalWorldOnB;
+				}
+			}
+
+			//handleCollisionCallbacks(m_ecs, body0->getUserIndex(), body1->getUserIndex());
+			//handleCollisionCallbacks(m_ecs, body1->getUserIndex(), body0->getUserIndex());
+		}
+
+		// note contacts that have ended
+		caches = m_ecs->find<CollisionCache>(); // re-fetch, entities can (and probably do) die in handlers.
+		for( const auto& ent : caches) {
+			auto& cache = m_ecs->get<CollisionCache>(ent);
+
+			// if we don't have an exit callback, it's pointless checking the cache
+			auto* callbacks = m_ecs->tryGet<CollisionCallbacks>(ent);
+			if ( callbacks == nullptr || callbacks->onExit == nullptr){
+				continue;
+			}
+
+			// check if a collision has ended
+			for (const auto& other : cache.lastFrame) {
+				auto itr = cache.collisions.find(other);
+				if (itr == cache.collisions.end()) {
+					callbacks->onExit( ent,other);
+				}
+			}
+		}
+	}
+
+	void BulletPhysicsEngine::onEntityDeath(entity::EntityID entity)  {
+			auto* btPhysics = m_ecs->tryGet<BulletBody>(entity);
+			if ( btPhysics != nullptr) {
+				// decouple physics from entity
+				//btPhysics->body->setUserIndex( entity::INVALID );
+				m_world->removeRigidBody( btPhysics->body );
+				btPhysics->release();
+			}
+	}
+
+	void BulletPhysicsEngine::onCollisionCreate(ContactPoint point) {
+		m_contactCache.created.push_back(point);
+	}
+
+	void BulletPhysicsEngine::onCollisionProcess(ContactPoint point) {
+		m_contactCache.modified.push_back( point );
+	}
+
+	void BulletPhysicsEngine::onCollisionDestroyed(ContactPoint point) {
+		m_contactCache.removed.push_back(point);
+	}
+
+	entity::EntityID BulletPhysicsEngine::raycast(math::vec3 from, math::vec3 to) {
+		const auto btFrom = to_bullet(from);
+		const auto btTo = to_bullet(to);
+
+		btCollisionWorld::ClosestRayResultCallback rayTestResult(btFrom, btTo);
+		m_world->rayTest(btFrom, btTo, rayTestResult);
+
+		if ( !rayTestResult.hasHit() ) {
+			return entity::INVALID;
+		}
+
+		// tell the user what it hit
+		return entity::INVALID;
+//		return rayTestResult.m_collisionObject->getUserIndex();
+	}
+
+	std::vector<ContactPoint> BulletPhysicsEngine::scanCollisions(entity::EntityID entity) {
+		return std::vector<ContactPoint>();
+	}
+
+	std::vector<entity::EntityID> BulletPhysicsEngine::raycastAll(math::vec3 fromPos, math::vec3 toPos) {
+		const auto btFrom = to_bullet(fromPos);
+		const auto btTo = to_bullet(toPos);
+
+		btCollisionWorld::AllHitsRayResultCallback rayTestResult(btFrom, btTo);
+		m_world->rayTest(btFrom, btTo, rayTestResult);
+
+		// we didn't hit anything
+		if ( !rayTestResult.hasHit() ) {
+			return {};
+		}
+
+		// hit processing
+		const auto hits = rayTestResult.m_collisionObjects.size();
+
+		std::vector<entity::EntityID> hitVec;
+		hitVec.reserve(hits);
+
+		for ( auto i = 0; i < hits; ++i) {
+			auto entity = rayTestResult.m_collisionObjects[i]->getUserIndex();
+			//hitVec.push_back(entity);
+		}
+
+		return hitVec;
+	}
+
+	std::vector<entity::EntityID> BulletPhysicsEngine::sweep(PhyShape &shape,
+														   math::Transform &from,
+														   math::Transform &to) {
+		return std::vector<entity::EntityID>();
+	}
+
+} // namespace fggl::phys::bullet
\ No newline at end of file

integrations/lua/CMakeLists.txt

+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)
+
+# sources and include directories
+target_sources(fggl-lua
+    PRIVATE
+        src/engine.cpp
+        src/module.cpp
+)
+target_include_directories(fggl-lua
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+)

integrations/lua/include/fggl/script/lua/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_INTEGRATIONS_LUA_SCRIPT_LUA_ENGINE_HPP
+#define FGGL_INTEGRATIONS_LUA_SCRIPT_LUA_ENGINE_HPP
+
+#include "fggl/script/engine.hpp"
+#include "fggl/data/storage.hpp"
+
+extern "C" {
+	#include "lua.h"
+	#include "lauxlib.h"
+	#include "lualib.h"
+};
+
+namespace fggl::script::lua {
+
+	class LuaScriptEngine : public ScriptEngine {
+		public:
+			LuaScriptEngine(data::Storage* storage);
+			virtual ~LuaScriptEngine();
+
+			void onActivate() override;
+			void onDeactivate() override;
+			void onUpdate() override;
+
+			void onEvent(const std::string& name) override;
+
+			// running scripts
+			bool run(const char* script) override;
+			bool load(const char* filename) override;
+
+			// variables
+			void setGlobal(const char* name, void* ptr) override;
+
+		private:
+			data::Storage* m_storage;
+			lua_State* m_state;
+			void release();
+	};
+
+	class LuaScriptProvider : public ScriptProvider {
+		public:
+			LuaScriptProvider(data::Storage* storage);
+
+			virtual ~LuaScriptProvider() = default;
+			LuaScriptEngine* create() override;
+
+		private:
+			data::Storage* m_storage;
+	};
+
+}
+
+#endif //FGGL_INTEGRATIONS_LUA_SCRIPT_LUA_ENGINE_HPP

integrations/lua/include/fggl/script/lua/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 15/10/22.
+//
+
+#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::ServiceName, 1> provides = {
+			script::ScriptProvider::service
+		};
+		constexpr static const std::array<modules::ServiceName, 2> depends = {
+			data::SERVICE_STORAGE,
+			assets::CheckinAdapted::service
+		};
+		static bool factory(modules::ServiceName name, modules::Services& serviceManager);
+	};
+
+} // namespace fggl::script::lua
+
+namespace fggl::script {
+	using Lua = lua::Lua;
+
+} // namespace fggl::script
+
+#endif //FGGL_INTEGRATIONS_LUA_SCRIPT_LUA_MODULE_HPP

integrations/lua/src/engine.cpp

+/*
+ * 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.
+//
+
+#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() {
+		return new LuaScriptEngine(m_storage);
+	}
+
+	LuaScriptEngine::LuaScriptEngine(data::Storage* storage) : m_state(luaL_newstate()), m_storage(storage) {
+		luaL_openlibs(m_state);
+		open_lua_fggl(m_state);
+	}
+
+	LuaScriptEngine::~LuaScriptEngine() {
+		release();
+	}
+
+	void LuaScriptEngine::release() {
+		if ( m_state != nullptr ) {
+			lua_close(m_state);
+			m_state = nullptr;
+		}
+	}
+
+	void LuaScriptEngine::onActivate() {
+		lua_getglobal(m_state, "print");
+		lua_pushstring(m_state, "LUA activate triggered");
+		lua_call(m_state, 1, 0);
+	}
+
+	void LuaScriptEngine::onDeactivate() {
+		lua_getglobal(m_state, "print");
+		lua_pushstring(m_state, "LUA deactivate triggered");
+		lua_call(m_state, 1, 0);
+	}
+
+	void LuaScriptEngine::onUpdate() {
+		lua_getglobal(m_state, "print");
+		lua_pushstring(m_state, "LUA update triggered");
+		lua_call(m_state, 1, 0);
+	}
+
+	void LuaScriptEngine::onEvent(const std::string &name) {
+		lua_getglobal(m_state, "print");
+		lua_pushstring(m_state, "LUA event triggered");
+		lua_call(m_state, 1, 0);
+	}
+
+	bool LuaScriptEngine::run(const char *script) {
+		auto result = luaL_dostring(m_state, script);
+		if ( !result ) {
+			fggl::debug::warning("lua error: {}", lua_tostring(m_state, -1));
+		}
+		return result;
+	}
+
+	bool LuaScriptEngine::load(const char *filename) {
+		assert( filename != nullptr);
+		auto path = m_storage->resolvePath(data::StorageType::Data, filename);
+
+		if ( !std::filesystem::exists(path) ) {
+			fggl::debug::warning("lua error: file does not exist: {}", path.c_str());
+			return false;
+		}
+
+		// load the file ( OK = 0 = false because reasons...)
+		auto result = !luaL_dofile(m_state, path.c_str());
+		if ( !result ) {
+			fggl::debug::warning("lua error: {}", lua_tostring(m_state, -1));
+			return false;
+		}
+		return true;
+	}
+
+	void LuaScriptEngine::setGlobal(const char *name, void *ptr) {
+		lua_pushlightuserdata(m_state, ptr);
+		lua_setglobal(m_state, name);
+	}
+
+}
\ No newline at end of file

integrations/lua/src/module.cpp

+/*
+ * 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.
+//
+
+#include "fggl/script/lua/module.hpp"
+#include "fggl/script/lua/engine.hpp"
+
+namespace fggl::script::lua {
+
+	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>();
+			serviceManager.bind<ScriptProvider,LuaScriptProvider>(storageService);
+
+			auto *assetPacker = serviceManager.get<assets::CheckinAdapted>();
+			assetPacker->setLoader(MIME_LUA, assets::NEEDS_CHECKIN, is_lua);
+
+			return true;
+		}
+
+		return false;
+	}
+
+}
\ No newline at end of file

tests/CMakeLists.txt

 find_package(Threads REQUIRED)
 
 # GTest Dependency
-include(FetchContent)
-FetchContent_Declare(
-  googletest
-  URL https://github.com/google/googletest/archive/refs/tags/release-1.11.0.zip
-)
-# For Windows: Prevent overriding the parent project's compiler/linker settings
-set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
-FetchContent_MakeAvailable(googletest)
+find_package( GTest REQUIRED )
+if ( NOT GTest_FOUND )
+    message(NOTICE "GTest not found, installing...")
+    include(FetchContent)
+    FetchContent_Declare(
+      googletest
+      URL https://github.com/google/googletest/archive/refs/tags/release-1.11.0.zip
+    )
+    # For Windows: Prevent overriding the parent project's compiler/linker settings
+    set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+    FetchContent_MakeAvailable(googletest)
+endif ()
 
 add_subdirectory(testfggl)

tests/testfggl/CMakeLists.txt

 enable_testing()
 
-add_executable(
-	fggl_test
-	#	TestFggl.cpp
-	ecs/ecs.cpp
-	ecs3/ecs.cpp
-	math/types.cpp
-        ecs3/utils.cpp)
-target_include_directories(fggl_test PUBLIC ${PROJECT_BINARY_DIR})
+add_executable( fggl_test
+#	TestFggl.cpp
+#	ecs/ecs.cpp
+#	ecs3/ecs.cpp
+#	ecs3/easing.cpp
+#	math/types.cpp
+	util/guid.cpp
+	util/safety.cpp
+)
+target_include_directories(fggl_test
+	PUBLIC
+		${PROJECT_BINARY_DIR}
+)
 
-target_link_libraries(
-	fggl_test
+target_link_libraries(fggl_test
 	fggl
+	gtest
 	gtest_main
 	gmock
 )
 
 include(GoogleTest)
 gtest_discover_tests(fggl_test)
-
-add_test(
-	NAME gtest
-	COMMAND $<TARGET_FILE:fggl_test>
-)