CollisionCollectorImpl.h

Go to the documentation of this file.

// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <Jolt/Physics/Collision/CollisionCollector.h>
#include <Jolt/Core/QuickSort.h>
 
JPH_NAMESPACE_BEGIN
 
template <class CollectorType>
class AllHitCollisionCollector : public CollectorType
{
public:
    using ResultType = typename CollectorType::ResultType;
 
    // See: CollectorType::Reset
    virtual void        Reset() override
    {
        CollectorType::Reset();
 
        mHits.clear();
    }
 
    // See: CollectorType::AddHit
    virtual void        AddHit(const ResultType &inResult) override
    {
        mHits.push_back(inResult);
    }
 
    void                Sort()
    {
        QuickSort(mHits.begin(), mHits.end(), [](const ResultType &inLHS, const ResultType &inRHS) { return inLHS.GetEarlyOutFraction() < inRHS.GetEarlyOutFraction(); });
    }
 
    inline bool         HadHit() const
    {
        return !mHits.empty();
    }
 
    Array<ResultType>   mHits;
};
 
template <class CollectorType>
class ClosestHitCollisionCollector : public CollectorType
{
public:
    using ResultType = typename CollectorType::ResultType;
 
    // See: CollectorType::Reset
    virtual void        Reset() override
    {
        CollectorType::Reset();
 
        mHadHit = false;
    }
 
    // See: CollectorType::AddHit
    virtual void        AddHit(const ResultType &inResult) override
    {
        float early_out = inResult.GetEarlyOutFraction();
        if (!mHadHit || early_out < mHit.GetEarlyOutFraction())
        {
            // Update early out fraction
            CollectorType::UpdateEarlyOutFraction(early_out);
 
            // Store hit
            mHit = inResult;
            mHadHit = true;
        }
    }
 
    inline bool         HadHit() const
    {
        return mHadHit;
    }
 
    ResultType          mHit;
 
private:
    bool                mHadHit = false;
};
 
template <class CollectorType>
class ClosestHitPerBodyCollisionCollector : public CollectorType
{
public:
    using ResultType = typename CollectorType::ResultType;
 
    // See: CollectorType::Reset
    virtual void        Reset() override
    {
        CollectorType::Reset();
 
        mHits.clear();
        mHadHit = false;
    }
 
    // See: CollectorType::OnBody
    virtual void        OnBody(const Body &inBody) override
    {
        // Store the early out fraction so we can restore it after we've collected all hits for this body
        mPreviousEarlyOutFraction = CollectorType::GetEarlyOutFraction();
    }
 
    // See: CollectorType::AddHit
    virtual void        AddHit(const ResultType &inResult) override
    {
        float early_out = inResult.GetEarlyOutFraction();
        if (!mHadHit || early_out < CollectorType::GetEarlyOutFraction())
        {
            // Update early out fraction to avoid spending work on collecting further hits for this body
            CollectorType::UpdateEarlyOutFraction(early_out);
 
            if (!mHadHit)
            {
                // First time we have a hit we append it to the array
                mHits.push_back(inResult);
                mHadHit = true;
            }
            else
            {
                // Closer hits will override the previous one
                mHits.back() = inResult;
            }
        }
    }
 
    // See: CollectorType::OnBodyEnd
    virtual void        OnBodyEnd() override
    {
        if (mHadHit)
        {
            // Reset the early out fraction to the configured value so that we will continue
            // to collect hits at any distance for other bodies
            JPH_ASSERT(mPreviousEarlyOutFraction != -FLT_MAX); // Check that we got a call to OnBody
            CollectorType::ResetEarlyOutFraction(mPreviousEarlyOutFraction);
            mHadHit = false;
        }
 
        // For asserting purposes we reset the stored early out fraction so we can detect that OnBody was called
        JPH_IF_ENABLE_ASSERTS(mPreviousEarlyOutFraction = -FLT_MAX;)
    }
 
    void                Sort()
    {
        QuickSort(mHits.begin(), mHits.end(), [](const ResultType &inLHS, const ResultType &inRHS) { return inLHS.GetEarlyOutFraction() < inRHS.GetEarlyOutFraction(); });
    }
 
    inline bool         HadHit() const
    {
        return !mHits.empty();
    }
 
    Array<ResultType>   mHits;
 
private:
    // Store early out fraction that was initially configured for the collector
    float               mPreviousEarlyOutFraction = -FLT_MAX;
 
    // Flag to indicate if we have a hit for the current body
    bool                mHadHit = false;
};
 
template <class CollectorType>
class AnyHitCollisionCollector : public CollectorType
{
public:
    using ResultType = typename CollectorType::ResultType;
 
    // See: CollectorType::Reset
    virtual void        Reset() override
    {
        CollectorType::Reset();
 
        mHadHit = false;
    }
 
    // See: CollectorType::AddHit
    virtual void        AddHit(const ResultType &inResult) override
    {
        // Test that the collector is not collecting more hits after forcing an early out
        JPH_ASSERT(!mHadHit);
 
        // Abort any further testing
        CollectorType::ForceEarlyOut();
 
        // Store hit
        mHit = inResult;
        mHadHit = true;
    }
 
    inline bool         HadHit() const
    {
        return mHadHit;
    }
 
    ResultType          mHit;
 
private:
    bool                mHadHit = false;
};
 
JPH_NAMESPACE_END