Remove unused arguments from isAreaOccupiedByOtherActor

apps/openmw/mwbase/world.hpp

@@ -574,8 +574,8 @@ namespace MWBase
         virtual bool hasCollisionWithDoor(
             const MWWorld::ConstPtr& door, const osg::Vec3f& position, const osg::Vec3f& destination) const = 0;
 
-        virtual bool isAreaOccupiedByOtherActor(const osg::Vec3f& position, const float radius,
+        virtual bool isAreaOccupiedByOtherActor(
-            std::span<const MWWorld::ConstPtr> ignore, std::vector<MWWorld::Ptr>* occupyingActors = nullptr) const = 0;
+            const osg::Vec3f& position, float radius, std::span<const MWWorld::ConstPtr> ignore) const = 0;
 
         virtual void reportStats(unsigned int frameNumber, osg::Stats& stats) const = 0;
 

apps/openmw/mwmechanics/obstacle.cpp

@@ -106,19 +106,13 @@ namespace MWMechanics
         return visitor.mResult;
     }
 
-    bool isAreaOccupiedByOtherActor(const MWWorld::ConstPtr& actor, const osg::Vec3f& destination, bool ignorePlayer,
+    bool isAreaOccupiedByOtherActor(const MWWorld::ConstPtr& actor, const osg::Vec3f& destination)
-        std::vector<MWWorld::Ptr>* occupyingActors)
     {
         const auto world = MWBase::Environment::get().getWorld();
         const osg::Vec3f halfExtents = world->getPathfindingAgentBounds(actor).mHalfExtents;
         const auto maxHalfExtent = std::max(halfExtents.x(), std::max(halfExtents.y(), halfExtents.z()));
-        if (ignorePlayer)
-        {
-            const std::array ignore{ actor, world->getPlayerConstPtr() };
-            return world->isAreaOccupiedByOtherActor(destination, 2 * maxHalfExtent, ignore, occupyingActors);
-        }
         const std::array ignore{ actor };
-        return world->isAreaOccupiedByOtherActor(destination, 2 * maxHalfExtent, ignore, occupyingActors);
+        return world->isAreaOccupiedByOtherActor(destination, 2 * maxHalfExtent, ignore);
     }
 
     ObstacleCheck::ObstacleCheck()

apps/openmw/mwmechanics/obstacle.hpp

@@ -5,8 +5,6 @@
 
 #include <osg/Vec3f>
 
