UE::Geometry::IsInside

Navigation

API > API/Runtime > API/Runtime/GeometryCore

Overloads

UE::Geometry::IsInside(const TSphere3< RealType > &, const TSphere3< RealType > &)

Description

Sphere Containment Queries

namespace UE  
{  
    namespace Geometry  
    {  
        template<typename RealType>  
        bool UE::Geometry::IsInside  
        (  
            const TSphere3 < RealType > & OuterSphere,  
            const TSphere3 < RealType > & InnerSphere  
        )  
    }  
}  
Copy full snippet

namespace UE {     namespace Geometry     {         template<typename RealType>         bool UE::Geometry::IsInside         (             const TSphere3 < RealType > & OuterSphere,             const TSphere3 < RealType > & InnerSphere         )     } }

true if InnerSphere is fully contained within OuterSphere

UE::Geometry::IsInside(const TSphere3< RealType > &, const TCapsule3< RealType > &)

namespace UE  
{  
    namespace Geometry  
    {  
        template<typename RealType>  
        bool UE::Geometry::IsInside  
        (  
            const TSphere3 < RealType > & OuterSphere,  
            const TCapsule3 < RealType > & InnerCapsule  
        )  
    }  
}  
Copy full snippet

namespace UE {     namespace Geometry     {         template<typename RealType>         bool UE::Geometry::IsInside         (             const TSphere3 < RealType > & OuterSphere,             const TCapsule3 < RealType > & InnerCapsule         )     } }

true if InnerCapsule is fully contained within OuterSphere

UE::Geometry::IsInside(const TSphere3< RealType > &, const TOrientedBox3< RealType > &)

namespace UE  
{  
    namespace Geometry  
    {  
        template<typename RealType>  
        bool UE::Geometry::IsInside  
        (  
            const TSphere3 < RealType > & OuterSphere,  
            const TOrientedBox3 < RealType > & InnerBox  
        )  
    }  
}  
Copy full snippet

namespace UE {     namespace Geometry     {         template<typename RealType>         bool UE::Geometry::IsInside         (             const TSphere3 < RealType > & OuterSphere,             const TOrientedBox3 < RealType > & InnerBox         )     } }

true if InnerBox is fully contained within OuterSphere

UE::Geometry::IsInside(const TSphere3< RealType > &, EnumerablePointsType)

namespace UE  
{  
    namespace Geometry  
    {  
        template<typename RealType, typename EnumerablePointsType, typename E>  
        bool UE::Geometry::IsInside  
        (  
            const TSphere3 < RealType > & OuterSphere,  
            EnumerablePointsType EnumerablePts  
        )  
    }  
}  
Copy full snippet

namespace UE {     namespace Geometry     {         template<typename RealType, typename EnumerablePointsType, typename E>         bool UE::Geometry::IsInside         (             const TSphere3 < RealType > & OuterSphere,             EnumerablePointsType EnumerablePts         )     } }

true if all all points in range-based for over EnumerablePts are inside OuterSphere

UE::Geometry::IsInside(const TSphere3< RealType > &, const TTriLinearGridInterpolant< GridType > &)

namespace UE  
{  
    namespace Geometry  
    {  
        template<typename RealType, typename GridType>  
        bool UE::Geometry::IsInside  
        (  
            const TSphere3 < RealType > & OuterSphere,  
            const TTriLinearGridInterpolant < GridType > & InnerGrid  
        )  
    }  
}  
Copy full snippet

namespace UE {     namespace Geometry     {         template<typename RealType, typename GridType>         bool UE::Geometry::IsInside         (             const TSphere3 < RealType > & OuterSphere,             const TTriLinearGridInterpolant < GridType > & InnerGrid         )     } }

true if the AABB of InnerGrid is completely inside OuterSphere

UE::Geometry::IsInside(const TCapsule3< RealType > &, const TCapsule3< RealType > &)

Description

Capsule Containment Queries

namespace UE  
{  
    namespace Geometry  
    {  
        template<typename RealType>  
        bool UE::Geometry::IsInside  
        (  
            const TCapsule3 < RealType > & OuterCapsule,  
            const TCapsule3 < RealType > & InnerCapsule  
        )  
    }  
}  
Copy full snippet

namespace UE {     namespace Geometry     {         template<typename RealType>         bool UE::Geometry::IsInside         (             const TCapsule3 < RealType > & OuterCapsule,             const TCapsule3 < RealType > & InnerCapsule         )     } }

