TimeOfImpact.hpp

Go to the documentation of this file.

/*
 * Original work Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
 * Modified work Copyright (c) 2017 Louis Langholtz https://github.com/louis-langholtz/PlayRho
 *
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 */
 
#ifndef PLAYRHO_COLLISION_TIMEOFIMPACT_HPP
#define PLAYRHO_COLLISION_TIMEOFIMPACT_HPP
 
#include <PlayRho/Common/Math.hpp>
#include <PlayRho/Common/Wider.hpp>
#include <PlayRho/Common/BoundedValue.hpp>
 
namespace playrho {
 
class StepConf;
    
struct ToiConf
{
    using root_iter_type = std::remove_const<decltype(DefaultMaxToiRootIters)>::type;
    
    using toi_iter_type = std::remove_const<decltype(DefaultMaxToiIters)>::type;
 
    using dist_iter_type = std::remove_const<decltype(DefaultMaxDistanceIters)>::type;
 
    PLAYRHO_CONSTEXPR inline ToiConf& UseTimeMax(Real value) noexcept;
 
    PLAYRHO_CONSTEXPR inline ToiConf& UseTargetDepth(Length value) noexcept;
    
    PLAYRHO_CONSTEXPR inline ToiConf& UseTolerance(NonNegative<Length> value) noexcept;
    
    PLAYRHO_CONSTEXPR inline ToiConf& UseMaxRootIters(root_iter_type value) noexcept;
    
    PLAYRHO_CONSTEXPR inline ToiConf& UseMaxToiIters(toi_iter_type value) noexcept;
    
    PLAYRHO_CONSTEXPR inline ToiConf& UseMaxDistIters(dist_iter_type value) noexcept;
 
    Real tMax = 1;
    
    Length targetDepth = DefaultLinearSlop * Real{3};
 
    NonNegative<Length> tolerance = NonNegative<Length>{DefaultLinearSlop / Real{4}};
    
    root_iter_type maxRootIters = DefaultMaxToiRootIters;
    
    toi_iter_type maxToiIters = DefaultMaxToiIters; 
    
    dist_iter_type maxDistIters = DefaultMaxDistanceIters; 
};
 
PLAYRHO_CONSTEXPR inline ToiConf& ToiConf::UseTimeMax(Real value) noexcept
{
    tMax = value;
    return *this;
}
 
PLAYRHO_CONSTEXPR inline ToiConf& ToiConf::UseTargetDepth(Length value) noexcept
{
    targetDepth = value;
    return *this;
}
 
PLAYRHO_CONSTEXPR inline ToiConf& ToiConf::UseTolerance(NonNegative<Length> value) noexcept
{
    tolerance = value;
    return *this;
}
 
PLAYRHO_CONSTEXPR inline ToiConf& ToiConf::UseMaxRootIters(root_iter_type value) noexcept
{
    maxRootIters = value;
    return *this;
}
 
PLAYRHO_CONSTEXPR inline ToiConf& ToiConf::UseMaxToiIters(toi_iter_type value) noexcept
{
    maxToiIters = value;
    return *this;
}
 
PLAYRHO_CONSTEXPR inline ToiConf& ToiConf::UseMaxDistIters(dist_iter_type value) noexcept
{
    maxDistIters = value;
    return *this;
}
 
PLAYRHO_CONSTEXPR inline auto GetDefaultToiConf()
{
    return ToiConf{};
}
 
ToiConf GetToiConf(const StepConf& conf) noexcept;
 
struct TOIOutput
{
    struct Statistics
    {
        using toi_iter_type = std::remove_const<decltype(DefaultMaxToiIters)>::type;
        
        using dist_iter_type = std::remove_const<decltype(DefaultMaxDistanceIters)>::type;
        
        using root_iter_type = std::remove_const<decltype(DefaultMaxToiRootIters)>::type;
        
        using toi_sum_type = Wider<toi_iter_type>::type;
        
        using dist_sum_type = Wider<dist_iter_type>::type;
        
        using root_sum_type = Wider<root_iter_type>::type;
 
        // 6-bytes
        toi_sum_type sum_finder_iters = 0; 
        dist_sum_type sum_dist_iters = 0; 
        root_sum_type sum_root_iters = 0; 
 
        // 3-bytes
        toi_iter_type toi_iters = 0; 
        dist_iter_type max_dist_iters = 0; 
        root_iter_type max_root_iters = 0; 
    };
    
    enum State: std::uint8_t
    {
        e_unknown,
        
        e_touching,
        
        e_separated,
        
        e_overlapped,
 
        e_maxRootIters,
        
        e_nextAfter,
        
        e_maxToiIters,
        
        e_belowMinTarget,
        
        e_maxDistIters,
        
        e_targetDepthExceedsTotalRadius,
        e_minTargetSquaredOverflow,
        e_maxTargetSquaredOverflow,
        
        e_notFinite,
    };
    
    TOIOutput() = default;
    
    TOIOutput(Real t, Statistics s, State z) noexcept: time{t}, stats{s}, state{z} {}
 
    Real time = 0; 
    Statistics stats; 
    State state = e_unknown; 
};
 
const char *GetName(TOIOutput::State state) noexcept;
 
namespace d2 {
 
class DistanceProxy;
 
TOIOutput GetToiViaSat(const DistanceProxy& proxyA, const Sweep& sweepA,
                       const DistanceProxy& proxyB, const Sweep& sweepB,
                       ToiConf conf = GetDefaultToiConf());
 
} // namespace d2
} // namespace playrho
 
#endif // PLAYRHO_COLLISION_TIMEOFIMPACT_HPP