mirror/openmw
1
0
Fork 0
mirror of https://github.com/OpenMW/openmw.git synced 2025-01-16 15:29:55 +00:00
Code Issues Releases Wiki Activity

Ignore player when checking whether AiTravel destination is occupied by other actor

Browse source
This commit is contained in:
elsid 2022-04-11 19:30:54 +02:00
parent fd6899e91d
commit 39da3bfef8
No known key found for this signature in database
GPG key ID: B845CB9FEE18AB40
10 changed files with 79 additions and 21 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
apps/openmw/mwbase/world.hpp
View file

@ -10,6 +10,7 @@
#include <components/esm3/cellid.hpp>
#include <components/misc/rng.hpp>
#include <components/misc/span.hpp>
#include <osg/Timer>
@ -658,7 +659,7 @@ 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,
const MWWorld::ConstPtr& ignore, std::vector<MWWorld::Ptr>* occupyingActors = nullptr) const = 0;
const Misc::Span<const MWWorld::ConstPtr>& ignore, std::vector<MWWorld::Ptr>* occupyingActors = nullptr) const = 0;
virtual void reportStats(unsigned int frameNumber, osg::Stats& stats) const = 0;

2
apps/openmw/mwmechanics/aitravel.cpp
View file

@ -83,7 +83,7 @@ namespace MWMechanics
if (mDestinationCheck.update(duration) == Misc::TimerStatus::Elapsed)
{
std::vector<MWWorld::Ptr> occupyingActors;
if (isAreaOccupiedByOtherActor(actor, targetPos, &occupyingActors))
if (isAreaOccupiedByOtherActor(actor, targetPos, true, &occupyingActors))
{
const float actorRadius = getActorRadius(actor);
const float distanceToTarget = distance(actorPos, targetPos);

12
apps/openmw/mwmechanics/obstacle.cpp
View file

@ -1,5 +1,7 @@
#include "obstacle.hpp"
#include <array>
#include <components/sceneutil/positionattitudetransform.hpp>
#include "../mwworld/class.hpp"
@ -74,13 +76,19 @@ namespace MWMechanics
return MWWorld::Ptr(); // none found
}
bool isAreaOccupiedByOtherActor(const MWWorld::ConstPtr& actor, const osg::Vec3f& destination,
bool isAreaOccupiedByOtherActor(const MWWorld::ConstPtr& actor, const osg::Vec3f& destination, bool ignorePlayer,
std::vector<MWWorld::Ptr>* occupyingActors)
{
const auto world = MWBase::Environment::get().getWorld();
const osg::Vec3f halfExtents = world->getPathfindingHalfExtents(actor);
const auto maxHalfExtent = std::max(halfExtents.x(), std::max(halfExtents.y(), halfExtents.z()));
return world->isAreaOccupiedByOtherActor(destination, 2 * maxHalfExtent, actor, occupyingActors);
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);
}
ObstacleCheck::ObstacleCheck()

2
apps/openmw/mwmechanics/obstacle.hpp
View file

@ -24,7 +24,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

12
apps/openmw/mwphysics/hasspherecollisioncallback.hpp
View file

@ -22,15 +22,15 @@ namespace MWPhysics
return nearest.distance(position) < radius;
}
template <class OnCollision>
template <class Ignore, class OnCollision>
class HasSphereCollisionCallback final : public btBroadphaseAabbCallback
{
public:
HasSphereCollisionCallback(const btVector3& position, const btScalar radius, btCollisionObject* object,
const int mask, const int group, OnCollision* onCollision)
HasSphereCollisionCallback(const btVector3& position, const btScalar radius, const int mask, const int group,
const Ignore& ignore, OnCollision* onCollision)
: mPosition(position),
mRadius(radius),
mCollisionObject(object),
mIgnore(ignore),
mCollisionFilterMask(mask),
mCollisionFilterGroup(group),
mOnCollision(onCollision)
@ -42,7 +42,7 @@ namespace MWPhysics
if (mResult && mOnCollision == nullptr)
return false;
const auto collisionObject = static_cast<btCollisionObject*>(proxy->m_clientObject);
if (collisionObject == mCollisionObject
if (mIgnore(collisionObject)
|| !needsCollision(*proxy)
|| !testAabbAgainstSphere(proxy->m_aabbMin, proxy->m_aabbMax, mPosition, mRadius))
return true;
@ -63,7 +63,7 @@ namespace MWPhysics
private:
btVector3 mPosition;
btScalar mRadius;
btCollisionObject* mCollisionObject;
Ignore mIgnore;
int mCollisionFilterMask;
int mCollisionFilterGroup;
OnCollision* mOnCollision;

25
apps/openmw/mwphysics/physicssystem.cpp
View file

@ -2,7 +2,11 @@
#include <LinearMath/btIDebugDraw.h>
#include <LinearMath/btVector3.h>
#include <memory>
#include <algorithm>
#include <vector>
#include <osg/Group>
#include <osg/Stats>
#include <osg/Timer>
@ -884,12 +888,19 @@ namespace MWPhysics
}
bool PhysicsSystem::isAreaOccupiedByOtherActor(const osg::Vec3f& position, const float radius,
const MWWorld::ConstPtr& ignore, std::vector<MWWorld::Ptr>* occupyingActors) const
const Misc::Span<const MWWorld::ConstPtr>& ignore, std::vector<MWWorld::Ptr>* occupyingActors) const
{
btCollisionObject* object = nullptr;
const auto it = mActors.find(ignore.mRef);
if (it != mActors.end())
object = it->second->getCollisionObject();
std::vector<const btCollisionObject*> ignoredObjects;
ignoredObjects.reserve(ignore.size());
for (const auto& v : ignore)
if (const auto it = mActors.find(v.mRef); it != mActors.end())
ignoredObjects.push_back(it->second->getCollisionObject());
std::sort(ignoredObjects.begin(), ignoredObjects.end());
ignoredObjects.erase(std::unique(ignoredObjects.begin(), ignoredObjects.end()), ignoredObjects.end());
const auto ignoreFilter = [&] (const btCollisionObject* v)
{
return std::binary_search(ignoredObjects.begin(), ignoredObjects.end(), v);
};
const auto bulletPosition = Misc::Convert::toBullet(position);
const auto aabbMin = bulletPosition - btVector3(radius, radius, radius);
const auto aabbMax = bulletPosition + btVector3(radius, radius, radius);
@ -897,7 +908,7 @@ namespace MWPhysics
const int group = 0xff;
if (occupyingActors == nullptr)
{
HasSphereCollisionCallback callback(bulletPosition, radius, object, mask, group,
HasSphereCollisionCallback callback(bulletPosition, radius, mask, group, ignoreFilter,
static_cast<void (*)(const btCollisionObject*)>(nullptr));
mTaskScheduler->aabbTest(aabbMin, aabbMax, callback);
return callback.getResult();
@ -907,7 +918,7 @@ namespace MWPhysics
if (PtrHolder* holder = static_cast<PtrHolder*>(object->getUserPointer()))
occupyingActors->push_back(holder->getPtr());
};
HasSphereCollisionCallback callback(bulletPosition, radius, object, mask, group, &onCollision);
HasSphereCollisionCallback callback(bulletPosition, radius, mask, group, ignoreFilter, &onCollision);
mTaskScheduler->aabbTest(aabbMin, aabbMax, callback);
return callback.getResult();
}

4
apps/openmw/mwphysics/physicssystem.hpp
View file

@ -16,6 +16,8 @@
#include <osg/ref_ptr>
#include <osg/Timer>
#include <components/misc/span.hpp>
#include "../mwworld/ptr.hpp"
#include "collisiontype.hpp"
@ -277,7 +279,7 @@ namespace MWPhysics
}
bool isAreaOccupiedByOtherActor(const osg::Vec3f& position, const float radius,
const MWWorld::ConstPtr& ignore, std::vector<MWWorld::Ptr>* occupyingActors) const;
const Misc::Span<const MWWorld::ConstPtr>& ignore, std::vector<MWWorld::Ptr>* occupyingActors) const;
void reportStats(unsigned int frameNumber, osg::Stats& stats) const;
void reportCollision(const btVector3& position, const btVector3& normal);