true if InnerCapsule is fully contained within OuterCapsule

UE::Geometry::IsInside(const TCapsule3< RealType > &, const TSphere3< RealType > &)

namespace UE  
{  
    namespace Geometry  
    {  
        template<typename RealType>  
        bool UE::Geometry::IsInside  
        (  
            const TCapsule3 < RealType > & OuterCapsule,  
            const TSphere3 < RealType > & InnerSphere  
        )  
    }  
}  
Copy full snippet

namespace UE {     namespace Geometry     {         template<typename RealType>         bool UE::Geometry::IsInside         (             const TCapsule3 < RealType > & OuterCapsule,             const TSphere3 < RealType > & InnerSphere         )     } }

true if InnerSphere is fully contained within OuterCapsule

UE::Geometry::IsInside(const TCapsule3< RealType > &, const TOrientedBox3< RealType > &)

namespace UE  
{  
    namespace Geometry  
    {  
        template<typename RealType>  
        bool UE::Geometry::IsInside  
        (  
            const TCapsule3 < RealType > & OuterCapsule,  
            const TOrientedBox3 < RealType > & InnerBox  
        )  
    }  
}  
Copy full snippet

namespace UE {     namespace Geometry     {         template<typename RealType>         bool UE::Geometry::IsInside         (             const TCapsule3 < RealType > & OuterCapsule,             const TOrientedBox3 < RealType > & InnerBox         )     } }

true if InnerBox is fully contained within OuterCapsule

UE::Geometry::IsInside(const TCapsule3< RealType > &, EnumerablePointsType)

namespace UE  
{  
    namespace Geometry  
    {  
        template<typename RealType, typename EnumerablePointsType, typename E>  
        bool UE::Geometry::IsInside  
        (  
            const TCapsule3 < RealType > & OuterCapsule,  
            EnumerablePointsType EnumerablePts  
        )  
    }  
}  
Copy full snippet

namespace UE {     namespace Geometry     {         template<typename RealType, typename EnumerablePointsType, typename E>         bool UE::Geometry::IsInside         (             const TCapsule3 < RealType > & OuterCapsule,             EnumerablePointsType EnumerablePts         )     } }

true if all all points in range-based for over EnumerablePts are inside OuterCapsule

UE::Geometry::IsInside(const TCapsule3< RealType > &, const TTriLinearGridInterpolant< GridType > &)

namespace UE  
{  
    namespace Geometry  
    {  
        template<typename RealType, typename GridType>  
        bool UE::Geometry::IsInside  
        (  
            const TCapsule3 < RealType > & OuterCapsule,  
            const TTriLinearGridInterpolant < GridType > & InnerGrid  
        )  
    }  
}  
Copy full snippet

namespace UE {     namespace Geometry     {         template<typename RealType, typename GridType>         bool UE::Geometry::IsInside         (             const TCapsule3 < RealType > & OuterCapsule,             const TTriLinearGridInterpolant < GridType > & InnerGrid         )     } }

true if the AABB of InnerGrid is completely inside OuterCapsule

UE::Geometry::IsInside(const TOrientedBox3< RealType > &, const TOrientedBox3< RealType > &)

Description

OrientedBox Containment Queries

namespace UE  
{  
    namespace Geometry  
    {  
        template<typename RealType>  
        bool UE::Geometry::IsInside  
        (  
            const TOrientedBox3 < RealType > & OuterBox,  
            const TOrientedBox3 < RealType > & InnerBox  
        )  
    }  
}  
Copy full snippet

namespace UE {     namespace Geometry     {         template<typename RealType>         bool UE::Geometry::IsInside         (             const TOrientedBox3 < RealType > & OuterBox,             const TOrientedBox3 < RealType > & InnerBox         )     } }

true if InnerBox is fully contained within OuterBox

UE::Geometry::IsInside(const TOrientedBox3< RealType > &, const TSphere3< RealType > &)

namespace UE  
{  
    namespace Geometry  
    {  
        template<typename RealType>  
        bool UE::Geometry::IsInside  
        (  
            const TOrientedBox3 < RealType > & OuterBox,  
            const TSphere3 < RealType > & InnerSphere  
        )  
    }  
}  
Copy full snippet

namespace UE {     namespace Geometry     {         template<typename RealType>         bool UE::Geometry::IsInside         (             const TOrientedBox3 < RealType > & OuterBox,             const TSphere3 < RealType > & InnerSphere         )     } }

