mirror/OpenMW
1
0
Fork 0
mirror of https://gitlab.com/OpenMW/openmw.git synced 2025-02-04 21:40:03 +00:00
Code Issues Projects Releases Wiki Activity
OpenMW/apps/openmw/mwphysics/projectile.cpp

160 lines
4.4 KiB
C++
Raw Normal View History

Modify projectile collision to work with async physics
2020-10-23 20:27:07 +02:00
#include <memory>
Generate physics collisions for projectiles (bug #3372) Remove redundant now mHit field
2019-02-13 11:30:16 +04:00
#include <BulletCollision/CollisionShapes/btSphereShape.h>
#include <BulletCollision/CollisionDispatch/btCollisionWorld.h>
#include <components/misc/convert.hpp>
#include "../mwworld/class.hpp"
Use btCollisionObject* instead of MWWorld::Ptr inside of Projectile collision handling and castRay() to avoid calling getPtr(). It is a step forward removing the mutex inside of PtrHolder. Do the same for DeepestNotMeContactTestResultCallback. It is used only for not-ranged combat for now, but do it anyway for parity with all other callback. This way, once the PtrHolder mutex is gone one will not have to worry about wether it is safe to use the callback in a specific context. To avoid use-after-free with projectile / projectile collision, defer deletion of projectile. Since instead of storing a copy of target Ptr we have a pointer to its collision object, we can't delete projectiles until after we finished iterating over the loops.
2021-08-05 10:55:19 +02:00
#include "actor.hpp"
Generate physics collisions for projectiles (bug #3372) Remove redundant now mHit field
2019-02-13 11:30:16 +04:00
#include "collisiontype.hpp"
Modify projectile collision to work with async physics
2020-10-23 20:27:07 +02:00
#include "mtphysics.hpp"
Use btCollisionObject* instead of MWWorld::Ptr inside of Projectile collision handling and castRay() to avoid calling getPtr(). It is a step forward removing the mutex inside of PtrHolder. Do the same for DeepestNotMeContactTestResultCallback. It is used only for not-ranged combat for now, but do it anyway for parity with all other callback. This way, once the PtrHolder mutex is gone one will not have to worry about wether it is safe to use the callback in a specific context. To avoid use-after-free with projectile / projectile collision, defer deletion of projectile. Since instead of storing a copy of target Ptr we have a pointer to its collision object, we can't delete projectiles until after we finished iterating over the loops.
2021-08-05 10:55:19 +02:00
#include "object.hpp"
Modify projectile collision to work with async physics
2020-10-23 20:27:07 +02:00
#include "projectile.hpp"
Generate physics collisions for projectiles (bug #3372) Remove redundant now mHit field
2019-02-13 11:30:16 +04:00
namespace MWPhysics
{
Use convexSweepTest for projectile movement to solve any imprecision issue with projectile collision detection. Simplify the mechanics: manage hits in one spot. Give magic projectiles a collision shape similar in size to their visible model. Rename the 2 convex result callback to clearly state their purpose.
2021-01-07 11:02:53 +01:00
Projectile::Projectile(const MWWorld::Ptr& caster, const osg::Vec3f& position, float radius, bool canCrossWaterSurface, PhysicsTaskScheduler* scheduler, PhysicsSystem* physicssystem)
: mCanCrossWaterSurface(canCrossWaterSurface)
, mCrossedWaterSurface(false)
, mActive(true)
Use btCollisionObject* instead of MWWorld::Ptr inside of Projectile collision handling and castRay() to avoid calling getPtr(). It is a step forward removing the mutex inside of PtrHolder. Do the same for DeepestNotMeContactTestResultCallback. It is used only for not-ranged combat for now, but do it anyway for parity with all other callback. This way, once the PtrHolder mutex is gone one will not have to worry about wether it is safe to use the callback in a specific context. To avoid use-after-free with projectile / projectile collision, defer deletion of projectile. Since instead of storing a copy of target Ptr we have a pointer to its collision object, we can't delete projectiles until after we finished iterating over the loops.
2021-08-05 10:55:19 +02:00
, mHitTarget(nullptr)
Use convexSweepTest for projectile movement to solve any imprecision issue with projectile collision detection. Simplify the mechanics: manage hits in one spot. Give magic projectiles a collision shape similar in size to their visible model. Rename the 2 convex result callback to clearly state their purpose.
2021-01-07 11:02:53 +01:00
, mWaterHitPosition(std::nullopt)
Projectile to projectile collision
2020-10-31 14:01:14 +01:00
, mPhysics(physicssystem)
Modify projectile collision to work with async physics
2020-10-23 20:27:07 +02:00
, mTaskScheduler(scheduler)
Generate physics collisions for projectiles (bug #3372) Remove redundant now mHit field
2019-02-13 11:30:16 +04:00
{
Use convexSweepTest for projectile movement to solve any imprecision issue with projectile collision detection. Simplify the mechanics: manage hits in one spot. Give magic projectiles a collision shape similar in size to their visible model. Rename the 2 convex result callback to clearly state their purpose.
2021-01-07 11:02:53 +01:00
mShape = std::make_unique<btSphereShape>(radius);
Generate physics collisions for projectiles (bug #3372) Remove redundant now mHit field
2019-02-13 11:30:16 +04:00
mConvexShape = static_cast<btConvexShape*>(mShape.get());
Make all physics object manage their own resources Use smart pointer for heightfields and their members. Move collision object addition inside of Object's ctor, as for Actors and HeightFields
2020-12-25 18:20:42 +01:00
mCollisionObject = std::make_unique<btCollisionObject>();
Generate physics collisions for projectiles (bug #3372) Remove redundant now mHit field
2019-02-13 11:30:16 +04:00
mCollisionObject->setCollisionFlags(btCollisionObject::CF_KINEMATIC_OBJECT);
mCollisionObject->setActivationState(DISABLE_DEACTIVATION);
mCollisionObject->setCollisionShape(mShape.get());
mCollisionObject->setUserPointer(this);
setPosition(position);
Use btCollisionObject* instead of MWWorld::Ptr inside of Projectile collision handling and castRay() to avoid calling getPtr(). It is a step forward removing the mutex inside of PtrHolder. Do the same for DeepestNotMeContactTestResultCallback. It is used only for not-ranged combat for now, but do it anyway for parity with all other callback. This way, once the PtrHolder mutex is gone one will not have to worry about wether it is safe to use the callback in a specific context. To avoid use-after-free with projectile / projectile collision, defer deletion of projectile. Since instead of storing a copy of target Ptr we have a pointer to its collision object, we can't delete projectiles until after we finished iterating over the loops.
2021-08-05 10:55:19 +02:00
setCaster(caster);
Generate physics collisions for projectiles (bug #3372) Remove redundant now mHit field
2019-02-13 11:30:16 +04:00
const int collisionMask = CollisionType_World | CollisionType_HeightMap |
Projectile to projectile collision
2020-10-31 14:01:14 +01:00
CollisionType_Actor | CollisionType_Door | CollisionType_Water | CollisionType_Projectile;
Modify projectile collision to work with async physics
2020-10-23 20:27:07 +02:00
mTaskScheduler->addCollisionObject(mCollisionObject.get(), CollisionType_Projectile, collisionMask);
commitPositionChange();
Generate physics collisions for projectiles (bug #3372) Remove redundant now mHit field
2019-02-13 11:30:16 +04:00
}
Projectile::~Projectile()
{
Make all physics object manage their own resources Use smart pointer for heightfields and their members. Move collision object addition inside of Object's ctor, as for Actors and HeightFields
2020-12-25 18:20:42 +01:00
if (!mActive)
mPhysics->reportCollision(mHitPosition, mHitNormal);
mTaskScheduler->removeCollisionObject(mCollisionObject.get());
Generate physics collisions for projectiles (bug #3372) Remove redundant now mHit field
2019-02-13 11:30:16 +04:00
}
Modify projectile collision to work with async physics
2020-10-23 20:27:07 +02:00
void Projectile::commitPositionChange()
Generate physics collisions for projectiles (bug #3372) Remove redundant now mHit field
2019-02-13 11:30:16 +04:00
{
Don't allow projectiles to stand still when they hit an ally. When an NPC fire a projectile, it should affect only its targeted actor. To this end, after a hit is detected the target is checked against the list of AI targets and reactivated if necessary. Problem occurs when the hit occurs as a result of a friendly actor going into the projectile (detected in ClosestNotMeConvexResultCallback): while the projectile is inside the friend's collision box, it is deactivated, just to be immediately reactivated. Effectively, the projectile does nothing until the actor moves out. Add a check inside the ClosestNotMeConvexResultCallback before declaring a hit. Since the necessary data is not safely accessible from the async thread, maintain a copy inside the Projectile class.
2020-12-14 22:23:01 +01:00
std::scoped_lock lock(mMutex);
Modify projectile collision to work with async physics
2020-10-23 20:27:07 +02:00
if (mTransformUpdatePending)
{
Do not store a btTransform into Projectile class: reduce its size by 112 bytes
2021-07-17 08:56:43 +02:00
auto& trans = mCollisionObject->getWorldTransform();
trans.setOrigin(Misc::Convert::toBullet(mPosition));
mCollisionObject->setWorldTransform(trans);
Modify projectile collision to work with async physics
2020-10-23 20:27:07 +02:00
mTransformUpdatePending = false;
}
Generate physics collisions for projectiles (bug #3372) Remove redundant now mHit field
2019-02-13 11:30:16 +04:00
}
void Projectile::setPosition(const osg::Vec3f &position)
{
Don't allow projectiles to stand still when they hit an ally. When an NPC fire a projectile, it should affect only its targeted actor. To this end, after a hit is detected the target is checked against the list of AI targets and reactivated if necessary. Problem occurs when the hit occurs as a result of a friendly actor going into the projectile (detected in ClosestNotMeConvexResultCallback): while the projectile is inside the friend's collision box, it is deactivated, just to be immediately reactivated. Effectively, the projectile does nothing until the actor moves out. Add a check inside the ClosestNotMeConvexResultCallback before declaring a hit. Since the necessary data is not safely accessible from the async thread, maintain a copy inside the Projectile class.
2020-12-14 22:23:01 +01:00
std::scoped_lock lock(mMutex);
Do not store a btTransform into Projectile class: reduce its size by 112 bytes
2021-07-17 08:56:43 +02:00
mPosition = position;
Modify projectile collision to work with async physics
2020-10-23 20:27:07 +02:00
mTransformUpdatePending = true;
Generate physics collisions for projectiles (bug #3372) Remove redundant now mHit field
2019-02-13 11:30:16 +04:00
}
Use convexSweepTest for projectile movement to solve any imprecision issue with projectile collision detection. Simplify the mechanics: manage hits in one spot. Give magic projectiles a collision shape similar in size to their visible model. Rename the 2 convex result callback to clearly state their purpose.
2021-01-07 11:02:53 +01:00
osg::Vec3f Projectile::getPosition() const
{
std::scoped_lock lock(mMutex);
Do not store a btTransform into Projectile class: reduce its size by 112 bytes
2021-07-17 08:56:43 +02:00
return mPosition;
Use convexSweepTest for projectile movement to solve any imprecision issue with projectile collision detection. Simplify the mechanics: manage hits in one spot. Give magic projectiles a collision shape similar in size to their visible model. Rename the 2 convex result callback to clearly state their purpose.
2021-01-07 11:02:53 +01:00
}
bool Projectile::canTraverseWater() const
{
return mCanCrossWaterSurface;
}
Use btCollisionObject* instead of MWWorld::Ptr inside of Projectile collision handling and castRay() to avoid calling getPtr(). It is a step forward removing the mutex inside of PtrHolder. Do the same for DeepestNotMeContactTestResultCallback. It is used only for not-ranged combat for now, but do it anyway for parity with all other callback. This way, once the PtrHolder mutex is gone one will not have to worry about wether it is safe to use the callback in a specific context. To avoid use-after-free with projectile / projectile collision, defer deletion of projectile. Since instead of storing a copy of target Ptr we have a pointer to its collision object, we can't delete projectiles until after we finished iterating over the loops.
2021-08-05 10:55:19 +02:00
void Projectile::hit(const btCollisionObject* target, btVector3 pos, btVector3 normal)
Generate physics collisions for projectiles (bug #3372) Remove redundant now mHit field
2019-02-13 11:30:16 +04:00
{
Use btCollisionObject* instead of MWWorld::Ptr inside of Projectile collision handling and castRay() to avoid calling getPtr(). It is a step forward removing the mutex inside of PtrHolder. Do the same for DeepestNotMeContactTestResultCallback. It is used only for not-ranged combat for now, but do it anyway for parity with all other callback. This way, once the PtrHolder mutex is gone one will not have to worry about wether it is safe to use the callback in a specific context. To avoid use-after-free with projectile / projectile collision, defer deletion of projectile. Since instead of storing a copy of target Ptr we have a pointer to its collision object, we can't delete projectiles until after we finished iterating over the loops.
2021-08-05 10:55:19 +02:00
bool active = true;
if (!mActive.compare_exchange_strong(active, false, std::memory_order_relaxed) || !active)
Modify projectile collision to work with async physics
2020-10-23 20:27:07 +02:00
return;
mHitTarget = target;
mHitPosition = pos;
Projectile to projectile collision
2020-10-31 14:01:14 +01:00
mHitNormal = normal;
Use btCollisionObject* instead of MWWorld::Ptr inside of Projectile collision handling and castRay() to avoid calling getPtr(). It is a step forward removing the mutex inside of PtrHolder. Do the same for DeepestNotMeContactTestResultCallback. It is used only for not-ranged combat for now, but do it anyway for parity with all other callback. This way, once the PtrHolder mutex is gone one will not have to worry about wether it is safe to use the callback in a specific context. To avoid use-after-free with projectile / projectile collision, defer deletion of projectile. Since instead of storing a copy of target Ptr we have a pointer to its collision object, we can't delete projectiles until after we finished iterating over the loops.
2021-08-05 10:55:19 +02:00
}
MWWorld::Ptr Projectile::getTarget() const
{
assert(!mActive);
auto* target = static_cast<PtrHolder*>(mHitTarget->getUserPointer());
return target ? target->getPtr() : MWWorld::Ptr();
Generate physics collisions for projectiles (bug #3372) Remove redundant now mHit field
2019-02-13 11:30:16 +04:00
}
Don't allow projectiles to stand still when they hit an ally. When an NPC fire a projectile, it should affect only its targeted actor. To this end, after a hit is detected the target is checked against the list of AI targets and reactivated if necessary. Problem occurs when the hit occurs as a result of a friendly actor going into the projectile (detected in ClosestNotMeConvexResultCallback): while the projectile is inside the friend's collision box, it is deactivated, just to be immediately reactivated. Effectively, the projectile does nothing until the actor moves out. Add a check inside the ClosestNotMeConvexResultCallback before declaring a hit. Since the necessary data is not safely accessible from the async thread, maintain a copy inside the Projectile class.
2020-12-14 22:23:01 +01:00
MWWorld::Ptr Projectile::getCaster() const
{
return mCaster;
}
Add a ton of const refs
2021-06-23 23:13:59 +02:00
void Projectile::setCaster(const MWWorld::Ptr& caster)
Don't allow projectiles to stand still when they hit an ally. When an NPC fire a projectile, it should affect only its targeted actor. To this end, after a hit is detected the target is checked against the list of AI targets and reactivated if necessary. Problem occurs when the hit occurs as a result of a friendly actor going into the projectile (detected in ClosestNotMeConvexResultCallback): while the projectile is inside the friend's collision box, it is deactivated, just to be immediately reactivated. Effectively, the projectile does nothing until the actor moves out. Add a check inside the ClosestNotMeConvexResultCallback before declaring a hit. Since the necessary data is not safely accessible from the async thread, maintain a copy inside the Projectile class.
2020-12-14 22:23:01 +01:00
{
mCaster = caster;
Use btCollisionObject* instead of MWWorld::Ptr inside of Projectile collision handling and castRay() to avoid calling getPtr(). It is a step forward removing the mutex inside of PtrHolder. Do the same for DeepestNotMeContactTestResultCallback. It is used only for not-ranged combat for now, but do it anyway for parity with all other callback. This way, once the PtrHolder mutex is gone one will not have to worry about wether it is safe to use the callback in a specific context. To avoid use-after-free with projectile / projectile collision, defer deletion of projectile. Since instead of storing a copy of target Ptr we have a pointer to its collision object, we can't delete projectiles until after we finished iterating over the loops.
2021-08-05 10:55:19 +02:00
mCasterColObj = [this,&caster]() -> const btCollisionObject*
{
const Actor* actor = mPhysics->getActor(caster);
if (actor)
return actor->getCollisionObject();
const Object* object = mPhysics->getObject(caster);
if (object)
return object->getCollisionObject();
return nullptr;
}();
Don't allow projectiles to stand still when they hit an ally. When an NPC fire a projectile, it should affect only its targeted actor. To this end, after a hit is detected the target is checked against the list of AI targets and reactivated if necessary. Problem occurs when the hit occurs as a result of a friendly actor going into the projectile (detected in ClosestNotMeConvexResultCallback): while the projectile is inside the friend's collision box, it is deactivated, just to be immediately reactivated. Effectively, the projectile does nothing until the actor moves out. Add a check inside the ClosestNotMeConvexResultCallback before declaring a hit. Since the necessary data is not safely accessible from the async thread, maintain a copy inside the Projectile class.
2020-12-14 22:23:01 +01:00
}
void Projectile::setValidTargets(const std::vector<MWWorld::Ptr>& targets)
{
std::scoped_lock lock(mMutex);
Use btCollisionObject* instead of MWWorld::Ptr inside of Projectile collision handling and castRay() to avoid calling getPtr(). It is a step forward removing the mutex inside of PtrHolder. Do the same for DeepestNotMeContactTestResultCallback. It is used only for not-ranged combat for now, but do it anyway for parity with all other callback. This way, once the PtrHolder mutex is gone one will not have to worry about wether it is safe to use the callback in a specific context. To avoid use-after-free with projectile / projectile collision, defer deletion of projectile. Since instead of storing a copy of target Ptr we have a pointer to its collision object, we can't delete projectiles until after we finished iterating over the loops.
2021-08-05 10:55:19 +02:00
mValidTargets.clear();
for (const auto& ptr : targets)
{
const auto* physicActor = mPhysics->getActor(ptr);
if (physicActor)
mValidTargets.push_back(physicActor->getCollisionObject());
}
Don't allow projectiles to stand still when they hit an ally. When an NPC fire a projectile, it should affect only its targeted actor. To this end, after a hit is detected the target is checked against the list of AI targets and reactivated if necessary. Problem occurs when the hit occurs as a result of a friendly actor going into the projectile (detected in ClosestNotMeConvexResultCallback): while the projectile is inside the friend's collision box, it is deactivated, just to be immediately reactivated. Effectively, the projectile does nothing until the actor moves out. Add a check inside the ClosestNotMeConvexResultCallback before declaring a hit. Since the necessary data is not safely accessible from the async thread, maintain a copy inside the Projectile class.
2020-12-14 22:23:01 +01:00
}
Use btCollisionObject* instead of MWWorld::Ptr inside of Projectile collision handling and castRay() to avoid calling getPtr(). It is a step forward removing the mutex inside of PtrHolder. Do the same for DeepestNotMeContactTestResultCallback. It is used only for not-ranged combat for now, but do it anyway for parity with all other callback. This way, once the PtrHolder mutex is gone one will not have to worry about wether it is safe to use the callback in a specific context. To avoid use-after-free with projectile / projectile collision, defer deletion of projectile. Since instead of storing a copy of target Ptr we have a pointer to its collision object, we can't delete projectiles until after we finished iterating over the loops.
2021-08-05 10:55:19 +02:00
bool Projectile::isValidTarget(const btCollisionObject* target) const
Don't allow projectiles to stand still when they hit an ally. When an NPC fire a projectile, it should affect only its targeted actor. To this end, after a hit is detected the target is checked against the list of AI targets and reactivated if necessary. Problem occurs when the hit occurs as a result of a friendly actor going into the projectile (detected in ClosestNotMeConvexResultCallback): while the projectile is inside the friend's collision box, it is deactivated, just to be immediately reactivated. Effectively, the projectile does nothing until the actor moves out. Add a check inside the ClosestNotMeConvexResultCallback before declaring a hit. Since the necessary data is not safely accessible from the async thread, maintain a copy inside the Projectile class.
2020-12-14 22:23:01 +01:00
{
Use btCollisionObject* instead of MWWorld::Ptr inside of Projectile collision handling and castRay() to avoid calling getPtr(). It is a step forward removing the mutex inside of PtrHolder. Do the same for DeepestNotMeContactTestResultCallback. It is used only for not-ranged combat for now, but do it anyway for parity with all other callback. This way, once the PtrHolder mutex is gone one will not have to worry about wether it is safe to use the callback in a specific context. To avoid use-after-free with projectile / projectile collision, defer deletion of projectile. Since instead of storing a copy of target Ptr we have a pointer to its collision object, we can't delete projectiles until after we finished iterating over the loops.
2021-08-05 10:55:19 +02:00
assert(target);
Don't allow projectiles to stand still when they hit an ally. When an NPC fire a projectile, it should affect only its targeted actor. To this end, after a hit is detected the target is checked against the list of AI targets and reactivated if necessary. Problem occurs when the hit occurs as a result of a friendly actor going into the projectile (detected in ClosestNotMeConvexResultCallback): while the projectile is inside the friend's collision box, it is deactivated, just to be immediately reactivated. Effectively, the projectile does nothing until the actor moves out. Add a check inside the ClosestNotMeConvexResultCallback before declaring a hit. Since the necessary data is not safely accessible from the async thread, maintain a copy inside the Projectile class.
2020-12-14 22:23:01 +01:00
std::scoped_lock lock(mMutex);
Use btCollisionObject* instead of MWWorld::Ptr inside of Projectile collision handling and castRay() to avoid calling getPtr(). It is a step forward removing the mutex inside of PtrHolder. Do the same for DeepestNotMeContactTestResultCallback. It is used only for not-ranged combat for now, but do it anyway for parity with all other callback. This way, once the PtrHolder mutex is gone one will not have to worry about wether it is safe to use the callback in a specific context. To avoid use-after-free with projectile / projectile collision, defer deletion of projectile. Since instead of storing a copy of target Ptr we have a pointer to its collision object, we can't delete projectiles until after we finished iterating over the loops.
2021-08-05 10:55:19 +02:00
if (mCasterColObj == target)
Don't allow projectiles to stand still when they hit an ally. When an NPC fire a projectile, it should affect only its targeted actor. To this end, after a hit is detected the target is checked against the list of AI targets and reactivated if necessary. Problem occurs when the hit occurs as a result of a friendly actor going into the projectile (detected in ClosestNotMeConvexResultCallback): while the projectile is inside the friend's collision box, it is deactivated, just to be immediately reactivated. Effectively, the projectile does nothing until the actor moves out. Add a check inside the ClosestNotMeConvexResultCallback before declaring a hit. Since the necessary data is not safely accessible from the async thread, maintain a copy inside the Projectile class.
2020-12-14 22:23:01 +01:00
return false;
Use btCollisionObject* instead of MWWorld::Ptr inside of Projectile collision handling and castRay() to avoid calling getPtr(). It is a step forward removing the mutex inside of PtrHolder. Do the same for DeepestNotMeContactTestResultCallback. It is used only for not-ranged combat for now, but do it anyway for parity with all other callback. This way, once the PtrHolder mutex is gone one will not have to worry about wether it is safe to use the callback in a specific context. To avoid use-after-free with projectile / projectile collision, defer deletion of projectile. Since instead of storing a copy of target Ptr we have a pointer to its collision object, we can't delete projectiles until after we finished iterating over the loops.
2021-08-05 10:55:19 +02:00
if (mValidTargets.empty())
Use convexSweepTest for projectile movement to solve any imprecision issue with projectile collision detection. Simplify the mechanics: manage hits in one spot. Give magic projectiles a collision shape similar in size to their visible model. Rename the 2 convex result callback to clearly state their purpose.
2021-01-07 11:02:53 +01:00
return true;
Use btCollisionObject* instead of MWWorld::Ptr inside of Projectile collision handling and castRay() to avoid calling getPtr(). It is a step forward removing the mutex inside of PtrHolder. Do the same for DeepestNotMeContactTestResultCallback. It is used only for not-ranged combat for now, but do it anyway for parity with all other callback. This way, once the PtrHolder mutex is gone one will not have to worry about wether it is safe to use the callback in a specific context. To avoid use-after-free with projectile / projectile collision, defer deletion of projectile. Since instead of storing a copy of target Ptr we have a pointer to its collision object, we can't delete projectiles until after we finished iterating over the loops.
2021-08-05 10:55:19 +02:00
return std::any_of(mValidTargets.begin(), mValidTargets.end(),
[target](const btCollisionObject* actor) { return target == actor; });
Use convexSweepTest for projectile movement to solve any imprecision issue with projectile collision detection. Simplify the mechanics: manage hits in one spot. Give magic projectiles a collision shape similar in size to their visible model. Rename the 2 convex result callback to clearly state their purpose.
2021-01-07 11:02:53 +01:00
}
std::optional<btVector3> Projectile::getWaterHitPosition()
{
return std::exchange(mWaterHitPosition, std::nullopt);
}
void Projectile::setWaterHitPosition(btVector3 pos)
{
if (mCrossedWaterSurface)
return;
mCrossedWaterSurface = true;
mWaterHitPosition = pos;
Don't allow projectiles to stand still when they hit an ally. When an NPC fire a projectile, it should affect only its targeted actor. To this end, after a hit is detected the target is checked against the list of AI targets and reactivated if necessary. Problem occurs when the hit occurs as a result of a friendly actor going into the projectile (detected in ClosestNotMeConvexResultCallback): while the projectile is inside the friend's collision box, it is deactivated, just to be immediately reactivated. Effectively, the projectile does nothing until the actor moves out. Add a check inside the ClosestNotMeConvexResultCallback before declaring a hit. Since the necessary data is not safely accessible from the async thread, maintain a copy inside the Projectile class.
2020-12-14 22:23:01 +01:00
}
Generate physics collisions for projectiles (bug #3372) Remove redundant now mHit field
2019-02-13 11:30:16 +04:00
}
Reference in New Issue Copy Permalink