From f4dacbe0a45b6d24b5c0c0f30634988c71bc321d Mon Sep 17 00:00:00 2001 From: schutz Date: Mon, 2 Aug 2010 17:40:12 +0200 Subject: [PATCH] first commit --- Box2D/CMakeLists.txt | 3 + Box2D/CMakeLists.txt~ | 12 + Box2D/License.txt | 18 + Box2D/Readme.txt | 19 + Box2D/Source/Box2D.h | 52 + Box2D/Source/CMakeLists.txt | 40 + Box2D/Source/Collision/Shapes/b2CircleShape.cpp | 120 +++ Box2D/Source/Collision/Shapes/b2CircleShape.h | 92 ++ Box2D/Source/Collision/Shapes/b2PolygonShape.cpp | 449 +++++++++ Box2D/Source/Collision/Shapes/b2PolygonShape.h | 163 +++ Box2D/Source/Collision/Shapes/b2Shape.cpp | 167 +++ Box2D/Source/Collision/Shapes/b2Shape.h | 285 ++++++ Box2D/Source/Collision/b2BroadPhase.cpp | 668 ++++++++++++ Box2D/Source/Collision/b2BroadPhase.h | 146 +++ Box2D/Source/Collision/b2CollideCircle.cpp | 168 ++++ Box2D/Source/Collision/b2CollidePoly.cpp | 352 +++++++ Box2D/Source/Collision/b2Collision.cpp | 72 ++ Box2D/Source/Collision/b2Collision.h | 154 +++ Box2D/Source/Collision/b2Distance.cpp | 364 +++++++ Box2D/Source/Collision/b2PairManager.cpp | 396 ++++++++ Box2D/Source/Collision/b2PairManager.h | 121 +++ Box2D/Source/Collision/b2TimeOfImpact.cpp | 112 +++ Box2D/Source/Common/Fixed.h | 477 +++++++++ Box2D/Source/Common/b2BlockAllocator.cpp | 206 ++++ Box2D/Source/Common/b2BlockAllocator.h | 59 ++ Box2D/Source/Common/b2Math.cpp | 54 + Box2D/Source/Common/b2Math.h | 636 ++++++++++++ Box2D/Source/Common/b2Settings.cpp | 51 + Box2D/Source/Common/b2Settings.h | 176 ++++ Box2D/Source/Common/b2StackAllocator.cpp | 83 ++ Box2D/Source/Common/b2StackAllocator.h | 60 ++ Box2D/Source/Common/jtypes.h | 139 +++ Box2D/Source/Dynamics/Contacts/b2CircleContact.cpp | 122 +++ Box2D/Source/Dynamics/Contacts/b2CircleContact.h | 46 + Box2D/Source/Dynamics/Contacts/b2Contact.cpp | 172 ++++ Box2D/Source/Dynamics/Contacts/b2Contact.h | 183 ++++ Box2D/Source/Dynamics/Contacts/b2ContactSolver.cpp | 360 +++++++ Box2D/Source/Dynamics/Contacts/b2ContactSolver.h | 77 ++ Box2D/Source/Dynamics/Contacts/b2NullContact.h | 33 + .../Dynamics/Contacts/b2PolyAndCircleContact.cpp | 158 +++ .../Dynamics/Contacts/b2PolyAndCircleContact.h | 44 + Box2D/Source/Dynamics/Contacts/b2PolyContact.cpp | 157 +++ Box2D/Source/Dynamics/Contacts/b2PolyContact.h | 44 + Box2D/Source/Dynamics/Joints/b2DistanceJoint.cpp | 206 ++++ Box2D/Source/Dynamics/Joints/b2DistanceJoint.h | 96 ++ Box2D/Source/Dynamics/Joints/b2GearJoint.cpp | 253 +++++ Box2D/Source/Dynamics/Joints/b2GearJoint.h | 109 ++ Box2D/Source/Dynamics/Joints/b2Joint.cpp | 134 +++ Box2D/Source/Dynamics/Joints/b2Joint.h | 219 ++++ Box2D/Source/Dynamics/Joints/b2MouseJoint.cpp | 146 +++ Box2D/Source/Dynamics/Joints/b2MouseJoint.h | 102 ++ Box2D/Source/Dynamics/Joints/b2PrismaticJoint.cpp | 478 +++++++++ Box2D/Source/Dynamics/Joints/b2PrismaticJoint.h | 176 ++++ Box2D/Source/Dynamics/Joints/b2PulleyJoint.cpp | 430 ++++++++ Box2D/Source/Dynamics/Joints/b2PulleyJoint.h | 153 +++ Box2D/Source/Dynamics/Joints/b2RevoluteJoint.cpp | 399 ++++++++ Box2D/Source/Dynamics/Joints/b2RevoluteJoint.h | 172 ++++ Box2D/Source/Dynamics/b2Body.cpp | 394 ++++++++ Box2D/Source/Dynamics/b2Body.h | 587 +++++++++++ Box2D/Source/Dynamics/b2ContactManager.cpp | 240 +++++ Box2D/Source/Dynamics/b2ContactManager.h | 54 + Box2D/Source/Dynamics/b2Island.cpp | 420 ++++++++ Box2D/Source/Dynamics/b2Island.h | 88 ++ Box2D/Source/Dynamics/b2World.cpp | 1064 ++++++++++++++++++++ Box2D/Source/Dynamics/b2World.h | 253 +++++ Box2D/Source/Dynamics/b2WorldCallbacks.cpp | 63 ++ Box2D/Source/Dynamics/b2WorldCallbacks.h | 172 ++++ Box2D/TODO.txt | 157 +++ Box2D/box2d.pri | 67 ++ Box2D/box2d.pri~ | 10 + CMakeLists.txt | 18 + athread.cpp | 42 + athread.h | 27 + blok.pro | 28 + blokgameview.cpp | 98 ++ blokgameview.h | 41 + blokitem/blokitem.cpp | 6 + blokitem/blokitem.h | 26 + blokitem/blokitem.pri | 17 + blokitem/blokitem.pri~ | 1 + blokitem/box2d.pri | 17 + blokitem/chimicblokitem.cpp | 12 + blokitem/chimicblokitem.h | 16 + blokitem/explodeblokitem.cpp | 9 + blokitem/explodeblokitem.h | 16 + blokitem/exploseblokitem.cpp | 9 + blokitem/exploseblokitem.h | 16 + blokitem/normalblokitem.cpp | 52 + blokitem/normalblokitem.h | 25 + blokitem/solidblokitem.cpp | 9 + blokitem/solidblokitem.h | 11 + blokitem/totemblokitem.cpp | 36 + blokitem/totemblokitem.h | 22 + boxitem.cpp | 108 ++ boxitem.h | 74 ++ data/sounds/explosion.wav | Bin 0 -> 184392 bytes data/sprites.qrc | 25 + data/sprites/.directory | 3 + data/sprites/blue_ground.png | Bin 0 -> 120556 bytes data/sprites/chimic_block.png | Bin 0 -> 37972 bytes data/sprites/clanbomber.png | Bin 0 -> 1218 bytes data/sprites/cloud.png | Bin 0 -> 16971 bytes data/sprites/cursor.png | Bin 0 -> 2236 bytes data/sprites/explode_block.png | Bin 0 -> 1706 bytes data/sprites/explose.png | Bin 0 -> 1706 bytes data/sprites/fire_wallpaper.png | Bin 0 -> 168699 bytes data/sprites/green_ground.png | Bin 0 -> 168228 bytes data/sprites/normal_block.png | Bin 0 -> 3091 bytes data/sprites/red_ground.png | Bin 0 -> 132007 bytes data/sprites/sky_wallpaper.png | Bin 0 -> 165603 bytes data/sprites/solid_block.png | Bin 0 -> 449 bytes data/sprites/supermario_wallpaper.png | Bin 0 -> 158731 bytes data/sprites/text05.png | Bin 0 -> 3743 bytes data/sprites/text06.png | Bin 0 -> 5279 bytes data/sprites/text07.png | Bin 0 -> 3339 bytes data/sprites/totem1_block.png | Bin 0 -> 2007 bytes data/sprites/totem2_block.png | Bin 0 -> 5690 bytes data/sprites/totem3_block.png | Bin 0 -> 4817 bytes main.cpp | 20 + mainwindow.cpp | 14 + mainwindow.h | 25 + physicsscene.cpp | 137 +++ physicsscene.h | 51 + totemblokitem.cpp | 33 + totemblokitem.h | 22 + 125 files changed, 15018 insertions(+) create mode 100644 Box2D/CMakeLists.txt create mode 100644 Box2D/CMakeLists.txt~ create mode 100644 Box2D/License.txt create mode 100644 Box2D/Readme.txt create mode 100644 Box2D/Source/Box2D.h create mode 100644 Box2D/Source/CMakeLists.txt create mode 100644 Box2D/Source/Collision/Shapes/b2CircleShape.cpp create mode 100644 Box2D/Source/Collision/Shapes/b2CircleShape.h create mode 100644 Box2D/Source/Collision/Shapes/b2PolygonShape.cpp create mode 100644 Box2D/Source/Collision/Shapes/b2PolygonShape.h create mode 100644 Box2D/Source/Collision/Shapes/b2Shape.cpp create mode 100644 Box2D/Source/Collision/Shapes/b2Shape.h create mode 100644 Box2D/Source/Collision/b2BroadPhase.cpp create mode 100644 Box2D/Source/Collision/b2BroadPhase.h create mode 100644 Box2D/Source/Collision/b2CollideCircle.cpp create mode 100644 Box2D/Source/Collision/b2CollidePoly.cpp create mode 100644 Box2D/Source/Collision/b2Collision.cpp create mode 100644 Box2D/Source/Collision/b2Collision.h create mode 100644 Box2D/Source/Collision/b2Distance.cpp create mode 100644 Box2D/Source/Collision/b2PairManager.cpp create mode 100644 Box2D/Source/Collision/b2PairManager.h create mode 100644 Box2D/Source/Collision/b2TimeOfImpact.cpp create mode 100644 Box2D/Source/Common/Fixed.h create mode 100644 Box2D/Source/Common/b2BlockAllocator.cpp create mode 100644 Box2D/Source/Common/b2BlockAllocator.h create mode 100644 Box2D/Source/Common/b2Math.cpp create mode 100644 Box2D/Source/Common/b2Math.h create mode 100644 Box2D/Source/Common/b2Settings.cpp create mode 100644 Box2D/Source/Common/b2Settings.h create mode 100644 Box2D/Source/Common/b2StackAllocator.cpp create mode 100644 Box2D/Source/Common/b2StackAllocator.h create mode 100644 Box2D/Source/Common/jtypes.h create mode 100644 Box2D/Source/Dynamics/Contacts/b2CircleContact.cpp create mode 100644 Box2D/Source/Dynamics/Contacts/b2CircleContact.h create mode 100644 Box2D/Source/Dynamics/Contacts/b2Contact.cpp create mode 100644 Box2D/Source/Dynamics/Contacts/b2Contact.h create mode 100644 Box2D/Source/Dynamics/Contacts/b2ContactSolver.cpp create mode 100644 Box2D/Source/Dynamics/Contacts/b2ContactSolver.h create mode 100644 Box2D/Source/Dynamics/Contacts/b2NullContact.h create mode 100644 Box2D/Source/Dynamics/Contacts/b2PolyAndCircleContact.cpp create mode 100644 Box2D/Source/Dynamics/Contacts/b2PolyAndCircleContact.h create mode 100644 Box2D/Source/Dynamics/Contacts/b2PolyContact.cpp create mode 100644 Box2D/Source/Dynamics/Contacts/b2PolyContact.h create mode 100644 Box2D/Source/Dynamics/Joints/b2DistanceJoint.cpp create mode 100644 Box2D/Source/Dynamics/Joints/b2DistanceJoint.h create mode 100644 Box2D/Source/Dynamics/Joints/b2GearJoint.cpp create mode 100644 Box2D/Source/Dynamics/Joints/b2GearJoint.h create mode 100644 Box2D/Source/Dynamics/Joints/b2Joint.cpp create mode 100644 Box2D/Source/Dynamics/Joints/b2Joint.h create mode 100644 Box2D/Source/Dynamics/Joints/b2MouseJoint.cpp create mode 100644 Box2D/Source/Dynamics/Joints/b2MouseJoint.h create mode 100644 Box2D/Source/Dynamics/Joints/b2PrismaticJoint.cpp create mode 100644 Box2D/Source/Dynamics/Joints/b2PrismaticJoint.h create mode 100644 Box2D/Source/Dynamics/Joints/b2PulleyJoint.cpp create mode 100644 Box2D/Source/Dynamics/Joints/b2PulleyJoint.h create mode 100644 Box2D/Source/Dynamics/Joints/b2RevoluteJoint.cpp create mode 100644 Box2D/Source/Dynamics/Joints/b2RevoluteJoint.h create mode 100644 Box2D/Source/Dynamics/b2Body.cpp create mode 100644 Box2D/Source/Dynamics/b2Body.h create mode 100644 Box2D/Source/Dynamics/b2ContactManager.cpp create mode 100644 Box2D/Source/Dynamics/b2ContactManager.h create mode 100644 Box2D/Source/Dynamics/b2Island.cpp create mode 100644 Box2D/Source/Dynamics/b2Island.h create mode 100644 Box2D/Source/Dynamics/b2World.cpp create mode 100644 Box2D/Source/Dynamics/b2World.h create mode 100644 Box2D/Source/Dynamics/b2WorldCallbacks.cpp create mode 100644 Box2D/Source/Dynamics/b2WorldCallbacks.h create mode 100644 Box2D/TODO.txt create mode 100755 Box2D/box2d.pri create mode 100755 Box2D/box2d.pri~ create mode 100644 CMakeLists.txt create mode 100644 athread.cpp create mode 100644 athread.h create mode 100644 blok.pro create mode 100644 blokgameview.cpp create mode 100644 blokgameview.h create mode 100644 blokitem/blokitem.cpp create mode 100644 blokitem/blokitem.h create mode 100644 blokitem/blokitem.pri create mode 100755 blokitem/blokitem.pri~ create mode 100755 blokitem/box2d.pri create mode 100644 blokitem/chimicblokitem.cpp create mode 100644 blokitem/chimicblokitem.h create mode 100644 blokitem/explodeblokitem.cpp create mode 100644 blokitem/explodeblokitem.h create mode 100644 blokitem/exploseblokitem.cpp create mode 100644 blokitem/exploseblokitem.h create mode 100644 blokitem/normalblokitem.cpp create mode 100644 blokitem/normalblokitem.h create mode 100644 blokitem/solidblokitem.cpp create mode 100644 blokitem/solidblokitem.h create mode 100644 blokitem/totemblokitem.cpp create mode 100644 blokitem/totemblokitem.h create mode 100644 boxitem.cpp create mode 100644 boxitem.h create mode 100644 data/sounds/explosion.wav create mode 100644 data/sprites.qrc create mode 100644 data/sprites/.directory create mode 100755 data/sprites/blue_ground.png create mode 100755 data/sprites/chimic_block.png create mode 100644 data/sprites/clanbomber.png create mode 100644 data/sprites/cloud.png create mode 100644 data/sprites/cursor.png create mode 100644 data/sprites/explode_block.png create mode 100644 data/sprites/explose.png create mode 100644 data/sprites/fire_wallpaper.png create mode 100755 data/sprites/green_ground.png create mode 100755 data/sprites/normal_block.png create mode 100755 data/sprites/red_ground.png create mode 100755 data/sprites/sky_wallpaper.png create mode 100755 data/sprites/solid_block.png create mode 100644 data/sprites/supermario_wallpaper.png create mode 100755 data/sprites/text05.png create mode 100755 data/sprites/text06.png create mode 100755 data/sprites/text07.png create mode 100755 data/sprites/totem1_block.png create mode 100755 data/sprites/totem2_block.png create mode 100755 data/sprites/totem3_block.png create mode 100644 main.cpp create mode 100644 mainwindow.cpp create mode 100644 mainwindow.h create mode 100644 physicsscene.cpp create mode 100644 physicsscene.h create mode 100644 totemblokitem.cpp create mode 100644 totemblokitem.h diff --git a/Box2D/CMakeLists.txt b/Box2D/CMakeLists.txt new file mode 100644 index 0000000..a2a89ce --- /dev/null +++ b/Box2D/CMakeLists.txt @@ -0,0 +1,3 @@ +project(kglengine) +add_subdirectory(Source) + diff --git a/Box2D/CMakeLists.txt~ b/Box2D/CMakeLists.txt~ new file mode 100644 index 0000000..121428f --- /dev/null +++ b/Box2D/CMakeLists.txt~ @@ -0,0 +1,12 @@ +project(kglengine) + +# FIND_PACKAGE(GLUT REQUIRED) +# FIND_PACKAGE(GLU REQUIRED) +# FIND_PACKAGE(OpenGL REQUIRED) + +add_subdirectory(Source) + + + +# INCLUDE_DIRECTORIES(${GLUT_INCLUDE_DIR} ${GLU_INCLUDE_DIR}) + diff --git a/Box2D/License.txt b/Box2D/License.txt new file mode 100644 index 0000000..65ba0dc --- /dev/null +++ b/Box2D/License.txt @@ -0,0 +1,18 @@ +Copyright (c) 2006-2007 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. + diff --git a/Box2D/Readme.txt b/Box2D/Readme.txt new file mode 100644 index 0000000..9ec1759 --- /dev/null +++ b/Box2D/Readme.txt @@ -0,0 +1,19 @@ +Box2D Version 2.0.1 + +Welcome to Box2D! + +Box2D is a 2D physics engine for games. + +For help with Box2D, please visit http://www.box2d.org. There is a forum there where you may post your questions. + +The project files with this distribution work with Microsoft Visual C++ 2005 and above. You can download MSVC 2008 for free and it includes the necessary Platform SDK. + +To run the demos, set "Testbed" as your startup project and press F5. Some test bed commands are: +- 'r' to reset the current test +- SPACE to launch a bomb +- arrow keys to pan +- 'x' and 'z' to zoom in/out +- use the mouse to click and drag objects + +Erin Catto +http://www.box2d.org diff --git a/Box2D/Source/Box2D.h b/Box2D/Source/Box2D.h new file mode 100644 index 0000000..ebdb75e --- /dev/null +++ b/Box2D/Source/Box2D.h @@ -0,0 +1,52 @@ +/* +* Copyright (c) 2006-2007 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 BOX2D_H +#define BOX2D_H + +/** +\mainpage Box2D API Documentation + +\section intro_sec Getting Started + +For tutorials please see http://www.box2d.org/manual.html + +For discussion please visit http://www.box2d.org/forum +*/ + +// These include files constitute the main Box2D API + +#include "Common/b2Settings.h" + +#include "Collision/Shapes/b2CircleShape.h" +#include "Collision/Shapes/b2PolygonShape.h" +#include "Collision/b2BroadPhase.h" +#include "Dynamics/b2WorldCallbacks.h" +#include "Dynamics/b2World.h" +#include "Dynamics/b2Body.h" + +#include "Dynamics/Contacts/b2Contact.h" + +#include "Dynamics/Joints/b2DistanceJoint.h" +#include "Dynamics/Joints/b2MouseJoint.h" +#include "Dynamics/Joints/b2PrismaticJoint.h" +#include "Dynamics/Joints/b2RevoluteJoint.h" +#include "Dynamics/Joints/b2PulleyJoint.h" +#include "Dynamics/Joints/b2GearJoint.h" + +#endif \ No newline at end of file diff --git a/Box2D/Source/CMakeLists.txt b/Box2D/Source/CMakeLists.txt new file mode 100644 index 0000000..dcb2484 --- /dev/null +++ b/Box2D/Source/CMakeLists.txt @@ -0,0 +1,40 @@ +set(SOURCES +./Common/b2StackAllocator.cpp +./Common/b2BlockAllocator.cpp +./Common/b2Settings.cpp +./Common/b2Math.cpp +./Collision/b2CollidePoly.cpp +./Collision/b2PairManager.cpp +./Collision/b2BroadPhase.cpp +./Collision/b2CollideCircle.cpp +./Collision/b2TimeOfImpact.cpp +./Collision/b2Distance.cpp +./Collision/Shapes/b2CircleShape.cpp +./Collision/Shapes/b2Shape.cpp +./Collision/Shapes/b2PolygonShape.cpp +./Collision/b2Collision.cpp +./Dynamics/Contacts/b2PolyContact.cpp +./Dynamics/Contacts/b2CircleContact.cpp +./Dynamics/Contacts/b2ContactSolver.cpp +./Dynamics/Contacts/b2PolyAndCircleContact.cpp +./Dynamics/Contacts/b2Contact.cpp +./Dynamics/b2Body.cpp +./Dynamics/Joints/b2Joint.cpp +./Dynamics/Joints/b2DistanceJoint.cpp +./Dynamics/Joints/b2RevoluteJoint.cpp +./Dynamics/Joints/b2PulleyJoint.cpp +./Dynamics/Joints/b2MouseJoint.cpp +./Dynamics/Joints/b2PrismaticJoint.cpp +./Dynamics/Joints/b2GearJoint.cpp +./Dynamics/b2Island.cpp +./Dynamics/b2ContactManager.cpp +./Dynamics/b2World.cpp +./Dynamics/b2WorldCallbacks.cpp +) + +add_library( Box2D STATIC ${SOURCES} ) + +if( CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64" ) +set_target_properties(Box2D PROPERTIES COMPILE_FLAGS "-fPIC") +endif( CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64" ) + diff --git a/Box2D/Source/Collision/Shapes/b2CircleShape.cpp b/Box2D/Source/Collision/Shapes/b2CircleShape.cpp new file mode 100644 index 0000000..3949628 --- /dev/null +++ b/Box2D/Source/Collision/Shapes/b2CircleShape.cpp @@ -0,0 +1,120 @@ +/* +* Copyright (c) 2006-2007 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. +*/ + +#include "b2CircleShape.h" + +b2CircleShape::b2CircleShape(const b2ShapeDef* def) +: b2Shape(def) +{ + b2Assert(def->type == e_circleShape); + const b2CircleDef* circleDef = (const b2CircleDef*)def; + + m_type = e_circleShape; + m_localPosition = circleDef->localPosition; + m_radius = circleDef->radius; +} + +void b2CircleShape::UpdateSweepRadius(const b2Vec2& center) +{ + // Update the sweep radius (maximum radius) as measured from + // a local center point. + b2Vec2 d = m_localPosition - center; + m_sweepRadius = d.Length() + m_radius - b2_toiSlop; +} + +bool b2CircleShape::TestPoint(const b2XForm& transform, const b2Vec2& p) const +{ + b2Vec2 center = transform.position + b2Mul(transform.R, m_localPosition); + b2Vec2 d = p - center; + return b2Dot(d, d) <= m_radius * m_radius; +} + +// Collision Detection in Interactive 3D Environments by Gino van den Bergen +// From Section 3.1.2 +// x = s + a * r +// norm(x) = radius +bool b2CircleShape::TestSegment(const b2XForm& transform, + float32* lambda, + b2Vec2* normal, + const b2Segment& segment, + float32 maxLambda) const +{ + b2Vec2 position = transform.position + b2Mul(transform.R, m_localPosition); + b2Vec2 s = segment.p1 - position; + float32 b = b2Dot(s, s) - m_radius * m_radius; + + // Does the segment start inside the circle? + if (b < 0.0f) + { + return false; + } + + // Solve quadratic equation. + b2Vec2 r = segment.p2 - segment.p1; + float32 c = b2Dot(s, r); + float32 rr = b2Dot(r, r); + float32 sigma = c * c - rr * b; + + // Check for negative discriminant and short segment. + if (sigma < 0.0f || rr < B2_FLT_EPSILON) + { + return false; + } + + // Find the point of intersection of the line with the circle. + float32 a = -(c + b2Sqrt(sigma)); + + // Is the intersection point on the segment? + if (0.0f <= a && a <= maxLambda * rr) + { + a /= rr; + *lambda = a; + *normal = s + a * r; + normal->Normalize(); + return true; + } + + return false; +} + +void b2CircleShape::ComputeAABB(b2AABB* aabb, const b2XForm& transform) const +{ + b2Vec2 p = transform.position + b2Mul(transform.R, m_localPosition); + aabb->lowerBound.Set(p.x - m_radius, p.y - m_radius); + aabb->upperBound.Set(p.x + m_radius, p.y + m_radius); +} + +void b2CircleShape::ComputeSweptAABB(b2AABB* aabb, const b2XForm& transform1, const b2XForm& transform2) const +{ + b2Vec2 p1 = transform1.position + b2Mul(transform1.R, m_localPosition); + b2Vec2 p2 = transform2.position + b2Mul(transform2.R, m_localPosition); + b2Vec2 lower = b2Min(p1, p2); + b2Vec2 upper = b2Max(p1, p2); + + aabb->lowerBound.Set(lower.x - m_radius, lower.y - m_radius); + aabb->upperBound.Set(upper.x + m_radius, upper.y + m_radius); +} + +void b2CircleShape::ComputeMass(b2MassData* massData) const +{ + massData->mass = m_density * b2_pi * m_radius * m_radius; + massData->center = m_localPosition; + + // inertia about the local origin + massData->I = massData->mass * (0.5f * m_radius * m_radius + b2Dot(m_localPosition, m_localPosition)); +} diff --git a/Box2D/Source/Collision/Shapes/b2CircleShape.h b/Box2D/Source/Collision/Shapes/b2CircleShape.h new file mode 100644 index 0000000..4ce35ef --- /dev/null +++ b/Box2D/Source/Collision/Shapes/b2CircleShape.h @@ -0,0 +1,92 @@ +/* +* Copyright (c) 2006-2007 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_CIRCLE_SHAPE_H +#define B2_CIRCLE_SHAPE_H + +#include "b2Shape.h" + +/// This structure is used to build circle shapes. +struct b2CircleDef : public b2ShapeDef +{ + b2CircleDef() + { + type = e_circleShape; + localPosition.SetZero(); + radius = 1.0f; + } + + b2Vec2 localPosition; + float32 radius; +}; + +/// A circle shape. +class b2CircleShape : public b2Shape +{ +public: + /// @see b2Shape::TestPoint + bool TestPoint(const b2XForm& transform, const b2Vec2& p) const; + + /// @see b2Shape::TestSegment + bool TestSegment( const b2XForm& transform, + float32* lambda, + b2Vec2* normal, + const b2Segment& segment, + float32 maxLambda) const; + + /// @see b2Shape::ComputeAABB + void ComputeAABB(b2AABB* aabb, const b2XForm& transform) const; + + /// @see b2Shape::ComputeSweptAABB + void ComputeSweptAABB( b2AABB* aabb, + const b2XForm& transform1, + const b2XForm& transform2) const; + + /// @see b2Shape::ComputeMass + void ComputeMass(b2MassData* massData) const; + + /// Get the local position of this circle in its parent body. + const b2Vec2& GetLocalPosition() const; + + /// Get the radius of this circle. + float32 GetRadius() const; + +private: + + friend class b2Shape; + + b2CircleShape(const b2ShapeDef* def); + + void UpdateSweepRadius(const b2Vec2& center); + + // Local position in parent body + b2Vec2 m_localPosition; + float32 m_radius; +}; + +inline const b2Vec2& b2CircleShape::GetLocalPosition() const +{ + return m_localPosition; +} + +inline float32 b2CircleShape::GetRadius() const +{ + return m_radius; +} + +#endif diff --git a/Box2D/Source/Collision/Shapes/b2PolygonShape.cpp b/Box2D/Source/Collision/Shapes/b2PolygonShape.cpp new file mode 100644 index 0000000..936fb51 --- /dev/null +++ b/Box2D/Source/Collision/Shapes/b2PolygonShape.cpp @@ -0,0 +1,449 @@ + +/* +* Copyright (c) 2006-2007 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. +*/ + +#include "b2PolygonShape.h" + +void b2PolygonDef::SetAsBox(float32 hx, float32 hy) +{ + vertexCount = 4; + vertices[0].Set(-hx, -hy); + vertices[1].Set( hx, -hy); + vertices[2].Set( hx, hy); + vertices[3].Set(-hx, hy); +} + +void b2PolygonDef::SetAsBox(float32 hx, float32 hy, const b2Vec2& center, float32 angle) +{ + SetAsBox(hx, hy); + b2XForm xf; + xf.position = center; + xf.R.Set(angle); + + for (int32 i = 0; i < vertexCount; ++i) + { + vertices[i] = b2Mul(xf, vertices[i]); + } +} + +static b2Vec2 ComputeCentroid(const b2Vec2* vs, int32 count) +{ + b2Assert(count >= 3); + + b2Vec2 c; c.Set(0.0f, 0.0f); + float32 area = 0.0f; + + // pRef is the reference point for forming triangles. + // It's location doesn't change the result (except for rounding error). + b2Vec2 pRef(0.0f, 0.0f); +#if 0 + // This code would put the reference point inside the polygon. + for (int32 i = 0; i < count; ++i) + { + pRef += vs[i]; + } + pRef *= 1.0f / count; +#endif + + const float32 inv3 = 1.0f / 3.0f; + + for (int32 i = 0; i < count; ++i) + { + // Triangle vertices. + b2Vec2 p1 = pRef; + b2Vec2 p2 = vs[i]; + b2Vec2 p3 = i + 1 < count ? vs[i+1] : vs[0]; + + b2Vec2 e1 = p2 - p1; + b2Vec2 e2 = p3 - p1; + + float32 D = b2Cross(e1, e2); + + float32 triangleArea = 0.5f * D; + area += triangleArea; + + // Area weighted centroid + c += triangleArea * inv3 * (p1 + p2 + p3); + } + + // Centroid + b2Assert(area > B2_FLT_EPSILON); + c *= 1.0f / area; + return c; +} + +// http://www.geometrictools.com/Documentation/MinimumAreaRectangle.pdf +static void ComputeOBB(b2OBB* obb, const b2Vec2* vs, int32 count) +{ + b2Assert(count <= b2_maxPolygonVertices); + b2Vec2 p[b2_maxPolygonVertices + 1]; + for (int32 i = 0; i < count; ++i) + { + p[i] = vs[i]; + } + p[count] = p[0]; + + float32 minArea = B2_FLT_MAX; + + for (int32 i = 1; i <= count; ++i) + { + b2Vec2 root = p[i-1]; + b2Vec2 ux = p[i] - root; + float32 length = ux.Normalize(); + b2Assert(length > B2_FLT_EPSILON); + b2Vec2 uy(-ux.y, ux.x); + b2Vec2 lower(B2_FLT_MAX, B2_FLT_MAX); + b2Vec2 upper(-B2_FLT_MAX, -B2_FLT_MAX); + + for (int32 j = 0; j < count; ++j) + { + b2Vec2 d = p[j] - root; + b2Vec2 r; + r.x = b2Dot(ux, d); + r.y = b2Dot(uy, d); + lower = b2Min(lower, r); + upper = b2Max(upper, r); + } + + float32 area = (upper.x - lower.x) * (upper.y - lower.y); + if (area < 0.95f * minArea) + { + minArea = area; + obb->R.col1 = ux; + obb->R.col2 = uy; + b2Vec2 center = 0.5f * (lower + upper); + obb->center = root + b2Mul(obb->R, center); + obb->extents = 0.5f * (upper - lower); + } + } + + b2Assert(minArea < B2_FLT_MAX); +} + +b2PolygonShape::b2PolygonShape(const b2ShapeDef* def) + : b2Shape(def) +{ + b2Assert(def->type == e_polygonShape); + m_type = e_polygonShape; + const b2PolygonDef* poly = (const b2PolygonDef*)def; + + // Get the vertices transformed into the body frame. + m_vertexCount = poly->vertexCount; + b2Assert(3 <= m_vertexCount && m_vertexCount <= b2_maxPolygonVertices); + + // Copy vertices. + for (int32 i = 0; i < m_vertexCount; ++i) + { + m_vertices[i] = poly->vertices[i]; + } + + // Compute normals. Ensure the edges have non-zero length. + for (int32 i = 0; i < m_vertexCount; ++i) + { + int32 i1 = i; + int32 i2 = i + 1 < m_vertexCount ? i + 1 : 0; + b2Vec2 edge = m_vertices[i2] - m_vertices[i1]; + b2Assert(edge.LengthSquared() > B2_FLT_EPSILON * B2_FLT_EPSILON); + m_normals[i] = b2Cross(edge, 1.0f); + m_normals[i].Normalize(); + } + +#ifdef _DEBUG + // Ensure the polygon is convex. + for (int32 i = 0; i < m_vertexCount; ++i) + { + for (int32 j = 0; j < m_vertexCount; ++j) + { + // Don't check vertices on the current edge. + if (j == i || j == (i + 1) % m_vertexCount) + { + continue; + } + + // Your polygon is non-convex (it has an indentation). + // Or your polygon is too skinny. + float32 s = b2Dot(m_normals[i], m_vertices[j] - m_vertices[i]); + b2Assert(s < -b2_linearSlop); + } + } + + // Ensure the polygon is counter-clockwise. + for (int32 i = 1; i < m_vertexCount; ++i) + { + float32 cross = b2Cross(m_normals[i-1], m_normals[i]); + + // Keep asinf happy. + cross = b2Clamp(cross, -1.0f, 1.0f); + + // You have consecutive edges that are almost parallel on your polygon. + float32 angle = asinf(cross); + b2Assert(angle > b2_angularSlop); + } +#endif + + // Compute the polygon centroid. + m_centroid = ComputeCentroid(poly->vertices, poly->vertexCount); + + // Compute the oriented bounding box. + ComputeOBB(&m_obb, m_vertices, m_vertexCount); + + // Create core polygon shape by shifting edges inward. + // Also compute the min/max radius for CCD. + for (int32 i = 0; i < m_vertexCount; ++i) + { + int32 i1 = i - 1 >= 0 ? i - 1 : m_vertexCount - 1; + int32 i2 = i; + + b2Vec2 n1 = m_normals[i1]; + b2Vec2 n2 = m_normals[i2]; + b2Vec2 v = m_vertices[i] - m_centroid;; + + b2Vec2 d; + d.x = b2Dot(n1, v) - b2_toiSlop; + d.y = b2Dot(n2, v) - b2_toiSlop; + + // Shifting the edge inward by b2_toiSlop should + // not cause the plane to pass the centroid. + + // Your shape has a radius/extent less than b2_toiSlop. + b2Assert(d.x >= 0.0f); + b2Assert(d.y >= 0.0f); + b2Mat22 A; + A.col1.x = n1.x; A.col2.x = n1.y; + A.col1.y = n2.x; A.col2.y = n2.y; + m_coreVertices[i] = A.Solve(d) + m_centroid; + } +} + +void b2PolygonShape::UpdateSweepRadius(const b2Vec2& center) +{ + // Update the sweep radius (maximum radius) as measured from + // a local center point. + m_sweepRadius = 0.0f; + for (int32 i = 0; i < m_vertexCount; ++i) + { + b2Vec2 d = m_coreVertices[i] - center; + m_sweepRadius = b2Max(m_sweepRadius, d.Length()); + } +} + +bool b2PolygonShape::TestPoint(const b2XForm& xf, const b2Vec2& p) const +{ + b2Vec2 pLocal = b2MulT(xf.R, p - xf.position); + + for (int32 i = 0; i < m_vertexCount; ++i) + { + float32 dot = b2Dot(m_normals[i], pLocal - m_vertices[i]); + if (dot > 0.0f) + { + return false; + } + } + + return true; +} + +bool b2PolygonShape::TestSegment( + const b2XForm& xf, + float32* lambda, + b2Vec2* normal, + const b2Segment& segment, + float32 maxLambda) const +{ + float32 lower = 0.0f, upper = maxLambda; + + b2Vec2 p1 = b2MulT(xf.R, segment.p1 - xf.position); + b2Vec2 p2 = b2MulT(xf.R, segment.p2 - xf.position); + b2Vec2 d = p2 - p1; + int32 index = -1; + + for (int32 i = 0; i < m_vertexCount; ++i) + { + // p = p1 + a * d + // dot(normal, p - v) = 0 + // dot(normal, p1 - v) + a * dot(normal, d) = 0 + float32 numerator = b2Dot(m_normals[i], m_vertices[i] - p1); + float32 denominator = b2Dot(m_normals[i], d); + + // Note: we want this predicate without division: + // lower < numerator / denominator, where denominator < 0 + // Since denominator < 0, we have to flip the inequality: + // lower < numerator / denominator <==> denominator * lower > numerator. + + if (denominator < 0.0f && numerator < lower * denominator) + { + // Increase lower. + // The segment enters this half-space. + lower = numerator / denominator; + index = i; + } + else if (denominator > 0.0f && numerator < upper * denominator) + { + // Decrease upper. + // The segment exits this half-space. + upper = numerator / denominator; + } + + if (upper < lower) + { + return false; + } + } + + b2Assert(0.0f <= lower && lower <= maxLambda); + + if (index >= 0) + { + *lambda = lower; + *normal = b2Mul(xf.R, m_normals[index]); + return true; + } + + return false; +} + +void b2PolygonShape::ComputeAABB(b2AABB* aabb, const b2XForm& xf) const +{ + b2Mat22 R = b2Mul(xf.R, m_obb.R); + b2Mat22 absR = b2Abs(R); + b2Vec2 h = b2Mul(absR, m_obb.extents); + b2Vec2 position = xf.position + b2Mul(xf.R, m_obb.center); + aabb->lowerBound = position - h; + aabb->upperBound = position + h; +} + +void b2PolygonShape::ComputeSweptAABB(b2AABB* aabb, + const b2XForm& transform1, + const b2XForm& transform2) const +{ + b2AABB aabb1, aabb2; + ComputeAABB(&aabb1, transform1); + ComputeAABB(&aabb2, transform2); + aabb->lowerBound = b2Min(aabb1.lowerBound, aabb2.lowerBound); + aabb->upperBound = b2Max(aabb1.upperBound, aabb2.upperBound); +} + +void b2PolygonShape::ComputeMass(b2MassData* massData) const +{ + // Polygon mass, centroid, and inertia. + // Let rho be the polygon density in mass per unit area. + // Then: + // mass = rho * int(dA) + // centroid.x = (1/mass) * rho * int(x * dA) + // centroid.y = (1/mass) * rho * int(y * dA) + // I = rho * int((x*x + y*y) * dA) + // + // We can compute these integrals by summing all the integrals + // for each triangle of the polygon. To evaluate the integral + // for a single triangle, we make a change of variables to + // the (u,v) coordinates of the triangle: + // x = x0 + e1x * u + e2x * v + // y = y0 + e1y * u + e2y * v + // where 0 <= u && 0 <= v && u + v <= 1. + // + // We integrate u from [0,1-v] and then v from [0,1]. + // We also need to use the Jacobian of the transformation: + // D = cross(e1, e2) + // + // Simplification: triangle centroid = (1/3) * (p1 + p2 + p3) + // + // The rest of the derivation is handled by computer algebra. + + b2Assert(m_vertexCount >= 3); + + b2Vec2 center; center.Set(0.0f, 0.0f); + float32 area = 0.0f; + float32 I = 0.0f; + + // pRef is the reference point for forming triangles. + // It's location doesn't change the result (except for rounding error). + b2Vec2 pRef(0.0f, 0.0f); +#if 0 + // This code would put the reference point inside the polygon. + for (int32 i = 0; i < m_vertexCount; ++i) + { + pRef += m_vertices[i]; + } + pRef *= 1.0f / count; +#endif + + const float32 k_inv3 = 1.0f / 3.0f; + + for (int32 i = 0; i < m_vertexCount; ++i) + { + // Triangle vertices. + b2Vec2 p1 = pRef; + b2Vec2 p2 = m_vertices[i]; + b2Vec2 p3 = i + 1 < m_vertexCount ? m_vertices[i+1] : m_vertices[0]; + + b2Vec2 e1 = p2 - p1; + b2Vec2 e2 = p3 - p1; + + float32 D = b2Cross(e1, e2); + + float32 triangleArea = 0.5f * D; + area += triangleArea; + + // Area weighted centroid + center += triangleArea * k_inv3 * (p1 + p2 + p3); + + float32 px = p1.x, py = p1.y; + float32 ex1 = e1.x, ey1 = e1.y; + float32 ex2 = e2.x, ey2 = e2.y; + + float32 intx2 = k_inv3 * (0.25f * (ex1*ex1 + ex2*ex1 + ex2*ex2) + (px*ex1 + px*ex2)) + 0.5f*px*px; + float32 inty2 = k_inv3 * (0.25f * (ey1*ey1 + ey2*ey1 + ey2*ey2) + (py*ey1 + py*ey2)) + 0.5f*py*py; + + I += D * (intx2 + inty2); + } + + // Total mass + massData->mass = m_density * area; + + // Center of mass + b2Assert(area > B2_FLT_EPSILON); + center *= 1.0f / area; + massData->center = center; + + // Inertia tensor relative to the local origin. + massData->I = m_density * I; +} + +b2Vec2 b2PolygonShape::Centroid(const b2XForm& xf) const +{ + return b2Mul(xf, m_centroid); +} + +b2Vec2 b2PolygonShape::Support(const b2XForm& xf, const b2Vec2& d) const +{ + b2Vec2 dLocal = b2MulT(xf.R, d); + + int32 bestIndex = 0; + float32 bestValue = b2Dot(m_coreVertices[0], dLocal); + for (int32 i = 1; i < m_vertexCount; ++i) + { + float32 value = b2Dot(m_coreVertices[i], dLocal); + if (value > bestValue) + { + bestIndex = i; + bestValue = value; + } + } + + return b2Mul(xf, m_coreVertices[bestIndex]); +} diff --git a/Box2D/Source/Collision/Shapes/b2PolygonShape.h b/Box2D/Source/Collision/Shapes/b2PolygonShape.h new file mode 100644 index 0000000..20834ce --- /dev/null +++ b/Box2D/Source/Collision/Shapes/b2PolygonShape.h @@ -0,0 +1,163 @@ +/* +* Copyright (c) 2006-2007 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_POLYGON_SHAPE_H +#define B2_POLYGON_SHAPE_H + +#include "b2Shape.h" + +/// Convex polygon. The vertices must be in CCW order for a right-handed +/// coordinate system with the z-axis coming out of the screen. +struct b2PolygonDef : public b2ShapeDef +{ + b2PolygonDef() + { + type = e_polygonShape; + vertexCount = 0; + } + + /// Build vertices to represent an axis-aligned box. + /// @param hx the half-width. + /// @param hy the half-height. + void SetAsBox(float32 hx, float32 hy); + + /// Build vertices to represent an oriented box. + /// @param hx the half-width. + /// @param hy the half-height. + /// @param center the center of the box in local coordinates. + /// @param angle the rotation of the box in local coordinates. + void SetAsBox(float32 hx, float32 hy, const b2Vec2& center, float32 angle); + + /// The polygon vertices in local coordinates. + b2Vec2 vertices[b2_maxPolygonVertices]; + + /// The number of polygon vertices. + int32 vertexCount; +}; + + +/// A convex polygon. +class b2PolygonShape : public b2Shape +{ +public: + /// @see b2Shape::TestPoint + bool TestPoint(const b2XForm& transform, const b2Vec2& p) const; + + /// @see b2Shape::TestSegment + bool TestSegment( const b2XForm& transform, + float32* lambda, + b2Vec2* normal, + const b2Segment& segment, + float32 maxLambda) const; + + /// @see b2Shape::ComputeAABB + void ComputeAABB(b2AABB* aabb, const b2XForm& transform) const; + + /// @see b2Shape::ComputeSweptAABB + void ComputeSweptAABB( b2AABB* aabb, + const b2XForm& transform1, + const b2XForm& transform2) const; + + /// @see b2Shape::ComputeMass + void ComputeMass(b2MassData* massData) const; + + /// Get the oriented bounding box relative to the parent body. + const b2OBB& GetOBB() const; + + /// Get local centroid relative to the parent body. + const b2Vec2& GetCentroid() const; + + /// Get the vertex count. + int32 GetVertexCount() const; + + /// Get the vertices in local coordinates. + const b2Vec2* GetVertices() const; + + /// Get the core vertices in local coordinates. These vertices + /// represent a smaller polygon that is used for time of impact + /// computations. + const b2Vec2* GetCoreVertices() const; + + /// Get the edge normal vectors. There is one for each vertex. + const b2Vec2* GetNormals() const; + + /// Get the first vertex and apply the supplied transform. + b2Vec2 GetFirstVertex(const b2XForm& xf) const; + + /// Get the centroid and apply the supplied transform. + b2Vec2 Centroid(const b2XForm& xf) const; + + /// Get the support point in the given world direction. + /// Use the supplied transform. + b2Vec2 Support(const b2XForm& xf, const b2Vec2& d) const; + +private: + + friend class b2Shape; + + b2PolygonShape(const b2ShapeDef* def); + + void UpdateSweepRadius(const b2Vec2& center); + + // Local position of the polygon centroid. + b2Vec2 m_centroid; + + b2OBB m_obb; + + b2Vec2 m_vertices[b2_maxPolygonVertices]; + b2Vec2 m_normals[b2_maxPolygonVertices]; + b2Vec2 m_coreVertices[b2_maxPolygonVertices]; + int32 m_vertexCount; +}; + +inline b2Vec2 b2PolygonShape::GetFirstVertex(const b2XForm& xf) const +{ + return b2Mul(xf, m_coreVertices[0]); +} + +inline const b2OBB& b2PolygonShape::GetOBB() const +{ + return m_obb; +} + +inline const b2Vec2& b2PolygonShape::GetCentroid() const +{ + return m_centroid; +} + +inline int32 b2PolygonShape::GetVertexCount() const +{ + return m_vertexCount; +} + +inline const b2Vec2* b2PolygonShape::GetVertices() const +{ + return m_vertices; +} + +inline const b2Vec2* b2PolygonShape::GetCoreVertices() const +{ + return m_coreVertices; +} + +inline const b2Vec2* b2PolygonShape::GetNormals() const +{ + return m_normals; +} + +#endif diff --git a/Box2D/Source/Collision/Shapes/b2Shape.cpp b/Box2D/Source/Collision/Shapes/b2Shape.cpp new file mode 100644 index 0000000..e11b4fa --- /dev/null +++ b/Box2D/Source/Collision/Shapes/b2Shape.cpp @@ -0,0 +1,167 @@ +/* +* Copyright (c) 2006-2007 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. +*/ + +#include "b2Shape.h" +#include "b2CircleShape.h" +#include "b2PolygonShape.h" +#include "../b2Collision.h" +#include "../b2BroadPhase.h" +#include "../../Common/b2BlockAllocator.h" + +#include + +b2Shape* b2Shape::Create(const b2ShapeDef* def, b2BlockAllocator* allocator) +{ + switch (def->type) + { + case e_circleShape: + { + void* mem = allocator->Allocate(sizeof(b2CircleShape)); + return new (mem) b2CircleShape(def); + } + + case e_polygonShape: + { + void* mem = allocator->Allocate(sizeof(b2PolygonShape)); + return new (mem) b2PolygonShape(def); + } + + default: + b2Assert(false); + return NULL; + } +} + +void b2Shape::Destroy(b2Shape* s, b2BlockAllocator* allocator) +{ + switch (s->GetType()) + { + case e_circleShape: + s->~b2Shape(); + allocator->Free(s, sizeof(b2CircleShape)); + break; + + case e_polygonShape: + s->~b2Shape(); + allocator->Free(s, sizeof(b2PolygonShape)); + break; + + default: + b2Assert(false); + } +} + +b2Shape::b2Shape(const b2ShapeDef* def) +{ + m_userData = def->userData; + m_friction = def->friction; + m_restitution = def->restitution; + m_density = def->density; + m_body = NULL; + m_sweepRadius = 0.0f; + + m_next = NULL; + + m_proxyId = b2_nullProxy; + + m_filter = def->filter; + + m_isSensor = def->isSensor; +} + +b2Shape::~b2Shape() +{ + b2Assert(m_proxyId == b2_nullProxy); +} + +void b2Shape::CreateProxy(b2BroadPhase* broadPhase, const b2XForm& transform) +{ + b2Assert(m_proxyId == b2_nullProxy); + + b2AABB aabb; + ComputeAABB(&aabb, transform); + + bool inRange = broadPhase->InRange(aabb); + + // You are creating a shape outside the world box. + b2Assert(inRange); + + if (inRange) + { + m_proxyId = broadPhase->CreateProxy(aabb, this); + } + else + { + m_proxyId = b2_nullProxy; + } +} + +void b2Shape::DestroyProxy(b2BroadPhase* broadPhase) +{ + if (m_proxyId != b2_nullProxy) + { + broadPhase->DestroyProxy(m_proxyId); + m_proxyId = b2_nullProxy; + } +} + +bool b2Shape::Synchronize(b2BroadPhase* broadPhase, const b2XForm& transform1, const b2XForm& transform2) +{ + if (m_proxyId == b2_nullProxy) + { + return false; + } + + // Compute an AABB that covers the swept shape (may miss some rotation effect). + b2AABB aabb; + ComputeSweptAABB(&aabb, transform1, transform2); + + if (broadPhase->InRange(aabb)) + { + broadPhase->MoveProxy(m_proxyId, aabb); + return true; + } + else + { + return false; + } +} + +void b2Shape::RefilterProxy(b2BroadPhase* broadPhase, const b2XForm& transform) +{ + if (m_proxyId == b2_nullProxy) + { + return; + } + + broadPhase->DestroyProxy(m_proxyId); + + b2AABB aabb; + ComputeAABB(&aabb, transform); + + bool inRange = broadPhase->InRange(aabb); + + if (inRange) + { + m_proxyId = broadPhase->CreateProxy(aabb, this); + } + else + { + m_proxyId = b2_nullProxy; + } +} diff --git a/Box2D/Source/Collision/Shapes/b2Shape.h b/Box2D/Source/Collision/Shapes/b2Shape.h new file mode 100644 index 0000000..a55a0e4 --- /dev/null +++ b/Box2D/Source/Collision/Shapes/b2Shape.h @@ -0,0 +1,285 @@ +/* +* Copyright (c) 2006-2007 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_SHAPE_H +#define B2_SHAPE_H + +#include "../../Common/b2Math.h" +#include "../b2Collision.h" + +class b2BlockAllocator; +class b2Body; +class b2BroadPhase; + +/// This holds the mass data computed for a shape. +struct b2MassData +{ + /// The mass of the shape, usually in kilograms. + float32 mass; + + /// The position of the shape's centroid relative to the shape's origin. + b2Vec2 center; + + /// The rotational inertia of the shape. + float32 I; +}; + +/// This holds contact filtering data. +struct b2FilterData +{ + /// The collision category bits. Normally you would just set one bit. + uint16 categoryBits; + + /// The collision mask bits. This states the categories that this + /// shape would accept for collision. + uint16 maskBits; + + /// Collision groups allow a certain group of objects to never collide (negative) + /// or always collide (positive). Zero means no collision group. Non-zero group + /// filtering always wins against the mask bits. + int16 groupIndex; +}; + +/// The various collision shape types supported by Box2D. +enum b2ShapeType +{ + e_unknownShape = -1, + e_circleShape, + e_polygonShape, + e_shapeTypeCount, +}; + +/// A shape definition is used to construct a shape. This class defines an +/// abstract shape definition. You can reuse shape definitions safely. +struct b2ShapeDef +{ + /// The constructor sets the default shape definition values. + b2ShapeDef() + { + type = e_unknownShape; + userData = NULL; + friction = 0.2f; + restitution = 0.0f; + density = 0.0f; + filter.categoryBits = 0x0001; + filter.maskBits = 0xFFFF; + filter.groupIndex = 0; + isSensor = false; + } + + virtual ~b2ShapeDef() {} + + /// Holds the shape type for down-casting. + b2ShapeType type; + + /// Use this to store application specify shape data. + void* userData; + + /// The shape's friction coefficient, usually in the range [0,1]. + float32 friction; + + /// The shape's restitution (elasticity) usually in the range [0,1]. + float32 restitution; + + /// The shape's density, usually in kg/m^2. + float32 density; + + /// A sensor shape collects contact information but never generates a collision + /// response. + bool isSensor; + + /// Contact filtering data. + b2FilterData filter; +}; + +/// A shape is used for collision detection. Shapes are created in b2World. +/// You can use shape for collision detection before they are attached to the world. +/// @warning you cannot reuse shapes. +class b2Shape +{ +public: + /// Get the type of this shape. You can use this to down cast to the concrete shape. + /// @return the shape type. + b2ShapeType GetType() const; + + /// Is this shape a sensor (non-solid)? + /// @return the true if the shape is a sensor. + bool IsSensor() const; + + /// Set the contact filtering data. You must call b2World::Refilter to correct + /// existing contacts/non-contacts. + void SetFilterData(const b2FilterData& filter); + + /// Get the contact filtering data. + const b2FilterData& GetFilterData() const; + + /// Get the parent body of this shape. This is NULL if the shape is not attached. + /// @return the parent body. + b2Body* GetBody(); + + /// Get the next shape in the parent body's shape list. + /// @return the next shape. + b2Shape* GetNext(); + + /// Get the user data that was assigned in the shape definition. Use this to + /// store your application specific data. + void* GetUserData(); + + /// Set the user data. Use this to store your application specific data. + void SetUserData(void* data); + + /// Test a point for containment in this shape. This only works for convex shapes. + /// @param xf the shape world transform. + /// @param p a point in world coordinates. + virtual bool TestPoint(const b2XForm& xf, const b2Vec2& p) const = 0; + + /// Perform a ray cast against this shape. + /// @param xf the shape world transform. + /// @param lambda returns the hit fraction. You can use this to compute the contact point + /// p = (1 - lambda) * segment.p1 + lambda * segment.p2. + /// @param normal returns the normal at the contact point. If there is no intersection, the normal + /// is not set. + /// @param segment defines the begin and end point of the ray cast. + /// @param maxLambda a number typically in the range [0,1]. + /// @return true if there was an intersection. + virtual bool TestSegment( const b2XForm& xf, + float32* lambda, + b2Vec2* normal, + const b2Segment& segment, + float32 maxLambda) const = 0; + + /// Given a transform, compute the associated axis aligned bounding box for this shape. + /// @param aabb returns the axis aligned box. + /// @param xf the world transform of the shape. + virtual void ComputeAABB(b2AABB* aabb, const b2XForm& xf) const = 0; + + /// Given two transforms, compute the associated swept axis aligned bounding box for this shape. + /// @param aabb returns the axis aligned box. + /// @param xf1 the starting shape world transform. + /// @param xf2 the ending shape world transform. + virtual void ComputeSweptAABB( b2AABB* aabb, + const b2XForm& xf1, + const b2XForm& xf2) const = 0; + + /// Compute the mass properties of this shape using its dimensions and density. + /// The inertia tensor is computed about the local origin, not the centroid. + /// @param massData returns the mass data for this shape. + virtual void ComputeMass(b2MassData* massData) const = 0; + + /// Get the maximum radius about the parent body's center of mass. + float32 GetSweepRadius() const; + + /// Get the coefficient of friction. + float32 GetFriction() const; + + /// Get the coefficient of restitution. + float32 GetRestitution() const; + +protected: + + friend class b2Body; + friend class b2World; + + static b2Shape* Create(const b2ShapeDef* def, b2BlockAllocator* allocator); + static void Destroy(b2Shape* shape, b2BlockAllocator* allocator); + + b2Shape(const b2ShapeDef* def); + virtual ~b2Shape(); + + void CreateProxy(b2BroadPhase* broadPhase, const b2XForm& xf); + void DestroyProxy(b2BroadPhase* broadPhase); + bool Synchronize(b2BroadPhase* broadPhase, const b2XForm& xf1, const b2XForm& xf2); + void RefilterProxy(b2BroadPhase* broadPhase, const b2XForm& xf); + + virtual void UpdateSweepRadius(const b2Vec2& center) = 0; + + b2ShapeType m_type; + b2Shape* m_next; + b2Body* m_body; + + // Sweep radius relative to the parent body's center of mass. + float32 m_sweepRadius; + + float32 m_density; + float32 m_friction; + float32 m_restitution; + + uint16 m_proxyId; + b2FilterData m_filter; + + bool m_isSensor; + + void* m_userData; +}; + +inline b2ShapeType b2Shape::GetType() const +{ + return m_type; +} + +inline bool b2Shape::IsSensor() const +{ + return m_isSensor; +} + +inline void b2Shape::SetFilterData(const b2FilterData& filter) +{ + m_filter = filter; +} + +inline const b2FilterData& b2Shape::GetFilterData() const +{ + return m_filter; +} + +inline void* b2Shape::GetUserData() +{ + return m_userData; +} + +inline void b2Shape::SetUserData(void* data) +{ + m_userData = data; +} + +inline b2Body* b2Shape::GetBody() +{ + return m_body; +} + +inline b2Shape* b2Shape::GetNext() +{ + return m_next; +} + +inline float32 b2Shape::GetSweepRadius() const +{ + return m_sweepRadius; +} + +inline float32 b2Shape::GetFriction() const +{ + return m_friction; +} + +inline float32 b2Shape::GetRestitution() const +{ + return m_restitution; +} + +#endif diff --git a/Box2D/Source/Collision/b2BroadPhase.cpp b/Box2D/Source/Collision/b2BroadPhase.cpp new file mode 100644 index 0000000..007cc10 --- /dev/null +++ b/Box2D/Source/Collision/b2BroadPhase.cpp @@ -0,0 +1,668 @@ +/* +* Copyright (c) 2006-2007 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. +*/ + +#include "b2BroadPhase.h" +#include +#include + +// Notes: +// - we use bound arrays instead of linked lists for cache coherence. +// - we use quantized integral values for fast compares. +// - we use short indices rather than pointers to save memory. +// - we use a stabbing count for fast overlap queries (less than order N). +// - we also use a time stamp on each proxy to speed up the registration of +// overlap query results. +// - where possible, we compare bound indices instead of values to reduce +// cache misses (TODO_ERIN). +// - no broadphase is perfect and neither is this one: it is not great for huge +// worlds (use a multi-SAP instead), it is not great for large objects. + +bool b2BroadPhase::s_validate = false; + +struct b2BoundValues +{ + uint16 lowerValues[2]; + uint16 upperValues[2]; +}; + +static int32 BinarySearch(b2Bound* bounds, int32 count, uint16 value) +{ + int32 low = 0; + int32 high = count - 1; + while (low <= high) + { + int32 mid = (low + high) >> 1; + if (bounds[mid].value > value) + { + high = mid - 1; + } + else if (bounds[mid].value < value) + { + low = mid + 1; + } + else + { + return (uint16)mid; + } + } + + return low; +} + +b2BroadPhase::b2BroadPhase(const b2AABB& worldAABB, b2PairCallback* callback) +{ + m_pairManager.Initialize(this, callback); + + b2Assert(worldAABB.IsValid()); + m_worldAABB = worldAABB; + m_proxyCount = 0; + + b2Vec2 d = worldAABB.upperBound - worldAABB.lowerBound; + m_quantizationFactor.x = float32(B2BROADPHASE_MAX) / d.x; + m_quantizationFactor.y = float32(B2BROADPHASE_MAX) / d.y; + + for (uint16 i = 0; i < b2_maxProxies - 1; ++i) + { + m_proxyPool[i].SetNext(i + 1); + m_proxyPool[i].timeStamp = 0; + m_proxyPool[i].overlapCount = b2_invalid; + m_proxyPool[i].userData = NULL; + } + m_proxyPool[b2_maxProxies-1].SetNext(b2_nullProxy); + m_proxyPool[b2_maxProxies-1].timeStamp = 0; + m_proxyPool[b2_maxProxies-1].overlapCount = b2_invalid; + m_proxyPool[b2_maxProxies-1].userData = NULL; + m_freeProxy = 0; + + m_timeStamp = 1; + m_queryResultCount = 0; +} + +b2BroadPhase::~b2BroadPhase() +{ +} + +// This one is only used for validation. +bool b2BroadPhase::TestOverlap(b2Proxy* p1, b2Proxy* p2) +{ + for (int32 axis = 0; axis < 2; ++axis) + { + b2Bound* bounds = m_bounds[axis]; + + b2Assert(p1->lowerBounds[axis] < 2 * m_proxyCount); + b2Assert(p1->upperBounds[axis] < 2 * m_proxyCount); + b2Assert(p2->lowerBounds[axis] < 2 * m_proxyCount); + b2Assert(p2->upperBounds[axis] < 2 * m_proxyCount); + + if (bounds[p1->lowerBounds[axis]].value > bounds[p2->upperBounds[axis]].value) + return false; + + if (bounds[p1->upperBounds[axis]].value < bounds[p2->lowerBounds[axis]].value) + return false; + } + + return true; +} + +bool b2BroadPhase::TestOverlap(const b2BoundValues& b, b2Proxy* p) +{ + for (int32 axis = 0; axis < 2; ++axis) + { + b2Bound* bounds = m_bounds[axis]; + + b2Assert(p->lowerBounds[axis] < 2 * m_proxyCount); + b2Assert(p->upperBounds[axis] < 2 * m_proxyCount); + + if (b.lowerValues[axis] > bounds[p->upperBounds[axis]].value) + return false; + + if (b.upperValues[axis] < bounds[p->lowerBounds[axis]].value) + return false; + } + + return true; +} + +void b2BroadPhase::ComputeBounds(uint16* lowerValues, uint16* upperValues, const b2AABB& aabb) +{ + b2Assert(aabb.upperBound.x > aabb.lowerBound.x); + b2Assert(aabb.upperBound.y > aabb.lowerBound.y); + + b2Vec2 minVertex = b2Clamp(aabb.lowerBound, m_worldAABB.lowerBound, m_worldAABB.upperBound); + b2Vec2 maxVertex = b2Clamp(aabb.upperBound, m_worldAABB.lowerBound, m_worldAABB.upperBound); + + // Bump lower bounds downs and upper bounds up. This ensures correct sorting of + // lower/upper bounds that would have equal values. + // TODO_ERIN implement fast float to uint16 conversion. + lowerValues[0] = (uint16)(m_quantizationFactor.x * (minVertex.x - m_worldAABB.lowerBound.x)) & (B2BROADPHASE_MAX - 1); + upperValues[0] = (uint16)(m_quantizationFactor.x * (maxVertex.x - m_worldAABB.lowerBound.x)) | 1; + + lowerValues[1] = (uint16)(m_quantizationFactor.y * (minVertex.y - m_worldAABB.lowerBound.y)) & (B2BROADPHASE_MAX - 1); + upperValues[1] = (uint16)(m_quantizationFactor.y * (maxVertex.y - m_worldAABB.lowerBound.y)) | 1; +} + +void b2BroadPhase::IncrementTimeStamp() +{ + if (m_timeStamp == B2BROADPHASE_MAX) + { + for (uint16 i = 0; i < b2_maxProxies; ++i) + { + m_proxyPool[i].timeStamp = 0; + } + m_timeStamp = 1; + } + else + { + ++m_timeStamp; + } +} + +void b2BroadPhase::IncrementOverlapCount(int32 proxyId) +{ + b2Proxy* proxy = m_proxyPool + proxyId; + if (proxy->timeStamp < m_timeStamp) + { + proxy->timeStamp = m_timeStamp; + proxy->overlapCount = 1; + } + else + { + proxy->overlapCount = 2; + b2Assert(m_queryResultCount < b2_maxProxies); + m_queryResults[m_queryResultCount] = (uint16)proxyId; + ++m_queryResultCount; + } +} + +void b2BroadPhase::Query(int32* lowerQueryOut, int32* upperQueryOut, + uint16 lowerValue, uint16 upperValue, + b2Bound* bounds, int32 boundCount, int32 axis) +{ + int32 lowerQuery = BinarySearch(bounds, boundCount, lowerValue); + int32 upperQuery = BinarySearch(bounds, boundCount, upperValue); + + // Easy case: lowerQuery <= lowerIndex(i) < upperQuery + // Solution: search query range for min bounds. + for (int32 i = lowerQuery; i < upperQuery; ++i) + { + if (bounds[i].IsLower()) + { + IncrementOverlapCount(bounds[i].proxyId); + } + } + + // Hard case: lowerIndex(i) < lowerQuery < upperIndex(i) + // Solution: use the stabbing count to search down the bound array. + if (lowerQuery > 0) + { + int32 i = lowerQuery - 1; + int32 s = bounds[i].stabbingCount; + + // Find the s overlaps. + while (s) + { + b2Assert(i >= 0); + + if (bounds[i].IsLower()) + { + b2Proxy* proxy = m_proxyPool + bounds[i].proxyId; + if (lowerQuery <= proxy->upperBounds[axis]) + { + IncrementOverlapCount(bounds[i].proxyId); + --s; + } + } + --i; + } + } + + *lowerQueryOut = lowerQuery; + *upperQueryOut = upperQuery; +} + +uint16 b2BroadPhase::CreateProxy(const b2AABB& aabb, void* userData) +{ + b2Assert(m_proxyCount < b2_maxProxies); + b2Assert(m_freeProxy != b2_nullProxy); + + uint16 proxyId = m_freeProxy; + b2Proxy* proxy = m_proxyPool + proxyId; + m_freeProxy = proxy->GetNext(); + + proxy->overlapCount = 0; + proxy->userData = userData; + + int32 boundCount = 2 * m_proxyCount; + + uint16 lowerValues[2], upperValues[2]; + ComputeBounds(lowerValues, upperValues, aabb); + + for (int32 axis = 0; axis < 2; ++axis) + { + b2Bound* bounds = m_bounds[axis]; + int32 lowerIndex, upperIndex; + Query(&lowerIndex, &upperIndex, lowerValues[axis], upperValues[axis], bounds, boundCount, axis); + + memmove(bounds + upperIndex + 2, bounds + upperIndex, (boundCount - upperIndex) * sizeof(b2Bound)); + memmove(bounds + lowerIndex + 1, bounds + lowerIndex, (upperIndex - lowerIndex) * sizeof(b2Bound)); + + // The upper index has increased because of the lower bound insertion. + ++upperIndex; + + // Copy in the new bounds. + bounds[lowerIndex].value = lowerValues[axis]; + bounds[lowerIndex].proxyId = proxyId; + bounds[upperIndex].value = upperValues[axis]; + bounds[upperIndex].proxyId = proxyId; + + bounds[lowerIndex].stabbingCount = lowerIndex == 0 ? 0 : bounds[lowerIndex-1].stabbingCount; + bounds[upperIndex].stabbingCount = bounds[upperIndex-1].stabbingCount; + + // Adjust the stabbing count between the new bounds. + for (int32 index = lowerIndex; index < upperIndex; ++index) + { + ++bounds[index].stabbingCount; + } + + // Adjust the all the affected bound indices. + for (int32 index = lowerIndex; index < boundCount + 2; ++index) + { + b2Proxy* proxy = m_proxyPool + bounds[index].proxyId; + if (bounds[index].IsLower()) + { + proxy->lowerBounds[axis] = (uint16)index; + } + else + { + proxy->upperBounds[axis] = (uint16)index; + } + } + } + + ++m_proxyCount; + + b2Assert(m_queryResultCount < b2_maxProxies); + + // Create pairs if the AABB is in range. + for (int32 i = 0; i < m_queryResultCount; ++i) + { + b2Assert(m_queryResults[i] < b2_maxProxies); + b2Assert(m_proxyPool[m_queryResults[i]].IsValid()); + + m_pairManager.AddBufferedPair(proxyId, m_queryResults[i]); + } + + m_pairManager.Commit(); + + if (s_validate) + { + Validate(); + } + + // Prepare for next query. + m_queryResultCount = 0; + IncrementTimeStamp(); + + return proxyId; +} + +void b2BroadPhase::DestroyProxy(int32 proxyId) +{ + b2Assert(0 < m_proxyCount && m_proxyCount <= b2_maxProxies); + b2Proxy* proxy = m_proxyPool + proxyId; + b2Assert(proxy->IsValid()); + + int32 boundCount = 2 * m_proxyCount; + + for (int32 axis = 0; axis < 2; ++axis) + { + b2Bound* bounds = m_bounds[axis]; + + int32 lowerIndex = proxy->lowerBounds[axis]; + int32 upperIndex = proxy->upperBounds[axis]; + uint16 lowerValue = bounds[lowerIndex].value; + uint16 upperValue = bounds[upperIndex].value; + + memmove(bounds + lowerIndex, bounds + lowerIndex + 1, (upperIndex - lowerIndex - 1) * sizeof(b2Bound)); + memmove(bounds + upperIndex-1, bounds + upperIndex + 1, (boundCount - upperIndex - 1) * sizeof(b2Bound)); + + // Fix bound indices. + for (int32 index = lowerIndex; index < boundCount - 2; ++index) + { + b2Proxy* proxy = m_proxyPool + bounds[index].proxyId; + if (bounds[index].IsLower()) + { + proxy->lowerBounds[axis] = (uint16)index; + } + else + { + proxy->upperBounds[axis] = (uint16)index; + } + } + + // Fix stabbing count. + for (int32 index = lowerIndex; index < upperIndex - 1; ++index) + { + --bounds[index].stabbingCount; + } + + // Query for pairs to be removed. lowerIndex and upperIndex are not needed. + Query(&lowerIndex, &upperIndex, lowerValue, upperValue, bounds, boundCount - 2, axis); + } + + b2Assert(m_queryResultCount < b2_maxProxies); + + for (int32 i = 0; i < m_queryResultCount; ++i) + { + b2Assert(m_proxyPool[m_queryResults[i]].IsValid()); + m_pairManager.RemoveBufferedPair(proxyId, m_queryResults[i]); + } + + m_pairManager.Commit(); + + // Prepare for next query. + m_queryResultCount = 0; + IncrementTimeStamp(); + + // Return the proxy to the pool. + proxy->userData = NULL; + proxy->overlapCount = b2_invalid; + proxy->lowerBounds[0] = b2_invalid; + proxy->lowerBounds[1] = b2_invalid; + proxy->upperBounds[0] = b2_invalid; + proxy->upperBounds[1] = b2_invalid; + + proxy->SetNext(m_freeProxy); + m_freeProxy = (uint16)proxyId; + --m_proxyCount; + + if (s_validate) + { + Validate(); + } +} + +void b2BroadPhase::MoveProxy(int32 proxyId, const b2AABB& aabb) +{ + if (proxyId == b2_nullProxy || b2_maxProxies <= proxyId) + { + b2Assert(false); + return; + } + + if (aabb.IsValid() == false) + { + b2Assert(false); + return; + } + + int32 boundCount = 2 * m_proxyCount; + + b2Proxy* proxy = m_proxyPool + proxyId; + + // Get new bound values + b2BoundValues newValues; + ComputeBounds(newValues.lowerValues, newValues.upperValues, aabb); + + // Get old bound values + b2BoundValues oldValues; + for (int32 axis = 0; axis < 2; ++axis) + { + oldValues.lowerValues[axis] = m_bounds[axis][proxy->lowerBounds[axis]].value; + oldValues.upperValues[axis] = m_bounds[axis][proxy->upperBounds[axis]].value; + } + + for (int32 axis = 0; axis < 2; ++axis) + { + b2Bound* bounds = m_bounds[axis]; + + int32 lowerIndex = proxy->lowerBounds[axis]; + int32 upperIndex = proxy->upperBounds[axis]; + + uint16 lowerValue = newValues.lowerValues[axis]; + uint16 upperValue = newValues.upperValues[axis]; + + int32 deltaLower = lowerValue - bounds[lowerIndex].value; + int32 deltaUpper = upperValue - bounds[upperIndex].value; + + bounds[lowerIndex].value = lowerValue; + bounds[upperIndex].value = upperValue; + + // + // Expanding adds overlaps + // + + // Should we move the lower bound down? + if (deltaLower < 0) + { + int32 index = lowerIndex; + while (index > 0 && lowerValue < bounds[index-1].value) + { + b2Bound* bound = bounds + index; + b2Bound* prevBound = bound - 1; + + int32 prevProxyId = prevBound->proxyId; + b2Proxy* prevProxy = m_proxyPool + prevBound->proxyId; + + ++prevBound->stabbingCount; + + if (prevBound->IsUpper() == true) + { + if (TestOverlap(newValues, prevProxy)) + { + m_pairManager.AddBufferedPair(proxyId, prevProxyId); + } + + ++prevProxy->upperBounds[axis]; + ++bound->stabbingCount; + } + else + { + ++prevProxy->lowerBounds[axis]; + --bound->stabbingCount; + } + + --proxy->lowerBounds[axis]; + b2Swap(*bound, *prevBound); + --index; + } + } + + // Should we move the upper bound up? + if (deltaUpper > 0) + { + int32 index = upperIndex; + while (index < boundCount-1 && bounds[index+1].value <= upperValue) + { + b2Bound* bound = bounds + index; + b2Bound* nextBound = bound + 1; + int32 nextProxyId = nextBound->proxyId; + b2Proxy* nextProxy = m_proxyPool + nextProxyId; + + ++nextBound->stabbingCount; + + if (nextBound->IsLower() == true) + { + if (TestOverlap(newValues, nextProxy)) + { + m_pairManager.AddBufferedPair(proxyId, nextProxyId); + } + + --nextProxy->lowerBounds[axis]; + ++bound->stabbingCount; + } + else + { + --nextProxy->upperBounds[axis]; + --bound->stabbingCount; + } + + ++proxy->upperBounds[axis]; + b2Swap(*bound, *nextBound); + ++index; + } + } + + // + // Shrinking removes overlaps + // + + // Should we move the lower bound up? + if (deltaLower > 0) + { + int32 index = lowerIndex; + while (index < boundCount-1 && bounds[index+1].value <= lowerValue) + { + b2Bound* bound = bounds + index; + b2Bound* nextBound = bound + 1; + + int32 nextProxyId = nextBound->proxyId; + b2Proxy* nextProxy = m_proxyPool + nextProxyId; + + --nextBound->stabbingCount; + + if (nextBound->IsUpper()) + { + if (TestOverlap(oldValues, nextProxy)) + { + m_pairManager.RemoveBufferedPair(proxyId, nextProxyId); + } + + --nextProxy->upperBounds[axis]; + --bound->stabbingCount; + } + else + { + --nextProxy->lowerBounds[axis]; + ++bound->stabbingCount; + } + + ++proxy->lowerBounds[axis]; + b2Swap(*bound, *nextBound); + ++index; + } + } + + // Should we move the upper bound down? + if (deltaUpper < 0) + { + int32 index = upperIndex; + while (index > 0 && upperValue < bounds[index-1].value) + { + b2Bound* bound = bounds + index; + b2Bound* prevBound = bound - 1; + + int32 prevProxyId = prevBound->proxyId; + b2Proxy* prevProxy = m_proxyPool + prevProxyId; + + --prevBound->stabbingCount; + + if (prevBound->IsLower() == true) + { + if (TestOverlap(oldValues, prevProxy)) + { + m_pairManager.RemoveBufferedPair(proxyId, prevProxyId); + } + + ++prevProxy->lowerBounds[axis]; + --bound->stabbingCount; + } + else + { + ++prevProxy->upperBounds[axis]; + ++bound->stabbingCount; + } + + --proxy->upperBounds[axis]; + b2Swap(*bound, *prevBound); + --index; + } + } + } + + if (s_validate) + { + Validate(); + } +} + +void b2BroadPhase::Commit() +{ + m_pairManager.Commit(); +} + +int32 b2BroadPhase::Query(const b2AABB& aabb, void** userData, int32 maxCount) +{ + uint16 lowerValues[2]; + uint16 upperValues[2]; + ComputeBounds(lowerValues, upperValues, aabb); + + int32 lowerIndex, upperIndex; + + Query(&lowerIndex, &upperIndex, lowerValues[0], upperValues[0], m_bounds[0], 2*m_proxyCount, 0); + Query(&lowerIndex, &upperIndex, lowerValues[1], upperValues[1], m_bounds[1], 2*m_proxyCount, 1); + + b2Assert(m_queryResultCount < b2_maxProxies); + + int32 count = 0; + for (int32 i = 0; i < m_queryResultCount && count < maxCount; ++i, ++count) + { + b2Assert(m_queryResults[i] < b2_maxProxies); + b2Proxy* proxy = m_proxyPool + m_queryResults[i]; + b2Assert(proxy->IsValid()); + userData[i] = proxy->userData; + } + + // Prepare for next query. + m_queryResultCount = 0; + IncrementTimeStamp(); + + return count; +} + +void b2BroadPhase::Validate() +{ + for (int32 axis = 0; axis < 2; ++axis) + { + b2Bound* bounds = m_bounds[axis]; + + int32 boundCount = 2 * m_proxyCount; + uint16 stabbingCount = 0; + + for (int32 i = 0; i < boundCount; ++i) + { + b2Bound* bound = bounds + i; + b2Assert(i == 0 || bounds[i-1].value <= bound->value); + b2Assert(bound->proxyId != b2_nullProxy); + b2Assert(m_proxyPool[bound->proxyId].IsValid()); + + if (bound->IsLower() == true) + { + b2Assert(m_proxyPool[bound->proxyId].lowerBounds[axis] == i); + ++stabbingCount; + } + else + { + b2Assert(m_proxyPool[bound->proxyId].upperBounds[axis] == i); + --stabbingCount; + } + + b2Assert(bound->stabbingCount == stabbingCount); + } + } +} diff --git a/Box2D/Source/Collision/b2BroadPhase.h b/Box2D/Source/Collision/b2BroadPhase.h new file mode 100644 index 0000000..0106123 --- /dev/null +++ b/Box2D/Source/Collision/b2BroadPhase.h @@ -0,0 +1,146 @@ +/* +* Copyright (c) 2006-2007 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_BROAD_PHASE_H +#define B2_BROAD_PHASE_H + +/* +This broad phase uses the Sweep and Prune algorithm as described in: +Collision Detection in Interactive 3D Environments by Gino van den Bergen +Also, some ideas, such as using integral values for fast compares comes from +Bullet (http:/www.bulletphysics.com). +*/ + +#include "../Common/b2Settings.h" +#include "b2Collision.h" +#include "b2PairManager.h" +#include + +#ifdef TARGET_FLOAT32_IS_FIXED +#define B2BROADPHASE_MAX (USHRT_MAX/2) +#else +#define B2BROADPHASE_MAX USHRT_MAX + +#endif + +const uint16 b2_invalid = B2BROADPHASE_MAX; +const uint16 b2_nullEdge = B2BROADPHASE_MAX; +struct b2BoundValues; + +struct b2Bound +{ + bool IsLower() const { return (value & 1) == 0; } + bool IsUpper() const { return (value & 1) == 1; } + + uint16 value; + uint16 proxyId; + uint16 stabbingCount; +}; + +struct b2Proxy +{ + uint16 GetNext() const { return lowerBounds[0]; } + void SetNext(uint16 next) { lowerBounds[0] = next; } + bool IsValid() const { return overlapCount != b2_invalid; } + + uint16 lowerBounds[2], upperBounds[2]; + uint16 overlapCount; + uint16 timeStamp; + void* userData; +}; + +class b2BroadPhase +{ +public: + b2BroadPhase(const b2AABB& worldAABB, b2PairCallback* callback); + ~b2BroadPhase(); + + // Use this to see if your proxy is in range. If it is not in range, + // it should be destroyed. Otherwise you may get O(m^2) pairs, where m + // is the number of proxies that are out of range. + bool InRange(const b2AABB& aabb) const; + + // Create and destroy proxies. These call Flush first. + uint16 CreateProxy(const b2AABB& aabb, void* userData); + void DestroyProxy(int32 proxyId); + + // Call MoveProxy as many times as you like, then when you are done + // call Commit to finalized the proxy pairs (for your time step). + void MoveProxy(int32 proxyId, const b2AABB& aabb); + void Commit(); + + // Get a single proxy. Returns NULL if the id is invalid. + b2Proxy* GetProxy(int32 proxyId); + + // Query an AABB for overlapping proxies, returns the user data and + // the count, up to the supplied maximum count. + int32 Query(const b2AABB& aabb, void** userData, int32 maxCount); + + void Validate(); + void ValidatePairs(); + +private: + void ComputeBounds(uint16* lowerValues, uint16* upperValues, const b2AABB& aabb); + + bool TestOverlap(b2Proxy* p1, b2Proxy* p2); + bool TestOverlap(const b2BoundValues& b, b2Proxy* p); + + void Query(int32* lowerIndex, int32* upperIndex, uint16 lowerValue, uint16 upperValue, + b2Bound* bounds, int32 boundCount, int32 axis); + void IncrementOverlapCount(int32 proxyId); + void IncrementTimeStamp(); + +public: + friend class b2PairManager; + + b2PairManager m_pairManager; + + b2Proxy m_proxyPool[b2_maxProxies]; + uint16 m_freeProxy; + + b2Bound m_bounds[2][2*b2_maxProxies]; + + uint16 m_queryResults[b2_maxProxies]; + int32 m_queryResultCount; + + b2AABB m_worldAABB; + b2Vec2 m_quantizationFactor; + int32 m_proxyCount; + uint16 m_timeStamp; + + static bool s_validate; +}; + + +inline bool b2BroadPhase::InRange(const b2AABB& aabb) const +{ + b2Vec2 d = b2Max(aabb.lowerBound - m_worldAABB.upperBound, m_worldAABB.lowerBound - aabb.upperBound); + return b2Max(d.x, d.y) < 0.0f; +} + +inline b2Proxy* b2BroadPhase::GetProxy(int32 proxyId) +{ + if (proxyId == b2_nullProxy || m_proxyPool[proxyId].IsValid() == false) + { + return NULL; + } + + return m_proxyPool + proxyId; +} + +#endif diff --git a/Box2D/Source/Collision/b2CollideCircle.cpp b/Box2D/Source/Collision/b2CollideCircle.cpp new file mode 100644 index 0000000..2b7030d --- /dev/null +++ b/Box2D/Source/Collision/b2CollideCircle.cpp @@ -0,0 +1,168 @@ +/* +* Copyright (c) 2007 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. +*/ + +#include "b2Collision.h" +#include "Shapes/b2CircleShape.h" +#include "Shapes/b2PolygonShape.h" + +void b2CollideCircles( + b2Manifold* manifold, + const b2CircleShape* circle1, const b2XForm& xf1, + const b2CircleShape* circle2, const b2XForm& xf2) +{ + manifold->pointCount = 0; + + b2Vec2 p1 = b2Mul(xf1, circle1->GetLocalPosition()); + b2Vec2 p2 = b2Mul(xf2, circle2->GetLocalPosition()); + + b2Vec2 d = p2 - p1; + float32 distSqr = b2Dot(d, d); + float32 r1 = circle1->GetRadius(); + float32 r2 = circle2->GetRadius(); + float32 radiusSum = r1 + r2; + if (distSqr > radiusSum * radiusSum) + { + return; + } + + float32 separation; + if (distSqr < B2_FLT_EPSILON) + { + separation = -radiusSum; + manifold->normal.Set(0.0f, 1.0f); + } + else + { + float32 dist = b2Sqrt(distSqr); + separation = dist - radiusSum; + float32 a = 1.0f / dist; + manifold->normal.x = a * d.x; + manifold->normal.y = a * d.y; + } + + manifold->pointCount = 1; + manifold->points[0].id.key = 0; + manifold->points[0].separation = separation; + + p1 += r1 * manifold->normal; + p2 -= r2 * manifold->normal; + + b2Vec2 p = 0.5f * (p1 + p2); + + manifold->points[0].localPoint1 = b2MulT(xf1, p); + manifold->points[0].localPoint2 = b2MulT(xf2, p); +} + +void b2CollidePolygonAndCircle( + b2Manifold* manifold, + const b2PolygonShape* polygon, const b2XForm& xf1, + const b2CircleShape* circle, const b2XForm& xf2) +{ + manifold->pointCount = 0; + + // Compute circle position in the frame of the polygon. + b2Vec2 c = b2Mul(xf2, circle->GetLocalPosition()); + b2Vec2 cLocal = b2MulT(xf1, c); + + // Find the min separating edge. + int32 normalIndex = 0; + float32 separation = -B2_FLT_MAX; + float32 radius = circle->GetRadius(); + int32 vertexCount = polygon->GetVertexCount(); + const b2Vec2* vertices = polygon->GetVertices(); + const b2Vec2* normals = polygon->GetNormals(); + + for (int32 i = 0; i < vertexCount; ++i) + { + float32 s = b2Dot(normals[i], cLocal - vertices[i]); + + if (s > radius) + { + // Early out. + return; + } + + if (s > separation) + { + separation = s; + normalIndex = i; + } + } + + // If the center is inside the polygon ... + if (separation < B2_FLT_EPSILON) + { + manifold->pointCount = 1; + manifold->normal = b2Mul(xf1.R, normals[normalIndex]); + manifold->points[0].id.features.incidentEdge = (uint8)normalIndex; + manifold->points[0].id.features.incidentVertex = b2_nullFeature; + manifold->points[0].id.features.referenceEdge = 0; + manifold->points[0].id.features.flip = 0; + b2Vec2 position = c - radius * manifold->normal; + manifold->points[0].localPoint1 = b2MulT(xf1, position); + manifold->points[0].localPoint2 = b2MulT(xf2, position); + manifold->points[0].separation = separation - radius; + return; + } + + // Project the circle center onto the edge segment. + int32 vertIndex1 = normalIndex; + int32 vertIndex2 = vertIndex1 + 1 < vertexCount ? vertIndex1 + 1 : 0; + b2Vec2 e = vertices[vertIndex2] - vertices[vertIndex1]; + + float32 length = e.Normalize(); + b2Assert(length > B2_FLT_EPSILON); + + // Project the center onto the edge. + float32 u = b2Dot(cLocal - vertices[vertIndex1], e); + b2Vec2 p; + if (u <= 0.0f) + { + p = vertices[vertIndex1]; + manifold->points[0].id.features.incidentEdge = b2_nullFeature; + manifold->points[0].id.features.incidentVertex = (uint8)vertIndex1; + } + else if (u >= length) + { + p = vertices[vertIndex2]; + manifold->points[0].id.features.incidentEdge = b2_nullFeature; + manifold->points[0].id.features.incidentVertex = (uint8)vertIndex2; + } + else + { + p = vertices[vertIndex1] + u * e; + manifold->points[0].id.features.incidentEdge = (uint8)normalIndex; + manifold->points[0].id.features.incidentVertex = 0; + } + + b2Vec2 d = cLocal - p; + float32 dist = d.Normalize(); + if (dist > radius) + { + return; + } + + manifold->pointCount = 1; + manifold->normal = b2Mul(xf1.R, d); + b2Vec2 position = c - radius * manifold->normal; + manifold->points[0].localPoint1 = b2MulT(xf1, position); + manifold->points[0].localPoint2 = b2MulT(xf2, position); + manifold->points[0].separation = dist - radius; + manifold->points[0].id.features.referenceEdge = 0; + manifold->points[0].id.features.flip = 0; +} diff --git a/Box2D/Source/Collision/b2CollidePoly.cpp b/Box2D/Source/Collision/b2CollidePoly.cpp new file mode 100644 index 0000000..155ebee --- /dev/null +++ b/Box2D/Source/Collision/b2CollidePoly.cpp @@ -0,0 +1,352 @@ +/* +* Copyright (c) 2006-2007 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. +*/ + +#include "b2Collision.h" +#include "Shapes/b2PolygonShape.h" + +struct ClipVertex +{ + b2Vec2 v; + b2ContactID id; +}; + +static int32 ClipSegmentToLine(ClipVertex vOut[2], ClipVertex vIn[2], + const b2Vec2& normal, float32 offset) +{ + // Start with no output points + int32 numOut = 0; + + // Calculate the distance of end points to the line + float32 distance0 = b2Dot(normal, vIn[0].v) - offset; + float32 distance1 = b2Dot(normal, vIn[1].v) - offset; + + // If the points are behind the plane + if (distance0 <= 0.0f) vOut[numOut++] = vIn[0]; + if (distance1 <= 0.0f) vOut[numOut++] = vIn[1]; + + // If the points are on different sides of the plane + if (distance0 * distance1 < 0.0f) + { + // Find intersection point of edge and plane + float32 interp = distance0 / (distance0 - distance1); + vOut[numOut].v = vIn[0].v + interp * (vIn[1].v - vIn[0].v); + if (distance0 > 0.0f) + { + vOut[numOut].id = vIn[0].id; + } + else + { + vOut[numOut].id = vIn[1].id; + } + ++numOut; + } + + return numOut; +} + +// Find the separation between poly1 and poly2 for a give edge normal on poly1. +static float32 EdgeSeparation(const b2PolygonShape* poly1, const b2XForm& xf1, int32 edge1, + const b2PolygonShape* poly2, const b2XForm& xf2) +{ + int32 count1 = poly1->GetVertexCount(); + const b2Vec2* vertices1 = poly1->GetVertices(); + const b2Vec2* normals1 = poly1->GetNormals(); + + int32 count2 = poly2->GetVertexCount(); + const b2Vec2* vertices2 = poly2->GetVertices(); + + b2Assert(0 <= edge1 && edge1 < count1); + + // Convert normal from poly1's frame into poly2's frame. + b2Vec2 normal1World = b2Mul(xf1.R, normals1[edge1]); + b2Vec2 normal1 = b2MulT(xf2.R, normal1World); + + // Find support vertex on poly2 for -normal. + int32 index = 0; + float32 minDot = B2_FLT_MAX; + + for (int32 i = 0; i < count2; ++i) + { + float32 dot = b2Dot(vertices2[i], normal1); + if (dot < minDot) + { + minDot = dot; + index = i; + } + } + + b2Vec2 v1 = b2Mul(xf1, vertices1[edge1]); + b2Vec2 v2 = b2Mul(xf2, vertices2[index]); + float32 separation = b2Dot(v2 - v1, normal1World); + return separation; +} + +// Find the max separation between poly1 and poly2 using edge normals from poly1. +static float32 FindMaxSeparation(int32* edgeIndex, + const b2PolygonShape* poly1, const b2XForm& xf1, + const b2PolygonShape* poly2, const b2XForm& xf2) +{ + int32 count1 = poly1->GetVertexCount(); + const b2Vec2* normals1 = poly1->GetNormals(); + + // Vector pointing from the centroid of poly1 to the centroid of poly2. + b2Vec2 d = b2Mul(xf2, poly2->GetCentroid()) - b2Mul(xf1, poly1->GetCentroid()); + b2Vec2 dLocal1 = b2MulT(xf1.R, d); + + // Find edge normal on poly1 that has the largest projection onto d. + int32 edge = 0; + float32 maxDot = -B2_FLT_MAX; + for (int32 i = 0; i < count1; ++i) + { + float32 dot = b2Dot(normals1[i], dLocal1); + if (dot > maxDot) + { + maxDot = dot; + edge = i; + } + } + + // Get the separation for the edge normal. + float32 s = EdgeSeparation(poly1, xf1, edge, poly2, xf2); + if (s > 0.0f) + { + return s; + } + + // Check the separation for the previous edge normal. + int32 prevEdge = edge - 1 >= 0 ? edge - 1 : count1 - 1; + float32 sPrev = EdgeSeparation(poly1, xf1, prevEdge, poly2, xf2); + if (sPrev > 0.0f) + { + return sPrev; + } + + // Check the separation for the next edge normal. + int32 nextEdge = edge + 1 < count1 ? edge + 1 : 0; + float32 sNext = EdgeSeparation(poly1, xf1, nextEdge, poly2, xf2); + if (sNext > 0.0f) + { + return sNext; + } + + // Find the best edge and the search direction. + int32 bestEdge; + float32 bestSeparation; + int32 increment; + if (sPrev > s && sPrev > sNext) + { + increment = -1; + bestEdge = prevEdge; + bestSeparation = sPrev; + } + else if (sNext > s) + { + increment = 1; + bestEdge = nextEdge; + bestSeparation = sNext; + } + else + { + *edgeIndex = edge; + return s; + } + + // Perform a local search for the best edge normal. + for ( ; ; ) + { + if (increment == -1) + edge = bestEdge - 1 >= 0 ? bestEdge - 1 : count1 - 1; + else + edge = bestEdge + 1 < count1 ? bestEdge + 1 : 0; + + s = EdgeSeparation(poly1, xf1, edge, poly2, xf2); + if (s > 0.0f) + { + return s; + } + + if (s > bestSeparation) + { + bestEdge = edge; + bestSeparation = s; + } + else + { + break; + } + } + + *edgeIndex = bestEdge; + return bestSeparation; +} + +static void FindIncidentEdge(ClipVertex c[2], + const b2PolygonShape* poly1, const b2XForm& xf1, int32 edge1, + const b2PolygonShape* poly2, const b2XForm& xf2) +{ + int32 count1 = poly1->GetVertexCount(); + const b2Vec2* normals1 = poly1->GetNormals(); + + int32 count2 = poly2->GetVertexCount(); + const b2Vec2* vertices2 = poly2->GetVertices(); + const b2Vec2* normals2 = poly2->GetNormals(); + + b2Assert(0 <= edge1 && edge1 < count1); + + // Get the normal of the reference edge in poly2's frame. + b2Vec2 normal1 = b2MulT(xf2.R, b2Mul(xf1.R, normals1[edge1])); + + // Find the incident edge on poly2. + int32 index = 0; + float32 minDot = B2_FLT_MAX; + for (int32 i = 0; i < count2; ++i) + { + float32 dot = b2Dot(normal1, normals2[i]); + if (dot < minDot) + { + minDot = dot; + index = i; + } + } + + // Build the clip vertices for the incident edge. + int32 i1 = index; + int32 i2 = i1 + 1 < count2 ? i1 + 1 : 0; + + c[0].v = b2Mul(xf2, vertices2[i1]); + c[0].id.features.referenceEdge = (uint8)edge1; + c[0].id.features.incidentEdge = (uint8)i1; + c[0].id.features.incidentVertex = 0; + + c[1].v = b2Mul(xf2, vertices2[i2]); + c[1].id.features.referenceEdge = (uint8)edge1; + c[1].id.features.incidentEdge = (uint8)i2; + c[1].id.features.incidentVertex = 1; +} + +// Find edge normal of max separation on A - return if separating axis is found +// Find edge normal of max separation on B - return if separation axis is found +// Choose reference edge as min(minA, minB) +// Find incident edge +// Clip + +// The normal points from 1 to 2 +void b2CollidePolygons(b2Manifold* manifold, + const b2PolygonShape* polyA, const b2XForm& xfA, + const b2PolygonShape* polyB, const b2XForm& xfB) +{ + manifold->pointCount = 0; + + int32 edgeA = 0; + float32 separationA = FindMaxSeparation(&edgeA, polyA, xfA, polyB, xfB); + if (separationA > 0.0f) + return; + + int32 edgeB = 0; + float32 separationB = FindMaxSeparation(&edgeB, polyB, xfB, polyA, xfA); + if (separationB > 0.0f) + return; + + const b2PolygonShape* poly1; // reference poly + const b2PolygonShape* poly2; // incident poly + b2XForm xf1, xf2; + int32 edge1; // reference edge + uint8 flip; + const float32 k_relativeTol = 0.98f; + const float32 k_absoluteTol = 0.001f; + + // TODO_ERIN use "radius" of poly for absolute tolerance. + if (separationB > k_relativeTol * separationA + k_absoluteTol) + { + poly1 = polyB; + poly2 = polyA; + xf1 = xfB; + xf2 = xfA; + edge1 = edgeB; + flip = 1; + } + else + { + poly1 = polyA; + poly2 = polyB; + xf1 = xfA; + xf2 = xfB; + edge1 = edgeA; + flip = 0; + } + + ClipVertex incidentEdge[2]; + FindIncidentEdge(incidentEdge, poly1, xf1, edge1, poly2, xf2); + + int32 count1 = poly1->GetVertexCount(); + const b2Vec2* vertices1 = poly1->GetVertices(); + + b2Vec2 v11 = vertices1[edge1]; + b2Vec2 v12 = edge1 + 1 < count1 ? vertices1[edge1+1] : vertices1[0]; + + b2Vec2 dv = v12 - v11; + b2Vec2 sideNormal = b2Mul(xf1.R, v12 - v11); + sideNormal.Normalize(); + b2Vec2 frontNormal = b2Cross(sideNormal, 1.0f); + + v11 = b2Mul(xf1, v11); + v12 = b2Mul(xf1, v12); + + float32 frontOffset = b2Dot(frontNormal, v11); + float32 sideOffset1 = -b2Dot(sideNormal, v11); + float32 sideOffset2 = b2Dot(sideNormal, v12); + + // Clip incident edge against extruded edge1 side edges. + ClipVertex clipPoints1[2]; + ClipVertex clipPoints2[2]; + int np; + + // Clip to box side 1 + np = ClipSegmentToLine(clipPoints1, incidentEdge, -sideNormal, sideOffset1); + + if (np < 2) + return; + + // Clip to negative box side 1 + np = ClipSegmentToLine(clipPoints2, clipPoints1, sideNormal, sideOffset2); + + if (np < 2) + return; + + // Now clipPoints2 contains the clipped points. + manifold->normal = flip ? -frontNormal : frontNormal; + + int32 pointCount = 0; + for (int32 i = 0; i < b2_maxManifoldPoints; ++i) + { + float32 separation = b2Dot(frontNormal, clipPoints2[i].v) - frontOffset; + + if (separation <= 0.0f) + { + b2ManifoldPoint* cp = manifold->points + pointCount; + cp->separation = separation; + cp->localPoint1 = b2MulT(xfA, clipPoints2[i].v); + cp->localPoint2 = b2MulT(xfB, clipPoints2[i].v); + cp->id = clipPoints2[i].id; + cp->id.features.flip = flip; + ++pointCount; + } + } + + manifold->pointCount = pointCount; +} diff --git a/Box2D/Source/Collision/b2Collision.cpp b/Box2D/Source/Collision/b2Collision.cpp new file mode 100644 index 0000000..884f247 --- /dev/null +++ b/Box2D/Source/Collision/b2Collision.cpp @@ -0,0 +1,72 @@ +/* +* Copyright (c) 2007 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. +*/ + +#include "b2Collision.h" + +// Collision Detection in Interactive 3D Environments by Gino van den Bergen +// From Section 3.4.1 +// x = mu1 * p1 + mu2 * p2 +// mu1 + mu2 = 1 && mu1 >= 0 && mu2 >= 0 +// mu1 = 1 - mu2; +// x = (1 - mu2) * p1 + mu2 * p2 +// = p1 + mu2 * (p2 - p1) +// x = s + a * r (s := start, r := end - start) +// s + a * r = p1 + mu2 * d (d := p2 - p1) +// -a * r + mu2 * d = b (b := s - p1) +// [-r d] * [a; mu2] = b +// Cramer's rule: +// denom = det[-r d] +// a = det[b d] / denom +// mu2 = det[-r b] / denom +bool b2Segment::TestSegment(float32* lambda, b2Vec2* normal, const b2Segment& segment, float32 maxLambda) const +{ + b2Vec2 s = segment.p1; + b2Vec2 r = segment.p2 - s; + b2Vec2 d = p2 - p1; + b2Vec2 n = b2Cross(d, 1.0f); + + const float32 k_slop = 100.0f * B2_FLT_EPSILON; + float32 denom = -b2Dot(r, n); + + // Cull back facing collision and ignore parallel segments. + if (denom > k_slop) + { + // Does the segment intersect the infinite line associated with this segment? + b2Vec2 b = s - p1; + float32 a = b2Dot(b, n); + + if (0.0f <= a && a <= maxLambda * denom) + { + float32 mu2 = -r.x * b.y + r.y * b.x; + + // Does the segment intersect this segment? + if (-k_slop * denom <= mu2 && mu2 <= denom * (1.0f + k_slop)) + { + a /= denom; + n.Normalize(); + *lambda = a; + *normal = n; + return true; + } + } + } + + return false; +} + + diff --git a/Box2D/Source/Collision/b2Collision.h b/Box2D/Source/Collision/b2Collision.h new file mode 100644 index 0000000..09d975e --- /dev/null +++ b/Box2D/Source/Collision/b2Collision.h @@ -0,0 +1,154 @@ +/* +* Copyright (c) 2006-2007 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_COLLISION_H +#define B2_COLLISION_H + +#include "../Common/b2Math.h" +#include + +/// @file +/// Structures and functions used for computing contact points, distance +/// queries, and TOI queries. + +class b2Shape; +class b2CircleShape; +class b2PolygonShape; + +const uint8 b2_nullFeature = UCHAR_MAX; + +/// Contact ids to facilitate warm starting. +union b2ContactID +{ + /// The features that intersect to form the contact point + struct Features + { + uint8 referenceEdge; ///< The edge that defines the outward contact normal. + uint8 incidentEdge; ///< The edge most anti-parallel to the reference edge. + uint8 incidentVertex; ///< The vertex (0 or 1) on the incident edge that was clipped. + uint8 flip; ///< A value of 1 indicates that the reference edge is on shape2. + } features; + uint32 key; ///< Used to quickly compare contact ids. +}; + +/// A manifold point is a contact point belonging to a contact +/// manifold. It holds details related to the geometry and dynamics +/// of the contact points. +/// The point is stored in local coordinates because CCD +/// requires sub-stepping in which the separation is stale. +struct b2ManifoldPoint +{ + b2Vec2 localPoint1; ///< local position of the contact point in body1 + b2Vec2 localPoint2; ///< local position of the contact point in body2 + float32 separation; ///< the separation of the shapes along the normal vector + float32 normalImpulse; ///< the non-penetration impulse + float32 tangentImpulse; ///< the friction impulse + b2ContactID id; ///< uniquely identifies a contact point between two shapes +}; + +/// A manifold for two touching convex shapes. +struct b2Manifold +{ + b2ManifoldPoint points[b2_maxManifoldPoints]; ///< the points of contact + b2Vec2 normal; ///< the shared unit normal vector + int32 pointCount; ///< the number of manifold points +}; + +/// A line segment. +struct b2Segment +{ + /// Ray cast against this segment with another segment. + bool TestSegment(float32* lambda, b2Vec2* normal, const b2Segment& segment, float32 maxLambda) const; + + b2Vec2 p1; ///< the starting point + b2Vec2 p2; ///< the ending point +}; + +/// An axis aligned bounding box. +struct b2AABB +{ + /// Verify that the bounds are sorted. + bool IsValid() const; + + b2Vec2 lowerBound; ///< the lower vertex + b2Vec2 upperBound; ///< the upper vertex +}; + +/// An oriented bounding box. +struct b2OBB +{ + b2Mat22 R; ///< the rotation matrix + b2Vec2 center; ///< the local centroid + b2Vec2 extents; ///< the half-widths +}; + +/// Compute the collision manifold between two circles. +void b2CollideCircles(b2Manifold* manifold, + const b2CircleShape* circle1, const b2XForm& xf1, + const b2CircleShape* circle2, const b2XForm& xf2); + +/// Compute the collision manifold between a polygon and a circle. +void b2CollidePolygonAndCircle(b2Manifold* manifold, + const b2PolygonShape* polygon, const b2XForm& xf1, + const b2CircleShape* circle, const b2XForm& xf2); + +/// Compute the collision manifold between two circles. +void b2CollidePolygons(b2Manifold* manifold, + const b2PolygonShape* polygon1, const b2XForm& xf1, + const b2PolygonShape* polygon2, const b2XForm& xf2); + +/// Compute the distance between two shapes and the closest points. +/// @return the distance between the shapes or zero if they are overlapped/touching. +float32 b2Distance(b2Vec2* x1, b2Vec2* x2, + const b2Shape* shape1, const b2XForm& xf1, + const b2Shape* shape2, const b2XForm& xf2); + +/// Compute the time when two shapes begin to touch or touch at a closer distance. +/// @warning the sweeps must have the same time interval. +/// @return the fraction between [0,1] in which the shapes first touch. +/// fraction=0 means the shapes begin touching/overlapped, and fraction=1 means the shapes don't touch. +float32 b2TimeOfImpact(const b2Shape* shape1, const b2Sweep& sweep1, + const b2Shape* shape2, const b2Sweep& sweep2); + + +// ---------------- Inline Functions ------------------------------------------ + +inline bool b2AABB::IsValid() const +{ + b2Vec2 d = upperBound - lowerBound; + bool valid = d.x >= 0.0f && d.y >= 0.0f; + valid = valid && lowerBound.IsValid() && upperBound.IsValid(); + return valid; +} + +inline bool b2TestOverlap(const b2AABB& a, const b2AABB& b) +{ + b2Vec2 d1, d2; + d1 = b.lowerBound - a.upperBound; + d2 = a.lowerBound - b.upperBound; + + if (d1.x > 0.0f || d1.y > 0.0f) + return false; + + if (d2.x > 0.0f || d2.y > 0.0f) + return false; + + return true; +} + +#endif diff --git a/Box2D/Source/Collision/b2Distance.cpp b/Box2D/Source/Collision/b2Distance.cpp new file mode 100644 index 0000000..e9ba070 --- /dev/null +++ b/Box2D/Source/Collision/b2Distance.cpp @@ -0,0 +1,364 @@ +/* +* Copyright (c) 2007 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. +*/ + +#include "b2Collision.h" +#include "Shapes/b2CircleShape.h" +#include "Shapes/b2PolygonShape.h" + +int32 g_GJK_Iterations = 0; + +// GJK using Voronoi regions (Christer Ericson) and region selection +// optimizations (Casey Muratori). + +// The origin is either in the region of points[1] or in the edge region. The origin is +// not in region of points[0] because that is the old point. +static int32 ProcessTwo(b2Vec2* x1, b2Vec2* x2, b2Vec2* p1s, b2Vec2* p2s, b2Vec2* points) +{ + // If in point[1] region + b2Vec2 r = -points[1]; + b2Vec2 d = points[0] - points[1]; + float32 length = d.Normalize(); + float32 lambda = b2Dot(r, d); + if (lambda <= 0.0f || length < B2_FLT_EPSILON) + { + // The simplex is reduced to a point. + *x1 = p1s[1]; + *x2 = p2s[1]; + p1s[0] = p1s[1]; + p2s[0] = p2s[1]; + points[0] = points[1]; + return 1; + } + + // Else in edge region + lambda /= length; + *x1 = p1s[1] + lambda * (p1s[0] - p1s[1]); + *x2 = p2s[1] + lambda * (p2s[0] - p2s[1]); + return 2; +} + +// Possible regions: +// - points[2] +// - edge points[0]-points[2] +// - edge points[1]-points[2] +// - inside the triangle +static int32 ProcessThree(b2Vec2* x1, b2Vec2* x2, b2Vec2* p1s, b2Vec2* p2s, b2Vec2* points) +{ + b2Vec2 a = points[0]; + b2Vec2 b = points[1]; + b2Vec2 c = points[2]; + + b2Vec2 ab = b - a; + b2Vec2 ac = c - a; + b2Vec2 bc = c - b; + + float32 sn = -b2Dot(a, ab), sd = b2Dot(b, ab); + float32 tn = -b2Dot(a, ac), td = b2Dot(c, ac); + float32 un = -b2Dot(b, bc), ud = b2Dot(c, bc); + + // In vertex c region? + if (td <= 0.0f && ud <= 0.0f) + { + // Single point + *x1 = p1s[2]; + *x2 = p2s[2]; + p1s[0] = p1s[2]; + p2s[0] = p2s[2]; + points[0] = points[2]; + return 1; + } + + // Should not be in vertex a or b region. + B2_NOT_USED(sd); + B2_NOT_USED(sn); + b2Assert(sn > 0.0f || tn > 0.0f); + b2Assert(sd > 0.0f || un > 0.0f); + + float32 n = b2Cross(ab, ac); + +#ifdef TARGET_FLOAT32_IS_FIXED + n = (n < 0.0)? -1.0 : ((n > 0.0)? 1.0 : 0.0); +#endif + + // Should not be in edge ab region. + float32 vc = n * b2Cross(a, b); + b2Assert(vc > 0.0f || sn > 0.0f || sd > 0.0f); + + // In edge bc region? + float32 va = n * b2Cross(b, c); + if (va <= 0.0f && un >= 0.0f && ud >= 0.0f && (un+ud) > 0.0f) + { + b2Assert(un + ud > 0.0f); + float32 lambda = un / (un + ud); + *x1 = p1s[1] + lambda * (p1s[2] - p1s[1]); + *x2 = p2s[1] + lambda * (p2s[2] - p2s[1]); + p1s[0] = p1s[2]; + p2s[0] = p2s[2]; + points[0] = points[2]; + return 2; + } + + // In edge ac region? + float32 vb = n * b2Cross(c, a); + if (vb <= 0.0f && tn >= 0.0f && td >= 0.0f && (tn+td) > 0.0f) + { + b2Assert(tn + td > 0.0f); + float32 lambda = tn / (tn + td); + *x1 = p1s[0] + lambda * (p1s[2] - p1s[0]); + *x2 = p2s[0] + lambda * (p2s[2] - p2s[0]); + p1s[1] = p1s[2]; + p2s[1] = p2s[2]; + points[1] = points[2]; + return 2; + } + + // Inside the triangle, compute barycentric coordinates + float32 denom = va + vb + vc; + b2Assert(denom > 0.0f); + denom = 1.0f / denom; + +#ifdef TARGET_FLOAT32_IS_FIXED + *x1 = denom * (va * p1s[0] + vb * p1s[1] + vc * p1s[2]); + *x2 = denom * (va * p2s[0] + vb * p2s[1] + vc * p2s[2]); +#else + float32 u = va * denom; + float32 v = vb * denom; + float32 w = 1.0f - u - v; + *x1 = u * p1s[0] + v * p1s[1] + w * p1s[2]; + *x2 = u * p2s[0] + v * p2s[1] + w * p2s[2]; +#endif + return 3; +} + +static bool InPoints(const b2Vec2& w, const b2Vec2* points, int32 pointCount) +{ + const float32 k_tolerance = 100.0f * B2_FLT_EPSILON; + for (int32 i = 0; i < pointCount; ++i) + { + b2Vec2 d = b2Abs(w - points[i]); + b2Vec2 m = b2Max(b2Abs(w), b2Abs(points[i])); + + if (d.x < k_tolerance * (m.x + 1.0f) && + d.y < k_tolerance * (m.y + 1.0f)) + { + return true; + } + } + + return false; +} + +template +float32 DistanceGeneric(b2Vec2* x1, b2Vec2* x2, + const T1* shape1, const b2XForm& xf1, + const T2* shape2, const b2XForm& xf2) +{ + b2Vec2 p1s[3], p2s[3]; + b2Vec2 points[3]; + int32 pointCount = 0; + + *x1 = shape1->GetFirstVertex(xf1); + *x2 = shape2->GetFirstVertex(xf2); + + float32 vSqr = 0.0f; + const int32 maxIterations = 20; + for (int32 iter = 0; iter < maxIterations; ++iter) + { + b2Vec2 v = *x2 - *x1; + b2Vec2 w1 = shape1->Support(xf1, v); + b2Vec2 w2 = shape2->Support(xf2, -v); + + vSqr = b2Dot(v, v); + b2Vec2 w = w2 - w1; + float32 vw = b2Dot(v, w); + if (vSqr - vw <= 0.01f * vSqr || InPoints(w, points, pointCount)) // or w in points + { + if (pointCount == 0) + { + *x1 = w1; + *x2 = w2; + } + g_GJK_Iterations = iter; + return b2Sqrt(vSqr); + } + + switch (pointCount) + { + case 0: + p1s[0] = w1; + p2s[0] = w2; + points[0] = w; + *x1 = p1s[0]; + *x2 = p2s[0]; + ++pointCount; + break; + + case 1: + p1s[1] = w1; + p2s[1] = w2; + points[1] = w; + pointCount = ProcessTwo(x1, x2, p1s, p2s, points); + break; + + case 2: + p1s[2] = w1; + p2s[2] = w2; + points[2] = w; + pointCount = ProcessThree(x1, x2, p1s, p2s, points); + break; + } + + // If we have three points, then the origin is in the corresponding triangle. + if (pointCount == 3) + { + g_GJK_Iterations = iter; + return 0.0f; + } + + float32 maxSqr = -B2_FLT_MAX; + for (int32 i = 0; i < pointCount; ++i) + { + maxSqr = b2Max(maxSqr, b2Dot(points[i], points[i])); + } + +#ifdef TARGET_FLOAT32_IS_FIXED + if (pointCount == 3 || vSqr <= 5.0*B2_FLT_EPSILON * maxSqr) +#else + if (pointCount == 3 || vSqr <= 100.0f * B2_FLT_EPSILON * maxSqr) +#endif + { + g_GJK_Iterations = iter; + v = *x2 - *x1; + vSqr = b2Dot(v, v); + return b2Sqrt(vSqr); + } + } + + g_GJK_Iterations = maxIterations; + return b2Sqrt(vSqr); +} + +static float32 DistanceCC( + b2Vec2* x1, b2Vec2* x2, + const b2CircleShape* circle1, const b2XForm& xf1, + const b2CircleShape* circle2, const b2XForm& xf2) +{ + b2Vec2 p1 = b2Mul(xf1, circle1->GetLocalPosition()); + b2Vec2 p2 = b2Mul(xf2, circle2->GetLocalPosition()); + + b2Vec2 d = p2 - p1; + float32 dSqr = b2Dot(d, d); + float32 r1 = circle1->GetRadius() - b2_toiSlop; + float32 r2 = circle2->GetRadius() - b2_toiSlop; + float32 r = r1 + r2; + if (dSqr > r * r) + { + float32 dLen = d.Normalize(); + float32 distance = dLen - r; + *x1 = p1 + r1 * d; + *x2 = p2 - r2 * d; + return distance; + } + else if (dSqr > B2_FLT_EPSILON * B2_FLT_EPSILON) + { + d.Normalize(); + *x1 = p1 + r1 * d; + *x2 = *x1; + return 0.0f; + } + + *x1 = p1; + *x2 = *x1; + return 0.0f; +} + +// This is used for polygon-vs-circle distance. +struct Point +{ + b2Vec2 Support(const b2XForm&, const b2Vec2&) const + { + return p; + } + + b2Vec2 GetFirstVertex(const b2XForm&) const + { + return p; + } + + b2Vec2 p; +}; + +// GJK is more robust with polygon-vs-point than polygon-vs-circle. +// So we convert polygon-vs-circle to polygon-vs-point. +static float32 DistancePC( + b2Vec2* x1, b2Vec2* x2, + const b2PolygonShape* polygon, const b2XForm& xf1, + const b2CircleShape* circle, const b2XForm& xf2) +{ + Point point; + point.p = b2Mul(xf2, circle->GetLocalPosition()); + + float32 distance = DistanceGeneric(x1, x2, polygon, xf1, &point, b2XForm_identity); + + float32 r = circle->GetRadius() - b2_toiSlop; + + if (distance > r) + { + distance -= r; + b2Vec2 d = *x2 - *x1; + d.Normalize(); + *x2 -= r * d; + } + else + { + distance = 0.0f; + *x2 = *x1; + } + + return distance; +} + +float32 b2Distance(b2Vec2* x1, b2Vec2* x2, + const b2Shape* shape1, const b2XForm& xf1, + const b2Shape* shape2, const b2XForm& xf2) +{ + b2ShapeType type1 = shape1->GetType(); + b2ShapeType type2 = shape2->GetType(); + + if (type1 == e_circleShape && type2 == e_circleShape) + { + return DistanceCC(x1, x2, (b2CircleShape*)shape1, xf1, (b2CircleShape*)shape2, xf2); + } + + if (type1 == e_polygonShape && type2 == e_circleShape) + { + return DistancePC(x1, x2, (b2PolygonShape*)shape1, xf1, (b2CircleShape*)shape2, xf2); + } + + if (type1 == e_circleShape && type2 == e_polygonShape) + { + return DistancePC(x2, x1, (b2PolygonShape*)shape2, xf2, (b2CircleShape*)shape1, xf1); + } + + if (type1 == e_polygonShape && type2 == e_polygonShape) + { + return DistanceGeneric(x1, x2, (b2PolygonShape*)shape1, xf1, (b2PolygonShape*)shape2, xf2); + } + + return 0.0f; +} diff --git a/Box2D/Source/Collision/b2PairManager.cpp b/Box2D/Source/Collision/b2PairManager.cpp new file mode 100644 index 0000000..5e1f7e6 --- /dev/null +++ b/Box2D/Source/Collision/b2PairManager.cpp @@ -0,0 +1,396 @@ +/* +* Copyright (c) 2006-2007 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. +*/ + +#include "b2PairManager.h" +#include "b2BroadPhase.h" + +#include + +// Thomas Wang's hash, see: http://www.concentric.net/~Ttwang/tech/inthash.htm +// This assumes proxyId1 and proxyId2 are 16-bit. +inline uint32 Hash(uint32 proxyId1, uint32 proxyId2) +{ + uint32 key = (proxyId2 << 16) | proxyId1; + key = ~key + (key << 15); + key = key ^ (key >> 12); + key = key + (key << 2); + key = key ^ (key >> 4); + key = key * 2057; + key = key ^ (key >> 16); + return key; +} + +inline bool Equals(const b2Pair& pair, int32 proxyId1, int32 proxyId2) +{ + return pair.proxyId1 == proxyId1 && pair.proxyId2 == proxyId2; +} + +inline bool Equals(const b2BufferedPair& pair1, const b2BufferedPair& pair2) +{ + return pair1.proxyId1 == pair2.proxyId1 && pair1.proxyId2 == pair2.proxyId2; +} + +// For sorting. +inline bool operator < (const b2BufferedPair& pair1, const b2BufferedPair& pair2) +{ + if (pair1.proxyId1 < pair2.proxyId1) + { + return true; + } + + if (pair1.proxyId1 == pair2.proxyId1) + { + return pair1.proxyId2 < pair2.proxyId2; + } + + return false; +} + + +b2PairManager::b2PairManager() +{ + b2Assert(b2IsPowerOfTwo(b2_tableCapacity) == true); + b2Assert(b2_tableCapacity >= b2_maxPairs); + for (int32 i = 0; i < b2_tableCapacity; ++i) + { + m_hashTable[i] = b2_nullPair; + } + m_freePair = 0; + for (int32 i = 0; i < b2_maxPairs; ++i) + { + m_pairs[i].proxyId1 = b2_nullProxy; + m_pairs[i].proxyId2 = b2_nullProxy; + m_pairs[i].userData = NULL; + m_pairs[i].status = 0; + m_pairs[i].next = uint16(i + 1); + } + m_pairs[b2_maxPairs-1].next = b2_nullPair; + m_pairCount = 0; + m_pairBufferCount = 0; +} + +void b2PairManager::Initialize(b2BroadPhase* broadPhase, b2PairCallback* callback) +{ + m_broadPhase = broadPhase; + m_callback = callback; +} + +b2Pair* b2PairManager::Find(int32 proxyId1, int32 proxyId2, uint32 hash) +{ + int32 index = m_hashTable[hash]; + + while (index != b2_nullPair && Equals(m_pairs[index], proxyId1, proxyId2) == false) + { + index = m_pairs[index].next; + } + + if (index == b2_nullPair) + { + return NULL; + } + + b2Assert(index < b2_maxPairs); + + return m_pairs + index; +} + +b2Pair* b2PairManager::Find(int32 proxyId1, int32 proxyId2) +{ + if (proxyId1 > proxyId2) b2Swap(proxyId1, proxyId2); + + int32 hash = Hash(proxyId1, proxyId2) & b2_tableMask; + + return Find(proxyId1, proxyId2, hash); +} + +// Returns existing pair or creates a new one. +b2Pair* b2PairManager::AddPair(int32 proxyId1, int32 proxyId2) +{ + if (proxyId1 > proxyId2) b2Swap(proxyId1, proxyId2); + + int32 hash = Hash(proxyId1, proxyId2) & b2_tableMask; + + b2Pair* pair = Find(proxyId1, proxyId2, hash); + if (pair != NULL) + { + return pair; + } + + b2Assert(m_pairCount < b2_maxPairs && m_freePair != b2_nullPair); + + uint16 pairIndex = m_freePair; + pair = m_pairs + pairIndex; + m_freePair = pair->next; + + pair->proxyId1 = (uint16)proxyId1; + pair->proxyId2 = (uint16)proxyId2; + pair->status = 0; + pair->userData = NULL; + pair->next = m_hashTable[hash]; + + m_hashTable[hash] = pairIndex; + + ++m_pairCount; + + return pair; +} + +// Removes a pair. The pair must exist. +void* b2PairManager::RemovePair(int32 proxyId1, int32 proxyId2) +{ + b2Assert(m_pairCount > 0); + + if (proxyId1 > proxyId2) b2Swap(proxyId1, proxyId2); + + int32 hash = Hash(proxyId1, proxyId2) & b2_tableMask; + + uint16* node = &m_hashTable[hash]; + while (*node != b2_nullPair) + { + if (Equals(m_pairs[*node], proxyId1, proxyId2)) + { + uint16 index = *node; + *node = m_pairs[*node].next; + + b2Pair* pair = m_pairs + index; + void* userData = pair->userData; + + // Scrub + pair->next = m_freePair; + pair->proxyId1 = b2_nullProxy; + pair->proxyId2 = b2_nullProxy; + pair->userData = NULL; + pair->status = 0; + + m_freePair = index; + --m_pairCount; + return userData; + } + else + { + node = &m_pairs[*node].next; + } + } + + b2Assert(false); + return NULL; +} + +/* +As proxies are created and moved, many pairs are created and destroyed. Even worse, the same +pair may be added and removed multiple times in a single time step of the physics engine. To reduce +traffic in the pair manager, we try to avoid destroying pairs in the pair manager until the +end of the physics step. This is done by buffering all the RemovePair requests. AddPair +requests are processed immediately because we need the hash table entry for quick lookup. + +All user user callbacks are delayed until the buffered pairs are confirmed in Commit. +This is very important because the user callbacks may be very expensive and client logic +may be harmed if pairs are added and removed within the same time step. + +Buffer a pair for addition. +We may add a pair that is not in the pair manager or pair buffer. +We may add a pair that is already in the pair manager and pair buffer. +If the added pair is not a new pair, then it must be in the pair buffer (because RemovePair was called). +*/ +void b2PairManager::AddBufferedPair(int32 id1, int32 id2) +{ + b2Assert(id1 != b2_nullProxy && id2 != b2_nullProxy); + b2Assert(m_pairBufferCount < b2_maxPairs); + + b2Pair* pair = AddPair(id1, id2); + + // If this pair is not in the pair buffer ... + if (pair->IsBuffered() == false) + { + // This must be a newly added pair. + b2Assert(pair->IsFinal() == false); + + // Add it to the pair buffer. + pair->SetBuffered(); + m_pairBuffer[m_pairBufferCount].proxyId1 = pair->proxyId1; + m_pairBuffer[m_pairBufferCount].proxyId2 = pair->proxyId2; + ++m_pairBufferCount; + + b2Assert(m_pairBufferCount <= m_pairCount); + } + + // Confirm this pair for the subsequent call to Commit. + pair->ClearRemoved(); + + if (b2BroadPhase::s_validate) + { + ValidateBuffer(); + } +} + +// Buffer a pair for removal. +void b2PairManager::RemoveBufferedPair(int32 id1, int32 id2) +{ + b2Assert(id1 != b2_nullProxy && id2 != b2_nullProxy); + b2Assert(m_pairBufferCount < b2_maxPairs); + + b2Pair* pair = Find(id1, id2); + + if (pair == NULL) + { + // The pair never existed. This is legal (due to collision filtering). + return; + } + + // If this pair is not in the pair buffer ... + if (pair->IsBuffered() == false) + { + // This must be an old pair. + b2Assert(pair->IsFinal() == true); + + pair->SetBuffered(); + m_pairBuffer[m_pairBufferCount].proxyId1 = pair->proxyId1; + m_pairBuffer[m_pairBufferCount].proxyId2 = pair->proxyId2; + ++m_pairBufferCount; + + b2Assert(m_pairBufferCount <= m_pairCount); + } + + pair->SetRemoved(); + + if (b2BroadPhase::s_validate) + { + ValidateBuffer(); + } +} + +void b2PairManager::Commit() +{ + int32 removeCount = 0; + + b2Proxy* proxies = m_broadPhase->m_proxyPool; + + for (int32 i = 0; i < m_pairBufferCount; ++i) + { + b2Pair* pair = Find(m_pairBuffer[i].proxyId1, m_pairBuffer[i].proxyId2); + b2Assert(pair->IsBuffered()); + pair->ClearBuffered(); + + b2Assert(pair->proxyId1 < b2_maxProxies && pair->proxyId2 < b2_maxProxies); + + b2Proxy* proxy1 = proxies + pair->proxyId1; + b2Proxy* proxy2 = proxies + pair->proxyId2; + + b2Assert(proxy1->IsValid()); + b2Assert(proxy2->IsValid()); + + if (pair->IsRemoved()) + { + // It is possible a pair was added then removed before a commit. Therefore, + // we should be careful not to tell the user the pair was removed when the + // the user didn't receive a matching add. + if (pair->IsFinal() == true) + { + m_callback->PairRemoved(proxy1->userData, proxy2->userData, pair->userData); + } + + // Store the ids so we can actually remove the pair below. + m_pairBuffer[removeCount].proxyId1 = pair->proxyId1; + m_pairBuffer[removeCount].proxyId2 = pair->proxyId2; + ++removeCount; + } + else + { + b2Assert(m_broadPhase->TestOverlap(proxy1, proxy2) == true); + + if (pair->IsFinal() == false) + { + pair->userData = m_callback->PairAdded(proxy1->userData, proxy2->userData); + pair->SetFinal(); + } + } + } + + for (int32 i = 0; i < removeCount; ++i) + { + RemovePair(m_pairBuffer[i].proxyId1, m_pairBuffer[i].proxyId2); + } + + m_pairBufferCount = 0; + + if (b2BroadPhase::s_validate) + { + ValidateTable(); + } +} + +void b2PairManager::ValidateBuffer() +{ +#ifdef _DEBUG + b2Assert(m_pairBufferCount <= m_pairCount); + + std::sort(m_pairBuffer, m_pairBuffer + m_pairBufferCount); + + for (int32 i = 0; i < m_pairBufferCount; ++i) + { + if (i > 0) + { + b2Assert(Equals(m_pairBuffer[i], m_pairBuffer[i-1]) == false); + } + + b2Pair* pair = Find(m_pairBuffer[i].proxyId1, m_pairBuffer[i].proxyId2); + b2Assert(pair->IsBuffered()); + + b2Assert(pair->proxyId1 != pair->proxyId2); + b2Assert(pair->proxyId1 < b2_maxProxies); + b2Assert(pair->proxyId2 < b2_maxProxies); + + b2Proxy* proxy1 = m_broadPhase->m_proxyPool + pair->proxyId1; + b2Proxy* proxy2 = m_broadPhase->m_proxyPool + pair->proxyId2; + + b2Assert(proxy1->IsValid() == true); + b2Assert(proxy2->IsValid() == true); + } +#endif +} + +void b2PairManager::ValidateTable() +{ +#ifdef _DEBUG + for (int32 i = 0; i < b2_tableCapacity; ++i) + { + uint16 index = m_hashTable[i]; + while (index != b2_nullPair) + { + b2Pair* pair = m_pairs + index; + b2Assert(pair->IsBuffered() == false); + b2Assert(pair->IsFinal() == true); + b2Assert(pair->IsRemoved() == false); + + b2Assert(pair->proxyId1 != pair->proxyId2); + b2Assert(pair->proxyId1 < b2_maxProxies); + b2Assert(pair->proxyId2 < b2_maxProxies); + + b2Proxy* proxy1 = m_broadPhase->m_proxyPool + pair->proxyId1; + b2Proxy* proxy2 = m_broadPhase->m_proxyPool + pair->proxyId2; + + b2Assert(proxy1->IsValid() == true); + b2Assert(proxy2->IsValid() == true); + + b2Assert(m_broadPhase->TestOverlap(proxy1, proxy2) == true); + + index = pair->next; + } + } +#endif +} diff --git a/Box2D/Source/Collision/b2PairManager.h b/Box2D/Source/Collision/b2PairManager.h new file mode 100644 index 0000000..d275814 --- /dev/null +++ b/Box2D/Source/Collision/b2PairManager.h @@ -0,0 +1,121 @@ +/* +* Copyright (c) 2006-2007 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. +*/ + +// The pair manager is used by the broad-phase to quickly add/remove/find pairs +// of overlapping proxies. It is based closely on code provided by Pierre Terdiman. +// http://www.codercorner.com/IncrementalSAP.txt + +#ifndef B2_PAIR_MANAGER_H +#define B2_PAIR_MANAGER_H + +#include "../Common/b2Settings.h" +#include "../Common/b2Math.h" + +#include + +class b2BroadPhase; +struct b2Proxy; + +const uint16 b2_nullPair = USHRT_MAX; +const uint16 b2_nullProxy = USHRT_MAX; +const int32 b2_tableCapacity = b2_maxPairs; // must be a power of two +const int32 b2_tableMask = b2_tableCapacity - 1; + +struct b2Pair +{ + enum + { + e_pairBuffered = 0x0001, + e_pairRemoved = 0x0002, + e_pairFinal = 0x0004, + }; + + void SetBuffered() { status |= e_pairBuffered; } + void ClearBuffered() { status &= ~e_pairBuffered; } + bool IsBuffered() { return (status & e_pairBuffered) == e_pairBuffered; } + + void SetRemoved() { status |= e_pairRemoved; } + void ClearRemoved() { status &= ~e_pairRemoved; } + bool IsRemoved() { return (status & e_pairRemoved) == e_pairRemoved; } + + void SetFinal() { status |= e_pairFinal; } + bool IsFinal() { return (status & e_pairFinal) == e_pairFinal; } + + void* userData; + uint16 proxyId1; + uint16 proxyId2; + uint16 next; + uint16 status; +}; + +struct b2BufferedPair +{ + uint16 proxyId1; + uint16 proxyId2; +}; + +class b2PairCallback +{ +public: + virtual ~b2PairCallback() {} + + // This should return the new pair user data. It is ok if the + // user data is null. + virtual void* PairAdded(void* proxyUserData1, void* proxyUserData2) = 0; + + // This should free the pair's user data. In extreme circumstances, it is possible + // this will be called with null pairUserData because the pair never existed. + virtual void PairRemoved(void* proxyUserData1, void* proxyUserData2, void* pairUserData) = 0; +}; + +class b2PairManager +{ +public: + b2PairManager(); + + void Initialize(b2BroadPhase* broadPhase, b2PairCallback* callback); + + void AddBufferedPair(int32 proxyId1, int32 proxyId2); + void RemoveBufferedPair(int32 proxyId1, int32 proxyId2); + + void Commit(); + +private: + b2Pair* Find(int32 proxyId1, int32 proxyId2); + b2Pair* Find(int32 proxyId1, int32 proxyId2, uint32 hashValue); + + b2Pair* AddPair(int32 proxyId1, int32 proxyId2); + void* RemovePair(int32 proxyId1, int32 proxyId2); + + void ValidateBuffer(); + void ValidateTable(); + +public: + b2BroadPhase *m_broadPhase; + b2PairCallback *m_callback; + b2Pair m_pairs[b2_maxPairs]; + uint16 m_freePair; + int32 m_pairCount; + + b2BufferedPair m_pairBuffer[b2_maxPairs]; + int32 m_pairBufferCount; + + uint16 m_hashTable[b2_tableCapacity]; +}; + +#endif diff --git a/Box2D/Source/Collision/b2TimeOfImpact.cpp b/Box2D/Source/Collision/b2TimeOfImpact.cpp new file mode 100644 index 0000000..0681eda --- /dev/null +++ b/Box2D/Source/Collision/b2TimeOfImpact.cpp @@ -0,0 +1,112 @@ +/* +* Copyright (c) 2007 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. +*/ + +#include "b2Collision.h" +#include "Shapes/b2Shape.h" + +// This algorithm uses conservative advancement to compute the time of +// impact (TOI) of two shapes. +// Refs: Bullet, Young Kim +float32 b2TimeOfImpact(const b2Shape* shape1, const b2Sweep& sweep1, + const b2Shape* shape2, const b2Sweep& sweep2) +{ + float32 r1 = shape1->GetSweepRadius(); + float32 r2 = shape2->GetSweepRadius(); + + b2Assert(sweep1.t0 == sweep2.t0); + b2Assert(1.0f - sweep1.t0 > B2_FLT_EPSILON); + + float32 t0 = sweep1.t0; + b2Vec2 v1 = sweep1.c - sweep1.c0; + b2Vec2 v2 = sweep2.c - sweep2.c0; + float32 omega1 = sweep1.a - sweep1.a0; + float32 omega2 = sweep2.a - sweep2.a0; + + float32 alpha = 0.0f; + + b2Vec2 p1, p2; + const int32 k_maxIterations = 20; // TODO_ERIN b2Settings + int32 iter = 0; + b2Vec2 normal = b2Vec2_zero; + float32 distance = 0.0f; + float32 targetDistance = 0.0f; + for(;;) + { + float32 t = (1.0f - alpha) * t0 + alpha; + b2XForm xf1, xf2; + sweep1.GetXForm(&xf1, t); + sweep2.GetXForm(&xf2, t); + + // Get the distance between shapes. + distance = b2Distance(&p1, &p2, shape1, xf1, shape2, xf2); + + if (iter == 0) + { + // Compute a reasonable target distance to give some breathing room + // for conservative advancement. + if (distance > 2.0f * b2_toiSlop) + { + targetDistance = 1.5f * b2_toiSlop; + } + else + { + targetDistance = b2Max(0.05f * b2_toiSlop, distance - 0.5f * b2_toiSlop); + } + } + + if (distance - targetDistance < 0.05f * b2_toiSlop || iter == k_maxIterations) + { + break; + } + + normal = p2 - p1; + normal.Normalize(); + + // Compute upper bound on remaining movement. + float32 approachVelocityBound = b2Dot(normal, v1 - v2) + b2Abs(omega1) * r1 + b2Abs(omega2) * r2; + if (b2Abs(approachVelocityBound) < B2_FLT_EPSILON) + { + alpha = 1.0f; + break; + } + + // Get the conservative time increment. Don't advance all the way. + float32 dAlpha = (distance - targetDistance) / approachVelocityBound; + //float32 dt = (distance - 0.5f * b2_linearSlop) / approachVelocityBound; + float32 newAlpha = alpha + dAlpha; + + // The shapes may be moving apart or a safe distance apart. + if (newAlpha < 0.0f || 1.0f < newAlpha) + { + alpha = 1.0f; + break; + } + + // Ensure significant advancement. + if (newAlpha < (1.0f + 100.0f * B2_FLT_EPSILON) * alpha) + { + break; + } + + alpha = newAlpha; + + ++iter; + } + + return alpha; +} diff --git a/Box2D/Source/Common/Fixed.h b/Box2D/Source/Common/Fixed.h new file mode 100644 index 0000000..0e1d980 --- /dev/null +++ b/Box2D/Source/Common/Fixed.h @@ -0,0 +1,477 @@ +/* +Copyright (c) 2006 Henry Strickland & Ryan Seto + 2007-2008 Tobias Weyand (modifications and extensions) + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + + (* http://www.opensource.org/licenses/mit-license.php *) +*/ + +#ifndef _FIXED_H_ +#define _FIXED_H_ + +#include + +#ifdef TARGET_IS_NDS + +#include "nds.h" + +#endif + +#define FIXED_BP 16 +#define FIXED_MAX ((1<<(32-FIXED_BP-1))-1) +#define FIXED_MIN (-(1<<(32-FIXED_BP-1))) +#define FIXED_EPSILON (Fixed(0.00007f)) + +#define G_1_DIV_PI 20861 + +class Fixed { + + private: + + int g; // the guts + + const static int BP= FIXED_BP; // how many low bits are right of Binary Point + const static int BP2= BP*2; // how many low bits are right of Binary Point + const static int BPhalf= BP/2; // how many low bits are right of Binary Point + + double STEP(); // smallest step we can represent + + // for private construction via guts + enum FixedRaw { RAW }; + Fixed(FixedRaw, int guts); + + public: + + Fixed(); + Fixed(const Fixed &a); + Fixed(float a); + Fixed(double a); + Fixed(int a); + Fixed(long a); + + Fixed& operator =(const Fixed a); + Fixed& operator =(float a); + Fixed& operator =(double a); + Fixed& operator =(int a); + Fixed& operator =(long a); + + operator float(); + operator double(); + operator int(); + operator long(); + operator unsigned short(); + + operator float() const; + + Fixed operator +() const; + Fixed operator -() const; + + Fixed operator +(const Fixed a) const; + Fixed operator -(const Fixed a) const; +#if 1 + // more acurate, using long long + Fixed operator *(const Fixed a) const; +#else + // faster, but with only half as many bits right of binary point + Fixed operator *(const Fixed a) const; +#endif + Fixed operator /(const Fixed a) const; + + Fixed operator *(unsigned short a) const; + Fixed operator *(int a) const; + + Fixed operator +(float a) const; + Fixed operator -(float a) const; + Fixed operator *(float a) const; + Fixed operator /(float a) const; + + Fixed operator +(double a) const; + Fixed operator -(double a) const; + Fixed operator *(double a) const; + Fixed operator /(double a) const; + + Fixed operator >>(int a) const; + Fixed operator <<(int a) const; + + Fixed& operator +=(Fixed a); + Fixed& operator -=(Fixed a); + Fixed& operator *=(Fixed a); + Fixed& operator /=(Fixed a); + + Fixed& operator +=(int a); + Fixed& operator -=(int a); + Fixed& operator *=(int a); + Fixed& operator /=(int a); + + Fixed& operator +=(long a); + Fixed& operator -=(long a); + Fixed& operator *=(long a); + Fixed& operator /=(long a); + + Fixed& operator +=(float a); + Fixed& operator -=(float a); + Fixed& operator *=(float a); + Fixed& operator /=(float a); + + Fixed& operator +=(double a); + Fixed& operator -=(double a); + Fixed& operator *=(double a); + Fixed& operator /=(double a); + + bool operator ==(const Fixed a) const; + bool operator !=(const Fixed a) const; + bool operator <=(const Fixed a) const; + bool operator >=(const Fixed a) const; + bool operator <(const Fixed a) const; + bool operator >(const Fixed a) const; + + bool operator ==(float a) const; + bool operator !=(float a) const; + bool operator <=(float a) const; + bool operator >=(float a) const; + bool operator <(float a) const; + bool operator >(float a) const; + + bool operator ==(double a) const; + bool operator !=(double a) const; + bool operator <=(double a) const; + bool operator >=(double a) const; + bool operator <(double a) const; + bool operator >(double a) const; + + bool operator >(int a) const; + bool operator <(int a) const; + bool operator >=(int a) const; + bool operator <=(int a) const; + + Fixed abs(); + Fixed sqrt(); +#ifdef TARGET_IS_NDS + Fixed cosf(); + Fixed sinf(); + Fixed tanf(); +#endif +}; + +// +// Implementation +// + +inline double Fixed::STEP() { return 1.0 / (1<>BP; } +inline Fixed::operator long() { return g>>BP; } +//#pragma warning(disable: 4244) //HARDWIRE added pragma to prevent VS2005 compilation error +inline Fixed::operator unsigned short() { return g>>BP; } +inline Fixed::operator float() const { return g / (float)(1<> BP)); } + +#elif 0 + +// check for overflow and figure out where. Must specify -rdynamic in linker +#include +#include +#include + +inline Fixed Fixed::operator *(const Fixed a) const { + long long x = ((long long)g * (long long)a.g ); + if(x > 0x7fffffffffffLL || x < -0x7fffffffffffLL) { + printf("overflow"); + void *array[2]; + int nSize = backtrace(array, 2); + char **symbols = backtrace_symbols(array, nSize); + for(int i=0; i>BP)); +} + +#else +// faster, but with only half as many bits right of binary point +inline Fixed Fixed::operator *(const Fixed a) const { return Fixed(RAW, (g>>BPhalf) * (a.g>>BPhalf) ); } +#endif + + +#ifdef TARGET_IS_NDS +// Division using the DS's maths coprocessor +inline Fixed Fixed::operator /(const Fixed a) const +{ + //printf("%d %d\n", (long long)g << BP, a.g); + return Fixed(RAW, int( div64((long long)g << BP, a.g) ) ); +} +#else +inline Fixed Fixed::operator /(const Fixed a) const +{ + return Fixed(RAW, int( (((long long)g << BP2) / (long long)(a.g)) >> BP) ); + //return Fixed(RAW, int( (((long long)g << BP) / (long long)(a.g)) ) ); +} +#endif + +inline Fixed Fixed::operator *(unsigned short a) const { return operator*(Fixed(a)); } +inline Fixed Fixed::operator *(int a) const { return operator*(Fixed(a)); } + +inline Fixed Fixed::operator +(float a) const { return Fixed(RAW, g + Fixed(a).g); } +inline Fixed Fixed::operator -(float a) const { return Fixed(RAW, g - Fixed(a).g); } +inline Fixed Fixed::operator *(float a) const { return Fixed(RAW, (g>>BPhalf) * (Fixed(a).g>>BPhalf) ); } +//inline Fixed Fixed::operator /(float a) const { return Fixed(RAW, int( (((long long)g << BP2) / (long long)(Fixed(a).g)) >> BP) ); } +inline Fixed Fixed::operator /(float a) const { return operator/(Fixed(a)); } + +inline Fixed Fixed::operator +(double a) const { return Fixed(RAW, g + Fixed(a).g); } +inline Fixed Fixed::operator -(double a) const { return Fixed(RAW, g - Fixed(a).g); } +inline Fixed Fixed::operator *(double a) const { return Fixed(RAW, (g>>BPhalf) * (Fixed(a).g>>BPhalf) ); } +//inline Fixed Fixed::operator /(double a) const { return Fixed(RAW, int( (((long long)g << BP2) / (long long)(Fixed(a).g)) >> BP) ); } +inline Fixed Fixed::operator /(double a) const { return operator/(Fixed(a)); } + +inline Fixed Fixed::operator >>(int a) const { return Fixed(RAW, g >> a); } +inline Fixed Fixed::operator <<(int a) const { return Fixed(RAW, g << a); } + +inline Fixed& Fixed::operator +=(Fixed a) { return *this = *this + a; } +inline Fixed& Fixed::operator -=(Fixed a) { return *this = *this - a; } +inline Fixed& Fixed::operator *=(Fixed a) { return *this = *this * a; } +//inline Fixed& Fixed::operator /=(Fixed a) { return *this = *this / a; } +inline Fixed& Fixed::operator /=(Fixed a) { return *this = operator/(a); } + +inline Fixed& Fixed::operator +=(int a) { return *this = *this + (Fixed)a; } +inline Fixed& Fixed::operator -=(int a) { return *this = *this - (Fixed)a; } +inline Fixed& Fixed::operator *=(int a) { return *this = *this * (Fixed)a; } +//inline Fixed& Fixed::operator /=(int a) { return *this = *this / (Fixed)a; } +inline Fixed& Fixed::operator /=(int a) { return *this = operator/((Fixed)a); } + +inline Fixed& Fixed::operator +=(long a) { return *this = *this + (Fixed)a; } +inline Fixed& Fixed::operator -=(long a) { return *this = *this - (Fixed)a; } +inline Fixed& Fixed::operator *=(long a) { return *this = *this * (Fixed)a; } +//inline Fixed& Fixed::operator /=(long a) { return *this = *this / (Fixed)a; } +inline Fixed& Fixed::operator /=(long a) { return *this = operator/((Fixed)a); } + +inline Fixed& Fixed::operator +=(float a) { return *this = *this + a; } +inline Fixed& Fixed::operator -=(float a) { return *this = *this - a; } +inline Fixed& Fixed::operator *=(float a) { return *this = *this * a; } +//inline Fixed& Fixed::operator /=(float a) { return *this = *this / a; } +inline Fixed& Fixed::operator /=(float a) { return *this = operator/(a); } + +inline Fixed& Fixed::operator +=(double a) { return *this = *this + a; } +inline Fixed& Fixed::operator -=(double a) { return *this = *this - a; } +inline Fixed& Fixed::operator *=(double a) { return *this = *this * a; } +//inline Fixed& Fixed::operator /=(double a) { return *this = *this / a; } +inline Fixed& Fixed::operator /=(double a) { return *this = operator/(a); } + +inline Fixed operator +(int a, const Fixed b) { return Fixed(a)+b; } +inline Fixed operator -(int a, const Fixed b) { return Fixed(a)-b; } +inline Fixed operator *(int a, const Fixed b) { return Fixed(a)*b; } +inline Fixed operator /(int a, const Fixed b) { return Fixed(a)/b; }; + +inline Fixed operator +(float a, const Fixed b) { return Fixed(a)+b; } +inline Fixed operator -(float a, const Fixed b) { return Fixed(a)-b; } +inline Fixed operator *(float a, const Fixed b) { return Fixed(a)*b; } +inline Fixed operator /(float a, const Fixed b) { return Fixed(a)/b; } + +inline bool Fixed::operator ==(const Fixed a) const { return g == a.g; } +inline bool Fixed::operator !=(const Fixed a) const { return g != a.g; } +inline bool Fixed::operator <=(const Fixed a) const { return g <= a.g; } +inline bool Fixed::operator >=(const Fixed a) const { return g >= a.g; } +inline bool Fixed::operator <(const Fixed a) const { return g < a.g; } +inline bool Fixed::operator >(const Fixed a) const { return g > a.g; } + +inline bool Fixed::operator ==(float a) const { return g == Fixed(a).g; } +inline bool Fixed::operator !=(float a) const { return g != Fixed(a).g; } +inline bool Fixed::operator <=(float a) const { return g <= Fixed(a).g; } +inline bool Fixed::operator >=(float a) const { return g >= Fixed(a).g; } +inline bool Fixed::operator <(float a) const { return g < Fixed(a).g; } +inline bool Fixed::operator >(float a) const { return g > Fixed(a).g; } + +inline bool Fixed::operator ==(double a) const { return g == Fixed(a).g; } +inline bool Fixed::operator !=(double a) const { return g != Fixed(a).g; } +inline bool Fixed::operator <=(double a) const { return g <= Fixed(a).g; } +inline bool Fixed::operator >=(double a) const { return g >= Fixed(a).g; } +inline bool Fixed::operator <(double a) const { return g < Fixed(a).g; } +inline bool Fixed::operator >(double a) const { return g > Fixed(a).g; } + +inline bool Fixed::operator >(int a) const { return g > Fixed(a).g; } +inline bool Fixed::operator <(int a) const { return g < Fixed(a).g; } +inline bool Fixed::operator >=(int a) const{ return g >= Fixed(a).g; }; +inline bool Fixed::operator <=(int a) const{ return g <= Fixed(a).g; }; + +inline bool operator ==(float a, const Fixed b) { return Fixed(a) == b; } +inline bool operator !=(float a, const Fixed b) { return Fixed(a) != b; } +inline bool operator <=(float a, const Fixed b) { return Fixed(a) <= b; } +inline bool operator >=(float a, const Fixed b) { return Fixed(a) >= b; } +inline bool operator <(float a, const Fixed b) { return Fixed(a) < b; } +inline bool operator >(float a, const Fixed b) { return Fixed(a) > b; } + +inline Fixed operator +(double a, const Fixed b) { return Fixed(a)+b; } +inline Fixed operator -(double a, const Fixed b) { return Fixed(a)-b; } +inline Fixed operator *(double a, const Fixed b) { return Fixed(a)*b; } +inline Fixed operator /(double a, const Fixed b) { return Fixed(a)/b; } + +inline bool operator ==(double a, const Fixed b) { return Fixed(a) == b; } +inline bool operator !=(double a, const Fixed b) { return Fixed(a) != b; } +inline bool operator <=(double a, const Fixed b) { return Fixed(a) <= b; } +inline bool operator >=(double a, const Fixed b) { return Fixed(a) >= b; } +inline bool operator <(double a, const Fixed b) { return Fixed(a) < b; } +inline bool operator >(double a, const Fixed b) { return Fixed(a) > b; } + +inline bool operator ==(int a, const Fixed b) { return Fixed(a) == b; } +inline bool operator !=(int a, const Fixed b) { return Fixed(a) != b; } +inline bool operator <=(int a, const Fixed b) { return Fixed(a) <= b; } +inline bool operator >=(int a, const Fixed b) { return Fixed(a) >= b; } +inline bool operator <(int a, const Fixed b) { return Fixed(a) < b; } +inline bool operator >(int a, const Fixed b) { return Fixed(a) > b; } + +inline int& operator +=(int& a, const Fixed b) { a = (Fixed)a + b; return a; } +inline int& operator -=(int& a, const Fixed b) { a = (Fixed)a - b; return a; } +inline int& operator *=(int& a, const Fixed b) { a = (Fixed)a * b; return a; } +inline int& operator /=(int& a, const Fixed b) { a = (Fixed)a / b; return a; } + +inline long& operator +=(long& a, const Fixed b) { a = (Fixed)a + b; return a; } +inline long& operator -=(long& a, const Fixed b) { a = (Fixed)a - b; return a; } +inline long& operator *=(long& a, const Fixed b) { a = (Fixed)a * b; return a; } +inline long& operator /=(long& a, const Fixed b) { a = (Fixed)a / b; return a; } + +inline float& operator +=(float& a, const Fixed b) { a = a + b; return a; } +inline float& operator -=(float& a, const Fixed b) { a = a - b; return a; } +inline float& operator *=(float& a, const Fixed b) { a = a * b; return a; } +inline float& operator /=(float& a, const Fixed b) { a = a / b; return a; } + +inline double& operator +=(double& a, const Fixed b) { a = a + b; return a; } +inline double& operator -=(double& a, const Fixed b) { a = a - b; return a; } +inline double& operator *=(double& a, const Fixed b) { a = a * b; return a; } +inline double& operator /=(double& a, const Fixed b) { a = a / b; return a; } + +inline Fixed Fixed::abs() { return (g>0) ? Fixed(RAW, g) : Fixed(RAW, -g); } +inline Fixed abs(Fixed f) { return f.abs(); } + +//inline Fixed atan2(Fixed a, Fixed b) { return atan2f((float) a, (float) b); } +inline Fixed atan2(Fixed y, Fixed x) +{ + Fixed abs_y = y.abs() + FIXED_EPSILON; // avoid 0/0 + Fixed r, angle; + + if(x >= 0.0f) { + r = (x - abs_y) / (x + abs_y); + angle = 3.1415926/4.0; + } else { + r = (x + abs_y) / (abs_y - x); + angle = 3.0*3.1415926/4.0; + } + angle += Fixed(0.1963) * (r * r * r) - Fixed(0.9817) * r; + return (y < 0) ? -angle : angle; +} + +#if TARGET_IS_NDS + +static inline long nds_sqrt64(long long a) +{ + SQRT_CR = SQRT_64; + while(SQRT_CR & SQRT_BUSY); + SQRT_PARAM64 = a; + while(SQRT_CR & SQRT_BUSY); + + return SQRT_RESULT32; +} + +static inline int32 div6464(int64 num, int64 den) +{ + DIV_CR = DIV_64_64; + while(DIV_CR & DIV_BUSY); + DIV_NUMERATOR64 = num; + DIV_DENOMINATOR64 = den; + while(DIV_CR & DIV_BUSY); + + return (DIV_RESULT32); +} + +inline Fixed Fixed::sqrt() +{ + return Fixed(RAW, nds_sqrt64(((long long)(g))<>= 2 ) + { + if ( ( left & -m ) > root ) + left -= ( root += m ), root += m; + root >>= 1; + } + return Fixed(RAW, root); +} +#endif + +inline Fixed sqrt(Fixed a) { return a.sqrt(); } +inline Fixed sqrtf(Fixed a) { return a.sqrt(); } + +#endif + +#ifdef TARGET_IS_NDS +// Use the libnds lookup tables for trigonometry functions +inline Fixed Fixed::cosf() { + int idx = (((long long)g*(long long)G_1_DIV_PI)>>24)%512; + if(idx < 0) + idx += 512; + return Fixed(RAW, COS_bin[idx] << 4); +} +inline Fixed cosf(Fixed x) { return x.cosf(); } +inline Fixed Fixed::sinf() { + int idx = (((long long)g*(long long)G_1_DIV_PI)>>24)%512; + if(idx < 0) + idx += 512; + return Fixed(RAW, SIN_bin[idx] << 4); +} +inline Fixed sinf(Fixed x) { return x.sinf(); } +inline Fixed Fixed::tanf() { + int idx = (((long long)g*(long long)G_1_DIV_PI)>>24)%512; + if(idx < 0) + idx += 512; + return Fixed(RAW, TAN_bin[idx] << 4); +} +inline Fixed tanf(Fixed x) { return x.tanf(); } + + +#endif diff --git a/Box2D/Source/Common/b2BlockAllocator.cpp b/Box2D/Source/Common/b2BlockAllocator.cpp new file mode 100644 index 0000000..56d595a --- /dev/null +++ b/Box2D/Source/Common/b2BlockAllocator.cpp @@ -0,0 +1,206 @@ +/* +* Copyright (c) 2006-2007 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. +*/ + +#include "b2BlockAllocator.h" +#include +#include +#include +#include + +int32 b2BlockAllocator::s_blockSizes[b2_blockSizes] = +{ + 16, // 0 + 32, // 1 + 64, // 2 + 96, // 3 + 128, // 4 + 160, // 5 + 192, // 6 + 224, // 7 + 256, // 8 + 320, // 9 + 384, // 10 + 448, // 11 + 512, // 12 + 640, // 13 +}; +uint8 b2BlockAllocator::s_blockSizeLookup[b2_maxBlockSize + 1]; +bool b2BlockAllocator::s_blockSizeLookupInitialized; + +struct b2Chunk +{ + int32 blockSize; + b2Block* blocks; +}; + +struct b2Block +{ + b2Block* next; +}; + +b2BlockAllocator::b2BlockAllocator() +{ + b2Assert(b2_blockSizes < UCHAR_MAX); + + m_chunkSpace = b2_chunkArrayIncrement; + m_chunkCount = 0; + m_chunks = (b2Chunk*)b2Alloc(m_chunkSpace * sizeof(b2Chunk)); + + memset(m_chunks, 0, m_chunkSpace * sizeof(b2Chunk)); + memset(m_freeLists, 0, sizeof(m_freeLists)); + + if (s_blockSizeLookupInitialized == false) + { + int32 j = 0; + for (int32 i = 1; i <= b2_maxBlockSize; ++i) + { + b2Assert(j < b2_blockSizes); + if (i <= s_blockSizes[j]) + { + s_blockSizeLookup[i] = (uint8)j; + } + else + { + ++j; + s_blockSizeLookup[i] = (uint8)j; + } + } + + s_blockSizeLookupInitialized = true; + } +} + +b2BlockAllocator::~b2BlockAllocator() +{ + for (int32 i = 0; i < m_chunkCount; ++i) + { + b2Free(m_chunks[i].blocks); + } + + b2Free(m_chunks); +} + +void* b2BlockAllocator::Allocate(int32 size) +{ + if (size == 0) + return NULL; + + b2Assert(0 < size && size <= b2_maxBlockSize); + + int32 index = s_blockSizeLookup[size]; + b2Assert(0 <= index && index < b2_blockSizes); + + if (m_freeLists[index]) + { + b2Block* block = m_freeLists[index]; + m_freeLists[index] = block->next; + return block; + } + else + { + if (m_chunkCount == m_chunkSpace) + { + b2Chunk* oldChunks = m_chunks; + m_chunkSpace += b2_chunkArrayIncrement; + m_chunks = (b2Chunk*)b2Alloc(m_chunkSpace * sizeof(b2Chunk)); + memcpy(m_chunks, oldChunks, m_chunkCount * sizeof(b2Chunk)); + memset(m_chunks + m_chunkCount, 0, b2_chunkArrayIncrement * sizeof(b2Chunk)); + b2Free(oldChunks); + } + + b2Chunk* chunk = m_chunks + m_chunkCount; + chunk->blocks = (b2Block*)b2Alloc(b2_chunkSize); +#if defined(_DEBUG) + memset(chunk->blocks, 0xcd, b2_chunkSize); +#endif + int32 blockSize = s_blockSizes[index]; + chunk->blockSize = blockSize; + int32 blockCount = b2_chunkSize / blockSize; + b2Assert(blockCount * blockSize <= b2_chunkSize); + for (int32 i = 0; i < blockCount - 1; ++i) + { + b2Block* block = (b2Block*)((int8*)chunk->blocks + blockSize * i); + b2Block* next = (b2Block*)((int8*)chunk->blocks + blockSize * (i + 1)); + block->next = next; + } + b2Block* last = (b2Block*)((int8*)chunk->blocks + blockSize * (blockCount - 1)); + last->next = NULL; + + m_freeLists[index] = chunk->blocks->next; + ++m_chunkCount; + + return chunk->blocks; + } +} + +void b2BlockAllocator::Free(void* p, int32 size) +{ + if (size == 0) + { + return; + } + + b2Assert(0 < size && size <= b2_maxBlockSize); + + int32 index = s_blockSizeLookup[size]; + b2Assert(0 <= index && index < b2_blockSizes); + +#ifdef _DEBUG + // Verify the memory address and size is valid. + int32 blockSize = s_blockSizes[index]; + bool found = false; + int32 gap = (int32)((int8*)&m_chunks->blocks - (int8*)m_chunks); + for (int32 i = 0; i < m_chunkCount; ++i) + { + b2Chunk* chunk = m_chunks + i; + if (chunk->blockSize != blockSize) + { + b2Assert( (int8*)p + blockSize <= (int8*)chunk->blocks || + (int8*)chunk->blocks + b2_chunkSize + gap <= (int8*)p); + } + else + { + if ((int8*)chunk->blocks <= (int8*)p && (int8*)p + blockSize <= (int8*)chunk->blocks + b2_chunkSize) + { + found = true; + } + } + } + + b2Assert(found); + + memset(p, 0xfd, blockSize); +#endif + + b2Block* block = (b2Block*)p; + block->next = m_freeLists[index]; + m_freeLists[index] = block; +} + +void b2BlockAllocator::Clear() +{ + for (int32 i = 0; i < m_chunkCount; ++i) + { + b2Free(m_chunks[i].blocks); + } + + m_chunkCount = 0; + memset(m_chunks, 0, m_chunkSpace * sizeof(b2Chunk)); + + memset(m_freeLists, 0, sizeof(m_freeLists)); +} diff --git a/Box2D/Source/Common/b2BlockAllocator.h b/Box2D/Source/Common/b2BlockAllocator.h new file mode 100644 index 0000000..b1c6265 --- /dev/null +++ b/Box2D/Source/Common/b2BlockAllocator.h @@ -0,0 +1,59 @@ +/* +* Copyright (c) 2006-2007 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_BLOCK_ALLOCATOR_H +#define B2_BLOCK_ALLOCATOR_H + +#include "b2Settings.h" + +const int32 b2_chunkSize = 4096; +const int32 b2_maxBlockSize = 640; +const int32 b2_blockSizes = 14; +const int32 b2_chunkArrayIncrement = 128; + +struct b2Block; +struct b2Chunk; + +// This is a small object allocator used for allocating small +// objects that persist for more than one time step. +// See: http://www.codeproject.com/useritems/Small_Block_Allocator.asp +class b2BlockAllocator +{ +public: + b2BlockAllocator(); + ~b2BlockAllocator(); + + void* Allocate(int32 size); + void Free(void* p, int32 size); + + void Clear(); + +private: + + b2Chunk* m_chunks; + int32 m_chunkCount; + int32 m_chunkSpace; + + b2Block* m_freeLists[b2_blockSizes]; + + static int32 s_blockSizes[b2_blockSizes]; + static uint8 s_blockSizeLookup[b2_maxBlockSize + 1]; + static bool s_blockSizeLookupInitialized; +}; + +#endif diff --git a/Box2D/Source/Common/b2Math.cpp b/Box2D/Source/Common/b2Math.cpp new file mode 100644 index 0000000..e67195b --- /dev/null +++ b/Box2D/Source/Common/b2Math.cpp @@ -0,0 +1,54 @@ +/* +* Copyright (c) 2007 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. +*/ + +#include "b2Math.h" + +const b2Vec2 b2Vec2_zero(0.0f, 0.0f); +const b2Mat22 b2Mat22_identity(1.0f, 0.0f, 0.0f, 1.0f); +const b2XForm b2XForm_identity(b2Vec2_zero, b2Mat22_identity); + +void b2Sweep::GetXForm(b2XForm* xf, float32 t) const +{ + // center = p + R * localCenter + if (1.0f - t0 > B2_FLT_EPSILON) + { + float32 alpha = (t - t0) / (1.0f - t0); + xf->position = (1.0f - alpha) * c0 + alpha * c; + float32 angle = (1.0f - alpha) * a0 + alpha * a; + xf->R.Set(angle); + } + else + { + xf->position = c; + xf->R.Set(a); + } + + // Shift to origin + xf->position -= b2Mul(xf->R, localCenter); +} + +void b2Sweep::Advance(float32 t) +{ + if (t0 < t && 1.0f - t0 > B2_FLT_EPSILON) + { + float32 alpha = (t - t0) / (1.0f - t0); + c0 = (1.0f - alpha) * c0 + alpha * c; + a0 = (1.0f - alpha) * a0 + alpha * a; + t0 = t; + } +} diff --git a/Box2D/Source/Common/b2Math.h b/Box2D/Source/Common/b2Math.h new file mode 100644 index 0000000..a253211 --- /dev/null +++ b/Box2D/Source/Common/b2Math.h @@ -0,0 +1,636 @@ +/* +* Copyright (c) 2006-2007 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_MATH_H +#define B2_MATH_H + +#include "b2Settings.h" +#include +#include +#include + +#include + +#ifdef TARGET_FLOAT32_IS_FIXED + +inline Fixed b2Min(const Fixed& a, const Fixed& b) +{ + return a < b ? a : b; +} + +inline Fixed b2Max(const Fixed& a, const Fixed& b) +{ + return a > b ? a : b; +} + +inline Fixed b2Clamp(Fixed a, Fixed low, Fixed high) +{ + return b2Max(low, b2Min(a, high)); +} + +inline bool b2IsValid(Fixed x) +{ + return true; +} + +#define b2Sqrt(x) sqrt(x) +#define b2Atan2(y, x) atan2(y, x) + +#else + +/// This function is used to ensure that a floating point number is +/// not a NaN or infinity. +inline bool b2IsValid(float32 x) +{ +#ifdef _MSC_VER + return _finite(x) != 0; +#else + return finite(x) != 0; +#endif +} + +/// This is a approximate yet fast inverse square-root. +inline float32 b2InvSqrt(float32 x) +{ + union + { + float32 x; + int32 i; + } convert; + + convert.x = x; + float32 xhalf = 0.5f * x; + convert.i = 0x5f3759df - (convert.i >> 1); + x = convert.x; + x = x * (1.5f - xhalf * x * x); + return x; +} + +#define b2Sqrt(x) sqrtf(x) +#define b2Atan2(y, x) atan2f(y, x) + +#endif + +inline float32 b2Abs(float32 a) +{ + return a > 0.0f ? a : -a; +} + +/// A 2D column vector. + +struct b2Vec2 +{ + /// Default constructor does nothing (for performance). + b2Vec2() {} + + /// Construct using coordinates. + b2Vec2(float32 x, float32 y) : x(x), y(y) {} + + /// Set this vector to all zeros. + void SetZero() { x = 0.0f; y = 0.0f; } + + /// Set this vector to some specified coordinates. + void Set(float32 x_, float32 y_) { x = x_; y = y_; } + + /// Negate this vector. + b2Vec2 operator -() const { b2Vec2 v; v.Set(-x, -y); return v; } + + /// Add a vector to this vector. + void operator += (const b2Vec2& v) + { + x += v.x; y += v.y; + } + + /// Subtract a vector from this vector. + void operator -= (const b2Vec2& v) + { + x -= v.x; y -= v.y; + } + + /// Multiply this vector by a scalar. + void operator *= (float32 a) + { + x *= a; y *= a; + } + + /// Get the length of this vector (the norm). + float32 Length() const + { +#ifdef TARGET_FLOAT32_IS_FIXED + float est = b2Abs(x) + b2Abs(y); + if(est == 0.0f) { + return 0.0; + } else if(est < 0.1) { + return (1.0/256.0) * b2Vec2(x<<8, y<<8).Length(); + } else if(est < 180.0f) { + return b2Sqrt(x * x + y * y); + } else { + return 256.0 * (b2Vec2(x>>8, y>>8).Length()); + } +#else + return b2Sqrt(x * x + y * y); +#endif + } + + /// Get the length squared. For performance, use this instead of + /// b2Vec2::Length (if possible). + float32 LengthSquared() const + { + return x * x + y * y; + } + + /// Convert this vector into a unit vector. Returns the length. +#ifdef TARGET_FLOAT32_IS_FIXED + float32 Normalize() + { + float32 length = Length(); + if (length < B2_FLT_EPSILON) + { + return 0.0f; + } +#ifdef NORMALIZE_BY_INVERT_MULTIPLY + if (length < (1.0/16.0)) { + x = x << 4; + y = y << 4; + return (1.0/16.0)*Normalize(); + } else if(length > 16.0) { + x = x >> 4; + y = y >> 4; + return 16.0*Normalize(); + } + float32 invLength = 1.0f / length; + x *= invLength; + y *= invLength; +#else + x /= length; + y /= length; +#endif + return length; + } +#else + float32 Normalize() + { + float32 length = Length(); + if (length < B2_FLT_EPSILON) + { + return 0.0f; + } + float32 invLength = 1.0f / length; + x *= invLength; + y *= invLength; + + return length; + } +#endif + + /// Does this vector contain finite coordinates? + bool IsValid() const + { + return b2IsValid(x) && b2IsValid(y); + } + + float32 x, y; +}; + +/// A 2-by-2 matrix. Stored in column-major order. +struct b2Mat22 +{ + /// The default constructor does nothing (for performance). + b2Mat22() {} + + /// Construct this matrix using columns. + b2Mat22(const b2Vec2& c1, const b2Vec2& c2) + { + col1 = c1; + col2 = c2; + } + + /// Construct this matrix using scalars. + b2Mat22(float32 a11, float32 a12, float32 a21, float32 a22) + { + col1.x = a11; col1.y = a21; + col2.x = a12; col2.y = a22; + } + + /// Construct this matrix using an angle. This matrix becomes + /// an orthonormal rotation matrix. + explicit b2Mat22(float32 angle) + { + float32 c = cosf(angle), s = sinf(angle); + col1.x = c; col2.x = -s; + col1.y = s; col2.y = c; + } + + /// Initialize this matrix using columns. + void Set(const b2Vec2& c1, const b2Vec2& c2) + { + col1 = c1; + col2 = c2; + } + + /// Initialize this matrix using an angle. This matrix becomes + /// an orthonormal rotation matrix. + void Set(float32 angle) + { + float32 c = cosf(angle), s = sinf(angle); + col1.x = c; col2.x = -s; + col1.y = s; col2.y = c; + } + + /// Set this to the identity matrix. + void SetIdentity() + { + col1.x = 1.0f; col2.x = 0.0f; + col1.y = 0.0f; col2.y = 1.0f; + } + + /// Set this matrix to all zeros. + void SetZero() + { + col1.x = 0.0f; col2.x = 0.0f; + col1.y = 0.0f; col2.y = 0.0f; + } + + /// Extract the angle from this matrix (assumed to be + /// a rotation matrix). + float32 GetAngle() const + { + return b2Atan2(col1.y, col1.x); + } + +#ifdef TARGET_FLOAT32_IS_FIXED + + /// Compute the inverse of this matrix, such that inv(A) * A = identity. + b2Mat22 Invert() const + { + float32 a = col1.x, b = col2.x, c = col1.y, d = col2.y; + float32 det = a * d - b * c; + b2Mat22 B; + int n = 0; + + if(b2Abs(det) <= (B2_FLT_EPSILON<<8)) + { + n = 3; + a = a<= 16.0)? 4 : 0; + b2Assert(det != 0.0f); + det = float32(1<> n; B.col2.x = (-det * b) >> n; + B.col1.y = (-det * c) >> n; B.col2.y = ( det * a) >> n; + } + + return B; + } + + // Solve A * x = b + b2Vec2 Solve(const b2Vec2& b) const + { + float32 a11 = col1.x, a12 = col2.x, a21 = col1.y, a22 = col2.y; + float32 det = a11 * a22 - a12 * a21; + int n = 0; + b2Vec2 x; + + + if(b2Abs(det) <= (B2_FLT_EPSILON<<8)) + { + n = 3; + a11 = col1.x<= 16.0) ? 4 : 0; + b2Assert(det != 0.0f); + det = float32(1<> n; + x.y = (det * (a11 * b.y - a21 * b.x)) >> n; + } + + return x; + } + +#else + b2Mat22 Invert() const + { + float32 a = col1.x, b = col2.x, c = col1.y, d = col2.y; + b2Mat22 B; + float32 det = a * d - b * c; + b2Assert(det != 0.0f); + det = float32(1.0f) / det; + B.col1.x = det * d; B.col2.x = -det * b; + B.col1.y = -det * c; B.col2.y = det * a; + return B; + } + + /// Solve A * x = b, where b is a column vector. This is more efficient + /// than computing the inverse in one-shot cases. + b2Vec2 Solve(const b2Vec2& b) const + { + float32 a11 = col1.x, a12 = col2.x, a21 = col1.y, a22 = col2.y; + float32 det = a11 * a22 - a12 * a21; + b2Assert(det != 0.0f); + det = 1.0f / det; + b2Vec2 x; + x.x = det * (a22 * b.x - a12 * b.y); + x.y = det * (a11 * b.y - a21 * b.x); + return x; + } +#endif + + b2Vec2 col1, col2; +}; + +/// A transform contains translation and rotation. It is used to represent +/// the position and orientation of rigid frames. +struct b2XForm +{ + /// The default constructor does nothing (for performance). + b2XForm() {} + + /// Initialize using a position vector and a rotation matrix. + b2XForm(const b2Vec2& position, const b2Mat22& R) : position(position), R(R) {} + + /// Set this to the identity transform. + void SetIdentity() + { + position.SetZero(); + R.SetIdentity(); + } + + b2Vec2 position; + b2Mat22 R; +}; + +/// This describes the motion of a body/shape for TOI computation. +/// Shapes are defined with respect to the body origin, which may +/// no coincide with the center of mass. However, to support dynamics +/// we must interpolate the center of mass position. +struct b2Sweep +{ + /// Get the interpolated transform at a specific time. + /// @param t the normalized time in [0,1]. + void GetXForm(b2XForm* xf, float32 t) const; + + /// Advance the sweep forward, yielding a new initial state. + /// @param t the new initial time. + void Advance(float32 t); + + b2Vec2 localCenter; ///< local center of mass position + b2Vec2 c0, c; ///< center world positions + float32 a0, a; ///< world angles + float32 t0; ///< time interval = [t0,1], where t0 is in [0,1] +}; + + +extern const b2Vec2 b2Vec2_zero; +extern const b2Mat22 b2Mat22_identity; +extern const b2XForm b2XForm_identity; + +/// Peform the dot product on two vectors. +inline float32 b2Dot(const b2Vec2& a, const b2Vec2& b) +{ + return a.x * b.x + a.y * b.y; +} + +/// Perform the cross product on two vectors. In 2D this produces a scalar. +inline float32 b2Cross(const b2Vec2& a, const b2Vec2& b) +{ + return a.x * b.y - a.y * b.x; +} + +/// Perform the cross product on a vector and a scalar. In 2D this produces +/// a vector. +inline b2Vec2 b2Cross(const b2Vec2& a, float32 s) +{ + b2Vec2 v; v.Set(s * a.y, -s * a.x); + return v; +} + +/// Perform the cross product on a scalar and a vector. In 2D this produces +/// a vector. +inline b2Vec2 b2Cross(float32 s, const b2Vec2& a) +{ + b2Vec2 v; v.Set(-s * a.y, s * a.x); + return v; +} + +/// Multiply a matrix times a vector. If a rotation matrix is provided, +/// then this transforms the vector from one frame to another. +inline b2Vec2 b2Mul(const b2Mat22& A, const b2Vec2& v) +{ + b2Vec2 u; + u.Set(A.col1.x * v.x + A.col2.x * v.y, A.col1.y * v.x + A.col2.y * v.y); + return u; +} + +/// Multiply a matrix transpose times a vector. If a rotation matrix is provided, +/// then this transforms the vector from one frame to another (inverse transform). +inline b2Vec2 b2MulT(const b2Mat22& A, const b2Vec2& v) +{ + b2Vec2 u; + u.Set(b2Dot(v, A.col1), b2Dot(v, A.col2)); + return u; +} + +/// Add two vectors component-wise. +inline b2Vec2 operator + (const b2Vec2& a, const b2Vec2& b) +{ + b2Vec2 v; v.Set(a.x + b.x, a.y + b.y); + return v; +} + +/// Subtract two vectors component-wise. +inline b2Vec2 operator - (const b2Vec2& a, const b2Vec2& b) +{ + b2Vec2 v; v.Set(a.x - b.x, a.y - b.y); + return v; +} + +inline b2Vec2 operator * (float32 s, const b2Vec2& a) +{ + b2Vec2 v; v.Set(s * a.x, s * a.y); + return v; +} + +inline bool operator == (const b2Vec2& a, const b2Vec2& b) +{ + return a.x == b.x && a.y == b.y; +} + +inline float32 b2Distance(const b2Vec2& a, const b2Vec2& b) +{ + b2Vec2 c = a - b; + return c.Length(); +} + +inline float32 b2DistanceSquared(const b2Vec2& a, const b2Vec2& b) +{ + b2Vec2 c = a - b; + return b2Dot(c, c); +} + +inline b2Mat22 operator + (const b2Mat22& A, const b2Mat22& B) +{ + b2Mat22 C; + C.Set(A.col1 + B.col1, A.col2 + B.col2); + return C; +} + +// A * B +inline b2Mat22 b2Mul(const b2Mat22& A, const b2Mat22& B) +{ + b2Mat22 C; + C.Set(b2Mul(A, B.col1), b2Mul(A, B.col2)); + return C; +} + +// A^T * B +inline b2Mat22 b2MulT(const b2Mat22& A, const b2Mat22& B) +{ + b2Vec2 c1; c1.Set(b2Dot(A.col1, B.col1), b2Dot(A.col2, B.col1)); + b2Vec2 c2; c2.Set(b2Dot(A.col1, B.col2), b2Dot(A.col2, B.col2)); + b2Mat22 C; + C.Set(c1, c2); + return C; +} + +inline b2Vec2 b2Mul(const b2XForm& T, const b2Vec2& v) +{ + return T.position + b2Mul(T.R, v); +} + +inline b2Vec2 b2MulT(const b2XForm& T, const b2Vec2& v) +{ + return b2MulT(T.R, v - T.position); +} + +inline b2Vec2 b2Abs(const b2Vec2& a) +{ + b2Vec2 b; b.Set(b2Abs(a.x), b2Abs(a.y)); + return b; +} + +inline b2Mat22 b2Abs(const b2Mat22& A) +{ + b2Mat22 B; + B.Set(b2Abs(A.col1), b2Abs(A.col2)); + return B; +} + +template +inline T b2Min(T a, T b) +{ + return a < b ? a : b; +} + +inline b2Vec2 b2Min(const b2Vec2& a, const b2Vec2& b) +{ + b2Vec2 c; + c.x = b2Min(a.x, b.x); + c.y = b2Min(a.y, b.y); + return c; +} + +template +inline T b2Max(T a, T b) +{ + return a > b ? a : b; +} + +inline b2Vec2 b2Max(const b2Vec2& a, const b2Vec2& b) +{ + b2Vec2 c; + c.x = b2Max(a.x, b.x); + c.y = b2Max(a.y, b.y); + return c; +} + +template +inline T b2Clamp(T a, T low, T high) +{ + return b2Max(low, b2Min(a, high)); +} + +inline b2Vec2 b2Clamp(const b2Vec2& a, const b2Vec2& low, const b2Vec2& high) +{ + return b2Max(low, b2Min(a, high)); +} + +template inline void b2Swap(T& a, T& b) +{ + T tmp = a; + a = b; + b = tmp; +} + +#define RAND_LIMIT 32767 + +// Random number in range [-1,1] +inline float32 b2Random() +{ + float32 r = (float32)(rand() & (RAND_LIMIT)); + r /= RAND_LIMIT; + r = 2.0f * r - 1.0f; + return r; +} + +/// Random floating point number in range [lo, hi] +inline float32 b2Random(float32 lo, float32 hi) +{ + float32 r = (float32)(rand() & (RAND_LIMIT)); + r /= RAND_LIMIT; + r = (hi - lo) * r + lo; + return r; +} + +/// "Next Largest Power of 2 +/// Given a binary integer value x, the next largest power of 2 can be computed by a SWAR algorithm +/// that recursively "folds" the upper bits into the lower bits. This process yields a bit vector with +/// the same most significant 1 as x, but all 1's below it. Adding 1 to that value yields the next +/// largest power of 2. For a 32-bit value:" +inline uint32 b2NextPowerOfTwo(uint32 x) +{ + x |= (x >> 1); + x |= (x >> 2); + x |= (x >> 4); + x |= (x >> 8); + x |= (x >> 16); + return x + 1; +} + +inline bool b2IsPowerOfTwo(uint32 x) +{ + bool result = x > 0 && (x & (x - 1)) == 0; + return result; +} + +#endif diff --git a/Box2D/Source/Common/b2Settings.cpp b/Box2D/Source/Common/b2Settings.cpp new file mode 100644 index 0000000..16ffe63 --- /dev/null +++ b/Box2D/Source/Common/b2Settings.cpp @@ -0,0 +1,51 @@ +/* +* Copyright (c) 2006-2007 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. +*/ + +#include "b2Settings.h" +#include + +b2Version b2_version = {2, 0, 1}; + +int32 b2_byteCount = 0; + + + +// Memory allocators. Modify these to use your own allocator. +void* b2Alloc(int32 size) +{ + size += 4; + b2_byteCount += size; + char* bytes = (char*)malloc(size); + *(int32*)bytes = size; + return bytes + 4; +} + +void b2Free(void* mem) +{ + if (mem == NULL) + { + return; + } + + char* bytes = (char*)mem; + bytes -= 4; + int32 size = *(int32*)bytes; + b2Assert(b2_byteCount >= size); + b2_byteCount -= size; + free(bytes); +} diff --git a/Box2D/Source/Common/b2Settings.h b/Box2D/Source/Common/b2Settings.h new file mode 100644 index 0000000..0c75823 --- /dev/null +++ b/Box2D/Source/Common/b2Settings.h @@ -0,0 +1,176 @@ +/* +* Copyright (c) 2006-2007 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 +#include + +#define B2_NOT_USED(x) x +#define b2Assert(A) assert(A) + + +// need to include NDS jtypes.h instead of +// usual typedefs because NDS jtypes defines +// them slightly differently, oh well. +#ifdef TARGET_IS_NDS + +#include "jtypes.h" + +#else + +typedef signed char int8; +typedef signed short int16; +typedef signed int int32; +typedef unsigned char uint8; +typedef unsigned short uint16; +typedef unsigned int uint32; + +#endif + +#ifdef TARGET_FLOAT32_IS_FIXED + +#include "Fixed.h" + +typedef Fixed float32; +#define B2_FLT_MAX FIXED_MAX +#define B2_FLT_EPSILON FIXED_EPSILON +#define B2FORCE_SCALE(x) ((x)<<7) +#define B2FORCE_INV_SCALE(x) ((x)>>7) + +#else + +typedef float float32; +#define B2_FLT_MAX FLT_MAX +#define B2_FLT_EPSILON FLT_EPSILON +#define B2FORCE_SCALE(x) (x) +#define B2FORCE_INV_SCALE(x) (x) + +#endif + +const float32 b2_pi = 3.14159265359f; + +/// @file +/// Global tuning constants based on meters-kilograms-seconds (MKS) units. +/// + +// Collision +const int32 b2_maxManifoldPoints = 2; +const int32 b2_maxPolygonVertices = 8; +const int32 b2_maxProxies = 512; // this must be a power of two +const int32 b2_maxPairs = 8 * b2_maxProxies; // this must be a power of two + +// Dynamics + +/// A small length used as a collision and constraint tolerance. Usually it is +/// chosen to be numerically significant, but visually insignificant. +const float32 b2_linearSlop = 0.005f; // 0.5 cm + +/// A small angle used as a collision and constraint tolerance. Usually it is +/// chosen to be numerically significant, but visually insignificant. +const float32 b2_angularSlop = 2.0f / 180.0f * b2_pi; // 2 degrees + +/// Continuous collision detection (CCD) works with core, shrunken shapes. This is the +/// amount by which shapes are automatically shrunk to work with CCD. This must be +/// larger than b2_linearSlop. +const float32 b2_toiSlop = 8.0f * b2_linearSlop; + +/// Maximum number of contacts to be handled to solve a TOI island. +const int32 b2_maxTOIContactsPerIsland = 32; + +/// A velocity threshold for elastic collisions. Any collision with a relative linear +/// velocity below this threshold will be treated as inelastic. +const float32 b2_velocityThreshold = 1.0f; // 1 m/s + +/// The maximum linear position correction used when solving constraints. This helps to +/// prevent overshoot. +const float32 b2_maxLinearCorrection = 0.2f; // 20 cm + +/// The maximum angular position correction used when solving constraints. This helps to +/// prevent overshoot. +const float32 b2_maxAngularCorrection = 8.0f / 180.0f * b2_pi; // 8 degrees + +/// 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. +#ifdef TARGET_FLOAT32_IS_FIXED +const float32 b2_maxLinearVelocity = 100.0f; +#else +const float32 b2_maxLinearVelocity = 200.0f; +const float32 b2_maxLinearVelocitySquared = b2_maxLinearVelocity * b2_maxLinearVelocity; +#endif + +/// 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. +const float32 b2_maxAngularVelocity = 250.0f; +#ifndef TARGET_FLOAT32_IS_FIXED +const float32 b2_maxAngularVelocitySquared = b2_maxAngularVelocity * b2_maxAngularVelocity; +#endif + +/// 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. +const float32 b2_contactBaumgarte = 0.2f; + +// Sleep + +/// The time that a body must be still before it will go to sleep. +const float32 b2_timeToSleep = 0.5f; // half a second + +/// A body cannot sleep if its linear velocity is above this tolerance. +const float32 b2_linearSleepTolerance = 0.01f; // 1 cm/s + +/// A body cannot sleep if its angular velocity is above this tolerance. +const float32 b2_angularSleepTolerance = 2.0f / 180.0f; // 2 degrees/s + +// Memory Allocation + +/// The current number of bytes allocated through b2Alloc. +extern int32 b2_byteCount; + +/// 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 float32 b2MixFriction(float32 friction1, float32 friction2) +{ + return sqrtf(friction1 * friction2); +} + +/// Restitution mixing law. Feel free to customize this. +inline float32 b2MixRestitution(float32 restitution1, float32 restitution2) +{ + return restitution1 > restitution2 ? restitution1 : restitution2; +} + +#endif diff --git a/Box2D/Source/Common/b2StackAllocator.cpp b/Box2D/Source/Common/b2StackAllocator.cpp new file mode 100644 index 0000000..aaa5e78 --- /dev/null +++ b/Box2D/Source/Common/b2StackAllocator.cpp @@ -0,0 +1,83 @@ +/* +* Copyright (c) 2006-2007 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. +*/ + +#include "b2StackAllocator.h" +#include "b2Math.h" + +b2StackAllocator::b2StackAllocator() +{ + m_index = 0; + m_allocation = 0; + m_maxAllocation = 0; + m_entryCount = 0; +} + +b2StackAllocator::~b2StackAllocator() +{ + b2Assert(m_index == 0); + b2Assert(m_entryCount == 0); +} + +void* b2StackAllocator::Allocate(int32 size) +{ + b2Assert(m_entryCount < b2_maxStackEntries); + + b2StackEntry* entry = m_entries + m_entryCount; + entry->size = size; + if (m_index + size > b2_stackSize) + { + entry->data = (char*)b2Alloc(size); + entry->usedMalloc = true; + } + else + { + entry->data = m_data + m_index; + entry->usedMalloc = false; + m_index += size; + } + + m_allocation += size; + m_maxAllocation = b2Max(m_maxAllocation, m_allocation); + ++m_entryCount; + + return entry->data; +} + +void b2StackAllocator::Free(void* p) +{ + b2Assert(m_entryCount > 0); + b2StackEntry* entry = m_entries + m_entryCount - 1; + b2Assert(p == entry->data); + if (entry->usedMalloc) + { + b2Free(p); + } + else + { + m_index -= entry->size; + } + m_allocation -= entry->size; + --m_entryCount; + + p = NULL; +} + +int32 b2StackAllocator::GetMaxAllocation() const +{ + return m_maxAllocation; +} diff --git a/Box2D/Source/Common/b2StackAllocator.h b/Box2D/Source/Common/b2StackAllocator.h new file mode 100644 index 0000000..bcdb8e5 --- /dev/null +++ b/Box2D/Source/Common/b2StackAllocator.h @@ -0,0 +1,60 @@ +/* +* Copyright (c) 2006-2007 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_STACK_ALLOCATOR_H +#define B2_STACK_ALLOCATOR_H + +#include "b2Settings.h" + +const int32 b2_stackSize = 100 * 1024; // 100k +const int32 b2_maxStackEntries = 32; + +struct b2StackEntry +{ + char* data; + int32 size; + bool usedMalloc; +}; + +// This is a stack allocator used for fast per step allocations. +// You must nest allocate/free pairs. The code will assert +// if you try to interleave multiple allocate/free pairs. +class b2StackAllocator +{ +public: + b2StackAllocator(); + ~b2StackAllocator(); + + void* Allocate(int32 size); + void Free(void* p); + + int32 GetMaxAllocation() const; + +private: + + char m_data[b2_stackSize]; + int32 m_index; + + int32 m_allocation; + int32 m_maxAllocation; + + b2StackEntry m_entries[b2_maxStackEntries]; + int32 m_entryCount; +}; + +#endif diff --git a/Box2D/Source/Common/jtypes.h b/Box2D/Source/Common/jtypes.h new file mode 100644 index 0000000..9f22454 --- /dev/null +++ b/Box2D/Source/Common/jtypes.h @@ -0,0 +1,139 @@ +/*--------------------------------------------------------------------------------- + $Id: jtypes.h,v 1.17 2007/07/18 05:20:45 wntrmute Exp $ + + jtypes.h -- Common types (and a few useful macros) + + Copyright (C) 2005 + Michael Noland (joat) + Jason Rogers (dovoto) + Dave Murphy (WinterMute) + Chris Double (doublec) + + 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 NDS_JTYPES_INCLUDE +#define NDS_JTYPES_INCLUDE +//--------------------------------------------------------------------------------- + + +#define PACKED __attribute__ ((packed)) +#define packed_struct struct PACKED + +//--------------------------------------------------------------------------------- +// libgba compatible section macros +//--------------------------------------------------------------------------------- +#define ITCM_CODE __attribute__((section(".itcm"), long_call)) + +#define DTCM_DATA __attribute__((section(".dtcm"))) +#define DTCM_BSS __attribute__((section(".sbss"))) +#define ALIGN(m) __attribute__((aligned (m))) + +#define PACKED __attribute__ ((packed)) +#define packed_struct struct PACKED + +//--------------------------------------------------------------------------------- +// These are linked to the bin2o macro in the Makefile +//--------------------------------------------------------------------------------- +#define GETRAW(name) (name) +#define GETRAWSIZE(name) ((int)name##_size) +#define GETRAWEND(name) ((int)name##_end) + +#ifndef TRUE +#define TRUE 1 +#define FALSE 0 +#endif + +#define BIT(n) (1 << (n)) + +// define libnds types in terms of stdint +#include + +typedef uint8_t uint8; +typedef uint16_t uint16; +typedef uint32_t uint32; +typedef uint64_t uint64; + +typedef int8_t int8; +typedef int16_t int16; +typedef int32_t int32; +typedef int64_t int64; + +//typedef float float32; +typedef double float64; + +typedef volatile uint8_t vuint8; +typedef volatile uint16_t vuint16; +typedef volatile uint32_t vuint32; +typedef volatile uint64_t vuint64; + +typedef volatile int8_t vint8; +typedef volatile int16_t vint16; +typedef volatile int32_t vint32; +typedef volatile int64_t vint64; + +typedef volatile float vfloat32; +typedef volatile float64 vfloat64; + +typedef uint8_t byte; + +typedef uint8_t u8; +typedef uint16_t u16; +typedef uint32_t u32; +typedef uint64_t u64; + +typedef int8_t s8; +typedef int16_t s16; +typedef int32_t s32; +typedef int64_t s64; + +typedef volatile u8 vu8; +typedef volatile u16 vu16; +typedef volatile u32 vu32; +typedef volatile u64 vu64; + +typedef volatile s8 vs8; +typedef volatile s16 vs16; +typedef volatile s32 vs32; +typedef volatile s64 vs64; + +typedef struct touchPosition { + int16 x; + int16 y; + int16 px; + int16 py; + int16 z1; + int16 z2; +} touchPosition; + + +#ifndef __cplusplus +/** C++ compatible bool for C + +*/ +typedef enum { false, true } bool; +#endif + +// Handy function pointer typedefs +typedef void ( * IntFn)(void); +typedef void (* VoidFunctionPointer)(void); +typedef void (* fp)(void); + +//--------------------------------------------------------------------------------- +#endif +//--------------------------------------------------------------------------------- diff --git a/Box2D/Source/Dynamics/Contacts/b2CircleContact.cpp b/Box2D/Source/Dynamics/Contacts/b2CircleContact.cpp new file mode 100644 index 0000000..af25138 --- /dev/null +++ b/Box2D/Source/Dynamics/Contacts/b2CircleContact.cpp @@ -0,0 +1,122 @@ +/* +* Copyright (c) 2006-2007 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. +*/ + +#include "b2CircleContact.h" +#include "../b2Body.h" +#include "../b2WorldCallbacks.h" +#include "../../Common/b2BlockAllocator.h" + +#include +#include + +b2Contact* b2CircleContact::Create(b2Shape* shape1, b2Shape* shape2, b2BlockAllocator* allocator) +{ + void* mem = allocator->Allocate(sizeof(b2CircleContact)); + return new (mem) b2CircleContact(shape1, shape2); +} + +void b2CircleContact::Destroy(b2Contact* contact, b2BlockAllocator* allocator) +{ + ((b2CircleContact*)contact)->~b2CircleContact(); + allocator->Free(contact, sizeof(b2CircleContact)); +} + +b2CircleContact::b2CircleContact(b2Shape* s1, b2Shape* s2) +: b2Contact(s1, s2) +{ + b2Assert(m_shape1->GetType() == e_circleShape); + b2Assert(m_shape2->GetType() == e_circleShape); + m_manifold.pointCount = 0; + m_manifold.points[0].normalImpulse = 0.0f; + m_manifold.points[0].tangentImpulse = 0.0f; +} + +void b2CircleContact::Evaluate(b2ContactListener* listener) +{ + b2Body* b1 = m_shape1->GetBody(); + b2Body* b2 = m_shape2->GetBody(); + + b2Manifold m0; + memcpy(&m0, &m_manifold, sizeof(b2Manifold)); + + b2CollideCircles(&m_manifold, (b2CircleShape*)m_shape1, b1->GetXForm(), (b2CircleShape*)m_shape2, b2->GetXForm()); + + b2ContactPoint cp; + cp.shape1 = m_shape1; + cp.shape2 = m_shape2; + cp.friction = m_friction; + cp.restitution = m_restitution; + + if (m_manifold.pointCount > 0) + { + m_manifoldCount = 1; + b2ManifoldPoint* mp = m_manifold.points + 0; + + if (m0.pointCount == 0) + { + mp->normalImpulse = 0.0f; + mp->tangentImpulse = 0.0f; + + if (listener) + { + cp.position = b1->GetWorldPoint(mp->localPoint1); + b2Vec2 v1 = b1->GetLinearVelocityFromLocalPoint(mp->localPoint1); + b2Vec2 v2 = b2->GetLinearVelocityFromLocalPoint(mp->localPoint2); + cp.velocity = v2 - v1; + cp.normal = m_manifold.normal; + cp.separation = mp->separation; + cp.id = mp->id; + listener->Add(&cp); + } + } + else + { + b2ManifoldPoint* mp0 = m0.points + 0; + mp->normalImpulse = mp0->normalImpulse; + mp->tangentImpulse = mp0->tangentImpulse; + + if (listener) + { + cp.position = b1->GetWorldPoint(mp->localPoint1); + b2Vec2 v1 = b1->GetLinearVelocityFromLocalPoint(mp->localPoint1); + b2Vec2 v2 = b2->GetLinearVelocityFromLocalPoint(mp->localPoint2); + cp.velocity = v2 - v1; + cp.normal = m_manifold.normal; + cp.separation = mp->separation; + cp.id = mp->id; + listener->Persist(&cp); + } + } + } + else + { + m_manifoldCount = 0; + if (m0.pointCount > 0 && listener) + { + b2ManifoldPoint* mp0 = m0.points + 0; + cp.position = b1->GetWorldPoint(mp0->localPoint1); + b2Vec2 v1 = b1->GetLinearVelocityFromLocalPoint(mp0->localPoint1); + b2Vec2 v2 = b2->GetLinearVelocityFromLocalPoint(mp0->localPoint2); + cp.velocity = v2 - v1; + cp.normal = m0.normal; + cp.separation = mp0->separation; + cp.id = mp0->id; + listener->Remove(&cp); + } + } +} diff --git a/Box2D/Source/Dynamics/Contacts/b2CircleContact.h b/Box2D/Source/Dynamics/Contacts/b2CircleContact.h new file mode 100644 index 0000000..647347b --- /dev/null +++ b/Box2D/Source/Dynamics/Contacts/b2CircleContact.h @@ -0,0 +1,46 @@ +/* +* Copyright (c) 2006-2007 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 CIRCLE_CONTACT_H +#define CIRCLE_CONTACT_H + +#include "../../Common/b2Math.h" +#include "../../Collision/b2Collision.h" +#include "b2Contact.h" + +class b2BlockAllocator; + +class b2CircleContact : public b2Contact +{ +public: + static b2Contact* Create(b2Shape* shape1, b2Shape* shape2, b2BlockAllocator* allocator); + static void Destroy(b2Contact* contact, b2BlockAllocator* allocator); + + b2CircleContact(b2Shape* shape1, b2Shape* shape2); + ~b2CircleContact() {} + + void Evaluate(b2ContactListener* listener); + b2Manifold* GetManifolds() + { + return &m_manifold; + } + + b2Manifold m_manifold; +}; + +#endif diff --git a/Box2D/Source/Dynamics/Contacts/b2Contact.cpp b/Box2D/Source/Dynamics/Contacts/b2Contact.cpp new file mode 100644 index 0000000..addbeb0 --- /dev/null +++ b/Box2D/Source/Dynamics/Contacts/b2Contact.cpp @@ -0,0 +1,172 @@ +/* +* Copyright (c) 2006-2007 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. +*/ + +#include "b2Contact.h" +#include "b2CircleContact.h" +#include "b2PolyAndCircleContact.h" +#include "b2PolyContact.h" +#include "b2ContactSolver.h" +#include "../../Collision/b2Collision.h" +#include "../../Collision/Shapes/b2Shape.h" +#include "../../Common/b2BlockAllocator.h" +#include "../../Dynamics/b2World.h" +#include "../../Dynamics/b2Body.h" + +b2ContactRegister b2Contact::s_registers[e_shapeTypeCount][e_shapeTypeCount]; +bool b2Contact::s_initialized = false; + +void b2Contact::InitializeRegisters() +{ + AddType(b2CircleContact::Create, b2CircleContact::Destroy, e_circleShape, e_circleShape); + AddType(b2PolyAndCircleContact::Create, b2PolyAndCircleContact::Destroy, e_polygonShape, e_circleShape); + AddType(b2PolygonContact::Create, b2PolygonContact::Destroy, e_polygonShape, e_polygonShape); +} + +void b2Contact::AddType(b2ContactCreateFcn* createFcn, b2ContactDestroyFcn* destoryFcn, + b2ShapeType type1, b2ShapeType type2) +{ + b2Assert(e_unknownShape < type1 && type1 < e_shapeTypeCount); + b2Assert(e_unknownShape < type2 && type2 < e_shapeTypeCount); + + s_registers[type1][type2].createFcn = createFcn; + s_registers[type1][type2].destroyFcn = destoryFcn; + s_registers[type1][type2].primary = true; + + if (type1 != type2) + { + s_registers[type2][type1].createFcn = createFcn; + s_registers[type2][type1].destroyFcn = destoryFcn; + s_registers[type2][type1].primary = false; + } +} + +b2Contact* b2Contact::Create(b2Shape* shape1, b2Shape* shape2, b2BlockAllocator* allocator) +{ + if (s_initialized == false) + { + InitializeRegisters(); + s_initialized = true; + } + + b2ShapeType type1 = shape1->GetType(); + b2ShapeType type2 = shape2->GetType(); + + b2Assert(e_unknownShape < type1 && type1 < e_shapeTypeCount); + b2Assert(e_unknownShape < type2 && type2 < e_shapeTypeCount); + + b2ContactCreateFcn* createFcn = s_registers[type1][type2].createFcn; + if (createFcn) + { + if (s_registers[type1][type2].primary) + { + return createFcn(shape1, shape2, allocator); + } + else + { + b2Contact* c = createFcn(shape2, shape1, allocator); + for (int32 i = 0; i < c->GetManifoldCount(); ++i) + { + b2Manifold* m = c->GetManifolds() + i; + m->normal = -m->normal; + } + return c; + } + } + else + { + return NULL; + } +} + +void b2Contact::Destroy(b2Contact* contact, b2BlockAllocator* allocator) +{ + b2Assert(s_initialized == true); + + if (contact->GetManifoldCount() > 0) + { + contact->GetShape1()->GetBody()->WakeUp(); + contact->GetShape2()->GetBody()->WakeUp(); + } + + b2ShapeType type1 = contact->GetShape1()->GetType(); + b2ShapeType type2 = contact->GetShape2()->GetType(); + + b2Assert(e_unknownShape < type1 && type1 < e_shapeTypeCount); + b2Assert(e_unknownShape < type2 && type2 < e_shapeTypeCount); + + b2ContactDestroyFcn* destroyFcn = s_registers[type1][type2].destroyFcn; + destroyFcn(contact, allocator); +} + +b2Contact::b2Contact(b2Shape* s1, b2Shape* s2) +{ + m_flags = 0; + + if (s1->IsSensor() || s2->IsSensor()) + { + m_flags |= e_nonSolidFlag; + } + + m_shape1 = s1; + m_shape2 = s2; + + m_manifoldCount = 0; + + m_friction = b2MixFriction(m_shape1->GetFriction(), m_shape2->GetFriction()); + m_restitution = b2MixRestitution(m_shape1->GetRestitution(), m_shape2->GetRestitution()); + m_prev = NULL; + m_next = NULL; + + m_node1.contact = NULL; + m_node1.prev = NULL; + m_node1.next = NULL; + m_node1.other = NULL; + + m_node2.contact = NULL; + m_node2.prev = NULL; + m_node2.next = NULL; + m_node2.other = NULL; +} + +void b2Contact::Update(b2ContactListener* listener) +{ + int32 oldCount = GetManifoldCount(); + + Evaluate(listener); + + int32 newCount = GetManifoldCount(); + + b2Body* body1 = m_shape1->GetBody(); + b2Body* body2 = m_shape2->GetBody(); + + if (newCount == 0 && oldCount > 0) + { + body1->WakeUp(); + body2->WakeUp(); + } + + // Slow contacts don't generate TOI events. + if (body1->IsStatic() || body1->IsBullet() || body2->IsStatic() || body2->IsBullet()) + { + m_flags &= ~e_slowFlag; + } + else + { + m_flags |= e_slowFlag; + } +} diff --git a/Box2D/Source/Dynamics/Contacts/b2Contact.h b/Box2D/Source/Dynamics/Contacts/b2Contact.h new file mode 100644 index 0000000..25cee8e --- /dev/null +++ b/Box2D/Source/Dynamics/Contacts/b2Contact.h @@ -0,0 +1,183 @@ +/* +* Copyright (c) 2006-2007 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 CONTACT_H +#define CONTACT_H + +#include "../../Common/b2Math.h" +#include "../../Collision/b2Collision.h" +#include "../../Collision/Shapes/b2Shape.h" + +class b2Body; +class b2Contact; +class b2World; +class b2BlockAllocator; +class b2StackAllocator; +class b2ContactListener; + +typedef b2Contact* b2ContactCreateFcn(b2Shape* shape1, b2Shape* shape2, b2BlockAllocator* allocator); +typedef void b2ContactDestroyFcn(b2Contact* contact, b2BlockAllocator* allocator); + +struct b2ContactRegister +{ + b2ContactCreateFcn* createFcn; + b2ContactDestroyFcn* destroyFcn; + bool primary; +}; + +/// A contact edge is used to connect bodies and contacts together +/// in a contact graph where each body is a node and each contact +/// is an edge. A contact edge belongs to a doubly linked list +/// maintained in each attached body. Each contact has two contact +/// nodes, one for each attached body. +struct b2ContactEdge +{ + b2Body* other; ///< provides quick access to the other body attached. + b2Contact* contact; ///< the contact + b2ContactEdge* prev; ///< the previous contact edge in the body's contact list + b2ContactEdge* next; ///< the next contact edge in the body's contact list +}; + +/// This structure is used to report contact points. +struct b2ContactPoint +{ + b2Shape* shape1; ///< the first shape + b2Shape* shape2; ///< the second shape + b2Vec2 position; ///< position in world coordinates + b2Vec2 velocity; ///< velocity of point on body2 relative to point on body1 (pre-solver) + b2Vec2 normal; ///< points from shape1 to shape2 + float32 separation; ///< the separation is negative when shapes are touching + float32 friction; ///< the combined friction coefficient + float32 restitution; ///< the combined restitution coefficient + b2ContactID id; ///< the contact id identifies the features in contact +}; + +/// This structure is used to report contact point results. +struct b2ContactResult +{ + b2Shape* shape1; ///< the first shape + b2Shape* shape2; ///< the second shape + b2Vec2 position; ///< position in world coordinates + b2Vec2 normal; ///< points from shape1 to shape2 + float32 normalImpulse; ///< the normal impulse applied to body2 + float32 tangentImpulse; ///< the tangent impulse applied to body2 + b2ContactID id; ///< the contact id identifies the features in contact +}; + +/// The class manages contact between two shapes. A contact exists for each overlapping +/// AABB in the broad-phase (except if filtered). Therefore a contact object may exist +/// that has no contact points. +class b2Contact +{ +public: + + /// Get the manifold array. + virtual b2Manifold* GetManifolds() = 0; + + /// Get the number of manifolds. This is 0 or 1 between convex shapes. + /// This may be greater than 1 for convex-vs-concave shapes. Each + /// manifold holds up to two contact points with a shared contact normal. + int32 GetManifoldCount() const; + + /// Is this contact solid? + /// @return true if this contact should generate a response. + bool IsSolid() const; + + /// Get the next contact in the world's contact list. + b2Contact* GetNext(); + + /// Get the first shape in this contact. + b2Shape* GetShape1(); + + /// Get the second shape in this contact. + b2Shape* GetShape2(); + + //--------------- Internals Below ------------------- +public: + + // m_flags + enum + { + e_nonSolidFlag = 0x0001, + e_slowFlag = 0x0002, + e_islandFlag = 0x0004, + e_toiFlag = 0x0008, + }; + + static void AddType(b2ContactCreateFcn* createFcn, b2ContactDestroyFcn* destroyFcn, + b2ShapeType type1, b2ShapeType type2); + static void InitializeRegisters(); + static b2Contact* Create(b2Shape* shape1, b2Shape* shape2, b2BlockAllocator* allocator); + static void Destroy(b2Contact* contact, b2BlockAllocator* allocator); + + b2Contact() : m_shape1(NULL), m_shape2(NULL) {} + b2Contact(b2Shape* shape1, b2Shape* shape2); + virtual ~b2Contact() {} + + void Update(b2ContactListener* listener); + virtual void Evaluate(b2ContactListener* listener) = 0; + static b2ContactRegister s_registers[e_shapeTypeCount][e_shapeTypeCount]; + static bool s_initialized; + + uint32 m_flags; + int32 m_manifoldCount; + + // World pool and list pointers. + b2Contact* m_prev; + b2Contact* m_next; + + // Nodes for connecting bodies. + b2ContactEdge m_node1; + b2ContactEdge m_node2; + + b2Shape* m_shape1; + b2Shape* m_shape2; + + // Combined friction + float32 m_friction; + float32 m_restitution; + + float32 m_toi; +}; + +inline int32 b2Contact::GetManifoldCount() const +{ + return m_manifoldCount; +} + +inline bool b2Contact::IsSolid() const +{ + return (m_flags & e_nonSolidFlag) == 0; +} + +inline b2Contact* b2Contact::GetNext() +{ + return m_next; +} + +inline b2Shape* b2Contact::GetShape1() +{ + return m_shape1; +} + +inline b2Shape* b2Contact::GetShape2() +{ + return m_shape2; +} + +#endif diff --git a/Box2D/Source/Dynamics/Contacts/b2ContactSolver.cpp b/Box2D/Source/Dynamics/Contacts/b2ContactSolver.cpp new file mode 100644 index 0000000..e481546 --- /dev/null +++ b/Box2D/Source/Dynamics/Contacts/b2ContactSolver.cpp @@ -0,0 +1,360 @@ +/* +* Copyright (c) 2006-2007 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. +*/ + +#include "b2ContactSolver.h" +#include "b2Contact.h" +#include "../b2Body.h" +#include "../b2World.h" +#include "../../Common/b2StackAllocator.h" + +b2ContactSolver::b2ContactSolver(const b2TimeStep& step, b2Contact** contacts, int32 contactCount, b2StackAllocator* allocator) +{ + m_step = step; + m_allocator = allocator; + + m_constraintCount = 0; + for (int32 i = 0; i < contactCount; ++i) + { + b2Assert(contacts[i]->IsSolid()); + m_constraintCount += contacts[i]->GetManifoldCount(); + } + + m_constraints = (b2ContactConstraint*)m_allocator->Allocate(m_constraintCount * sizeof(b2ContactConstraint)); + + int32 count = 0; + for (int32 i = 0; i < contactCount; ++i) + { + b2Contact* contact = contacts[i]; + + b2Body* b1 = contact->m_shape1->GetBody(); + b2Body* b2 = contact->m_shape2->GetBody(); + int32 manifoldCount = contact->GetManifoldCount(); + b2Manifold* manifolds = contact->GetManifolds(); + float32 friction = contact->m_friction; + float32 restitution = contact->m_restitution; + + b2Vec2 v1 = b1->m_linearVelocity; + b2Vec2 v2 = b2->m_linearVelocity; + float32 w1 = b1->m_angularVelocity; + float32 w2 = b2->m_angularVelocity; + + for (int32 j = 0; j < manifoldCount; ++j) + { + b2Manifold* manifold = manifolds + j; + + b2Assert(manifold->pointCount > 0); + + const b2Vec2 normal = manifold->normal; + + b2Assert(count < m_constraintCount); + b2ContactConstraint* c = m_constraints + count; + c->body1 = b1; + c->body2 = b2; + c->manifold = manifold; + c->normal = normal; + c->pointCount = manifold->pointCount; + c->friction = friction; + c->restitution = restitution; + + for (int32 k = 0; k < c->pointCount; ++k) + { + b2ManifoldPoint* cp = manifold->points + k; + b2ContactConstraintPoint* ccp = c->points + k; + + ccp->normalImpulse = cp->normalImpulse; + ccp->tangentImpulse = cp->tangentImpulse; + ccp->separation = cp->separation; + ccp->positionImpulse = 0.0f; + + ccp->localAnchor1 = cp->localPoint1; + ccp->localAnchor2 = cp->localPoint2; + ccp->r1 = b2Mul(b1->GetXForm().R, cp->localPoint1 - b1->GetLocalCenter()); + ccp->r2 = b2Mul(b2->GetXForm().R, cp->localPoint2 - b2->GetLocalCenter()); + + float32 r1Sqr = b2Dot(ccp->r1, ccp->r1); + float32 r2Sqr = b2Dot(ccp->r2, ccp->r2); + float32 rn1 = b2Dot(ccp->r1, normal); + float32 rn2 = b2Dot(ccp->r2, normal); + + float32 kNormal = b1->m_invMass + b2->m_invMass; + kNormal += b1->m_invI * (r1Sqr - rn1 * rn1) + b2->m_invI * (r2Sqr - rn2 * rn2); + + b2Assert(kNormal > B2_FLT_EPSILON); + ccp->normalMass = 1.0f / kNormal; + + float32 kEqualized = b1->m_mass * b1->m_invMass + b2->m_mass * b2->m_invMass; + kEqualized += b1->m_mass * b1->m_invI * (r1Sqr - rn1 * rn1) + b2->m_mass * b2->m_invI * (r2Sqr - rn2 * rn2); + + b2Assert(kEqualized > B2_FLT_EPSILON); + ccp->equalizedMass = 1.0f / kEqualized; + + b2Vec2 tangent = b2Cross(normal, 1.0f); + + float32 rt1 = b2Dot(ccp->r1, tangent); + float32 rt2 = b2Dot(ccp->r2, tangent); + float32 kTangent = b1->m_invMass + b2->m_invMass; + kTangent += b1->m_invI * (r1Sqr - rt1 * rt1) + b2->m_invI * (r2Sqr - rt2 * rt2); + + b2Assert(kTangent > B2_FLT_EPSILON); + ccp->tangentMass = 1.0f / kTangent; + + // Setup a velocity bias for restitution. + ccp->velocityBias = 0.0f; + if (ccp->separation > 0.0f) + { + ccp->velocityBias = -60.0f * ccp->separation; // TODO_ERIN b2TimeStep + } + + float32 vRel = b2Dot(c->normal, v2 + b2Cross(w2, ccp->r2) - v1 - b2Cross(w1, ccp->r1)); + if (vRel < -b2_velocityThreshold) + { + ccp->velocityBias += -c->restitution * vRel; + } + } + + ++count; + } + } + + b2Assert(count == m_constraintCount); +} + +b2ContactSolver::~b2ContactSolver() +{ + m_allocator->Free(m_constraints); +} + +void b2ContactSolver::InitVelocityConstraints(const b2TimeStep& step) +{ + // Warm start. + for (int32 i = 0; i < m_constraintCount; ++i) + { + b2ContactConstraint* c = m_constraints + i; + + b2Body* b1 = c->body1; + b2Body* b2 = c->body2; + float32 invMass1 = b1->m_invMass; + float32 invI1 = b1->m_invI; + float32 invMass2 = b2->m_invMass; + float32 invI2 = b2->m_invI; + b2Vec2 normal = c->normal; + b2Vec2 tangent = b2Cross(normal, 1.0f); + + if (step.warmStarting) + { + for (int32 j = 0; j < c->pointCount; ++j) + { + b2ContactConstraintPoint* ccp = c->points + j; + ccp->normalImpulse *= step.dtRatio; + ccp->tangentImpulse *= step.dtRatio; + b2Vec2 P = ccp->normalImpulse * normal + ccp->tangentImpulse * tangent; + b1->m_angularVelocity -= invI1 * b2Cross(ccp->r1, P); + b1->m_linearVelocity -= invMass1 * P; + b2->m_angularVelocity += invI2 * b2Cross(ccp->r2, P); + b2->m_linearVelocity += invMass2 * P; + } + } + else + { + for (int32 j = 0; j < c->pointCount; ++j) + { + b2ContactConstraintPoint* ccp = c->points + j; + ccp->normalImpulse = 0.0f; + ccp->tangentImpulse = 0.0f; + } + } + } +} + +void b2ContactSolver::SolveVelocityConstraints() +{ + for (int32 i = 0; i < m_constraintCount; ++i) + { + b2ContactConstraint* c = m_constraints + i; + b2Body* b1 = c->body1; + b2Body* b2 = c->body2; + float32 w1 = b1->m_angularVelocity; + float32 w2 = b2->m_angularVelocity; + b2Vec2 v1 = b1->m_linearVelocity; + b2Vec2 v2 = b2->m_linearVelocity; + float32 invMass1 = b1->m_invMass; + float32 invI1 = b1->m_invI; + float32 invMass2 = b2->m_invMass; + float32 invI2 = b2->m_invI; + b2Vec2 normal = c->normal; + b2Vec2 tangent = b2Cross(normal, 1.0f); + float32 friction = c->friction; +//#define DEFERRED_UPDATE +#ifdef DEFERRED_UPDATE + b2Vec2 b1_linearVelocity = b1->m_linearVelocity; + float32 b1_angularVelocity = b1->m_angularVelocity; + b2Vec2 b2_linearVelocity = b2->m_linearVelocity; + float32 b2_angularVelocity = b2->m_angularVelocity; +#endif + // Solve normal constraints + for (int32 j = 0; j < c->pointCount; ++j) + { + b2ContactConstraintPoint* ccp = c->points + j; + + // Relative velocity at contact + b2Vec2 dv = v2 + b2Cross(w2, ccp->r2) - v1 - b2Cross(w1, ccp->r1); + + // Compute normal impulse + float32 vn = b2Dot(dv, normal); + float32 lambda = -ccp->normalMass * (vn - ccp->velocityBias); + + // b2Clamp the accumulated impulse + float32 newImpulse = b2Max(ccp->normalImpulse + lambda, 0.0f); + lambda = newImpulse - ccp->normalImpulse; + + // Apply contact impulse + b2Vec2 P = lambda * normal; +#ifdef DEFERRED_UPDATE + b1_linearVelocity -= invMass1 * P; + b1_angularVelocity -= invI1 * b2Cross(r1, P); + + b2_linearVelocity += invMass2 * P; + b2_angularVelocity += invI2 * b2Cross(r2, P); +#else + v1 -= invMass1 * P; + w1 -= invI1 * b2Cross(ccp->r1, P); + + v2 += invMass2 * P; + w2 += invI2 * b2Cross(ccp->r2, P); +#endif + ccp->normalImpulse = newImpulse; + } + +#ifdef DEFERRED_UPDATE + b1->m_linearVelocity = b1_linearVelocity; + b1->m_angularVelocity = b1_angularVelocity; + b2->m_linearVelocity = b2_linearVelocity; + b2->m_angularVelocity = b2_angularVelocity; +#endif + // Solve tangent constraints + for (int32 j = 0; j < c->pointCount; ++j) + { + b2ContactConstraintPoint* ccp = c->points + j; + + // Relative velocity at contact + b2Vec2 dv = v2 + b2Cross(w2, ccp->r2) - v1 - b2Cross(w1, ccp->r1); + + // Compute tangent force + float32 vt = b2Dot(dv, tangent); + float32 lambda = ccp->tangentMass * (-vt); + + // b2Clamp the accumulated force + float32 maxFriction = friction * ccp->normalImpulse; + float32 newImpulse = b2Clamp(ccp->tangentImpulse + lambda, -maxFriction, maxFriction); + lambda = newImpulse - ccp->tangentImpulse; + + // Apply contact impulse + b2Vec2 P = lambda * tangent; + + v1 -= invMass1 * P; + w1 -= invI1 * b2Cross(ccp->r1, P); + + v2 += invMass2 * P; + w2 += invI2 * b2Cross(ccp->r2, P); + + ccp->tangentImpulse = newImpulse; + } + + b1->m_linearVelocity = v1; + b1->m_angularVelocity = w1; + b2->m_linearVelocity = v2; + b2->m_angularVelocity = w2; + } +} + +void b2ContactSolver::FinalizeVelocityConstraints() +{ + for (int32 i = 0; i < m_constraintCount; ++i) + { + b2ContactConstraint* c = m_constraints + i; + b2Manifold* m = c->manifold; + + for (int32 j = 0; j < c->pointCount; ++j) + { + m->points[j].normalImpulse = c->points[j].normalImpulse; + m->points[j].tangentImpulse = c->points[j].tangentImpulse; + } + } +} + +bool b2ContactSolver::SolvePositionConstraints(float32 baumgarte) +{ + float32 minSeparation = 0.0f; + + for (int32 i = 0; i < m_constraintCount; ++i) + { + b2ContactConstraint* c = m_constraints + i; + b2Body* b1 = c->body1; + b2Body* b2 = c->body2; + float32 invMass1 = b1->m_mass * b1->m_invMass; + float32 invI1 = b1->m_mass * b1->m_invI; + float32 invMass2 = b2->m_mass * b2->m_invMass; + float32 invI2 = b2->m_mass * b2->m_invI; + + b2Vec2 normal = c->normal; + + // Solver normal constraints + for (int32 j = 0; j < c->pointCount; ++j) + { + b2ContactConstraintPoint* ccp = c->points + j; + + b2Vec2 r1 = b2Mul(b1->GetXForm().R, ccp->localAnchor1 - b1->GetLocalCenter()); + b2Vec2 r2 = b2Mul(b2->GetXForm().R, ccp->localAnchor2 - b2->GetLocalCenter()); + + b2Vec2 p1 = b1->m_sweep.c + r1; + b2Vec2 p2 = b2->m_sweep.c + r2; + b2Vec2 dp = p2 - p1; + + // Approximate the current separation. + float32 separation = b2Dot(dp, normal) + ccp->separation; + + // Track max constraint error. + minSeparation = b2Min(minSeparation, separation); + + // Prevent large corrections and allow slop. + float32 C = baumgarte * b2Clamp(separation + b2_linearSlop, -b2_maxLinearCorrection, 0.0f); + + // Compute normal impulse + float32 dImpulse = -ccp->equalizedMass * C; + + // b2Clamp the accumulated impulse + float32 impulse0 = ccp->positionImpulse; + ccp->positionImpulse = b2Max(impulse0 + dImpulse, 0.0f); + dImpulse = ccp->positionImpulse - impulse0; + + b2Vec2 impulse = dImpulse * normal; + + b1->m_sweep.c -= invMass1 * impulse; + b1->m_sweep.a -= invI1 * b2Cross(r1, impulse); + b1->SynchronizeTransform(); + + b2->m_sweep.c += invMass2 * impulse; + b2->m_sweep.a += invI2 * b2Cross(r2, impulse); + b2->SynchronizeTransform(); + } + } + + // We can't expect minSpeparation >= -b2_linearSlop because we don't + // push the separation above -b2_linearSlop. + return minSeparation >= -1.5f * b2_linearSlop; +} diff --git a/Box2D/Source/Dynamics/Contacts/b2ContactSolver.h b/Box2D/Source/Dynamics/Contacts/b2ContactSolver.h new file mode 100644 index 0000000..6e8b3d1 --- /dev/null +++ b/Box2D/Source/Dynamics/Contacts/b2ContactSolver.h @@ -0,0 +1,77 @@ +/* +* Copyright (c) 2006-2007 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 CONTACT_SOLVER_H +#define CONTACT_SOLVER_H + +#include "../../Common/b2Math.h" +#include "../../Collision/b2Collision.h" +#include "../b2World.h" + +class b2Contact; +class b2Body; +class b2Island; +class b2StackAllocator; + +struct b2ContactConstraintPoint +{ + b2Vec2 localAnchor1; + b2Vec2 localAnchor2; + b2Vec2 r1; + b2Vec2 r2; + float32 normalImpulse; + float32 tangentImpulse; + float32 positionImpulse; + float32 normalMass; + float32 tangentMass; + float32 equalizedMass; + float32 separation; + float32 velocityBias; +}; + +struct b2ContactConstraint +{ + b2ContactConstraintPoint points[b2_maxManifoldPoints]; + b2Vec2 normal; + b2Manifold* manifold; + b2Body* body1; + b2Body* body2; + float32 friction; + float32 restitution; + int32 pointCount; +}; + +class b2ContactSolver +{ +public: + b2ContactSolver(const b2TimeStep& step, b2Contact** contacts, int32 contactCount, b2StackAllocator* allocator); + ~b2ContactSolver(); + + void InitVelocityConstraints(const b2TimeStep& step); + void SolveVelocityConstraints(); + void FinalizeVelocityConstraints(); + + bool SolvePositionConstraints(float32 baumgarte); + + b2TimeStep m_step; + b2StackAllocator* m_allocator; + b2ContactConstraint* m_constraints; + int m_constraintCount; +}; + +#endif diff --git a/Box2D/Source/Dynamics/Contacts/b2NullContact.h b/Box2D/Source/Dynamics/Contacts/b2NullContact.h new file mode 100644 index 0000000..f5b2d1d --- /dev/null +++ b/Box2D/Source/Dynamics/Contacts/b2NullContact.h @@ -0,0 +1,33 @@ +/* +* Copyright (c) 2006-2007 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_NULL_CONTACT_H +#define B2_NULL_CONTACT_H + +#include "../../Common/b2Math.h" +#include "b2Contact.h" + +class b2NullContact : public b2Contact +{ +public: + b2NullContact() {} + void Evaluate(b2ContactListener*) {} + b2Manifold* GetManifolds() { return NULL; } +}; + +#endif diff --git a/Box2D/Source/Dynamics/Contacts/b2PolyAndCircleContact.cpp b/Box2D/Source/Dynamics/Contacts/b2PolyAndCircleContact.cpp new file mode 100644 index 0000000..6d9287d --- /dev/null +++ b/Box2D/Source/Dynamics/Contacts/b2PolyAndCircleContact.cpp @@ -0,0 +1,158 @@ +/* +* Copyright (c) 2006-2007 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. +*/ + +#include "b2PolyAndCircleContact.h" +#include "../b2Body.h" +#include "../b2WorldCallbacks.h" +#include "../../Common/b2BlockAllocator.h" + +#include +#include + +b2Contact* b2PolyAndCircleContact::Create(b2Shape* shape1, b2Shape* shape2, b2BlockAllocator* allocator) +{ + void* mem = allocator->Allocate(sizeof(b2PolyAndCircleContact)); + return new (mem) b2PolyAndCircleContact(shape1, shape2); +} + +void b2PolyAndCircleContact::Destroy(b2Contact* contact, b2BlockAllocator* allocator) +{ + ((b2PolyAndCircleContact*)contact)->~b2PolyAndCircleContact(); + allocator->Free(contact, sizeof(b2PolyAndCircleContact)); +} + +b2PolyAndCircleContact::b2PolyAndCircleContact(b2Shape* s1, b2Shape* s2) +: b2Contact(s1, s2) +{ + b2Assert(m_shape1->GetType() == e_polygonShape); + b2Assert(m_shape2->GetType() == e_circleShape); + m_manifold.pointCount = 0; + m_manifold.points[0].normalImpulse = 0.0f; + m_manifold.points[0].tangentImpulse = 0.0f; +} + +void b2PolyAndCircleContact::Evaluate(b2ContactListener* listener) +{ + b2Body* b1 = m_shape1->GetBody(); + b2Body* b2 = m_shape2->GetBody(); + + b2Manifold m0; + memcpy(&m0, &m_manifold, sizeof(b2Manifold)); + + b2CollidePolygonAndCircle(&m_manifold, (b2PolygonShape*)m_shape1, b1->GetXForm(), (b2CircleShape*)m_shape2, b2->GetXForm()); + + bool persisted[b2_maxManifoldPoints] = {false, false}; + + b2ContactPoint cp; + cp.shape1 = m_shape1; + cp.shape2 = m_shape2; + cp.friction = m_friction; + cp.restitution = m_restitution; + + // Match contact ids to facilitate warm starting. + if (m_manifold.pointCount > 0) + { + // Match old contact ids to new contact ids and copy the + // stored impulses to warm start the solver. + for (int32 i = 0; i < m_manifold.pointCount; ++i) + { + b2ManifoldPoint* mp = m_manifold.points + i; + mp->normalImpulse = 0.0f; + mp->tangentImpulse = 0.0f; + bool found = false; + b2ContactID id = mp->id; + + for (int32 j = 0; j < m0.pointCount; ++j) + { + if (persisted[j] == true) + { + continue; + } + + b2ManifoldPoint* mp0 = m0.points + j; + + if (mp0->id.key == id.key) + { + persisted[j] = true; + mp->normalImpulse = mp0->normalImpulse; + mp->tangentImpulse = mp0->tangentImpulse; + + // A persistent point. + found = true; + + // Report persistent point. + if (listener != NULL) + { + cp.position = b1->GetWorldPoint(mp->localPoint1); + b2Vec2 v1 = b1->GetLinearVelocityFromLocalPoint(mp->localPoint1); + b2Vec2 v2 = b2->GetLinearVelocityFromLocalPoint(mp->localPoint2); + cp.velocity = v2 - v1; + cp.normal = m_manifold.normal; + cp.separation = mp->separation; + cp.id = id; + listener->Persist(&cp); + } + break; + } + } + + // Report added point. + if (found == false && listener != NULL) + { + cp.position = b1->GetWorldPoint(mp->localPoint1); + b2Vec2 v1 = b1->GetLinearVelocityFromLocalPoint(mp->localPoint1); + b2Vec2 v2 = b2->GetLinearVelocityFromLocalPoint(mp->localPoint2); + cp.velocity = v2 - v1; + cp.normal = m_manifold.normal; + cp.separation = mp->separation; + cp.id = id; + listener->Add(&cp); + } + } + + m_manifoldCount = 1; + } + else + { + m_manifoldCount = 0; + } + + if (listener == NULL) + { + return; + } + + // Report removed points. + for (int32 i = 0; i < m0.pointCount; ++i) + { + if (persisted[i]) + { + continue; + } + + b2ManifoldPoint* mp0 = m0.points + i; + cp.position = b1->GetWorldPoint(mp0->localPoint1); + b2Vec2 v1 = b1->GetLinearVelocityFromLocalPoint(mp0->localPoint1); + b2Vec2 v2 = b2->GetLinearVelocityFromLocalPoint(mp0->localPoint2); + cp.velocity = v2 - v1; + cp.normal = m0.normal; + cp.separation = mp0->separation; + cp.id = mp0->id; + listener->Remove(&cp); + } +} diff --git a/Box2D/Source/Dynamics/Contacts/b2PolyAndCircleContact.h b/Box2D/Source/Dynamics/Contacts/b2PolyAndCircleContact.h new file mode 100644 index 0000000..120abdc --- /dev/null +++ b/Box2D/Source/Dynamics/Contacts/b2PolyAndCircleContact.h @@ -0,0 +1,44 @@ +/* +* Copyright (c) 2006-2007 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 POLY_AND_CIRCLE_CONTACT_H +#define POLY_AND_CIRCLE_CONTACT_H + +#include "b2Contact.h" + +class b2BlockAllocator; + +class b2PolyAndCircleContact : public b2Contact +{ +public: + static b2Contact* Create(b2Shape* shape1, b2Shape* shape2, b2BlockAllocator* allocator); + static void Destroy(b2Contact* contact, b2BlockAllocator* allocator); + + b2PolyAndCircleContact(b2Shape* shape1, b2Shape* shape2); + ~b2PolyAndCircleContact() {} + + void Evaluate(b2ContactListener* listener); + b2Manifold* GetManifolds() + { + return &m_manifold; + } + + b2Manifold m_manifold; +}; + +#endif diff --git a/Box2D/Source/Dynamics/Contacts/b2PolyContact.cpp b/Box2D/Source/Dynamics/Contacts/b2PolyContact.cpp new file mode 100644 index 0000000..b66899d --- /dev/null +++ b/Box2D/Source/Dynamics/Contacts/b2PolyContact.cpp @@ -0,0 +1,157 @@ +/* +* Copyright (c) 2006-2007 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. +*/ + +#include "b2PolyContact.h" +#include "../b2Body.h" +#include "../b2WorldCallbacks.h" +#include "../../Common/b2BlockAllocator.h" + +#include +#include +#include + +b2Contact* b2PolygonContact::Create(b2Shape* shape1, b2Shape* shape2, b2BlockAllocator* allocator) +{ + void* mem = allocator->Allocate(sizeof(b2PolygonContact)); + return new (mem) b2PolygonContact(shape1, shape2); +} + +void b2PolygonContact::Destroy(b2Contact* contact, b2BlockAllocator* allocator) +{ + ((b2PolygonContact*)contact)->~b2PolygonContact(); + allocator->Free(contact, sizeof(b2PolygonContact)); +} + +b2PolygonContact::b2PolygonContact(b2Shape* s1, b2Shape* s2) + : b2Contact(s1, s2) +{ + b2Assert(m_shape1->GetType() == e_polygonShape); + b2Assert(m_shape2->GetType() == e_polygonShape); + m_manifold.pointCount = 0; +} + +void b2PolygonContact::Evaluate(b2ContactListener* listener) +{ + b2Body* b1 = m_shape1->GetBody(); + b2Body* b2 = m_shape2->GetBody(); + + b2Manifold m0; + memcpy(&m0, &m_manifold, sizeof(b2Manifold)); + + b2CollidePolygons(&m_manifold, (b2PolygonShape*)m_shape1, b1->GetXForm(), (b2PolygonShape*)m_shape2, b2->GetXForm()); + + bool persisted[b2_maxManifoldPoints] = {false, false}; + + b2ContactPoint cp; + cp.shape1 = m_shape1; + cp.shape2 = m_shape2; + cp.friction = m_friction; + cp.restitution = m_restitution; + + // Match contact ids to facilitate warm starting. + if (m_manifold.pointCount > 0) + { + // Match old contact ids to new contact ids and copy the + // stored impulses to warm start the solver. + for (int32 i = 0; i < m_manifold.pointCount; ++i) + { + b2ManifoldPoint* mp = m_manifold.points + i; + mp->normalImpulse = 0.0f; + mp->tangentImpulse = 0.0f; + bool found = false; + b2ContactID id = mp->id; + + for (int32 j = 0; j < m0.pointCount; ++j) + { + if (persisted[j] == true) + { + continue; + } + + b2ManifoldPoint* mp0 = m0.points + j; + + if (mp0->id.key == id.key) + { + persisted[j] = true; + mp->normalImpulse = mp0->normalImpulse; + mp->tangentImpulse = mp0->tangentImpulse; + + // A persistent point. + found = true; + + // Report persistent point. + if (listener != NULL) + { + cp.position = b1->GetWorldPoint(mp->localPoint1); + b2Vec2 v1 = b1->GetLinearVelocityFromLocalPoint(mp->localPoint1); + b2Vec2 v2 = b2->GetLinearVelocityFromLocalPoint(mp->localPoint2); + cp.velocity = v2 - v1; + cp.normal = m_manifold.normal; + cp.separation = mp->separation; + cp.id = id; + listener->Persist(&cp); + } + break; + } + } + + // Report added point. + if (found == false && listener != NULL) + { + cp.position = b1->GetWorldPoint(mp->localPoint1); + b2Vec2 v1 = b1->GetLinearVelocityFromLocalPoint(mp->localPoint1); + b2Vec2 v2 = b2->GetLinearVelocityFromLocalPoint(mp->localPoint2); + cp.velocity = v2 - v1; + cp.normal = m_manifold.normal; + cp.separation = mp->separation; + cp.id = id; + listener->Add(&cp); + } + } + + m_manifoldCount = 1; + } + else + { + m_manifoldCount = 0; + } + + if (listener == NULL) + { + return; + } + + // Report removed points. + for (int32 i = 0; i < m0.pointCount; ++i) + { + if (persisted[i]) + { + continue; + } + + b2ManifoldPoint* mp0 = m0.points + i; + cp.position = b1->GetWorldPoint(mp0->localPoint1); + b2Vec2 v1 = b1->GetLinearVelocityFromLocalPoint(mp0->localPoint1); + b2Vec2 v2 = b2->GetLinearVelocityFromLocalPoint(mp0->localPoint2); + cp.velocity = v2 - v1; + cp.normal = m0.normal; + cp.separation = mp0->separation; + cp.id = mp0->id; + listener->Remove(&cp); + } +} diff --git a/Box2D/Source/Dynamics/Contacts/b2PolyContact.h b/Box2D/Source/Dynamics/Contacts/b2PolyContact.h new file mode 100644 index 0000000..a2cddf1 --- /dev/null +++ b/Box2D/Source/Dynamics/Contacts/b2PolyContact.h @@ -0,0 +1,44 @@ +/* +* Copyright (c) 2006-2007 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 POLYCONTACT_H +#define POLYCONTACT_H + +#include "b2Contact.h" + +class b2BlockAllocator; + +class b2PolygonContact : public b2Contact +{ +public: + static b2Contact* Create(b2Shape* shape1, b2Shape* shape2, b2BlockAllocator* allocator); + static void Destroy(b2Contact* contact, b2BlockAllocator* allocator); + + b2PolygonContact(b2Shape* shape1, b2Shape* shape2); + ~b2PolygonContact() {} + + void Evaluate(b2ContactListener* listener); + b2Manifold* GetManifolds() + { + return &m_manifold; + } + + b2Manifold m_manifold; +}; + +#endif diff --git a/Box2D/Source/Dynamics/Joints/b2DistanceJoint.cpp b/Box2D/Source/Dynamics/Joints/b2DistanceJoint.cpp new file mode 100644 index 0000000..a164ab7 --- /dev/null +++ b/Box2D/Source/Dynamics/Joints/b2DistanceJoint.cpp @@ -0,0 +1,206 @@ +/* +* Copyright (c) 2006-2007 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. +*/ + +#include "b2DistanceJoint.h" +#include "../b2Body.h" +#include "../b2World.h" + +// 1-D constrained system +// m (v2 - v1) = lambda +// v2 + (beta/h) * x1 + gamma * lambda = 0, gamma has units of inverse mass. +// x2 = x1 + h * v2 + +// 1-D mass-damper-spring system +// m (v2 - v1) + h * d * v2 + h * k * + +// C = norm(p2 - p1) - L +// u = (p2 - p1) / norm(p2 - p1) +// Cdot = dot(u, v2 + cross(w2, r2) - v1 - cross(w1, r1)) +// J = [-u -cross(r1, u) u cross(r2, u)] +// K = J * invM * JT +// = invMass1 + invI1 * cross(r1, u)^2 + invMass2 + invI2 * cross(r2, u)^2 + +void b2DistanceJointDef::Initialize(b2Body* b1, b2Body* b2, + const b2Vec2& anchor1, const b2Vec2& anchor2) +{ + body1 = b1; + body2 = b2; + localAnchor1 = body1->GetLocalPoint(anchor1); + localAnchor2 = body2->GetLocalPoint(anchor2); + b2Vec2 d = anchor2 - anchor1; + length = d.Length(); +} + + +b2DistanceJoint::b2DistanceJoint(const b2DistanceJointDef* def) +: b2Joint(def) +{ + m_localAnchor1 = def->localAnchor1; + m_localAnchor2 = def->localAnchor2; + m_length = def->length; + m_frequencyHz = def->frequencyHz; + m_dampingRatio = def->dampingRatio; + m_impulse = 0.0f; + m_gamma = 0.0f; + m_bias = 0.0f; + m_inv_dt = 0.0f; +} + +void b2DistanceJoint::InitVelocityConstraints(const b2TimeStep& step) +{ + m_inv_dt = step.inv_dt; + + b2Body* b1 = m_body1; + b2Body* b2 = m_body2; + + // Compute the effective mass matrix. + b2Vec2 r1 = b2Mul(b1->GetXForm().R, m_localAnchor1 - b1->GetLocalCenter()); + b2Vec2 r2 = b2Mul(b2->GetXForm().R, m_localAnchor2 - b2->GetLocalCenter()); + m_u = b2->m_sweep.c + r2 - b1->m_sweep.c - r1; + + // Handle singularity. + float32 length = m_u.Length(); + if (length > b2_linearSlop) + { + m_u *= 1.0f / length; + } + else + { + m_u.Set(0.0f, 0.0f); + } + + float32 cr1u = b2Cross(r1, m_u); + float32 cr2u = b2Cross(r2, m_u); + float32 invMass = b1->m_invMass + b1->m_invI * cr1u * cr1u + b2->m_invMass + b2->m_invI * cr2u * cr2u; + b2Assert(invMass > B2_FLT_EPSILON); + m_mass = 1.0f / invMass; + + if (m_frequencyHz > 0.0f) + { + float32 C = length - m_length; + + // Frequency + float32 omega = 2.0f * b2_pi * m_frequencyHz; + + // Damping coefficient + float32 d = 2.0f * m_mass * m_dampingRatio * omega; + + // Spring stiffness + float32 k = m_mass * omega * omega; + + // magic formulas + m_gamma = 1.0f / (step.dt * (d + step.dt * k)); + m_bias = C * step.dt * k * m_gamma; + + m_mass = 1.0f / (invMass + m_gamma); + } + + if (step.warmStarting) + { + m_impulse *= step.dtRatio; + b2Vec2 P = m_impulse * m_u; + b1->m_linearVelocity -= b1->m_invMass * P; + b1->m_angularVelocity -= b1->m_invI * b2Cross(r1, P); + b2->m_linearVelocity += b2->m_invMass * P; + b2->m_angularVelocity += b2->m_invI * b2Cross(r2, P); + } + else + { + m_impulse = 0.0f; + } +} + +void b2DistanceJoint::SolveVelocityConstraints(const b2TimeStep& step) +{ + B2_NOT_USED(step); + + b2Body* b1 = m_body1; + b2Body* b2 = m_body2; + + b2Vec2 r1 = b2Mul(b1->GetXForm().R, m_localAnchor1 - b1->GetLocalCenter()); + b2Vec2 r2 = b2Mul(b2->GetXForm().R, m_localAnchor2 - b2->GetLocalCenter()); + + // Cdot = dot(u, v + cross(w, r)) + b2Vec2 v1 = b1->m_linearVelocity + b2Cross(b1->m_angularVelocity, r1); + b2Vec2 v2 = b2->m_linearVelocity + b2Cross(b2->m_angularVelocity, r2); + float32 Cdot = b2Dot(m_u, v2 - v1); + + float32 impulse = -m_mass * (Cdot + m_bias + m_gamma * m_impulse); + m_impulse += impulse; + + b2Vec2 P = impulse * m_u; + b1->m_linearVelocity -= b1->m_invMass * P; + b1->m_angularVelocity -= b1->m_invI * b2Cross(r1, P); + b2->m_linearVelocity += b2->m_invMass * P; + b2->m_angularVelocity += b2->m_invI * b2Cross(r2, P); +} + +bool b2DistanceJoint::SolvePositionConstraints() +{ + if (m_frequencyHz > 0.0f) + { + return true; + } + + b2Body* b1 = m_body1; + b2Body* b2 = m_body2; + + b2Vec2 r1 = b2Mul(b1->GetXForm().R, m_localAnchor1 - b1->GetLocalCenter()); + b2Vec2 r2 = b2Mul(b2->GetXForm().R, m_localAnchor2 - b2->GetLocalCenter()); + + b2Vec2 d = b2->m_sweep.c + r2 - b1->m_sweep.c - r1; + + float32 length = d.Normalize(); + float32 C = length - m_length; + C = b2Clamp(C, -b2_maxLinearCorrection, b2_maxLinearCorrection); + + float32 impulse = -m_mass * C; + m_u = d; + b2Vec2 P = impulse * m_u; + + b1->m_sweep.c -= b1->m_invMass * P; + b1->m_sweep.a -= b1->m_invI * b2Cross(r1, P); + b2->m_sweep.c += b2->m_invMass * P; + b2->m_sweep.a += b2->m_invI * b2Cross(r2, P); + + b1->SynchronizeTransform(); + b2->SynchronizeTransform(); + + return b2Abs(C) < b2_linearSlop; +} + +b2Vec2 b2DistanceJoint::GetAnchor1() const +{ + return m_body1->GetWorldPoint(m_localAnchor1); +} + +b2Vec2 b2DistanceJoint::GetAnchor2() const +{ + return m_body2->GetWorldPoint(m_localAnchor2); +} + +b2Vec2 b2DistanceJoint::GetReactionForce() const +{ + b2Vec2 F = (m_inv_dt * m_impulse) * m_u; + return F; +} + +float32 b2DistanceJoint::GetReactionTorque() const +{ + return 0.0f; +} diff --git a/Box2D/Source/Dynamics/Joints/b2DistanceJoint.h b/Box2D/Source/Dynamics/Joints/b2DistanceJoint.h new file mode 100644 index 0000000..3d2536b --- /dev/null +++ b/Box2D/Source/Dynamics/Joints/b2DistanceJoint.h @@ -0,0 +1,96 @@ +/* +* Copyright (c) 2006-2007 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_DISTANCE_JOINT_H +#define B2_DISTANCE_JOINT_H + +#include "b2Joint.h" + +/// Distance joint definition. This requires defining an +/// anchor point on both bodies and the non-zero length of the +/// distance joint. The definition uses local anchor points +/// so that the initial configuration can violate the constraint +/// slightly. This helps when saving and loading a game. +/// @warning Do not use a zero or short length. +struct b2DistanceJointDef : public b2JointDef +{ + b2DistanceJointDef() + { + type = e_distanceJoint; + localAnchor1.Set(0.0f, 0.0f); + localAnchor2.Set(0.0f, 0.0f); + length = 1.0f; + frequencyHz = 0.0f; + dampingRatio = 0.0f; + } + + /// Initialize the bodies, anchors, and length using the world + /// anchors. + void Initialize(b2Body* body1, b2Body* body2, + const b2Vec2& anchor1, const b2Vec2& anchor2); + + /// The local anchor point relative to body1's origin. + b2Vec2 localAnchor1; + + /// The local anchor point relative to body2's origin. + b2Vec2 localAnchor2; + + /// The equilibrium length between the anchor points. + float32 length; + + /// The response speed. + float32 frequencyHz; + + /// The damping ratio. 0 = no damping, 1 = critical damping. + float32 dampingRatio; +}; + +/// A distance joint constrains two points on two bodies +/// to remain at a fixed distance from each other. You can view +/// this as a massless, rigid rod. +class b2DistanceJoint : public b2Joint +{ +public: + + b2Vec2 GetAnchor1() const; + b2Vec2 GetAnchor2() const; + + b2Vec2 GetReactionForce() const; + float32 GetReactionTorque() const; + + //--------------- Internals Below ------------------- + + b2DistanceJoint(const b2DistanceJointDef* data); + + void InitVelocityConstraints(const b2TimeStep& step); + void SolveVelocityConstraints(const b2TimeStep& step); + bool SolvePositionConstraints(); + + b2Vec2 m_localAnchor1; + b2Vec2 m_localAnchor2; + b2Vec2 m_u; + float32 m_frequencyHz; + float32 m_dampingRatio; + float32 m_gamma; + float32 m_bias; + float32 m_impulse; + float32 m_mass; // effective mass for the constraint. + float32 m_length; +}; + +#endif diff --git a/Box2D/Source/Dynamics/Joints/b2GearJoint.cpp b/Box2D/Source/Dynamics/Joints/b2GearJoint.cpp new file mode 100644 index 0000000..cb92889 --- /dev/null +++ b/Box2D/Source/Dynamics/Joints/b2GearJoint.cpp @@ -0,0 +1,253 @@ +/* +* Copyright (c) 2007 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. +*/ + +#include "b2GearJoint.h" +#include "b2RevoluteJoint.h" +#include "b2PrismaticJoint.h" +#include "../b2Body.h" +#include "../b2World.h" + +// Gear Joint: +// C0 = (coordinate1 + ratio * coordinate2)_initial +// C = C0 - (cordinate1 + ratio * coordinate2) = 0 +// Cdot = -(Cdot1 + ratio * Cdot2) +// J = -[J1 ratio * J2] +// K = J * invM * JT +// = J1 * invM1 * J1T + ratio * ratio * J2 * invM2 * J2T +// +// Revolute: +// coordinate = rotation +// Cdot = angularVelocity +// J = [0 0 1] +// K = J * invM * JT = invI +// +// Prismatic: +// coordinate = dot(p - pg, ug) +// Cdot = dot(v + cross(w, r), ug) +// J = [ug cross(r, ug)] +// K = J * invM * JT = invMass + invI * cross(r, ug)^2 + +b2GearJoint::b2GearJoint(const b2GearJointDef* def) +: b2Joint(def) +{ + b2JointType type1 = def->joint1->GetType(); + b2JointType type2 = def->joint2->GetType(); + + b2Assert(type1 == e_revoluteJoint || type1 == e_prismaticJoint); + b2Assert(type2 == e_revoluteJoint || type2 == e_prismaticJoint); + b2Assert(def->joint1->GetBody1()->IsStatic()); + b2Assert(def->joint2->GetBody1()->IsStatic()); + + m_revolute1 = NULL; + m_prismatic1 = NULL; + m_revolute2 = NULL; + m_prismatic2 = NULL; + + float32 coordinate1, coordinate2; + + m_ground1 = def->joint1->GetBody1(); + m_body1 = def->joint1->GetBody2(); + if (type1 == e_revoluteJoint) + { + m_revolute1 = (b2RevoluteJoint*)def->joint1; + m_groundAnchor1 = m_revolute1->m_localAnchor1; + m_localAnchor1 = m_revolute1->m_localAnchor2; + coordinate1 = m_revolute1->GetJointAngle(); + } + else + { + m_prismatic1 = (b2PrismaticJoint*)def->joint1; + m_groundAnchor1 = m_prismatic1->m_localAnchor1; + m_localAnchor1 = m_prismatic1->m_localAnchor2; + coordinate1 = m_prismatic1->GetJointTranslation(); + } + + m_ground2 = def->joint2->GetBody1(); + m_body2 = def->joint2->GetBody2(); + if (type2 == e_revoluteJoint) + { + m_revolute2 = (b2RevoluteJoint*)def->joint2; + m_groundAnchor2 = m_revolute2->m_localAnchor1; + m_localAnchor2 = m_revolute2->m_localAnchor2; + coordinate2 = m_revolute2->GetJointAngle(); + } + else + { + m_prismatic2 = (b2PrismaticJoint*)def->joint2; + m_groundAnchor2 = m_prismatic2->m_localAnchor1; + m_localAnchor2 = m_prismatic2->m_localAnchor2; + coordinate2 = m_prismatic2->GetJointTranslation(); + } + + m_ratio = def->ratio; + + m_constant = coordinate1 + m_ratio * coordinate2; + + m_force = 0.0f; +} + +void b2GearJoint::InitVelocityConstraints(const b2TimeStep& step) +{ + b2Body* g1 = m_ground1; + b2Body* g2 = m_ground2; + b2Body* b1 = m_body1; + b2Body* b2 = m_body2; + + float32 K = 0.0f; + m_J.SetZero(); + + if (m_revolute1) + { + m_J.angular1 = -1.0f; + K += b1->m_invI; + } + else + { + b2Vec2 ug = b2Mul(g1->GetXForm().R, m_prismatic1->m_localXAxis1); + b2Vec2 r = b2Mul(b1->GetXForm().R, m_localAnchor1 - b1->GetLocalCenter()); + float32 crug = b2Cross(r, ug); + m_J.linear1 = -ug; + m_J.angular1 = -crug; + K += b1->m_invMass + b1->m_invI * crug * crug; + } + + if (m_revolute2) + { + m_J.angular2 = -m_ratio; + K += m_ratio * m_ratio * b2->m_invI; + } + else + { + b2Vec2 ug = b2Mul(g2->GetXForm().R, m_prismatic2->m_localXAxis1); + b2Vec2 r = b2Mul(b2->GetXForm().R, m_localAnchor2 - b2->GetLocalCenter()); + float32 crug = b2Cross(r, ug); + m_J.linear2 = -m_ratio * ug; + m_J.angular2 = -m_ratio * crug; + K += m_ratio * m_ratio * (b2->m_invMass + b2->m_invI * crug * crug); + } + + // Compute effective mass. + b2Assert(K > 0.0f); + m_mass = 1.0f / K; + + if (step.warmStarting) + { + // Warm starting. + float32 P = B2FORCE_SCALE(step.dt) * m_force; + b1->m_linearVelocity += b1->m_invMass * P * m_J.linear1; + b1->m_angularVelocity += b1->m_invI * P * m_J.angular1; + b2->m_linearVelocity += b2->m_invMass * P * m_J.linear2; + b2->m_angularVelocity += b2->m_invI * P * m_J.angular2; + } + else + { + m_force = 0.0f; + } +} + +void b2GearJoint::SolveVelocityConstraints(const b2TimeStep& step) +{ + b2Body* b1 = m_body1; + b2Body* b2 = m_body2; + + float32 Cdot = m_J.Compute( b1->m_linearVelocity, b1->m_angularVelocity, + b2->m_linearVelocity, b2->m_angularVelocity); + + float32 force = -B2FORCE_INV_SCALE(step.inv_dt) * m_mass * Cdot; + m_force += force; + + float32 P = B2FORCE_SCALE(step.dt) * force; + b1->m_linearVelocity += b1->m_invMass * P * m_J.linear1; + b1->m_angularVelocity += b1->m_invI * P * m_J.angular1; + b2->m_linearVelocity += b2->m_invMass * P * m_J.linear2; + b2->m_angularVelocity += b2->m_invI * P * m_J.angular2; +} + +bool b2GearJoint::SolvePositionConstraints() +{ + float32 linearError = 0.0f; + + b2Body* b1 = m_body1; + b2Body* b2 = m_body2; + + float32 coordinate1, coordinate2; + if (m_revolute1) + { + coordinate1 = m_revolute1->GetJointAngle(); + } + else + { + coordinate1 = m_prismatic1->GetJointTranslation(); + } + + if (m_revolute2) + { + coordinate2 = m_revolute2->GetJointAngle(); + } + else + { + coordinate2 = m_prismatic2->GetJointTranslation(); + } + + float32 C = m_constant - (coordinate1 + m_ratio * coordinate2); + + float32 impulse = -m_mass * C; + + b1->m_sweep.c += b1->m_invMass * impulse * m_J.linear1; + b1->m_sweep.a += b1->m_invI * impulse * m_J.angular1; + b2->m_sweep.c += b2->m_invMass * impulse * m_J.linear2; + b2->m_sweep.a += b2->m_invI * impulse * m_J.angular2; + + b1->SynchronizeTransform(); + b2->SynchronizeTransform(); + + return linearError < b2_linearSlop; +} + +b2Vec2 b2GearJoint::GetAnchor1() const +{ + return m_body1->GetWorldPoint(m_localAnchor1); +} + +b2Vec2 b2GearJoint::GetAnchor2() const +{ + return m_body2->GetWorldPoint(m_localAnchor2); +} + +b2Vec2 b2GearJoint::GetReactionForce() const +{ + // TODO_ERIN not tested + b2Vec2 F = B2FORCE_SCALE(m_force) * m_J.linear2; + return F; +} + +float32 b2GearJoint::GetReactionTorque() const +{ + // TODO_ERIN not tested + b2Vec2 r = b2Mul(m_body2->GetXForm().R, m_localAnchor2 - m_body2->GetLocalCenter()); + b2Vec2 F = m_force * m_J.linear2; + float32 T = B2FORCE_SCALE(m_force * m_J.angular2 - b2Cross(r, F)); + return T; +} + +float32 b2GearJoint::GetRatio() const +{ + return m_ratio; +} + + diff --git a/Box2D/Source/Dynamics/Joints/b2GearJoint.h b/Box2D/Source/Dynamics/Joints/b2GearJoint.h new file mode 100644 index 0000000..5c8e48d --- /dev/null +++ b/Box2D/Source/Dynamics/Joints/b2GearJoint.h @@ -0,0 +1,109 @@ +/* +* Copyright (c) 2006-2007 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_GEAR_JOINT_H +#define B2_GEAR_JOINT_H + +#include "b2Joint.h" + +class b2RevoluteJoint; +class b2PrismaticJoint; + +/// Gear joint definition. This definition requires two existing +/// revolute or prismatic joints (any combination will work). +/// The provided joints must attach a dynamic body to a static body. +struct b2GearJointDef : public b2JointDef +{ + b2GearJointDef() + { + type = e_gearJoint; + joint1 = NULL; + joint2 = NULL; + ratio = 1.0f; + } + + /// The first revolute/prismatic joint attached to the gear joint. + b2Joint* joint1; + + /// The second revolute/prismatic joint attached to the gear joint. + b2Joint* joint2; + + /// The gear ratio. + /// @see b2GearJoint for explanation. + float32 ratio; +}; + +/// A gear joint is used to connect two joints together. Either joint +/// can be a revolute or prismatic joint. You specify a gear ratio +/// to bind the motions together: +/// coordinate1 + ratio * coordinate2 = constant +/// The ratio can be negative or positive. If one joint is a revolute joint +/// and the other joint is a prismatic joint, then the ratio will have units +/// of length or units of 1/length. +/// @warning The revolute and prismatic joints must be attached to +/// fixed bodies (which must be body1 on those joints). +class b2GearJoint : public b2Joint +{ +public: + b2Vec2 GetAnchor1() const; + b2Vec2 GetAnchor2() const; + + b2Vec2 GetReactionForce() const; + float32 GetReactionTorque() const; + + /// Get the gear ratio. + float32 GetRatio() const; + + //--------------- Internals Below ------------------- + + b2GearJoint(const b2GearJointDef* data); + + void InitVelocityConstraints(const b2TimeStep& step); + void SolveVelocityConstraints(const b2TimeStep& step); + bool SolvePositionConstraints(); + + b2Body* m_ground1; + b2Body* m_ground2; + + // One of these is NULL. + b2RevoluteJoint* m_revolute1; + b2PrismaticJoint* m_prismatic1; + + // One of these is NULL. + b2RevoluteJoint* m_revolute2; + b2PrismaticJoint* m_prismatic2; + + b2Vec2 m_groundAnchor1; + b2Vec2 m_groundAnchor2; + + b2Vec2 m_localAnchor1; + b2Vec2 m_localAnchor2; + + b2Jacobian m_J; + + float32 m_constant; + float32 m_ratio; + + // Effective mass + float32 m_mass; + + // Impulse for accumulation/warm starting. + float32 m_force; +}; + +#endif diff --git a/Box2D/Source/Dynamics/Joints/b2Joint.cpp b/Box2D/Source/Dynamics/Joints/b2Joint.cpp new file mode 100644 index 0000000..867ba8e --- /dev/null +++ b/Box2D/Source/Dynamics/Joints/b2Joint.cpp @@ -0,0 +1,134 @@ +/* +* Copyright (c) 2006-2007 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. +*/ + +#include "b2Joint.h" +#include "b2DistanceJoint.h" +#include "b2MouseJoint.h" +#include "b2RevoluteJoint.h" +#include "b2PrismaticJoint.h" +#include "b2PulleyJoint.h" +#include "b2GearJoint.h" +#include "../b2Body.h" +#include "../b2World.h" +#include "../../Common/b2BlockAllocator.h" +#include "../../Collision/b2BroadPhase.h" + +#include + +b2Joint* b2Joint::Create(const b2JointDef* def, b2BlockAllocator* allocator) +{ + b2Joint* joint = NULL; + + switch (def->type) + { + case e_distanceJoint: + { + void* mem = allocator->Allocate(sizeof(b2DistanceJoint)); + joint = new (mem) b2DistanceJoint((b2DistanceJointDef*)def); + } + break; + + case e_mouseJoint: + { + void* mem = allocator->Allocate(sizeof(b2MouseJoint)); + joint = new (mem) b2MouseJoint((b2MouseJointDef*)def); + } + break; + + case e_prismaticJoint: + { + void* mem = allocator->Allocate(sizeof(b2PrismaticJoint)); + joint = new (mem) b2PrismaticJoint((b2PrismaticJointDef*)def); + } + break; + + case e_revoluteJoint: + { + void* mem = allocator->Allocate(sizeof(b2RevoluteJoint)); + joint = new (mem) b2RevoluteJoint((b2RevoluteJointDef*)def); + } + break; + + case e_pulleyJoint: + { + void* mem = allocator->Allocate(sizeof(b2PulleyJoint)); + joint = new (mem) b2PulleyJoint((b2PulleyJointDef*)def); + } + break; + + case e_gearJoint: + { + void* mem = allocator->Allocate(sizeof(b2GearJoint)); + joint = new (mem) b2GearJoint((b2GearJointDef*)def); + } + break; + + default: + b2Assert(false); + break; + } + + return joint; +} + +void b2Joint::Destroy(b2Joint* joint, b2BlockAllocator* allocator) +{ + joint->~b2Joint(); + switch (joint->m_type) + { + case e_distanceJoint: + allocator->Free(joint, sizeof(b2DistanceJoint)); + break; + + case e_mouseJoint: + allocator->Free(joint, sizeof(b2MouseJoint)); + break; + + case e_prismaticJoint: + allocator->Free(joint, sizeof(b2PrismaticJoint)); + break; + + case e_revoluteJoint: + allocator->Free(joint, sizeof(b2RevoluteJoint)); + break; + + case e_pulleyJoint: + allocator->Free(joint, sizeof(b2PulleyJoint)); + break; + + case e_gearJoint: + allocator->Free(joint, sizeof(b2GearJoint)); + break; + + default: + b2Assert(false); + break; + } +} + +b2Joint::b2Joint(const b2JointDef* def) +{ + m_type = def->type; + m_prev = NULL; + m_next = NULL; + m_body1 = def->body1; + m_body2 = def->body2; + m_collideConnected = def->collideConnected; + m_islandFlag = false; + m_userData = def->userData; +} diff --git a/Box2D/Source/Dynamics/Joints/b2Joint.h b/Box2D/Source/Dynamics/Joints/b2Joint.h new file mode 100644 index 0000000..11744e7 --- /dev/null +++ b/Box2D/Source/Dynamics/Joints/b2Joint.h @@ -0,0 +1,219 @@ +/* +* Copyright (c) 2006-2007 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 JOINT_H +#define JOINT_H + +#include "../../Common/b2Math.h" + +class b2Body; +class b2Joint; +struct b2TimeStep; +class b2BlockAllocator; + +enum b2JointType +{ + e_unknownJoint, + e_revoluteJoint, + e_prismaticJoint, + e_distanceJoint, + e_pulleyJoint, + e_mouseJoint, + e_gearJoint +}; + +enum b2LimitState +{ + e_inactiveLimit, + e_atLowerLimit, + e_atUpperLimit, + e_equalLimits +}; + +struct b2Jacobian +{ + b2Vec2 linear1; + float32 angular1; + b2Vec2 linear2; + float32 angular2; + + void SetZero(); + void Set(const b2Vec2& x1, float32 a1, const b2Vec2& x2, float32 a2); + float32 Compute(const b2Vec2& x1, float32 a1, const b2Vec2& x2, float32 a2); +}; + +/// A joint edge is used to connect bodies and joints together +/// in a joint graph where each body is a node and each joint +/// is an edge. A joint edge belongs to a doubly linked list +/// maintained in each attached body. Each joint has two joint +/// nodes, one for each attached body. +struct b2JointEdge +{ + b2Body* other; ///< provides quick access to the other body attached. + b2Joint* joint; ///< the joint + b2JointEdge* prev; ///< the previous joint edge in the body's joint list + b2JointEdge* next; ///< the next joint edge in the body's joint list +}; + +/// Joint definitions are used to construct joints. +struct b2JointDef +{ + b2JointDef() + { + type = e_unknownJoint; + userData = NULL; + body1 = NULL; + body2 = NULL; + collideConnected = false; + } + + /// The joint type is set automatically for concrete joint types. + b2JointType type; + + /// Use this to attach application specific data to your joints. + void* userData; + + /// The first attached body. + b2Body* body1; + + /// The second attached body. + b2Body* body2; + + /// Set this flag to true if the attached bodies should collide. + bool collideConnected; +}; + +/// The base joint class. Joints are used to constraint two bodies together in +/// various fashions. Some joints also feature limits and motors. +class b2Joint +{ +public: + + /// Get the type of the concrete joint. + b2JointType GetType() const; + + /// Get the first body attached to this joint. + b2Body* GetBody1(); + + /// Get the second body attached to this joint. + b2Body* GetBody2(); + + /// Get the anchor point on body1 in world coordinates. + virtual b2Vec2 GetAnchor1() const = 0; + + /// Get the anchor point on body2 in world coordinates. + virtual b2Vec2 GetAnchor2() const = 0; + + /// Get the reaction force on body2 at the joint anchor. + virtual b2Vec2 GetReactionForce() const = 0; + + /// Get the reaction torque on body2. + virtual float32 GetReactionTorque() const = 0; + + /// Get the next joint the world joint list. + b2Joint* GetNext(); + + /// Get the user data pointer. + void* GetUserData(); + + /// Set the user data pointer. + void SetUserData(void* data); + + //--------------- Internals Below ------------------- +protected: + friend class b2World; + friend class b2Body; + friend class b2Island; + + static b2Joint* Create(const b2JointDef* def, b2BlockAllocator* allocator); + static void Destroy(b2Joint* joint, b2BlockAllocator* allocator); + + b2Joint(const b2JointDef* def); + virtual ~b2Joint() {} + + virtual void InitVelocityConstraints(const b2TimeStep& step) = 0; + virtual void SolveVelocityConstraints(const b2TimeStep& step) = 0; + + // This returns true if the position errors are within tolerance. + virtual void InitPositionConstraints() {} + virtual bool SolvePositionConstraints() = 0; + + b2JointType m_type; + b2Joint* m_prev; + b2Joint* m_next; + b2JointEdge m_node1; + b2JointEdge m_node2; + b2Body* m_body1; + b2Body* m_body2; + + float32 m_inv_dt; + + bool m_islandFlag; + bool m_collideConnected; + + void* m_userData; +}; + +inline void b2Jacobian::SetZero() +{ + linear1.SetZero(); angular1 = 0.0f; + linear2.SetZero(); angular2 = 0.0f; +} + +inline void b2Jacobian::Set(const b2Vec2& x1, float32 a1, const b2Vec2& x2, float32 a2) +{ + linear1 = x1; angular1 = a1; + linear2 = x2; angular2 = a2; +} + +inline float32 b2Jacobian::Compute(const b2Vec2& x1, float32 a1, const b2Vec2& x2, float32 a2) +{ + return b2Dot(linear1, x1) + angular1 * a1 + b2Dot(linear2, x2) + angular2 * a2; +} + +inline b2JointType b2Joint::GetType() const +{ + return m_type; +} + +inline b2Body* b2Joint::GetBody1() +{ + return m_body1; +} + +inline b2Body* b2Joint::GetBody2() +{ + return m_body2; +} + +inline b2Joint* b2Joint::GetNext() +{ + return m_next; +} + +inline void* b2Joint::GetUserData() +{ + return m_userData; +} + +inline void b2Joint::SetUserData(void* data) +{ + m_userData = data; +} + +#endif diff --git a/Box2D/Source/Dynamics/Joints/b2MouseJoint.cpp b/Box2D/Source/Dynamics/Joints/b2MouseJoint.cpp new file mode 100644 index 0000000..88cbca6 --- /dev/null +++ b/Box2D/Source/Dynamics/Joints/b2MouseJoint.cpp @@ -0,0 +1,146 @@ +/* +* Copyright (c) 2006-2007 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. +*/ + +#include "b2MouseJoint.h" +#include "../b2Body.h" +#include "../b2World.h" + +// p = attached point, m = mouse point +// C = p - m +// Cdot = v +// = v + cross(w, r) +// J = [I r_skew] +// Identity used: +// w k % (rx i + ry j) = w * (-ry i + rx j) + +b2MouseJoint::b2MouseJoint(const b2MouseJointDef* def) +: b2Joint(def) +{ + m_target = def->target; + m_localAnchor = b2MulT(m_body2->GetXForm(), m_target); + + m_maxForce = B2FORCE_INV_SCALE(def->maxForce); + m_impulse.SetZero(); + + float32 mass = m_body2->m_mass; + + // Frequency + float32 omega = 2.0f * b2_pi * def->frequencyHz; + + // Damping coefficient + float32 d = 2.0f * mass * def->dampingRatio * omega; + + // Spring stiffness + float32 k = (def->timeStep * mass) * (omega * omega); + + // magic formulas + b2Assert(d + k > B2_FLT_EPSILON); + m_gamma = 1.0f / (d + k); + m_beta = k / (d + k); +} + +void b2MouseJoint::SetTarget(const b2Vec2& target) +{ + if (m_body2->IsSleeping()) + { + m_body2->WakeUp(); + } + m_target = target; +} + +void b2MouseJoint::InitVelocityConstraints(const b2TimeStep& step) +{ + b2Body* b = m_body2; + + // Compute the effective mass matrix. + b2Vec2 r = b2Mul(b->GetXForm().R, m_localAnchor - b->GetLocalCenter()); + + // K = [(1/m1 + 1/m2) * eye(2) - skew(r1) * invI1 * skew(r1) - skew(r2) * invI2 * skew(r2)] + // = [1/m1+1/m2 0 ] + invI1 * [r1.y*r1.y -r1.x*r1.y] + invI2 * [r1.y*r1.y -r1.x*r1.y] + // [ 0 1/m1+1/m2] [-r1.x*r1.y r1.x*r1.x] [-r1.x*r1.y r1.x*r1.x] + float32 invMass = b->m_invMass; + float32 invI = b->m_invI; + + b2Mat22 K1; + K1.col1.x = invMass; K1.col2.x = 0.0f; + K1.col1.y = 0.0f; K1.col2.y = invMass; + + b2Mat22 K2; + K2.col1.x = invI * r.y * r.y; K2.col2.x = -invI * r.x * r.y; + K2.col1.y = -invI * r.x * r.y; K2.col2.y = invI * r.x * r.x; + + b2Mat22 K = K1 + K2; + K.col1.x += m_gamma; + K.col2.y += m_gamma; + + m_mass = K.Invert(); + + m_C = b->m_sweep.c + r - m_target; + + // Cheat with some damping + b->m_angularVelocity *= 0.98f; + + // Warm starting. + b2Vec2 P = B2FORCE_SCALE(step.dt) * m_impulse; + b->m_linearVelocity += invMass * P; + b->m_angularVelocity += invI * b2Cross(r, P); +} + +void b2MouseJoint::SolveVelocityConstraints(const b2TimeStep& step) +{ + b2Body* b = m_body2; + + b2Vec2 r = b2Mul(b->GetXForm().R, m_localAnchor - b->GetLocalCenter()); + + // Cdot = v + cross(w, r) + b2Vec2 Cdot = b->m_linearVelocity + b2Cross(b->m_angularVelocity, r); + b2Vec2 force = -B2FORCE_INV_SCALE(step.inv_dt) * b2Mul(m_mass, Cdot + (m_beta * step.inv_dt) * m_C + B2FORCE_SCALE(step.dt) * (m_gamma * m_impulse)); + + b2Vec2 oldForce = m_impulse; + m_impulse += force; + float32 forceMagnitude = m_impulse.Length(); + if (forceMagnitude > m_maxForce) + { + m_impulse *= m_maxForce / forceMagnitude; + } + force = m_impulse - oldForce; + + b2Vec2 P = B2FORCE_SCALE(step.dt) * force; + b->m_linearVelocity += b->m_invMass * P; + b->m_angularVelocity += b->m_invI * b2Cross(r, P); +} + +b2Vec2 b2MouseJoint::GetAnchor1() const +{ + return m_target; +} + +b2Vec2 b2MouseJoint::GetAnchor2() const +{ + return m_body2->GetWorldPoint(m_localAnchor); +} + +b2Vec2 b2MouseJoint::GetReactionForce() const +{ + return B2FORCE_SCALE(float32(1.0))*m_impulse; +} + +float32 b2MouseJoint::GetReactionTorque() const +{ + return 0.0f; +} diff --git a/Box2D/Source/Dynamics/Joints/b2MouseJoint.h b/Box2D/Source/Dynamics/Joints/b2MouseJoint.h new file mode 100644 index 0000000..6de585e --- /dev/null +++ b/Box2D/Source/Dynamics/Joints/b2MouseJoint.h @@ -0,0 +1,102 @@ +/* +* Copyright (c) 2006-2007 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_MOUSE_JOINT_H +#define B2_MOUSE_JOINT_H + +#include "b2Joint.h" + +/// Mouse joint definition. This requires a world target point, +/// tuning parameters, and the time step. +struct b2MouseJointDef : public b2JointDef +{ + b2MouseJointDef() + { + type = e_mouseJoint; + target.Set(0.0f, 0.0f); + maxForce = 0.0f; + frequencyHz = 5.0f; + dampingRatio = 0.7f; + timeStep = 1.0f / 60.0f; + } + + /// The initial world target point. This is assumed + /// to coincide with the body anchor initially. + b2Vec2 target; + + /// The maximum constraint force that can be exerted + /// to move the candidate body. Usually you will express + /// as some multiple of the weight (multiplier * mass * gravity). + float32 maxForce; + + /// The response speed. + float32 frequencyHz; + + /// The damping ratio. 0 = no damping, 1 = critical damping. + float32 dampingRatio; + + /// The time step used in the simulation. + float32 timeStep; +}; + +/// A mouse joint is used to make a point on a body track a +/// specified world point. This a soft constraint with a maximum +/// force. This allows the constraint to stretch and without +/// applying huge forces. +class b2MouseJoint : public b2Joint +{ +public: + + /// Implements b2Joint. + b2Vec2 GetAnchor1() const; + + /// Implements b2Joint. + b2Vec2 GetAnchor2() const; + + /// Implements b2Joint. + b2Vec2 GetReactionForce() const; + + /// Implements b2Joint. + float32 GetReactionTorque() const; + + /// Use this to update the target point. + void SetTarget(const b2Vec2& target); + + //--------------- Internals Below ------------------- + + b2MouseJoint(const b2MouseJointDef* def); + + void InitVelocityConstraints(const b2TimeStep& step); + void SolveVelocityConstraints(const b2TimeStep& step); + bool SolvePositionConstraints() + { + return true; + } + + b2Vec2 m_localAnchor; + b2Vec2 m_target; + b2Vec2 m_impulse; + + b2Mat22 m_mass; // effective mass for point-to-point constraint. + b2Vec2 m_C; // position error + float32 m_maxForce; + float32 m_beta; // bias factor + float32 m_gamma; // softness +}; + +#endif diff --git a/Box2D/Source/Dynamics/Joints/b2PrismaticJoint.cpp b/Box2D/Source/Dynamics/Joints/b2PrismaticJoint.cpp new file mode 100644 index 0000000..c3f6752 --- /dev/null +++ b/Box2D/Source/Dynamics/Joints/b2PrismaticJoint.cpp @@ -0,0 +1,478 @@ +/* +* Copyright (c) 2006-2007 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. +*/ + +#include "b2PrismaticJoint.h" +#include "../b2Body.h" +#include "../b2World.h" + +// Linear constraint (point-to-line) +// d = p2 - p1 = x2 + r2 - x1 - r1 +// C = dot(ay1, d) +// Cdot = dot(d, cross(w1, ay1)) + dot(ay1, v2 + cross(w2, r2) - v1 - cross(w1, r1)) +// = -dot(ay1, v1) - dot(cross(d + r1, ay1), w1) + dot(ay1, v2) + dot(cross(r2, ay1), v2) +// J = [-ay1 -cross(d+r1,ay1) ay1 cross(r2,ay1)] +// +// Angular constraint +// C = a2 - a1 + a_initial +// Cdot = w2 - w1 +// J = [0 0 -1 0 0 1] + +// Motor/Limit linear constraint +// C = dot(ax1, d) +// Cdot = = -dot(ax1, v1) - dot(cross(d + r1, ax1), w1) + dot(ax1, v2) + dot(cross(r2, ax1), v2) +// J = [-ax1 -cross(d+r1,ax1) ax1 cross(r2,ax1)] + +void b2PrismaticJointDef::Initialize(b2Body* b1, b2Body* b2, const b2Vec2& anchor, const b2Vec2& axis) +{ + body1 = b1; + body2 = b2; + localAnchor1 = body1->GetLocalPoint(anchor); + localAnchor2 = body2->GetLocalPoint(anchor); + localAxis1 = body1->GetLocalVector(axis); + referenceAngle = body2->GetAngle() - body1->GetAngle(); +} + +b2PrismaticJoint::b2PrismaticJoint(const b2PrismaticJointDef* def) +: b2Joint(def) +{ + m_localAnchor1 = def->localAnchor1; + m_localAnchor2 = def->localAnchor2; + m_localXAxis1 = def->localAxis1; + m_localYAxis1 = b2Cross(1.0f, m_localXAxis1); + m_refAngle = def->referenceAngle; + + m_linearJacobian.SetZero(); + m_linearMass = 0.0f; + m_force = 0.0f; + + m_angularMass = 0.0f; + m_torque = 0.0f; + + m_motorJacobian.SetZero(); + m_motorMass = 0.0; + m_motorForce = 0.0f; + m_limitForce = 0.0f; + m_limitPositionImpulse = 0.0f; + + m_lowerTranslation = def->lowerTranslation; + m_upperTranslation = def->upperTranslation; + m_maxMotorForce = B2FORCE_INV_SCALE(def->maxMotorForce); + m_motorSpeed = def->motorSpeed; + m_enableLimit = def->enableLimit; + m_enableMotor = def->enableMotor; +} + +void b2PrismaticJoint::InitVelocityConstraints(const b2TimeStep& step) +{ + b2Body* b1 = m_body1; + b2Body* b2 = m_body2; + + // Compute the effective masses. + b2Vec2 r1 = b2Mul(b1->GetXForm().R, m_localAnchor1 - b1->GetLocalCenter()); + b2Vec2 r2 = b2Mul(b2->GetXForm().R, m_localAnchor2 - b2->GetLocalCenter()); + + float32 invMass1 = b1->m_invMass, invMass2 = b2->m_invMass; + float32 invI1 = b1->m_invI, invI2 = b2->m_invI; + + // Compute point to line constraint effective mass. + // J = [-ay1 -cross(d+r1,ay1) ay1 cross(r2,ay1)] + b2Vec2 ay1 = b2Mul(b1->GetXForm().R, m_localYAxis1); + b2Vec2 e = b2->m_sweep.c + r2 - b1->m_sweep.c; // e = d + r1 + + m_linearJacobian.Set(-ay1, -b2Cross(e, ay1), ay1, b2Cross(r2, ay1)); + m_linearMass = invMass1 + invI1 * m_linearJacobian.angular1 * m_linearJacobian.angular1 + + invMass2 + invI2 * m_linearJacobian.angular2 * m_linearJacobian.angular2; + b2Assert(m_linearMass > B2_FLT_EPSILON); + m_linearMass = 1.0f / m_linearMass; + + // Compute angular constraint effective mass. + m_angularMass = invI1 + invI2; + if (m_angularMass > B2_FLT_EPSILON) + { + m_angularMass = 1.0f / m_angularMass; + } + + // Compute motor and limit terms. + if (m_enableLimit || m_enableMotor) + { + // The motor and limit share a Jacobian and effective mass. + b2Vec2 ax1 = b2Mul(b1->GetXForm().R, m_localXAxis1); + m_motorJacobian.Set(-ax1, -b2Cross(e, ax1), ax1, b2Cross(r2, ax1)); + m_motorMass = invMass1 + invI1 * m_motorJacobian.angular1 * m_motorJacobian.angular1 + + invMass2 + invI2 * m_motorJacobian.angular2 * m_motorJacobian.angular2; + b2Assert(m_motorMass > B2_FLT_EPSILON); + m_motorMass = 1.0f / m_motorMass; + + if (m_enableLimit) + { + b2Vec2 d = e - r1; // p2 - p1 + float32 jointTranslation = b2Dot(ax1, d); + if (b2Abs(m_upperTranslation - m_lowerTranslation) < 2.0f * b2_linearSlop) + { + m_limitState = e_equalLimits; + } + else if (jointTranslation <= m_lowerTranslation) + { + if (m_limitState != e_atLowerLimit) + { + m_limitForce = 0.0f; + } + m_limitState = e_atLowerLimit; + } + else if (jointTranslation >= m_upperTranslation) + { + if (m_limitState != e_atUpperLimit) + { + m_limitForce = 0.0f; + } + m_limitState = e_atUpperLimit; + } + else + { + m_limitState = e_inactiveLimit; + m_limitForce = 0.0f; + } + } + } + + if (m_enableMotor == false) + { + m_motorForce = 0.0f; + } + + if (m_enableLimit == false) + { + m_limitForce = 0.0f; + } + + if (step.warmStarting) + { + b2Vec2 P1 = B2FORCE_SCALE(step.dt) * (m_force * m_linearJacobian.linear1 + (m_motorForce + m_limitForce) * m_motorJacobian.linear1); + b2Vec2 P2 = B2FORCE_SCALE(step.dt) * (m_force * m_linearJacobian.linear2 + (m_motorForce + m_limitForce) * m_motorJacobian.linear2); + float32 L1 = B2FORCE_SCALE(step.dt) * (m_force * m_linearJacobian.angular1 - m_torque + (m_motorForce + m_limitForce) * m_motorJacobian.angular1); + float32 L2 = B2FORCE_SCALE(step.dt) * (m_force * m_linearJacobian.angular2 + m_torque + (m_motorForce + m_limitForce) * m_motorJacobian.angular2); + + b1->m_linearVelocity += invMass1 * P1; + b1->m_angularVelocity += invI1 * L1; + + b2->m_linearVelocity += invMass2 * P2; + b2->m_angularVelocity += invI2 * L2; + } + else + { + m_force = 0.0f; + m_torque = 0.0f; + m_limitForce = 0.0f; + m_motorForce = 0.0f; + } + + m_limitPositionImpulse = 0.0f; +} + +void b2PrismaticJoint::SolveVelocityConstraints(const b2TimeStep& step) +{ + b2Body* b1 = m_body1; + b2Body* b2 = m_body2; + + float32 invMass1 = b1->m_invMass, invMass2 = b2->m_invMass; + float32 invI1 = b1->m_invI, invI2 = b2->m_invI; + + // Solve linear constraint. + float32 linearCdot = m_linearJacobian.Compute(b1->m_linearVelocity, b1->m_angularVelocity, b2->m_linearVelocity, b2->m_angularVelocity); + float32 force = -B2FORCE_INV_SCALE(step.inv_dt) * m_linearMass * linearCdot; + m_force += force; + + float32 P = B2FORCE_SCALE(step.dt) * force; + b1->m_linearVelocity += (invMass1 * P) * m_linearJacobian.linear1; + b1->m_angularVelocity += invI1 * P * m_linearJacobian.angular1; + + b2->m_linearVelocity += (invMass2 * P) * m_linearJacobian.linear2; + b2->m_angularVelocity += invI2 * P * m_linearJacobian.angular2; + + // Solve angular constraint. + float32 angularCdot = b2->m_angularVelocity - b1->m_angularVelocity; + float32 torque = -B2FORCE_INV_SCALE(step.inv_dt) * m_angularMass * angularCdot; + m_torque += torque; + + float32 L = B2FORCE_SCALE(step.dt) * torque; + b1->m_angularVelocity -= invI1 * L; + b2->m_angularVelocity += invI2 * L; + + // Solve linear motor constraint. + if (m_enableMotor && m_limitState != e_equalLimits) + { + float32 motorCdot = m_motorJacobian.Compute(b1->m_linearVelocity, b1->m_angularVelocity, b2->m_linearVelocity, b2->m_angularVelocity) - m_motorSpeed; + float32 motorForce = -B2FORCE_INV_SCALE(step.inv_dt) * m_motorMass * motorCdot; + float32 oldMotorForce = m_motorForce; + m_motorForce = b2Clamp(m_motorForce + motorForce, -m_maxMotorForce, m_maxMotorForce); + motorForce = m_motorForce - oldMotorForce; + + float32 P = B2FORCE_SCALE(step.dt) * motorForce; + b1->m_linearVelocity += (invMass1 * P) * m_motorJacobian.linear1; + b1->m_angularVelocity += invI1 * P * m_motorJacobian.angular1; + + b2->m_linearVelocity += (invMass2 * P) * m_motorJacobian.linear2; + b2->m_angularVelocity += invI2 * P * m_motorJacobian.angular2; + } + + // Solve linear limit constraint. + if (m_enableLimit && m_limitState != e_inactiveLimit) + { + float32 limitCdot = m_motorJacobian.Compute(b1->m_linearVelocity, b1->m_angularVelocity, b2->m_linearVelocity, b2->m_angularVelocity); + float32 limitForce = -B2FORCE_INV_SCALE(step.inv_dt) * m_motorMass * limitCdot; + + if (m_limitState == e_equalLimits) + { + m_limitForce += limitForce; + } + else if (m_limitState == e_atLowerLimit) + { + float32 oldLimitForce = m_limitForce; + m_limitForce = b2Max(m_limitForce + limitForce, 0.0f); + limitForce = m_limitForce - oldLimitForce; + } + else if (m_limitState == e_atUpperLimit) + { + float32 oldLimitForce = m_limitForce; + m_limitForce = b2Min(m_limitForce + limitForce, 0.0f); + limitForce = m_limitForce - oldLimitForce; + } + + float32 P = B2FORCE_SCALE(step.dt) * limitForce; + + b1->m_linearVelocity += (invMass1 * P) * m_motorJacobian.linear1; + b1->m_angularVelocity += invI1 * P * m_motorJacobian.angular1; + + b2->m_linearVelocity += (invMass2 * P) * m_motorJacobian.linear2; + b2->m_angularVelocity += invI2 * P * m_motorJacobian.angular2; + } +} + +bool b2PrismaticJoint::SolvePositionConstraints() +{ + b2Body* b1 = m_body1; + b2Body* b2 = m_body2; + + float32 invMass1 = b1->m_invMass, invMass2 = b2->m_invMass; + float32 invI1 = b1->m_invI, invI2 = b2->m_invI; + + b2Vec2 r1 = b2Mul(b1->GetXForm().R, m_localAnchor1 - b1->GetLocalCenter()); + b2Vec2 r2 = b2Mul(b2->GetXForm().R, m_localAnchor2 - b2->GetLocalCenter()); + b2Vec2 p1 = b1->m_sweep.c + r1; + b2Vec2 p2 = b2->m_sweep.c + r2; + b2Vec2 d = p2 - p1; + b2Vec2 ay1 = b2Mul(b1->GetXForm().R, m_localYAxis1); + + // Solve linear (point-to-line) constraint. + float32 linearC = b2Dot(ay1, d); + // Prevent overly large corrections. + linearC = b2Clamp(linearC, -b2_maxLinearCorrection, b2_maxLinearCorrection); + float32 linearImpulse = -m_linearMass * linearC; + + b1->m_sweep.c += (invMass1 * linearImpulse) * m_linearJacobian.linear1; + b1->m_sweep.a += invI1 * linearImpulse * m_linearJacobian.angular1; + //b1->SynchronizeTransform(); // updated by angular constraint + b2->m_sweep.c += (invMass2 * linearImpulse) * m_linearJacobian.linear2; + b2->m_sweep.a += invI2 * linearImpulse * m_linearJacobian.angular2; + //b2->SynchronizeTransform(); // updated by angular constraint + + float32 positionError = b2Abs(linearC); + + // Solve angular constraint. + float32 angularC = b2->m_sweep.a - b1->m_sweep.a - m_refAngle; + // Prevent overly large corrections. + angularC = b2Clamp(angularC, -b2_maxAngularCorrection, b2_maxAngularCorrection); + float32 angularImpulse = -m_angularMass * angularC; + + b1->m_sweep.a -= b1->m_invI * angularImpulse; + b2->m_sweep.a += b2->m_invI * angularImpulse; + + b1->SynchronizeTransform(); + b2->SynchronizeTransform(); + + float32 angularError = b2Abs(angularC); + + // Solve linear limit constraint. + if (m_enableLimit && m_limitState != e_inactiveLimit) + { + b2Vec2 r1 = b2Mul(b1->GetXForm().R, m_localAnchor1 - b1->GetLocalCenter()); + b2Vec2 r2 = b2Mul(b2->GetXForm().R, m_localAnchor2 - b2->GetLocalCenter()); + b2Vec2 p1 = b1->m_sweep.c + r1; + b2Vec2 p2 = b2->m_sweep.c + r2; + b2Vec2 d = p2 - p1; + b2Vec2 ax1 = b2Mul(b1->GetXForm().R, m_localXAxis1); + + float32 translation = b2Dot(ax1, d); + float32 limitImpulse = 0.0f; + + if (m_limitState == e_equalLimits) + { + // Prevent large angular corrections + float32 limitC = b2Clamp(translation, -b2_maxLinearCorrection, b2_maxLinearCorrection); + limitImpulse = -m_motorMass * limitC; + positionError = b2Max(positionError, b2Abs(angularC)); + } + else if (m_limitState == e_atLowerLimit) + { + float32 limitC = translation - m_lowerTranslation; + positionError = b2Max(positionError, -limitC); + + // Prevent large linear corrections and allow some slop. + limitC = b2Clamp(limitC + b2_linearSlop, -b2_maxLinearCorrection, 0.0f); + limitImpulse = -m_motorMass * limitC; + float32 oldLimitImpulse = m_limitPositionImpulse; + m_limitPositionImpulse = b2Max(m_limitPositionImpulse + limitImpulse, 0.0f); + limitImpulse = m_limitPositionImpulse - oldLimitImpulse; + } + else if (m_limitState == e_atUpperLimit) + { + float32 limitC = translation - m_upperTranslation; + positionError = b2Max(positionError, limitC); + + // Prevent large linear corrections and allow some slop. + limitC = b2Clamp(limitC - b2_linearSlop, 0.0f, b2_maxLinearCorrection); + limitImpulse = -m_motorMass * limitC; + float32 oldLimitImpulse = m_limitPositionImpulse; + m_limitPositionImpulse = b2Min(m_limitPositionImpulse + limitImpulse, 0.0f); + limitImpulse = m_limitPositionImpulse - oldLimitImpulse; + } + + b1->m_sweep.c += (invMass1 * limitImpulse) * m_motorJacobian.linear1; + b1->m_sweep.a += invI1 * limitImpulse * m_motorJacobian.angular1; + b2->m_sweep.c += (invMass2 * limitImpulse) * m_motorJacobian.linear2; + b2->m_sweep.a += invI2 * limitImpulse * m_motorJacobian.angular2; + + b1->SynchronizeTransform(); + b2->SynchronizeTransform(); + } + + return positionError <= b2_linearSlop && angularError <= b2_angularSlop; +} + +b2Vec2 b2PrismaticJoint::GetAnchor1() const +{ + return m_body1->GetWorldPoint(m_localAnchor1); +} + +b2Vec2 b2PrismaticJoint::GetAnchor2() const +{ + return m_body2->GetWorldPoint(m_localAnchor2); +} + +b2Vec2 b2PrismaticJoint::GetReactionForce() const +{ + b2Vec2 ax1 = b2Mul(m_body1->GetXForm().R, m_localXAxis1); + b2Vec2 ay1 = b2Mul(m_body1->GetXForm().R, m_localYAxis1); + + return B2FORCE_SCALE(float32(1.0))*(m_limitForce * ax1 + m_force * ay1); +} + +float32 b2PrismaticJoint::GetReactionTorque() const +{ + return B2FORCE_SCALE(m_torque); +} + +float32 b2PrismaticJoint::GetJointTranslation() const +{ + b2Body* b1 = m_body1; + b2Body* b2 = m_body2; + + b2Vec2 p1 = b1->GetWorldPoint(m_localAnchor1); + b2Vec2 p2 = b2->GetWorldPoint(m_localAnchor2); + b2Vec2 d = p2 - p1; + b2Vec2 axis = b1->GetWorldVector(m_localXAxis1); + + float32 translation = b2Dot(d, axis); + return translation; +} + +float32 b2PrismaticJoint::GetJointSpeed() const +{ + b2Body* b1 = m_body1; + b2Body* b2 = m_body2; + + b2Vec2 r1 = b2Mul(b1->GetXForm().R, m_localAnchor1 - b1->GetLocalCenter()); + b2Vec2 r2 = b2Mul(b2->GetXForm().R, m_localAnchor2 - b2->GetLocalCenter()); + b2Vec2 p1 = b1->m_sweep.c + r1; + b2Vec2 p2 = b2->m_sweep.c + r2; + b2Vec2 d = p2 - p1; + b2Vec2 axis = b1->GetWorldVector(m_localXAxis1); + + b2Vec2 v1 = b1->m_linearVelocity; + b2Vec2 v2 = b2->m_linearVelocity; + float32 w1 = b1->m_angularVelocity; + float32 w2 = b2->m_angularVelocity; + + float32 speed = b2Dot(d, b2Cross(w1, axis)) + b2Dot(axis, v2 + b2Cross(w2, r2) - v1 - b2Cross(w1, r1)); + return speed; +} + +bool b2PrismaticJoint::IsLimitEnabled() const +{ + return m_enableLimit; +} + +void b2PrismaticJoint::EnableLimit(bool flag) +{ + m_enableLimit = flag; +} + +float32 b2PrismaticJoint::GetLowerLimit() const +{ + return m_lowerTranslation; +} + +float32 b2PrismaticJoint::GetUpperLimit() const +{ + return m_upperTranslation; +} + +void b2PrismaticJoint::SetLimits(float32 lower, float32 upper) +{ + b2Assert(lower <= upper); + m_lowerTranslation = lower; + m_upperTranslation = upper; +} + +bool b2PrismaticJoint::IsMotorEnabled() const +{ + return m_enableMotor; +} + +void b2PrismaticJoint::EnableMotor(bool flag) +{ + m_enableMotor = flag; +} + +void b2PrismaticJoint::SetMotorSpeed(float32 speed) +{ + m_motorSpeed = speed; +} + +void b2PrismaticJoint::SetMaxMotorForce(float32 force) +{ + m_maxMotorForce = B2FORCE_SCALE(float32(1.0))*force; +} + +float32 b2PrismaticJoint::GetMotorForce() const +{ + return m_motorForce; +} + + + diff --git a/Box2D/Source/Dynamics/Joints/b2PrismaticJoint.h b/Box2D/Source/Dynamics/Joints/b2PrismaticJoint.h new file mode 100644 index 0000000..06f8cb7 --- /dev/null +++ b/Box2D/Source/Dynamics/Joints/b2PrismaticJoint.h @@ -0,0 +1,176 @@ +/* +* Copyright (c) 2006-2007 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_PRISMATIC_JOINT_H +#define B2_PRISMATIC_JOINT_H + +#include "b2Joint.h" + +/// Prismatic joint definition. This requires defining a line of +/// motion using an axis and an anchor point. The definition uses local +/// anchor points and a local axis so that the initial configuration +/// can violate the constraint slightly. The joint translation is zero +/// when the local anchor points coincide in world space. Using local +/// anchors and a local axis helps when saving and loading a game. +struct b2PrismaticJointDef : public b2JointDef +{ + b2PrismaticJointDef() + { + type = e_prismaticJoint; + localAnchor1.SetZero(); + localAnchor2.SetZero(); + localAxis1.Set(1.0f, 0.0f); + referenceAngle = 0.0f; + enableLimit = false; + lowerTranslation = 0.0f; + upperTranslation = 0.0f; + enableMotor = false; + maxMotorForce = 0.0f; + motorSpeed = 0.0f; + } + + /// Initialize the bodies, anchors, axis, and reference angle using the world + /// anchor and world axis. + void Initialize(b2Body* body1, b2Body* body2, const b2Vec2& anchor, const b2Vec2& axis); + + /// The local anchor point relative to body1's origin. + b2Vec2 localAnchor1; + + /// The local anchor point relative to body2's origin. + b2Vec2 localAnchor2; + + /// The local translation axis in body1. + b2Vec2 localAxis1; + + /// The constrained angle between the bodies: body2_angle - body1_angle. + float32 referenceAngle; + + /// Enable/disable the joint limit. + bool enableLimit; + + /// The lower translation limit, usually in meters. + float32 lowerTranslation; + + /// The upper translation limit, usually in meters. + float32 upperTranslation; + + /// Enable/disable the joint motor. + bool enableMotor; + + /// The maximum motor torque, usually in N-m. + float32 maxMotorForce; + + /// The desired motor speed in radians per second. + float32 motorSpeed; +}; + +/// A prismatic joint. This joint provides one degree of freedom: translation +/// along an axis fixed in body1. Relative rotation is prevented. You can +/// use a joint limit to restrict the range of motion and a joint motor to +/// drive the motion or to model joint friction. +class b2PrismaticJoint : public b2Joint +{ +public: + b2Vec2 GetAnchor1() const; + b2Vec2 GetAnchor2() const; + + b2Vec2 GetReactionForce() const; + float32 GetReactionTorque() const; + + /// Get the current joint translation, usually in meters. + float32 GetJointTranslation() const; + + /// Get the current joint translation speed, usually in meters per second. + float32 GetJointSpeed() const; + + /// Is the joint limit enabled? + bool IsLimitEnabled() const; + + /// Enable/disable the joint limit. + void EnableLimit(bool flag); + + /// Get the lower joint limit, usually in meters. + float32 GetLowerLimit() const; + + /// Get the upper joint limit, usually in meters. + float32 GetUpperLimit() const; + + /// Set the joint limits, usually in meters. + void SetLimits(float32 lower, float32 upper); + + /// Is the joint motor enabled? + bool IsMotorEnabled() const; + + /// Enable/disable the joint motor. + void EnableMotor(bool flag); + + /// Set the motor speed, usually in meters per second. + void SetMotorSpeed(float32 speed); + + /// Get the motor speed, usually in meters per second. + float32 GetMotorSpeed() const; + + /// Set the maximum motor force, usually in N. + void SetMaxMotorForce(float32 force); + + /// Get the current motor force, usually in N. + float32 GetMotorForce() const; + + //--------------- Internals Below ------------------- + + b2PrismaticJoint(const b2PrismaticJointDef* def); + + void InitVelocityConstraints(const b2TimeStep& step); + void SolveVelocityConstraints(const b2TimeStep& step); + bool SolvePositionConstraints(); + + b2Vec2 m_localAnchor1; + b2Vec2 m_localAnchor2; + b2Vec2 m_localXAxis1; + b2Vec2 m_localYAxis1; + float32 m_refAngle; + + b2Jacobian m_linearJacobian; + float32 m_linearMass; // effective mass for point-to-line constraint. + float32 m_force; + + float32 m_angularMass; // effective mass for angular constraint. + float32 m_torque; + + b2Jacobian m_motorJacobian; + float32 m_motorMass; // effective mass for motor/limit translational constraint. + float32 m_motorForce; + float32 m_limitForce; + float32 m_limitPositionImpulse; + + float32 m_lowerTranslation; + float32 m_upperTranslation; + float32 m_maxMotorForce; + float32 m_motorSpeed; + + bool m_enableLimit; + bool m_enableMotor; + b2LimitState m_limitState; +}; + +inline float32 b2PrismaticJoint::GetMotorSpeed() const +{ + return m_motorSpeed; +} + +#endif diff --git a/Box2D/Source/Dynamics/Joints/b2PulleyJoint.cpp b/Box2D/Source/Dynamics/Joints/b2PulleyJoint.cpp new file mode 100644 index 0000000..4366af9 --- /dev/null +++ b/Box2D/Source/Dynamics/Joints/b2PulleyJoint.cpp @@ -0,0 +1,430 @@ +/* +* Copyright (c) 2007 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. +*/ + +#include "b2PulleyJoint.h" +#include "../b2Body.h" +#include "../b2World.h" + +// Pulley: +// length1 = norm(p1 - s1) +// length2 = norm(p2 - s2) +// C0 = (length1 + ratio * length2)_initial +// C = C0 - (length1 + ratio * length2) >= 0 +// u1 = (p1 - s1) / norm(p1 - s1) +// u2 = (p2 - s2) / norm(p2 - s2) +// Cdot = -dot(u1, v1 + cross(w1, r1)) - ratio * dot(u2, v2 + cross(w2, r2)) +// J = -[u1 cross(r1, u1) ratio * u2 ratio * cross(r2, u2)] +// K = J * invM * JT +// = invMass1 + invI1 * cross(r1, u1)^2 + ratio^2 * (invMass2 + invI2 * cross(r2, u2)^2) +// +// Limit: +// C = maxLength - length +// u = (p - s) / norm(p - s) +// Cdot = -dot(u, v + cross(w, r)) +// K = invMass + invI * cross(r, u)^2 +// 0 <= impulse + +void b2PulleyJointDef::Initialize(b2Body* b1, b2Body* b2, + const b2Vec2& ga1, const b2Vec2& ga2, + const b2Vec2& anchor1, const b2Vec2& anchor2, + float32 r) +{ + body1 = b1; + body2 = b2; + groundAnchor1 = ga1; + groundAnchor2 = ga2; + localAnchor1 = body1->GetLocalPoint(anchor1); + localAnchor2 = body2->GetLocalPoint(anchor2); + b2Vec2 d1 = anchor1 - ga1; + length1 = d1.Length(); + b2Vec2 d2 = anchor2 - ga2; + length2 = d2.Length(); + ratio = r; + b2Assert(ratio > B2_FLT_EPSILON); + float32 C = length1 + ratio * length2; + maxLength1 = C - ratio * b2_minPulleyLength; + maxLength2 = (C - b2_minPulleyLength) / ratio; +} + +b2PulleyJoint::b2PulleyJoint(const b2PulleyJointDef* def) +: b2Joint(def) +{ + m_ground = m_body1->GetWorld()->GetGroundBody(); + m_groundAnchor1 = def->groundAnchor1 - m_ground->GetXForm().position; + m_groundAnchor2 = def->groundAnchor2 - m_ground->GetXForm().position; + m_localAnchor1 = def->localAnchor1; + m_localAnchor2 = def->localAnchor2; + + b2Assert(def->ratio != 0.0f); + m_ratio = def->ratio; + + m_constant = def->length1 + m_ratio * def->length2; + + m_maxLength1 = b2Min(def->maxLength1, m_constant - m_ratio * b2_minPulleyLength); + m_maxLength2 = b2Min(def->maxLength2, (m_constant - b2_minPulleyLength) / m_ratio); + + m_force = 0.0f; + m_limitForce1 = 0.0f; + m_limitForce2 = 0.0f; +} + +void b2PulleyJoint::InitVelocityConstraints(const b2TimeStep& step) +{ + b2Body* b1 = m_body1; + b2Body* b2 = m_body2; + + b2Vec2 r1 = b2Mul(b1->GetXForm().R, m_localAnchor1 - b1->GetLocalCenter()); + b2Vec2 r2 = b2Mul(b2->GetXForm().R, m_localAnchor2 - b2->GetLocalCenter()); + + b2Vec2 p1 = b1->m_sweep.c + r1; + b2Vec2 p2 = b2->m_sweep.c + r2; + + b2Vec2 s1 = m_ground->GetXForm().position + m_groundAnchor1; + b2Vec2 s2 = m_ground->GetXForm().position + m_groundAnchor2; + + // Get the pulley axes. + m_u1 = p1 - s1; + m_u2 = p2 - s2; + + float32 length1 = m_u1.Length(); + float32 length2 = m_u2.Length(); + + if (length1 > b2_linearSlop) + { + m_u1 *= 1.0f / length1; + } + else + { + m_u1.SetZero(); + } + + if (length2 > b2_linearSlop) + { + m_u2 *= 1.0f / length2; + } + else + { + m_u2.SetZero(); + } + + float32 C = m_constant - length1 - m_ratio * length2; + if (C > 0.0f) + { + m_state = e_inactiveLimit; + m_force = 0.0f; + } + else + { + m_state = e_atUpperLimit; + m_positionImpulse = 0.0f; + } + + if (length1 < m_maxLength1) + { + m_limitState1 = e_inactiveLimit; + m_limitForce1 = 0.0f; + } + else + { + m_limitState1 = e_atUpperLimit; + m_limitPositionImpulse1 = 0.0f; + } + + if (length2 < m_maxLength2) + { + m_limitState2 = e_inactiveLimit; + m_limitForce2 = 0.0f; + } + else + { + m_limitState2 = e_atUpperLimit; + m_limitPositionImpulse2 = 0.0f; + } + + // Compute effective mass. + float32 cr1u1 = b2Cross(r1, m_u1); + float32 cr2u2 = b2Cross(r2, m_u2); + + m_limitMass1 = b1->m_invMass + b1->m_invI * cr1u1 * cr1u1; + m_limitMass2 = b2->m_invMass + b2->m_invI * cr2u2 * cr2u2; + m_pulleyMass = m_limitMass1 + m_ratio * m_ratio * m_limitMass2; + b2Assert(m_limitMass1 > B2_FLT_EPSILON); + b2Assert(m_limitMass2 > B2_FLT_EPSILON); + b2Assert(m_pulleyMass > B2_FLT_EPSILON); + m_limitMass1 = 1.0f / m_limitMass1; + m_limitMass2 = 1.0f / m_limitMass2; + m_pulleyMass = 1.0f / m_pulleyMass; + + if (step.warmStarting) + { + // Warm starting. + b2Vec2 P1 = B2FORCE_SCALE(step.dt) * (-m_force - m_limitForce1) * m_u1; + b2Vec2 P2 = B2FORCE_SCALE(step.dt) * (-m_ratio * m_force - m_limitForce2) * m_u2; + b1->m_linearVelocity += b1->m_invMass * P1; + b1->m_angularVelocity += b1->m_invI * b2Cross(r1, P1); + b2->m_linearVelocity += b2->m_invMass * P2; + b2->m_angularVelocity += b2->m_invI * b2Cross(r2, P2); + } + else + { + m_force = 0.0f; + m_limitForce1 = 0.0f; + m_limitForce2 = 0.0f; + } +} + +void b2PulleyJoint::SolveVelocityConstraints(const b2TimeStep& step) +{ + b2Body* b1 = m_body1; + b2Body* b2 = m_body2; + + b2Vec2 r1 = b2Mul(b1->GetXForm().R, m_localAnchor1 - b1->GetLocalCenter()); + b2Vec2 r2 = b2Mul(b2->GetXForm().R, m_localAnchor2 - b2->GetLocalCenter()); + + if (m_state == e_atUpperLimit) + { + b2Vec2 v1 = b1->m_linearVelocity + b2Cross(b1->m_angularVelocity, r1); + b2Vec2 v2 = b2->m_linearVelocity + b2Cross(b2->m_angularVelocity, r2); + + float32 Cdot = -b2Dot(m_u1, v1) - m_ratio * b2Dot(m_u2, v2); + float32 force = -B2FORCE_INV_SCALE(step.inv_dt) * m_pulleyMass * Cdot; + float32 oldForce = m_force; + m_force = b2Max(0.0f, m_force + force); + force = m_force - oldForce; + + b2Vec2 P1 = -B2FORCE_SCALE(step.dt) * force * m_u1; + b2Vec2 P2 = -B2FORCE_SCALE(step.dt) * m_ratio * force * m_u2; + b1->m_linearVelocity += b1->m_invMass * P1; + b1->m_angularVelocity += b1->m_invI * b2Cross(r1, P1); + b2->m_linearVelocity += b2->m_invMass * P2; + b2->m_angularVelocity += b2->m_invI * b2Cross(r2, P2); + } + + if (m_limitState1 == e_atUpperLimit) + { + b2Vec2 v1 = b1->m_linearVelocity + b2Cross(b1->m_angularVelocity, r1); + + float32 Cdot = -b2Dot(m_u1, v1); + float32 force = -B2FORCE_INV_SCALE(step.inv_dt) * m_limitMass1 * Cdot; + float32 oldForce = m_limitForce1; + m_limitForce1 = b2Max(0.0f, m_limitForce1 + force); + force = m_limitForce1 - oldForce; + + b2Vec2 P1 = -B2FORCE_SCALE(step.dt) * force * m_u1; + b1->m_linearVelocity += b1->m_invMass * P1; + b1->m_angularVelocity += b1->m_invI * b2Cross(r1, P1); + } + + if (m_limitState2 == e_atUpperLimit) + { + b2Vec2 v2 = b2->m_linearVelocity + b2Cross(b2->m_angularVelocity, r2); + + float32 Cdot = -b2Dot(m_u2, v2); + float32 force = -B2FORCE_INV_SCALE(step.inv_dt) * m_limitMass2 * Cdot; + float32 oldForce = m_limitForce2; + m_limitForce2 = b2Max(0.0f, m_limitForce2 + force); + force = m_limitForce2 - oldForce; + + b2Vec2 P2 = -B2FORCE_SCALE(step.dt) * force * m_u2; + b2->m_linearVelocity += b2->m_invMass * P2; + b2->m_angularVelocity += b2->m_invI * b2Cross(r2, P2); + } +} + +bool b2PulleyJoint::SolvePositionConstraints() +{ + b2Body* b1 = m_body1; + b2Body* b2 = m_body2; + + b2Vec2 s1 = m_ground->GetXForm().position + m_groundAnchor1; + b2Vec2 s2 = m_ground->GetXForm().position + m_groundAnchor2; + + float32 linearError = 0.0f; + + if (m_state == e_atUpperLimit) + { + b2Vec2 r1 = b2Mul(b1->GetXForm().R, m_localAnchor1 - b1->GetLocalCenter()); + b2Vec2 r2 = b2Mul(b2->GetXForm().R, m_localAnchor2 - b2->GetLocalCenter()); + + b2Vec2 p1 = b1->m_sweep.c + r1; + b2Vec2 p2 = b2->m_sweep.c + r2; + + // Get the pulley axes. + m_u1 = p1 - s1; + m_u2 = p2 - s2; + + float32 length1 = m_u1.Length(); + float32 length2 = m_u2.Length(); + + if (length1 > b2_linearSlop) + { + m_u1 *= 1.0f / length1; + } + else + { + m_u1.SetZero(); + } + + if (length2 > b2_linearSlop) + { + m_u2 *= 1.0f / length2; + } + else + { + m_u2.SetZero(); + } + + float32 C = m_constant - length1 - m_ratio * length2; + linearError = b2Max(linearError, -C); + + C = b2Clamp(C + b2_linearSlop, -b2_maxLinearCorrection, 0.0f); + float32 impulse = -m_pulleyMass * C; + float32 oldImpulse = m_positionImpulse; + m_positionImpulse = b2Max(0.0f, m_positionImpulse + impulse); + impulse = m_positionImpulse - oldImpulse; + + b2Vec2 P1 = -impulse * m_u1; + b2Vec2 P2 = -m_ratio * impulse * m_u2; + + b1->m_sweep.c += b1->m_invMass * P1; + b1->m_sweep.a += b1->m_invI * b2Cross(r1, P1); + b2->m_sweep.c += b2->m_invMass * P2; + b2->m_sweep.a += b2->m_invI * b2Cross(r2, P2); + + b1->SynchronizeTransform(); + b2->SynchronizeTransform(); + } + + if (m_limitState1 == e_atUpperLimit) + { + b2Vec2 r1 = b2Mul(b1->GetXForm().R, m_localAnchor1 - b1->GetLocalCenter()); + b2Vec2 p1 = b1->m_sweep.c + r1; + + m_u1 = p1 - s1; + float32 length1 = m_u1.Length(); + + if (length1 > b2_linearSlop) + { + m_u1 *= 1.0f / length1; + } + else + { + m_u1.SetZero(); + } + + float32 C = m_maxLength1 - length1; + linearError = b2Max(linearError, -C); + C = b2Clamp(C + b2_linearSlop, -b2_maxLinearCorrection, 0.0f); + float32 impulse = -m_limitMass1 * C; + float32 oldLimitPositionImpulse = m_limitPositionImpulse1; + m_limitPositionImpulse1 = b2Max(0.0f, m_limitPositionImpulse1 + impulse); + impulse = m_limitPositionImpulse1 - oldLimitPositionImpulse; + + b2Vec2 P1 = -impulse * m_u1; + b1->m_sweep.c += b1->m_invMass * P1; + b1->m_sweep.a += b1->m_invI * b2Cross(r1, P1); + + b1->SynchronizeTransform(); + } + + if (m_limitState2 == e_atUpperLimit) + { + b2Vec2 r2 = b2Mul(b2->GetXForm().R, m_localAnchor2 - b2->GetLocalCenter()); + b2Vec2 p2 = b2->m_sweep.c + r2; + + m_u2 = p2 - s2; + float32 length2 = m_u2.Length(); + + if (length2 > b2_linearSlop) + { + m_u2 *= 1.0f / length2; + } + else + { + m_u2.SetZero(); + } + + float32 C = m_maxLength2 - length2; + linearError = b2Max(linearError, -C); + C = b2Clamp(C + b2_linearSlop, -b2_maxLinearCorrection, 0.0f); + float32 impulse = -m_limitMass2 * C; + float32 oldLimitPositionImpulse = m_limitPositionImpulse2; + m_limitPositionImpulse2 = b2Max(0.0f, m_limitPositionImpulse2 + impulse); + impulse = m_limitPositionImpulse2 - oldLimitPositionImpulse; + + b2Vec2 P2 = -impulse * m_u2; + b2->m_sweep.c += b2->m_invMass * P2; + b2->m_sweep.a += b2->m_invI * b2Cross(r2, P2); + + b2->SynchronizeTransform(); + } + + return linearError < b2_linearSlop; +} + +b2Vec2 b2PulleyJoint::GetAnchor1() const +{ + return m_body1->GetWorldPoint(m_localAnchor1); +} + +b2Vec2 b2PulleyJoint::GetAnchor2() const +{ + return m_body2->GetWorldPoint(m_localAnchor2); +} + +b2Vec2 b2PulleyJoint::GetReactionForce() const +{ + b2Vec2 F = B2FORCE_SCALE(m_force) * m_u2; + return F; +} + +float32 b2PulleyJoint::GetReactionTorque() const +{ + return 0.0f; +} + +b2Vec2 b2PulleyJoint::GetGroundAnchor1() const +{ + return m_ground->GetXForm().position + m_groundAnchor1; +} + +b2Vec2 b2PulleyJoint::GetGroundAnchor2() const +{ + return m_ground->GetXForm().position + m_groundAnchor2; +} + +float32 b2PulleyJoint::GetLength1() const +{ + b2Vec2 p = m_body1->GetWorldPoint(m_localAnchor1); + b2Vec2 s = m_ground->GetXForm().position + m_groundAnchor1; + b2Vec2 d = p - s; + return d.Length(); +} + +float32 b2PulleyJoint::GetLength2() const +{ + b2Vec2 p = m_body2->GetWorldPoint(m_localAnchor2); + b2Vec2 s = m_ground->GetXForm().position + m_groundAnchor2; + b2Vec2 d = p - s; + return d.Length(); +} + +float32 b2PulleyJoint::GetRatio() const +{ + return m_ratio; +} diff --git a/Box2D/Source/Dynamics/Joints/b2PulleyJoint.h b/Box2D/Source/Dynamics/Joints/b2PulleyJoint.h new file mode 100644 index 0000000..293f405 --- /dev/null +++ b/Box2D/Source/Dynamics/Joints/b2PulleyJoint.h @@ -0,0 +1,153 @@ +/* +* Copyright (c) 2006-2007 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_PULLEY_JOINT_H +#define B2_PULLEY_JOINT_H + +#include "b2Joint.h" + +const float32 b2_minPulleyLength = 2.0f; + +/// Pulley joint definition. This requires two ground anchors, +/// two dynamic body anchor points, max lengths for each side, +/// and a pulley ratio. +struct b2PulleyJointDef : public b2JointDef +{ + b2PulleyJointDef() + { + type = e_pulleyJoint; + groundAnchor1.Set(-1.0f, 1.0f); + groundAnchor2.Set(1.0f, 1.0f); + localAnchor1.Set(-1.0f, 0.0f); + localAnchor2.Set(1.0f, 0.0f); + length1 = 0.0f; + maxLength1 = 0.0f; + length2 = 0.0f; + maxLength2 = 0.0f; + ratio = 1.0f; + collideConnected = true; + } + + /// Initialize the bodies, anchors, lengths, max lengths, and ratio using the world anchors. + void Initialize(b2Body* body1, b2Body* body2, + const b2Vec2& groundAnchor1, const b2Vec2& groundAnchor2, + const b2Vec2& anchor1, const b2Vec2& anchor2, + float32 ratio); + + /// The first ground anchor in world coordinates. This point never moves. + b2Vec2 groundAnchor1; + + /// The second ground anchor in world coordinates. This point never moves. + b2Vec2 groundAnchor2; + + /// The local anchor point relative to body1's origin. + b2Vec2 localAnchor1; + + /// The local anchor point relative to body2's origin. + b2Vec2 localAnchor2; + + /// The a reference length for the segment attached to body1. + float32 length1; + + /// The maximum length of the segment attached to body1. + float32 maxLength1; + + /// The a reference length for the segment attached to body2. + float32 length2; + + /// The maximum length of the segment attached to body2. + float32 maxLength2; + + /// The pulley ratio, used to simulate a block-and-tackle. + float32 ratio; +}; + +/// The pulley joint is connected to two bodies and two fixed ground points. +/// The pulley supports a ratio such that: +/// length1 + ratio * length2 <= constant +/// Yes, the force transmitted is scaled by the ratio. +/// The pulley also enforces a maximum length limit on both sides. This is +/// useful to prevent one side of the pulley hitting the top. +class b2PulleyJoint : public b2Joint +{ +public: + b2Vec2 GetAnchor1() const; + b2Vec2 GetAnchor2() const; + + b2Vec2 GetReactionForce() const; + float32 GetReactionTorque() const; + + /// Get the first ground anchor. + b2Vec2 GetGroundAnchor1() const; + + /// Get the second ground anchor. + b2Vec2 GetGroundAnchor2() const; + + /// Get the current length of the segment attached to body1. + float32 GetLength1() const; + + /// Get the current length of the segment attached to body2. + float32 GetLength2() const; + + /// Get the pulley ratio. + float32 GetRatio() const; + + //--------------- Internals Below ------------------- + + b2PulleyJoint(const b2PulleyJointDef* data); + + void InitVelocityConstraints(const b2TimeStep& step); + void SolveVelocityConstraints(const b2TimeStep& step); + bool SolvePositionConstraints(); + + b2Body* m_ground; + b2Vec2 m_groundAnchor1; + b2Vec2 m_groundAnchor2; + b2Vec2 m_localAnchor1; + b2Vec2 m_localAnchor2; + + b2Vec2 m_u1; + b2Vec2 m_u2; + + float32 m_constant; + float32 m_ratio; + + float32 m_maxLength1; + float32 m_maxLength2; + + // Effective masses + float32 m_pulleyMass; + float32 m_limitMass1; + float32 m_limitMass2; + + // Impulses for accumulation/warm starting. + float32 m_force; + float32 m_limitForce1; + float32 m_limitForce2; + + // Position impulses for accumulation. + float32 m_positionImpulse; + float32 m_limitPositionImpulse1; + float32 m_limitPositionImpulse2; + + b2LimitState m_state; + b2LimitState m_limitState1; + b2LimitState m_limitState2; +}; + +#endif diff --git a/Box2D/Source/Dynamics/Joints/b2RevoluteJoint.cpp b/Box2D/Source/Dynamics/Joints/b2RevoluteJoint.cpp new file mode 100644 index 0000000..4fcc17a --- /dev/null +++ b/Box2D/Source/Dynamics/Joints/b2RevoluteJoint.cpp @@ -0,0 +1,399 @@ +/* +* Copyright (c) 2006-2007 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. +*/ + +#include "b2RevoluteJoint.h" +#include "../b2Body.h" +#include "../b2World.h" + +#include "../b2Island.h" + +// Point-to-point constraint +// C = p2 - p1 +// Cdot = v2 - v1 +// = v2 + cross(w2, r2) - v1 - cross(w1, r1) +// J = [-I -r1_skew I r2_skew ] +// Identity used: +// w k % (rx i + ry j) = w * (-ry i + rx j) + +// Motor constraint +// Cdot = w2 - w1 +// J = [0 0 -1 0 0 1] +// K = invI1 + invI2 + +void b2RevoluteJointDef::Initialize(b2Body* b1, b2Body* b2, const b2Vec2& anchor) +{ + body1 = b1; + body2 = b2; + localAnchor1 = body1->GetLocalPoint(anchor); + localAnchor2 = body2->GetLocalPoint(anchor); + referenceAngle = body2->GetAngle() - body1->GetAngle(); +} + +b2RevoluteJoint::b2RevoluteJoint(const b2RevoluteJointDef* def) +: b2Joint(def) +{ + m_localAnchor1 = def->localAnchor1; + m_localAnchor2 = def->localAnchor2; + m_referenceAngle = def->referenceAngle; + + m_pivotForce.Set(0.0f, 0.0f); + m_motorForce = 0.0f; + m_limitForce = 0.0f; + m_limitPositionImpulse = 0.0f; + + m_lowerAngle = def->lowerAngle; + m_upperAngle = def->upperAngle; + m_maxMotorTorque = def->maxMotorTorque; + m_motorSpeed = def->motorSpeed; + m_enableLimit = def->enableLimit; + m_enableMotor = def->enableMotor; +} + +void b2RevoluteJoint::InitVelocityConstraints(const b2TimeStep& step) +{ + b2Body* b1 = m_body1; + b2Body* b2 = m_body2; + + // Compute the effective mass matrix. + b2Vec2 r1 = b2Mul(b1->GetXForm().R, m_localAnchor1 - b1->GetLocalCenter()); + b2Vec2 r2 = b2Mul(b2->GetXForm().R, m_localAnchor2 - b2->GetLocalCenter()); + + // K = [(1/m1 + 1/m2) * eye(2) - skew(r1) * invI1 * skew(r1) - skew(r2) * invI2 * skew(r2)] + // = [1/m1+1/m2 0 ] + invI1 * [r1.y*r1.y -r1.x*r1.y] + invI2 * [r1.y*r1.y -r1.x*r1.y] + // [ 0 1/m1+1/m2] [-r1.x*r1.y r1.x*r1.x] [-r1.x*r1.y r1.x*r1.x] + float32 invMass1 = b1->m_invMass, invMass2 = b2->m_invMass; + float32 invI1 = b1->m_invI, invI2 = b2->m_invI; + + b2Mat22 K1; + K1.col1.x = invMass1 + invMass2; K1.col2.x = 0.0f; + K1.col1.y = 0.0f; K1.col2.y = invMass1 + invMass2; + + b2Mat22 K2; + K2.col1.x = invI1 * r1.y * r1.y; K2.col2.x = -invI1 * r1.x * r1.y; + K2.col1.y = -invI1 * r1.x * r1.y; K2.col2.y = invI1 * r1.x * r1.x; + + b2Mat22 K3; + K3.col1.x = invI2 * r2.y * r2.y; K3.col2.x = -invI2 * r2.x * r2.y; + K3.col1.y = -invI2 * r2.x * r2.y; K3.col2.y = invI2 * r2.x * r2.x; + + b2Mat22 K = K1 + K2 + K3; + m_pivotMass = K.Invert(); + + m_motorMass = 1.0f / (invI1 + invI2); + + if (m_enableMotor == false) + { + m_motorForce = 0.0f; + } + + if (m_enableLimit) + { + float32 jointAngle = b2->m_sweep.a - b1->m_sweep.a - m_referenceAngle; + if (b2Abs(m_upperAngle - m_lowerAngle) < 2.0f * b2_angularSlop) + { + m_limitState = e_equalLimits; + } + else if (jointAngle <= m_lowerAngle) + { + if (m_limitState != e_atLowerLimit) + { + m_limitForce = 0.0f; + } + m_limitState = e_atLowerLimit; + } + else if (jointAngle >= m_upperAngle) + { + if (m_limitState != e_atUpperLimit) + { + m_limitForce = 0.0f; + } + m_limitState = e_atUpperLimit; + } + else + { + m_limitState = e_inactiveLimit; + m_limitForce = 0.0f; + } + } + else + { + m_limitForce = 0.0f; + } + + if (step.warmStarting) + { + b1->m_linearVelocity -= B2FORCE_SCALE(step.dt) * invMass1 * m_pivotForce; + b1->m_angularVelocity -= B2FORCE_SCALE(step.dt) * invI1 * (b2Cross(r1, m_pivotForce) + B2FORCE_INV_SCALE(m_motorForce + m_limitForce)); + + b2->m_linearVelocity += B2FORCE_SCALE(step.dt) * invMass2 * m_pivotForce; + b2->m_angularVelocity += B2FORCE_SCALE(step.dt) * invI2 * (b2Cross(r2, m_pivotForce) + B2FORCE_INV_SCALE(m_motorForce + m_limitForce)); + } + else + { + m_pivotForce.SetZero(); + m_motorForce = 0.0f; + m_limitForce = 0.0f; + } + + m_limitPositionImpulse = 0.0f; +} + +void b2RevoluteJoint::SolveVelocityConstraints(const b2TimeStep& step) +{ + b2Body* b1 = m_body1; + b2Body* b2 = m_body2; + + b2Vec2 r1 = b2Mul(b1->GetXForm().R, m_localAnchor1 - b1->GetLocalCenter()); + b2Vec2 r2 = b2Mul(b2->GetXForm().R, m_localAnchor2 - b2->GetLocalCenter()); + + // Solve point-to-point constraint + b2Vec2 pivotCdot = b2->m_linearVelocity + b2Cross(b2->m_angularVelocity, r2) - b1->m_linearVelocity - b2Cross(b1->m_angularVelocity, r1); + b2Vec2 pivotForce = -B2FORCE_INV_SCALE(step.inv_dt) * b2Mul(m_pivotMass, pivotCdot); + m_pivotForce += pivotForce; + + b2Vec2 P = B2FORCE_SCALE(step.dt) * pivotForce; + b1->m_linearVelocity -= b1->m_invMass * P; + b1->m_angularVelocity -= b1->m_invI * b2Cross(r1, P); + + b2->m_linearVelocity += b2->m_invMass * P; + b2->m_angularVelocity += b2->m_invI * b2Cross(r2, P); + + if (m_enableMotor && m_limitState != e_equalLimits) + { + float32 motorCdot = b2->m_angularVelocity - b1->m_angularVelocity - m_motorSpeed; + float32 motorForce = -step.inv_dt * m_motorMass * motorCdot; + float32 oldMotorForce = m_motorForce; + m_motorForce = b2Clamp(m_motorForce + motorForce, -m_maxMotorTorque, m_maxMotorTorque); + motorForce = m_motorForce - oldMotorForce; + + float32 P = step.dt * motorForce; + b1->m_angularVelocity -= b1->m_invI * P; + b2->m_angularVelocity += b2->m_invI * P; + } + + if (m_enableLimit && m_limitState != e_inactiveLimit) + { + float32 limitCdot = b2->m_angularVelocity - b1->m_angularVelocity; + float32 limitForce = -step.inv_dt * m_motorMass * limitCdot; + + if (m_limitState == e_equalLimits) + { + m_limitForce += limitForce; + } + else if (m_limitState == e_atLowerLimit) + { + float32 oldLimitForce = m_limitForce; + m_limitForce = b2Max(m_limitForce + limitForce, 0.0f); + limitForce = m_limitForce - oldLimitForce; + } + else if (m_limitState == e_atUpperLimit) + { + float32 oldLimitForce = m_limitForce; + m_limitForce = b2Min(m_limitForce + limitForce, 0.0f); + limitForce = m_limitForce - oldLimitForce; + } + + float32 P = step.dt * limitForce; + b1->m_angularVelocity -= b1->m_invI * P; + b2->m_angularVelocity += b2->m_invI * P; + } +} + +bool b2RevoluteJoint::SolvePositionConstraints() +{ + b2Body* b1 = m_body1; + b2Body* b2 = m_body2; + + float32 positionError = 0.0f; + + // Solve point-to-point position error. + b2Vec2 r1 = b2Mul(b1->GetXForm().R, m_localAnchor1 - b1->GetLocalCenter()); + b2Vec2 r2 = b2Mul(b2->GetXForm().R, m_localAnchor2 - b2->GetLocalCenter()); + + b2Vec2 p1 = b1->m_sweep.c + r1; + b2Vec2 p2 = b2->m_sweep.c + r2; + b2Vec2 ptpC = p2 - p1; + + positionError = ptpC.Length(); + + // Prevent overly large corrections. + //b2Vec2 dpMax(b2_maxLinearCorrection, b2_maxLinearCorrection); + //ptpC = b2Clamp(ptpC, -dpMax, dpMax); + + float32 invMass1 = b1->m_invMass, invMass2 = b2->m_invMass; + float32 invI1 = b1->m_invI, invI2 = b2->m_invI; + + b2Mat22 K1; + K1.col1.x = invMass1 + invMass2; K1.col2.x = 0.0f; + K1.col1.y = 0.0f; K1.col2.y = invMass1 + invMass2; + + b2Mat22 K2; + K2.col1.x = invI1 * r1.y * r1.y; K2.col2.x = -invI1 * r1.x * r1.y; + K2.col1.y = -invI1 * r1.x * r1.y; K2.col2.y = invI1 * r1.x * r1.x; + + b2Mat22 K3; + K3.col1.x = invI2 * r2.y * r2.y; K3.col2.x = -invI2 * r2.x * r2.y; + K3.col1.y = -invI2 * r2.x * r2.y; K3.col2.y = invI2 * r2.x * r2.x; + + b2Mat22 K = K1 + K2 + K3; + b2Vec2 impulse = K.Solve(-ptpC); + + b1->m_sweep.c -= b1->m_invMass * impulse; + b1->m_sweep.a -= b1->m_invI * b2Cross(r1, impulse); + + b2->m_sweep.c += b2->m_invMass * impulse; + b2->m_sweep.a += b2->m_invI * b2Cross(r2, impulse); + + b1->SynchronizeTransform(); + b2->SynchronizeTransform(); + + // Handle limits. + float32 angularError = 0.0f; + + if (m_enableLimit && m_limitState != e_inactiveLimit) + { + float32 angle = b2->m_sweep.a - b1->m_sweep.a - m_referenceAngle; + float32 limitImpulse = 0.0f; + + if (m_limitState == e_equalLimits) + { + // Prevent large angular corrections + float32 limitC = b2Clamp(angle, -b2_maxAngularCorrection, b2_maxAngularCorrection); + limitImpulse = -m_motorMass * limitC; + angularError = b2Abs(limitC); + } + else if (m_limitState == e_atLowerLimit) + { + float32 limitC = angle - m_lowerAngle; + angularError = b2Max(0.0f, -limitC); + + // Prevent large angular corrections and allow some slop. + limitC = b2Clamp(limitC + b2_angularSlop, -b2_maxAngularCorrection, 0.0f); + limitImpulse = -m_motorMass * limitC; + float32 oldLimitImpulse = m_limitPositionImpulse; + m_limitPositionImpulse = b2Max(m_limitPositionImpulse + limitImpulse, 0.0f); + limitImpulse = m_limitPositionImpulse - oldLimitImpulse; + } + else if (m_limitState == e_atUpperLimit) + { + float32 limitC = angle - m_upperAngle; + angularError = b2Max(0.0f, limitC); + + // Prevent large angular corrections and allow some slop. + limitC = b2Clamp(limitC - b2_angularSlop, 0.0f, b2_maxAngularCorrection); + limitImpulse = -m_motorMass * limitC; + float32 oldLimitImpulse = m_limitPositionImpulse; + m_limitPositionImpulse = b2Min(m_limitPositionImpulse + limitImpulse, 0.0f); + limitImpulse = m_limitPositionImpulse - oldLimitImpulse; + } + + b1->m_sweep.a -= b1->m_invI * limitImpulse; + b2->m_sweep.a += b2->m_invI * limitImpulse; + + b1->SynchronizeTransform(); + b2->SynchronizeTransform(); + } + + return positionError <= b2_linearSlop && angularError <= b2_angularSlop; +} + +b2Vec2 b2RevoluteJoint::GetAnchor1() const +{ + return m_body1->GetWorldPoint(m_localAnchor1); +} + +b2Vec2 b2RevoluteJoint::GetAnchor2() const +{ + return m_body2->GetWorldPoint(m_localAnchor2); +} + +b2Vec2 b2RevoluteJoint::GetReactionForce() const +{ + return B2FORCE_SCALE(float32(1.0))*m_pivotForce; +} + +float32 b2RevoluteJoint::GetReactionTorque() const +{ + return m_limitForce; +} + +float32 b2RevoluteJoint::GetJointAngle() const +{ + b2Body* b1 = m_body1; + b2Body* b2 = m_body2; + return b2->m_sweep.a - b1->m_sweep.a - m_referenceAngle; +} + +float32 b2RevoluteJoint::GetJointSpeed() const +{ + b2Body* b1 = m_body1; + b2Body* b2 = m_body2; + return b2->m_angularVelocity - b1->m_angularVelocity; +} + +bool b2RevoluteJoint::IsMotorEnabled() const +{ + return m_enableMotor; +} + +void b2RevoluteJoint::EnableMotor(bool flag) +{ + m_enableMotor = flag; +} + +float32 b2RevoluteJoint::GetMotorTorque() const +{ + return m_motorForce; +} + +void b2RevoluteJoint::SetMotorSpeed(float32 speed) +{ + m_motorSpeed = speed; +} + +void b2RevoluteJoint::SetMaxMotorTorque(float32 torque) +{ + m_maxMotorTorque = torque; +} + +bool b2RevoluteJoint::IsLimitEnabled() const +{ + return m_enableLimit; +} + +void b2RevoluteJoint::EnableLimit(bool flag) +{ + m_enableLimit = flag; +} + +float32 b2RevoluteJoint::GetLowerLimit() const +{ + return m_lowerAngle; +} + +float32 b2RevoluteJoint::GetUpperLimit() const +{ + return m_upperAngle; +} + +void b2RevoluteJoint::SetLimits(float32 lower, float32 upper) +{ + b2Assert(lower <= upper); + m_lowerAngle = lower; + m_upperAngle = upper; +} diff --git a/Box2D/Source/Dynamics/Joints/b2RevoluteJoint.h b/Box2D/Source/Dynamics/Joints/b2RevoluteJoint.h new file mode 100644 index 0000000..ebef20d --- /dev/null +++ b/Box2D/Source/Dynamics/Joints/b2RevoluteJoint.h @@ -0,0 +1,172 @@ +/* +* Copyright (c) 2006-2007 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_REVOLUTE_JOINT_H +#define B2_REVOLUTE_JOINT_H + +#include "b2Joint.h" + +/// Revolute joint definition. This requires defining an +/// anchor point where the bodies are joined. The definition +/// uses local anchor points so that the initial configuration +/// can violate the constraint slightly. You also need to +/// specify the initial relative angle for joint limits. This +/// helps when saving and loading a game. +/// The local anchor points are measured from the body's origin +/// rather than the center of mass because: +/// 1. you might not know where the center of mass will be. +/// 2. if you add/remove shapes from a body and recompute the mass, +/// the joints will be broken. +struct b2RevoluteJointDef : public b2JointDef +{ + b2RevoluteJointDef() + { + type = e_revoluteJoint; + localAnchor1.Set(0.0f, 0.0f); + localAnchor2.Set(0.0f, 0.0f); + referenceAngle = 0.0f; + lowerAngle = 0.0f; + upperAngle = 0.0f; + maxMotorTorque = 0.0f; + motorSpeed = 0.0f; + enableLimit = false; + enableMotor = false; + } + + /// Initialize the bodies, anchors, and reference angle using the world + /// anchor. + void Initialize(b2Body* body1, b2Body* body2, const b2Vec2& anchor); + + /// The local anchor point relative to body1's origin. + b2Vec2 localAnchor1; + + /// The local anchor point relative to body2's origin. + b2Vec2 localAnchor2; + + /// The body2 angle minus body1 angle in the reference state (radians). + float32 referenceAngle; + + /// A flag to enable joint limits. + bool enableLimit; + + /// The lower angle for the joint limit (radians). + float32 lowerAngle; + + /// The upper angle for the joint limit (radians). + float32 upperAngle; + + /// A flag to enable the joint motor. + bool enableMotor; + + /// The desired motor speed. Usually in radians per second. + float32 motorSpeed; + + /// The maximum motor torque used to achieve the desired motor speed. + /// Usually in N-m. + float32 maxMotorTorque; +}; + +/// A revolute joint constrains to bodies to share a common point while they +/// are free to rotate about the point. The relative rotation about the shared +/// point is the joint angle. You can limit the relative rotation with +/// a joint limit that specifies a lower and upper angle. You can use a motor +/// to drive the relative rotation about the shared point. A maximum motor torque +/// is provided so that infinite forces are not generated. +class b2RevoluteJoint : public b2Joint +{ +public: + b2Vec2 GetAnchor1() const; + b2Vec2 GetAnchor2() const; + + b2Vec2 GetReactionForce() const; + float32 GetReactionTorque() const; + + /// Get the current joint angle in radians. + float32 GetJointAngle() const; + + /// Get the current joint angle speed in radians per second. + float32 GetJointSpeed() const; + + /// Is the joint limit enabled? + bool IsLimitEnabled() const; + + /// Enable/disable the joint limit. + void EnableLimit(bool flag); + + /// Get the lower joint limit in radians. + float32 GetLowerLimit() const; + + /// Get the upper joint limit in radians. + float32 GetUpperLimit() const; + + /// Set the joint limits in radians. + void SetLimits(float32 lower, float32 upper); + + /// Is the joint motor enabled? + bool IsMotorEnabled() const; + + /// Enable/disable the joint motor. + void EnableMotor(bool flag); + + /// Set the motor speed in radians per second. + void SetMotorSpeed(float32 speed); + + /// Get the motor speed in radians per second. + float32 GetMotorSpeed() const; + + /// Set the maximum motor torque, usually in N-m. + void SetMaxMotorTorque(float32 torque); + + /// Get the current motor torque, usually in N-m. + float32 GetMotorTorque() const; + + //--------------- Internals Below ------------------- + b2RevoluteJoint(const b2RevoluteJointDef* def); + + void InitVelocityConstraints(const b2TimeStep& step); + void SolveVelocityConstraints(const b2TimeStep& step); + + bool SolvePositionConstraints(); + + b2Vec2 m_localAnchor1; // relative + b2Vec2 m_localAnchor2; + b2Vec2 m_pivotForce; + float32 m_motorForce; + float32 m_limitForce; + float32 m_limitPositionImpulse; + + b2Mat22 m_pivotMass; // effective mass for point-to-point constraint. + float32 m_motorMass; // effective mass for motor/limit angular constraint. + + bool m_enableMotor; + float32 m_maxMotorTorque; + float32 m_motorSpeed; + + bool m_enableLimit; + float32 m_referenceAngle; + float32 m_lowerAngle; + float32 m_upperAngle; + b2LimitState m_limitState; +}; + +inline float32 b2RevoluteJoint::GetMotorSpeed() const +{ + return m_motorSpeed; +} + +#endif diff --git a/Box2D/Source/Dynamics/b2Body.cpp b/Box2D/Source/Dynamics/b2Body.cpp new file mode 100644 index 0000000..fc6fa05 --- /dev/null +++ b/Box2D/Source/Dynamics/b2Body.cpp @@ -0,0 +1,394 @@ +/* +* Copyright (c) 2006-2007 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. +*/ + +#include "b2Body.h" +#include "b2World.h" +#include "Joints/b2Joint.h" +#include "../Collision/Shapes/b2Shape.h" + +b2Body::b2Body(const b2BodyDef* bd, b2World* world) +{ + b2Assert(world->m_lock == false); + + m_flags = 0; + + if (bd->isBullet) + { + m_flags |= e_bulletFlag; + } + if (bd->fixedRotation) + { + m_flags |= e_fixedRotationFlag; + } + if (bd->allowSleep) + { + m_flags |= e_allowSleepFlag; + } + if (bd->isSleeping) + { + m_flags |= e_sleepFlag; + } + + m_world = world; + + m_xf.position = bd->position; + m_xf.R.Set(bd->angle); + + m_sweep.localCenter = bd->massData.center; + m_sweep.t0 = 1.0f; + m_sweep.a0 = m_sweep.a = bd->angle; + m_sweep.c0 = m_sweep.c = b2Mul(m_xf, m_sweep.localCenter); + + m_jointList = NULL; + m_contactList = NULL; + m_prev = NULL; + m_next = NULL; + + m_linearDamping = bd->linearDamping; + m_angularDamping = bd->angularDamping; + + m_force.Set(0.0f, 0.0f); + m_torque = 0.0f; + + m_linearVelocity.SetZero(); + m_angularVelocity = 0.0f; + + m_sleepTime = 0.0f; + + m_invMass = 0.0f; + m_I = 0.0f; + m_invI = 0.0f; + + m_mass = bd->massData.mass; + + if (m_mass > 0.0f) + { + m_invMass = 1.0f / m_mass; + } + + if ((m_flags & b2Body::e_fixedRotationFlag) == 0) + { + m_I = bd->massData.I; + } + + if (m_I > 0.0f) + { + m_invI = 1.0f / m_I; + } + + if (m_invMass == 0.0f && m_invI == 0.0f) + { + m_type = e_staticType; + } + else + { + m_type = e_dynamicType; + } + + m_userData = bd->userData; + + m_shapeList = NULL; + m_shapeCount = 0; +} + +b2Body::~b2Body() +{ + b2Assert(m_world->m_lock == false); + // shapes and joints are destroyed in b2World::Destroy +} + +b2Shape* b2Body::CreateShape(b2ShapeDef* def) +{ + b2Assert(m_world->m_lock == false); + if (m_world->m_lock == true) + { + return NULL; + } + + b2Shape* s = b2Shape::Create(def, &m_world->m_blockAllocator); + + s->m_next = m_shapeList; + m_shapeList = s; + ++m_shapeCount; + + s->m_body = this; + + // Add the shape to the world's broad-phase. + s->CreateProxy(m_world->m_broadPhase, m_xf); + + // Compute the sweep radius for CCD. + s->UpdateSweepRadius(m_sweep.localCenter); + + return s; +} + +void b2Body::DestroyShape(b2Shape* s) +{ + b2Assert(m_world->m_lock == false); + if (m_world->m_lock == true) + { + return; + } + + b2Assert(s->GetBody() == this); + s->DestroyProxy(m_world->m_broadPhase); + + b2Assert(m_shapeCount > 0); + b2Shape** node = &m_shapeList; + bool found = false; + while (*node != NULL) + { + if (*node == s) + { + *node = s->m_next; + found = true; + break; + } + + node = &(*node)->m_next; + } + + // You tried to remove a shape that is not attached to this body. + b2Assert(found); + + s->m_body = NULL; + s->m_next = NULL; + + --m_shapeCount; + + b2Shape::Destroy(s, &m_world->m_blockAllocator); +} + +// TODO_ERIN adjust linear velocity and torque to account for movement of center. +void b2Body::SetMass(const b2MassData* massData) +{ + b2Assert(m_world->m_lock == false); + if (m_world->m_lock == true) + { + return; + } + + m_invMass = 0.0f; + m_I = 0.0f; + m_invI = 0.0f; + + m_mass = massData->mass; + + if (m_mass > 0.0f) + { + m_invMass = 1.0f / m_mass; + } + + if ((m_flags & b2Body::e_fixedRotationFlag) == 0) + { + m_I = massData->I; + } + + if (m_I > 0.0f) + { + m_invI = 1.0f / m_I; + } + + // Move center of mass. + m_sweep.localCenter = massData->center; + m_sweep.c0 = m_sweep.c = b2Mul(m_xf, m_sweep.localCenter); + + // Update the sweep radii of all child shapes. + for (b2Shape* s = m_shapeList; s; s = s->m_next) + { + s->UpdateSweepRadius(m_sweep.localCenter); + } + + int16 oldType = m_type; + if (m_invMass == 0.0f && m_invI == 0.0f) + { + m_type = e_staticType; + } + else + { + m_type = e_dynamicType; + } + + // If the body type changed, we need to refilter the broad-phase proxies. + if (oldType != m_type) + { + for (b2Shape* s = m_shapeList; s; s = s->m_next) + { + s->RefilterProxy(m_world->m_broadPhase, m_xf); + } + } +} + +// TODO_ERIN adjust linear velocity and torque to account for movement of center. +void b2Body::SetMassFromShapes() +{ + b2Assert(m_world->m_lock == false); + if (m_world->m_lock == true) + { + return; + } + + // Compute mass data from shapes. Each shape has its own density. + m_mass = 0.0f; + m_invMass = 0.0f; + m_I = 0.0f; + m_invI = 0.0f; + + b2Vec2 center = b2Vec2_zero; + for (b2Shape* s = m_shapeList; s; s = s->m_next) + { + b2MassData massData; + s->ComputeMass(&massData); + m_mass += massData.mass; + center += massData.mass * massData.center; + m_I += massData.I; + } + + // Compute center of mass, and shift the origin to the COM. + if (m_mass > 0.0f) + { + m_invMass = 1.0f / m_mass; + center *= m_invMass; + } + + if (m_I > 0.0f && (m_flags & e_fixedRotationFlag) == 0) + { + // Center the inertia about the center of mass. + m_I -= m_mass * b2Dot(center, center); + b2Assert(m_I > 0.0f); + m_invI = 1.0f / m_I; + } + else + { + m_I = 0.0f; + m_invI = 0.0f; + } + + // Move center of mass. + m_sweep.localCenter = center; + m_sweep.c0 = m_sweep.c = b2Mul(m_xf, m_sweep.localCenter); + + // Update the sweep radii of all child shapes. + for (b2Shape* s = m_shapeList; s; s = s->m_next) + { + s->UpdateSweepRadius(m_sweep.localCenter); + } + + int16 oldType = m_type; + if (m_invMass == 0.0f && m_invI == 0.0f) + { + m_type = e_staticType; + } + else + { + m_type = e_dynamicType; + } + + // If the body type changed, we need to refilter the broad-phase proxies. + if (oldType != m_type) + { + for (b2Shape* s = m_shapeList; s; s = s->m_next) + { + s->RefilterProxy(m_world->m_broadPhase, m_xf); + } + } +} + +bool b2Body::SetXForm(const b2Vec2& position, float32 angle) +{ + b2Assert(m_world->m_lock == false); + if (m_world->m_lock == true) + { + return true; + } + + if (IsFrozen()) + { + return false; + } + + m_xf.R.Set(angle); + m_xf.position = position; + + m_sweep.c0 = m_sweep.c = b2Mul(m_xf, m_sweep.localCenter); + m_sweep.a0 = m_sweep.a = angle; + + bool freeze = false; + for (b2Shape* s = m_shapeList; s; s = s->m_next) + { + bool inRange = s->Synchronize(m_world->m_broadPhase, m_xf, m_xf); + + if (inRange == false) + { + freeze = true; + break; + } + } + + if (freeze == true) + { + m_flags |= e_frozenFlag; + m_linearVelocity.SetZero(); + m_angularVelocity = 0.0f; + for (b2Shape* s = m_shapeList; s; s = s->m_next) + { + s->DestroyProxy(m_world->m_broadPhase); + } + + // Failure + return false; + } + + // Success + m_world->m_broadPhase->Commit(); + return true; +} + +bool b2Body::SynchronizeShapes() +{ + b2XForm xf1; + xf1.R.Set(m_sweep.a0); + xf1.position = m_sweep.c0 - b2Mul(xf1.R, m_sweep.localCenter); + + bool inRange = true; + for (b2Shape* s = m_shapeList; s; s = s->m_next) + { + inRange = s->Synchronize(m_world->m_broadPhase, xf1, m_xf); + if (inRange == false) + { + break; + } + } + + if (inRange == false) + { + m_flags |= e_frozenFlag; + m_linearVelocity.SetZero(); + m_angularVelocity = 0.0f; + for (b2Shape* s = m_shapeList; s; s = s->m_next) + { + s->DestroyProxy(m_world->m_broadPhase); + } + + // Failure + return false; + } + + // Success + return true; +} diff --git a/Box2D/Source/Dynamics/b2Body.h b/Box2D/Source/Dynamics/b2Body.h new file mode 100644 index 0000000..3621f01 --- /dev/null +++ b/Box2D/Source/Dynamics/b2Body.h @@ -0,0 +1,587 @@ +/* +* Copyright (c) 2006-2007 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_BODY_H +#define B2_BODY_H + +#include "../Common/b2Math.h" +#include "../Collision/Shapes/b2Shape.h" +#include "Joints/b2Joint.h" + +#include + +class b2Joint; +class b2Contact; +class b2World; +struct b2JointEdge; +struct b2ContactEdge; + +/// A body definition holds all the data needed to construct a rigid body. +/// You can safely re-use body definitions. +struct b2BodyDef +{ + /// This constructor sets the body definition default values. + b2BodyDef() + { + massData.center.SetZero(); + massData.mass = 0.0f; + massData.I = 0.0f; + userData = NULL; + position.Set(0.0f, 0.0f); + angle = 0.0f; + linearDamping = 0.0f; + angularDamping = 0.0f; + allowSleep = true; + isSleeping = false; + fixedRotation = false; + isBullet = false; + } + + /// You can use this to initialized the mass properties of the body. + /// If you prefer, you can set the mass properties after the shapes + /// have been added using b2Body::SetMassFromShapes. + b2MassData massData; + + /// Use this to store application specific body data. + void* userData; + + /// The world position of the body. Avoid creating bodies at the origin + /// since this can lead to many overlapping shapes. + b2Vec2 position; + + /// The world angle of the body in radians. + float32 angle; + + /// Linear damping is use to reduce the linear velocity. The damping parameter + /// can be larger than 1.0f but the damping effect becomes sensitive to the + /// time step when the damping parameter is large. + float32 linearDamping; + + /// Angular damping is use to reduce the angular velocity. The damping parameter + /// can be larger than 1.0f but the damping effect becomes sensitive to the + /// time step when the damping parameter is large. + float32 angularDamping; + + /// Set this flag to false if this body should never fall asleep. Note that + /// this increases CPU usage. + bool allowSleep; + + /// Is this body initially sleeping? + bool isSleeping; + + /// Should this body be prevented from rotating? Useful for characters. + bool fixedRotation; + + /// Is this a fast moving body that should be prevented from tunneling through + /// other moving bodies? Note that all bodies are prevented from tunneling through + /// static bodies. + /// @warning You should use this flag sparingly since it increases processing time. + bool isBullet; +}; + +/// A rigid body. +class b2Body +{ +public: + /// Creates a shape and attach it to this body. + /// @param shapeDef the shape definition. + /// @warning This function is locked during callbacks. + b2Shape* CreateShape(b2ShapeDef* shapeDef); + + /// Destroy a shape. This removes the shape from the broad-phase and + /// therefore destroys any contacts associated with this shape. All shapes + /// attached to a body are implicitly destroyed when the body is destroyed. + /// @param shape the shape to be removed. + /// @warning This function is locked during callbacks. + void DestroyShape(b2Shape* shape); + + /// Set the mass properties. Note that this changes the center of mass position. + /// If you are not sure how to compute mass properties, use SetMassFromShapes. + /// The inertia tensor is assumed to be relative to the center of mass. + /// @param massData the mass properties. + void SetMass(const b2MassData* massData); + + /// Compute the mass properties from the attached shapes. You typically call this + /// after adding all the shapes. If you add or remove shapes later, you may want + /// to call this again. Note that this changes the center of mass position. + void SetMassFromShapes(); + + /// Set the position of the body's origin and rotation (radians). + /// This breaks any contacts and wakes the other bodies. + /// @param position the new world position of the body's origin (not necessarily + /// the center of mass). + /// @param angle the new world rotation angle of the body in radians. + /// @return false if the movement put a shape outside the world. In this case the + /// body is automatically frozen. + bool SetXForm(const b2Vec2& position, float32 angle); + + /// Get the body transform for the body's origin. + /// @return the world transform of the body's origin. + const b2XForm& GetXForm() const; + + /// Get the world body origin position. + /// @return the world position of the body's origin. + const b2Vec2& GetPosition() const; + + /// Get the angle in radians. + /// @return the current world rotation angle in radians. + float32 GetAngle() const; + + /// Get the world position of the center of mass. + const b2Vec2& GetWorldCenter() const; + + /// Get the local position of the center of mass. + const b2Vec2& GetLocalCenter() const; + + /// Set the linear velocity of the center of mass. + /// @param v the new linear velocity of the center of mass. + void SetLinearVelocity(const b2Vec2& v); + + /// Get the linear velocity of the center of mass. + /// @return the linear velocity of the center of mass. + b2Vec2 GetLinearVelocity() const; + + /// Set the angular velocity. + /// @param omega the new angular velocity in radians/second. + void SetAngularVelocity(float32 omega); + + /// Get the angular velocity. + /// @return the angular velocity in radians/second. + float32 GetAngularVelocity() const; + + /// Apply a force at a world point. If the force is not + /// applied at the center of mass, it will generate a torque and + /// affect the angular velocity. This wakes up the body. + /// @param force the world force vector, usually in Newtons (N). + /// @param point the world position of the point of application. + void ApplyForce(const b2Vec2& force, const b2Vec2& point); + + /// Apply a torque. This affects the angular velocity + /// without affecting the linear velocity of the center of mass. + /// This wakes up the body. + /// @param torque about the z-axis (out of the screen), usually in N-m. + void ApplyTorque(float32 torque); + + /// Apply an impulse at a point. This immediately modifies the velocity. + /// It also modifies the angular velocity if the point of application + /// is not at the center of mass. This wakes up the body. + /// @param impulse the world impulse vector, usually in N-seconds or kg-m/s. + /// @param point the world position of the point of application. + void ApplyImpulse(const b2Vec2& impulse, const b2Vec2& point); + + /// Get the total mass of the body. + /// @return the mass, usually in kilograms (kg). + float32 GetMass() const; + + /// Get the central rotational inertia of the body. + /// @return the rotational inertia, usually in kg-m^2. + float32 GetInertia() const; + + /// Get the world coordinates of a point given the local coordinates. + /// @param localPoint a point on the body measured relative the the body's origin. + /// @return the same point expressed in world coordinates. + b2Vec2 GetWorldPoint(const b2Vec2& localPoint) const; + + /// Get the world coordinates of a vector given the local coordinates. + /// @param localVector a vector fixed in the body. + /// @return the same vector expressed in world coordinates. + b2Vec2 GetWorldVector(const b2Vec2& localVector) const; + + /// Gets a local point relative to the body's origin given a world point. + /// @param a point in world coordinates. + /// @return the corresponding local point relative to the body's origin. + b2Vec2 GetLocalPoint(const b2Vec2& worldPoint) const; + + /// Gets a local vector given a world vector. + /// @param a vector in world coordinates. + /// @return the corresponding local vector. + b2Vec2 GetLocalVector(const b2Vec2& worldVector) const; + + /// Get the world linear velocity of a world point attached to this body. + /// @param a point in world coordinates. + /// @return the world velocity of a point. + b2Vec2 GetLinearVelocityFromWorldPoint(const b2Vec2& worldPoint) const; + + /// Get the world velocity of a local point. + /// @param a point in local coordinates. + /// @return the world velocity of a point. + b2Vec2 GetLinearVelocityFromLocalPoint(const b2Vec2& localPoint) const; + + /// Is this body treated like a bullet for continuous collision detection? + bool IsBullet() const; + + /// Should this body be treated like a bullet for continuous collision detection? + void SetBullet(bool flag); + + /// Is this body static (immovable)? + bool IsStatic() const; + + /// Is this body dynamic (movable)? + bool IsDynamic() const; + + /// Is this body frozen? + bool IsFrozen() const; + + /// Is this body sleeping (not simulating). + bool IsSleeping() const; + + /// You can disable sleeping on this body. + void AllowSleeping(bool flag); + + /// Wake up this body so it will begin simulating. + void WakeUp(); + + /// Put this body to sleep so it will stop simulating. + /// This also sets the velocity to zero. + void PutToSleep(); + + /// Get the list of all shapes attached to this body. + b2Shape* GetShapeList(); + + /// Get the list of all joints attached to this body. + b2JointEdge* GetJointList(); + + /// Get the next body in the world's body list. + b2Body* GetNext(); + + /// Get the user data pointer that was provided in the body definition. + void* GetUserData(); + + /// Set the user data. Use this to store your application specific data. + void SetUserData(void* data); + + /// Get the parent world of this body. + b2World* GetWorld(); + +private: + + friend class b2World; + friend class b2Island; + friend class b2ContactManager; + friend class b2ContactSolver; + + friend class b2DistanceJoint; + friend class b2GearJoint; + friend class b2MouseJoint; + friend class b2PrismaticJoint; + friend class b2PulleyJoint; + friend class b2RevoluteJoint; + + // m_flags + enum + { + e_frozenFlag = 0x0002, + e_islandFlag = 0x0004, + e_sleepFlag = 0x0008, + e_allowSleepFlag = 0x0010, + e_bulletFlag = 0x0020, + e_fixedRotationFlag = 0x0040, + }; + + // m_type + enum + { + e_staticType, + e_dynamicType, + e_maxTypes, + }; + + b2Body(const b2BodyDef* bd, b2World* world); + ~b2Body(); + + bool SynchronizeShapes(); + + void SynchronizeTransform(); + + // This is used to prevent connected bodies from colliding. + // It may lie, depending on the collideConnected flag. + bool IsConnected(const b2Body* other) const; + + void Advance(float32 t); + + uint16 m_flags; + int16 m_type; + + b2XForm m_xf; // the body origin transform + + b2Sweep m_sweep; // the swept motion for CCD + + b2Vec2 m_linearVelocity; + float32 m_angularVelocity; + + b2Vec2 m_force; + float32 m_torque; + + b2World* m_world; + b2Body* m_prev; + b2Body* m_next; + + b2Shape* m_shapeList; + int32 m_shapeCount; + + b2JointEdge* m_jointList; + b2ContactEdge* m_contactList; + + float32 m_mass, m_invMass; + float32 m_I, m_invI; + + float32 m_linearDamping; + float32 m_angularDamping; + + float32 m_sleepTime; + + void* m_userData; +}; + +inline const b2XForm& b2Body::GetXForm() const +{ + return m_xf; +} + +inline const b2Vec2& b2Body::GetPosition() const +{ + return m_xf.position; +} + +inline float32 b2Body::GetAngle() const +{ + return m_sweep.a; +} + +inline const b2Vec2& b2Body::GetWorldCenter() const +{ + return m_sweep.c; +} + +inline const b2Vec2& b2Body::GetLocalCenter() const +{ + return m_sweep.localCenter; +} + +inline void b2Body::SetLinearVelocity(const b2Vec2& v) +{ + m_linearVelocity = v; +} + +inline b2Vec2 b2Body::GetLinearVelocity() const +{ + return m_linearVelocity; +} + +inline void b2Body::SetAngularVelocity(float32 w) +{ + m_angularVelocity = w; +} + +inline float32 b2Body::GetAngularVelocity() const +{ + return m_angularVelocity; +} + +inline float32 b2Body::GetMass() const +{ + return m_mass; +} + +inline float32 b2Body::GetInertia() const +{ + return m_I; +} + +inline b2Vec2 b2Body::GetWorldPoint(const b2Vec2& localPoint) const +{ + return b2Mul(m_xf, localPoint); +} + +inline b2Vec2 b2Body::GetWorldVector(const b2Vec2& localVector) const +{ + return b2Mul(m_xf.R, localVector); +} + +inline b2Vec2 b2Body::GetLocalPoint(const b2Vec2& worldPoint) const +{ + return b2MulT(m_xf, worldPoint); +} + +inline b2Vec2 b2Body::GetLocalVector(const b2Vec2& worldVector) const +{ + return b2MulT(m_xf.R, worldVector); +} + +inline b2Vec2 b2Body::GetLinearVelocityFromWorldPoint(const b2Vec2& worldPoint) const +{ + return m_linearVelocity + b2Cross(m_angularVelocity, worldPoint - m_sweep.c); +} + +inline b2Vec2 b2Body::GetLinearVelocityFromLocalPoint(const b2Vec2& localPoint) const +{ + return GetLinearVelocityFromWorldPoint(GetWorldPoint(localPoint)); +} + +inline bool b2Body::IsBullet() const +{ + return (m_flags & e_bulletFlag) == e_bulletFlag; +} + +inline void b2Body::SetBullet(bool flag) +{ + if (flag) + { + m_flags |= e_bulletFlag; + } + else + { + m_flags &= ~e_bulletFlag; + } +} + +inline bool b2Body::IsStatic() const +{ + return m_type == e_staticType; +} + +inline bool b2Body::IsDynamic() const +{ + return m_type == e_dynamicType; +} + +inline bool b2Body::IsFrozen() const +{ + return (m_flags & e_frozenFlag) == e_frozenFlag; +} + +inline bool b2Body::IsSleeping() const +{ + return (m_flags & e_sleepFlag) == e_sleepFlag; +} + +inline void b2Body::AllowSleeping(bool flag) +{ + if (flag) + { + m_flags |= e_allowSleepFlag; + } + else + { + m_flags &= ~e_allowSleepFlag; + WakeUp(); + } +} + +inline void b2Body::WakeUp() +{ + m_flags &= ~e_sleepFlag; + m_sleepTime = 0.0f; +} + +inline void b2Body::PutToSleep() +{ + m_flags |= e_sleepFlag; + m_sleepTime = 0.0f; + m_linearVelocity.SetZero(); + m_angularVelocity = 0.0f; + m_force.SetZero(); + m_torque = 0.0f; +} + +inline b2Shape* b2Body::GetShapeList() +{ + return m_shapeList; +} + +inline b2JointEdge* b2Body::GetJointList() +{ + return m_jointList; +} + +inline b2Body* b2Body::GetNext() +{ + return m_next; +} + +inline void* b2Body::GetUserData() +{ + return m_userData; +} + +inline void b2Body::SetUserData(void* data) +{ + m_userData = data; +} + +inline bool b2Body::IsConnected(const b2Body* other) const +{ + for (b2JointEdge* jn = m_jointList; jn; jn = jn->next) + { + if (jn->other == other) + return jn->joint->m_collideConnected == false; + } + + return false; +} + +inline void b2Body::ApplyForce(const b2Vec2& force, const b2Vec2& point) +{ + if (IsSleeping()) + { + WakeUp(); + } + m_force += force; + m_torque += b2Cross(point - m_sweep.c, force); +} + +inline void b2Body::ApplyTorque(float32 torque) +{ + if (IsSleeping()) + { + WakeUp(); + } + m_torque += torque; +} + +inline void b2Body::ApplyImpulse(const b2Vec2& impulse, const b2Vec2& point) +{ + if (IsSleeping()) + { + WakeUp(); + } + m_linearVelocity += m_invMass * impulse; + m_angularVelocity += m_invI * b2Cross(point - m_sweep.c, impulse); +} + +inline void b2Body::SynchronizeTransform() +{ + m_xf.R.Set(m_sweep.a); + m_xf.position = m_sweep.c - b2Mul(m_xf.R, m_sweep.localCenter); +} + +inline void b2Body::Advance(float32 t) +{ + // Advance to the new safe time. + m_sweep.Advance(t); + m_sweep.c = m_sweep.c0; + m_sweep.a = m_sweep.a0; + SynchronizeTransform(); +} + +inline b2World* b2Body::GetWorld() +{ + return m_world; +} + +#endif diff --git a/Box2D/Source/Dynamics/b2ContactManager.cpp b/Box2D/Source/Dynamics/b2ContactManager.cpp new file mode 100644 index 0000000..d476811 --- /dev/null +++ b/Box2D/Source/Dynamics/b2ContactManager.cpp @@ -0,0 +1,240 @@ +/* +* Copyright (c) 2006-2007 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. +*/ + +#include "b2ContactManager.h" +#include "b2World.h" +#include "b2Body.h" + +// This is a callback from the broadphase when two AABB proxies begin +// to overlap. We create a b2Contact to manage the narrow phase. +void* b2ContactManager::PairAdded(void* proxyUserData1, void* proxyUserData2) +{ + b2Shape* shape1 = (b2Shape*)proxyUserData1; + b2Shape* shape2 = (b2Shape*)proxyUserData2; + + b2Body* body1 = shape1->GetBody(); + b2Body* body2 = shape2->GetBody(); + + if (body1->IsStatic() && body2->IsStatic()) + { + return &m_nullContact; + } + + if (shape1->GetBody() == shape2->GetBody()) + { + return &m_nullContact; + } + + if (body2->IsConnected(body1)) + { + return &m_nullContact; + } + + if (m_world->m_contactFilter != NULL && m_world->m_contactFilter->ShouldCollide(shape1, shape2) == false) + { + return &m_nullContact; + } + + // Call the factory. + b2Contact* c = b2Contact::Create(shape1, shape2, &m_world->m_blockAllocator); + + if (c == NULL) + { + return &m_nullContact; + } + + // Contact creation may swap shapes. + shape1 = c->GetShape1(); + shape2 = c->GetShape2(); + body1 = shape1->GetBody(); + body2 = shape2->GetBody(); + + // Insert into the world. + c->m_prev = NULL; + c->m_next = m_world->m_contactList; + if (m_world->m_contactList != NULL) + { + m_world->m_contactList->m_prev = c; + } + m_world->m_contactList = c; + + // Connect to island graph. + + // Connect to body 1 + c->m_node1.contact = c; + c->m_node1.other = body2; + + c->m_node1.prev = NULL; + c->m_node1.next = body1->m_contactList; + if (body1->m_contactList != NULL) + { + body1->m_contactList->prev = &c->m_node1; + } + body1->m_contactList = &c->m_node1; + + // Connect to body 2 + c->m_node2.contact = c; + c->m_node2.other = body1; + + c->m_node2.prev = NULL; + c->m_node2.next = body2->m_contactList; + if (body2->m_contactList != NULL) + { + body2->m_contactList->prev = &c->m_node2; + } + body2->m_contactList = &c->m_node2; + + ++m_world->m_contactCount; + return c; +} + +// This is a callback from the broadphase when two AABB proxies cease +// to overlap. We retire the b2Contact. +void b2ContactManager::PairRemoved(void* proxyUserData1, void* proxyUserData2, void* pairUserData) +{ + B2_NOT_USED(proxyUserData1); + B2_NOT_USED(proxyUserData2); + + if (pairUserData == NULL) + { + return; + } + + b2Contact* c = (b2Contact*)pairUserData; + if (c == &m_nullContact) + { + return; + } + + // An attached body is being destroyed, we must destroy this contact + // immediately to avoid orphaned shape pointers. + Destroy(c); +} + +void b2ContactManager::Destroy(b2Contact* c) +{ + b2Shape* shape1 = c->GetShape1(); + b2Shape* shape2 = c->GetShape2(); + + // Inform the user that this contact is ending. + int32 manifoldCount = c->GetManifoldCount(); + if (manifoldCount > 0 && m_world->m_contactListener) + { + b2Body* b1 = shape1->GetBody(); + b2Body* b2 = shape2->GetBody(); + + b2Manifold* manifolds = c->GetManifolds(); + b2ContactPoint cp; + cp.shape1 = c->GetShape1(); + cp.shape2 = c->GetShape2(); + cp.friction = c->m_friction; + cp.restitution = c->m_restitution; + + for (int32 i = 0; i < manifoldCount; ++i) + { + b2Manifold* manifold = manifolds + i; + cp.normal = manifold->normal; + + for (int32 j = 0; j < manifold->pointCount; ++j) + { + b2ManifoldPoint* mp = manifold->points + j; + cp.position = b1->GetWorldPoint(mp->localPoint1); + b2Vec2 v1 = b1->GetLinearVelocityFromLocalPoint(mp->localPoint1); + b2Vec2 v2 = b2->GetLinearVelocityFromLocalPoint(mp->localPoint2); + cp.velocity = v2 - v1; + cp.separation = mp->separation; + cp.id = mp->id; + m_world->m_contactListener->Remove(&cp); + } + } + } + + // Remove from the world. + if (c->m_prev) + { + c->m_prev->m_next = c->m_next; + } + + if (c->m_next) + { + c->m_next->m_prev = c->m_prev; + } + + if (c == m_world->m_contactList) + { + m_world->m_contactList = c->m_next; + } + + b2Body* body1 = shape1->GetBody(); + b2Body* body2 = shape2->GetBody(); + + // Remove from body 1 + if (c->m_node1.prev) + { + c->m_node1.prev->next = c->m_node1.next; + } + + if (c->m_node1.next) + { + c->m_node1.next->prev = c->m_node1.prev; + } + + if (&c->m_node1 == body1->m_contactList) + { + body1->m_contactList = c->m_node1.next; + } + + // Remove from body 2 + if (c->m_node2.prev) + { + c->m_node2.prev->next = c->m_node2.next; + } + + if (c->m_node2.next) + { + c->m_node2.next->prev = c->m_node2.prev; + } + + if (&c->m_node2 == body2->m_contactList) + { + body2->m_contactList = c->m_node2.next; + } + + // Call the factory. + b2Contact::Destroy(c, &m_world->m_blockAllocator); + --m_world->m_contactCount; +} + +// This is the top level collision call for the time step. Here +// all the narrow phase collision is processed for the world +// contact list. +void b2ContactManager::Collide() +{ + // Update awake contacts. + for (b2Contact* c = m_world->m_contactList; c; c = c->GetNext()) + { + b2Body* body1 = c->GetShape1()->GetBody(); + b2Body* body2 = c->GetShape2()->GetBody(); + if (body1->IsSleeping() && body2->IsSleeping()) + { + continue; + } + + c->Update(m_world->m_contactListener); + } +} diff --git a/Box2D/Source/Dynamics/b2ContactManager.h b/Box2D/Source/Dynamics/b2ContactManager.h new file mode 100644 index 0000000..dfcda76 --- /dev/null +++ b/Box2D/Source/Dynamics/b2ContactManager.h @@ -0,0 +1,54 @@ +/* +* Copyright (c) 2006-2007 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_CONTACT_MANAGER_H +#define B2_CONTACT_MANAGER_H + +#include "../Collision/b2BroadPhase.h" +#include "../Dynamics/Contacts/b2NullContact.h" + +class b2World; +class b2Contact; +struct b2TimeStep; + +// Delegate of b2World. +class b2ContactManager : public b2PairCallback +{ +public: + b2ContactManager() : m_world(NULL), m_destroyImmediate(false) {} + + // Implements PairCallback + void* PairAdded(void* proxyUserData1, void* proxyUserData2); + + // Implements PairCallback + void PairRemoved(void* proxyUserData1, void* proxyUserData2, void* pairUserData); + + void Destroy(b2Contact* c); + + void Collide(); + + b2World* m_world; + + // This lets us provide broadphase proxy pair user data for + // contacts that shouldn't exist. + b2NullContact m_nullContact; + + bool m_destroyImmediate; +}; + +#endif diff --git a/Box2D/Source/Dynamics/b2Island.cpp b/Box2D/Source/Dynamics/b2Island.cpp new file mode 100644 index 0000000..f869a78 --- /dev/null +++ b/Box2D/Source/Dynamics/b2Island.cpp @@ -0,0 +1,420 @@ +/* +* Copyright (c) 2006-2007 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. +*/ + +#include "b2Island.h" +#include "b2Body.h" +#include "b2World.h" +#include "Contacts/b2Contact.h" +#include "Contacts/b2ContactSolver.h" +#include "Joints/b2Joint.h" +#include "../Common/b2StackAllocator.h" + +/* +Position Correction Notes +========================= +I tried the several algorithms for position correction of the 2D revolute joint. +I looked at these systems: +- simple pendulum (1m diameter sphere on massless 5m stick) with initial angular velocity of 100 rad/s. +- suspension bridge with 30 1m long planks of length 1m. +- multi-link chain with 30 1m long links. + +Here are the algorithms: + +Baumgarte - A fraction of the position error is added to the velocity error. There is no +separate position solver. + +Pseudo Velocities - After the velocity solver and position integration, +the position error, Jacobian, and effective mass are recomputed. Then +the velocity constraints are solved with pseudo velocities and a fraction +of the position error is added to the pseudo velocity error. The pseudo +velocities are initialized to zero and there is no warm-starting. After +the position solver, the pseudo velocities are added to the positions. +This is also called the First Order World method or the Position LCP method. + +Modified Nonlinear Gauss-Seidel (NGS) - Like Pseudo Velocities except the +position error is re-computed for each constraint and the positions are updated +after the constraint is solved. The radius vectors (aka Jacobians) are +re-computed too (otherwise the algorithm has horrible instability). The pseudo +velocity states are not needed because they are effectively zero at the beginning +of each iteration. Since we have the current position error, we allow the +iterations to terminate early if the error becomes smaller than b2_linearSlop. + +Full NGS or just NGS - Like Modified NGS except the effective mass are re-computed +each time a constraint is solved. + +Here are the results: +Baumgarte - this is the cheapest algorithm but it has some stability problems, +especially with the bridge. The chain links separate easily close to the root +and they jitter as they struggle to pull together. This is one of the most common +methods in the field. The big drawback is that the position correction artificially +affects the momentum, thus leading to instabilities and false bounce. I used a +bias factor of 0.2. A larger bias factor makes the bridge less stable, a smaller +factor makes joints and contacts more spongy. + +Pseudo Velocities - the is more stable than the Baumgarte method. The bridge is +stable. However, joints still separate with large angular velocities. Drag the +simple pendulum in a circle quickly and the joint will separate. The chain separates +easily and does not recover. I used a bias factor of 0.2. A larger value lead to +the bridge collapsing when a heavy cube drops on it. + +Modified NGS - this algorithm is better in some ways than Baumgarte and Pseudo +Velocities, but in other ways it is worse. The bridge and chain are much more +stable, but the simple pendulum goes unstable at high angular velocities. + +Full NGS - stable in all tests. The joints display good stiffness. The bridge +still sags, but this is better than infinite forces. + +Recommendations +Pseudo Velocities are not really worthwhile because the bridge and chain cannot +recover from joint separation. In other cases the benefit over Baumgarte is small. + +Modified NGS is not a robust method for the revolute joint due to the violent +instability seen in the simple pendulum. Perhaps it is viable with other constraint +types, especially scalar constraints where the effective mass is a scalar. + +This leaves Baumgarte and Full NGS. Baumgarte has small, but manageable instabilities +and is very fast. I don't think we can escape Baumgarte, especially in highly +demanding cases where high constraint fidelity is not needed. + +Full NGS is robust and easy on the eyes. I recommend this as an option for +higher fidelity simulation and certainly for suspension bridges and long chains. +Full NGS might be a good choice for ragdolls, especially motorized ragdolls where +joint separation can be problematic. The number of NGS iterations can be reduced +for better performance without harming robustness much. + +Each joint in a can be handled differently in the position solver. So I recommend +a system where the user can select the algorithm on a per joint basis. I would +probably default to the slower Full NGS and let the user select the faster +Baumgarte method in performance critical scenarios. +*/ + +b2Island::b2Island( + int32 bodyCapacity, + int32 contactCapacity, + int32 jointCapacity, + b2StackAllocator* allocator, + b2ContactListener* listener) +{ + m_bodyCapacity = bodyCapacity; + m_contactCapacity = contactCapacity; + m_jointCapacity = jointCapacity; + m_bodyCount = 0; + m_contactCount = 0; + m_jointCount = 0; + + m_allocator = allocator; + m_listener = listener; + + m_bodies = (b2Body**)m_allocator->Allocate(bodyCapacity * sizeof(b2Body*)); + m_contacts = (b2Contact**)m_allocator->Allocate(contactCapacity * sizeof(b2Contact*)); + m_joints = (b2Joint**)m_allocator->Allocate(jointCapacity * sizeof(b2Joint*)); + + m_positionIterationCount = 0; +} + +b2Island::~b2Island() +{ + // Warning: the order should reverse the constructor order. + m_allocator->Free(m_joints); + m_allocator->Free(m_contacts); + m_allocator->Free(m_bodies); +} + +void b2Island::Solve(const b2TimeStep& step, const b2Vec2& gravity, bool correctPositions, bool allowSleep) +{ + // Integrate velocities and apply damping. + for (int32 i = 0; i < m_bodyCount; ++i) + { + b2Body* b = m_bodies[i]; + + if (b->IsStatic()) + continue; + + // Integrate velocities. + b->m_linearVelocity += step.dt * (gravity + b->m_invMass * b->m_force); + b->m_angularVelocity += step.dt * b->m_invI * b->m_torque; + + // Reset forces. + b->m_force.Set(0.0f, 0.0f); + b->m_torque = 0.0f; + + // Apply damping. + // ODE: dv/dt + c * v = 0 + // Solution: v(t) = v0 * exp(-c * t) + // Time step: v(t + dt) = v0 * exp(-c * (t + dt)) = v0 * exp(-c * t) * exp(-c * dt) = v * exp(-c * dt) + // v2 = exp(-c * dt) * v1 + // Taylor expansion: + // v2 = (1.0f - c * dt) * v1 + b->m_linearVelocity *= b2Clamp(1.0f - step.dt * b->m_linearDamping, 0.0f, 1.0f); + b->m_angularVelocity *= b2Clamp(1.0f - step.dt * b->m_angularDamping, 0.0f, 1.0f); + + // Check for large velocities. +#ifdef TARGET_FLOAT32_IS_FIXED + // Fixed point code written this way to prevent + // overflows, float code is optimized for speed + + float32 vMagnitude = b->m_linearVelocity.Length(); + if(vMagnitude > b2_maxLinearVelocity) { + b->m_linearVelocity *= b2_maxLinearVelocity/vMagnitude; + } + b->m_angularVelocity = b2Clamp(b->m_angularVelocity, + -b2_maxAngularVelocity, b2_maxAngularVelocity); + +#else + + if (b2Dot(b->m_linearVelocity, b->m_linearVelocity) > b2_maxLinearVelocitySquared) + { + b->m_linearVelocity.Normalize(); + b->m_linearVelocity *= b2_maxLinearVelocity; + } + if (b->m_angularVelocity * b->m_angularVelocity > b2_maxAngularVelocitySquared) + { + if (b->m_angularVelocity < 0.0f) + { + b->m_angularVelocity = -b2_maxAngularVelocity; + } + else + { + b->m_angularVelocity = b2_maxAngularVelocity; + } + } +#endif + + } + + b2ContactSolver contactSolver(step, m_contacts, m_contactCount, m_allocator); + + // Initialize velocity constraints. + contactSolver.InitVelocityConstraints(step); + + for (int32 i = 0; i < m_jointCount; ++i) + { + m_joints[i]->InitVelocityConstraints(step); + } + + // Solve velocity constraints. + for (int32 i = 0; i < step.maxIterations; ++i) + { + contactSolver.SolveVelocityConstraints(); + + for (int32 j = 0; j < m_jointCount; ++j) + { + m_joints[j]->SolveVelocityConstraints(step); + } + } + + // Post-solve (store impulses for warm starting). + contactSolver.FinalizeVelocityConstraints(); + + // Integrate positions. + for (int32 i = 0; i < m_bodyCount; ++i) + { + b2Body* b = m_bodies[i]; + + if (b->IsStatic()) + continue; + + // Store positions for continuous collision. + b->m_sweep.c0 = b->m_sweep.c; + b->m_sweep.a0 = b->m_sweep.a; + + // Integrate + b->m_sweep.c += step.dt * b->m_linearVelocity; + b->m_sweep.a += step.dt * b->m_angularVelocity; + + // Compute new transform + b->SynchronizeTransform(); + + // Note: shapes are synchronized later. + } + + if (correctPositions) + { + // Initialize position constraints. + // Contacts don't need initialization. + for (int32 i = 0; i < m_jointCount; ++i) + { + m_joints[i]->InitPositionConstraints(); + } + + // Iterate over constraints. + for (m_positionIterationCount = 0; m_positionIterationCount < step.maxIterations; ++m_positionIterationCount) + { + bool contactsOkay = contactSolver.SolvePositionConstraints(b2_contactBaumgarte); + + bool jointsOkay = true; + for (int i = 0; i < m_jointCount; ++i) + { + bool jointOkay = m_joints[i]->SolvePositionConstraints(); + jointsOkay = jointsOkay && jointOkay; + } + + if (contactsOkay && jointsOkay) + { + break; + } + } + } + + Report(contactSolver.m_constraints); + + if (allowSleep) + { + float32 minSleepTime = B2_FLT_MAX; + +#ifndef TARGET_FLOAT32_IS_FIXED + const float32 linTolSqr = b2_linearSleepTolerance * b2_linearSleepTolerance; + const float32 angTolSqr = b2_angularSleepTolerance * b2_angularSleepTolerance; +#endif + + for (int32 i = 0; i < m_bodyCount; ++i) + { + b2Body* b = m_bodies[i]; + if (b->m_invMass == 0.0f) + { + continue; + } + + if ((b->m_flags & b2Body::e_allowSleepFlag) == 0) + { + b->m_sleepTime = 0.0f; + minSleepTime = 0.0f; + } + + if ((b->m_flags & b2Body::e_allowSleepFlag) == 0 || +#ifdef TARGET_FLOAT32_IS_FIXED + b2Abs(b->m_angularVelocity) > b2_angularSleepTolerance || + b2Abs(b->m_linearVelocity.x) > b2_linearSleepTolerance || + b2Abs(b->m_linearVelocity.y) > b2_linearSleepTolerance) +#else + b->m_angularVelocity * b->m_angularVelocity > angTolSqr || + b2Dot(b->m_linearVelocity, b->m_linearVelocity) > linTolSqr) +#endif + { + b->m_sleepTime = 0.0f; + minSleepTime = 0.0f; + } + else + { + b->m_sleepTime += step.dt; + minSleepTime = b2Min(minSleepTime, b->m_sleepTime); + } + } + + if (minSleepTime >= b2_timeToSleep) + { + for (int32 i = 0; i < m_bodyCount; ++i) + { + b2Body* b = m_bodies[i]; + b->m_flags |= b2Body::e_sleepFlag; + b->m_linearVelocity = b2Vec2_zero; + b->m_angularVelocity = 0.0f; + } + } + } +} + +void b2Island::SolveTOI(const b2TimeStep& subStep) +{ + b2ContactSolver contactSolver(subStep, m_contacts, m_contactCount, m_allocator); + + // No warm starting needed for TOI events. + + // Solve velocity constraints. + for (int32 i = 0; i < subStep.maxIterations; ++i) + { + contactSolver.SolveVelocityConstraints(); + } + + // Don't store the TOI contact forces for warm starting + // because they can be quite large. + + // Integrate positions. + for (int32 i = 0; i < m_bodyCount; ++i) + { + b2Body* b = m_bodies[i]; + + if (b->IsStatic()) + continue; + + // Store positions for continuous collision. + b->m_sweep.c0 = b->m_sweep.c; + b->m_sweep.a0 = b->m_sweep.a; + + // Integrate + b->m_sweep.c += subStep.dt * b->m_linearVelocity; + b->m_sweep.a += subStep.dt * b->m_angularVelocity; + + // Compute new transform + b->SynchronizeTransform(); + + // Note: shapes are synchronized later. + } + + // Solve position constraints. + const float32 k_toiBaumgarte = 0.75f; + for (int32 i = 0; i < subStep.maxIterations; ++i) + { + bool contactsOkay = contactSolver.SolvePositionConstraints(k_toiBaumgarte); + if (contactsOkay) + { + break; + } + } + + Report(contactSolver.m_constraints); +} + +void b2Island::Report(b2ContactConstraint* constraints) +{ + if (m_listener == NULL) + { + return; + } + + for (int32 i = 0; i < m_contactCount; ++i) + { + b2Contact* c = m_contacts[i]; + b2ContactConstraint* cc = constraints + i; + b2ContactResult cr; + cr.shape1 = c->GetShape1(); + cr.shape2 = c->GetShape2(); + b2Body* b1 = cr.shape1->GetBody(); + int32 manifoldCount = c->GetManifoldCount(); + b2Manifold* manifolds = c->GetManifolds(); + for (int32 j = 0; j < manifoldCount; ++j) + { + b2Manifold* manifold = manifolds + j; + cr.normal = manifold->normal; + for (int32 k = 0; k < manifold->pointCount; ++k) + { + b2ManifoldPoint* point = manifold->points + k; + b2ContactConstraintPoint* ccp = cc->points + k; + cr.position = b1->GetWorldPoint(point->localPoint1); + + // TOI constraint results are not stored, so get + // the result from the constraint. + cr.normalImpulse = ccp->normalImpulse; + cr.tangentImpulse = ccp->tangentImpulse; + cr.id = point->id; + + m_listener->Result(&cr); + } + } + } +} diff --git a/Box2D/Source/Dynamics/b2Island.h b/Box2D/Source/Dynamics/b2Island.h new file mode 100644 index 0000000..a23e9e9 --- /dev/null +++ b/Box2D/Source/Dynamics/b2Island.h @@ -0,0 +1,88 @@ +/* +* Copyright (c) 2006-2007 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_ISLAND_H +#define B2_ISLAND_H + +#include "../Common/b2Math.h" + +class b2Contact; +class b2Body; +class b2Joint; +class b2StackAllocator; +class b2ContactListener; +struct b2ContactConstraint; +struct b2TimeStep; + +class b2Island +{ +public: + b2Island(int32 bodyCapacity, int32 contactCapacity, int32 jointCapacity, + b2StackAllocator* allocator, b2ContactListener* listener); + ~b2Island(); + + void Clear() + { + m_bodyCount = 0; + m_contactCount = 0; + m_jointCount = 0; + } + + void Solve(const b2TimeStep& step, const b2Vec2& gravity, bool correctPositions, bool allowSleep); + + void SolveTOI(const b2TimeStep& subStep); + + void Add(b2Body* body) + { + b2Assert(m_bodyCount < m_bodyCapacity); + m_bodies[m_bodyCount++] = body; + } + + void Add(b2Contact* contact) + { + b2Assert(m_contactCount < m_contactCapacity); + m_contacts[m_contactCount++] = contact; + } + + void Add(b2Joint* joint) + { + b2Assert(m_jointCount < m_jointCapacity); + m_joints[m_jointCount++] = joint; + } + + void Report(b2ContactConstraint* constraints); + + b2StackAllocator* m_allocator; + b2ContactListener* m_listener; + + b2Body** m_bodies; + b2Contact** m_contacts; + b2Joint** m_joints; + + int32 m_bodyCount; + int32 m_jointCount; + int32 m_contactCount; + + int32 m_bodyCapacity; + int32 m_contactCapacity; + int32 m_jointCapacity; + + int32 m_positionIterationCount; +}; + +#endif diff --git a/Box2D/Source/Dynamics/b2World.cpp b/Box2D/Source/Dynamics/b2World.cpp new file mode 100644 index 0000000..882a0d3 --- /dev/null +++ b/Box2D/Source/Dynamics/b2World.cpp @@ -0,0 +1,1064 @@ +/* +* Copyright (c) 2006-2007 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. +*/ + +#include "b2World.h" +#include "b2Body.h" +#include "b2Island.h" +#include "Joints/b2PulleyJoint.h" +#include "Contacts/b2Contact.h" +#include "Contacts/b2ContactSolver.h" +#include "../Collision/b2Collision.h" +#include "../Collision/Shapes/b2CircleShape.h" +#include "../Collision/Shapes/b2PolygonShape.h" +#include + +b2World::b2World(const b2AABB& worldAABB, const b2Vec2& gravity, bool doSleep) +{ + m_destructionListener = NULL; + m_boundaryListener = NULL; + m_contactFilter = &b2_defaultFilter; + m_contactListener = NULL; + m_debugDraw = NULL; + + m_bodyList = NULL; + m_contactList = NULL; + m_jointList = NULL; + + m_bodyCount = 0; + m_contactCount = 0; + m_jointCount = 0; + + m_positionCorrection = true; + m_warmStarting = true; + m_continuousPhysics = true; + + m_allowSleep = doSleep; + m_gravity = gravity; + + m_lock = false; + + m_inv_dt0 = 0.0f; + + m_contactManager.m_world = this; + void* mem = b2Alloc(sizeof(b2BroadPhase)); + m_broadPhase = new (mem) b2BroadPhase(worldAABB, &m_contactManager); + + b2BodyDef bd; + m_groundBody = CreateBody(&bd); +} + +b2World::~b2World() +{ + DestroyBody(m_groundBody); + m_broadPhase->~b2BroadPhase(); + b2Free(m_broadPhase); +} + +void b2World::SetDestructionListener(b2DestructionListener* listener) +{ + m_destructionListener = listener; +} + +void b2World::SetBoundaryListener(b2BoundaryListener* listener) +{ + m_boundaryListener = listener; +} + +void b2World::SetContactFilter(b2ContactFilter* filter) +{ + m_contactFilter = filter; +} + +void b2World::SetContactListener(b2ContactListener* listener) +{ + m_contactListener = listener; +} + +void b2World::SetDebugDraw(b2DebugDraw* debugDraw) +{ + m_debugDraw = debugDraw; +} + +b2Body* b2World::CreateBody(const b2BodyDef* def) +{ + b2Assert(m_lock == false); + if (m_lock == true) + { + return NULL; + } + + void* mem = m_blockAllocator.Allocate(sizeof(b2Body)); + b2Body* b = new (mem) b2Body(def, this); + + // Add to world doubly linked list. + b->m_prev = NULL; + b->m_next = m_bodyList; + if (m_bodyList) + { + m_bodyList->m_prev = b; + } + m_bodyList = b; + ++m_bodyCount; + + return b; +} + +void b2World::DestroyBody(b2Body* b) +{ + b2Assert(m_bodyCount > 0); + b2Assert(m_lock == false); + if (m_lock == true) + { + return; + } + + // Delete the attached joints. + b2JointEdge* jn = b->m_jointList; + while (jn) + { + b2JointEdge* jn0 = jn; + jn = jn->next; + + if (m_destructionListener) + { + m_destructionListener->SayGoodbye(jn0->joint); + } + + DestroyJoint(jn0->joint); + } + + // Delete the attached shapes. This destroys broad-phase + // proxies and pairs, leading to the destruction of contacts. + b2Shape* s = b->m_shapeList; + while (s) + { + b2Shape* s0 = s; + s = s->m_next; + + if (m_destructionListener) + { + m_destructionListener->SayGoodbye(s0); + } + + s0->DestroyProxy(m_broadPhase); + b2Shape::Destroy(s0, &m_blockAllocator); + } + + // Remove world body list. + if (b->m_prev) + { + b->m_prev->m_next = b->m_next; + } + + if (b->m_next) + { + b->m_next->m_prev = b->m_prev; + } + + if (b == m_bodyList) + { + m_bodyList = b->m_next; + } + + --m_bodyCount; + b->~b2Body(); + m_blockAllocator.Free(b, sizeof(b2Body)); +} + +b2Joint* b2World::CreateJoint(const b2JointDef* def) +{ + b2Assert(m_lock == false); + + b2Joint* j = b2Joint::Create(def, &m_blockAllocator); + + // Connect to the world list. + j->m_prev = NULL; + j->m_next = m_jointList; + if (m_jointList) + { + m_jointList->m_prev = j; + } + m_jointList = j; + ++m_jointCount; + + // Connect to the bodies' doubly linked lists. + j->m_node1.joint = j; + j->m_node1.other = j->m_body2; + j->m_node1.prev = NULL; + j->m_node1.next = j->m_body1->m_jointList; + if (j->m_body1->m_jointList) j->m_body1->m_jointList->prev = &j->m_node1; + j->m_body1->m_jointList = &j->m_node1; + + j->m_node2.joint = j; + j->m_node2.other = j->m_body1; + j->m_node2.prev = NULL; + j->m_node2.next = j->m_body2->m_jointList; + if (j->m_body2->m_jointList) j->m_body2->m_jointList->prev = &j->m_node2; + j->m_body2->m_jointList = &j->m_node2; + + // If the joint prevents collisions, then reset collision filtering. + if (def->collideConnected == false) + { + // Reset the proxies on the body with the minimum number of shapes. + b2Body* b = def->body1->m_shapeCount < def->body2->m_shapeCount ? def->body1 : def->body2; + for (b2Shape* s = b->m_shapeList; s; s = s->m_next) + { + s->RefilterProxy(m_broadPhase, b->GetXForm()); + } + } + + return j; +} + +void b2World::DestroyJoint(b2Joint* j) +{ + b2Assert(m_lock == false); + + bool collideConnected = j->m_collideConnected; + + // Remove from the doubly linked list. + if (j->m_prev) + { + j->m_prev->m_next = j->m_next; + } + + if (j->m_next) + { + j->m_next->m_prev = j->m_prev; + } + + if (j == m_jointList) + { + m_jointList = j->m_next; + } + + // Disconnect from island graph. + b2Body* body1 = j->m_body1; + b2Body* body2 = j->m_body2; + + // Wake up connected bodies. + body1->WakeUp(); + body2->WakeUp(); + + // Remove from body 1. + if (j->m_node1.prev) + { + j->m_node1.prev->next = j->m_node1.next; + } + + if (j->m_node1.next) + { + j->m_node1.next->prev = j->m_node1.prev; + } + + if (&j->m_node1 == body1->m_jointList) + { + body1->m_jointList = j->m_node1.next; + } + + j->m_node1.prev = NULL; + j->m_node1.next = NULL; + + // Remove from body 2 + if (j->m_node2.prev) + { + j->m_node2.prev->next = j->m_node2.next; + } + + if (j->m_node2.next) + { + j->m_node2.next->prev = j->m_node2.prev; + } + + if (&j->m_node2 == body2->m_jointList) + { + body2->m_jointList = j->m_node2.next; + } + + j->m_node2.prev = NULL; + j->m_node2.next = NULL; + + b2Joint::Destroy(j, &m_blockAllocator); + + b2Assert(m_jointCount > 0); + --m_jointCount; + + // If the joint prevents collisions, then reset collision filtering. + if (collideConnected == false) + { + // Reset the proxies on the body with the minimum number of shapes. + b2Body* b = body1->m_shapeCount < body2->m_shapeCount ? body1 : body2; + for (b2Shape* s = b->m_shapeList; s; s = s->m_next) + { + s->RefilterProxy(m_broadPhase, b->GetXForm()); + } + } +} + +void b2World::Refilter(b2Shape* shape) +{ + shape->RefilterProxy(m_broadPhase, shape->GetBody()->GetXForm()); +} + +// Find islands, integrate and solve constraints, solve position constraints +void b2World::Solve(const b2TimeStep& step) +{ + m_positionIterationCount = 0; + + // Size the island for the worst case. + b2Island island(m_bodyCount, m_contactCount, m_jointCount, &m_stackAllocator, m_contactListener); + + // Clear all the island flags. + for (b2Body* b = m_bodyList; b; b = b->m_next) + { + b->m_flags &= ~b2Body::e_islandFlag; + } + for (b2Contact* c = m_contactList; c; c = c->m_next) + { + c->m_flags &= ~b2Contact::e_islandFlag; + } + for (b2Joint* j = m_jointList; j; j = j->m_next) + { + j->m_islandFlag = false; + } + + // Build and simulate all awake islands. + int32 stackSize = m_bodyCount; + b2Body** stack = (b2Body**)m_stackAllocator.Allocate(stackSize * sizeof(b2Body*)); + for (b2Body* seed = m_bodyList; seed; seed = seed->m_next) + { + if (seed->m_flags & (b2Body::e_islandFlag | b2Body::e_sleepFlag | b2Body::e_frozenFlag)) + { + continue; + } + + if (seed->IsStatic()) + { + continue; + } + + // Reset island and stack. + island.Clear(); + int32 stackCount = 0; + stack[stackCount++] = seed; + seed->m_flags |= b2Body::e_islandFlag; + + // Perform a depth first search (DFS) on the constraint graph. + while (stackCount > 0) + { + // Grab the next body off the stack and add it to the island. + b2Body* b = stack[--stackCount]; + island.Add(b); + + // Make sure the body is awake. + b->m_flags &= ~b2Body::e_sleepFlag; + + // To keep islands as small as possible, we don't + // propagate islands across static bodies. + if (b->IsStatic()) + { + continue; + } + + // Search all contacts connected to this body. + for (b2ContactEdge* cn = b->m_contactList; cn; cn = cn->next) + { + // Has this contact already been added to an island? + if (cn->contact->m_flags & (b2Contact::e_islandFlag | b2Contact::e_nonSolidFlag)) + { + continue; + } + + // Is this contact touching? + if (cn->contact->GetManifoldCount() == 0) + { + continue; + } + + island.Add(cn->contact); + cn->contact->m_flags |= b2Contact::e_islandFlag; + + b2Body* other = cn->other; + + // Was the other body already added to this island? + if (other->m_flags & b2Body::e_islandFlag) + { + continue; + } + + b2Assert(stackCount < stackSize); + stack[stackCount++] = other; + other->m_flags |= b2Body::e_islandFlag; + } + + // Search all joints connect to this body. + for (b2JointEdge* jn = b->m_jointList; jn; jn = jn->next) + { + if (jn->joint->m_islandFlag == true) + { + continue; + } + + island.Add(jn->joint); + jn->joint->m_islandFlag = true; + + b2Body* other = jn->other; + if (other->m_flags & b2Body::e_islandFlag) + { + continue; + } + + b2Assert(stackCount < stackSize); + stack[stackCount++] = other; + other->m_flags |= b2Body::e_islandFlag; + } + } + + island.Solve(step, m_gravity, m_positionCorrection, m_allowSleep); + m_positionIterationCount = b2Max(m_positionIterationCount, island.m_positionIterationCount); + + // Post solve cleanup. + for (int32 i = 0; i < island.m_bodyCount; ++i) + { + // Allow static bodies to participate in other islands. + b2Body* b = island.m_bodies[i]; + if (b->IsStatic()) + { + b->m_flags &= ~b2Body::e_islandFlag; + } + } + } + + m_stackAllocator.Free(stack); + + // Synchronize shapes, check for out of range bodies. + for (b2Body* b = m_bodyList; b; b = b->GetNext()) + { + if (b->m_flags & (b2Body::e_sleepFlag | b2Body::e_frozenFlag)) + { + continue; + } + + if (b->IsStatic()) + { + continue; + } + + // Update shapes (for broad-phase). If the shapes go out of + // the world AABB then shapes and contacts may be destroyed, + // including contacts that are + bool inRange = b->SynchronizeShapes(); + + // Did the body's shapes leave the world? + if (inRange == false && m_boundaryListener != NULL) + { + m_boundaryListener->Violation(b); + } + } + + // Commit shape proxy movements to the broad-phase so that new contacts are created. + // Also, some contacts can be destroyed. + m_broadPhase->Commit(); +} + +// Find TOI contacts and solve them. +void b2World::SolveTOI(const b2TimeStep& step) +{ + // Reserve an island and a stack for TOI island solution. + b2Island island(m_bodyCount, b2_maxTOIContactsPerIsland, 0, &m_stackAllocator, m_contactListener); + int32 stackSize = m_bodyCount; + b2Body** stack = (b2Body**)m_stackAllocator.Allocate(stackSize * sizeof(b2Body*)); + + for (b2Body* b = m_bodyList; b; b = b->m_next) + { + b->m_flags &= ~b2Body::e_islandFlag; + b->m_sweep.t0 = 0.0f; + } + + for (b2Contact* c = m_contactList; c; c = c->m_next) + { + // Invalidate TOI + c->m_flags &= ~(b2Contact::e_toiFlag | b2Contact::e_islandFlag); + } + + // Find TOI events and solve them. + for (;;) + { + // Find the first TOI. + b2Contact* minContact = NULL; + float32 minTOI = 1.0f; + + for (b2Contact* c = m_contactList; c; c = c->m_next) + { + if (c->m_flags & (b2Contact::e_slowFlag | b2Contact::e_nonSolidFlag)) + { + continue; + } + + // TODO_ERIN keep a counter on the contact, only respond to M TOIs per contact. + + float32 toi = 1.0f; + if (c->m_flags & b2Contact::e_toiFlag) + { + // This contact has a valid cached TOI. + toi = c->m_toi; + } + else + { + // Compute the TOI for this contact. + b2Shape* s1 = c->GetShape1(); + b2Shape* s2 = c->GetShape2(); + b2Body* b1 = s1->GetBody(); + b2Body* b2 = s2->GetBody(); + + if ((b1->IsStatic() || b1->IsSleeping()) && (b2->IsStatic() || b2->IsSleeping())) + { + continue; + } + + // Put the sweeps onto the same time interval. + float32 t0 = b1->m_sweep.t0; + + if (b1->m_sweep.t0 < b2->m_sweep.t0) + { + t0 = b2->m_sweep.t0; + b1->m_sweep.Advance(t0); + } + else if (b2->m_sweep.t0 < b1->m_sweep.t0) + { + t0 = b1->m_sweep.t0; + b2->m_sweep.Advance(t0); + } + + b2Assert(t0 < 1.0f); + + // Compute the time of impact. + toi = b2TimeOfImpact(c->m_shape1, b1->m_sweep, c->m_shape2, b2->m_sweep); + + b2Assert(0.0f <= toi && toi <= 1.0f); + + if (toi > 0.0f && toi < 1.0f) + { + toi = b2Min((1.0f - toi) * t0 + toi, 1.0f); + } + + + c->m_toi = toi; + c->m_flags |= b2Contact::e_toiFlag; + } + + if (B2_FLT_EPSILON < toi && toi < minTOI) + { + // This is the minimum TOI found so far. + minContact = c; + minTOI = toi; + } + } + + if (minContact == NULL || 1.0f - 100.0f * B2_FLT_EPSILON < minTOI) + { + // No more TOI events. Done! + break; + } + + // Advance the bodies to the TOI. + b2Shape* s1 = minContact->GetShape1(); + b2Shape* s2 = minContact->GetShape2(); + b2Body* b1 = s1->GetBody(); + b2Body* b2 = s2->GetBody(); + b1->Advance(minTOI); + b2->Advance(minTOI); + + // The TOI contact likely has some new contact points. + minContact->Update(m_contactListener); + minContact->m_flags &= ~b2Contact::e_toiFlag; + + if (minContact->GetManifoldCount() == 0) + { + // This shouldn't happen. Numerical error? + //b2Assert(false); + continue; + } + + // Build the TOI island. We need a dynamic seed. + b2Body* seed = b1; + if (seed->IsStatic()) + { + seed = b2; + } + + // Reset island and stack. + island.Clear(); + int32 stackCount = 0; + stack[stackCount++] = seed; + seed->m_flags |= b2Body::e_islandFlag; + + // Perform a depth first search (DFS) on the contact graph. + while (stackCount > 0) + { + // Grab the next body off the stack and add it to the island. + b2Body* b = stack[--stackCount]; + island.Add(b); + + // Make sure the body is awake. + b->m_flags &= ~b2Body::e_sleepFlag; + + // To keep islands as small as possible, we don't + // propagate islands across static bodies. + if (b->IsStatic()) + { + continue; + } + + // Search all contacts connected to this body. + for (b2ContactEdge* cn = b->m_contactList; cn; cn = cn->next) + { + // Does the TOI island still have space for contacts? + if (island.m_contactCount == island.m_contactCapacity) + { + continue; + } + + // Has this contact already been added to an island? Skip slow or non-solid contacts. + if (cn->contact->m_flags & (b2Contact::e_islandFlag | b2Contact::e_slowFlag | b2Contact::e_nonSolidFlag)) + { + continue; + } + + // Is this contact touching? For performance we are not updating this contact. + if (cn->contact->GetManifoldCount() == 0) + { + continue; + } + + island.Add(cn->contact); + cn->contact->m_flags |= b2Contact::e_islandFlag; + + // Update other body. + b2Body* other = cn->other; + + // Was the other body already added to this island? + if (other->m_flags & b2Body::e_islandFlag) + { + continue; + } + + // March forward, this can do no harm since this is the min TOI. + if (other->IsStatic() == false) + { + other->Advance(minTOI); + other->WakeUp(); + } + + b2Assert(stackCount < stackSize); + stack[stackCount++] = other; + other->m_flags |= b2Body::e_islandFlag; + } + } + + b2TimeStep subStep; + subStep.dt = (1.0f - minTOI) * step.dt; + b2Assert(subStep.dt > B2_FLT_EPSILON); + subStep.inv_dt = 1.0f / subStep.dt; + subStep.maxIterations = step.maxIterations; + + island.SolveTOI(subStep); + + // Post solve cleanup. + for (int32 i = 0; i < island.m_bodyCount; ++i) + { + // Allow bodies to participate in future TOI islands. + b2Body* b = island.m_bodies[i]; + b->m_flags &= ~b2Body::e_islandFlag; + + if (b->m_flags & (b2Body::e_sleepFlag | b2Body::e_frozenFlag)) + { + continue; + } + + if (b->IsStatic()) + { + continue; + } + + // Update shapes (for broad-phase). If the shapes go out of + // the world AABB then shapes and contacts may be destroyed, + // including contacts that are + bool inRange = b->SynchronizeShapes(); + + // Did the body's shapes leave the world? + if (inRange == false && m_boundaryListener != NULL) + { + m_boundaryListener->Violation(b); + } + + // Invalidate all contact TOIs associated with this body. Some of these + // may not be in the island because they were not touching. + for (b2ContactEdge* cn = b->m_contactList; cn; cn = cn->next) + { + cn->contact->m_flags &= ~b2Contact::e_toiFlag; + } + } + + for (int32 i = 0; i < island.m_contactCount; ++i) + { + // Allow contacts to participate in future TOI islands. + b2Contact* c = island.m_contacts[i]; + c->m_flags &= ~(b2Contact::e_toiFlag | b2Contact::e_islandFlag); + } + + // Commit shape proxy movements to the broad-phase so that new contacts are created. + // Also, some contacts can be destroyed. + m_broadPhase->Commit(); + } + + m_stackAllocator.Free(stack); +} + +void b2World::Step(float32 dt, int32 iterations) +{ + m_lock = true; + + b2TimeStep step; + step.dt = dt; + step.maxIterations = iterations; + if (dt > 0.0f) + { + step.inv_dt = 1.0f / dt; + } + else + { + step.inv_dt = 0.0f; + } + + step.dtRatio = m_inv_dt0 * dt; + + step.positionCorrection = m_positionCorrection; + step.warmStarting = m_warmStarting; + + // Update contacts. + m_contactManager.Collide(); + + // Integrate velocities, solve velocity constraints, and integrate positions. + if (step.dt > 0.0f) + { + Solve(step); + } + + // Handle TOI events. + if (m_continuousPhysics && step.dt > 0.0f) + { + SolveTOI(step); + } + + // Draw debug information. + DrawDebugData(); + + m_inv_dt0 = step.inv_dt; + m_lock = false; +} + +int32 b2World::Query(const b2AABB& aabb, b2Shape** shapes, int32 maxCount) +{ + void** results = (void**)m_stackAllocator.Allocate(maxCount * sizeof(void*)); + + int32 count = m_broadPhase->Query(aabb, results, maxCount); + + for (int32 i = 0; i < count; ++i) + { + shapes[i] = (b2Shape*)results[i]; + } + + m_stackAllocator.Free(results); + return count; +} + +void b2World::DrawShape(b2Shape* shape, const b2XForm& xf, const b2Color& color, bool core) +{ + b2Color coreColor(0.9f, 0.6f, 0.6f); + + switch (shape->GetType()) + { + case e_circleShape: + { + b2CircleShape* circle = (b2CircleShape*)shape; + + b2Vec2 center = b2Mul(xf, circle->GetLocalPosition()); + float32 radius = circle->GetRadius(); + b2Vec2 axis = xf.R.col1; + + m_debugDraw->DrawSolidCircle(center, radius, axis, color); + + if (core) + { + m_debugDraw->DrawCircle(center, radius - b2_toiSlop, coreColor); + } + } + break; + + case e_polygonShape: + { + b2PolygonShape* poly = (b2PolygonShape*)shape; + int32 vertexCount = poly->GetVertexCount(); + const b2Vec2* localVertices = poly->GetVertices(); + + b2Assert(vertexCount <= b2_maxPolygonVertices); + b2Vec2 vertices[b2_maxPolygonVertices]; + + for (int32 i = 0; i < vertexCount; ++i) + { + vertices[i] = b2Mul(xf, localVertices[i]); + } + + m_debugDraw->DrawSolidPolygon(vertices, vertexCount, color); + + if (core) + { + const b2Vec2* localCoreVertices = poly->GetCoreVertices(); + for (int32 i = 0; i < vertexCount; ++i) + { + vertices[i] = b2Mul(xf, localCoreVertices[i]); + } + m_debugDraw->DrawPolygon(vertices, vertexCount, coreColor); + } + } + break; + } +} + +void b2World::DrawJoint(b2Joint* joint) +{ + b2Body* b1 = joint->GetBody1(); + b2Body* b2 = joint->GetBody2(); + const b2XForm& xf1 = b1->GetXForm(); + const b2XForm& xf2 = b2->GetXForm(); + b2Vec2 x1 = xf1.position; + b2Vec2 x2 = xf2.position; + b2Vec2 p1 = joint->GetAnchor1(); + b2Vec2 p2 = joint->GetAnchor2(); + + b2Color color(0.5f, 0.8f, 0.8f); + + switch (joint->GetType()) + { + case e_distanceJoint: + m_debugDraw->DrawSegment(p1, p2, color); + break; + + case e_pulleyJoint: + { + b2PulleyJoint* pulley = (b2PulleyJoint*)joint; + b2Vec2 s1 = pulley->GetGroundAnchor1(); + b2Vec2 s2 = pulley->GetGroundAnchor2(); + m_debugDraw->DrawSegment(s1, p1, color); + m_debugDraw->DrawSegment(s2, p2, color); + m_debugDraw->DrawSegment(s1, s2, color); + } + break; + + case e_mouseJoint: + // don't draw this + break; + + default: + m_debugDraw->DrawSegment(x1, p1, color); + m_debugDraw->DrawSegment(p1, p2, color); + m_debugDraw->DrawSegment(x2, p2, color); + } +} + +void b2World::DrawDebugData() +{ + if (m_debugDraw == NULL) + { + return; + } + + uint32 flags = m_debugDraw->GetFlags(); + + if (flags & b2DebugDraw::e_shapeBit) + { + bool core = (flags & b2DebugDraw::e_coreShapeBit) == b2DebugDraw::e_coreShapeBit; + + for (b2Body* b = m_bodyList; b; b = b->GetNext()) + { + const b2XForm& xf = b->GetXForm(); + for (b2Shape* s = b->GetShapeList(); s; s = s->GetNext()) + { + if (b->IsStatic()) + { + DrawShape(s, xf, b2Color(0.5f, 0.9f, 0.5f), core); + } + else if (b->IsSleeping()) + { + DrawShape(s, xf, b2Color(0.5f, 0.5f, 0.9f), core); + } + else + { + DrawShape(s, xf, b2Color(0.9f, 0.9f, 0.9f), core); + } + } + } + } + + if (flags & b2DebugDraw::e_jointBit) + { + for (b2Joint* j = m_jointList; j; j = j->GetNext()) + { + if (j->GetType() != e_mouseJoint) + { + DrawJoint(j); + } + } + } + + if (flags & b2DebugDraw::e_pairBit) + { + b2BroadPhase* bp = m_broadPhase; + b2Vec2 invQ; + invQ.Set(1.0f / bp->m_quantizationFactor.x, 1.0f / bp->m_quantizationFactor.y); + b2Color color(0.9f, 0.9f, 0.3f); + + for (int32 i = 0; i < b2_tableCapacity; ++i) + { + uint16 index = bp->m_pairManager.m_hashTable[i]; + while (index != b2_nullPair) + { + b2Pair* pair = bp->m_pairManager.m_pairs + index; + b2Proxy* p1 = bp->m_proxyPool + pair->proxyId1; + b2Proxy* p2 = bp->m_proxyPool + pair->proxyId2; + + b2AABB b1, b2; + b1.lowerBound.x = bp->m_worldAABB.lowerBound.x + invQ.x * bp->m_bounds[0][p1->lowerBounds[0]].value; + b1.lowerBound.y = bp->m_worldAABB.lowerBound.y + invQ.y * bp->m_bounds[1][p1->lowerBounds[1]].value; + b1.upperBound.x = bp->m_worldAABB.lowerBound.x + invQ.x * bp->m_bounds[0][p1->upperBounds[0]].value; + b1.upperBound.y = bp->m_worldAABB.lowerBound.y + invQ.y * bp->m_bounds[1][p1->upperBounds[1]].value; + b2.lowerBound.x = bp->m_worldAABB.lowerBound.x + invQ.x * bp->m_bounds[0][p2->lowerBounds[0]].value; + b2.lowerBound.y = bp->m_worldAABB.lowerBound.y + invQ.y * bp->m_bounds[1][p2->lowerBounds[1]].value; + b2.upperBound.x = bp->m_worldAABB.lowerBound.x + invQ.x * bp->m_bounds[0][p2->upperBounds[0]].value; + b2.upperBound.y = bp->m_worldAABB.lowerBound.y + invQ.y * bp->m_bounds[1][p2->upperBounds[1]].value; + + b2Vec2 x1 = 0.5f * (b1.lowerBound + b1.upperBound); + b2Vec2 x2 = 0.5f * (b2.lowerBound + b2.upperBound); + + m_debugDraw->DrawSegment(x1, x2, color); + + index = pair->next; + } + } + } + + if (flags & b2DebugDraw::e_aabbBit) + { + b2BroadPhase* bp = m_broadPhase; + b2Vec2 worldLower = bp->m_worldAABB.lowerBound; + b2Vec2 worldUpper = bp->m_worldAABB.upperBound; + + b2Vec2 invQ; + invQ.Set(1.0f / bp->m_quantizationFactor.x, 1.0f / bp->m_quantizationFactor.y); + b2Color color(0.9f, 0.3f, 0.9f); + for (int32 i = 0; i < b2_maxProxies; ++i) + { + b2Proxy* p = bp->m_proxyPool + i; + if (p->IsValid() == false) + { + continue; + } + + b2AABB b; + b.lowerBound.x = worldLower.x + invQ.x * bp->m_bounds[0][p->lowerBounds[0]].value; + b.lowerBound.y = worldLower.y + invQ.y * bp->m_bounds[1][p->lowerBounds[1]].value; + b.upperBound.x = worldLower.x + invQ.x * bp->m_bounds[0][p->upperBounds[0]].value; + b.upperBound.y = worldLower.y + invQ.y * bp->m_bounds[1][p->upperBounds[1]].value; + + b2Vec2 vs[4]; + vs[0].Set(b.lowerBound.x, b.lowerBound.y); + vs[1].Set(b.upperBound.x, b.lowerBound.y); + vs[2].Set(b.upperBound.x, b.upperBound.y); + vs[3].Set(b.lowerBound.x, b.upperBound.y); + + m_debugDraw->DrawPolygon(vs, 4, color); + } + + b2Vec2 vs[4]; + vs[0].Set(worldLower.x, worldLower.y); + vs[1].Set(worldUpper.x, worldLower.y); + vs[2].Set(worldUpper.x, worldUpper.y); + vs[3].Set(worldLower.x, worldUpper.y); + m_debugDraw->DrawPolygon(vs, 4, b2Color(0.3f, 0.9f, 0.9f)); + } + + if (flags & b2DebugDraw::e_obbBit) + { + b2Color color(0.5f, 0.3f, 0.5f); + + for (b2Body* b = m_bodyList; b; b = b->GetNext()) + { + const b2XForm& xf = b->GetXForm(); + for (b2Shape* s = b->GetShapeList(); s; s = s->GetNext()) + { + if (s->GetType() != e_polygonShape) + { + continue; + } + + b2PolygonShape* poly = (b2PolygonShape*)s; + const b2OBB& obb = poly->GetOBB(); + b2Vec2 h = obb.extents; + b2Vec2 vs[4]; + vs[0].Set(-h.x, -h.y); + vs[1].Set( h.x, -h.y); + vs[2].Set( h.x, h.y); + vs[3].Set(-h.x, h.y); + + for (int32 i = 0; i < 4; ++i) + { + vs[i] = obb.center + b2Mul(obb.R, vs[i]); + vs[i] = b2Mul(xf, vs[i]); + } + + m_debugDraw->DrawPolygon(vs, 4, color); + } + } + } + + if (flags & b2DebugDraw::e_centerOfMassBit) + { + for (b2Body* b = m_bodyList; b; b = b->GetNext()) + { + b2XForm xf = b->GetXForm(); + xf.position = b->GetWorldCenter(); + m_debugDraw->DrawXForm(xf); + } + } +} + +void b2World::Validate() +{ + m_broadPhase->Validate(); +} + +int32 b2World::GetProxyCount() const +{ + return m_broadPhase->m_proxyCount; +} + +int32 b2World::GetPairCount() const +{ + return m_broadPhase->m_pairManager.m_pairCount; +} diff --git a/Box2D/Source/Dynamics/b2World.h b/Box2D/Source/Dynamics/b2World.h new file mode 100644 index 0000000..18fe3da --- /dev/null +++ b/Box2D/Source/Dynamics/b2World.h @@ -0,0 +1,253 @@ +/* +* Copyright (c) 2006-2007 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_WORLD_H +#define B2_WORLD_H + +#include "../Common/b2Math.h" +#include "../Common/b2BlockAllocator.h" +#include "../Common/b2StackAllocator.h" +#include "b2ContactManager.h" +#include "b2WorldCallbacks.h" + +struct b2AABB; +struct b2ShapeDef; +struct b2BodyDef; +struct b2JointDef; +class b2Body; +class b2Joint; +class b2Shape; +class b2Contact; +class b2BroadPhase; + +struct b2TimeStep +{ + float32 dt; // time step + float32 inv_dt; // inverse time step (0 if dt == 0). + float32 dtRatio; // dt * inv_dt0 + int32 maxIterations; + bool warmStarting; + bool positionCorrection; +}; + +/// The world class manages all physics entities, dynamic simulation, +/// and asynchronous queries. The world also contains efficient memory +/// management facilities. +class b2World +{ +public: + /// Construct a world object. + /// @param worldAABB a bounding box that completely encompasses all your shapes. + /// @param gravity the world gravity vector. + /// @param doSleep improve performance by not simulating inactive bodies. + b2World(const b2AABB& worldAABB, const b2Vec2& gravity, bool doSleep); + + /// Destruct the world. All physics entities are destroyed and all heap memory is released. + ~b2World(); + + /// Register a destruction listener. + void SetDestructionListener(b2DestructionListener* listener); + + /// Register a broad-phase boundary listener. + void SetBoundaryListener(b2BoundaryListener* listener); + + /// Register a contact filter to provide specific control over collision. + /// Otherwise the default filter is used (b2_defaultFilter). + void SetContactFilter(b2ContactFilter* filter); + + /// Register a contact event listener + void SetContactListener(b2ContactListener* listener); + + /// Register a routine for debug drawing. The debug draw functions are called + /// inside the b2World::Step method, so make sure your renderer is ready to + /// consume draw commands when you call Step(). + void SetDebugDraw(b2DebugDraw* debugDraw); + + /// Create a rigid body given a definition. No reference to the definition + /// is retained. + /// @warning This function is locked during callbacks. + b2Body* CreateBody(const b2BodyDef* def); + + /// Destroy a rigid body given a definition. No reference to the definition + /// is retained. This function is locked during callbacks. + /// @warning This automatically deletes all associated shapes and joints. + /// @warning This function is locked during callbacks. + void DestroyBody(b2Body* body); + + /// Create a joint to constrain bodies together. No reference to the definition + /// is retained. This may cause the connected bodies to cease colliding. + /// @warning This function is locked during callbacks. + b2Joint* CreateJoint(const b2JointDef* def); + + /// Destroy a joint. This may cause the connected bodies to begin colliding. + /// @warning This function is locked during callbacks. + void DestroyJoint(b2Joint* joint); + + /// The world provides a single static ground body with no collision shapes. + /// You can use this to simplify the creation of joints and static shapes. + b2Body* GetGroundBody(); + + /// Take a time step. This performs collision detection, integration, + /// and constraint solution. + /// @param timeStep the amount of time to simulate, this should not vary. + /// @param iterations the number of iterations to be used by the constraint solver. + void Step(float32 timeStep, int32 iterations); + + /// Query the world for all shapes that potentially overlap the + /// provided AABB. You provide a shape pointer buffer of specified + /// size. The number of shapes found is returned. + /// @param aabb the query box. + /// @param shapes a user allocated shape pointer array of size maxCount (or greater). + /// @param maxCount the capacity of the shapes array. + /// @return the number of shapes found in aabb. + int32 Query(const b2AABB& aabb, b2Shape** shapes, int32 maxCount); + + /// Get the world body list. With the returned body, use b2Body::GetNext to get + /// the next body in the world list. A NULL body indicates the end of the list. + /// @return the head of the world body list. + b2Body* GetBodyList(); + + /// Get the world joint list. With the returned joint, use b2Joint::GetNext to get + /// the next joint in the world list. A NULL joint indicates the end of the list. + /// @return the head of the world joint list. + b2Joint* GetJointList(); + + /// Re-filter a shape. This re-runs contact filtering on a shape. + void Refilter(b2Shape* shape); + + /// Enable/disable warm starting. For testing. + void SetWarmStarting(bool flag) { m_warmStarting = flag; } + + /// Enable/disable position correction. For testing. + void SetPositionCorrection(bool flag) { m_positionCorrection = flag; } + + /// Enable/disable continuous physics. For testing. + void SetContinuousPhysics(bool flag) { m_continuousPhysics = flag; } + + /// Perform validation of internal data structures. + void Validate(); + + /// Get the number of broad-phase proxies. + int32 GetProxyCount() const; + + /// Get the number of broad-phase pairs. + int32 GetPairCount() const; + + /// Get the number of bodies. + int32 GetBodyCount() const; + + /// Get the number joints. + int32 GetJointCount() const; + + /// Get the number of contacts (each may have 0 or more contact points). + int32 GetContactCount() const; + + /// Change the global gravity vector. + void SetGravity(const b2Vec2& gravity); + +private: + + friend class b2Body; + friend class b2ContactManager; + + void Solve(const b2TimeStep& step); + void SolveTOI(const b2TimeStep& step); + + void DrawJoint(b2Joint* joint); + void DrawShape(b2Shape* shape, const b2XForm& xf, const b2Color& color, bool core); + void DrawDebugData(); + + b2BlockAllocator m_blockAllocator; + b2StackAllocator m_stackAllocator; + + bool m_lock; + + b2BroadPhase* m_broadPhase; + b2ContactManager m_contactManager; + + b2Body* m_bodyList; + b2Joint* m_jointList; + + // Do not access + b2Contact* m_contactList; + + int32 m_bodyCount; + int32 m_contactCount; + int32 m_jointCount; + + b2Vec2 m_gravity; + bool m_allowSleep; + + b2Body* m_groundBody; + + b2DestructionListener* m_destructionListener; + b2BoundaryListener* m_boundaryListener; + b2ContactFilter* m_contactFilter; + b2ContactListener* m_contactListener; + b2DebugDraw* m_debugDraw; + + float32 m_inv_dt0; + + int32 m_positionIterationCount; + + // This is for debugging the solver. + bool m_positionCorrection; + + // This is for debugging the solver. + bool m_warmStarting; + + // This is for debugging the solver. + bool m_continuousPhysics; +}; + +inline b2Body* b2World::GetGroundBody() +{ + return m_groundBody; +} + +inline b2Body* b2World::GetBodyList() +{ + return m_bodyList; +} + +inline b2Joint* b2World::GetJointList() +{ + return m_jointList; +} + +inline int32 b2World::GetBodyCount() const +{ + return m_bodyCount; +} + +inline int32 b2World::GetJointCount() const +{ + return m_jointCount; +} + +inline int32 b2World::GetContactCount() const +{ + return m_contactCount; +} + +inline void b2World::SetGravity(const b2Vec2& gravity) +{ + m_gravity = gravity; +} + +#endif diff --git a/Box2D/Source/Dynamics/b2WorldCallbacks.cpp b/Box2D/Source/Dynamics/b2WorldCallbacks.cpp new file mode 100644 index 0000000..b060a28 --- /dev/null +++ b/Box2D/Source/Dynamics/b2WorldCallbacks.cpp @@ -0,0 +1,63 @@ +/* +* Copyright (c) 2006-2007 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. +*/ + +#include "b2WorldCallbacks.h" +#include "../Collision/Shapes/b2Shape.h" + +b2ContactFilter b2_defaultFilter; + +// Return true if contact calculations should be performed between these two shapes. +// If you implement your own collision filter you may want to build from this implementation. +bool b2ContactFilter::ShouldCollide(b2Shape* shape1, b2Shape* shape2) +{ + const b2FilterData& filter1 = shape1->GetFilterData(); + const b2FilterData& filter2 = shape2->GetFilterData(); + + if (filter1.groupIndex == filter2.groupIndex && filter1.groupIndex != 0) + { + return filter1.groupIndex > 0; + } + + bool collide = (filter1.maskBits & filter2.categoryBits) != 0 && (filter1.categoryBits & filter2.maskBits) != 0; + return collide; +} + +b2DebugDraw::b2DebugDraw() +{ + m_drawFlags = 0; +} + +void b2DebugDraw::SetFlags(uint32 flags) +{ + m_drawFlags = flags; +} + +uint32 b2DebugDraw::GetFlags() const +{ + return m_drawFlags; +} + +void b2DebugDraw::AppendFlags(uint32 flags) +{ + m_drawFlags |= flags; +} + +void b2DebugDraw::ClearFlags(uint32 flags) +{ + m_drawFlags &= ~flags; +} diff --git a/Box2D/Source/Dynamics/b2WorldCallbacks.h b/Box2D/Source/Dynamics/b2WorldCallbacks.h new file mode 100644 index 0000000..7684480 --- /dev/null +++ b/Box2D/Source/Dynamics/b2WorldCallbacks.h @@ -0,0 +1,172 @@ +/* +* Copyright (c) 2006-2007 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_WORLD_CALLBACKS_H +#define B2_WORLD_CALLBACKS_H + +#include "../Common/b2Settings.h" + +struct b2Vec2; +struct b2XForm; +class b2Shape; +class b2Body; +class b2Joint; +class b2Contact; +struct b2ContactPoint; +struct b2ContactResult; + +/// Joints and shapes are destroyed when their associated +/// body is destroyed. Implement this listener so that you +/// may nullify references to these joints and shapes. +class b2DestructionListener +{ +public: + virtual ~b2DestructionListener() {} + + /// Called when any joint is about to be destroyed due + /// to the destruction of one of its attached bodies. + virtual void SayGoodbye(b2Joint* joint) = 0; + + /// Called when any shape is about to be destroyed due + /// to the destruction of its parent body. + virtual void SayGoodbye(b2Shape* shape) = 0; +}; + + +/// This is called when a body's shape passes outside of the world boundary. +class b2BoundaryListener +{ +public: + virtual ~b2BoundaryListener() {} + + /// This is called for each body that leaves the world boundary. + /// @warning you can't modify the world inside this callback. + virtual void Violation(b2Body* body) = 0; +}; + + +/// Implement this class to provide collision filtering. In other words, you can implement +/// this class if you want finer control over contact creation. +class b2ContactFilter +{ +public: + virtual ~b2ContactFilter() {} + + /// Return true if contact calculations should be performed between these two shapes. + /// @warning for performance reasons this is only called when the AABBs begin to overlap. + virtual bool ShouldCollide(b2Shape* shape1, b2Shape* shape2); +}; + +/// The default contact filter. +extern b2ContactFilter b2_defaultFilter; + +/// Implement this class to get collision results. You can use these results for +/// things like sounds and game logic. You can also get contact results by +/// traversing the contact lists after the time step. However, you might miss +/// some contacts because continuous physics leads to sub-stepping. +/// Additionally you may receive multiple callbacks for the same contact in a +/// single time step. +/// You should strive to make your callbacks efficient because there may be +/// many callbacks per time step. +/// @warning The contact separation is the last computed value. +/// @warning You cannot create/destroy Box2D entities inside these callbacks. +class b2ContactListener +{ +public: + virtual ~b2ContactListener() {} + + /// Called when a contact point is added. This includes the geometry + /// and the forces. + virtual void Add(const b2ContactPoint* point) { B2_NOT_USED(point); } + + /// Called when a contact point persists. This includes the geometry + /// and the forces. + virtual void Persist(const b2ContactPoint* point) { B2_NOT_USED(point); } + + /// Called when a contact point is removed. This includes the last + /// computed geometry and forces. + virtual void Remove(const b2ContactPoint* point) { B2_NOT_USED(point); } + + /// Called after a contact point is solved. + virtual void Result(const b2ContactResult* point) { B2_NOT_USED(point); } +}; + +/// Color for debug drawing. Each value has the range [0,1]. +struct b2Color +{ + b2Color() {} + b2Color(float32 r, float32 g, float32 b) : r(r), g(g), b(b) {} + float32 r, g, b; +}; + +/// Implement and register this class with a b2World to provide debug drawing of physics +/// entities in your game. +class b2DebugDraw +{ +public: + b2DebugDraw(); + + virtual ~b2DebugDraw() {} + + enum + { + e_shapeBit = 0x0001, ///< draw shapes + e_jointBit = 0x0002, ///< draw joint connections + e_coreShapeBit = 0x0004, ///< draw core (TOI) shapes + e_aabbBit = 0x0008, ///< draw axis aligned bounding boxes + e_obbBit = 0x0010, ///< draw oriented bounding boxes + e_pairBit = 0x0020, ///< draw broad-phase pairs + e_centerOfMassBit = 0x0040, ///< draw center of mass frame + }; + + /// Set the drawing flags. + void SetFlags(uint32 flags); + + /// Get the drawing flags. + uint32 GetFlags() const; + + /// Append flags to the current flags. + void AppendFlags(uint32 flags); + + /// Clear flags from the current flags. + void ClearFlags(uint32 flags); + + /// Draw a closed polygon provided in CCW order. + virtual void DrawPolygon(const b2Vec2* vertices, int32 vertexCount, const b2Color& color) = 0; + + /// Draw a solid closed polygon provided in CCW order. + virtual void DrawSolidPolygon(const b2Vec2* vertices, int32 vertexCount, const b2Color& color) = 0; + + /// Draw a circle. + virtual void DrawCircle(const b2Vec2& center, float32 radius, const b2Color& color) = 0; + + /// Draw a solid circle. + virtual void DrawSolidCircle(const b2Vec2& center, float32 radius, const b2Vec2& axis, const b2Color& color) = 0; + + /// Draw a line segment. + virtual void DrawSegment(const b2Vec2& p1, const b2Vec2& p2, const b2Color& color) = 0; + + /// Draw a transform. Choose your own length scale. + /// @param xf a transform. + virtual void DrawXForm(const b2XForm& xf) = 0; + +protected: + uint32 m_drawFlags; +}; + +#endif diff --git a/Box2D/TODO.txt b/Box2D/TODO.txt new file mode 100644 index 0000000..45c7ca2 --- /dev/null +++ b/Box2D/TODO.txt @@ -0,0 +1,157 @@ +Version 1.0.0 +- Clamp large rotations. DONE +- Restitution. DONE +- Prismatic joint. DONE +- Limits and motors. DONE +- Handle equal limits. DONE +- Fast broadphase. DONE +- Collide connected. DONE +- Island sleeping. DONE +- Custom allocators. DONE +- Convex polygons. DONE +- Compound shapes. DONE +- Constraint graph. DONE +- Contact solver. DONE +- Joint solver. DONE +- Improved stability. DONE +- Improve contact matching. DONE +- Contact solver. DONE +- Joint solver. DONE +- Mouse picking. DONE +- SAP AABB query. DONE +- Distance joint. DONE + +Version 1.0.1 +- Joint limit bug fix. DONE + +Version 1.1.0 +- Handle dangling joint pointers. DONE +- Collision filters. DONE +- User data. DONE +- Improved API. DONE +- Orphaned mouse joint. DONE + +Version 1.2.0 +- Rename engine.lib to box2d.lib. DONE +- Code layout. DONE +- Circles. DONE + +Version 1.2.1 +- Handle proxies hitting the world boundary. DONE +- Freeze out of bounds bodies, notify user. DONE +- Handle running out of pairs. DONE + +Version 1.3.0 +- Documentation phase 1. DONE +- Add "no rotation" option to body def. DONE +- b2Settings configuration for pixel coordinates. DONE +- Slider-crank test. DONE +- Notify client when a body is frozen. DONE +- Fix collide-connected. DONE +- Fix compound polygons. DONE +- Check degenerate containment resolution. DONE (no problem found) +- Access to contacts and joints. DONE + +Version 1.4.0 +- Gear joint. DONE +- Pulley joint. DONE +- Personalize the phpbb header. DONE +- Document contacts and new joint types. DONE + +Version 1.4.1 +- Fix contact list. DONE +- Damping. DONE +- Poly-circle ids. DONE +- Improve mouse joint. DONE + +Version 1.4.2 +- Improve joint stability. DONE. + +Version 1.4.3 +- Fix thin polygon collision. DONE +- Simplify broad-phase internally. DONE +- OSX patch. DONE +- Fix compound body freezing. DONE +- Collision filter callback. DONE + +Version 2.0.0 +- Collision doesn't include any files from Dynamics. DONE +- User created shapes. DONE +- Shape ray casts. DONE +- Verify polygon convex and CCW. DONE +- Deferred body destruction is gone. DONE +- Deferred contact destruction is gone. DONE +- JointDefs in local coordinates so that save/load works with limits. DONE +- Wake up bonies on apply force/torque/impulse. DONE +- Improve polygon collision performance. DONE +- Optimal OBBs for polygons. DONE +- Debug display interface. DONE +- Access version number. DONE +- Improved TestBed camera. DONE +- Continuous physics with TOI islands. DONE +- Max velocities. DONE +- Body add/remove shape. DONE +- Damping now works better with a variable time step. DONE +- Time of Impact (TOI) callbacks. DONE +- Contact solver tweak callbacks. DONE +- Contact callbacks with impulses. DONE +- Safe contact callback example. DONE +- Draw world AABB in TestBed. DONE +- Use forces instead of impulses to handle variable time step. DONE +- Ragdoll contribution. DONE +- Car example. DONE +- Constraint graph and shapes support changes in center of mass. DONE +- Sensors with overlap report. DONE +- Doxygen. DONE +- Update manual. DONE + +Version 2.1.0 +- Meshes (segment soup). +- Ray casts. +- Wiki. DONE +- Pairs and proxies use small block allocator? +- Bounds use growable array? +- Don't sleep until position error is low? +- Allow non-solid polygon edges. +- User refilter. +- CMake. +- Kequalized crash. +- Soft distance constraint. DONE +- + +Version 2.2.0 +- Handle orphaned gear joint. +- Friction/motor joint for top down games. +- Rolling resistance for circles. +- Add comments to examples and testbed. + +Version 2.3.0 +- Convex hull tool. +- Angle joint. +- Weld joint. +- Speculative contacts. + +Version 2.4.0 +- Spline joints. +- Contact block solver. + +Version 2.5.0 +- Convex decomposition. +- Kinematic bodies. + +Version 2.6.0 +- Ropes and particles. +- Growable vertex arrays. + +Version 3+ +- Performance. +- Try position correction clamping and larger Baumgarte. +- Characters. +- Vehicles. +- Tree constraints. +- Buoyancy. +- Heightfields. +- Static point-grids. +- Revolute 3x3 effective mass. +- Use velocity lambda to control NGS clamping. +- No globals or statics. \ No newline at end of file diff --git a/Box2D/box2d.pri b/Box2D/box2d.pri new file mode 100755 index 0000000..ae17016 --- /dev/null +++ b/Box2D/box2d.pri @@ -0,0 +1,67 @@ +DEPENDPATH += $$PWD + +HEADERS += \ + Box2D/Source/Collision/b2PairManager.h \ + Box2D/Source/Collision/b2Collision.h \ + Box2D/Source/Collision/b2BroadPhase.h \ + Box2D/Source/Collision/Shapes/b2Shape.h \ + Box2D/Source/Collision/Shapes/b2PolygonShape.h \ + Box2D/Source/Collision/Shapes/b2CircleShape.h \ + Box2D/Source/Common/jtypes.h \ + Box2D/Source/Common/Fixed.h \ + Box2D/Source/Common/b2StackAllocator.h \ + Box2D/Source/Common/b2Settings.h \ + Box2D/Source/Common/b2Math.h \ + Box2D/Source/Common/b2BlockAllocator.h \ + Box2D/Source/Dynamics/b2WorldCallbacks.h \ + Box2D/Source/Dynamics/b2World.h \ + Box2D/Source/Dynamics/b2Island.h \ + Box2D/Source/Dynamics/b2ContactManager.h \ + Box2D/Source/Dynamics/b2Body.h \ + Box2D/Source/Dynamics/Contacts/b2PolyContact.h \ + Box2D/Source/Dynamics/Contacts/b2PolyAndCircleContact.h \ + Box2D/Source/Dynamics/Contacts/b2NullContact.h \ + Box2D/Source/Dynamics/Contacts/b2ContactSolver.h \ + Box2D/Source/Dynamics/Contacts/b2Contact.h \ + Box2D/Source/Dynamics/Contacts/b2CircleContact.h \ + Box2D/Source/Dynamics/Joints/b2RevoluteJoint.h \ + Box2D/Source/Dynamics/Joints/b2PulleyJoint.h \ + Box2D/Source/Dynamics/Joints/b2PrismaticJoint.h \ + Box2D/Source/Dynamics/Joints/b2MouseJoint.h \ + Box2D/Source/Dynamics/Joints/b2Joint.h \ + Box2D/Source/Dynamics/Joints/b2GearJoint.h \ + Box2D/Source/Dynamics/Joints/b2DistanceJoint.h \ + Box2D/Source/Box2D.h + +SOURCES += \ + Box2D/Source/Collision/b2TimeOfImpact.cpp \ + Box2D/Source/Collision/b2PairManager.cpp \ + Box2D/Source/Collision/b2Distance.cpp \ + Box2D/Source/Collision/b2Collision.cpp \ + Box2D/Source/Collision/b2CollidePoly.cpp \ + Box2D/Source/Collision/b2CollideCircle.cpp \ + Box2D/Source/Collision/b2BroadPhase.cpp \ + Box2D/Source/Collision/Shapes/b2Shape.cpp \ + Box2D/Source/Collision/Shapes/b2PolygonShape.cpp \ + Box2D/Source/Collision/Shapes/b2CircleShape.cpp \ + Box2D/Source/Common/b2StackAllocator.cpp \ + Box2D/Source/Common/b2Settings.cpp \ + Box2D/Source/Common/b2Math.cpp \ + Box2D/Source/Common/b2BlockAllocator.cpp \ + Box2D/Source/Dynamics/b2WorldCallbacks.cpp \ + Box2D/Source/Dynamics/b2World.cpp \ + Box2D/Source/Dynamics/b2Island.cpp \ + Box2D/Source/Dynamics/b2ContactManager.cpp \ + Box2D/Source/Dynamics/b2Body.cpp \ + Box2D/Source/Dynamics/Contacts/b2PolyContact.cpp \ + Box2D/Source/Dynamics/Contacts/b2PolyAndCircleContact.cpp \ + Box2D/Source/Dynamics/Contacts/b2ContactSolver.cpp \ + Box2D/Source/Dynamics/Contacts/b2Contact.cpp \ + Box2D/Source/Dynamics/Contacts/b2CircleContact.cpp \ + Box2D/Source/Dynamics/Joints/b2RevoluteJoint.cpp \ + Box2D/Source/Dynamics/Joints/b2PulleyJoint.cpp \ + Box2D/Source/Dynamics/Joints/b2PrismaticJoint.cpp \ + Box2D/Source/Dynamics/Joints/b2MouseJoint.cpp \ + Box2D/Source/Dynamics/Joints/b2Joint.cpp \ + Box2D/Source/Dynamics/Joints/b2GearJoint.cpp \ + Box2D/Source/Dynamics/Joints/b2DistanceJoint.cpp diff --git a/Box2D/box2d.pri~ b/Box2D/box2d.pri~ new file mode 100755 index 0000000..27dd7a4 --- /dev/null +++ b/Box2D/box2d.pri~ @@ -0,0 +1,10 @@ +DEPENDPATH += $$PWD + +HEADERS += \ + wizard/accountwizard.h \ + wizard/annuairepage.h + +SOURCES += \ + wizard/accountwizard.cpp + +FORMS += diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..67c6b15 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,18 @@ +project(maemoblok) + +cmake_minimum_required(VERSION 2.4.0) +find_package(Qt4 REQUIRED) + + +INCLUDE_DIRECTORIES( ${QT_INCLUDE_DIR} ${QT_QTCORE_INCLUDE_DIR} ${QT_QTGUI_INCLUDE_DIR}) +ADD_DEFINITIONS( ${QT_DEFINITIONS} ) + + +set(maemoblok_SRCS + main.cpp) + +add_executable(qtproject ${maemoblok_SRCS}) + +target_link_libraries(qtproject ${QT_QTCORE_LIBRARY} ${QT_QTGUI_LIBRARY}) + +add_subdirectory(Box2D) \ No newline at end of file diff --git a/athread.cpp b/athread.cpp new file mode 100644 index 0000000..9f248c5 --- /dev/null +++ b/athread.cpp @@ -0,0 +1,42 @@ +#include +#include +#include +#include + +#include "athread.h" + +aThread::aThread(QObject *parent) + : QThread(parent) +{ +} + +void aThread::run() +{ + QTimer timer; + connect(&timer, SIGNAL(timeout()), this, SLOT(updateCoords())); + timer.start(10); // 50 Hz update rate + exec(); +} + +void aThread::updateCoords() +{ + QFile file("/sys/class/i2c-adapter/i2c-3/3-001d/coord"); + if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) + return; + QTextStream in(&file); + QString data = in.readAll(); + processCoords(data); +} + +void aThread::processCoords(QString &data) +{ + QStringList data_splited = data.split(" "); + + x = data_splited[0]; + y = data_splited[1]; + z = data_splited[2]; + + emit deviceOrientation(x, y, z); +} + + diff --git a/athread.h b/athread.h new file mode 100644 index 0000000..daf556a --- /dev/null +++ b/athread.h @@ -0,0 +1,27 @@ +#ifndef ATHREAD_H +#define ATHREAD_H + +#include +#include + +class aThread : public QThread +{ + Q_OBJECT + +public: + aThread(QObject *parent = 0); + void run(); + + QString x; + QString y; + QString z; + +public slots: + void updateCoords(); + void processCoords(QString &data); + +signals: + void deviceOrientation(QString x, QString y, QString z); +}; + +#endif // ATHREAD_H diff --git a/blok.pro b/blok.pro new file mode 100644 index 0000000..2f03452 --- /dev/null +++ b/blok.pro @@ -0,0 +1,28 @@ + +QT += phonon +TARGET = blok +include (Box2D/box2d.pri) +include (blokitem/blokitem.pri) + +INCLUDEPATH += Box2D/Source/ + + +SOURCES += \ + main.cpp \ + physicsscene.cpp \ + boxitem.cpp \ + mainwindow.cpp \ + blokgameview.cpp \ + athread.cpp + + +HEADERS += \ + physicsscene.h \ + boxitem.h \ + mainwindow.h \ + blokgameview.h \ + athread.h + + +RESOURCES += \ + data/sprites.qrc diff --git a/blokgameview.cpp b/blokgameview.cpp new file mode 100644 index 0000000..a8fc521 --- /dev/null +++ b/blokgameview.cpp @@ -0,0 +1,98 @@ +#include "blokgameview.h" + +BlokGameView::BlokGameView(QWidget *parent) : + QGraphicsView(parent) +{ + + mScene = new PhysicsScene; + mWallpaperItem = new QGraphicsPixmapItem; + mGroundItem = new BoxItem(QRectF(0,430,800,50),true); + + setScene(mScene); + + + mScene->addPhysicsItem(new BoxItem(QRectF(0,0,10,480),true)); + mScene->addPhysicsItem(new BoxItem(QRectF(790,0,10,480),true)); + mScene->addPhysicsItem(new BoxItem(QRectF(0,0,800,10),true)); + mScene->addPhysicsItem(new BoxItem(QRectF(0,470,800,10),true)); + + + //Level + + + + + + + + + mScene->addItem(mWallpaperItem); + mScene->addPhysicsItem(mGroundItem); + + setWallpaper(":sprites/sky_wallpaper.png"); + setGround(":sprites/green_ground.png"); + + + + + + + + + for ( int i=0; i<5; ++i) + { + + NormalBlokItem * item =new NormalBlokItem(1,1); + item->setPos(32,i*32); + mScene->addPhysicsItem(item); + + NormalBlokItem * item2 =new NormalBlokItem(1,1); + item2->setPos(40, i*32); + mScene->addPhysicsItem(item2); + + + + } + + + +mScene->addPhysicsItem(new SolidBlokItem(2,2)); +mScene->addPhysicsItem(new SolidBlokItem(1,4)); + + + + mScene->start(); + +} + +void BlokGameView::setGround(const QString& path) +{ + mGroundItem->setBrush(QBrush(QPixmap(path))); +} + +void BlokGameView::setWallpaper(const QString& path) +{ + + mWallpaperItem->setPixmap(QPixmap(path)); + + +} + +void BlokGameView::mousePressEvent(QMouseEvent *event) +{ + + if (event->button() == Qt::RightButton) + mScene->stop(); + + else + mScene->start(); + + + +} + +void BlokGameView::loadMap(const QString& path) +{ + + +} diff --git a/blokgameview.h b/blokgameview.h new file mode 100644 index 0000000..a6c4422 --- /dev/null +++ b/blokgameview.h @@ -0,0 +1,41 @@ +#ifndef BLOKGAMEVIEW_H +#define BLOKGAMEVIEW_H + +#include +#include +#include "physicsscene.h" +#include "boxitem.h" + +#include "blokitem/chimicblokitem.h" +#include "blokitem/solidblokitem.h" +#include "blokitem/normalblokitem.h" +#include "blokitem/explodeblokitem.h" +#include "blokitem/totemblokitem.h" + + + +class BlokGameView : public QGraphicsView +{ + Q_OBJECT +public: + explicit BlokGameView(QWidget *parent = 0); +void setWallpaper(const QString& path); +void setGround(const QString& path); + +signals: + +public slots: +void loadMap(const QString& path); + + +protected: +void mousePressEvent(QMouseEvent *event); + +private: +PhysicsScene * mScene; +QGraphicsPixmapItem * mWallpaperItem; +BoxItem * mGroundItem; + +}; + +#endif // BLOKGAMEVIEW_H diff --git a/blokitem/blokitem.cpp b/blokitem/blokitem.cpp new file mode 100644 index 0000000..20a8cc5 --- /dev/null +++ b/blokitem/blokitem.cpp @@ -0,0 +1,6 @@ +#include "blokitem.h" + +BlokItem::BlokItem(int width, int height,QObject *parent): + BoxItem(QRectF(0,0,width*32,height*32)) +{ +} diff --git a/blokitem/blokitem.h b/blokitem/blokitem.h new file mode 100644 index 0000000..64a5e59 --- /dev/null +++ b/blokitem/blokitem.h @@ -0,0 +1,26 @@ +#ifndef BLOKITEM_H +#define BLOKITEM_H +#include +#include "boxitem.h" + +class BlokItem :public QObject, public BoxItem +{ + Q_OBJECT +public: + enum BlokType{NORMAL_BLOK, SOLID_BLOK, CHIMIC_BLOK, EXPLOSE_BLOK}; + Q_ENUMS(BlokType); + explicit BlokItem(int width=1, int height=1,QObject *parent = 0); + BlokType blokType(){return mBlokType;} +protected: + void setType(BlokType type){mBlokType = type;} + +signals: + +public slots: + +private: + BlokType mBlokType; + +}; + +#endif // BLOKITEM_H diff --git a/blokitem/blokitem.pri b/blokitem/blokitem.pri new file mode 100644 index 0000000..c339914 --- /dev/null +++ b/blokitem/blokitem.pri @@ -0,0 +1,17 @@ +DEPENDPATH += $$PWD + +HEADERS += \ + blokitem/blokitem.h \ + blokitem/totemblokitem.h \ + blokitem/normalblokitem.h \ + blokitem/explodeblokitem.h \ + blokitem/chimicblokitem.h \ + blokitem/solidblokitem.h + +SOURCES += \ + blokitem/blokitem.cpp \ + blokitem/totemblokitem.cpp \ + blokitem/normalblokitem.cpp \ + blokitem/explodeblokitem.cpp \ + blokitem/chimicblokitem.cpp \ + blokitem/solidblokitem.cpp diff --git a/blokitem/blokitem.pri~ b/blokitem/blokitem.pri~ new file mode 100755 index 0000000..88086e5 --- /dev/null +++ b/blokitem/blokitem.pri~ @@ -0,0 +1 @@ +DEPENDPATH += $$PWD diff --git a/blokitem/box2d.pri b/blokitem/box2d.pri new file mode 100755 index 0000000..c339914 --- /dev/null +++ b/blokitem/box2d.pri @@ -0,0 +1,17 @@ +DEPENDPATH += $$PWD + +HEADERS += \ + blokitem/blokitem.h \ + blokitem/totemblokitem.h \ + blokitem/normalblokitem.h \ + blokitem/explodeblokitem.h \ + blokitem/chimicblokitem.h \ + blokitem/solidblokitem.h + +SOURCES += \ + blokitem/blokitem.cpp \ + blokitem/totemblokitem.cpp \ + blokitem/normalblokitem.cpp \ + blokitem/explodeblokitem.cpp \ + blokitem/chimicblokitem.cpp \ + blokitem/solidblokitem.cpp diff --git a/blokitem/chimicblokitem.cpp b/blokitem/chimicblokitem.cpp new file mode 100644 index 0000000..04dbac4 --- /dev/null +++ b/blokitem/chimicblokitem.cpp @@ -0,0 +1,12 @@ +#include "chimicblokitem.h" + +ChimicBlokItem::ChimicBlokItem(int width, int height,QObject *parent) : + BlokItem(width, height,parent) +{ + + setBrush(QBrush(QPixmap(":sprites/chimic_block.png"))); + + + + +} diff --git a/blokitem/chimicblokitem.h b/blokitem/chimicblokitem.h new file mode 100644 index 0000000..46d7840 --- /dev/null +++ b/blokitem/chimicblokitem.h @@ -0,0 +1,16 @@ +#ifndef CHIMICBLOKITEM_H +#define CHIMICBLOKITEM_H +#include "blokitem.h" +class ChimicBlokItem : public BlokItem +{ + Q_OBJECT +public: + explicit ChimicBlokItem(int width=1, int height=1,QObject *parent = 0); + +signals: + +public slots: + +}; + +#endif // CHIMICBLOKITEM_H diff --git a/blokitem/explodeblokitem.cpp b/blokitem/explodeblokitem.cpp new file mode 100644 index 0000000..0bef06a --- /dev/null +++ b/blokitem/explodeblokitem.cpp @@ -0,0 +1,9 @@ +#include "explodeblokitem.h" + +ExplodeBlokItem::ExplodeBlokItem(int width, int height,QObject *parent) : + BlokItem(width,height,parent) +{ + + setBrush(QBrush(QPixmap(":sprites/explode_block.png"))); + +} diff --git a/blokitem/explodeblokitem.h b/blokitem/explodeblokitem.h new file mode 100644 index 0000000..038f23e --- /dev/null +++ b/blokitem/explodeblokitem.h @@ -0,0 +1,16 @@ +#ifndef EXPLOSEBLOKITEM_H +#define EXPLOSEBLOKITEM_H +#include "blokitem.h" +class ExplodeBlokItem : public BlokItem +{ + Q_OBJECT +public: + explicit ExplodeBlokItem(int width=1, int height=1,QObject *parent = 0); + +signals: + +public slots: + +}; + +#endif // EXPLOSEBLOKITEM_H diff --git a/blokitem/exploseblokitem.cpp b/blokitem/exploseblokitem.cpp new file mode 100644 index 0000000..0bef06a --- /dev/null +++ b/blokitem/exploseblokitem.cpp @@ -0,0 +1,9 @@ +#include "explodeblokitem.h" + +ExplodeBlokItem::ExplodeBlokItem(int width, int height,QObject *parent) : + BlokItem(width,height,parent) +{ + + setBrush(QBrush(QPixmap(":sprites/explode_block.png"))); + +} diff --git a/blokitem/exploseblokitem.h b/blokitem/exploseblokitem.h new file mode 100644 index 0000000..32b114d --- /dev/null +++ b/blokitem/exploseblokitem.h @@ -0,0 +1,16 @@ +#ifndef EXPLOSEBLOKITEM_H +#define EXPLOSEBLOKITEM_H +#include "blokitem.h" +class ExplodeBlokItem : public BlokItem +{ + Q_OBJECT +public: + explicit ExplodeBlokItem(int width=32, int height=32,QObject *parent = 0); + +signals: + +public slots: + +}; + +#endif // EXPLOSEBLOKITEM_H diff --git a/blokitem/normalblokitem.cpp b/blokitem/normalblokitem.cpp new file mode 100644 index 0000000..c15f28b --- /dev/null +++ b/blokitem/normalblokitem.cpp @@ -0,0 +1,52 @@ +#include "normalblokitem.h" +#include + +NormalBlokItem::NormalBlokItem(int width, int height,QObject *parent) : + BlokItem(width,height,parent) +{ + + mAnimationTimeLine = new QTimeLine; + mAnimationTimeLine->setFrameRange(0,10); + setBrush(QBrush(QPixmap(":sprites/normal_block.png"))); + + connect(mAnimationTimeLine,SIGNAL(frameChanged(int)),this,SLOT(anim(int))); + +} + +void NormalBlokItem::mousePressEvent(QGraphicsSceneMouseEvent *event) +{ + + + + mAnimationTimeLine->start(); + + setBrush(Qt::white); + QPen pen; + pen.setColor(Qt::transparent); + setPen(pen); + +} + +void NormalBlokItem::anim(int frame) +{ + qDebug()<<"anim"; + + QColor c= brush().color(); + int alpha = c.alpha(); + + alpha-= 255/9; + + qDebug()<(scene()); + s->world()->DestroyBody(body()); + s->removeItem(this); + return; + } + + c.setAlpha(alpha); + setBrush(QBrush(c)); + +} diff --git a/blokitem/normalblokitem.h b/blokitem/normalblokitem.h new file mode 100644 index 0000000..760721e --- /dev/null +++ b/blokitem/normalblokitem.h @@ -0,0 +1,25 @@ +#ifndef NORMALBLOKITEM_H +#define NORMALBLOKITEM_H +#include "blokitem.h" +#include +#include +#include "physicsscene.h" +class NormalBlokItem : public BlokItem +{ + Q_OBJECT +public: + explicit NormalBlokItem(int width=1, int height=1,QObject *parent = 0); + + +protected: + void mousePressEvent(QGraphicsSceneMouseEvent *event); +signals: + +public slots: +void anim(int frame); + +private: +QTimeLine *mAnimationTimeLine; +}; + +#endif // NORMALBLOKITEM_H diff --git a/blokitem/solidblokitem.cpp b/blokitem/solidblokitem.cpp new file mode 100644 index 0000000..1794d2f --- /dev/null +++ b/blokitem/solidblokitem.cpp @@ -0,0 +1,9 @@ +#include "solidblokitem.h" + +SolidBlokItem::SolidBlokItem(int width, int height,QObject * parent) + :BlokItem(width,height,parent) +{ + + setBrush(QBrush(QPixmap(":sprites/solid_block.png"))); + +} diff --git a/blokitem/solidblokitem.h b/blokitem/solidblokitem.h new file mode 100644 index 0000000..cf9e785 --- /dev/null +++ b/blokitem/solidblokitem.h @@ -0,0 +1,11 @@ +#ifndef SOLIDBLOKITEM_H +#define SOLIDBLOKITEM_H +#include "blokitem.h" + +class SolidBlokItem : public BlokItem +{ +public: + SolidBlokItem(int width=1, int height=1,QObject * parent=0); +}; + +#endif // SOLIDBLOKITEM_H diff --git a/blokitem/totemblokitem.cpp b/blokitem/totemblokitem.cpp new file mode 100644 index 0000000..3edf8c1 --- /dev/null +++ b/blokitem/totemblokitem.cpp @@ -0,0 +1,36 @@ +#include "totemblokitem.h" + +TotemBlokItem::TotemBlokItem(int width,int height,QObject *parent) : + BlokItem(width, height,parent) +{ + setTotem(YELLOW_TOTEM); + QPen pen; + pen.setColor(Qt::transparent); + setPen(pen); +} + + +void TotemBlokItem::setTotem(Totem _totem) +{ + mCurrentTotem = _totem; + + if ( mCurrentTotem == YELLOW_TOTEM) + { + setBrush(QBrush(QPixmap(":sprites/totem1_block.png"))); + } + + if ( mCurrentTotem == BLUE_TOTEM) + { + setBrush(QBrush(QPixmap(":sprites/totem2_block.png"))); + + } + + if ( mCurrentTotem == RED_TOTEM) + { + setBrush(QBrush(QPixmap(":sprites/totem3_block.png"))); + + } + + + +} diff --git a/blokitem/totemblokitem.h b/blokitem/totemblokitem.h new file mode 100644 index 0000000..fdf57ab --- /dev/null +++ b/blokitem/totemblokitem.h @@ -0,0 +1,22 @@ +#ifndef TOTEMBLOKITEM_H +#define TOTEMBLOKITEM_H +#include "blokitem.h" +class TotemBlokItem : public BlokItem +{ + Q_OBJECT +public: + enum Totem{YELLOW_TOTEM, BLUE_TOTEM, RED_TOTEM}; + Q_ENUMS (Totem); + explicit TotemBlokItem(int width=1,int height=1,QObject *parent = 0); + + void setTotem(Totem _totem); +signals: + +public slots: + +private: + Totem mCurrentTotem; + +}; + +#endif // TOTEMBLOKITEM_H diff --git a/boxitem.cpp b/boxitem.cpp new file mode 100644 index 0000000..abe327d --- /dev/null +++ b/boxitem.cpp @@ -0,0 +1,108 @@ +#include "boxitem.h" +#include +#include +#include + +#define MAEMO_WIDTH 800 +#define MAEMO_HEIGHT 480 + +#define BOX2D_WIDTH 10 +#define BOX2D_HEIGHT 6 + + +BoxItem::BoxItem(QRectF rect, bool isStatic) + :QGraphicsPolygonItem() +{ + setPolygon(QPolygonF(rect)); + mIsStatic = isStatic; + + m_body = 0; + mNeedRemoveFromWorld = false; + + +} + +BoxItem::BoxItem(QPolygonF poly, bool isStatic ) + :QGraphicsPolygonItem() +{ + setPolygon(poly); + mIsStatic = isStatic; +} + + +void BoxItem::setup(b2World *world) +{ + if ( polygon().size() > 8) + { + qDebug()<<"Error! Cannot build a physics polygon with more 8 vertex..."; + return; + } + + double angleRad = rotation() * M_PI / 180; + + + //#define MAEMO_WIDTH 800 + //#define MAEMO_HEIGHT 480 + + //#define BOX2D_WIDTH 10 + //#define BOX2D_HEIGHT 6 + + + + m_bodyDef.userData = this; + m_bodyDef.position.Set(pos().x() * 10/800, pos().y() * 6/480); + m_bodyDef.angle = angleRad; + + m_polygonDef.friction = 0.3f; + m_polygonDef.density = 1.0f; + m_polygonDef.restitution = 0.5f; + m_polygonDef.vertexCount = polygon().count() - 1; + //---CONSTRUCT A POYLGON SHAPE + int i=0; + QPolygonF poly = polygon(); + poly.remove(poly.count()-1); + foreach (QPointF p, poly) + { + m_polygonDef.vertices[i].Set(p.x()* 10/800,p.y()* 6/480); + ++i; + } + + m_body = world->CreateBody(&m_bodyDef); + m_body->CreateShape(&m_polygonDef); + if (!mIsStatic) + m_body->SetMassFromShapes(); + + +} +void BoxItem::updatePhysics() +{ + resetTransform(); + + + double factorX =BOX2D_WIDTH / MAEMO_WIDTH; + double factorY =BOX2D_HEIGHT / MAEMO_HEIGHT; + + double angleDeg = m_body->GetAngle() * 180 / M_PI; + setPos(m_body->GetPosition().x*800/10, m_body->GetPosition().y*480/6); + setRotation(angleDeg); + +} + +void BoxItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) +{ + + painter->setBrush(brush()); + painter->setPen(pen()); + painter->drawPolygon(polygon()); + + +} + +b2Body* BoxItem::body() +{ +if ( m_body == 0) + return 0; + +return m_body; + +} diff --git a/boxitem.h b/boxitem.h new file mode 100644 index 0000000..308f99d --- /dev/null +++ b/boxitem.h @@ -0,0 +1,74 @@ +#ifndef BOXITEM_H +#define BOXITEM_H + +#include +#include +#include +#include "Box2D/Source/Box2D.h" + +#define MAEMO_WIDTH 800 +#define MAEMO_HEIGHT 480 + +class BoxItem : public QGraphicsPolygonItem +{ +public: + BoxItem(QRectF rect, bool isStatic = false); + BoxItem(QPolygonF poly, bool isStatic = false); + + void setPolygonDef(b2PolygonDef p){m_polygonDef = p;} + void setBodyDef(b2BodyDef b){m_bodyDef = b;} + void initDensity(const float32 &d ){m_polygonDef.density = d;} + void initFriction(const float32 &f){m_polygonDef.friction = f;} + void initRestitution(const float32 &r){m_polygonDef.restitution = r;} + void initSensor(bool b){m_polygonDef.isSensor = b;} + void setMass(const float32 &m){m_bodyDef.massData.mass = m;} + void initLinearDamping(const float32 &l){m_bodyDef.linearDamping = l;} + void initAngularDamping(const float32 &a){m_bodyDef.angularDamping = a;} + void initCategoryBits(const uint16 &c){m_polygonDef.filter.categoryBits = c;} + void initMaskBits(const uint16 &c){m_polygonDef.filter.maskBits = c;} + void initStatic(bool isStatic=true){mIsStatic=isStatic;} + + + b2PolygonDef *polygonDef(){return &m_polygonDef;} + b2BodyDef * bodyDef(){return &m_bodyDef;} + inline const float32 &density(){return m_polygonDef.density;} + inline const float32 &friction(){return m_polygonDef.friction;} + inline const float32 &restition(){return m_polygonDef.restitution;} + inline const float32 &mass(){return m_bodyDef.massData.mass; } + inline bool isSensor(){return m_polygonDef.isSensor;} + inline const float32 &linearDamping(){return m_bodyDef.linearDamping;} + inline const float32 &angularDamping(){return m_bodyDef.angularDamping;} + inline const uint16 &categoryBits(){return m_polygonDef.filter.categoryBits;} + inline const uint16 &maskBits(){return m_polygonDef.filter.maskBits;} + + b2Body * body(); + + + + void setup(b2World *world); + void updatePhysics(); + + void removeFromWorld() + { + mNeedRemoveFromWorld = true; + } + + bool needRemoveFromWorld() + { + return mNeedRemoveFromWorld; + } + + +protected: + void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget); + +private: + b2PolygonDef m_polygonDef; + b2BodyDef m_bodyDef; + b2Body *m_body; + bool mIsStatic; + bool mNeedRemoveFromWorld; + QPixmap mPixmap; +}; + +#endif // BOXITEM_H diff --git a/data/sounds/explosion.wav b/data/sounds/explosion.wav new file mode 100644 index 0000000000000000000000000000000000000000..b8d31f7b40073b53245ac78314b05f504f6b58e7 GIT binary patch literal 184392 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 + + sprites/blue_ground.png + sprites/chimic_block.png + sprites/clanbomber.png + sprites/cloud.png + sprites/cursor.png + sprites/explode_block.png + sprites/explose.png + sprites/fire_wallpaper.png + sprites/green_ground.png + sprites/normal_block.png + sprites/red_ground.png + sprites/solid_block.png + sprites/supermario_wallpaper.png + sprites/text05.png + sprites/text06.png + sprites/text07.png + sprites/totem1_block.png + sprites/totem2_block.png + sprites/totem3_block.png + sprites/sky_wallpaper.png + sounds/explosion.wav + + diff --git a/data/sprites/.directory b/data/sprites/.directory new file mode 100644 index 0000000..9fda713 --- /dev/null +++ b/data/sprites/.directory @@ -0,0 +1,3 @@ +[Dolphin] +ShowPreview=true +Timestamp=2010,7,8,22,24,40 diff --git a/data/sprites/blue_ground.png b/data/sprites/blue_ground.png new file mode 100755 index 0000000000000000000000000000000000000000..d6bf98dbdab40c2e974e0e97dcc6bcfa95e13021 GIT binary patch literal 120556 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®sFfpW#8~11Z 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

%5gCDI;ztvl(wb;S}6ze&UCtWG%eB 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 literal 0 HcmV?d00001 diff --git a/data/sprites/clanbomber.png b/data/sprites/clanbomber.png new file mode 100644 index 0000000000000000000000000000000000000000..dac89b847f1781aba818666c67ec9fb6f27901fd GIT binary patch literal 1218 zcmV;z1U>tSP)z@;j(q!3lK=n!AY({UO#lFTB>(_`g8%^e{{R4h=>PzA zFaQARU;qF*m;eA5Z<1fdMgRZ=I7vi7RCwCGmQ6@pR}{zpj^o#ebv6dcLZgAW7?1}k z6e7XNMsQPxirYp+EOC{TK~RM3%tDh?S~pF>wu>$bWrPM7MlhvzBZ{V?0|Vly_!Toc z&l$g+xj6^!m52AuWL_Zo!;gFCySx7Y7;S89eB9O5Wt^Rzp{lA1zSCFL zTcRy-{mWk;Jbi?8Dh*fn5F!B1hvZl{ZAYm9Ek4j?hPLCB~tE8Ygk`jKQc5l z6rd4-M?){c@$oTEPEJ&N**`x&M`vdze=Z*#9mUGZ3JwnsK|!FWrw7&5CYF|#t^>G9 zEWn~XJM;GT_Q`>P0i(3ER5Q)gGNDiiV`F2;pl8G%#4IezziJ)~1}6sx2aQxJg+wBO zWHOmk%XqzBOifL}Mr`_oSSJn%*e*dJ5D4}5_8R;9`?-!>>u1nQB0;<*U>iV9P0hpp z{(iqhbM5;K`kwfmK&Ak^EiEmNDbumHxA)QJtE;QXpfch)@ePr(3!tsJx!FtR4ovlS zZEX#Cd3j(7A#g?a2p{pk765IR`xh4%oKPQa9*f1Wv$F#!yFki_0I^7g>-ts=kw)iuJVOnn$nNQ2N2j78Wx6j0`}p1M`rYnVG@j;vy<4Do|8Z#D@?+#Kzq6=d2@Uxm+%|-EL*9 zPyr|G0*JyQHdFiAf%yMdjkOsdMTnH$446bYoJe11tGO14tdg_DkzEdih&DKrW-R-5 z)6co1?t@8K>4MT+?tfj`s!cud196XLfvY297X%;2T)g;5=4#1__Cnr( zxxcK;od%!|jwYg$@DpWx^HsUQt!bL-D2~X>=if4)HuX!W^8l1Q#5Lk8Sut-DtSxC2 gv23xJB!wLG9<9r>rTZ8ppa1{>07*qoM6N<$f-OBTm;e9( literal 0 HcmV?d00001 diff --git a/data/sprites/cloud.png b/data/sprites/cloud.png new file mode 100644 index 0000000000000000000000000000000000000000..7ffc0e001fc5d20d27c2e062ccb44a19d12fb3c0 GIT binary patch literal 16971 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 KMNUMnLSTYd-cQj0 literal 0 HcmV?d00001 diff --git a/data/sprites/explode_block.png b/data/sprites/explode_block.png new file mode 100644 index 0000000000000000000000000000000000000000..e570df483fd50ebb38d8b3fc82d9c649547c7220 GIT binary patch literal 1706 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� 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 N002ovPDHLkV1lB3&BXu! literal 0 HcmV?d00001 diff --git a/data/sprites/green_ground.png b/data/sprites/green_ground.png new file mode 100755 index 0000000000000000000000000000000000000000..d289b4480ef54e1a8b8ad1d2cd6dc765f2dcad92 GIT binary patch literal 168228 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

?A+2Ezd`R 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 literal 0 HcmV?d00001 diff --git a/data/sprites/normal_block.png b/data/sprites/normal_block.png new file mode 100755 index 0000000000000000000000000000000000000000..d2e8700bf6230f4a4accb3f7fa420e816510ae27 GIT binary patch literal 3091 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 literal 0 HcmV?d00001 diff --git a/data/sprites/red_ground.png b/data/sprites/red_ground.png new file mode 100755 index 0000000000000000000000000000000000000000..96e4bf8fb5a013e50681b19a04732e2fb825a0cb GIT binary patch literal 132007 zcmX_IcQ}>r|CeNE$HB2>ZxT8vTSoTEp4nTDne0t6kC8nyvsZRHMx1nr>=`nSjI8hd z`Q!Jyx?FKCp5uA$_x*mq)-6^`Q~5q29U&GL)_qkK1syD`JK)nhSopZ$KU1#?`~SZ3 z)=`$js-1xDfG=>Z)sz*mZvXrDp}RZ{yh7liV(g8DMMU}E#~rMkTnKm(&qq~55pRz0 z4mO=oes)w2c!}0W(a1;M-PP63%?C@~%g)Nj&X)PLqt7d5WmOF=!!QyWEG%X$RfT7I z{y+7)(O#yG8KoBt8-yf=9xBl#_##|S@1!tu$=TZK8>TlKzqB}^98(*!>-h}(Vwy0g z{xZI5j8Ku_nU*ubzKOG}lfZvjz)c0$V&gE&}BboZq)hGupgsT8d++xR2C?WvHIBK@ z%eBQ4m;7Egm}M4ZWOxKf-}GJw+q01yaB@zul80QJr;?jFJj_#KVz9&P8ve`}+V`P* zb6HC9On+k{Tl6GOkue=PTZ=5vEEsO)TeNTbu8}s=ApG4jr4tWtkT|@$sR?W0*RO|e zklgqoExq(a9fCLXJ7RHF$BjCLRyj4viG|9=E=-Kr_3t!`A-FFZjdL=FNaN#Y^Ck|j zbCZ+^q6fOTs4GcugJd6%d_b)je^fF;wMj_EIzeEP5+7y{Fr-98TsgzLE*W1fKcAIr zTAc-Sjcx7x6mRXlrf!;9U0h@o9$20pBlasFXnG!*zvkf`KsO{bD+3$!G!qzHOHe3Y zcp~xCkg67m>8hLAHlpTjYBKsrjYuc#D5`&_Ui4e)Nhw7~kq6v~P!ZME+KTr%uU&G_ zJb7e8q^igxIE1l!X4R@eWm>3BNHl!L>8Qe#F+|43=Y6#MlC>ns*Ps`1>tlHI8P;HN%sI|_lsǼ{5QXl5C8xOu2-}iM_7JXgk`W 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ྫྷ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 literal 0 HcmV?d00001 diff --git a/data/sprites/solid_block.png b/data/sprites/solid_block.png new file mode 100755 index 0000000000000000000000000000000000000000..18b57c708b67749bc6f49c0fd731270643ce57be GIT binary patch literal 449 zcmeAS@N?(olHy`uVBq!ia0vp^3LwnE1|*BCs=fdz#^NA%Cx&(BWL^R}Y)RhkE)4%c zaKYZ?lYt_f1s;*b3=G`DAk4@xYmNj^kiEpy*OmPy8#602tL2;<>wrR%C9V-A&iT2y zsd*&~&PAz-C8;S2<(VZJ3hti10pX2&;y|lpJY5_^A`U12`S34om*QHUH_6SLszherUHT zn4Puuk4@fDP-4uy>DRGURcu~gjhC{{PWsBZD=p{1fm_oXgZ}#5Q0ctL;~g>ORr(>d z4&UPBP+MoGG|7V|4y)?cs6IS=JYG^SX4g581r-63FEWilt~hbJNVtSW^H-tR(HlbI zhSMgml23PZ=}MjQLjK1thUfsnQ_rtVIUdO;0Hi0$=koV#V|TmFy!dV7#cu~PsuQ-@ e8a#N*$Y7$gV&leaFI8Y*GI+ZBxvXhUkD7*#Duw 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 TPAZ9S00000NkvXXu0mjfVhIXW literal 0 HcmV?d00001 diff --git a/data/sprites/text05.png b/data/sprites/text05.png new file mode 100755 index 0000000000000000000000000000000000000000..82b41ec2e43571b19c4779c69b1dee60d4d82a09 GIT binary patch literal 3743 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 B60raP literal 0 HcmV?d00001 diff --git a/data/sprites/text07.png b/data/sprites/text07.png new file mode 100755 index 0000000000000000000000000000000000000000..f93d548a650c902aa6edd69110e7075fa2f9c055 GIT binary patch literal 3339 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 literal 0 HcmV?d00001 diff --git a/data/sprites/totem2_block.png b/data/sprites/totem2_block.png new file mode 100755 index 0000000000000000000000000000000000000000..0a21fe96e47b124c6bff34c5a35ce49b8fe2f553 GIT binary patch literal 5690 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 b&H${({S3;2F_GurPXG%OYvXD|Y}Ee&f;st@ literal 0 HcmV?d00001 diff --git a/main.cpp b/main.cpp new file mode 100644 index 0000000..d887b84 --- /dev/null +++ b/main.cpp @@ -0,0 +1,20 @@ +#include +#include +#include "mainwindow.h" +int main(int argc, char **argv) +{ + + QApplication app(argc,argv); + + + MainWindow * win = new MainWindow; + + win->show(); + + app.exec(); + + +// defined(Q_WS_MAEMO_5) + + +} diff --git a/mainwindow.cpp b/mainwindow.cpp new file mode 100644 index 0000000..349a798 --- /dev/null +++ b/mainwindow.cpp @@ -0,0 +1,14 @@ +#include "mainwindow.h" +#include +MainWindow::MainWindow(QWidget *parent) : + QMainWindow(parent) +{ + mView = new BlokGameView; + + setCentralWidget(mView); + + setFixedSize(800,480); + + showFullScreen(); +} + diff --git a/mainwindow.h b/mainwindow.h new file mode 100644 index 0000000..eaf7f99 --- /dev/null +++ b/mainwindow.h @@ -0,0 +1,25 @@ +#ifndef MAINWINDOW_H +#define MAINWINDOW_H + +#include +#include +#include "physicsscene.h" + +#include "blokgameview.h" + + +class MainWindow : public QMainWindow +{ + Q_OBJECT +public: + explicit MainWindow(QWidget *parent = 0); +signals: + +public slots: + + +private: + BlokGameView * mView; +}; + +#endif // MAINWINDOW_H diff --git a/physicsscene.cpp b/physicsscene.cpp new file mode 100644 index 0000000..2ae0578 --- /dev/null +++ b/physicsscene.cpp @@ -0,0 +1,137 @@ +#include "physicsscene.h" +#include + + +#include "athread.h" + +PhysicsScene::PhysicsScene(QObject *parent) : + QGraphicsScene(parent) +{ + mGravity= b2Vec2(0.0f,10.0f); + createWorld(); + mTimer = new QTimer; + mTimer->setInterval(20); + mTime = QTime::currentTime(); + connect(mTimer,SIGNAL(timeout()),this,SLOT(mainLoop())); + mFps = 20; + + aThread * accelerometer = new aThread(this); + connect(accelerometer,SIGNAL(deviceOrientation(QString,QString,QString)),this,SLOT(moveXYZ(QString,QString,QString))); + + + accelerometer->start(QThread::NormalPriority); +} +PhysicsScene::~PhysicsScene() +{ + + delete mWorld; +} + +void PhysicsScene::createWorld() +{ + + b2AABB worldAABB; + worldAABB.lowerBound.Set(-100.0f, -100.0f); + worldAABB.upperBound.Set(100.0f, 100.0f); + bool doSleep = false; + mWorld = new b2World(worldAABB, mGravity, doSleep); + +} +void PhysicsScene::addPhysicsItem(BoxItem * item) +{ + addItem(item); + item->setup(mWorld); + mBoxList.append(item); +} +void PhysicsScene::removePhysicsItem(BoxItem * item) +{ + mBoxList.removeOne(item); + mWorld->DestroyBody(item->body()); + removeItem(item); + +} + +void PhysicsScene::computeSimulation(int32 iterations) +{ + + double R = mFps/1000; + + float32 timeStep = R; + mWorld->Step(timeStep, iterations); + + b2Body* node = mWorld->GetBodyList(); + while (node) + { + b2Body* b = node; + node = node->GetNext(); + + if ( b->GetUserData()!=NULL) + { + // qDebug()<<"positionx:"<GetPosition().x; + // q#include +//qDebug()<<"positiony:"<GetPosition().y; + + + BoxItem* item = (BoxItem*)b->GetUserData(); + if (!item->needRemoveFromWorld()) + item->updatePhysics(); + + else + { + mWorld->DestroyBody(item->body()); + } + + } + } +} + +void PhysicsScene::keyPressEvent(QKeyEvent *event) +{ + qDebug()<<"key press"; + + computeSimulation(); + +} + +void PhysicsScene::mainLoop() +{ + mFps = mTime.elapsed(); + mTime = QTime::currentTime(); + + computeSimulation(); + + +} + +void PhysicsScene::start() +{ + mTimer->start(); +} + +void PhysicsScene::stop() +{ + + + + + + mTimer->stop(); + +} + +void PhysicsScene::moveXYZ(QString x, QString y, QString z) +{ +#if defined(Q_WS_MAEMO_5) + + + + + + mWorld->SetGravity(b2Vec2(-x.toDouble()/10, -y.toDouble() / 10)); + +#endif + + } + + + diff --git a/physicsscene.h b/physicsscene.h new file mode 100644 index 0000000..b812c2d --- /dev/null +++ b/physicsscene.h @@ -0,0 +1,51 @@ +#ifndef PHYSICSSCENE_H +#define PHYSICSSCENE_H + +#include +#include +#include +#include +#include + +#include "Box2D/Source/Box2D.h" + +#include "boxitem.h" + +#include +class PhysicsScene : public QGraphicsScene +{ + Q_OBJECT +public: + explicit PhysicsScene(QObject *parent = 0); + ~PhysicsScene(); + void createWorld(); + void addPhysicsItem(BoxItem * item); + void removePhysicsItem(BoxItem * item); + void start(); + void stop(); + b2World * world(){return mWorld;} + +signals: + +public slots: + virtual void mainLoop(); + void moveXYZ(QString x, QString y, QString z); + +protected: + void keyPressEvent(QKeyEvent *event); + void computeSimulation(int32 iterations = 10); + +private: + b2World *mWorld; + b2Vec2 mGravity; + QTimer* mTimer; + QTime mTime; + double mFps; + QList mBoxList; + + BoxItem * ground; + + +}; + +#endif // PHYSICSSCENE_H diff --git a/totemblokitem.cpp b/totemblokitem.cpp new file mode 100644 index 0000000..73d36a7 --- /dev/null +++ b/totemblokitem.cpp @@ -0,0 +1,33 @@ +#include "totemblokitem.h" + +TotemBlokItem::TotemBlokItem(int width,int height,QObject *parent) : + BlokItem(width, height,parent) +{ + setTotem(YELLOW_TOTEM); +} + + +void TotemBlokItem::setTotem(Totem _totem) +{ + mCurrentTotem = _totem; + + if ( mCurrentTotem == YELLOW_TOTEM) + { + setBrush(QBrush(QPixmap(":sprites/totem1_block.png"))); + } + + if ( mCurrentTotem == BLUE_TOTEM) + { + setBrush(QBrush(QPixmap(":sprites/totem2_block.png"))); + + } + + if ( mCurrentTotem == RED_TOTEM) + { + setBrush(QBrush(QPixmap(":sprites/totem3_block.png"))); + + } + + + +} diff --git a/totemblokitem.h b/totemblokitem.h new file mode 100644 index 0000000..70c9bbe --- /dev/null +++ b/totemblokitem.h @@ -0,0 +1,22 @@ +#ifndef TOTEMBLOKITEM_H +#define TOTEMBLOKITEM_H +#include "blokitem.h" +class TotemBlokItem : public BlokItem +{ + Q_OBJECT +public: + enum Totem{YELLOW_TOTEM, BLUE_TOTEM, RED_TOTEM}; + Q_ENUMS (Totem); + explicit TotemBlokItem(int width=64,int height=64,QObject *parent = 0); + + void setTotem(Totem _totem); +signals: + +public slots: + +private: + Totem mCurrentTotem; + +}; + +#endif // TOTEMBLOKITEM_H -- 1.7.9.5