added more tests

include/omath/collision/physx_rigid_body.hpp

@@ -0,0 +1,137 @@
+//
+// Created by orange-cpp
+//
+#pragma once
+
+#ifdef OMATH_ENABLE_PHYSX
+
+#include "collider_interface.hpp"
+#include "physx_world.hpp"
+#include <PxPhysicsAPI.h>
+#include <extensions/PxRigidBodyExt.h>
+#include <cmath>
+
+namespace omath::collision
+{
+    /// Dynamic rigid body backed by a PhysX PxRigidDynamic actor.
+    /// Implements ColliderInterface so it can participate in both omath GJK
+    /// and PhysX simulation-based collision resolution.
+    ///
+    /// Ownership: the actor is added to the world's scene on construction
+    /// and removed + released on destruction.
+    class PhysXRigidBody final : public ColliderInterface<Vector3<float>>
+    {
+    public:
+        /// @param world     PhysXWorld that owns the scene.
+        /// @param geometry  Shape geometry (PxBoxGeometry, PxSphereGeometry, …).
+        /// @param origin    Initial world-space position.
+        /// @param density   Mass density used to compute mass and inertia.
+        PhysXRigidBody(PhysXWorld& world, const physx::PxGeometry& geometry,
+                       const VectorType& origin = {}, float density = 1.f)
+            : m_world(world)
+            , m_geometry(geometry)
+        {
+            const physx::PxTransform pose(physx::PxVec3(origin.x, origin.y, origin.z));
+            m_actor = world.get_physics().createRigidDynamic(pose);
+
+            physx::PxShape* shape = world.get_physics().createShape(
+                geometry, world.get_default_material(), true);
+            m_actor->attachShape(*shape);
+            shape->release();
+
+            physx::PxRigidBodyExt::updateMassAndInertia(*m_actor, density);
+            world.get_scene().addActor(*m_actor);
+        }
+
+        ~PhysXRigidBody() override
+        {
+            m_world.get_scene().removeActor(*m_actor);
+            m_actor->release();
+        }
+
+        PhysXRigidBody(const PhysXRigidBody&)            = delete;
+        PhysXRigidBody& operator=(const PhysXRigidBody&) = delete;
+
+        // ── ColliderInterface ────────────────────────────────────────────────
+
+        /// Support function — delegates to the stored geometry type so the body
+        /// can be used with omath GJK alongside the non-simulated colliders.
+        [[nodiscard]]
+        VectorType find_abs_furthest_vertex_position(const VectorType& direction) const override
+        {
+            const VectorType o = get_origin();
+            switch (m_geometry.getType())
+            {
+                case physx::PxGeometryType::eBOX:
+                {
+                    const auto& he = m_geometry.box().halfExtents;
+                    return {
+                        o.x + (direction.x >= 0.f ? he.x : -he.x),
+                        o.y + (direction.y >= 0.f ? he.y : -he.y),
+                        o.z + (direction.z >= 0.f ? he.z : -he.z),
+                    };
+                }
+                case physx::PxGeometryType::eSPHERE:
+                {
+                    const float r   = m_geometry.sphere().radius;
+                    const float len = std::sqrt(direction.x * direction.x +
+                                               direction.y * direction.y +
+                                               direction.z * direction.z);
+                    if (len == 0.f)
+                        return o;
+                    const float inv = r / len;
+                    return { o.x + direction.x * inv,
+                             o.y + direction.y * inv,
+                             o.z + direction.z * inv };
+                }
+                default:
+                    return o; // unsupported geometry — return centre
+            }
+        }
+
+        [[nodiscard]]
+        const VectorType& get_origin() const override
+        {
+            const auto& p = m_actor->getGlobalPose().p;
+            m_cached_origin = { p.x, p.y, p.z };
+            return m_cached_origin;
+        }
+
+        void set_origin(const VectorType& new_origin) override
+        {
+            physx::PxTransform pose = m_actor->getGlobalPose();
+            pose.p = physx::PxVec3(new_origin.x, new_origin.y, new_origin.z);
+            m_actor->setGlobalPose(pose);
+        }
+
+        // ── PhysX-specific API ───────────────────────────────────────────────
+
+        [[nodiscard]] physx::PxRigidDynamic& get_actor() { return *m_actor; }
+        [[nodiscard]] const physx::PxRigidDynamic& get_actor() const { return *m_actor; }
+
+        void set_linear_velocity(const VectorType& v)
+        {
+            m_actor->setLinearVelocity(physx::PxVec3(v.x, v.y, v.z));
+        }
+
+        [[nodiscard]]
+        VectorType get_linear_velocity() const
+        {
+            const auto& v = m_actor->getLinearVelocity();
+            return { v.x, v.y, v.z };
+        }
+
+        void set_kinematic(bool enabled)
+        {
+            m_actor->setRigidBodyFlag(physx::PxRigidBodyFlag::eKINEMATIC, enabled);
+        }
+
+    private:
+        PhysXWorld&                    m_world;
+        physx::PxGeometryHolder        m_geometry;
+        physx::PxRigidDynamic*         m_actor{nullptr};
+        mutable VectorType             m_cached_origin{};
+    };
+} // namespace omath::collision
+
+#endif // OMATH_ENABLE_PHYSX

