File indexing completed on 2025-06-01 03:50:40

 /*
 * Copyright (c) 2006-2009 Erin Catto http://www.gphysics.com
 *
 * 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 B2_SETTINGS_H
 #define B2_SETTINGS_H
 
 #include <cassert>
 #include <cfloat>
 #include <cmath>
 #include <climits>
 #include <stdint.h>
 #include <qmath.h>
 
 #define B2_NOT_USED(x) ((void)(x))
 #define b2Assert(A) assert(A)
 
 typedef signed char int8;
 typedef signed short int16;
 typedef signed int int32;
 typedef unsigned char uint8;
 typedef unsigned short uint16;
 typedef unsigned int uint32;
 
 template<size_t fltsize> struct b2_floatValues;
 template<> struct b2_floatValues<4> {
     static inline float maxFloat() { return FLT_MAX; }
     static inline float epsilon() { return FLT_EPSILON; }
     static inline float pi() { return 3.14159265359f; }
 };
 template<> struct b2_floatValues<8> {
     static inline double maxFloat() { return DBL_MAX; }
     static inline double epsilon() { return DBL_EPSILON; }
     static inline double pi() { return M_PI; }
 };
 
 #define b2_maxFloat     b2_floatValues<sizeof(qreal)>::maxFloat()
 #define b2_epsilon      b2_floatValues<sizeof(qreal)>::epsilon()
 #define b2_pi           b2_floatValues<sizeof(qreal)>::pi()
 
 /// @file
 /// Global tuning constants based on meters-kilograms-seconds (MKS) units.
 ///
 
 // Collision
 
 /// The maximum number of contact points between two convex shapes.
 #define b2_maxManifoldPoints    2
 
 /// The maximum number of vertices on a convex polygon. You cannot increase
 /// this too much because b2BlockAllocator has a maximum object size.
 #define b2_maxPolygonVertices   8
 
 /// This is used to fatten AABBs in the dynamic tree. This allows proxies
 /// to move by a small amount without triggering a tree adjustment.
 /// This is in meters.
 #define b2_aabbExtension        0.1f
 
 /// This is used to fatten AABBs in the dynamic tree. This is used to predict
 /// the future position based on the current displacement.
 /// This is a dimensionless multiplier.
 #define b2_aabbMultiplier       2.0f
 
 /// A small length used as a collision and constraint tolerance. Usually it is
 /// chosen to be numerically significant, but visually insignificant.
 #define b2_linearSlop           0.005f
 
 /// A small angle used as a collision and constraint tolerance. Usually it is
 /// chosen to be numerically significant, but visually insignificant.
 #define b2_angularSlop          (2.0f / 180.0f * b2_pi)
 
 /// The radius of the polygon/edge shape skin. This should not be modified. Making
 /// this smaller means polygons will have an insufficient buffer for continuous collision.
 /// Making it larger may create artifacts for vertex collision.
 #define b2_polygonRadius        (2.0f * b2_linearSlop)
 
 /// Maximum number of sub-steps per contact in continuous physics simulation.
 #define b2_maxSubSteps          8
 
 
 // Dynamics
 
 /// Maximum number of contacts to be handled to solve a TOI impact.
 #define b2_maxTOIContacts           32
 
 /// A velocity threshold for elastic collisions. Any collision with a relative linear
 /// velocity below this threshold will be treated as inelastic.
 #define b2_velocityThreshold        0.0f
 
 /// The maximum linear position correction used when solving constraints. This helps to
 /// prevent overshoot.
 #define b2_maxLinearCorrection      0.2f
 
 /// The maximum angular position correction used when solving constraints. This helps to
 /// prevent overshoot.
 #define b2_maxAngularCorrection     (8.0f / 180.0f * b2_pi)
 
 /// The maximum linear velocity of a body. This limit is very large and is used
 /// to prevent numerical problems. You shouldn't need to adjust this.
 #define b2_maxTranslation           2.0f
 #define b2_maxTranslationSquared    (b2_maxTranslation * b2_maxTranslation)
 
 /// The maximum angular velocity of a body. This limit is very large and is used
 /// to prevent numerical problems. You shouldn't need to adjust this.
 #define b2_maxRotation              (0.5f * b2_pi)
 #define b2_maxRotationSquared       (b2_maxRotation * b2_maxRotation)
 
 /// This scale factor controls how fast overlap is resolved. Ideally this would be 1 so
 /// that overlap is removed in one time step. However using values close to 1 often lead
 /// to overshoot.
 #define b2_contactBaumgarte         0.2f
 
 
 // Sleep
 
 /// The time that a body must be still before it will go to sleep.
 #define b2_timeToSleep              0.5f
 
 /// A body cannot sleep if its linear velocity is above this tolerance.
 #define b2_linearSleepTolerance     0.01f
 
 /// A body cannot sleep if its angular velocity is above this tolerance.
 #define b2_angularSleepTolerance    (2.0f / 180.0f * b2_pi)
 
 // Memory Allocation
 
 /// Implement this function to use your own memory allocator.
 void* b2Alloc(int32 size);
 
 /// If you implement b2Alloc, you should also implement this function.
 void b2Free(void* mem);
 
 /// Version numbering scheme.
 /// See http://en.wikipedia.org/wiki/Software_versioning
 struct b2Version
 {
     int32 major;        ///< significant changes
     int32 minor;        ///< incremental changes
     int32 revision;     ///< bug fixes
 };
 
 /// Current version.
 extern b2Version b2_version;
 
 /// Friction mixing law. Feel free to customize this.
 inline qreal b2MixFriction(qreal friction1, qreal friction2)
 {
     return std::sqrt(friction1 * friction2);
 }
 
 /// Restitution mixing law. Feel free to customize this.
 inline qreal b2MixRestitution(qreal restitution1, qreal restitution2)
 {
     return restitution1 > restitution2 ? restitution1 : restitution2;
 }
 
 #endif