true if InnerSphere is fully contained within OuterBox

UE::Geometry::IsInside(const TOrientedBox3< RealType > &, const TCapsule3< RealType > &)

namespace UE  
{  
    namespace Geometry  
    {  
        template<typename RealType>  
        bool UE::Geometry::IsInside  
        (  
            const TOrientedBox3 < RealType > & OuterBox,  
            const TCapsule3 < RealType > & InnerCapsule  
        )  
    }  
}  
Copy full snippet

namespace UE {     namespace Geometry     {         template<typename RealType>         bool UE::Geometry::IsInside         (             const TOrientedBox3 < RealType > & OuterBox,             const TCapsule3 < RealType > & InnerCapsule         )     } }

true if InnerCapsule is fully contained within OuterBox

UE::Geometry::IsInside(const TOrientedBox3< RealType > &, EnumerablePointsType)

namespace UE  
{  
    namespace Geometry  
    {  
        template<typename RealType, typename EnumerablePointsType, typename E>  
        bool UE::Geometry::IsInside  
        (  
            const TOrientedBox3 < RealType > & OuterBox,  
            EnumerablePointsType EnumerablePts  
        )  
    }  
}  
Copy full snippet

namespace UE {     namespace Geometry     {         template<typename RealType, typename EnumerablePointsType, typename E>         bool UE::Geometry::IsInside         (             const TOrientedBox3 < RealType > & OuterBox,             EnumerablePointsType EnumerablePts         )     } }

true if all all points in range-based for over EnumerablePts are inside OuterBox

UE::Geometry::IsInside(const TOrientedBox3< RealType > &, const TTriLinearGridInterpolant< GridType > &)

namespace UE  
{  
    namespace Geometry  
    {  
        template<typename RealType, typename GridType>  
        bool UE::Geometry::IsInside  
        (  
            const TOrientedBox3 < RealType > & OuterBox,  
            const TTriLinearGridInterpolant < GridType > & InnerGrid  
        )  
    }  
}  
Copy full snippet

namespace UE {     namespace Geometry     {         template<typename RealType, typename GridType>         bool UE::Geometry::IsInside         (             const TOrientedBox3 < RealType > & OuterBox,             const TTriLinearGridInterpolant < GridType > & InnerGrid         )     } }

true if the AABB of InnerGrid is completely inside OuterBox

UE::Geometry::IsInside(const TTriLinearGridInterpolant< GridType > &, const UE::Geometry::TAxisAlignedBox3< RealType > &)

Description

Signed distance field containment tests

To test if an object is inside an SDF, we first rasterize the object's AABB onto the SDF grid. If all of the AABB cells have negative SDF values, we report that the object is inside. Note this is conservative, not exact so an object may actually be inside the implicit surface defined by the SDF, but if its AABB is not fully inside then we will report "not inside."

namespace UE  
{  
    namespace Geometry  
    {  
        template<typename RealType, typename GridType>  
        bool UE::Geometry::IsInside  
        (  
            const TTriLinearGridInterpolant < GridType > & OuterGrid,  
            const UE::Geometry::TAxisAlignedBox3 < RealType > & InnerAABB  
        )  
    }  
}  
Copy full snippet

namespace UE {     namespace Geometry     {         template<typename RealType, typename GridType>         bool UE::Geometry::IsInside         (             const TTriLinearGridInterpolant < GridType > & OuterGrid,             const UE::Geometry::TAxisAlignedBox3 < RealType > & InnerAABB         )     } }

UE::Geometry::IsInside(const TTriLinearGridInterpolant< GridType > &, const TTransform< RealType > &, const TSphere3< RealType > &)

Description

Signed Distance Field containment queries Test if the axis-aligned bounding box of InnerSphere is completely inside the negative region of the signed distance field discretized on OuterGrid

namespace UE  
{  
    namespace Geometry  
    {  
        template<typename RealType, typename GridType>  
        bool UE::Geometry::IsInside  
        (  
            const TTriLinearGridInterpolant < GridType > & OuterGrid,  
            const TTransform < RealType > & OuterGridTransform,  
            const TSphere3 < RealType > & InnerSphere  
        )  
    }  
}  
Copy full snippet

namespace UE {     namespace Geometry     {         template<typename RealType, typename GridType>         bool UE::Geometry::IsInside         (             const TTriLinearGridInterpolant < GridType > & OuterGrid,             const TTransform < RealType > & OuterGridTransform,             const TSphere3 < RealType > & InnerSphere         )     } }

