OpenMW/apps/openmw/mwphysics/closestnotmerayresultcallback.cpp

#include "closestnotmerayresultcallback.hpp"

#include <algorithm>

#include <BulletCollision/CollisionDispatch/btCollisionObject.h>

#include "collisiontype.hpp"

namespace MWPhysics
{
    btScalar ClosestNotMeRayResultCallback::addSingleResult(
        btCollisionWorld::LocalRayResult& rayResult, bool normalInWorldSpace)
    {
        const auto* hitObject = rayResult.m_collisionObject;
        if (std::find(mIgnoreList.begin(), mIgnoreList.end(), hitObject) != mIgnoreList.end())
            return 1.f;

        if (hitObject->getBroadphaseHandle()->m_collisionFilterGroup == CollisionType_Actor && !mTargets.empty())
        {
            if ((std::find(mTargets.begin(), mTargets.end(), hitObject) == mTargets.end()))
                return 1.f;
        }

        return btCollisionWorld::ClosestRayResultCallback::addSingleResult(rayResult, normalInWorldSpace);
    }
}
Separate ClosestNotMeRayResultCallback 2020-03-30 18:45:38 +00:00			`#include "closestnotmerayresultcallback.hpp"`

			`#include <algorithm>`

			`#include <BulletCollision/CollisionDispatch/btCollisionObject.h>`

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 "collisiontype.hpp"`
Separate ClosestNotMeRayResultCallback 2020-03-30 18:45:38 +00:00
			`namespace MWPhysics`
			`{`
			`btScalar ClosestNotMeRayResultCallback::addSingleResult(`
			`btCollisionWorld::LocalRayResult& rayResult, bool normalInWorldSpace)`
			`{`
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			`const auto* hitObject = rayResult.m_collisionObject;`
add ignore list to raycasts 2024-02-12 15:52:47 +00:00			`if (std::find(mIgnoreList.begin(), mIgnoreList.end(), hitObject) != mIgnoreList.end())`
Separate ClosestNotMeRayResultCallback 2020-03-30 18:45:38 +00:00			`return 1.f;`
When doing a ray cast to the next projectile position, ignore collisions that occurs with the projectile own collision object. Otherwise a magic bolt can explode "spontaneously". 2020-12-15 20:34:58 +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			`if (hitObject->getBroadphaseHandle()->m_collisionFilterGroup == CollisionType_Actor && !mTargets.empty())`
Separate ClosestNotMeRayResultCallback 2020-03-30 18:45:38 +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			`if ((std::find(mTargets.begin(), mTargets.end(), hitObject) == mTargets.end()))`
			`return 1.f;`
Separate ClosestNotMeRayResultCallback 2020-03-30 18:45:38 +00:00			`}`
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			`return btCollisionWorld::ClosestRayResultCallback::addSingleResult(rayResult, normalInWorldSpace);`
Separate ClosestNotMeRayResultCallback 2020-03-30 18:45:38 +00:00			`}`
			`}`