include/omath/collision/physx_world.hpp

@@ -0,0 +1,82 @@
+//
+// Created by orange-cpp
+//
+#pragma once
+
+#ifdef OMATH_ENABLE_PHYSX
+
+#include <PxPhysicsAPI.h>
+
+namespace omath::collision
+{
+    /// RAII owner of a PhysX Foundation + Physics + Scene.
+    /// One world per simulation context; not copyable or movable.
+    class PhysXWorld final
+    {
+    public:
+        explicit PhysXWorld(physx::PxVec3 gravity = {0.f, -9.81f, 0.f},
+                            physx::PxU32 cpu_threads = 2)
+        {
+            m_foundation = PxCreateFoundation(PX_PHYSICS_VERSION, m_allocator, m_error_callback);
+
+            m_physics = PxCreatePhysics(PX_PHYSICS_VERSION, *m_foundation,
+                                        physx::PxTolerancesScale{});
+
+            physx::PxSceneDesc desc(m_physics->getTolerancesScale());
+            desc.gravity       = gravity;
+            desc.cpuDispatcher = physx::PxDefaultCpuDispatcherCreate(cpu_threads);
+            m_dispatcher       = static_cast<physx::PxDefaultCpuDispatcher*>(desc.cpuDispatcher);
+            desc.filterShader  = physx::PxDefaultSimulationFilterShader;
+
+            m_scene = m_physics->createScene(desc);
+
+            // Default material: static friction 0.5, dynamic friction 0.5, restitution 0.
+            m_default_material = m_physics->createMaterial(0.5f, 0.5f, 0.f);
+        }
+
+        ~PhysXWorld()
+        {
+            m_scene->release();
+            m_dispatcher->release();
+            m_default_material->release();
+            m_physics->release();
+            m_foundation->release();
+        }
+
+        PhysXWorld(const PhysXWorld&)            = delete;
+        PhysXWorld& operator=(const PhysXWorld&) = delete;
+
+        /// Advance the simulation by @p dt seconds and block until results are ready.
+        void step(float dt)
+        {
+            m_scene->simulate(dt);
+            m_scene->fetchResults(true);
+        }
+
+        [[nodiscard]] physx::PxPhysics&  get_physics()          { return *m_physics;          }
+        [[nodiscard]] physx::PxScene&    get_scene()             { return *m_scene;             }
+        [[nodiscard]] physx::PxMaterial& get_default_material()  { return *m_default_material;  }
+
+        /// Add an infinite static ground plane at y = @p y_level facing +Y.
+        physx::PxRigidStatic* add_ground_plane(float y_level = 0.f)
+        {
+            physx::PxRigidStatic* plane = PxCreatePlane(
+                *m_physics,
+                physx::PxPlane(0.f, 1.f, 0.f, -y_level),
+                *m_default_material);
+            m_scene->addActor(*plane);
+            return plane;
+        }
+
+    private:
+        physx::PxDefaultAllocator      m_allocator{};
+        physx::PxDefaultErrorCallback  m_error_callback{};
+        physx::PxFoundation*           m_foundation{nullptr};
+        physx::PxPhysics*              m_physics{nullptr};
+        physx::PxDefaultCpuDispatcher* m_dispatcher{nullptr};
+        physx::PxScene*                m_scene{nullptr};
+        physx::PxMaterial*             m_default_material{nullptr};
+    };
+} // namespace omath::collision
+
+#endif // OMATH_ENABLE_PHYSX