BroadPhaseLayer.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/Core/NonCopyable.h>
#include <Jolt/Physics/Collision/ObjectLayer.h>
 
JPH_NAMESPACE_BEGIN
 
class BroadPhaseLayer
{
public:
    using Type = uint8;
 
    JPH_INLINE                      BroadPhaseLayer() = default;
    JPH_INLINE explicit constexpr   BroadPhaseLayer(Type inValue) : mValue(inValue) { }
    JPH_INLINE constexpr            BroadPhaseLayer(const BroadPhaseLayer &) = default;
    JPH_INLINE BroadPhaseLayer &    operator = (const BroadPhaseLayer &) = default;
 
    JPH_INLINE constexpr bool       operator == (const BroadPhaseLayer &inRHS) const
    {
        return mValue == inRHS.mValue;
    }
 
    JPH_INLINE constexpr bool       operator != (const BroadPhaseLayer &inRHS) const
    {
        return mValue != inRHS.mValue;
    }
 
    JPH_INLINE constexpr bool       operator < (const BroadPhaseLayer &inRHS) const
    {
        return mValue < inRHS.mValue;
    }
 
    JPH_INLINE explicit constexpr   operator Type() const
    {
        return mValue;
    }
 
private:
    Type                            mValue;
};
 
static constexpr BroadPhaseLayer cBroadPhaseLayerInvalid(0xff);
 
class BroadPhaseLayerInterface : public NonCopyable
{
public:
    virtual                         ~BroadPhaseLayerInterface() = default;
 
    virtual uint                    GetNumBroadPhaseLayers() const = 0;
 
    virtual BroadPhaseLayer         GetBroadPhaseLayer(ObjectLayer inLayer) const = 0;
 
#if defined(JPH_EXTERNAL_PROFILE) || defined(JPH_PROFILE_ENABLED)
    virtual const char *            GetBroadPhaseLayerName(BroadPhaseLayer inLayer) const = 0;
#endif // JPH_EXTERNAL_PROFILE || JPH_PROFILE_ENABLED
};
 
class ObjectVsBroadPhaseLayerFilter : public NonCopyable
{
public:
    virtual                         ~ObjectVsBroadPhaseLayerFilter() = default;
 
    virtual bool                    ShouldCollide(ObjectLayer inLayer1, BroadPhaseLayer inLayer2) const
    {
        return true;
    }
};
 
class BroadPhaseLayerFilter : public NonCopyable
{
public:
    virtual                         ~BroadPhaseLayerFilter() = default;
 
    virtual bool                    ShouldCollide(BroadPhaseLayer inLayer) const
    {
        return true;
    }
};
 
class DefaultBroadPhaseLayerFilter : public BroadPhaseLayerFilter
{
public:
                                    DefaultBroadPhaseLayerFilter(const ObjectVsBroadPhaseLayerFilter &inObjectVsBroadPhaseLayerFilter, ObjectLayer inLayer) :
        mObjectVsBroadPhaseLayerFilter(inObjectVsBroadPhaseLayerFilter),
        mLayer(inLayer)
    {
    }
 
    // See BroadPhaseLayerFilter::ShouldCollide
    virtual bool                    ShouldCollide(BroadPhaseLayer inLayer) const override
    {
        return mObjectVsBroadPhaseLayerFilter.ShouldCollide(mLayer, inLayer);
    }
 
private:
    const ObjectVsBroadPhaseLayerFilter &mObjectVsBroadPhaseLayerFilter;
    ObjectLayer                     mLayer;
};
 
class SpecifiedBroadPhaseLayerFilter : public BroadPhaseLayerFilter
{
public:
    explicit                        SpecifiedBroadPhaseLayerFilter(BroadPhaseLayer inLayer) :
        mLayer(inLayer)
    {
    }
 
    // See BroadPhaseLayerFilter::ShouldCollide
    virtual bool                    ShouldCollide(BroadPhaseLayer inLayer) const override
    {
        return mLayer == inLayer;
    }
 
private:
    BroadPhaseLayer                 mLayer;
};
 
JPH_NAMESPACE_END