-#include <vector>
-
 namespace MWWorld
 {
     class Ptr;
@@ -24,8 +22,7 @@ namespace MWMechanics
     /** \return Pointer to the door, or empty pointer if none exists **/
     const MWWorld::Ptr getNearbyDoor(const MWWorld::Ptr& actor, float minDist);
 
-    bool isAreaOccupiedByOtherActor(const MWWorld::ConstPtr& actor, const osg::Vec3f& destination,
+    bool isAreaOccupiedByOtherActor(const MWWorld::ConstPtr& actor, const osg::Vec3f& destination);
-        bool ignorePlayer = false, std::vector<MWWorld::Ptr>* occupyingActors = nullptr);
 
     class ObstacleCheck
     {

apps/openmw/mwphysics/hasspherecollisioncallback.hpp

@@ -10,7 +10,7 @@
 namespace MWPhysics
 {
     // https://developer.mozilla.org/en-US/docs/Games/Techniques/3D_collision_detection
-    bool testAabbAgainstSphere(
+    inline bool testAabbAgainstSphere(
         const btVector3& aabbMin, const btVector3& aabbMax, const btVector3& position, const btScalar radius)
     {
         const btVector3 nearest(std::clamp(position.x(), aabbMin.x(), aabbMax.x()),
@@ -18,35 +18,29 @@ namespace MWPhysics
         return nearest.distance(position) < radius;
     }
 
-    template <class Ignore, class OnCollision>
+    template <class Ignore>
     class HasSphereCollisionCallback final : public btBroadphaseAabbCallback
     {
     public:
-        HasSphereCollisionCallback(const btVector3& position, const btScalar radius, const int mask, const int group,
+        explicit HasSphereCollisionCallback(
-            const Ignore& ignore, OnCollision* onCollision)
+            const btVector3& position, const btScalar radius, const int mask, const int group, const Ignore& ignore)
             : mPosition(position)
             , mRadius(radius)
             , mIgnore(ignore)
             , mCollisionFilterMask(mask)
             , mCollisionFilterGroup(group)
-            , mOnCollision(onCollision)
         {
         }
 
         bool process(const btBroadphaseProxy* proxy) override
         {
-            if (mResult && mOnCollision == nullptr)
+            if (mResult)
                 return false;
             const auto collisionObject = static_cast<btCollisionObject*>(proxy->m_clientObject);
             if (mIgnore(collisionObject) || !needsCollision(*proxy)
                 || !testAabbAgainstSphere(proxy->m_aabbMin, proxy->m_aabbMax, mPosition, mRadius))
                 return true;
             mResult = true;
-            if (mOnCollision != nullptr)
-            {
-                (*mOnCollision)(collisionObject);
-                return true;
-            }
             return !mResult;
         }
 
@@ -58,7 +52,6 @@ namespace MWPhysics
         Ignore mIgnore;
         int mCollisionFilterMask;
         int mCollisionFilterGroup;
-        OnCollision* mOnCollision;
         bool mResult = false;
 
         bool needsCollision(const btBroadphaseProxy& proxy) const

apps/openmw/mwphysics/physicssystem.cpp

@@ -849,8 +849,8 @@ namespace MWPhysics
             mWaterCollisionObject.get(), CollisionType_Water, CollisionType_Actor | CollisionType_Projectile);
     }
 
-    bool PhysicsSystem::isAreaOccupiedByOtherActor(const osg::Vec3f& position, const float radius,
+    bool PhysicsSystem::isAreaOccupiedByOtherActor(
-        std::span<const MWWorld::ConstPtr> ignore, std::vector<MWWorld::Ptr>* occupyingActors) const
+        const osg::Vec3f& position, const float radius, std::span<const MWWorld::ConstPtr> ignore) const
     {
         std::vector<const btCollisionObject*> ignoredObjects;
         ignoredObjects.reserve(ignore.size());
@@ -867,18 +867,7 @@ namespace MWPhysics
         const auto aabbMax = bulletPosition + btVector3(radius, radius, radius);
         const int mask = MWPhysics::CollisionType_Actor;
         const int group = MWPhysics::CollisionType_AnyPhysical;
-        if (occupyingActors == nullptr)
+        HasSphereCollisionCallback callback(bulletPosition, radius, mask, group, ignoreFilter);
-        {
-            HasSphereCollisionCallback callback(bulletPosition, radius, mask, group, ignoreFilter,
-                static_cast<void (*)(const btCollisionObject*)>(nullptr));
-            mTaskScheduler->aabbTest(aabbMin, aabbMax, callback);
-            return callback.getResult();
-        }
-        const auto onCollision = [&](const btCollisionObject* object) {
-            if (PtrHolder* holder = static_cast<PtrHolder*>(object->getUserPointer()))
-                occupyingActors->push_back(holder->getPtr());
-        };
-        HasSphereCollisionCallback callback(bulletPosition, radius, mask, group, ignoreFilter, &onCollision);
         mTaskScheduler->aabbTest(aabbMin, aabbMax, callback);
         return callback.getResult();
     }

apps/openmw/mwphysics/physicssystem.hpp

@@ -281,8 +281,8 @@ namespace MWPhysics
             std::for_each(mAnimatedObjects.begin(), mAnimatedObjects.end(), function);
         }
 
-        bool isAreaOccupiedByOtherActor(const osg::Vec3f& position, const float radius,
+        bool isAreaOccupiedByOtherActor(
-            std::span<const MWWorld::ConstPtr> ignore, std::vector<MWWorld::Ptr>* occupyingActors) const;
+            const osg::Vec3f& position, float radius, std::span<const MWWorld::ConstPtr> ignore) const;
 
         void reportStats(unsigned int frameNumber, osg::Stats& stats) const;
         void reportCollision(const btVector3& position, const btVector3& normal);

apps/openmw/mwworld/worldimp.cpp

@@ -3832,10 +3832,10 @@ namespace MWWorld
         return btRayAabb(localFrom, localTo, aabbMin, aabbMax, hitDistance, hitNormal);
     }
 
-    bool World::isAreaOccupiedByOtherActor(const osg::Vec3f& position, const float radius,
+    bool World::isAreaOccupiedByOtherActor(
-        std::span<const MWWorld::ConstPtr> ignore, std::vector<MWWorld::Ptr>* occupyingActors) const
+        const osg::Vec3f& position, const float radius, std::span<const MWWorld::ConstPtr> ignore) const
     {
-        return mPhysics->isAreaOccupiedByOtherActor(position, radius, ignore, occupyingActors);
+        return mPhysics->isAreaOccupiedByOtherActor(position, radius, ignore);
     }
 
     void World::reportStats(unsigned int frameNumber, osg::Stats& stats) const

apps/openmw/mwworld/worldimp.hpp

@@ -656,8 +656,8 @@ namespace MWWorld
         bool hasCollisionWithDoor(
             const MWWorld::ConstPtr& door, const osg::Vec3f& position, const osg::Vec3f& destination) const override;
 
-        bool isAreaOccupiedByOtherActor(const osg::Vec3f& position, const float radius,
+        bool isAreaOccupiedByOtherActor(
-            std::span<const MWWorld::ConstPtr> ignore, std::vector<MWWorld::Ptr>* occupyingActors) const override;
+            const osg::Vec3f& position, float radius, std::span<const MWWorld::ConstPtr> ignore) const override;
 
         void reportStats(unsigned int frameNumber, osg::Stats& stats) const override;