UE::Geometry::IsInside(const TTriLinearGridInterpolant< GridType > &, const TTransform< RealType > &, const TCapsule3< RealType > &)

Description

Test if the axis-aligned bounding box of InnerCapsule is completely inside the negative region of the signed distance field discretized on OuterGrid

namespace UE  
{  
    namespace Geometry  
    {  
        template<typename RealType, typename GridType>  
        bool UE::Geometry::IsInside  
        (  
            const TTriLinearGridInterpolant < GridType > & OuterGrid,  
            const TTransform < RealType > & OuterGridTransform,  
            const TCapsule3 < RealType > & InnerCapsule  
        )  
    }  
}  
Copy full snippet

namespace UE {     namespace Geometry     {         template<typename RealType, typename GridType>         bool UE::Geometry::IsInside         (             const TTriLinearGridInterpolant < GridType > & OuterGrid,             const TTransform < RealType > & OuterGridTransform,             const TCapsule3 < RealType > & InnerCapsule         )     } }

UE::Geometry::IsInside(const TTriLinearGridInterpolant< GridType > &, const TTransform< RealType > &, const TOrientedBox3< RealType > &)

Description

Test if the axis-aligned bounding box of InnerBox is completely inside the negative region of the signed distance field discretized on OuterGrid

namespace UE  
{  
    namespace Geometry  
    {  
        template<typename RealType, typename GridType>  
        bool UE::Geometry::IsInside  
        (  
            const TTriLinearGridInterpolant < GridType > & OuterGrid,  
            const TTransform < RealType > & OuterGridTransform,  
            const TOrientedBox3 < RealType > & InnerBox  
        )  
    }  
}  
Copy full snippet

namespace UE {     namespace Geometry     {         template<typename RealType, typename GridType>         bool UE::Geometry::IsInside         (             const TTriLinearGridInterpolant < GridType > & OuterGrid,             const TTransform < RealType > & OuterGridTransform,             const TOrientedBox3 < RealType > & InnerBox         )     } }

UE::Geometry::IsInside(const TTriLinearGridInterpolant< GridType > &, const TTransform< RealType > &, EnumerablePointsType)

Description

Test if all enumerable points are inside the negative region of the signed distance field discretized on OuterGrid

namespace UE  
{  
    namespace Geometry  
    {  
        template<typename RealType, typename GridType, typename EnumerablePointsType, typename E>  
        bool UE::Geometry::IsInside  
        (  
            const TTriLinearGridInterpolant < GridType > & OuterGrid,  
            const TTransform < RealType > & OuterGridTransform,  
            EnumerablePointsType EnumerablePts  
        )  
    }  
}  
Copy full snippet

namespace UE {     namespace Geometry     {         template<typename RealType, typename GridType, typename EnumerablePointsType, typename E>         bool UE::Geometry::IsInside         (             const TTriLinearGridInterpolant < GridType > & OuterGrid,             const TTransform < RealType > & OuterGridTransform,             EnumerablePointsType EnumerablePts         )     } }

UE::Geometry::IsInside(const TTriLinearGridInterpolant< GridType1 > &, const TTransform< RealType > &, const TTriLinearGridInterpolant< GridType2 > &, const TTransform< RealType > &)

Description

Test if the axis-aligned bounding box of InnerGrid is completely inside the negative region of the signed distance field discretized on OuterGrid

namespace UE  
{  
    namespace Geometry  
    {  
        template<typename RealType, typename GridType1, typename GridType2>  
        bool UE::Geometry::IsInside  
        (  
            const TTriLinearGridInterpolant < GridType1 > & OuterGrid,  
            const TTransform < RealType > & OuterGridTransform,  
            const TTriLinearGridInterpolant < GridType2 > & InnerGrid,  
            const TTransform < RealType > & InnerGridTransform  
        )  
    }  
}  
Copy full snippet

namespace UE {     namespace Geometry     {         template<typename RealType, typename GridType1, typename GridType2>         bool UE::Geometry::IsInside         (             const TTriLinearGridInterpolant < GridType1 > & OuterGrid,             const TTransform < RealType > & OuterGridTransform,             const TTriLinearGridInterpolant < GridType2 > & InnerGrid,             const TTransform < RealType > & InnerGridTransform         )     } }