mirror/OpenMW
1
0
Fork 0
mirror of https://gitlab.com/OpenMW/openmw.git synced 2025-01-17 10:10:23 +00:00
Code Issues Projects Releases Wiki Activity
5009b66ef5
OpenMW/apps/openmw/mwphysics/projectile.cpp

140 lines
3.9 KiB
C++
Raw Normal View History

Modify projectile collision to work with async physics
2020-10-23 18:27:07 +00:00
#include <memory>
Generate physics collisions for projectiles (bug #3372) Remove redundant now mHit field
2019-02-13 07:30:16 +00: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 08:55:19 +00:00
#include "actor.hpp"
Generate physics collisions for projectiles (bug #3372) Remove redundant now mHit field
2019-02-13 07:30:16 +00:00
#include "collisiontype.hpp"
Modify projectile collision to work with async physics
2020-10-23 18:27:07 +00: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 08:55:19 +00:00
#include "object.hpp"
Modify projectile collision to work with async physics
2020-10-23 18:27:07 +00:00
#include "projectile.hpp"
Generate physics collisions for projectiles (bug #3372) Remove redundant now mHit field
2019-02-13 07:30:16 +00:00
namespace MWPhysics
{
Change projectile behaviour to be like in vanilla wrt. water plane: - enchanted arrow explode upon hit the water plane - non enchanted arrow disappear (or more accurately, they hit nothingness) - enchanted arrow shot underwater explode immediately - non enchanted arrow disappear immediately Also, solve a bug that occured previously and could theoritically still happens where we use the last tested collision position for instead of the last registered hit: Use the hit position as saved inside Projectile::hit() instead of the last position saved inside the callback. If a projectile collides with several objects (bottom of the sea and water surface for instance), the last collision tested won't necessarily be the impact position as we have no control over the order in which the tests are performed.
2021-08-31 14:25:45 +00:00
Projectile::Projectile(const MWWorld::Ptr& caster, const osg::Vec3f& position, float radius, PhysicsTaskScheduler* scheduler, PhysicsSystem* physicssystem)
: mHitWater(false)
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 10:02:53 +00:00
, 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 08:55:19 +00:00
, mHitTarget(nullptr)
Projectile to projectile collision
2020-10-31 13:01:14 +00:00
, mPhysics(physicssystem)
Modify projectile collision to work with async physics
2020-10-23 18:27:07 +00:00
, mTaskScheduler(scheduler)
Generate physics collisions for projectiles (bug #3372) Remove redundant now mHit field
2019-02-13 07:30:16 +00: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 10:02:53 +00:00
mShape = std::make_unique<btSphereShape>(radius);
Generate physics collisions for projectiles (bug #3372) Remove redundant now mHit field
2019-02-13 07:30:16 +00: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 17:20:42 +00:00
mCollisionObject = std::make_unique<btCollisionObject>();
Generate physics collisions for projectiles (bug #3372) Remove redundant now mHit field
2019-02-13 07:30:16 +00: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 08:55:19 +00:00
setCaster(caster);
Generate physics collisions for projectiles (bug #3372) Remove redundant now mHit field
2019-02-13 07:30:16 +00:00
const int collisionMask = CollisionType_World | CollisionType_HeightMap |
Projectile to projectile collision
2020-10-31 13:01:14 +00:00
CollisionType_Actor | CollisionType_Door | CollisionType_Water | CollisionType_Projectile;
Modify projectile collision to work with async physics
2020-10-23 18:27:07 +00:00
mTaskScheduler->addCollisionObject(mCollisionObject.get(), CollisionType_Projectile, collisionMask);
commitPositionChange();
Generate physics collisions for projectiles (bug #3372) Remove redundant now mHit field
2019-02-13 07:30:16 +00: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 17:20:42 +00: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 07:30:16 +00:00
}
Modify projectile collision to work with async physics
2020-10-23 18:27:07 +00:00
void Projectile::commitPositionChange()
Generate physics collisions for projectiles (bug #3372) Remove redundant now mHit field
2019-02-13 07:30:16 +00: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 21:23:01 +00:00
std::scoped_lock lock(mMutex);
Modify projectile collision to work with async physics
2020-10-23 18:27:07 +00:00
if (mTransformUpdatePending)
{
Do not store a btTransform into Projectile class: reduce its size by 112 bytes
2021-07-17 06:56:43 +00: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 18:27:07 +00:00
mTransformUpdatePending = false;
}
Generate physics collisions for projectiles (bug #3372) Remove redundant now mHit field
2019-02-13 07:30:16 +00: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 21:23:01 +00:00
std::scoped_lock lock(mMutex);
Do not store a btTransform into Projectile class: reduce its size by 112 bytes
2021-07-17 06:56:43 +00:00
mPosition = position;
Modify projectile collision to work with async physics
2020-10-23 18:27:07 +00:00
mTransformUpdatePending = true;
Generate physics collisions for projectiles (bug #3372) Remove redundant now mHit field
2019-02-13 07:30:16 +00: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 10:02:53 +00: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 06:56:43 +00: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 10:02:53 +00: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 08:55:19 +00: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 07:30:16 +00: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 08:55:19 +00: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 18:27:07 +00:00
return;
mHitTarget = target;
mHitPosition = pos;
Projectile to projectile collision
2020-10-31 13:01:14 +00: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 08:55:19 +00: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 07:30:16 +00: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 21:23:01 +00:00
MWWorld::Ptr Projectile::getCaster() const
{
return mCaster;
}
Add a ton of const refs
2021-06-23 21:13:59 +00: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 21:23:01 +00: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 08:55:19 +00: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 21:23:01 +00: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 08:55:19 +00: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 21:23:01 +00: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 08:55:19 +00: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 21:23:01 +00: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 08:55:19 +00: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 21:23:01 +00: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 08:55:19 +00: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 21:23:01 +00: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 08:55:19 +00: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 10:02:53 +00: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 08:55:19 +00: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 10:02:53 +00:00
}
Generate physics collisions for projectiles (bug #3372) Remove redundant now mHit field
2019-02-13 07:30:16 +00:00
}
Reference in New Issue Copy Permalink