StepConf.hpp

Go to the documentation of this file.

/*
 * Original work Copyright (c) 2006-2011 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_DYNAMICS_STEPCONF_HPP
#define PLAYRHO_DYNAMICS_STEPCONF_HPP
 
 
#include <PlayRho/Common/Settings.hpp>
#include <PlayRho/Common/BoundedValue.hpp>
 
namespace playrho {
 
class StepConf
{
public:
    using iteration_type = TimestepIters;
 
    static PLAYRHO_CONSTEXPR const auto InvalidIteration = static_cast<iteration_type>(-1);
 
    Time GetTime() const noexcept { return time; }
 
    Frequency GetInvTime() const noexcept { return invTime; }
    
    PLAYRHO_CONSTEXPR inline StepConf& SetTime(Time value) noexcept
    {
        time = value;
        invTime = (value != 0_s)? Real{1} / value: 0_Hz;
        return *this;
    }
 
    PLAYRHO_CONSTEXPR inline StepConf& SetInvTime(Frequency value) noexcept
    {
        invTime = value;
        time = (value != 0_Hz)? Time{Real{1} / value}: 0_s;
        return *this;
    }
    
    Real dtRatio = 1;
 
    Time minStillTimeToSleep = DefaultMinStillTimeToSleep;
 
    Positive<Length> linearSlop = DefaultLinearSlop;
    
    Positive<Angle> angularSlop = DefaultAngularSlop;
    
    Real regResolutionRate = Real{2} / 10; // aka 0.2.
    
    Length regMinSeparation = -DefaultLinearSlop * Real{3};
    
    Momentum regMinMomentum = DefaultRegMinMomentum;
 
    Real toiResolutionRate = Real{75} / 100; // aka .75
 
    Length toiMinSeparation = -DefaultLinearSlop * Real(1.5f);
 
    Momentum toiMinMomentum = DefaultToiMinMomentum;
 
    Length targetDepth = DefaultLinearSlop * Real{3};
    
    NonNegative<Length> tolerance = DefaultLinearSlop / Real{4};
 
    LinearVelocity velocityThreshold = DefaultVelocityThreshold;
 
    Length maxTranslation = DefaultMaxTranslation;
    
    Angle maxRotation = DefaultMaxRotation;
 
    Length maxLinearCorrection = DefaultMaxLinearCorrection;
    
    Angle maxAngularCorrection = DefaultMaxAngularCorrection;
 
    LinearVelocity linearSleepTolerance = DefaultLinearSleepTolerance;
 
    AngularVelocity angularSleepTolerance = DefaultAngularSleepTolerance;
    
    Real displaceMultiplier = DefaultDistanceMultiplier;
    
    Length aabbExtension = DefaultAabbExtension;
 
    Real maxCirclesRatio = DefaultCirclesRatio;
 
    iteration_type regVelocityIterations = 8;
    
    iteration_type regPositionIterations = 3;
 
    iteration_type toiVelocityIterations = 8;
 
    iteration_type toiPositionIterations = 20;
    
    iteration_type maxToiRootIters = DefaultMaxToiRootIters;
    
    iteration_type maxToiIters = DefaultMaxToiIters;
    
    iteration_type maxDistanceIters = DefaultMaxDistanceIters;
 
    iteration_type maxSubSteps = DefaultMaxSubSteps;
    
    bool doWarmStart = true;
    
    bool doToi = true;
 
    bool doBlocksolve = true;
 
private:
    Time time = DefaultStepTime;
 
    Frequency invTime = DefaultStepFrequency;
};
 
inline Length GetMaxRegLinearCorrection(const StepConf& conf) noexcept
{
    return conf.maxLinearCorrection * static_cast<Real>(conf.regPositionIterations);
}
 
bool IsMaxTranslationWithinTolerance(const StepConf& conf) noexcept;
 
} // namespace playrho
 
#endif // PLAYRHO_DYNAMICS_STEPCONF_HPP