Settings.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_COMMON_SETTINGS_HPP
#define PLAYRHO_COMMON_SETTINGS_HPP
 
#include <cstddef>
#include <cassert>
#include <cfloat>
#include <cmath>
#include <cstdint>
#include <algorithm>
 
#include <PlayRho/Common/Templates.hpp>
#include <PlayRho/Common/RealConstants.hpp>
#include <PlayRho/Common/Units.hpp>
#include <PlayRho/Common/Wider.hpp>
 
namespace playrho {
namespace detail {
 
template <typename T>
struct Defaults
{
    static PLAYRHO_CONSTEXPR inline auto GetLinearSlop() noexcept
    {
        // Return the value used by Box2D 2.3.2 b2_linearSlop define....
        return 0.005_m;
    }
    
    static PLAYRHO_CONSTEXPR inline auto GetMaxVertexRadius() noexcept
    {
        // DefaultLinearSlop * Real{2 * 1024 * 1024};
        // linearSlop * 2550000
        return 255_m;
    }
};
 
template <unsigned int FRACTION_BITS>
struct Defaults<Fixed<std::int32_t,FRACTION_BITS>>
{
    static PLAYRHO_CONSTEXPR inline auto GetLinearSlop() noexcept
    {
        // Needs to be big enough that the step tolerance doesn't go to zero.
        // ex: FRACTION_BITS==10, then divisor==256
        return Length{1_m / Real{(1u << (FRACTION_BITS - 2))}};
    }
    
    static PLAYRHO_CONSTEXPR inline auto GetMaxVertexRadius() noexcept
    {
        // linearSlop * 2550000
        return Length{Real(1u << (28 - FRACTION_BITS)) * 1_m};
    }
};
 
} // namespace detail
 
PLAYRHO_CONSTEXPR const auto MaxSimplexEdges = std::uint8_t{3};
 
PLAYRHO_CONSTEXPR const auto MaxChildCount = std::numeric_limits<std::uint32_t>::max() >> 6;
 
using ChildCounter = std::remove_const<decltype(MaxChildCount)>::type;
 
using TimestepIters = std::uint8_t;
 
PLAYRHO_CONSTEXPR const auto MaxFloat = std::numeric_limits<Real>::max(); // FLT_MAX
 
// Collision
 
PLAYRHO_CONSTEXPR const auto MaxManifoldPoints = std::uint8_t{2};
 
PLAYRHO_CONSTEXPR const auto MaxShapeVertices = std::uint8_t{254};
 
using VertexCounter = std::remove_const<decltype(MaxShapeVertices)>::type;
 
PLAYRHO_CONSTEXPR const auto InvalidVertex = static_cast<VertexCounter>(-1);
 
PLAYRHO_CONSTEXPR const auto DefaultLinearSlop = detail::Defaults<Real>::GetLinearSlop();
 
PLAYRHO_CONSTEXPR const auto DefaultMinVertexRadius = DefaultLinearSlop * Real{2};
 
PLAYRHO_CONSTEXPR const auto DefaultMaxVertexRadius = detail::Defaults<Real>::GetMaxVertexRadius();
 
PLAYRHO_CONSTEXPR const auto DefaultAabbExtension = DefaultLinearSlop * Real{20};
 
PLAYRHO_CONSTEXPR const auto DefaultDistanceMultiplier = Real{2};
 
PLAYRHO_CONSTEXPR const auto DefaultAngularSlop = (Pi * 2_rad) / Real{180};
 
PLAYRHO_CONSTEXPR const auto DefaultMaxLinearCorrection = 0.2_m;
 
PLAYRHO_CONSTEXPR const auto DefaultMaxAngularCorrection = Real(8.0f / 180.0f) * Pi * 1_rad;
 
PLAYRHO_CONSTEXPR const auto DefaultMaxTranslation = 2_m;
 
PLAYRHO_CONSTEXPR const auto DefaultMaxRotation = Angle{Pi * 1_rad / Real(2)};
 
PLAYRHO_CONSTEXPR const auto DefaultMaxToiIters = std::uint8_t{20};
 
PLAYRHO_CONSTEXPR const auto DefaultMaxToiRootIters = std::uint8_t{30};
 
PLAYRHO_CONSTEXPR const auto DefaultMaxDistanceIters = std::uint8_t{20};
 
PLAYRHO_CONSTEXPR const auto DefaultMaxSubSteps = std::uint8_t{8};
    
// Dynamics
 
PLAYRHO_CONSTEXPR const auto DefaultVelocityThreshold = 1_mps;
 
PLAYRHO_CONSTEXPR const auto DefaultRegMinMomentum = Momentum{0_Ns / 100};
 
PLAYRHO_CONSTEXPR const auto DefaultToiMinMomentum = Momentum{0_Ns / 100};
 
PLAYRHO_CONSTEXPR const auto MaxBodies = static_cast<std::uint16_t>(std::numeric_limits<std::uint16_t>::max() -
                                                      std::uint16_t{1});
 
using BodyCounter = std::remove_const<decltype(MaxBodies)>::type;
 
using ContactCounter = Wider<BodyCounter>::type;
 
PLAYRHO_CONSTEXPR const auto InvalidContactIndex = static_cast<ContactCounter>(-1);
 
PLAYRHO_CONSTEXPR const auto MaxContacts = ContactCounter{MaxBodies} * ContactCounter{MaxBodies - 1} / ContactCounter{2};
 
PLAYRHO_CONSTEXPR const auto MaxJoints = static_cast<std::uint16_t>(std::numeric_limits<std::uint16_t>::max() -
                                                      std::uint16_t{1});
 
using JointCounter = std::remove_const<decltype(MaxJoints)>::type;
 
PLAYRHO_CONSTEXPR const auto DefaultStepTime = Time{1_s / 60};
 
PLAYRHO_CONSTEXPR const auto DefaultStepFrequency = 60_Hz;
 
// Sleep
 
PLAYRHO_CONSTEXPR const auto DefaultMinStillTimeToSleep = Time{1_s / 2}; // aka 0.5 secs
 
PLAYRHO_CONSTEXPR const auto DefaultLinearSleepTolerance = 0.01_mps; // aka 0.01
 
PLAYRHO_CONSTEXPR const auto DefaultAngularSleepTolerance = Real{(Pi * 2) / 180} * RadianPerSecond;
 
PLAYRHO_CONSTEXPR const auto DefaultCirclesRatio = Real{10};
 
} // namespace playrho
 
#endif // PLAYRHO_COMMON_SETTINGS_HPP