2
apps/openmw/mwworld/worldimp.cpp
View file

@ -3997,7 +3997,7 @@ namespace MWWorld
}
bool World::isAreaOccupiedByOtherActor(const osg::Vec3f& position, const float radius,
const MWWorld::ConstPtr& ignore, std::vector<MWWorld::Ptr>* occupyingActors) const
const Misc::Span<const MWWorld::ConstPtr>& ignore, std::vector<MWWorld::Ptr>* occupyingActors) const
{
return mPhysics->isAreaOccupiedByOtherActor(position, radius, ignore, occupyingActors);
}

2
apps/openmw/mwworld/worldimp.hpp
View file

@ -736,7 +736,7 @@ 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,
const MWWorld::ConstPtr& ignore, std::vector<MWWorld::Ptr>* occupyingActors) const override;
const Misc::Span<const MWWorld::ConstPtr>& ignore, std::vector<MWWorld::Ptr>* occupyingActors) const override;
void reportStats(unsigned int frameNumber, osg::Stats& stats) const override;

36
components/misc/span.hpp Normal file
View file

@ -0,0 +1,36 @@
#ifndef OPENMW_COMPONENTS_MISC_SPAN_H
#define OPENMW_COMPONENTS_MISC_SPAN_H
#include <cstddef>
namespace Misc
{
template <class T>
class Span
{
public:
constexpr Span() = default;
constexpr Span(T* pointer, std::size_t size)
: mPointer(pointer)
, mSize(size)
{}
template <class Range>
constexpr Span(Range& range)
: Span(range.data(), range.size())
{}
constexpr T* begin() const { return mPointer; }
constexpr T* end() const { return mPointer + mSize; }
constexpr std::size_t size() const { return mSize; }
private:
T* mPointer = nullptr;
std::size_t mSize = 0;
};
}
#endif