diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1c7eb767cdd2e0a6e239a62c0c9245b69bec7242..7368b2fdff8b5248e027b435d9900af35f23470f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -48,6 +48,8 @@ add_subdirectory( fggl )
target_compile_options( fggl PRIVATE -Wall -Wpedantic -Wextra -Wodr -fno-strict-aliasing -fno-strict-overflow )
set_property(TARGET fggl PROPERTY INTERPROCEDURAL_OPTIMIZATION True)
+add_subdirectory( components )
+
# Unit Tests
if (FGGL_TESTS)
include(CTest)
diff --git a/components/CMakeLists.txt b/components/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e220ee79c6760b1dc26e5925d75960a360eec34e
--- /dev/null
+++ b/components/CMakeLists.txt
@@ -0,0 +1 @@
+add_subdirectory(physics)
\ No newline at end of file
diff --git a/components/physics/CMakeLists.txt b/components/physics/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c9241e8632605296e916d9f1d680786182387b92
--- /dev/null
+++ b/components/physics/CMakeLists.txt
@@ -0,0 +1,11 @@
+add_library(fggl-phys)
+
+target_link_libraries(fggl-phys fggl)
+
+target_include_directories(fggl-phys PUBLIC include)
+target_sources(fggl-phys
+ PRIVATE
+ src/collision.cpp
+ src/integration.cpp
+ src/service.cpp
+ )
\ No newline at end of file
diff --git a/components/physics/docs/NOTICE b/components/physics/docs/NOTICE
new file mode 100644
index 0000000000000000000000000000000000000000..703fdb35fafc9b1d6a2abfd713378020328376e1
--- /dev/null
+++ b/components/physics/docs/NOTICE
@@ -0,0 +1,31 @@
+fggl-physics includes code derived from:
+
+Game Physics Engine Development, by Ian Millington
+CRC Press, ISBN 978-0-12-381976-5
+
+This book includes code from Cyclone Physics, available under the MIT licence:
+
+The MIT License
+
+Copyright (c) 2003-2009 Ian Millington
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+
+
diff --git a/components/physics/include/phys/module.hpp b/components/physics/include/phys/module.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..f770494e643081b1a88256f9fb0690b2608b4fb9
--- /dev/null
+++ b/components/physics/include/phys/module.hpp
@@ -0,0 +1,68 @@
+/*
+ * 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 24/06/23.
+//
+
+#ifndef FGGL_COMPONENTS_PHYSICS_INCLUDE_PHYS_MODULE_HPP
+#define FGGL_COMPONENTS_PHYSICS_INCLUDE_PHYS_MODULE_HPP
+
+#include <fggl/phys/types.hpp>
+#include <fggl/phys/service.hpp>
+
+namespace fggl::phys {
+
+ class InternalPhysicsEngine : public PhysicsEngine {
+ public:
+ explicit InternalPhysicsEngine( entity::EntityManager* entities );
+ void step() override;
+
+ std::vector<ContactPoint> scanCollisions(entity::EntityID) override;
+
+ entity::EntityID raycast(math::vec3, math::vec3) override;
+ std::vector<entity::EntityID> raycastAll(math::vec3, math::vec3) override;
+ std::vector<entity::EntityID> sweep(PhyShape &shape,
+ math::Transform &from,
+ math::Transform &to) override;
+
+ inline void setDebugDraw(bool enable) override {
+ m_debugDraw = enable;
+ }
+
+ private:
+ entity::EntityManager* m_entities;
+ bool m_debugDraw = false;
+ };
+
+ class InternalPhysicsProvider : public PhysicsProvider {
+ public:
+ virtual ~InternalPhysicsProvider() = default;
+ InternalPhysicsEngine* create(entity::EntityManager*, entity::EntityFactory*) override;
+ };
+
+ struct InternalPhysics {
+ constexpr static const char *name = "fggl::phys::internal";
+ 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 name, modules::Services& services);
+ };
+
+} // namespace fggl::phys
+
+#endif //FGGL_COMPONENTS_PHYSICS_INCLUDE_PHYS_MODULE_HPP
diff --git a/components/physics/include/phys/types.hpp b/components/physics/include/phys/types.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..70a48533e6c52d1366c089595065a01ff7fbd05e
--- /dev/null
+++ b/components/physics/include/phys/types.hpp
@@ -0,0 +1,38 @@
+/*
+ * 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 24/06/23.
+//
+
+#ifndef FGGL_COMPONENTS_PHYSICS_INCLUDE_PHYS_TYPES_HPP
+#define FGGL_COMPONENTS_PHYSICS_INCLUDE_PHYS_TYPES_HPP
+
+#include <fggl/math/fmath.hpp>
+#include <fggl/entity/module.hpp>
+
+namespace fggl::phys {
+ constexpr float FLOAT_HALF = 0.5F;
+
+ struct Motion {
+ math::vec3f velocity;
+ math::vec3f acceleration;
+ float damping = 0.9F;
+ };
+
+ void euler(entity::EntityManager& entities, float duration);
+
+} // namespace fggl::phys
+
+#endif //FGGL_COMPONENTS_PHYSICS_INCLUDE_PHYS_TYPES_HPP
diff --git a/components/physics/src/collision.cpp b/components/physics/src/collision.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0fae02d6097ebfa221c1fec089be1254fe6114bc
--- /dev/null
+++ b/components/physics/src/collision.cpp
@@ -0,0 +1,21 @@
+/*
+ * 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/>.
+ */
+
+namespace fggl::phys {
+
+ void detect_collisions() {
+
+ }
+
+} // namespace fggl::phys
\ No newline at end of file
diff --git a/components/physics/src/integration.cpp b/components/physics/src/integration.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a94c98a08227b2cb30ad3dcb8440f469166390d9
--- /dev/null
+++ b/components/physics/src/integration.cpp
@@ -0,0 +1,41 @@
+/*
+ * 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 <phys/types.hpp>
+#include <fggl/entity/module.hpp>
+
+namespace fggl::phys {
+
+ void euler(entity::EntityManager& entities, float duration) {
+
+ auto physEntities = entities.find<math::Transform, Motion, Dynamics>();
+
+ for ( const auto& entity : physEntities ) {
+ auto& transform = entities.get<math::Transform>(entity);
+ auto& motion = entities.get<Motion>(entity);
+ auto& dynamics = entities.get<Dynamics>(entity);
+
+ transform.origin( math::add_scaled(transform.origin(), motion.velocity, duration) );
+ //math::add_scaled(entity.position, entity.acceleration, duration * duration * FLOAT_HALF);
+
+ math::vec3f const resultingAcc = dynamics.force;
+ motion.velocity = math::add_scaled( motion.velocity, resultingAcc, duration );
+ motion.velocity *= powf( motion.damping, duration);
+
+ dynamics.force = math::VEC3_ZERO;
+ }
+
+ }
+
+} // namespace fggl::phys
\ No newline at end of file
diff --git a/components/physics/src/service.cpp b/components/physics/src/service.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4cc48131bb6935bd71eeab4882f49bcac50fd9cf
--- /dev/null
+++ b/components/physics/src/service.cpp
@@ -0,0 +1,125 @@
+/*
+ * 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 24/06/23.
+//
+
+#include <phys/module.hpp>
+#include <phys/types.hpp>
+
+namespace fggl::phys {
+
+ namespace {
+ void build_internal(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);
+ manager.add<fggl::phys::Motion>(entity);
+ }
+ }
+
+ constexpr float DELTA_60 = 1000.0F / 60.0F;
+ constexpr float DELTA_TO_SECONDS = 1.F / 1000.F;
+
+ InternalPhysicsEngine *InternalPhysicsProvider::create(entity::EntityManager *manager, entity::EntityFactory *factory) {
+ factory->bind(util::make_guid("phys::Body"), build_internal);
+ return new InternalPhysicsEngine(manager);
+ }
+
+ bool InternalPhysics::factory(modules::ServiceName serviceName, modules::Services &services) {
+ if ( serviceName == phys::PhysicsProvider::service ) {
+ services.bind<phys::PhysicsProvider, InternalPhysicsProvider>();
+ return true;
+ }
+ return false;
+ }
+
+ void checkCollisions(entity::EntityManager& manager) {
+ auto colliders = manager.find<math::Transform, RigidBody>();
+ for ( auto entity : colliders ) {
+
+ }
+ }
+
+ void InternalPhysicsEngine::step() {
+ euler( *m_entities, DELTA_60 * DELTA_TO_SECONDS );
+ }
+
+
+ bool overlaps(const entity::EntityID& e1, math::Transform& t1, RigidBody& b1,
+ const entity::EntityID& e2, math::Transform& t2, RigidBody& b2, ContactPoint& cp) {
+
+ auto distance = glm::distance(t1.origin(), t2.origin());
+ if ( distance <= 2.0F ) {
+ cp.entityA = e1;
+ cp.entityB = e2;
+
+ return true;
+ }
+
+ return false;
+ }
+
+ std::vector<ContactPoint> InternalPhysicsEngine::scanCollisions(entity::EntityID target) {
+ // really dumb N^2 version, need to use acceleration structure
+
+ auto colliders = m_entities->find<math::Transform, RigidBody>();
+ std::vector<ContactPoint> contacts;
+
+ auto targetTransform = m_entities->get<math::Transform>(target);
+ auto targetBody = m_entities->get<RigidBody>(target);
+
+ for ( const auto& entity : colliders ) {
+ // cannot collide with itself
+ if ( entity == target) {
+ continue;
+ }
+
+ auto transform = m_entities->get<math::Transform>(entity);
+ auto body = m_entities->get<RigidBody>(entity);
+
+ // check there is an overlap
+ ContactPoint contact{};
+ if ( overlaps(target, targetTransform, targetBody, entity, transform, body, contact) ) {
+ contacts.push_back(contact);
+ }
+
+ }
+
+ return contacts;
+ }
+
+ entity::EntityID InternalPhysicsEngine::raycast(math::vec3, math::vec3) {
+ entity::EntityID result;
+ return result;
+ }
+
+ std::vector<entity::EntityID> InternalPhysicsEngine::raycastAll(math::vec3, math::vec3) {
+ return std::vector<entity::EntityID>();
+ }
+
+ std::vector<entity::EntityID> InternalPhysicsEngine::sweep(PhyShape &shape,
+ math::Transform &from,
+ math::Transform &to) {
+ return std::vector<entity::EntityID>();
+ }
+
+ InternalPhysicsEngine::InternalPhysicsEngine(entity::EntityManager *entities) : m_entities(entities) {
+
+ }
+
+}
\ No newline at end of file
diff --git a/demo/CMakeLists.txt b/demo/CMakeLists.txt
index 665ed51474f54a11c3ad1aa4fa49d6c028001e30..1530839ad070f63b92a6a63cf6120586ac3ffc57 100644
--- a/demo/CMakeLists.txt
+++ b/demo/CMakeLists.txt
@@ -23,7 +23,7 @@ target_include_directories(demo
${CMAKE_CURRENT_SOURCE_DIR}/include
)
-target_link_libraries( demo fggl )
+target_link_libraries( demo fggl fggl-phys )
#target_link_libraries(demo fggl fgglbt)
if ( FGGL_EXT_LUA )
target_link_libraries( demo fggl-lua )
diff --git a/demo/demo/grid.cpp b/demo/demo/grid.cpp
index 3af24697b7dbcb6bdb4232d38fe9a41dc6a85cdd..51e7109588700844707e57a573573ca72e5f5051 100644
--- a/demo/demo/grid.cpp
+++ b/demo/demo/grid.cpp
@@ -109,7 +109,7 @@ namespace demo {
std::function<void(void)> callback;
};
- GridScene::GridScene(fggl::App &app) : GameBase(app), m_tiles(), m_animator(15.0F), m_grid(nullptr), m_canvas() {
+ GridScene::GridScene(fggl::App &app) : GameBase(app), m_tiles(), m_grid(nullptr), m_canvas(), m_animator(15.0F) {
m_animator.add([this](){this->tickPlayer();});
auto btnGrid = std::make_unique<fggl::gui::GridBox>(0, 2);
diff --git a/demo/demo/main.cpp b/demo/demo/main.cpp
index 7960f63b65c42994c1bcc64d538468e03351e352..d06c75fe95faaee9cba94d00415df0f1298a962c 100644
--- a/demo/demo/main.cpp
+++ b/demo/demo/main.cpp
@@ -24,7 +24,7 @@
#if __has_include("fggl/phys/bullet/bullet.hpp")
#include "fggl/phys/bullet/bullet.hpp"
#else
- #include "fggl/phys/null.hpp"
+ #include <phys/module.hpp>
#endif
#include "fggl/fggl.hpp"
@@ -100,7 +100,7 @@ int main(int argc, const char* argv[]) {
#ifdef FGGL_MODULE_BULLET
moduleManager.use<fggl::phys::Bullet3>();
#else
- moduleManager.use<fggl::phys::NullPhysics>();
+ moduleManager.use<fggl::phys::InternalPhysics>();
#endif
moduleManager.resolve();
diff --git a/include/fggl/entity/gridworld/zone.hpp b/include/fggl/entity/gridworld/zone.hpp
index 28d0c05d10035b75ac858bc8456785d6c5ee0fd3..66953b04e48b98da5f93b292028f331e7d1238a2 100644
--- a/include/fggl/entity/gridworld/zone.hpp
+++ b/include/fggl/entity/gridworld/zone.hpp
@@ -104,8 +104,8 @@ namespace fggl::entity::grid {
[[nodiscard]]
inline bool inBounds(GridPos pos) const {
- return 0 <= pos.x && pos.x <= width
- && 0 <= pos.y && pos.y <= height;
+ return 0U <= pos.x && pos.x <= width
+ && 0U <= pos.y && pos.y <= height;
}
void clear() {
diff --git a/include/fggl/grid/hexagon.hpp b/include/fggl/grid/hexagon.hpp
index 7277d65d23eb70c293d9b1b4b0e7bdfb716f92af..3573a10edb460bc2cd062fda4f8df5aa2b0309fc 100644
--- a/include/fggl/grid/hexagon.hpp
+++ b/include/fggl/grid/hexagon.hpp
@@ -25,6 +25,7 @@
#include <compare>
#include <fggl/math/fmath.hpp>
+#include <fggl/math/easing.hpp>
/**
* Hexagonal Grid Implementation.
diff --git a/include/fggl/math/easing.hpp b/include/fggl/math/easing.hpp
index f31eb909d01b288add03a359da9949e809651ab4..2c07c2e9c7b4d7f24c5ba46fc619203499014cd5 100644
--- a/include/fggl/math/easing.hpp
+++ b/include/fggl/math/easing.hpp
@@ -24,8 +24,12 @@
namespace fggl::math {
- constexpr inline float lerp(float a, float b, float w) {
- return (b - a) * w + a;
+ constexpr float lerpImprecise(float start, float end, float t) {
+ return start + t * (end - start);
+ }
+
+ constexpr float lerp(float start, float end, float t) {
+ return (1 - t) * start + t * end;
}
constexpr inline float scale(float in, float inMin, float inMax, float outMin, float outMax) {
diff --git a/include/fggl/math/fmath.hpp b/include/fggl/math/fmath.hpp
index d7088379de46666604e1df2381670cc111ce90c3..c2f81de9f617a1bd36de1bffa4e98f91931442ae 100644
--- a/include/fggl/math/fmath.hpp
+++ b/include/fggl/math/fmath.hpp
@@ -29,6 +29,11 @@ namespace fggl::math {
* A 3D floating-point vector.
*/
using vec3f = glm::vec3;
+ constexpr static const math::vec3f VEC3_ZERO{0.0F, 0.0F, 0.0F};
+
+ constexpr vec3f add_scaled(vec3f vec, vec3f value, float scaled) {
+ return vec + (value * scaled);
+ }
/**
* A 2D floating-point vector.
@@ -36,7 +41,6 @@ namespace fggl::math {
using vec2f = glm::vec2;
constexpr static const math::vec2f VEC2_ZERO{0.0F, 0.0F};
- constexpr static const math::vec3f VEC3_ZERO{0.0F, 0.0F, 0.0F};
constexpr static const math::vec3f VEC3_ONES{1.0F, 1.0F, 1.0F};
/**
@@ -84,14 +88,6 @@ namespace fggl::math {
return valueOrMin > max ? max : valueOrMin;
}
- constexpr float lerpImprecise(float start, float end, float t) {
- return start + t * (end - start);
- }
-
- constexpr float lerp(float start, float end, float t) {
- return (1 - t) * start + t * end;
- }
-
template<typename T>
[[nodiscard]]
constexpr T smooth_add(T first, T second, const float weight) {