migrating to the latest JUCE version
This commit is contained in:
Nikolai Rodionov
@@ -1,54 +1,54 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2010 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "b2ChainAndCircleContact.h"
|
||||
#include "../../Common/b2BlockAllocator.h"
|
||||
#include "../b2Fixture.h"
|
||||
#include "../../Collision/Shapes/b2ChainShape.h"
|
||||
#include "../../Collision/Shapes/b2EdgeShape.h"
|
||||
|
||||
#include <new>
|
||||
using namespace std;
|
||||
|
||||
b2Contact* b2ChainAndCircleContact::Create(b2Fixture* fixtureA, int32 indexA, b2Fixture* fixtureB, int32 indexB, b2BlockAllocator* allocator)
|
||||
{
|
||||
void* mem = allocator->Allocate(sizeof(b2ChainAndCircleContact));
|
||||
return new (mem) b2ChainAndCircleContact(fixtureA, indexA, fixtureB, indexB);
|
||||
}
|
||||
|
||||
void b2ChainAndCircleContact::Destroy(b2Contact* contact, b2BlockAllocator* allocator)
|
||||
{
|
||||
((b2ChainAndCircleContact*)contact)->~b2ChainAndCircleContact();
|
||||
allocator->Free(contact, sizeof(b2ChainAndCircleContact));
|
||||
}
|
||||
|
||||
b2ChainAndCircleContact::b2ChainAndCircleContact(b2Fixture* fixtureA, int32 indexA, b2Fixture* fixtureB, int32 indexB)
|
||||
: b2Contact(fixtureA, indexA, fixtureB, indexB)
|
||||
{
|
||||
b2Assert(m_fixtureA->GetType() == b2Shape::e_chain);
|
||||
b2Assert(m_fixtureB->GetType() == b2Shape::e_circle);
|
||||
}
|
||||
|
||||
void b2ChainAndCircleContact::Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB)
|
||||
{
|
||||
b2ChainShape* chain = (b2ChainShape*)m_fixtureA->GetShape();
|
||||
b2EdgeShape edge;
|
||||
chain->GetChildEdge(&edge, m_indexA);
|
||||
b2CollideEdgeAndCircle( manifold, &edge, xfA,
|
||||
(b2CircleShape*)m_fixtureB->GetShape(), xfB);
|
||||
}
|
||||
/*
|
||||
* Copyright (c) 2006-2010 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "b2ChainAndCircleContact.h"
|
||||
#include "../../Common/b2BlockAllocator.h"
|
||||
#include "../b2Fixture.h"
|
||||
#include "../../Collision/Shapes/b2ChainShape.h"
|
||||
#include "../../Collision/Shapes/b2EdgeShape.h"
|
||||
|
||||
#include <new>
|
||||
using namespace std;
|
||||
|
||||
b2Contact* b2ChainAndCircleContact::Create(b2Fixture* fixtureA, int32 indexA, b2Fixture* fixtureB, int32 indexB, b2BlockAllocator* allocator)
|
||||
{
|
||||
void* mem = allocator->Allocate(sizeof(b2ChainAndCircleContact));
|
||||
return new (mem) b2ChainAndCircleContact(fixtureA, indexA, fixtureB, indexB);
|
||||
}
|
||||
|
||||
void b2ChainAndCircleContact::Destroy(b2Contact* contact, b2BlockAllocator* allocator)
|
||||
{
|
||||
((b2ChainAndCircleContact*)contact)->~b2ChainAndCircleContact();
|
||||
allocator->Free(contact, sizeof(b2ChainAndCircleContact));
|
||||
}
|
||||
|
||||
b2ChainAndCircleContact::b2ChainAndCircleContact(b2Fixture* fixtureA, int32 indexA, b2Fixture* fixtureB, int32 indexB)
|
||||
: b2Contact(fixtureA, indexA, fixtureB, indexB)
|
||||
{
|
||||
b2Assert(m_fixtureA->GetType() == b2Shape::e_chain);
|
||||
b2Assert(m_fixtureB->GetType() == b2Shape::e_circle);
|
||||
}
|
||||
|
||||
void b2ChainAndCircleContact::Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB)
|
||||
{
|
||||
b2ChainShape* chain = (b2ChainShape*)m_fixtureA->GetShape();
|
||||
b2EdgeShape edge;
|
||||
chain->GetChildEdge(&edge, m_indexA);
|
||||
b2CollideEdgeAndCircle( manifold, &edge, xfA,
|
||||
(b2CircleShape*)m_fixtureB->GetShape(), xfB);
|
||||
}
|
||||
|
||||
@@ -1,39 +1,39 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_CHAIN_AND_CIRCLE_CONTACT_H
|
||||
#define B2_CHAIN_AND_CIRCLE_CONTACT_H
|
||||
|
||||
#include "b2Contact.h"
|
||||
|
||||
class b2BlockAllocator;
|
||||
|
||||
class b2ChainAndCircleContact : public b2Contact
|
||||
{
|
||||
public:
|
||||
static b2Contact* Create( b2Fixture* fixtureA, int32 indexA,
|
||||
b2Fixture* fixtureB, int32 indexB, b2BlockAllocator* allocator);
|
||||
static void Destroy(b2Contact* contact, b2BlockAllocator* allocator);
|
||||
|
||||
b2ChainAndCircleContact(b2Fixture* fixtureA, int32 indexA, b2Fixture* fixtureB, int32 indexB);
|
||||
~b2ChainAndCircleContact() {}
|
||||
|
||||
void Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB);
|
||||
};
|
||||
|
||||
#endif
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_CHAIN_AND_CIRCLE_CONTACT_H
|
||||
#define B2_CHAIN_AND_CIRCLE_CONTACT_H
|
||||
|
||||
#include "b2Contact.h"
|
||||
|
||||
class b2BlockAllocator;
|
||||
|
||||
class b2ChainAndCircleContact : public b2Contact
|
||||
{
|
||||
public:
|
||||
static b2Contact* Create( b2Fixture* fixtureA, int32 indexA,
|
||||
b2Fixture* fixtureB, int32 indexB, b2BlockAllocator* allocator);
|
||||
static void Destroy(b2Contact* contact, b2BlockAllocator* allocator);
|
||||
|
||||
b2ChainAndCircleContact(b2Fixture* fixtureA, int32 indexA, b2Fixture* fixtureB, int32 indexB);
|
||||
~b2ChainAndCircleContact() {}
|
||||
|
||||
void Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,54 +1,54 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2010 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "b2ChainAndPolygonContact.h"
|
||||
#include "../../Common/b2BlockAllocator.h"
|
||||
#include "../b2Fixture.h"
|
||||
#include "../../Collision/Shapes/b2ChainShape.h"
|
||||
#include "../../Collision/Shapes/b2EdgeShape.h"
|
||||
|
||||
#include <new>
|
||||
using namespace std;
|
||||
|
||||
b2Contact* b2ChainAndPolygonContact::Create(b2Fixture* fixtureA, int32 indexA, b2Fixture* fixtureB, int32 indexB, b2BlockAllocator* allocator)
|
||||
{
|
||||
void* mem = allocator->Allocate(sizeof(b2ChainAndPolygonContact));
|
||||
return new (mem) b2ChainAndPolygonContact(fixtureA, indexA, fixtureB, indexB);
|
||||
}
|
||||
|
||||
void b2ChainAndPolygonContact::Destroy(b2Contact* contact, b2BlockAllocator* allocator)
|
||||
{
|
||||
((b2ChainAndPolygonContact*)contact)->~b2ChainAndPolygonContact();
|
||||
allocator->Free(contact, sizeof(b2ChainAndPolygonContact));
|
||||
}
|
||||
|
||||
b2ChainAndPolygonContact::b2ChainAndPolygonContact(b2Fixture* fixtureA, int32 indexA, b2Fixture* fixtureB, int32 indexB)
|
||||
: b2Contact(fixtureA, indexA, fixtureB, indexB)
|
||||
{
|
||||
b2Assert(m_fixtureA->GetType() == b2Shape::e_chain);
|
||||
b2Assert(m_fixtureB->GetType() == b2Shape::e_polygon);
|
||||
}
|
||||
|
||||
void b2ChainAndPolygonContact::Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB)
|
||||
{
|
||||
b2ChainShape* chain = (b2ChainShape*)m_fixtureA->GetShape();
|
||||
b2EdgeShape edge;
|
||||
chain->GetChildEdge(&edge, m_indexA);
|
||||
b2CollideEdgeAndPolygon( manifold, &edge, xfA,
|
||||
(b2PolygonShape*)m_fixtureB->GetShape(), xfB);
|
||||
}
|
||||
/*
|
||||
* Copyright (c) 2006-2010 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "b2ChainAndPolygonContact.h"
|
||||
#include "../../Common/b2BlockAllocator.h"
|
||||
#include "../b2Fixture.h"
|
||||
#include "../../Collision/Shapes/b2ChainShape.h"
|
||||
#include "../../Collision/Shapes/b2EdgeShape.h"
|
||||
|
||||
#include <new>
|
||||
using namespace std;
|
||||
|
||||
b2Contact* b2ChainAndPolygonContact::Create(b2Fixture* fixtureA, int32 indexA, b2Fixture* fixtureB, int32 indexB, b2BlockAllocator* allocator)
|
||||
{
|
||||
void* mem = allocator->Allocate(sizeof(b2ChainAndPolygonContact));
|
||||
return new (mem) b2ChainAndPolygonContact(fixtureA, indexA, fixtureB, indexB);
|
||||
}
|
||||
|
||||
void b2ChainAndPolygonContact::Destroy(b2Contact* contact, b2BlockAllocator* allocator)
|
||||
{
|
||||
((b2ChainAndPolygonContact*)contact)->~b2ChainAndPolygonContact();
|
||||
allocator->Free(contact, sizeof(b2ChainAndPolygonContact));
|
||||
}
|
||||
|
||||
b2ChainAndPolygonContact::b2ChainAndPolygonContact(b2Fixture* fixtureA, int32 indexA, b2Fixture* fixtureB, int32 indexB)
|
||||
: b2Contact(fixtureA, indexA, fixtureB, indexB)
|
||||
{
|
||||
b2Assert(m_fixtureA->GetType() == b2Shape::e_chain);
|
||||
b2Assert(m_fixtureB->GetType() == b2Shape::e_polygon);
|
||||
}
|
||||
|
||||
void b2ChainAndPolygonContact::Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB)
|
||||
{
|
||||
b2ChainShape* chain = (b2ChainShape*)m_fixtureA->GetShape();
|
||||
b2EdgeShape edge;
|
||||
chain->GetChildEdge(&edge, m_indexA);
|
||||
b2CollideEdgeAndPolygon( manifold, &edge, xfA,
|
||||
(b2PolygonShape*)m_fixtureB->GetShape(), xfB);
|
||||
}
|
||||
|
||||
@@ -1,39 +1,39 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_CHAIN_AND_POLYGON_CONTACT_H
|
||||
#define B2_CHAIN_AND_POLYGON_CONTACT_H
|
||||
|
||||
#include "b2Contact.h"
|
||||
|
||||
class b2BlockAllocator;
|
||||
|
||||
class b2ChainAndPolygonContact : public b2Contact
|
||||
{
|
||||
public:
|
||||
static b2Contact* Create( b2Fixture* fixtureA, int32 indexA,
|
||||
b2Fixture* fixtureB, int32 indexB, b2BlockAllocator* allocator);
|
||||
static void Destroy(b2Contact* contact, b2BlockAllocator* allocator);
|
||||
|
||||
b2ChainAndPolygonContact(b2Fixture* fixtureA, int32 indexA, b2Fixture* fixtureB, int32 indexB);
|
||||
~b2ChainAndPolygonContact() {}
|
||||
|
||||
void Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB);
|
||||
};
|
||||
|
||||
#endif
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_CHAIN_AND_POLYGON_CONTACT_H
|
||||
#define B2_CHAIN_AND_POLYGON_CONTACT_H
|
||||
|
||||
#include "b2Contact.h"
|
||||
|
||||
class b2BlockAllocator;
|
||||
|
||||
class b2ChainAndPolygonContact : public b2Contact
|
||||
{
|
||||
public:
|
||||
static b2Contact* Create( b2Fixture* fixtureA, int32 indexA,
|
||||
b2Fixture* fixtureB, int32 indexB, b2BlockAllocator* allocator);
|
||||
static void Destroy(b2Contact* contact, b2BlockAllocator* allocator);
|
||||
|
||||
b2ChainAndPolygonContact(b2Fixture* fixtureA, int32 indexA, b2Fixture* fixtureB, int32 indexB);
|
||||
~b2ChainAndPolygonContact() {}
|
||||
|
||||
void Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,53 +1,53 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "../b2Fixture.h"
|
||||
#include "../b2WorldCallbacks.h"
|
||||
#include "../../Common/b2BlockAllocator.h"
|
||||
#include "../../Collision/b2TimeOfImpact.h"
|
||||
|
||||
#include <new>
|
||||
using namespace std;
|
||||
|
||||
b2Contact* b2CircleContact::Create(b2Fixture* fixtureA, int32, b2Fixture* fixtureB, int32, b2BlockAllocator* allocator)
|
||||
{
|
||||
void* mem = allocator->Allocate(sizeof(b2CircleContact));
|
||||
return new (mem) b2CircleContact(fixtureA, fixtureB);
|
||||
}
|
||||
|
||||
void b2CircleContact::Destroy(b2Contact* contact, b2BlockAllocator* allocator)
|
||||
{
|
||||
((b2CircleContact*)contact)->~b2CircleContact();
|
||||
allocator->Free(contact, sizeof(b2CircleContact));
|
||||
}
|
||||
|
||||
b2CircleContact::b2CircleContact(b2Fixture* fixtureA, b2Fixture* fixtureB)
|
||||
: b2Contact(fixtureA, 0, fixtureB, 0)
|
||||
{
|
||||
b2Assert(m_fixtureA->GetType() == b2Shape::e_circle);
|
||||
b2Assert(m_fixtureB->GetType() == b2Shape::e_circle);
|
||||
}
|
||||
|
||||
void b2CircleContact::Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB)
|
||||
{
|
||||
b2CollideCircles(manifold,
|
||||
(b2CircleShape*)m_fixtureA->GetShape(), xfA,
|
||||
(b2CircleShape*)m_fixtureB->GetShape(), xfB);
|
||||
}
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "../b2Fixture.h"
|
||||
#include "../b2WorldCallbacks.h"
|
||||
#include "../../Common/b2BlockAllocator.h"
|
||||
#include "../../Collision/b2TimeOfImpact.h"
|
||||
|
||||
#include <new>
|
||||
using namespace std;
|
||||
|
||||
b2Contact* b2CircleContact::Create(b2Fixture* fixtureA, int32, b2Fixture* fixtureB, int32, b2BlockAllocator* allocator)
|
||||
{
|
||||
void* mem = allocator->Allocate(sizeof(b2CircleContact));
|
||||
return new (mem) b2CircleContact(fixtureA, fixtureB);
|
||||
}
|
||||
|
||||
void b2CircleContact::Destroy(b2Contact* contact, b2BlockAllocator* allocator)
|
||||
{
|
||||
((b2CircleContact*)contact)->~b2CircleContact();
|
||||
allocator->Free(contact, sizeof(b2CircleContact));
|
||||
}
|
||||
|
||||
b2CircleContact::b2CircleContact(b2Fixture* fixtureA, b2Fixture* fixtureB)
|
||||
: b2Contact(fixtureA, 0, fixtureB, 0)
|
||||
{
|
||||
b2Assert(m_fixtureA->GetType() == b2Shape::e_circle);
|
||||
b2Assert(m_fixtureB->GetType() == b2Shape::e_circle);
|
||||
}
|
||||
|
||||
void b2CircleContact::Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB)
|
||||
{
|
||||
b2CollideCircles(manifold,
|
||||
(b2CircleShape*)m_fixtureA->GetShape(), xfA,
|
||||
(b2CircleShape*)m_fixtureB->GetShape(), xfB);
|
||||
}
|
||||
|
||||
@@ -1,39 +1,39 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_CONTACT_H
|
||||
#define B2_CIRCLE_CONTACT_H
|
||||
|
||||
#include "b2Contact.h"
|
||||
|
||||
class b2BlockAllocator;
|
||||
|
||||
class b2CircleContact : public b2Contact
|
||||
{
|
||||
public:
|
||||
static b2Contact* Create( b2Fixture* fixtureA, int32 indexA,
|
||||
b2Fixture* fixtureB, int32 indexB, b2BlockAllocator* allocator);
|
||||
static void Destroy(b2Contact* contact, b2BlockAllocator* allocator);
|
||||
|
||||
b2CircleContact(b2Fixture* fixtureA, b2Fixture* fixtureB);
|
||||
~b2CircleContact() {}
|
||||
|
||||
void Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB);
|
||||
};
|
||||
|
||||
#endif
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_CONTACT_H
|
||||
#define B2_CIRCLE_CONTACT_H
|
||||
|
||||
#include "b2Contact.h"
|
||||
|
||||
class b2BlockAllocator;
|
||||
|
||||
class b2CircleContact : public b2Contact
|
||||
{
|
||||
public:
|
||||
static b2Contact* Create( b2Fixture* fixtureA, int32 indexA,
|
||||
b2Fixture* fixtureB, int32 indexB, b2BlockAllocator* allocator);
|
||||
static void Destroy(b2Contact* contact, b2BlockAllocator* allocator);
|
||||
|
||||
b2CircleContact(b2Fixture* fixtureA, b2Fixture* fixtureB);
|
||||
~b2CircleContact() {}
|
||||
|
||||
void Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,240 +1,240 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "b2PolygonAndCircleContact.h"
|
||||
#include "b2PolygonContact.h"
|
||||
#include "b2EdgeAndCircleContact.h"
|
||||
#include "b2EdgeAndPolygonContact.h"
|
||||
#include "b2ChainAndCircleContact.h"
|
||||
#include "b2ChainAndPolygonContact.h"
|
||||
#include "b2ContactSolver.h"
|
||||
|
||||
#include "../../Collision/b2Collision.h"
|
||||
#include "../../Collision/b2TimeOfImpact.h"
|
||||
#include "../../Collision/Shapes/b2Shape.h"
|
||||
#include "../../Common/b2BlockAllocator.h"
|
||||
#include "../b2Body.h"
|
||||
#include "../b2Fixture.h"
|
||||
#include "../b2World.h"
|
||||
|
||||
b2ContactRegister b2Contact::s_registers[b2Shape::e_typeCount][b2Shape::e_typeCount];
|
||||
bool b2Contact::s_initialized = false;
|
||||
|
||||
void b2Contact::InitializeRegisters()
|
||||
{
|
||||
AddType(b2CircleContact::Create, b2CircleContact::Destroy, b2Shape::e_circle, b2Shape::e_circle);
|
||||
AddType(b2PolygonAndCircleContact::Create, b2PolygonAndCircleContact::Destroy, b2Shape::e_polygon, b2Shape::e_circle);
|
||||
AddType(b2PolygonContact::Create, b2PolygonContact::Destroy, b2Shape::e_polygon, b2Shape::e_polygon);
|
||||
AddType(b2EdgeAndCircleContact::Create, b2EdgeAndCircleContact::Destroy, b2Shape::e_edge, b2Shape::e_circle);
|
||||
AddType(b2EdgeAndPolygonContact::Create, b2EdgeAndPolygonContact::Destroy, b2Shape::e_edge, b2Shape::e_polygon);
|
||||
AddType(b2ChainAndCircleContact::Create, b2ChainAndCircleContact::Destroy, b2Shape::e_chain, b2Shape::e_circle);
|
||||
AddType(b2ChainAndPolygonContact::Create, b2ChainAndPolygonContact::Destroy, b2Shape::e_chain, b2Shape::e_polygon);
|
||||
}
|
||||
|
||||
void b2Contact::AddType(b2ContactCreateFcn* createFcn, b2ContactDestroyFcn* destoryFcn,
|
||||
b2Shape::Type type1, b2Shape::Type type2)
|
||||
{
|
||||
b2Assert(0 <= type1 && type1 < b2Shape::e_typeCount);
|
||||
b2Assert(0 <= type2 && type2 < b2Shape::e_typeCount);
|
||||
|
||||
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(b2Fixture* fixtureA, int32 indexA, b2Fixture* fixtureB, int32 indexB, b2BlockAllocator* allocator)
|
||||
{
|
||||
if (s_initialized == false)
|
||||
{
|
||||
InitializeRegisters();
|
||||
s_initialized = true;
|
||||
}
|
||||
|
||||
b2Shape::Type type1 = fixtureA->GetType();
|
||||
b2Shape::Type type2 = fixtureB->GetType();
|
||||
|
||||
b2Assert(0 <= type1 && type1 < b2Shape::e_typeCount);
|
||||
b2Assert(0 <= type2 && type2 < b2Shape::e_typeCount);
|
||||
|
||||
b2ContactCreateFcn* createFcn = s_registers[type1][type2].createFcn;
|
||||
if (createFcn)
|
||||
{
|
||||
if (s_registers[type1][type2].primary)
|
||||
{
|
||||
return createFcn(fixtureA, indexA, fixtureB, indexB, allocator);
|
||||
}
|
||||
else
|
||||
{
|
||||
return createFcn(fixtureB, indexB, fixtureA, indexA, allocator);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
void b2Contact::Destroy(b2Contact* contact, b2BlockAllocator* allocator)
|
||||
{
|
||||
b2Assert(s_initialized == true);
|
||||
|
||||
if (contact->m_manifold.pointCount > 0)
|
||||
{
|
||||
contact->GetFixtureA()->GetBody()->SetAwake(true);
|
||||
contact->GetFixtureB()->GetBody()->SetAwake(true);
|
||||
}
|
||||
|
||||
b2Shape::Type typeA = contact->GetFixtureA()->GetType();
|
||||
b2Shape::Type typeB = contact->GetFixtureB()->GetType();
|
||||
|
||||
b2Assert(0 <= typeA && typeB < b2Shape::e_typeCount);
|
||||
b2Assert(0 <= typeA && typeB < b2Shape::e_typeCount);
|
||||
|
||||
b2ContactDestroyFcn* destroyFcn = s_registers[typeA][typeB].destroyFcn;
|
||||
destroyFcn(contact, allocator);
|
||||
}
|
||||
|
||||
b2Contact::b2Contact(b2Fixture* fA, int32 indexA, b2Fixture* fB, int32 indexB)
|
||||
{
|
||||
m_flags = e_enabledFlag;
|
||||
|
||||
m_fixtureA = fA;
|
||||
m_fixtureB = fB;
|
||||
|
||||
m_indexA = indexA;
|
||||
m_indexB = indexB;
|
||||
|
||||
m_manifold.pointCount = 0;
|
||||
|
||||
m_prev = NULL;
|
||||
m_next = NULL;
|
||||
|
||||
m_nodeA.contact = NULL;
|
||||
m_nodeA.prev = NULL;
|
||||
m_nodeA.next = NULL;
|
||||
m_nodeA.other = NULL;
|
||||
|
||||
m_nodeB.contact = NULL;
|
||||
m_nodeB.prev = NULL;
|
||||
m_nodeB.next = NULL;
|
||||
m_nodeB.other = NULL;
|
||||
|
||||
m_toiCount = 0;
|
||||
|
||||
m_friction = b2MixFriction(m_fixtureA->m_friction, m_fixtureB->m_friction);
|
||||
m_restitution = b2MixRestitution(m_fixtureA->m_restitution, m_fixtureB->m_restitution);
|
||||
}
|
||||
|
||||
// Update the contact manifold and touching status.
|
||||
// Note: do not assume the fixture AABBs are overlapping or are valid.
|
||||
void b2Contact::Update(b2ContactListener* listener)
|
||||
{
|
||||
b2Manifold oldManifold = m_manifold;
|
||||
|
||||
// Re-enable this contact.
|
||||
m_flags |= e_enabledFlag;
|
||||
|
||||
bool touching = false;
|
||||
bool wasTouching = (m_flags & e_touchingFlag) == e_touchingFlag;
|
||||
|
||||
bool sensorA = m_fixtureA->IsSensor();
|
||||
bool sensorB = m_fixtureB->IsSensor();
|
||||
bool sensor = sensorA || sensorB;
|
||||
|
||||
b2Body* bodyA = m_fixtureA->GetBody();
|
||||
b2Body* bodyB = m_fixtureB->GetBody();
|
||||
const b2Transform& xfA = bodyA->GetTransform();
|
||||
const b2Transform& xfB = bodyB->GetTransform();
|
||||
|
||||
// Is this contact a sensor?
|
||||
if (sensor)
|
||||
{
|
||||
const b2Shape* shapeA = m_fixtureA->GetShape();
|
||||
const b2Shape* shapeB = m_fixtureB->GetShape();
|
||||
touching = b2TestOverlap(shapeA, m_indexA, shapeB, m_indexB, xfA, xfB);
|
||||
|
||||
// Sensors don't generate manifolds.
|
||||
m_manifold.pointCount = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
Evaluate(&m_manifold, xfA, xfB);
|
||||
touching = 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* mp2 = m_manifold.points + i;
|
||||
mp2->normalImpulse = 0.0f;
|
||||
mp2->tangentImpulse = 0.0f;
|
||||
b2ContactID id2 = mp2->id;
|
||||
|
||||
for (int32 j = 0; j < oldManifold.pointCount; ++j)
|
||||
{
|
||||
b2ManifoldPoint* mp1 = oldManifold.points + j;
|
||||
|
||||
if (mp1->id.key == id2.key)
|
||||
{
|
||||
mp2->normalImpulse = mp1->normalImpulse;
|
||||
mp2->tangentImpulse = mp1->tangentImpulse;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (touching != wasTouching)
|
||||
{
|
||||
bodyA->SetAwake(true);
|
||||
bodyB->SetAwake(true);
|
||||
}
|
||||
}
|
||||
|
||||
if (touching)
|
||||
{
|
||||
m_flags |= e_touchingFlag;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_flags &= ~e_touchingFlag;
|
||||
}
|
||||
|
||||
if (wasTouching == false && touching == true && listener)
|
||||
{
|
||||
listener->BeginContact(this);
|
||||
}
|
||||
|
||||
if (wasTouching == true && touching == false && listener)
|
||||
{
|
||||
listener->EndContact(this);
|
||||
}
|
||||
|
||||
if (sensor == false && touching && listener)
|
||||
{
|
||||
listener->PreSolve(this, &oldManifold);
|
||||
}
|
||||
}
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "b2PolygonAndCircleContact.h"
|
||||
#include "b2PolygonContact.h"
|
||||
#include "b2EdgeAndCircleContact.h"
|
||||
#include "b2EdgeAndPolygonContact.h"
|
||||
#include "b2ChainAndCircleContact.h"
|
||||
#include "b2ChainAndPolygonContact.h"
|
||||
#include "b2ContactSolver.h"
|
||||
|
||||
#include "../../Collision/b2Collision.h"
|
||||
#include "../../Collision/b2TimeOfImpact.h"
|
||||
#include "../../Collision/Shapes/b2Shape.h"
|
||||
#include "../../Common/b2BlockAllocator.h"
|
||||
#include "../b2Body.h"
|
||||
#include "../b2Fixture.h"
|
||||
#include "../b2World.h"
|
||||
|
||||
b2ContactRegister b2Contact::s_registers[b2Shape::e_typeCount][b2Shape::e_typeCount];
|
||||
bool b2Contact::s_initialized = false;
|
||||
|
||||
void b2Contact::InitializeRegisters()
|
||||
{
|
||||
AddType(b2CircleContact::Create, b2CircleContact::Destroy, b2Shape::e_circle, b2Shape::e_circle);
|
||||
AddType(b2PolygonAndCircleContact::Create, b2PolygonAndCircleContact::Destroy, b2Shape::e_polygon, b2Shape::e_circle);
|
||||
AddType(b2PolygonContact::Create, b2PolygonContact::Destroy, b2Shape::e_polygon, b2Shape::e_polygon);
|
||||
AddType(b2EdgeAndCircleContact::Create, b2EdgeAndCircleContact::Destroy, b2Shape::e_edge, b2Shape::e_circle);
|
||||
AddType(b2EdgeAndPolygonContact::Create, b2EdgeAndPolygonContact::Destroy, b2Shape::e_edge, b2Shape::e_polygon);
|
||||
AddType(b2ChainAndCircleContact::Create, b2ChainAndCircleContact::Destroy, b2Shape::e_chain, b2Shape::e_circle);
|
||||
AddType(b2ChainAndPolygonContact::Create, b2ChainAndPolygonContact::Destroy, b2Shape::e_chain, b2Shape::e_polygon);
|
||||
}
|
||||
|
||||
void b2Contact::AddType(b2ContactCreateFcn* createFcn, b2ContactDestroyFcn* destoryFcn,
|
||||
b2Shape::Type type1, b2Shape::Type type2)
|
||||
{
|
||||
b2Assert(0 <= type1 && type1 < b2Shape::e_typeCount);
|
||||
b2Assert(0 <= type2 && type2 < b2Shape::e_typeCount);
|
||||
|
||||
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(b2Fixture* fixtureA, int32 indexA, b2Fixture* fixtureB, int32 indexB, b2BlockAllocator* allocator)
|
||||
{
|
||||
if (s_initialized == false)
|
||||
{
|
||||
InitializeRegisters();
|
||||
s_initialized = true;
|
||||
}
|
||||
|
||||
b2Shape::Type type1 = fixtureA->GetType();
|
||||
b2Shape::Type type2 = fixtureB->GetType();
|
||||
|
||||
b2Assert(0 <= type1 && type1 < b2Shape::e_typeCount);
|
||||
b2Assert(0 <= type2 && type2 < b2Shape::e_typeCount);
|
||||
|
||||
b2ContactCreateFcn* createFcn = s_registers[type1][type2].createFcn;
|
||||
if (createFcn)
|
||||
{
|
||||
if (s_registers[type1][type2].primary)
|
||||
{
|
||||
return createFcn(fixtureA, indexA, fixtureB, indexB, allocator);
|
||||
}
|
||||
else
|
||||
{
|
||||
return createFcn(fixtureB, indexB, fixtureA, indexA, allocator);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
void b2Contact::Destroy(b2Contact* contact, b2BlockAllocator* allocator)
|
||||
{
|
||||
b2Assert(s_initialized == true);
|
||||
|
||||
if (contact->m_manifold.pointCount > 0)
|
||||
{
|
||||
contact->GetFixtureA()->GetBody()->SetAwake(true);
|
||||
contact->GetFixtureB()->GetBody()->SetAwake(true);
|
||||
}
|
||||
|
||||
b2Shape::Type typeA = contact->GetFixtureA()->GetType();
|
||||
b2Shape::Type typeB = contact->GetFixtureB()->GetType();
|
||||
|
||||
b2Assert(0 <= typeA && typeB < b2Shape::e_typeCount);
|
||||
b2Assert(0 <= typeA && typeB < b2Shape::e_typeCount);
|
||||
|
||||
b2ContactDestroyFcn* destroyFcn = s_registers[typeA][typeB].destroyFcn;
|
||||
destroyFcn(contact, allocator);
|
||||
}
|
||||
|
||||
b2Contact::b2Contact(b2Fixture* fA, int32 indexA, b2Fixture* fB, int32 indexB)
|
||||
{
|
||||
m_flags = e_enabledFlag;
|
||||
|
||||
m_fixtureA = fA;
|
||||
m_fixtureB = fB;
|
||||
|
||||
m_indexA = indexA;
|
||||
m_indexB = indexB;
|
||||
|
||||
m_manifold.pointCount = 0;
|
||||
|
||||
m_prev = NULL;
|
||||
m_next = NULL;
|
||||
|
||||
m_nodeA.contact = NULL;
|
||||
m_nodeA.prev = NULL;
|
||||
m_nodeA.next = NULL;
|
||||
m_nodeA.other = NULL;
|
||||
|
||||
m_nodeB.contact = NULL;
|
||||
m_nodeB.prev = NULL;
|
||||
m_nodeB.next = NULL;
|
||||
m_nodeB.other = NULL;
|
||||
|
||||
m_toiCount = 0;
|
||||
|
||||
m_friction = b2MixFriction(m_fixtureA->m_friction, m_fixtureB->m_friction);
|
||||
m_restitution = b2MixRestitution(m_fixtureA->m_restitution, m_fixtureB->m_restitution);
|
||||
}
|
||||
|
||||
// Update the contact manifold and touching status.
|
||||
// Note: do not assume the fixture AABBs are overlapping or are valid.
|
||||
void b2Contact::Update(b2ContactListener* listener)
|
||||
{
|
||||
b2Manifold oldManifold = m_manifold;
|
||||
|
||||
// Re-enable this contact.
|
||||
m_flags |= e_enabledFlag;
|
||||
|
||||
bool touching = false;
|
||||
bool wasTouching = (m_flags & e_touchingFlag) == e_touchingFlag;
|
||||
|
||||
bool sensorA = m_fixtureA->IsSensor();
|
||||
bool sensorB = m_fixtureB->IsSensor();
|
||||
bool sensor = sensorA || sensorB;
|
||||
|
||||
b2Body* bodyA = m_fixtureA->GetBody();
|
||||
b2Body* bodyB = m_fixtureB->GetBody();
|
||||
const b2Transform& xfA = bodyA->GetTransform();
|
||||
const b2Transform& xfB = bodyB->GetTransform();
|
||||
|
||||
// Is this contact a sensor?
|
||||
if (sensor)
|
||||
{
|
||||
const b2Shape* shapeA = m_fixtureA->GetShape();
|
||||
const b2Shape* shapeB = m_fixtureB->GetShape();
|
||||
touching = b2TestOverlap(shapeA, m_indexA, shapeB, m_indexB, xfA, xfB);
|
||||
|
||||
// Sensors don't generate manifolds.
|
||||
m_manifold.pointCount = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
Evaluate(&m_manifold, xfA, xfB);
|
||||
touching = 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* mp2 = m_manifold.points + i;
|
||||
mp2->normalImpulse = 0.0f;
|
||||
mp2->tangentImpulse = 0.0f;
|
||||
b2ContactID id2 = mp2->id;
|
||||
|
||||
for (int32 j = 0; j < oldManifold.pointCount; ++j)
|
||||
{
|
||||
b2ManifoldPoint* mp1 = oldManifold.points + j;
|
||||
|
||||
if (mp1->id.key == id2.key)
|
||||
{
|
||||
mp2->normalImpulse = mp1->normalImpulse;
|
||||
mp2->tangentImpulse = mp1->tangentImpulse;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (touching != wasTouching)
|
||||
{
|
||||
bodyA->SetAwake(true);
|
||||
bodyB->SetAwake(true);
|
||||
}
|
||||
}
|
||||
|
||||
if (touching)
|
||||
{
|
||||
m_flags |= e_touchingFlag;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_flags &= ~e_touchingFlag;
|
||||
}
|
||||
|
||||
if (wasTouching == false && touching == true && listener)
|
||||
{
|
||||
listener->BeginContact(this);
|
||||
}
|
||||
|
||||
if (wasTouching == true && touching == false && listener)
|
||||
{
|
||||
listener->EndContact(this);
|
||||
}
|
||||
|
||||
if (sensor == false && touching && listener)
|
||||
{
|
||||
listener->PreSolve(this, &oldManifold);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,331 +1,331 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_H
|
||||
#define B2_CONTACT_H
|
||||
|
||||
#include "../../Common/b2Math.h"
|
||||
#include "../../Collision/b2Collision.h"
|
||||
#include "../../Collision/Shapes/b2Shape.h"
|
||||
#include "../b2Fixture.h"
|
||||
|
||||
class b2Body;
|
||||
class b2Contact;
|
||||
class b2Fixture;
|
||||
class b2World;
|
||||
class b2BlockAllocator;
|
||||
class b2StackAllocator;
|
||||
class b2ContactListener;
|
||||
|
||||
/// Friction mixing law. The idea is to allow either fixture to drive the restitution to zero.
|
||||
/// For example, anything slides on ice.
|
||||
inline float32 b2MixFriction(float32 friction1, float32 friction2)
|
||||
{
|
||||
return std::sqrt(friction1 * friction2);
|
||||
}
|
||||
|
||||
/// Restitution mixing law. The idea is allow for anything to bounce off an inelastic surface.
|
||||
/// For example, a superball bounces on anything.
|
||||
inline float32 b2MixRestitution(float32 restitution1, float32 restitution2)
|
||||
{
|
||||
return restitution1 > restitution2 ? restitution1 : restitution2;
|
||||
}
|
||||
|
||||
typedef b2Contact* b2ContactCreateFcn( b2Fixture* fixtureA, juce::int32 indexA,
|
||||
b2Fixture* fixtureB, juce::int32 indexB,
|
||||
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
|
||||
};
|
||||
|
||||
/// 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 contact manifold. Do not modify the manifold unless you understand the
|
||||
/// internals of Box2D.
|
||||
b2Manifold* GetManifold();
|
||||
const b2Manifold* GetManifold() const;
|
||||
|
||||
/// Get the world manifold.
|
||||
void GetWorldManifold(b2WorldManifold* worldManifold) const;
|
||||
|
||||
/// Is this contact touching?
|
||||
bool IsTouching() const;
|
||||
|
||||
/// Enable/disable this contact. This can be used inside the pre-solve
|
||||
/// contact listener. The contact is only disabled for the current
|
||||
/// time step (or sub-step in continuous collisions).
|
||||
void SetEnabled(bool flag);
|
||||
|
||||
/// Has this contact been disabled?
|
||||
bool IsEnabled() const;
|
||||
|
||||
/// Get the next contact in the world's contact list.
|
||||
b2Contact* GetNext();
|
||||
const b2Contact* GetNext() const;
|
||||
|
||||
/// Get fixture A in this contact.
|
||||
b2Fixture* GetFixtureA();
|
||||
const b2Fixture* GetFixtureA() const;
|
||||
|
||||
/// Get the child primitive index for fixture A.
|
||||
juce::int32 GetChildIndexA() const;
|
||||
|
||||
/// Get fixture B in this contact.
|
||||
b2Fixture* GetFixtureB();
|
||||
const b2Fixture* GetFixtureB() const;
|
||||
|
||||
/// Get the child primitive index for fixture B.
|
||||
juce::int32 GetChildIndexB() const;
|
||||
|
||||
/// Override the default friction mixture. You can call this in b2ContactListener::PreSolve.
|
||||
/// This value persists until set or reset.
|
||||
void SetFriction(float32 friction);
|
||||
|
||||
/// Get the friction.
|
||||
float32 GetFriction() const;
|
||||
|
||||
/// Reset the friction mixture to the default value.
|
||||
void ResetFriction();
|
||||
|
||||
/// Override the default restitution mixture. You can call this in b2ContactListener::PreSolve.
|
||||
/// The value persists until you set or reset.
|
||||
void SetRestitution(float32 restitution);
|
||||
|
||||
/// Get the restitution.
|
||||
float32 GetRestitution() const;
|
||||
|
||||
/// Reset the restitution to the default value.
|
||||
void ResetRestitution();
|
||||
|
||||
/// Evaluate this contact with your own manifold and transforms.
|
||||
virtual void Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB) = 0;
|
||||
|
||||
protected:
|
||||
friend class b2ContactManager;
|
||||
friend class b2World;
|
||||
friend class b2ContactSolver;
|
||||
friend class b2Body;
|
||||
friend class b2Fixture;
|
||||
|
||||
// Flags stored in m_flags
|
||||
enum
|
||||
{
|
||||
// Used when crawling contact graph when forming islands.
|
||||
e_islandFlag = 0x0001,
|
||||
|
||||
// Set when the shapes are touching.
|
||||
e_touchingFlag = 0x0002,
|
||||
|
||||
// This contact can be disabled (by user)
|
||||
e_enabledFlag = 0x0004,
|
||||
|
||||
// This contact needs filtering because a fixture filter was changed.
|
||||
e_filterFlag = 0x0008,
|
||||
|
||||
// This bullet contact had a TOI event
|
||||
e_bulletHitFlag = 0x0010,
|
||||
|
||||
// This contact has a valid TOI in m_toi
|
||||
e_toiFlag = 0x0020
|
||||
};
|
||||
|
||||
/// Flag this contact for filtering. Filtering will occur the next time step.
|
||||
void FlagForFiltering();
|
||||
|
||||
static void AddType(b2ContactCreateFcn* createFcn, b2ContactDestroyFcn* destroyFcn,
|
||||
b2Shape::Type typeA, b2Shape::Type typeB);
|
||||
static void InitializeRegisters();
|
||||
static b2Contact* Create(b2Fixture* fixtureA, juce::int32 indexA, b2Fixture* fixtureB, juce::int32 indexB, b2BlockAllocator* allocator);
|
||||
static void Destroy(b2Contact* contact, b2Shape::Type typeA, b2Shape::Type typeB, b2BlockAllocator* allocator);
|
||||
static void Destroy(b2Contact* contact, b2BlockAllocator* allocator);
|
||||
|
||||
b2Contact() : m_fixtureA(NULL), m_fixtureB(NULL) {}
|
||||
b2Contact(b2Fixture* fixtureA, juce::int32 indexA, b2Fixture* fixtureB, juce::int32 indexB);
|
||||
virtual ~b2Contact() {}
|
||||
|
||||
void Update(b2ContactListener* listener);
|
||||
|
||||
static b2ContactRegister s_registers[b2Shape::e_typeCount][b2Shape::e_typeCount];
|
||||
static bool s_initialized;
|
||||
|
||||
juce::uint32 m_flags;
|
||||
|
||||
// World pool and list pointers.
|
||||
b2Contact* m_prev;
|
||||
b2Contact* m_next;
|
||||
|
||||
// Nodes for connecting bodies.
|
||||
b2ContactEdge m_nodeA;
|
||||
b2ContactEdge m_nodeB;
|
||||
|
||||
b2Fixture* m_fixtureA;
|
||||
b2Fixture* m_fixtureB;
|
||||
|
||||
juce::int32 m_indexA;
|
||||
juce::int32 m_indexB;
|
||||
|
||||
b2Manifold m_manifold;
|
||||
|
||||
juce::int32 m_toiCount;
|
||||
float32 m_toi;
|
||||
|
||||
float32 m_friction;
|
||||
float32 m_restitution;
|
||||
};
|
||||
|
||||
inline b2Manifold* b2Contact::GetManifold()
|
||||
{
|
||||
return &m_manifold;
|
||||
}
|
||||
|
||||
inline const b2Manifold* b2Contact::GetManifold() const
|
||||
{
|
||||
return &m_manifold;
|
||||
}
|
||||
|
||||
inline void b2Contact::GetWorldManifold(b2WorldManifold* worldManifold) const
|
||||
{
|
||||
const b2Body* bodyA = m_fixtureA->GetBody();
|
||||
const b2Body* bodyB = m_fixtureB->GetBody();
|
||||
const b2Shape* shapeA = m_fixtureA->GetShape();
|
||||
const b2Shape* shapeB = m_fixtureB->GetShape();
|
||||
|
||||
worldManifold->Initialize(&m_manifold, bodyA->GetTransform(), shapeA->m_radius, bodyB->GetTransform(), shapeB->m_radius);
|
||||
}
|
||||
|
||||
inline void b2Contact::SetEnabled(bool flag)
|
||||
{
|
||||
if (flag)
|
||||
{
|
||||
m_flags |= e_enabledFlag;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_flags &= ~((unsigned int) e_enabledFlag);
|
||||
}
|
||||
}
|
||||
|
||||
inline bool b2Contact::IsEnabled() const
|
||||
{
|
||||
return (m_flags & e_enabledFlag) == e_enabledFlag;
|
||||
}
|
||||
|
||||
inline bool b2Contact::IsTouching() const
|
||||
{
|
||||
return (m_flags & e_touchingFlag) == e_touchingFlag;
|
||||
}
|
||||
|
||||
inline b2Contact* b2Contact::GetNext()
|
||||
{
|
||||
return m_next;
|
||||
}
|
||||
|
||||
inline const b2Contact* b2Contact::GetNext() const
|
||||
{
|
||||
return m_next;
|
||||
}
|
||||
|
||||
inline b2Fixture* b2Contact::GetFixtureA()
|
||||
{
|
||||
return m_fixtureA;
|
||||
}
|
||||
|
||||
inline const b2Fixture* b2Contact::GetFixtureA() const
|
||||
{
|
||||
return m_fixtureA;
|
||||
}
|
||||
|
||||
inline b2Fixture* b2Contact::GetFixtureB()
|
||||
{
|
||||
return m_fixtureB;
|
||||
}
|
||||
|
||||
inline juce::int32 b2Contact::GetChildIndexA() const
|
||||
{
|
||||
return m_indexA;
|
||||
}
|
||||
|
||||
inline const b2Fixture* b2Contact::GetFixtureB() const
|
||||
{
|
||||
return m_fixtureB;
|
||||
}
|
||||
|
||||
inline juce::int32 b2Contact::GetChildIndexB() const
|
||||
{
|
||||
return m_indexB;
|
||||
}
|
||||
|
||||
inline void b2Contact::FlagForFiltering()
|
||||
{
|
||||
m_flags |= e_filterFlag;
|
||||
}
|
||||
|
||||
inline void b2Contact::SetFriction(float32 friction)
|
||||
{
|
||||
m_friction = friction;
|
||||
}
|
||||
|
||||
inline float32 b2Contact::GetFriction() const
|
||||
{
|
||||
return m_friction;
|
||||
}
|
||||
|
||||
inline void b2Contact::ResetFriction()
|
||||
{
|
||||
m_friction = b2MixFriction(m_fixtureA->m_friction, m_fixtureB->m_friction);
|
||||
}
|
||||
|
||||
inline void b2Contact::SetRestitution(float32 restitution)
|
||||
{
|
||||
m_restitution = restitution;
|
||||
}
|
||||
|
||||
inline float32 b2Contact::GetRestitution() const
|
||||
{
|
||||
return m_restitution;
|
||||
}
|
||||
|
||||
inline void b2Contact::ResetRestitution()
|
||||
{
|
||||
m_restitution = b2MixRestitution(m_fixtureA->m_restitution, m_fixtureB->m_restitution);
|
||||
}
|
||||
|
||||
#endif
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_H
|
||||
#define B2_CONTACT_H
|
||||
|
||||
#include "../../Common/b2Math.h"
|
||||
#include "../../Collision/b2Collision.h"
|
||||
#include "../../Collision/Shapes/b2Shape.h"
|
||||
#include "../b2Fixture.h"
|
||||
|
||||
class b2Body;
|
||||
class b2Contact;
|
||||
class b2Fixture;
|
||||
class b2World;
|
||||
class b2BlockAllocator;
|
||||
class b2StackAllocator;
|
||||
class b2ContactListener;
|
||||
|
||||
/// Friction mixing law. The idea is to allow either fixture to drive the restitution to zero.
|
||||
/// For example, anything slides on ice.
|
||||
inline float32 b2MixFriction(float32 friction1, float32 friction2)
|
||||
{
|
||||
return std::sqrt(friction1 * friction2);
|
||||
}
|
||||
|
||||
/// Restitution mixing law. The idea is allow for anything to bounce off an inelastic surface.
|
||||
/// For example, a superball bounces on anything.
|
||||
inline float32 b2MixRestitution(float32 restitution1, float32 restitution2)
|
||||
{
|
||||
return restitution1 > restitution2 ? restitution1 : restitution2;
|
||||
}
|
||||
|
||||
typedef b2Contact* b2ContactCreateFcn( b2Fixture* fixtureA, juce::int32 indexA,
|
||||
b2Fixture* fixtureB, juce::int32 indexB,
|
||||
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
|
||||
};
|
||||
|
||||
/// 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 contact manifold. Do not modify the manifold unless you understand the
|
||||
/// internals of Box2D.
|
||||
b2Manifold* GetManifold();
|
||||
const b2Manifold* GetManifold() const;
|
||||
|
||||
/// Get the world manifold.
|
||||
void GetWorldManifold(b2WorldManifold* worldManifold) const;
|
||||
|
||||
/// Is this contact touching?
|
||||
bool IsTouching() const;
|
||||
|
||||
/// Enable/disable this contact. This can be used inside the pre-solve
|
||||
/// contact listener. The contact is only disabled for the current
|
||||
/// time step (or sub-step in continuous collisions).
|
||||
void SetEnabled(bool flag);
|
||||
|
||||
/// Has this contact been disabled?
|
||||
bool IsEnabled() const;
|
||||
|
||||
/// Get the next contact in the world's contact list.
|
||||
b2Contact* GetNext();
|
||||
const b2Contact* GetNext() const;
|
||||
|
||||
/// Get fixture A in this contact.
|
||||
b2Fixture* GetFixtureA();
|
||||
const b2Fixture* GetFixtureA() const;
|
||||
|
||||
/// Get the child primitive index for fixture A.
|
||||
juce::int32 GetChildIndexA() const;
|
||||
|
||||
/// Get fixture B in this contact.
|
||||
b2Fixture* GetFixtureB();
|
||||
const b2Fixture* GetFixtureB() const;
|
||||
|
||||
/// Get the child primitive index for fixture B.
|
||||
juce::int32 GetChildIndexB() const;
|
||||
|
||||
/// Override the default friction mixture. You can call this in b2ContactListener::PreSolve.
|
||||
/// This value persists until set or reset.
|
||||
void SetFriction(float32 friction);
|
||||
|
||||
/// Get the friction.
|
||||
float32 GetFriction() const;
|
||||
|
||||
/// Reset the friction mixture to the default value.
|
||||
void ResetFriction();
|
||||
|
||||
/// Override the default restitution mixture. You can call this in b2ContactListener::PreSolve.
|
||||
/// The value persists until you set or reset.
|
||||
void SetRestitution(float32 restitution);
|
||||
|
||||
/// Get the restitution.
|
||||
float32 GetRestitution() const;
|
||||
|
||||
/// Reset the restitution to the default value.
|
||||
void ResetRestitution();
|
||||
|
||||
/// Evaluate this contact with your own manifold and transforms.
|
||||
virtual void Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB) = 0;
|
||||
|
||||
protected:
|
||||
friend class b2ContactManager;
|
||||
friend class b2World;
|
||||
friend class b2ContactSolver;
|
||||
friend class b2Body;
|
||||
friend class b2Fixture;
|
||||
|
||||
// Flags stored in m_flags
|
||||
enum
|
||||
{
|
||||
// Used when crawling contact graph when forming islands.
|
||||
e_islandFlag = 0x0001,
|
||||
|
||||
// Set when the shapes are touching.
|
||||
e_touchingFlag = 0x0002,
|
||||
|
||||
// This contact can be disabled (by user)
|
||||
e_enabledFlag = 0x0004,
|
||||
|
||||
// This contact needs filtering because a fixture filter was changed.
|
||||
e_filterFlag = 0x0008,
|
||||
|
||||
// This bullet contact had a TOI event
|
||||
e_bulletHitFlag = 0x0010,
|
||||
|
||||
// This contact has a valid TOI in m_toi
|
||||
e_toiFlag = 0x0020
|
||||
};
|
||||
|
||||
/// Flag this contact for filtering. Filtering will occur the next time step.
|
||||
void FlagForFiltering();
|
||||
|
||||
static void AddType(b2ContactCreateFcn* createFcn, b2ContactDestroyFcn* destroyFcn,
|
||||
b2Shape::Type typeA, b2Shape::Type typeB);
|
||||
static void InitializeRegisters();
|
||||
static b2Contact* Create(b2Fixture* fixtureA, juce::int32 indexA, b2Fixture* fixtureB, juce::int32 indexB, b2BlockAllocator* allocator);
|
||||
static void Destroy(b2Contact* contact, b2Shape::Type typeA, b2Shape::Type typeB, b2BlockAllocator* allocator);
|
||||
static void Destroy(b2Contact* contact, b2BlockAllocator* allocator);
|
||||
|
||||
b2Contact() : m_fixtureA(NULL), m_fixtureB(NULL) {}
|
||||
b2Contact(b2Fixture* fixtureA, juce::int32 indexA, b2Fixture* fixtureB, juce::int32 indexB);
|
||||
virtual ~b2Contact() {}
|
||||
|
||||
void Update(b2ContactListener* listener);
|
||||
|
||||
static b2ContactRegister s_registers[b2Shape::e_typeCount][b2Shape::e_typeCount];
|
||||
static bool s_initialized;
|
||||
|
||||
juce::uint32 m_flags;
|
||||
|
||||
// World pool and list pointers.
|
||||
b2Contact* m_prev;
|
||||
b2Contact* m_next;
|
||||
|
||||
// Nodes for connecting bodies.
|
||||
b2ContactEdge m_nodeA;
|
||||
b2ContactEdge m_nodeB;
|
||||
|
||||
b2Fixture* m_fixtureA;
|
||||
b2Fixture* m_fixtureB;
|
||||
|
||||
juce::int32 m_indexA;
|
||||
juce::int32 m_indexB;
|
||||
|
||||
b2Manifold m_manifold;
|
||||
|
||||
juce::int32 m_toiCount;
|
||||
float32 m_toi;
|
||||
|
||||
float32 m_friction;
|
||||
float32 m_restitution;
|
||||
};
|
||||
|
||||
inline b2Manifold* b2Contact::GetManifold()
|
||||
{
|
||||
return &m_manifold;
|
||||
}
|
||||
|
||||
inline const b2Manifold* b2Contact::GetManifold() const
|
||||
{
|
||||
return &m_manifold;
|
||||
}
|
||||
|
||||
inline void b2Contact::GetWorldManifold(b2WorldManifold* worldManifold) const
|
||||
{
|
||||
const b2Body* bodyA = m_fixtureA->GetBody();
|
||||
const b2Body* bodyB = m_fixtureB->GetBody();
|
||||
const b2Shape* shapeA = m_fixtureA->GetShape();
|
||||
const b2Shape* shapeB = m_fixtureB->GetShape();
|
||||
|
||||
worldManifold->Initialize(&m_manifold, bodyA->GetTransform(), shapeA->m_radius, bodyB->GetTransform(), shapeB->m_radius);
|
||||
}
|
||||
|
||||
inline void b2Contact::SetEnabled(bool flag)
|
||||
{
|
||||
if (flag)
|
||||
{
|
||||
m_flags |= e_enabledFlag;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_flags &= ~((unsigned int) e_enabledFlag);
|
||||
}
|
||||
}
|
||||
|
||||
inline bool b2Contact::IsEnabled() const
|
||||
{
|
||||
return (m_flags & e_enabledFlag) == e_enabledFlag;
|
||||
}
|
||||
|
||||
inline bool b2Contact::IsTouching() const
|
||||
{
|
||||
return (m_flags & e_touchingFlag) == e_touchingFlag;
|
||||
}
|
||||
|
||||
inline b2Contact* b2Contact::GetNext()
|
||||
{
|
||||
return m_next;
|
||||
}
|
||||
|
||||
inline const b2Contact* b2Contact::GetNext() const
|
||||
{
|
||||
return m_next;
|
||||
}
|
||||
|
||||
inline b2Fixture* b2Contact::GetFixtureA()
|
||||
{
|
||||
return m_fixtureA;
|
||||
}
|
||||
|
||||
inline const b2Fixture* b2Contact::GetFixtureA() const
|
||||
{
|
||||
return m_fixtureA;
|
||||
}
|
||||
|
||||
inline b2Fixture* b2Contact::GetFixtureB()
|
||||
{
|
||||
return m_fixtureB;
|
||||
}
|
||||
|
||||
inline juce::int32 b2Contact::GetChildIndexA() const
|
||||
{
|
||||
return m_indexA;
|
||||
}
|
||||
|
||||
inline const b2Fixture* b2Contact::GetFixtureB() const
|
||||
{
|
||||
return m_fixtureB;
|
||||
}
|
||||
|
||||
inline juce::int32 b2Contact::GetChildIndexB() const
|
||||
{
|
||||
return m_indexB;
|
||||
}
|
||||
|
||||
inline void b2Contact::FlagForFiltering()
|
||||
{
|
||||
m_flags |= e_filterFlag;
|
||||
}
|
||||
|
||||
inline void b2Contact::SetFriction(float32 friction)
|
||||
{
|
||||
m_friction = friction;
|
||||
}
|
||||
|
||||
inline float32 b2Contact::GetFriction() const
|
||||
{
|
||||
return m_friction;
|
||||
}
|
||||
|
||||
inline void b2Contact::ResetFriction()
|
||||
{
|
||||
m_friction = b2MixFriction(m_fixtureA->m_friction, m_fixtureB->m_friction);
|
||||
}
|
||||
|
||||
inline void b2Contact::SetRestitution(float32 restitution)
|
||||
{
|
||||
m_restitution = restitution;
|
||||
}
|
||||
|
||||
inline float32 b2Contact::GetRestitution() const
|
||||
{
|
||||
return m_restitution;
|
||||
}
|
||||
|
||||
inline void b2Contact::ResetRestitution()
|
||||
{
|
||||
m_restitution = b2MixRestitution(m_fixtureA->m_restitution, m_fixtureB->m_restitution);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,93 +1,93 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_SOLVER_H
|
||||
#define B2_CONTACT_SOLVER_H
|
||||
|
||||
#include "../../Common/b2Math.h"
|
||||
#include "../../Collision/b2Collision.h"
|
||||
#include "../b2TimeStep.h"
|
||||
|
||||
class b2Contact;
|
||||
class b2Body;
|
||||
class b2StackAllocator;
|
||||
struct b2ContactPositionConstraint;
|
||||
|
||||
struct b2VelocityConstraintPoint
|
||||
{
|
||||
b2Vec2 rA;
|
||||
b2Vec2 rB;
|
||||
float32 normalImpulse;
|
||||
float32 tangentImpulse;
|
||||
float32 normalMass;
|
||||
float32 tangentMass;
|
||||
float32 velocityBias;
|
||||
};
|
||||
|
||||
struct b2ContactVelocityConstraint
|
||||
{
|
||||
b2VelocityConstraintPoint points[b2_maxManifoldPoints];
|
||||
b2Vec2 normal;
|
||||
b2Mat22 normalMass;
|
||||
b2Mat22 K;
|
||||
int32 indexA;
|
||||
int32 indexB;
|
||||
float32 invMassA, invMassB;
|
||||
float32 invIA, invIB;
|
||||
float32 friction;
|
||||
float32 restitution;
|
||||
int32 pointCount;
|
||||
int32 contactIndex;
|
||||
};
|
||||
|
||||
struct b2ContactSolverDef
|
||||
{
|
||||
b2TimeStep step;
|
||||
b2Contact** contacts;
|
||||
int32 count;
|
||||
b2Position* positions;
|
||||
b2Velocity* velocities;
|
||||
b2StackAllocator* allocator;
|
||||
};
|
||||
|
||||
class b2ContactSolver
|
||||
{
|
||||
public:
|
||||
b2ContactSolver(b2ContactSolverDef* def);
|
||||
~b2ContactSolver();
|
||||
|
||||
void InitializeVelocityConstraints();
|
||||
|
||||
void WarmStart();
|
||||
void SolveVelocityConstraints();
|
||||
void StoreImpulses();
|
||||
|
||||
bool SolvePositionConstraints();
|
||||
bool SolveTOIPositionConstraints(int32 toiIndexA, int32 toiIndexB);
|
||||
|
||||
b2TimeStep m_step;
|
||||
b2Position* m_positions;
|
||||
b2Velocity* m_velocities;
|
||||
b2StackAllocator* m_allocator;
|
||||
b2ContactPositionConstraint* m_positionConstraints;
|
||||
b2ContactVelocityConstraint* m_velocityConstraints;
|
||||
b2Contact** m_contacts;
|
||||
int m_count;
|
||||
};
|
||||
|
||||
#endif
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_SOLVER_H
|
||||
#define B2_CONTACT_SOLVER_H
|
||||
|
||||
#include "../../Common/b2Math.h"
|
||||
#include "../../Collision/b2Collision.h"
|
||||
#include "../b2TimeStep.h"
|
||||
|
||||
class b2Contact;
|
||||
class b2Body;
|
||||
class b2StackAllocator;
|
||||
struct b2ContactPositionConstraint;
|
||||
|
||||
struct b2VelocityConstraintPoint
|
||||
{
|
||||
b2Vec2 rA;
|
||||
b2Vec2 rB;
|
||||
float32 normalImpulse;
|
||||
float32 tangentImpulse;
|
||||
float32 normalMass;
|
||||
float32 tangentMass;
|
||||
float32 velocityBias;
|
||||
};
|
||||
|
||||
struct b2ContactVelocityConstraint
|
||||
{
|
||||
b2VelocityConstraintPoint points[b2_maxManifoldPoints];
|
||||
b2Vec2 normal;
|
||||
b2Mat22 normalMass;
|
||||
b2Mat22 K;
|
||||
int32 indexA;
|
||||
int32 indexB;
|
||||
float32 invMassA, invMassB;
|
||||
float32 invIA, invIB;
|
||||
float32 friction;
|
||||
float32 restitution;
|
||||
int32 pointCount;
|
||||
int32 contactIndex;
|
||||
};
|
||||
|
||||
struct b2ContactSolverDef
|
||||
{
|
||||
b2TimeStep step;
|
||||
b2Contact** contacts;
|
||||
int32 count;
|
||||
b2Position* positions;
|
||||
b2Velocity* velocities;
|
||||
b2StackAllocator* allocator;
|
||||
};
|
||||
|
||||
class b2ContactSolver
|
||||
{
|
||||
public:
|
||||
b2ContactSolver(b2ContactSolverDef* def);
|
||||
~b2ContactSolver();
|
||||
|
||||
void InitializeVelocityConstraints();
|
||||
|
||||
void WarmStart();
|
||||
void SolveVelocityConstraints();
|
||||
void StoreImpulses();
|
||||
|
||||
bool SolvePositionConstraints();
|
||||
bool SolveTOIPositionConstraints(int32 toiIndexA, int32 toiIndexB);
|
||||
|
||||
b2TimeStep m_step;
|
||||
b2Position* m_positions;
|
||||
b2Velocity* m_velocities;
|
||||
b2StackAllocator* m_allocator;
|
||||
b2ContactPositionConstraint* m_positionConstraints;
|
||||
b2ContactVelocityConstraint* m_velocityConstraints;
|
||||
b2Contact** m_contacts;
|
||||
int m_count;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,50 +1,50 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2010 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "b2EdgeAndCircleContact.h"
|
||||
#include "../../Common/b2BlockAllocator.h"
|
||||
#include "../b2Fixture.h"
|
||||
|
||||
#include <new>
|
||||
using namespace std;
|
||||
|
||||
b2Contact* b2EdgeAndCircleContact::Create(b2Fixture* fixtureA, int32, b2Fixture* fixtureB, int32, b2BlockAllocator* allocator)
|
||||
{
|
||||
void* mem = allocator->Allocate(sizeof(b2EdgeAndCircleContact));
|
||||
return new (mem) b2EdgeAndCircleContact(fixtureA, fixtureB);
|
||||
}
|
||||
|
||||
void b2EdgeAndCircleContact::Destroy(b2Contact* contact, b2BlockAllocator* allocator)
|
||||
{
|
||||
((b2EdgeAndCircleContact*)contact)->~b2EdgeAndCircleContact();
|
||||
allocator->Free(contact, sizeof(b2EdgeAndCircleContact));
|
||||
}
|
||||
|
||||
b2EdgeAndCircleContact::b2EdgeAndCircleContact(b2Fixture* fixtureA, b2Fixture* fixtureB)
|
||||
: b2Contact(fixtureA, 0, fixtureB, 0)
|
||||
{
|
||||
b2Assert(m_fixtureA->GetType() == b2Shape::e_edge);
|
||||
b2Assert(m_fixtureB->GetType() == b2Shape::e_circle);
|
||||
}
|
||||
|
||||
void b2EdgeAndCircleContact::Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB)
|
||||
{
|
||||
b2CollideEdgeAndCircle( manifold,
|
||||
(b2EdgeShape*)m_fixtureA->GetShape(), xfA,
|
||||
(b2CircleShape*)m_fixtureB->GetShape(), xfB);
|
||||
}
|
||||
/*
|
||||
* Copyright (c) 2006-2010 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "b2EdgeAndCircleContact.h"
|
||||
#include "../../Common/b2BlockAllocator.h"
|
||||
#include "../b2Fixture.h"
|
||||
|
||||
#include <new>
|
||||
using namespace std;
|
||||
|
||||
b2Contact* b2EdgeAndCircleContact::Create(b2Fixture* fixtureA, int32, b2Fixture* fixtureB, int32, b2BlockAllocator* allocator)
|
||||
{
|
||||
void* mem = allocator->Allocate(sizeof(b2EdgeAndCircleContact));
|
||||
return new (mem) b2EdgeAndCircleContact(fixtureA, fixtureB);
|
||||
}
|
||||
|
||||
void b2EdgeAndCircleContact::Destroy(b2Contact* contact, b2BlockAllocator* allocator)
|
||||
{
|
||||
((b2EdgeAndCircleContact*)contact)->~b2EdgeAndCircleContact();
|
||||
allocator->Free(contact, sizeof(b2EdgeAndCircleContact));
|
||||
}
|
||||
|
||||
b2EdgeAndCircleContact::b2EdgeAndCircleContact(b2Fixture* fixtureA, b2Fixture* fixtureB)
|
||||
: b2Contact(fixtureA, 0, fixtureB, 0)
|
||||
{
|
||||
b2Assert(m_fixtureA->GetType() == b2Shape::e_edge);
|
||||
b2Assert(m_fixtureB->GetType() == b2Shape::e_circle);
|
||||
}
|
||||
|
||||
void b2EdgeAndCircleContact::Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB)
|
||||
{
|
||||
b2CollideEdgeAndCircle( manifold,
|
||||
(b2EdgeShape*)m_fixtureA->GetShape(), xfA,
|
||||
(b2CircleShape*)m_fixtureB->GetShape(), xfB);
|
||||
}
|
||||
|
||||
@@ -1,39 +1,39 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_EDGE_AND_CIRCLE_CONTACT_H
|
||||
#define B2_EDGE_AND_CIRCLE_CONTACT_H
|
||||
|
||||
#include "b2Contact.h"
|
||||
|
||||
class b2BlockAllocator;
|
||||
|
||||
class b2EdgeAndCircleContact : public b2Contact
|
||||
{
|
||||
public:
|
||||
static b2Contact* Create( b2Fixture* fixtureA, int32 indexA,
|
||||
b2Fixture* fixtureB, int32 indexB, b2BlockAllocator* allocator);
|
||||
static void Destroy(b2Contact* contact, b2BlockAllocator* allocator);
|
||||
|
||||
b2EdgeAndCircleContact(b2Fixture* fixtureA, b2Fixture* fixtureB);
|
||||
~b2EdgeAndCircleContact() {}
|
||||
|
||||
void Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB);
|
||||
};
|
||||
|
||||
#endif
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_EDGE_AND_CIRCLE_CONTACT_H
|
||||
#define B2_EDGE_AND_CIRCLE_CONTACT_H
|
||||
|
||||
#include "b2Contact.h"
|
||||
|
||||
class b2BlockAllocator;
|
||||
|
||||
class b2EdgeAndCircleContact : public b2Contact
|
||||
{
|
||||
public:
|
||||
static b2Contact* Create( b2Fixture* fixtureA, int32 indexA,
|
||||
b2Fixture* fixtureB, int32 indexB, b2BlockAllocator* allocator);
|
||||
static void Destroy(b2Contact* contact, b2BlockAllocator* allocator);
|
||||
|
||||
b2EdgeAndCircleContact(b2Fixture* fixtureA, b2Fixture* fixtureB);
|
||||
~b2EdgeAndCircleContact() {}
|
||||
|
||||
void Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,50 +1,50 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2010 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "b2EdgeAndPolygonContact.h"
|
||||
#include "../../Common/b2BlockAllocator.h"
|
||||
#include "../b2Fixture.h"
|
||||
|
||||
#include <new>
|
||||
using namespace std;
|
||||
|
||||
b2Contact* b2EdgeAndPolygonContact::Create(b2Fixture* fixtureA, int32, b2Fixture* fixtureB, int32, b2BlockAllocator* allocator)
|
||||
{
|
||||
void* mem = allocator->Allocate(sizeof(b2EdgeAndPolygonContact));
|
||||
return new (mem) b2EdgeAndPolygonContact(fixtureA, fixtureB);
|
||||
}
|
||||
|
||||
void b2EdgeAndPolygonContact::Destroy(b2Contact* contact, b2BlockAllocator* allocator)
|
||||
{
|
||||
((b2EdgeAndPolygonContact*)contact)->~b2EdgeAndPolygonContact();
|
||||
allocator->Free(contact, sizeof(b2EdgeAndPolygonContact));
|
||||
}
|
||||
|
||||
b2EdgeAndPolygonContact::b2EdgeAndPolygonContact(b2Fixture* fixtureA, b2Fixture* fixtureB)
|
||||
: b2Contact(fixtureA, 0, fixtureB, 0)
|
||||
{
|
||||
b2Assert(m_fixtureA->GetType() == b2Shape::e_edge);
|
||||
b2Assert(m_fixtureB->GetType() == b2Shape::e_polygon);
|
||||
}
|
||||
|
||||
void b2EdgeAndPolygonContact::Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB)
|
||||
{
|
||||
b2CollideEdgeAndPolygon( manifold,
|
||||
(b2EdgeShape*)m_fixtureA->GetShape(), xfA,
|
||||
(b2PolygonShape*)m_fixtureB->GetShape(), xfB);
|
||||
}
|
||||
/*
|
||||
* Copyright (c) 2006-2010 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "b2EdgeAndPolygonContact.h"
|
||||
#include "../../Common/b2BlockAllocator.h"
|
||||
#include "../b2Fixture.h"
|
||||
|
||||
#include <new>
|
||||
using namespace std;
|
||||
|
||||
b2Contact* b2EdgeAndPolygonContact::Create(b2Fixture* fixtureA, int32, b2Fixture* fixtureB, int32, b2BlockAllocator* allocator)
|
||||
{
|
||||
void* mem = allocator->Allocate(sizeof(b2EdgeAndPolygonContact));
|
||||
return new (mem) b2EdgeAndPolygonContact(fixtureA, fixtureB);
|
||||
}
|
||||
|
||||
void b2EdgeAndPolygonContact::Destroy(b2Contact* contact, b2BlockAllocator* allocator)
|
||||
{
|
||||
((b2EdgeAndPolygonContact*)contact)->~b2EdgeAndPolygonContact();
|
||||
allocator->Free(contact, sizeof(b2EdgeAndPolygonContact));
|
||||
}
|
||||
|
||||
b2EdgeAndPolygonContact::b2EdgeAndPolygonContact(b2Fixture* fixtureA, b2Fixture* fixtureB)
|
||||
: b2Contact(fixtureA, 0, fixtureB, 0)
|
||||
{
|
||||
b2Assert(m_fixtureA->GetType() == b2Shape::e_edge);
|
||||
b2Assert(m_fixtureB->GetType() == b2Shape::e_polygon);
|
||||
}
|
||||
|
||||
void b2EdgeAndPolygonContact::Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB)
|
||||
{
|
||||
b2CollideEdgeAndPolygon( manifold,
|
||||
(b2EdgeShape*)m_fixtureA->GetShape(), xfA,
|
||||
(b2PolygonShape*)m_fixtureB->GetShape(), xfB);
|
||||
}
|
||||
|
||||
@@ -1,39 +1,39 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_EDGE_AND_POLYGON_CONTACT_H
|
||||
#define B2_EDGE_AND_POLYGON_CONTACT_H
|
||||
|
||||
#include "b2Contact.h"
|
||||
|
||||
class b2BlockAllocator;
|
||||
|
||||
class b2EdgeAndPolygonContact : public b2Contact
|
||||
{
|
||||
public:
|
||||
static b2Contact* Create( b2Fixture* fixtureA, int32 indexA,
|
||||
b2Fixture* fixtureB, int32 indexB, b2BlockAllocator* allocator);
|
||||
static void Destroy(b2Contact* contact, b2BlockAllocator* allocator);
|
||||
|
||||
b2EdgeAndPolygonContact(b2Fixture* fixtureA, b2Fixture* fixtureB);
|
||||
~b2EdgeAndPolygonContact() {}
|
||||
|
||||
void Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB);
|
||||
};
|
||||
|
||||
#endif
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_EDGE_AND_POLYGON_CONTACT_H
|
||||
#define B2_EDGE_AND_POLYGON_CONTACT_H
|
||||
|
||||
#include "b2Contact.h"
|
||||
|
||||
class b2BlockAllocator;
|
||||
|
||||
class b2EdgeAndPolygonContact : public b2Contact
|
||||
{
|
||||
public:
|
||||
static b2Contact* Create( b2Fixture* fixtureA, int32 indexA,
|
||||
b2Fixture* fixtureB, int32 indexB, b2BlockAllocator* allocator);
|
||||
static void Destroy(b2Contact* contact, b2BlockAllocator* allocator);
|
||||
|
||||
b2EdgeAndPolygonContact(b2Fixture* fixtureA, b2Fixture* fixtureB);
|
||||
~b2EdgeAndPolygonContact() {}
|
||||
|
||||
void Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,50 +1,50 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "b2PolygonAndCircleContact.h"
|
||||
#include "../../Common/b2BlockAllocator.h"
|
||||
#include "../b2Fixture.h"
|
||||
|
||||
#include <new>
|
||||
using namespace std;
|
||||
|
||||
b2Contact* b2PolygonAndCircleContact::Create(b2Fixture* fixtureA, int32, b2Fixture* fixtureB, int32, b2BlockAllocator* allocator)
|
||||
{
|
||||
void* mem = allocator->Allocate(sizeof(b2PolygonAndCircleContact));
|
||||
return new (mem) b2PolygonAndCircleContact(fixtureA, fixtureB);
|
||||
}
|
||||
|
||||
void b2PolygonAndCircleContact::Destroy(b2Contact* contact, b2BlockAllocator* allocator)
|
||||
{
|
||||
((b2PolygonAndCircleContact*)contact)->~b2PolygonAndCircleContact();
|
||||
allocator->Free(contact, sizeof(b2PolygonAndCircleContact));
|
||||
}
|
||||
|
||||
b2PolygonAndCircleContact::b2PolygonAndCircleContact(b2Fixture* fixtureA, b2Fixture* fixtureB)
|
||||
: b2Contact(fixtureA, 0, fixtureB, 0)
|
||||
{
|
||||
b2Assert(m_fixtureA->GetType() == b2Shape::e_polygon);
|
||||
b2Assert(m_fixtureB->GetType() == b2Shape::e_circle);
|
||||
}
|
||||
|
||||
void b2PolygonAndCircleContact::Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB)
|
||||
{
|
||||
b2CollidePolygonAndCircle( manifold,
|
||||
(b2PolygonShape*)m_fixtureA->GetShape(), xfA,
|
||||
(b2CircleShape*)m_fixtureB->GetShape(), xfB);
|
||||
}
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "b2PolygonAndCircleContact.h"
|
||||
#include "../../Common/b2BlockAllocator.h"
|
||||
#include "../b2Fixture.h"
|
||||
|
||||
#include <new>
|
||||
using namespace std;
|
||||
|
||||
b2Contact* b2PolygonAndCircleContact::Create(b2Fixture* fixtureA, int32, b2Fixture* fixtureB, int32, b2BlockAllocator* allocator)
|
||||
{
|
||||
void* mem = allocator->Allocate(sizeof(b2PolygonAndCircleContact));
|
||||
return new (mem) b2PolygonAndCircleContact(fixtureA, fixtureB);
|
||||
}
|
||||
|
||||
void b2PolygonAndCircleContact::Destroy(b2Contact* contact, b2BlockAllocator* allocator)
|
||||
{
|
||||
((b2PolygonAndCircleContact*)contact)->~b2PolygonAndCircleContact();
|
||||
allocator->Free(contact, sizeof(b2PolygonAndCircleContact));
|
||||
}
|
||||
|
||||
b2PolygonAndCircleContact::b2PolygonAndCircleContact(b2Fixture* fixtureA, b2Fixture* fixtureB)
|
||||
: b2Contact(fixtureA, 0, fixtureB, 0)
|
||||
{
|
||||
b2Assert(m_fixtureA->GetType() == b2Shape::e_polygon);
|
||||
b2Assert(m_fixtureB->GetType() == b2Shape::e_circle);
|
||||
}
|
||||
|
||||
void b2PolygonAndCircleContact::Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB)
|
||||
{
|
||||
b2CollidePolygonAndCircle( manifold,
|
||||
(b2PolygonShape*)m_fixtureA->GetShape(), xfA,
|
||||
(b2CircleShape*)m_fixtureB->GetShape(), xfB);
|
||||
}
|
||||
|
||||
@@ -1,38 +1,38 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_AND_CIRCLE_CONTACT_H
|
||||
#define B2_POLYGON_AND_CIRCLE_CONTACT_H
|
||||
|
||||
#include "b2Contact.h"
|
||||
|
||||
class b2BlockAllocator;
|
||||
|
||||
class b2PolygonAndCircleContact : public b2Contact
|
||||
{
|
||||
public:
|
||||
static b2Contact* Create(b2Fixture* fixtureA, int32 indexA, b2Fixture* fixtureB, int32 indexB, b2BlockAllocator* allocator);
|
||||
static void Destroy(b2Contact* contact, b2BlockAllocator* allocator);
|
||||
|
||||
b2PolygonAndCircleContact(b2Fixture* fixtureA, b2Fixture* fixtureB);
|
||||
~b2PolygonAndCircleContact() {}
|
||||
|
||||
void Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB);
|
||||
};
|
||||
|
||||
#endif
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_AND_CIRCLE_CONTACT_H
|
||||
#define B2_POLYGON_AND_CIRCLE_CONTACT_H
|
||||
|
||||
#include "b2Contact.h"
|
||||
|
||||
class b2BlockAllocator;
|
||||
|
||||
class b2PolygonAndCircleContact : public b2Contact
|
||||
{
|
||||
public:
|
||||
static b2Contact* Create(b2Fixture* fixtureA, int32 indexA, b2Fixture* fixtureB, int32 indexB, b2BlockAllocator* allocator);
|
||||
static void Destroy(b2Contact* contact, b2BlockAllocator* allocator);
|
||||
|
||||
b2PolygonAndCircleContact(b2Fixture* fixtureA, b2Fixture* fixtureB);
|
||||
~b2PolygonAndCircleContact() {}
|
||||
|
||||
void Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,53 +1,53 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "b2PolygonContact.h"
|
||||
#include "../../Common/b2BlockAllocator.h"
|
||||
#include "../../Collision/b2TimeOfImpact.h"
|
||||
#include "../b2Body.h"
|
||||
#include "../b2Fixture.h"
|
||||
#include "../b2WorldCallbacks.h"
|
||||
|
||||
#include <new>
|
||||
using namespace std;
|
||||
|
||||
b2Contact* b2PolygonContact::Create(b2Fixture* fixtureA, int32, b2Fixture* fixtureB, int32, b2BlockAllocator* allocator)
|
||||
{
|
||||
void* mem = allocator->Allocate(sizeof(b2PolygonContact));
|
||||
return new (mem) b2PolygonContact(fixtureA, fixtureB);
|
||||
}
|
||||
|
||||
void b2PolygonContact::Destroy(b2Contact* contact, b2BlockAllocator* allocator)
|
||||
{
|
||||
((b2PolygonContact*)contact)->~b2PolygonContact();
|
||||
allocator->Free(contact, sizeof(b2PolygonContact));
|
||||
}
|
||||
|
||||
b2PolygonContact::b2PolygonContact(b2Fixture* fixtureA, b2Fixture* fixtureB)
|
||||
: b2Contact(fixtureA, 0, fixtureB, 0)
|
||||
{
|
||||
b2Assert(m_fixtureA->GetType() == b2Shape::e_polygon);
|
||||
b2Assert(m_fixtureB->GetType() == b2Shape::e_polygon);
|
||||
}
|
||||
|
||||
void b2PolygonContact::Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB)
|
||||
{
|
||||
b2CollidePolygons( manifold,
|
||||
(b2PolygonShape*)m_fixtureA->GetShape(), xfA,
|
||||
(b2PolygonShape*)m_fixtureB->GetShape(), xfB);
|
||||
}
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "b2PolygonContact.h"
|
||||
#include "../../Common/b2BlockAllocator.h"
|
||||
#include "../../Collision/b2TimeOfImpact.h"
|
||||
#include "../b2Body.h"
|
||||
#include "../b2Fixture.h"
|
||||
#include "../b2WorldCallbacks.h"
|
||||
|
||||
#include <new>
|
||||
using namespace std;
|
||||
|
||||
b2Contact* b2PolygonContact::Create(b2Fixture* fixtureA, int32, b2Fixture* fixtureB, int32, b2BlockAllocator* allocator)
|
||||
{
|
||||
void* mem = allocator->Allocate(sizeof(b2PolygonContact));
|
||||
return new (mem) b2PolygonContact(fixtureA, fixtureB);
|
||||
}
|
||||
|
||||
void b2PolygonContact::Destroy(b2Contact* contact, b2BlockAllocator* allocator)
|
||||
{
|
||||
((b2PolygonContact*)contact)->~b2PolygonContact();
|
||||
allocator->Free(contact, sizeof(b2PolygonContact));
|
||||
}
|
||||
|
||||
b2PolygonContact::b2PolygonContact(b2Fixture* fixtureA, b2Fixture* fixtureB)
|
||||
: b2Contact(fixtureA, 0, fixtureB, 0)
|
||||
{
|
||||
b2Assert(m_fixtureA->GetType() == b2Shape::e_polygon);
|
||||
b2Assert(m_fixtureB->GetType() == b2Shape::e_polygon);
|
||||
}
|
||||
|
||||
void b2PolygonContact::Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB)
|
||||
{
|
||||
b2CollidePolygons( manifold,
|
||||
(b2PolygonShape*)m_fixtureA->GetShape(), xfA,
|
||||
(b2PolygonShape*)m_fixtureB->GetShape(), xfB);
|
||||
}
|
||||
|
||||
@@ -1,39 +1,39 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_CONTACT_H
|
||||
#define B2_POLYGON_CONTACT_H
|
||||
|
||||
#include "b2Contact.h"
|
||||
|
||||
class b2BlockAllocator;
|
||||
|
||||
class b2PolygonContact : public b2Contact
|
||||
{
|
||||
public:
|
||||
static b2Contact* Create( b2Fixture* fixtureA, int32 indexA,
|
||||
b2Fixture* fixtureB, int32 indexB, b2BlockAllocator* allocator);
|
||||
static void Destroy(b2Contact* contact, b2BlockAllocator* allocator);
|
||||
|
||||
b2PolygonContact(b2Fixture* fixtureA, b2Fixture* fixtureB);
|
||||
~b2PolygonContact() {}
|
||||
|
||||
void Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB);
|
||||
};
|
||||
|
||||
#endif
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_CONTACT_H
|
||||
#define B2_POLYGON_CONTACT_H
|
||||
|
||||
#include "b2Contact.h"
|
||||
|
||||
class b2BlockAllocator;
|
||||
|
||||
class b2PolygonContact : public b2Contact
|
||||
{
|
||||
public:
|
||||
static b2Contact* Create( b2Fixture* fixtureA, int32 indexA,
|
||||
b2Fixture* fixtureB, int32 indexB, b2BlockAllocator* allocator);
|
||||
static void Destroy(b2Contact* contact, b2BlockAllocator* allocator);
|
||||
|
||||
b2PolygonContact(b2Fixture* fixtureA, b2Fixture* fixtureB);
|
||||
~b2PolygonContact() {}
|
||||
|
||||
void Evaluate(b2Manifold* manifold, const b2Transform& xfA, const b2Transform& xfB);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,260 +1,260 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "../b2TimeStep.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)
|
||||
{
|
||||
bodyA = b1;
|
||||
bodyB = b2;
|
||||
localAnchorA = bodyA->GetLocalPoint(anchor1);
|
||||
localAnchorB = bodyB->GetLocalPoint(anchor2);
|
||||
b2Vec2 d = anchor2 - anchor1;
|
||||
length = d.Length();
|
||||
}
|
||||
|
||||
b2DistanceJoint::b2DistanceJoint(const b2DistanceJointDef* def)
|
||||
: b2Joint(def)
|
||||
{
|
||||
m_localAnchorA = def->localAnchorA;
|
||||
m_localAnchorB = def->localAnchorB;
|
||||
m_length = def->length;
|
||||
m_frequencyHz = def->frequencyHz;
|
||||
m_dampingRatio = def->dampingRatio;
|
||||
m_impulse = 0.0f;
|
||||
m_gamma = 0.0f;
|
||||
m_bias = 0.0f;
|
||||
}
|
||||
|
||||
void b2DistanceJoint::InitVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
m_indexA = m_bodyA->m_islandIndex;
|
||||
m_indexB = m_bodyB->m_islandIndex;
|
||||
m_localCenterA = m_bodyA->m_sweep.localCenter;
|
||||
m_localCenterB = m_bodyB->m_sweep.localCenter;
|
||||
m_invMassA = m_bodyA->m_invMass;
|
||||
m_invMassB = m_bodyB->m_invMass;
|
||||
m_invIA = m_bodyA->m_invI;
|
||||
m_invIB = m_bodyB->m_invI;
|
||||
|
||||
b2Vec2 cA = data.positions[m_indexA].c;
|
||||
float32 aA = data.positions[m_indexA].a;
|
||||
b2Vec2 vA = data.velocities[m_indexA].v;
|
||||
float32 wA = data.velocities[m_indexA].w;
|
||||
|
||||
b2Vec2 cB = data.positions[m_indexB].c;
|
||||
float32 aB = data.positions[m_indexB].a;
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
|
||||
b2Rot qA(aA), qB(aB);
|
||||
|
||||
m_rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
|
||||
m_rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
|
||||
m_u = cB + m_rB - cA - m_rA;
|
||||
|
||||
// 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 crAu = b2Cross(m_rA, m_u);
|
||||
float32 crBu = b2Cross(m_rB, m_u);
|
||||
float32 invMass = m_invMassA + m_invIA * crAu * crAu + m_invMassB + m_invIB * crBu * crBu;
|
||||
|
||||
// Compute the effective mass matrix.
|
||||
m_mass = invMass != 0.0f ? 1.0f / invMass : 0.0f;
|
||||
|
||||
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
|
||||
float32 h = data.step.dt;
|
||||
m_gamma = h * (d + h * k);
|
||||
m_gamma = m_gamma != 0.0f ? 1.0f / m_gamma : 0.0f;
|
||||
m_bias = C * h * k * m_gamma;
|
||||
|
||||
invMass += m_gamma;
|
||||
m_mass = invMass != 0.0f ? 1.0f / invMass : 0.0f;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_gamma = 0.0f;
|
||||
m_bias = 0.0f;
|
||||
}
|
||||
|
||||
if (data.step.warmStarting)
|
||||
{
|
||||
// Scale the impulse to support a variable time step.
|
||||
m_impulse *= data.step.dtRatio;
|
||||
|
||||
b2Vec2 P = m_impulse * m_u;
|
||||
vA -= m_invMassA * P;
|
||||
wA -= m_invIA * b2Cross(m_rA, P);
|
||||
vB += m_invMassB * P;
|
||||
wB += m_invIB * b2Cross(m_rB, P);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_impulse = 0.0f;
|
||||
}
|
||||
|
||||
data.velocities[m_indexA].v = vA;
|
||||
data.velocities[m_indexA].w = wA;
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
}
|
||||
|
||||
void b2DistanceJoint::SolveVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
b2Vec2 vA = data.velocities[m_indexA].v;
|
||||
float32 wA = data.velocities[m_indexA].w;
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
|
||||
// Cdot = dot(u, v + cross(w, r))
|
||||
b2Vec2 vpA = vA + b2Cross(wA, m_rA);
|
||||
b2Vec2 vpB = vB + b2Cross(wB, m_rB);
|
||||
float32 Cdot = b2Dot(m_u, vpB - vpA);
|
||||
|
||||
float32 impulse = -m_mass * (Cdot + m_bias + m_gamma * m_impulse);
|
||||
m_impulse += impulse;
|
||||
|
||||
b2Vec2 P = impulse * m_u;
|
||||
vA -= m_invMassA * P;
|
||||
wA -= m_invIA * b2Cross(m_rA, P);
|
||||
vB += m_invMassB * P;
|
||||
wB += m_invIB * b2Cross(m_rB, P);
|
||||
|
||||
data.velocities[m_indexA].v = vA;
|
||||
data.velocities[m_indexA].w = wA;
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
}
|
||||
|
||||
bool b2DistanceJoint::SolvePositionConstraints(const b2SolverData& data)
|
||||
{
|
||||
if (m_frequencyHz > 0.0f)
|
||||
{
|
||||
// There is no position correction for soft distance constraints.
|
||||
return true;
|
||||
}
|
||||
|
||||
b2Vec2 cA = data.positions[m_indexA].c;
|
||||
float32 aA = data.positions[m_indexA].a;
|
||||
b2Vec2 cB = data.positions[m_indexB].c;
|
||||
float32 aB = data.positions[m_indexB].a;
|
||||
|
||||
b2Rot qA(aA), qB(aB);
|
||||
|
||||
b2Vec2 rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
|
||||
b2Vec2 rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
|
||||
b2Vec2 u = cB + rB - cA - rA;
|
||||
|
||||
float32 length = u.Normalize();
|
||||
float32 C = length - m_length;
|
||||
C = b2Clamp(C, -b2_maxLinearCorrection, b2_maxLinearCorrection);
|
||||
|
||||
float32 impulse = -m_mass * C;
|
||||
b2Vec2 P = impulse * u;
|
||||
|
||||
cA -= m_invMassA * P;
|
||||
aA -= m_invIA * b2Cross(rA, P);
|
||||
cB += m_invMassB * P;
|
||||
aB += m_invIB * b2Cross(rB, P);
|
||||
|
||||
data.positions[m_indexA].c = cA;
|
||||
data.positions[m_indexA].a = aA;
|
||||
data.positions[m_indexB].c = cB;
|
||||
data.positions[m_indexB].a = aB;
|
||||
|
||||
return b2Abs(C) < b2_linearSlop;
|
||||
}
|
||||
|
||||
b2Vec2 b2DistanceJoint::GetAnchorA() const
|
||||
{
|
||||
return m_bodyA->GetWorldPoint(m_localAnchorA);
|
||||
}
|
||||
|
||||
b2Vec2 b2DistanceJoint::GetAnchorB() const
|
||||
{
|
||||
return m_bodyB->GetWorldPoint(m_localAnchorB);
|
||||
}
|
||||
|
||||
b2Vec2 b2DistanceJoint::GetReactionForce(float32 inv_dt) const
|
||||
{
|
||||
b2Vec2 F = (inv_dt * m_impulse) * m_u;
|
||||
return F;
|
||||
}
|
||||
|
||||
float32 b2DistanceJoint::GetReactionTorque(float32 inv_dt) const
|
||||
{
|
||||
B2_NOT_USED(inv_dt);
|
||||
return 0.0f;
|
||||
}
|
||||
|
||||
void b2DistanceJoint::Dump()
|
||||
{
|
||||
int32 indexA = m_bodyA->m_islandIndex;
|
||||
int32 indexB = m_bodyB->m_islandIndex;
|
||||
|
||||
b2Log(" b2DistanceJointDef jd;\n");
|
||||
b2Log(" jd.bodyA = bodies[%d];\n", indexA);
|
||||
b2Log(" jd.bodyB = bodies[%d];\n", indexB);
|
||||
b2Log(" jd.collideConnected = bool(%d);\n", m_collideConnected);
|
||||
b2Log(" jd.localAnchorA.Set(%.15lef, %.15lef);\n", m_localAnchorA.x, m_localAnchorA.y);
|
||||
b2Log(" jd.localAnchorB.Set(%.15lef, %.15lef);\n", m_localAnchorB.x, m_localAnchorB.y);
|
||||
b2Log(" jd.length = %.15lef;\n", m_length);
|
||||
b2Log(" jd.frequencyHz = %.15lef;\n", m_frequencyHz);
|
||||
b2Log(" jd.dampingRatio = %.15lef;\n", m_dampingRatio);
|
||||
b2Log(" joints[%d] = m_world->CreateJoint(&jd);\n", m_index);
|
||||
}
|
||||
/*
|
||||
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "../b2TimeStep.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)
|
||||
{
|
||||
bodyA = b1;
|
||||
bodyB = b2;
|
||||
localAnchorA = bodyA->GetLocalPoint(anchor1);
|
||||
localAnchorB = bodyB->GetLocalPoint(anchor2);
|
||||
b2Vec2 d = anchor2 - anchor1;
|
||||
length = d.Length();
|
||||
}
|
||||
|
||||
b2DistanceJoint::b2DistanceJoint(const b2DistanceJointDef* def)
|
||||
: b2Joint(def)
|
||||
{
|
||||
m_localAnchorA = def->localAnchorA;
|
||||
m_localAnchorB = def->localAnchorB;
|
||||
m_length = def->length;
|
||||
m_frequencyHz = def->frequencyHz;
|
||||
m_dampingRatio = def->dampingRatio;
|
||||
m_impulse = 0.0f;
|
||||
m_gamma = 0.0f;
|
||||
m_bias = 0.0f;
|
||||
}
|
||||
|
||||
void b2DistanceJoint::InitVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
m_indexA = m_bodyA->m_islandIndex;
|
||||
m_indexB = m_bodyB->m_islandIndex;
|
||||
m_localCenterA = m_bodyA->m_sweep.localCenter;
|
||||
m_localCenterB = m_bodyB->m_sweep.localCenter;
|
||||
m_invMassA = m_bodyA->m_invMass;
|
||||
m_invMassB = m_bodyB->m_invMass;
|
||||
m_invIA = m_bodyA->m_invI;
|
||||
m_invIB = m_bodyB->m_invI;
|
||||
|
||||
b2Vec2 cA = data.positions[m_indexA].c;
|
||||
float32 aA = data.positions[m_indexA].a;
|
||||
b2Vec2 vA = data.velocities[m_indexA].v;
|
||||
float32 wA = data.velocities[m_indexA].w;
|
||||
|
||||
b2Vec2 cB = data.positions[m_indexB].c;
|
||||
float32 aB = data.positions[m_indexB].a;
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
|
||||
b2Rot qA(aA), qB(aB);
|
||||
|
||||
m_rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
|
||||
m_rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
|
||||
m_u = cB + m_rB - cA - m_rA;
|
||||
|
||||
// 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 crAu = b2Cross(m_rA, m_u);
|
||||
float32 crBu = b2Cross(m_rB, m_u);
|
||||
float32 invMass = m_invMassA + m_invIA * crAu * crAu + m_invMassB + m_invIB * crBu * crBu;
|
||||
|
||||
// Compute the effective mass matrix.
|
||||
m_mass = invMass != 0.0f ? 1.0f / invMass : 0.0f;
|
||||
|
||||
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
|
||||
float32 h = data.step.dt;
|
||||
m_gamma = h * (d + h * k);
|
||||
m_gamma = m_gamma != 0.0f ? 1.0f / m_gamma : 0.0f;
|
||||
m_bias = C * h * k * m_gamma;
|
||||
|
||||
invMass += m_gamma;
|
||||
m_mass = invMass != 0.0f ? 1.0f / invMass : 0.0f;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_gamma = 0.0f;
|
||||
m_bias = 0.0f;
|
||||
}
|
||||
|
||||
if (data.step.warmStarting)
|
||||
{
|
||||
// Scale the impulse to support a variable time step.
|
||||
m_impulse *= data.step.dtRatio;
|
||||
|
||||
b2Vec2 P = m_impulse * m_u;
|
||||
vA -= m_invMassA * P;
|
||||
wA -= m_invIA * b2Cross(m_rA, P);
|
||||
vB += m_invMassB * P;
|
||||
wB += m_invIB * b2Cross(m_rB, P);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_impulse = 0.0f;
|
||||
}
|
||||
|
||||
data.velocities[m_indexA].v = vA;
|
||||
data.velocities[m_indexA].w = wA;
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
}
|
||||
|
||||
void b2DistanceJoint::SolveVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
b2Vec2 vA = data.velocities[m_indexA].v;
|
||||
float32 wA = data.velocities[m_indexA].w;
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
|
||||
// Cdot = dot(u, v + cross(w, r))
|
||||
b2Vec2 vpA = vA + b2Cross(wA, m_rA);
|
||||
b2Vec2 vpB = vB + b2Cross(wB, m_rB);
|
||||
float32 Cdot = b2Dot(m_u, vpB - vpA);
|
||||
|
||||
float32 impulse = -m_mass * (Cdot + m_bias + m_gamma * m_impulse);
|
||||
m_impulse += impulse;
|
||||
|
||||
b2Vec2 P = impulse * m_u;
|
||||
vA -= m_invMassA * P;
|
||||
wA -= m_invIA * b2Cross(m_rA, P);
|
||||
vB += m_invMassB * P;
|
||||
wB += m_invIB * b2Cross(m_rB, P);
|
||||
|
||||
data.velocities[m_indexA].v = vA;
|
||||
data.velocities[m_indexA].w = wA;
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
}
|
||||
|
||||
bool b2DistanceJoint::SolvePositionConstraints(const b2SolverData& data)
|
||||
{
|
||||
if (m_frequencyHz > 0.0f)
|
||||
{
|
||||
// There is no position correction for soft distance constraints.
|
||||
return true;
|
||||
}
|
||||
|
||||
b2Vec2 cA = data.positions[m_indexA].c;
|
||||
float32 aA = data.positions[m_indexA].a;
|
||||
b2Vec2 cB = data.positions[m_indexB].c;
|
||||
float32 aB = data.positions[m_indexB].a;
|
||||
|
||||
b2Rot qA(aA), qB(aB);
|
||||
|
||||
b2Vec2 rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
|
||||
b2Vec2 rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
|
||||
b2Vec2 u = cB + rB - cA - rA;
|
||||
|
||||
float32 length = u.Normalize();
|
||||
float32 C = length - m_length;
|
||||
C = b2Clamp(C, -b2_maxLinearCorrection, b2_maxLinearCorrection);
|
||||
|
||||
float32 impulse = -m_mass * C;
|
||||
b2Vec2 P = impulse * u;
|
||||
|
||||
cA -= m_invMassA * P;
|
||||
aA -= m_invIA * b2Cross(rA, P);
|
||||
cB += m_invMassB * P;
|
||||
aB += m_invIB * b2Cross(rB, P);
|
||||
|
||||
data.positions[m_indexA].c = cA;
|
||||
data.positions[m_indexA].a = aA;
|
||||
data.positions[m_indexB].c = cB;
|
||||
data.positions[m_indexB].a = aB;
|
||||
|
||||
return b2Abs(C) < b2_linearSlop;
|
||||
}
|
||||
|
||||
b2Vec2 b2DistanceJoint::GetAnchorA() const
|
||||
{
|
||||
return m_bodyA->GetWorldPoint(m_localAnchorA);
|
||||
}
|
||||
|
||||
b2Vec2 b2DistanceJoint::GetAnchorB() const
|
||||
{
|
||||
return m_bodyB->GetWorldPoint(m_localAnchorB);
|
||||
}
|
||||
|
||||
b2Vec2 b2DistanceJoint::GetReactionForce(float32 inv_dt) const
|
||||
{
|
||||
b2Vec2 F = (inv_dt * m_impulse) * m_u;
|
||||
return F;
|
||||
}
|
||||
|
||||
float32 b2DistanceJoint::GetReactionTorque(float32 inv_dt) const
|
||||
{
|
||||
B2_NOT_USED(inv_dt);
|
||||
return 0.0f;
|
||||
}
|
||||
|
||||
void b2DistanceJoint::Dump()
|
||||
{
|
||||
int32 indexA = m_bodyA->m_islandIndex;
|
||||
int32 indexB = m_bodyB->m_islandIndex;
|
||||
|
||||
b2Log(" b2DistanceJointDef jd;\n");
|
||||
b2Log(" jd.bodyA = bodies[%d];\n", indexA);
|
||||
b2Log(" jd.bodyB = bodies[%d];\n", indexB);
|
||||
b2Log(" jd.collideConnected = bool(%d);\n", m_collideConnected);
|
||||
b2Log(" jd.localAnchorA.Set(%.15lef, %.15lef);\n", m_localAnchorA.x, m_localAnchorA.y);
|
||||
b2Log(" jd.localAnchorB.Set(%.15lef, %.15lef);\n", m_localAnchorB.x, m_localAnchorB.y);
|
||||
b2Log(" jd.length = %.15lef;\n", m_length);
|
||||
b2Log(" jd.frequencyHz = %.15lef;\n", m_frequencyHz);
|
||||
b2Log(" jd.dampingRatio = %.15lef;\n", m_dampingRatio);
|
||||
b2Log(" joints[%d] = m_world->CreateJoint(&jd);\n", m_index);
|
||||
}
|
||||
|
||||
@@ -1,169 +1,169 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2007 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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;
|
||||
localAnchorA.Set(0.0f, 0.0f);
|
||||
localAnchorB.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* bodyA, b2Body* bodyB,
|
||||
const b2Vec2& anchorA, const b2Vec2& anchorB);
|
||||
|
||||
/// The local anchor point relative to bodyA's origin.
|
||||
b2Vec2 localAnchorA;
|
||||
|
||||
/// The local anchor point relative to bodyB's origin.
|
||||
b2Vec2 localAnchorB;
|
||||
|
||||
/// The natural length between the anchor points.
|
||||
float32 length;
|
||||
|
||||
/// The mass-spring-damper frequency in Hertz. A value of 0
|
||||
/// disables softness.
|
||||
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 GetAnchorA() const;
|
||||
b2Vec2 GetAnchorB() const;
|
||||
|
||||
/// Get the reaction force given the inverse time step.
|
||||
/// Unit is N.
|
||||
b2Vec2 GetReactionForce(float32 inv_dt) const;
|
||||
|
||||
/// Get the reaction torque given the inverse time step.
|
||||
/// Unit is N*m. This is always zero for a distance joint.
|
||||
float32 GetReactionTorque(float32 inv_dt) const;
|
||||
|
||||
/// The local anchor point relative to bodyA's origin.
|
||||
const b2Vec2& GetLocalAnchorA() const { return m_localAnchorA; }
|
||||
|
||||
/// The local anchor point relative to bodyB's origin.
|
||||
const b2Vec2& GetLocalAnchorB() const { return m_localAnchorB; }
|
||||
|
||||
/// Set/get the natural length.
|
||||
/// Manipulating the length can lead to non-physical behavior when the frequency is zero.
|
||||
void SetLength(float32 length);
|
||||
float32 GetLength() const;
|
||||
|
||||
/// Set/get frequency in Hz.
|
||||
void SetFrequency(float32 hz);
|
||||
float32 GetFrequency() const;
|
||||
|
||||
/// Set/get damping ratio.
|
||||
void SetDampingRatio(float32 ratio);
|
||||
float32 GetDampingRatio() const;
|
||||
|
||||
/// Dump joint to dmLog
|
||||
void Dump();
|
||||
|
||||
protected:
|
||||
|
||||
friend class b2Joint;
|
||||
b2DistanceJoint(const b2DistanceJointDef* data);
|
||||
|
||||
void InitVelocityConstraints(const b2SolverData& data);
|
||||
void SolveVelocityConstraints(const b2SolverData& data);
|
||||
bool SolvePositionConstraints(const b2SolverData& data);
|
||||
|
||||
float32 m_frequencyHz;
|
||||
float32 m_dampingRatio;
|
||||
float32 m_bias;
|
||||
|
||||
// Solver shared
|
||||
b2Vec2 m_localAnchorA;
|
||||
b2Vec2 m_localAnchorB;
|
||||
float32 m_gamma;
|
||||
float32 m_impulse;
|
||||
float32 m_length;
|
||||
|
||||
// Solver temp
|
||||
juce::int32 m_indexA;
|
||||
juce::int32 m_indexB;
|
||||
b2Vec2 m_u;
|
||||
b2Vec2 m_rA;
|
||||
b2Vec2 m_rB;
|
||||
b2Vec2 m_localCenterA;
|
||||
b2Vec2 m_localCenterB;
|
||||
float32 m_invMassA;
|
||||
float32 m_invMassB;
|
||||
float32 m_invIA;
|
||||
float32 m_invIB;
|
||||
float32 m_mass;
|
||||
};
|
||||
|
||||
inline void b2DistanceJoint::SetLength(float32 length)
|
||||
{
|
||||
m_length = length;
|
||||
}
|
||||
|
||||
inline float32 b2DistanceJoint::GetLength() const
|
||||
{
|
||||
return m_length;
|
||||
}
|
||||
|
||||
inline void b2DistanceJoint::SetFrequency(float32 hz)
|
||||
{
|
||||
m_frequencyHz = hz;
|
||||
}
|
||||
|
||||
inline float32 b2DistanceJoint::GetFrequency() const
|
||||
{
|
||||
return m_frequencyHz;
|
||||
}
|
||||
|
||||
inline void b2DistanceJoint::SetDampingRatio(float32 ratio)
|
||||
{
|
||||
m_dampingRatio = ratio;
|
||||
}
|
||||
|
||||
inline float32 b2DistanceJoint::GetDampingRatio() const
|
||||
{
|
||||
return m_dampingRatio;
|
||||
}
|
||||
|
||||
#endif
|
||||
/*
|
||||
* Copyright (c) 2006-2007 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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;
|
||||
localAnchorA.Set(0.0f, 0.0f);
|
||||
localAnchorB.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* bodyA, b2Body* bodyB,
|
||||
const b2Vec2& anchorA, const b2Vec2& anchorB);
|
||||
|
||||
/// The local anchor point relative to bodyA's origin.
|
||||
b2Vec2 localAnchorA;
|
||||
|
||||
/// The local anchor point relative to bodyB's origin.
|
||||
b2Vec2 localAnchorB;
|
||||
|
||||
/// The natural length between the anchor points.
|
||||
float32 length;
|
||||
|
||||
/// The mass-spring-damper frequency in Hertz. A value of 0
|
||||
/// disables softness.
|
||||
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 GetAnchorA() const;
|
||||
b2Vec2 GetAnchorB() const;
|
||||
|
||||
/// Get the reaction force given the inverse time step.
|
||||
/// Unit is N.
|
||||
b2Vec2 GetReactionForce(float32 inv_dt) const;
|
||||
|
||||
/// Get the reaction torque given the inverse time step.
|
||||
/// Unit is N*m. This is always zero for a distance joint.
|
||||
float32 GetReactionTorque(float32 inv_dt) const;
|
||||
|
||||
/// The local anchor point relative to bodyA's origin.
|
||||
const b2Vec2& GetLocalAnchorA() const { return m_localAnchorA; }
|
||||
|
||||
/// The local anchor point relative to bodyB's origin.
|
||||
const b2Vec2& GetLocalAnchorB() const { return m_localAnchorB; }
|
||||
|
||||
/// Set/get the natural length.
|
||||
/// Manipulating the length can lead to non-physical behavior when the frequency is zero.
|
||||
void SetLength(float32 length);
|
||||
float32 GetLength() const;
|
||||
|
||||
/// Set/get frequency in Hz.
|
||||
void SetFrequency(float32 hz);
|
||||
float32 GetFrequency() const;
|
||||
|
||||
/// Set/get damping ratio.
|
||||
void SetDampingRatio(float32 ratio);
|
||||
float32 GetDampingRatio() const;
|
||||
|
||||
/// Dump joint to dmLog
|
||||
void Dump();
|
||||
|
||||
protected:
|
||||
|
||||
friend class b2Joint;
|
||||
b2DistanceJoint(const b2DistanceJointDef* data);
|
||||
|
||||
void InitVelocityConstraints(const b2SolverData& data);
|
||||
void SolveVelocityConstraints(const b2SolverData& data);
|
||||
bool SolvePositionConstraints(const b2SolverData& data);
|
||||
|
||||
float32 m_frequencyHz;
|
||||
float32 m_dampingRatio;
|
||||
float32 m_bias;
|
||||
|
||||
// Solver shared
|
||||
b2Vec2 m_localAnchorA;
|
||||
b2Vec2 m_localAnchorB;
|
||||
float32 m_gamma;
|
||||
float32 m_impulse;
|
||||
float32 m_length;
|
||||
|
||||
// Solver temp
|
||||
juce::int32 m_indexA;
|
||||
juce::int32 m_indexB;
|
||||
b2Vec2 m_u;
|
||||
b2Vec2 m_rA;
|
||||
b2Vec2 m_rB;
|
||||
b2Vec2 m_localCenterA;
|
||||
b2Vec2 m_localCenterB;
|
||||
float32 m_invMassA;
|
||||
float32 m_invMassB;
|
||||
float32 m_invIA;
|
||||
float32 m_invIB;
|
||||
float32 m_mass;
|
||||
};
|
||||
|
||||
inline void b2DistanceJoint::SetLength(float32 length)
|
||||
{
|
||||
m_length = length;
|
||||
}
|
||||
|
||||
inline float32 b2DistanceJoint::GetLength() const
|
||||
{
|
||||
return m_length;
|
||||
}
|
||||
|
||||
inline void b2DistanceJoint::SetFrequency(float32 hz)
|
||||
{
|
||||
m_frequencyHz = hz;
|
||||
}
|
||||
|
||||
inline float32 b2DistanceJoint::GetFrequency() const
|
||||
{
|
||||
return m_frequencyHz;
|
||||
}
|
||||
|
||||
inline void b2DistanceJoint::SetDampingRatio(float32 ratio)
|
||||
{
|
||||
m_dampingRatio = ratio;
|
||||
}
|
||||
|
||||
inline float32 b2DistanceJoint::GetDampingRatio() const
|
||||
{
|
||||
return m_dampingRatio;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,251 +1,251 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "b2FrictionJoint.h"
|
||||
#include "../b2Body.h"
|
||||
#include "../b2TimeStep.h"
|
||||
|
||||
// Point-to-point constraint
|
||||
// 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)
|
||||
|
||||
// Angle constraint
|
||||
// Cdot = w2 - w1
|
||||
// J = [0 0 -1 0 0 1]
|
||||
// K = invI1 + invI2
|
||||
|
||||
void b2FrictionJointDef::Initialize(b2Body* bA, b2Body* bB, const b2Vec2& anchor)
|
||||
{
|
||||
bodyA = bA;
|
||||
bodyB = bB;
|
||||
localAnchorA = bodyA->GetLocalPoint(anchor);
|
||||
localAnchorB = bodyB->GetLocalPoint(anchor);
|
||||
}
|
||||
|
||||
b2FrictionJoint::b2FrictionJoint(const b2FrictionJointDef* def)
|
||||
: b2Joint(def)
|
||||
{
|
||||
m_localAnchorA = def->localAnchorA;
|
||||
m_localAnchorB = def->localAnchorB;
|
||||
|
||||
m_linearImpulse.SetZero();
|
||||
m_angularImpulse = 0.0f;
|
||||
|
||||
m_maxForce = def->maxForce;
|
||||
m_maxTorque = def->maxTorque;
|
||||
}
|
||||
|
||||
void b2FrictionJoint::InitVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
m_indexA = m_bodyA->m_islandIndex;
|
||||
m_indexB = m_bodyB->m_islandIndex;
|
||||
m_localCenterA = m_bodyA->m_sweep.localCenter;
|
||||
m_localCenterB = m_bodyB->m_sweep.localCenter;
|
||||
m_invMassA = m_bodyA->m_invMass;
|
||||
m_invMassB = m_bodyB->m_invMass;
|
||||
m_invIA = m_bodyA->m_invI;
|
||||
m_invIB = m_bodyB->m_invI;
|
||||
|
||||
float32 aA = data.positions[m_indexA].a;
|
||||
b2Vec2 vA = data.velocities[m_indexA].v;
|
||||
float32 wA = data.velocities[m_indexA].w;
|
||||
|
||||
float32 aB = data.positions[m_indexB].a;
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
|
||||
b2Rot qA(aA), qB(aB);
|
||||
|
||||
// Compute the effective mass matrix.
|
||||
m_rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
|
||||
m_rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
|
||||
|
||||
// J = [-I -r1_skew I r2_skew]
|
||||
// [ 0 -1 0 1]
|
||||
// r_skew = [-ry; rx]
|
||||
|
||||
// Matlab
|
||||
// K = [ mA+r1y^2*iA+mB+r2y^2*iB, -r1y*iA*r1x-r2y*iB*r2x, -r1y*iA-r2y*iB]
|
||||
// [ -r1y*iA*r1x-r2y*iB*r2x, mA+r1x^2*iA+mB+r2x^2*iB, r1x*iA+r2x*iB]
|
||||
// [ -r1y*iA-r2y*iB, r1x*iA+r2x*iB, iA+iB]
|
||||
|
||||
float32 mA = m_invMassA, mB = m_invMassB;
|
||||
float32 iA = m_invIA, iB = m_invIB;
|
||||
|
||||
b2Mat22 K;
|
||||
K.ex.x = mA + mB + iA * m_rA.y * m_rA.y + iB * m_rB.y * m_rB.y;
|
||||
K.ex.y = -iA * m_rA.x * m_rA.y - iB * m_rB.x * m_rB.y;
|
||||
K.ey.x = K.ex.y;
|
||||
K.ey.y = mA + mB + iA * m_rA.x * m_rA.x + iB * m_rB.x * m_rB.x;
|
||||
|
||||
m_linearMass = K.GetInverse();
|
||||
|
||||
m_angularMass = iA + iB;
|
||||
if (m_angularMass > 0.0f)
|
||||
{
|
||||
m_angularMass = 1.0f / m_angularMass;
|
||||
}
|
||||
|
||||
if (data.step.warmStarting)
|
||||
{
|
||||
// Scale impulses to support a variable time step.
|
||||
m_linearImpulse *= data.step.dtRatio;
|
||||
m_angularImpulse *= data.step.dtRatio;
|
||||
|
||||
b2Vec2 P(m_linearImpulse.x, m_linearImpulse.y);
|
||||
vA -= mA * P;
|
||||
wA -= iA * (b2Cross(m_rA, P) + m_angularImpulse);
|
||||
vB += mB * P;
|
||||
wB += iB * (b2Cross(m_rB, P) + m_angularImpulse);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_linearImpulse.SetZero();
|
||||
m_angularImpulse = 0.0f;
|
||||
}
|
||||
|
||||
data.velocities[m_indexA].v = vA;
|
||||
data.velocities[m_indexA].w = wA;
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
}
|
||||
|
||||
void b2FrictionJoint::SolveVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
b2Vec2 vA = data.velocities[m_indexA].v;
|
||||
float32 wA = data.velocities[m_indexA].w;
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
|
||||
float32 mA = m_invMassA, mB = m_invMassB;
|
||||
float32 iA = m_invIA, iB = m_invIB;
|
||||
|
||||
float32 h = data.step.dt;
|
||||
|
||||
// Solve angular friction
|
||||
{
|
||||
float32 Cdot = wB - wA;
|
||||
float32 impulse = -m_angularMass * Cdot;
|
||||
|
||||
float32 oldImpulse = m_angularImpulse;
|
||||
float32 maxImpulse = h * m_maxTorque;
|
||||
m_angularImpulse = b2Clamp(m_angularImpulse + impulse, -maxImpulse, maxImpulse);
|
||||
impulse = m_angularImpulse - oldImpulse;
|
||||
|
||||
wA -= iA * impulse;
|
||||
wB += iB * impulse;
|
||||
}
|
||||
|
||||
// Solve linear friction
|
||||
{
|
||||
b2Vec2 Cdot = vB + b2Cross(wB, m_rB) - vA - b2Cross(wA, m_rA);
|
||||
|
||||
b2Vec2 impulse = -b2Mul(m_linearMass, Cdot);
|
||||
b2Vec2 oldImpulse = m_linearImpulse;
|
||||
m_linearImpulse += impulse;
|
||||
|
||||
float32 maxImpulse = h * m_maxForce;
|
||||
|
||||
if (m_linearImpulse.LengthSquared() > maxImpulse * maxImpulse)
|
||||
{
|
||||
m_linearImpulse.Normalize();
|
||||
m_linearImpulse *= maxImpulse;
|
||||
}
|
||||
|
||||
impulse = m_linearImpulse - oldImpulse;
|
||||
|
||||
vA -= mA * impulse;
|
||||
wA -= iA * b2Cross(m_rA, impulse);
|
||||
|
||||
vB += mB * impulse;
|
||||
wB += iB * b2Cross(m_rB, impulse);
|
||||
}
|
||||
|
||||
data.velocities[m_indexA].v = vA;
|
||||
data.velocities[m_indexA].w = wA;
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
}
|
||||
|
||||
bool b2FrictionJoint::SolvePositionConstraints(const b2SolverData& data)
|
||||
{
|
||||
B2_NOT_USED(data);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
b2Vec2 b2FrictionJoint::GetAnchorA() const
|
||||
{
|
||||
return m_bodyA->GetWorldPoint(m_localAnchorA);
|
||||
}
|
||||
|
||||
b2Vec2 b2FrictionJoint::GetAnchorB() const
|
||||
{
|
||||
return m_bodyB->GetWorldPoint(m_localAnchorB);
|
||||
}
|
||||
|
||||
b2Vec2 b2FrictionJoint::GetReactionForce(float32 inv_dt) const
|
||||
{
|
||||
return inv_dt * m_linearImpulse;
|
||||
}
|
||||
|
||||
float32 b2FrictionJoint::GetReactionTorque(float32 inv_dt) const
|
||||
{
|
||||
return inv_dt * m_angularImpulse;
|
||||
}
|
||||
|
||||
void b2FrictionJoint::SetMaxForce(float32 force)
|
||||
{
|
||||
b2Assert(b2IsValid(force) && force >= 0.0f);
|
||||
m_maxForce = force;
|
||||
}
|
||||
|
||||
float32 b2FrictionJoint::GetMaxForce() const
|
||||
{
|
||||
return m_maxForce;
|
||||
}
|
||||
|
||||
void b2FrictionJoint::SetMaxTorque(float32 torque)
|
||||
{
|
||||
b2Assert(b2IsValid(torque) && torque >= 0.0f);
|
||||
m_maxTorque = torque;
|
||||
}
|
||||
|
||||
float32 b2FrictionJoint::GetMaxTorque() const
|
||||
{
|
||||
return m_maxTorque;
|
||||
}
|
||||
|
||||
void b2FrictionJoint::Dump()
|
||||
{
|
||||
int32 indexA = m_bodyA->m_islandIndex;
|
||||
int32 indexB = m_bodyB->m_islandIndex;
|
||||
|
||||
b2Log(" b2FrictionJointDef jd;\n");
|
||||
b2Log(" jd.bodyA = bodies[%d];\n", indexA);
|
||||
b2Log(" jd.bodyB = bodies[%d];\n", indexB);
|
||||
b2Log(" jd.collideConnected = bool(%d);\n", m_collideConnected);
|
||||
b2Log(" jd.localAnchorA.Set(%.15lef, %.15lef);\n", m_localAnchorA.x, m_localAnchorA.y);
|
||||
b2Log(" jd.localAnchorB.Set(%.15lef, %.15lef);\n", m_localAnchorB.x, m_localAnchorB.y);
|
||||
b2Log(" jd.maxForce = %.15lef;\n", m_maxForce);
|
||||
b2Log(" jd.maxTorque = %.15lef;\n", m_maxTorque);
|
||||
b2Log(" joints[%d] = m_world->CreateJoint(&jd);\n", m_index);
|
||||
}
|
||||
/*
|
||||
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "b2FrictionJoint.h"
|
||||
#include "../b2Body.h"
|
||||
#include "../b2TimeStep.h"
|
||||
|
||||
// Point-to-point constraint
|
||||
// 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)
|
||||
|
||||
// Angle constraint
|
||||
// Cdot = w2 - w1
|
||||
// J = [0 0 -1 0 0 1]
|
||||
// K = invI1 + invI2
|
||||
|
||||
void b2FrictionJointDef::Initialize(b2Body* bA, b2Body* bB, const b2Vec2& anchor)
|
||||
{
|
||||
bodyA = bA;
|
||||
bodyB = bB;
|
||||
localAnchorA = bodyA->GetLocalPoint(anchor);
|
||||
localAnchorB = bodyB->GetLocalPoint(anchor);
|
||||
}
|
||||
|
||||
b2FrictionJoint::b2FrictionJoint(const b2FrictionJointDef* def)
|
||||
: b2Joint(def)
|
||||
{
|
||||
m_localAnchorA = def->localAnchorA;
|
||||
m_localAnchorB = def->localAnchorB;
|
||||
|
||||
m_linearImpulse.SetZero();
|
||||
m_angularImpulse = 0.0f;
|
||||
|
||||
m_maxForce = def->maxForce;
|
||||
m_maxTorque = def->maxTorque;
|
||||
}
|
||||
|
||||
void b2FrictionJoint::InitVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
m_indexA = m_bodyA->m_islandIndex;
|
||||
m_indexB = m_bodyB->m_islandIndex;
|
||||
m_localCenterA = m_bodyA->m_sweep.localCenter;
|
||||
m_localCenterB = m_bodyB->m_sweep.localCenter;
|
||||
m_invMassA = m_bodyA->m_invMass;
|
||||
m_invMassB = m_bodyB->m_invMass;
|
||||
m_invIA = m_bodyA->m_invI;
|
||||
m_invIB = m_bodyB->m_invI;
|
||||
|
||||
float32 aA = data.positions[m_indexA].a;
|
||||
b2Vec2 vA = data.velocities[m_indexA].v;
|
||||
float32 wA = data.velocities[m_indexA].w;
|
||||
|
||||
float32 aB = data.positions[m_indexB].a;
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
|
||||
b2Rot qA(aA), qB(aB);
|
||||
|
||||
// Compute the effective mass matrix.
|
||||
m_rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
|
||||
m_rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
|
||||
|
||||
// J = [-I -r1_skew I r2_skew]
|
||||
// [ 0 -1 0 1]
|
||||
// r_skew = [-ry; rx]
|
||||
|
||||
// Matlab
|
||||
// K = [ mA+r1y^2*iA+mB+r2y^2*iB, -r1y*iA*r1x-r2y*iB*r2x, -r1y*iA-r2y*iB]
|
||||
// [ -r1y*iA*r1x-r2y*iB*r2x, mA+r1x^2*iA+mB+r2x^2*iB, r1x*iA+r2x*iB]
|
||||
// [ -r1y*iA-r2y*iB, r1x*iA+r2x*iB, iA+iB]
|
||||
|
||||
float32 mA = m_invMassA, mB = m_invMassB;
|
||||
float32 iA = m_invIA, iB = m_invIB;
|
||||
|
||||
b2Mat22 K;
|
||||
K.ex.x = mA + mB + iA * m_rA.y * m_rA.y + iB * m_rB.y * m_rB.y;
|
||||
K.ex.y = -iA * m_rA.x * m_rA.y - iB * m_rB.x * m_rB.y;
|
||||
K.ey.x = K.ex.y;
|
||||
K.ey.y = mA + mB + iA * m_rA.x * m_rA.x + iB * m_rB.x * m_rB.x;
|
||||
|
||||
m_linearMass = K.GetInverse();
|
||||
|
||||
m_angularMass = iA + iB;
|
||||
if (m_angularMass > 0.0f)
|
||||
{
|
||||
m_angularMass = 1.0f / m_angularMass;
|
||||
}
|
||||
|
||||
if (data.step.warmStarting)
|
||||
{
|
||||
// Scale impulses to support a variable time step.
|
||||
m_linearImpulse *= data.step.dtRatio;
|
||||
m_angularImpulse *= data.step.dtRatio;
|
||||
|
||||
b2Vec2 P(m_linearImpulse.x, m_linearImpulse.y);
|
||||
vA -= mA * P;
|
||||
wA -= iA * (b2Cross(m_rA, P) + m_angularImpulse);
|
||||
vB += mB * P;
|
||||
wB += iB * (b2Cross(m_rB, P) + m_angularImpulse);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_linearImpulse.SetZero();
|
||||
m_angularImpulse = 0.0f;
|
||||
}
|
||||
|
||||
data.velocities[m_indexA].v = vA;
|
||||
data.velocities[m_indexA].w = wA;
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
}
|
||||
|
||||
void b2FrictionJoint::SolveVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
b2Vec2 vA = data.velocities[m_indexA].v;
|
||||
float32 wA = data.velocities[m_indexA].w;
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
|
||||
float32 mA = m_invMassA, mB = m_invMassB;
|
||||
float32 iA = m_invIA, iB = m_invIB;
|
||||
|
||||
float32 h = data.step.dt;
|
||||
|
||||
// Solve angular friction
|
||||
{
|
||||
float32 Cdot = wB - wA;
|
||||
float32 impulse = -m_angularMass * Cdot;
|
||||
|
||||
float32 oldImpulse = m_angularImpulse;
|
||||
float32 maxImpulse = h * m_maxTorque;
|
||||
m_angularImpulse = b2Clamp(m_angularImpulse + impulse, -maxImpulse, maxImpulse);
|
||||
impulse = m_angularImpulse - oldImpulse;
|
||||
|
||||
wA -= iA * impulse;
|
||||
wB += iB * impulse;
|
||||
}
|
||||
|
||||
// Solve linear friction
|
||||
{
|
||||
b2Vec2 Cdot = vB + b2Cross(wB, m_rB) - vA - b2Cross(wA, m_rA);
|
||||
|
||||
b2Vec2 impulse = -b2Mul(m_linearMass, Cdot);
|
||||
b2Vec2 oldImpulse = m_linearImpulse;
|
||||
m_linearImpulse += impulse;
|
||||
|
||||
float32 maxImpulse = h * m_maxForce;
|
||||
|
||||
if (m_linearImpulse.LengthSquared() > maxImpulse * maxImpulse)
|
||||
{
|
||||
m_linearImpulse.Normalize();
|
||||
m_linearImpulse *= maxImpulse;
|
||||
}
|
||||
|
||||
impulse = m_linearImpulse - oldImpulse;
|
||||
|
||||
vA -= mA * impulse;
|
||||
wA -= iA * b2Cross(m_rA, impulse);
|
||||
|
||||
vB += mB * impulse;
|
||||
wB += iB * b2Cross(m_rB, impulse);
|
||||
}
|
||||
|
||||
data.velocities[m_indexA].v = vA;
|
||||
data.velocities[m_indexA].w = wA;
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
}
|
||||
|
||||
bool b2FrictionJoint::SolvePositionConstraints(const b2SolverData& data)
|
||||
{
|
||||
B2_NOT_USED(data);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
b2Vec2 b2FrictionJoint::GetAnchorA() const
|
||||
{
|
||||
return m_bodyA->GetWorldPoint(m_localAnchorA);
|
||||
}
|
||||
|
||||
b2Vec2 b2FrictionJoint::GetAnchorB() const
|
||||
{
|
||||
return m_bodyB->GetWorldPoint(m_localAnchorB);
|
||||
}
|
||||
|
||||
b2Vec2 b2FrictionJoint::GetReactionForce(float32 inv_dt) const
|
||||
{
|
||||
return inv_dt * m_linearImpulse;
|
||||
}
|
||||
|
||||
float32 b2FrictionJoint::GetReactionTorque(float32 inv_dt) const
|
||||
{
|
||||
return inv_dt * m_angularImpulse;
|
||||
}
|
||||
|
||||
void b2FrictionJoint::SetMaxForce(float32 force)
|
||||
{
|
||||
b2Assert(b2IsValid(force) && force >= 0.0f);
|
||||
m_maxForce = force;
|
||||
}
|
||||
|
||||
float32 b2FrictionJoint::GetMaxForce() const
|
||||
{
|
||||
return m_maxForce;
|
||||
}
|
||||
|
||||
void b2FrictionJoint::SetMaxTorque(float32 torque)
|
||||
{
|
||||
b2Assert(b2IsValid(torque) && torque >= 0.0f);
|
||||
m_maxTorque = torque;
|
||||
}
|
||||
|
||||
float32 b2FrictionJoint::GetMaxTorque() const
|
||||
{
|
||||
return m_maxTorque;
|
||||
}
|
||||
|
||||
void b2FrictionJoint::Dump()
|
||||
{
|
||||
int32 indexA = m_bodyA->m_islandIndex;
|
||||
int32 indexB = m_bodyB->m_islandIndex;
|
||||
|
||||
b2Log(" b2FrictionJointDef jd;\n");
|
||||
b2Log(" jd.bodyA = bodies[%d];\n", indexA);
|
||||
b2Log(" jd.bodyB = bodies[%d];\n", indexB);
|
||||
b2Log(" jd.collideConnected = bool(%d);\n", m_collideConnected);
|
||||
b2Log(" jd.localAnchorA.Set(%.15lef, %.15lef);\n", m_localAnchorA.x, m_localAnchorA.y);
|
||||
b2Log(" jd.localAnchorB.Set(%.15lef, %.15lef);\n", m_localAnchorB.x, m_localAnchorB.y);
|
||||
b2Log(" jd.maxForce = %.15lef;\n", m_maxForce);
|
||||
b2Log(" jd.maxTorque = %.15lef;\n", m_maxTorque);
|
||||
b2Log(" joints[%d] = m_world->CreateJoint(&jd);\n", m_index);
|
||||
}
|
||||
|
||||
@@ -1,119 +1,119 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2007 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_FRICTION_JOINT_H
|
||||
#define B2_FRICTION_JOINT_H
|
||||
|
||||
#include "b2Joint.h"
|
||||
|
||||
/// Friction joint definition.
|
||||
struct b2FrictionJointDef : public b2JointDef
|
||||
{
|
||||
b2FrictionJointDef()
|
||||
{
|
||||
type = e_frictionJoint;
|
||||
localAnchorA.SetZero();
|
||||
localAnchorB.SetZero();
|
||||
maxForce = 0.0f;
|
||||
maxTorque = 0.0f;
|
||||
}
|
||||
|
||||
/// Initialize the bodies, anchors, axis, and reference angle using the world
|
||||
/// anchor and world axis.
|
||||
void Initialize(b2Body* bodyA, b2Body* bodyB, const b2Vec2& anchor);
|
||||
|
||||
/// The local anchor point relative to bodyA's origin.
|
||||
b2Vec2 localAnchorA;
|
||||
|
||||
/// The local anchor point relative to bodyB's origin.
|
||||
b2Vec2 localAnchorB;
|
||||
|
||||
/// The maximum friction force in N.
|
||||
float32 maxForce;
|
||||
|
||||
/// The maximum friction torque in N-m.
|
||||
float32 maxTorque;
|
||||
};
|
||||
|
||||
/// Friction joint. This is used for top-down friction.
|
||||
/// It provides 2D translational friction and angular friction.
|
||||
class b2FrictionJoint : public b2Joint
|
||||
{
|
||||
public:
|
||||
b2Vec2 GetAnchorA() const;
|
||||
b2Vec2 GetAnchorB() const;
|
||||
|
||||
b2Vec2 GetReactionForce(float32 inv_dt) const;
|
||||
float32 GetReactionTorque(float32 inv_dt) const;
|
||||
|
||||
/// The local anchor point relative to bodyA's origin.
|
||||
const b2Vec2& GetLocalAnchorA() const { return m_localAnchorA; }
|
||||
|
||||
/// The local anchor point relative to bodyB's origin.
|
||||
const b2Vec2& GetLocalAnchorB() const { return m_localAnchorB; }
|
||||
|
||||
/// Set the maximum friction force in N.
|
||||
void SetMaxForce(float32 force);
|
||||
|
||||
/// Get the maximum friction force in N.
|
||||
float32 GetMaxForce() const;
|
||||
|
||||
/// Set the maximum friction torque in N*m.
|
||||
void SetMaxTorque(float32 torque);
|
||||
|
||||
/// Get the maximum friction torque in N*m.
|
||||
float32 GetMaxTorque() const;
|
||||
|
||||
/// Dump joint to dmLog
|
||||
void Dump();
|
||||
|
||||
protected:
|
||||
|
||||
friend class b2Joint;
|
||||
|
||||
b2FrictionJoint(const b2FrictionJointDef* def);
|
||||
|
||||
void InitVelocityConstraints(const b2SolverData& data);
|
||||
void SolveVelocityConstraints(const b2SolverData& data);
|
||||
bool SolvePositionConstraints(const b2SolverData& data);
|
||||
|
||||
b2Vec2 m_localAnchorA;
|
||||
b2Vec2 m_localAnchorB;
|
||||
|
||||
// Solver shared
|
||||
b2Vec2 m_linearImpulse;
|
||||
float32 m_angularImpulse;
|
||||
float32 m_maxForce;
|
||||
float32 m_maxTorque;
|
||||
|
||||
// Solver temp
|
||||
juce::int32 m_indexA;
|
||||
juce::int32 m_indexB;
|
||||
b2Vec2 m_rA;
|
||||
b2Vec2 m_rB;
|
||||
b2Vec2 m_localCenterA;
|
||||
b2Vec2 m_localCenterB;
|
||||
float32 m_invMassA;
|
||||
float32 m_invMassB;
|
||||
float32 m_invIA;
|
||||
float32 m_invIB;
|
||||
b2Mat22 m_linearMass;
|
||||
float32 m_angularMass;
|
||||
};
|
||||
|
||||
#endif
|
||||
/*
|
||||
* Copyright (c) 2006-2007 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_FRICTION_JOINT_H
|
||||
#define B2_FRICTION_JOINT_H
|
||||
|
||||
#include "b2Joint.h"
|
||||
|
||||
/// Friction joint definition.
|
||||
struct b2FrictionJointDef : public b2JointDef
|
||||
{
|
||||
b2FrictionJointDef()
|
||||
{
|
||||
type = e_frictionJoint;
|
||||
localAnchorA.SetZero();
|
||||
localAnchorB.SetZero();
|
||||
maxForce = 0.0f;
|
||||
maxTorque = 0.0f;
|
||||
}
|
||||
|
||||
/// Initialize the bodies, anchors, axis, and reference angle using the world
|
||||
/// anchor and world axis.
|
||||
void Initialize(b2Body* bodyA, b2Body* bodyB, const b2Vec2& anchor);
|
||||
|
||||
/// The local anchor point relative to bodyA's origin.
|
||||
b2Vec2 localAnchorA;
|
||||
|
||||
/// The local anchor point relative to bodyB's origin.
|
||||
b2Vec2 localAnchorB;
|
||||
|
||||
/// The maximum friction force in N.
|
||||
float32 maxForce;
|
||||
|
||||
/// The maximum friction torque in N-m.
|
||||
float32 maxTorque;
|
||||
};
|
||||
|
||||
/// Friction joint. This is used for top-down friction.
|
||||
/// It provides 2D translational friction and angular friction.
|
||||
class b2FrictionJoint : public b2Joint
|
||||
{
|
||||
public:
|
||||
b2Vec2 GetAnchorA() const;
|
||||
b2Vec2 GetAnchorB() const;
|
||||
|
||||
b2Vec2 GetReactionForce(float32 inv_dt) const;
|
||||
float32 GetReactionTorque(float32 inv_dt) const;
|
||||
|
||||
/// The local anchor point relative to bodyA's origin.
|
||||
const b2Vec2& GetLocalAnchorA() const { return m_localAnchorA; }
|
||||
|
||||
/// The local anchor point relative to bodyB's origin.
|
||||
const b2Vec2& GetLocalAnchorB() const { return m_localAnchorB; }
|
||||
|
||||
/// Set the maximum friction force in N.
|
||||
void SetMaxForce(float32 force);
|
||||
|
||||
/// Get the maximum friction force in N.
|
||||
float32 GetMaxForce() const;
|
||||
|
||||
/// Set the maximum friction torque in N*m.
|
||||
void SetMaxTorque(float32 torque);
|
||||
|
||||
/// Get the maximum friction torque in N*m.
|
||||
float32 GetMaxTorque() const;
|
||||
|
||||
/// Dump joint to dmLog
|
||||
void Dump();
|
||||
|
||||
protected:
|
||||
|
||||
friend class b2Joint;
|
||||
|
||||
b2FrictionJoint(const b2FrictionJointDef* def);
|
||||
|
||||
void InitVelocityConstraints(const b2SolverData& data);
|
||||
void SolveVelocityConstraints(const b2SolverData& data);
|
||||
bool SolvePositionConstraints(const b2SolverData& data);
|
||||
|
||||
b2Vec2 m_localAnchorA;
|
||||
b2Vec2 m_localAnchorB;
|
||||
|
||||
// Solver shared
|
||||
b2Vec2 m_linearImpulse;
|
||||
float32 m_angularImpulse;
|
||||
float32 m_maxForce;
|
||||
float32 m_maxTorque;
|
||||
|
||||
// Solver temp
|
||||
juce::int32 m_indexA;
|
||||
juce::int32 m_indexB;
|
||||
b2Vec2 m_rA;
|
||||
b2Vec2 m_rB;
|
||||
b2Vec2 m_localCenterA;
|
||||
b2Vec2 m_localCenterB;
|
||||
float32 m_invMassA;
|
||||
float32 m_invMassB;
|
||||
float32 m_invIA;
|
||||
float32 m_invIB;
|
||||
b2Mat22 m_linearMass;
|
||||
float32 m_angularMass;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,419 +1,419 @@
|
||||
/*
|
||||
* Copyright (c) 2007-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "../b2TimeStep.h"
|
||||
|
||||
// Gear Joint:
|
||||
// C0 = (coordinate1 + ratio * coordinate2)_initial
|
||||
// C = (coordinate1 + ratio * coordinate2) - C0 = 0
|
||||
// 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)
|
||||
{
|
||||
m_joint1 = def->joint1;
|
||||
m_joint2 = def->joint2;
|
||||
|
||||
m_typeA = m_joint1->GetType();
|
||||
m_typeB = m_joint2->GetType();
|
||||
|
||||
b2Assert(m_typeA == e_revoluteJoint || m_typeA == e_prismaticJoint);
|
||||
b2Assert(m_typeB == e_revoluteJoint || m_typeB == e_prismaticJoint);
|
||||
|
||||
float32 coordinateA, coordinateB;
|
||||
|
||||
// TODO_ERIN there might be some problem with the joint edges in b2Joint.
|
||||
|
||||
m_bodyC = m_joint1->GetBodyA();
|
||||
m_bodyA = m_joint1->GetBodyB();
|
||||
|
||||
// Get geometry of joint1
|
||||
b2Transform xfA = m_bodyA->m_xf;
|
||||
float32 aA = m_bodyA->m_sweep.a;
|
||||
b2Transform xfC = m_bodyC->m_xf;
|
||||
float32 aC = m_bodyC->m_sweep.a;
|
||||
|
||||
if (m_typeA == e_revoluteJoint)
|
||||
{
|
||||
b2RevoluteJoint* revolute = (b2RevoluteJoint*)def->joint1;
|
||||
m_localAnchorC = revolute->m_localAnchorA;
|
||||
m_localAnchorA = revolute->m_localAnchorB;
|
||||
m_referenceAngleA = revolute->m_referenceAngle;
|
||||
m_localAxisC.SetZero();
|
||||
|
||||
coordinateA = aA - aC - m_referenceAngleA;
|
||||
}
|
||||
else
|
||||
{
|
||||
b2PrismaticJoint* prismatic = (b2PrismaticJoint*)def->joint1;
|
||||
m_localAnchorC = prismatic->m_localAnchorA;
|
||||
m_localAnchorA = prismatic->m_localAnchorB;
|
||||
m_referenceAngleA = prismatic->m_referenceAngle;
|
||||
m_localAxisC = prismatic->m_localXAxisA;
|
||||
|
||||
b2Vec2 pC = m_localAnchorC;
|
||||
b2Vec2 pA = b2MulT(xfC.q, b2Mul(xfA.q, m_localAnchorA) + (xfA.p - xfC.p));
|
||||
coordinateA = b2Dot(pA - pC, m_localAxisC);
|
||||
}
|
||||
|
||||
m_bodyD = m_joint2->GetBodyA();
|
||||
m_bodyB = m_joint2->GetBodyB();
|
||||
|
||||
// Get geometry of joint2
|
||||
b2Transform xfB = m_bodyB->m_xf;
|
||||
float32 aB = m_bodyB->m_sweep.a;
|
||||
b2Transform xfD = m_bodyD->m_xf;
|
||||
float32 aD = m_bodyD->m_sweep.a;
|
||||
|
||||
if (m_typeB == e_revoluteJoint)
|
||||
{
|
||||
b2RevoluteJoint* revolute = (b2RevoluteJoint*)def->joint2;
|
||||
m_localAnchorD = revolute->m_localAnchorA;
|
||||
m_localAnchorB = revolute->m_localAnchorB;
|
||||
m_referenceAngleB = revolute->m_referenceAngle;
|
||||
m_localAxisD.SetZero();
|
||||
|
||||
coordinateB = aB - aD - m_referenceAngleB;
|
||||
}
|
||||
else
|
||||
{
|
||||
b2PrismaticJoint* prismatic = (b2PrismaticJoint*)def->joint2;
|
||||
m_localAnchorD = prismatic->m_localAnchorA;
|
||||
m_localAnchorB = prismatic->m_localAnchorB;
|
||||
m_referenceAngleB = prismatic->m_referenceAngle;
|
||||
m_localAxisD = prismatic->m_localXAxisA;
|
||||
|
||||
b2Vec2 pD = m_localAnchorD;
|
||||
b2Vec2 pB = b2MulT(xfD.q, b2Mul(xfB.q, m_localAnchorB) + (xfB.p - xfD.p));
|
||||
coordinateB = b2Dot(pB - pD, m_localAxisD);
|
||||
}
|
||||
|
||||
m_ratio = def->ratio;
|
||||
|
||||
m_constant = coordinateA + m_ratio * coordinateB;
|
||||
|
||||
m_impulse = 0.0f;
|
||||
}
|
||||
|
||||
void b2GearJoint::InitVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
m_indexA = m_bodyA->m_islandIndex;
|
||||
m_indexB = m_bodyB->m_islandIndex;
|
||||
m_indexC = m_bodyC->m_islandIndex;
|
||||
m_indexD = m_bodyD->m_islandIndex;
|
||||
m_lcA = m_bodyA->m_sweep.localCenter;
|
||||
m_lcB = m_bodyB->m_sweep.localCenter;
|
||||
m_lcC = m_bodyC->m_sweep.localCenter;
|
||||
m_lcD = m_bodyD->m_sweep.localCenter;
|
||||
m_mA = m_bodyA->m_invMass;
|
||||
m_mB = m_bodyB->m_invMass;
|
||||
m_mC = m_bodyC->m_invMass;
|
||||
m_mD = m_bodyD->m_invMass;
|
||||
m_iA = m_bodyA->m_invI;
|
||||
m_iB = m_bodyB->m_invI;
|
||||
m_iC = m_bodyC->m_invI;
|
||||
m_iD = m_bodyD->m_invI;
|
||||
|
||||
float32 aA = data.positions[m_indexA].a;
|
||||
b2Vec2 vA = data.velocities[m_indexA].v;
|
||||
float32 wA = data.velocities[m_indexA].w;
|
||||
|
||||
float32 aB = data.positions[m_indexB].a;
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
|
||||
float32 aC = data.positions[m_indexC].a;
|
||||
b2Vec2 vC = data.velocities[m_indexC].v;
|
||||
float32 wC = data.velocities[m_indexC].w;
|
||||
|
||||
float32 aD = data.positions[m_indexD].a;
|
||||
b2Vec2 vD = data.velocities[m_indexD].v;
|
||||
float32 wD = data.velocities[m_indexD].w;
|
||||
|
||||
b2Rot qA(aA), qB(aB), qC(aC), qD(aD);
|
||||
|
||||
m_mass = 0.0f;
|
||||
|
||||
if (m_typeA == e_revoluteJoint)
|
||||
{
|
||||
m_JvAC.SetZero();
|
||||
m_JwA = 1.0f;
|
||||
m_JwC = 1.0f;
|
||||
m_mass += m_iA + m_iC;
|
||||
}
|
||||
else
|
||||
{
|
||||
b2Vec2 u = b2Mul(qC, m_localAxisC);
|
||||
b2Vec2 rC = b2Mul(qC, m_localAnchorC - m_lcC);
|
||||
b2Vec2 rA = b2Mul(qA, m_localAnchorA - m_lcA);
|
||||
m_JvAC = u;
|
||||
m_JwC = b2Cross(rC, u);
|
||||
m_JwA = b2Cross(rA, u);
|
||||
m_mass += m_mC + m_mA + m_iC * m_JwC * m_JwC + m_iA * m_JwA * m_JwA;
|
||||
}
|
||||
|
||||
if (m_typeB == e_revoluteJoint)
|
||||
{
|
||||
m_JvBD.SetZero();
|
||||
m_JwB = m_ratio;
|
||||
m_JwD = m_ratio;
|
||||
m_mass += m_ratio * m_ratio * (m_iB + m_iD);
|
||||
}
|
||||
else
|
||||
{
|
||||
b2Vec2 u = b2Mul(qD, m_localAxisD);
|
||||
b2Vec2 rD = b2Mul(qD, m_localAnchorD - m_lcD);
|
||||
b2Vec2 rB = b2Mul(qB, m_localAnchorB - m_lcB);
|
||||
m_JvBD = m_ratio * u;
|
||||
m_JwD = m_ratio * b2Cross(rD, u);
|
||||
m_JwB = m_ratio * b2Cross(rB, u);
|
||||
m_mass += m_ratio * m_ratio * (m_mD + m_mB) + m_iD * m_JwD * m_JwD + m_iB * m_JwB * m_JwB;
|
||||
}
|
||||
|
||||
// Compute effective mass.
|
||||
m_mass = m_mass > 0.0f ? 1.0f / m_mass : 0.0f;
|
||||
|
||||
if (data.step.warmStarting)
|
||||
{
|
||||
vA += (m_mA * m_impulse) * m_JvAC;
|
||||
wA += m_iA * m_impulse * m_JwA;
|
||||
vB += (m_mB * m_impulse) * m_JvBD;
|
||||
wB += m_iB * m_impulse * m_JwB;
|
||||
vC -= (m_mC * m_impulse) * m_JvAC;
|
||||
wC -= m_iC * m_impulse * m_JwC;
|
||||
vD -= (m_mD * m_impulse) * m_JvBD;
|
||||
wD -= m_iD * m_impulse * m_JwD;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_impulse = 0.0f;
|
||||
}
|
||||
|
||||
data.velocities[m_indexA].v = vA;
|
||||
data.velocities[m_indexA].w = wA;
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
data.velocities[m_indexC].v = vC;
|
||||
data.velocities[m_indexC].w = wC;
|
||||
data.velocities[m_indexD].v = vD;
|
||||
data.velocities[m_indexD].w = wD;
|
||||
}
|
||||
|
||||
void b2GearJoint::SolveVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
b2Vec2 vA = data.velocities[m_indexA].v;
|
||||
float32 wA = data.velocities[m_indexA].w;
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
b2Vec2 vC = data.velocities[m_indexC].v;
|
||||
float32 wC = data.velocities[m_indexC].w;
|
||||
b2Vec2 vD = data.velocities[m_indexD].v;
|
||||
float32 wD = data.velocities[m_indexD].w;
|
||||
|
||||
float32 Cdot = b2Dot(m_JvAC, vA - vC) + b2Dot(m_JvBD, vB - vD);
|
||||
Cdot += (m_JwA * wA - m_JwC * wC) + (m_JwB * wB - m_JwD * wD);
|
||||
|
||||
float32 impulse = -m_mass * Cdot;
|
||||
m_impulse += impulse;
|
||||
|
||||
vA += (m_mA * impulse) * m_JvAC;
|
||||
wA += m_iA * impulse * m_JwA;
|
||||
vB += (m_mB * impulse) * m_JvBD;
|
||||
wB += m_iB * impulse * m_JwB;
|
||||
vC -= (m_mC * impulse) * m_JvAC;
|
||||
wC -= m_iC * impulse * m_JwC;
|
||||
vD -= (m_mD * impulse) * m_JvBD;
|
||||
wD -= m_iD * impulse * m_JwD;
|
||||
|
||||
data.velocities[m_indexA].v = vA;
|
||||
data.velocities[m_indexA].w = wA;
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
data.velocities[m_indexC].v = vC;
|
||||
data.velocities[m_indexC].w = wC;
|
||||
data.velocities[m_indexD].v = vD;
|
||||
data.velocities[m_indexD].w = wD;
|
||||
}
|
||||
|
||||
bool b2GearJoint::SolvePositionConstraints(const b2SolverData& data)
|
||||
{
|
||||
b2Vec2 cA = data.positions[m_indexA].c;
|
||||
float32 aA = data.positions[m_indexA].a;
|
||||
b2Vec2 cB = data.positions[m_indexB].c;
|
||||
float32 aB = data.positions[m_indexB].a;
|
||||
b2Vec2 cC = data.positions[m_indexC].c;
|
||||
float32 aC = data.positions[m_indexC].a;
|
||||
b2Vec2 cD = data.positions[m_indexD].c;
|
||||
float32 aD = data.positions[m_indexD].a;
|
||||
|
||||
b2Rot qA(aA), qB(aB), qC(aC), qD(aD);
|
||||
|
||||
float32 linearError = 0.0f;
|
||||
|
||||
float32 coordinateA, coordinateB;
|
||||
|
||||
b2Vec2 JvAC, JvBD;
|
||||
float32 JwA, JwB, JwC, JwD;
|
||||
float32 mass = 0.0f;
|
||||
|
||||
if (m_typeA == e_revoluteJoint)
|
||||
{
|
||||
JvAC.SetZero();
|
||||
JwA = 1.0f;
|
||||
JwC = 1.0f;
|
||||
mass += m_iA + m_iC;
|
||||
|
||||
coordinateA = aA - aC - m_referenceAngleA;
|
||||
}
|
||||
else
|
||||
{
|
||||
b2Vec2 u = b2Mul(qC, m_localAxisC);
|
||||
b2Vec2 rC = b2Mul(qC, m_localAnchorC - m_lcC);
|
||||
b2Vec2 rA = b2Mul(qA, m_localAnchorA - m_lcA);
|
||||
JvAC = u;
|
||||
JwC = b2Cross(rC, u);
|
||||
JwA = b2Cross(rA, u);
|
||||
mass += m_mC + m_mA + m_iC * JwC * JwC + m_iA * JwA * JwA;
|
||||
|
||||
b2Vec2 pC = m_localAnchorC - m_lcC;
|
||||
b2Vec2 pA = b2MulT(qC, rA + (cA - cC));
|
||||
coordinateA = b2Dot(pA - pC, m_localAxisC);
|
||||
}
|
||||
|
||||
if (m_typeB == e_revoluteJoint)
|
||||
{
|
||||
JvBD.SetZero();
|
||||
JwB = m_ratio;
|
||||
JwD = m_ratio;
|
||||
mass += m_ratio * m_ratio * (m_iB + m_iD);
|
||||
|
||||
coordinateB = aB - aD - m_referenceAngleB;
|
||||
}
|
||||
else
|
||||
{
|
||||
b2Vec2 u = b2Mul(qD, m_localAxisD);
|
||||
b2Vec2 rD = b2Mul(qD, m_localAnchorD - m_lcD);
|
||||
b2Vec2 rB = b2Mul(qB, m_localAnchorB - m_lcB);
|
||||
JvBD = m_ratio * u;
|
||||
JwD = m_ratio * b2Cross(rD, u);
|
||||
JwB = m_ratio * b2Cross(rB, u);
|
||||
mass += m_ratio * m_ratio * (m_mD + m_mB) + m_iD * JwD * JwD + m_iB * JwB * JwB;
|
||||
|
||||
b2Vec2 pD = m_localAnchorD - m_lcD;
|
||||
b2Vec2 pB = b2MulT(qD, rB + (cB - cD));
|
||||
coordinateB = b2Dot(pB - pD, m_localAxisD);
|
||||
}
|
||||
|
||||
float32 C = (coordinateA + m_ratio * coordinateB) - m_constant;
|
||||
|
||||
float32 impulse = 0.0f;
|
||||
if (mass > 0.0f)
|
||||
{
|
||||
impulse = -C / mass;
|
||||
}
|
||||
|
||||
cA += m_mA * impulse * JvAC;
|
||||
aA += m_iA * impulse * JwA;
|
||||
cB += m_mB * impulse * JvBD;
|
||||
aB += m_iB * impulse * JwB;
|
||||
cC -= m_mC * impulse * JvAC;
|
||||
aC -= m_iC * impulse * JwC;
|
||||
cD -= m_mD * impulse * JvBD;
|
||||
aD -= m_iD * impulse * JwD;
|
||||
|
||||
data.positions[m_indexA].c = cA;
|
||||
data.positions[m_indexA].a = aA;
|
||||
data.positions[m_indexB].c = cB;
|
||||
data.positions[m_indexB].a = aB;
|
||||
data.positions[m_indexC].c = cC;
|
||||
data.positions[m_indexC].a = aC;
|
||||
data.positions[m_indexD].c = cD;
|
||||
data.positions[m_indexD].a = aD;
|
||||
|
||||
// TODO_ERIN not implemented
|
||||
return linearError < b2_linearSlop;
|
||||
}
|
||||
|
||||
b2Vec2 b2GearJoint::GetAnchorA() const
|
||||
{
|
||||
return m_bodyA->GetWorldPoint(m_localAnchorA);
|
||||
}
|
||||
|
||||
b2Vec2 b2GearJoint::GetAnchorB() const
|
||||
{
|
||||
return m_bodyB->GetWorldPoint(m_localAnchorB);
|
||||
}
|
||||
|
||||
b2Vec2 b2GearJoint::GetReactionForce(float32 inv_dt) const
|
||||
{
|
||||
b2Vec2 P = m_impulse * m_JvAC;
|
||||
return inv_dt * P;
|
||||
}
|
||||
|
||||
float32 b2GearJoint::GetReactionTorque(float32 inv_dt) const
|
||||
{
|
||||
float32 L = m_impulse * m_JwA;
|
||||
return inv_dt * L;
|
||||
}
|
||||
|
||||
void b2GearJoint::SetRatio(float32 ratio)
|
||||
{
|
||||
b2Assert(b2IsValid(ratio));
|
||||
m_ratio = ratio;
|
||||
}
|
||||
|
||||
float32 b2GearJoint::GetRatio() const
|
||||
{
|
||||
return m_ratio;
|
||||
}
|
||||
|
||||
void b2GearJoint::Dump()
|
||||
{
|
||||
int32 indexA = m_bodyA->m_islandIndex;
|
||||
int32 indexB = m_bodyB->m_islandIndex;
|
||||
|
||||
int32 index1 = m_joint1->m_index;
|
||||
int32 index2 = m_joint2->m_index;
|
||||
|
||||
b2Log(" b2GearJointDef jd;\n");
|
||||
b2Log(" jd.bodyA = bodies[%d];\n", indexA);
|
||||
b2Log(" jd.bodyB = bodies[%d];\n", indexB);
|
||||
b2Log(" jd.collideConnected = bool(%d);\n", m_collideConnected);
|
||||
b2Log(" jd.joint1 = joints[%d];\n", index1);
|
||||
b2Log(" jd.joint2 = joints[%d];\n", index2);
|
||||
b2Log(" jd.ratio = %.15lef;\n", m_ratio);
|
||||
b2Log(" joints[%d] = m_world->CreateJoint(&jd);\n", m_index);
|
||||
}
|
||||
/*
|
||||
* Copyright (c) 2007-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "../b2TimeStep.h"
|
||||
|
||||
// Gear Joint:
|
||||
// C0 = (coordinate1 + ratio * coordinate2)_initial
|
||||
// C = (coordinate1 + ratio * coordinate2) - C0 = 0
|
||||
// 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)
|
||||
{
|
||||
m_joint1 = def->joint1;
|
||||
m_joint2 = def->joint2;
|
||||
|
||||
m_typeA = m_joint1->GetType();
|
||||
m_typeB = m_joint2->GetType();
|
||||
|
||||
b2Assert(m_typeA == e_revoluteJoint || m_typeA == e_prismaticJoint);
|
||||
b2Assert(m_typeB == e_revoluteJoint || m_typeB == e_prismaticJoint);
|
||||
|
||||
float32 coordinateA, coordinateB;
|
||||
|
||||
// TODO_ERIN there might be some problem with the joint edges in b2Joint.
|
||||
|
||||
m_bodyC = m_joint1->GetBodyA();
|
||||
m_bodyA = m_joint1->GetBodyB();
|
||||
|
||||
// Get geometry of joint1
|
||||
b2Transform xfA = m_bodyA->m_xf;
|
||||
float32 aA = m_bodyA->m_sweep.a;
|
||||
b2Transform xfC = m_bodyC->m_xf;
|
||||
float32 aC = m_bodyC->m_sweep.a;
|
||||
|
||||
if (m_typeA == e_revoluteJoint)
|
||||
{
|
||||
b2RevoluteJoint* revolute = (b2RevoluteJoint*)def->joint1;
|
||||
m_localAnchorC = revolute->m_localAnchorA;
|
||||
m_localAnchorA = revolute->m_localAnchorB;
|
||||
m_referenceAngleA = revolute->m_referenceAngle;
|
||||
m_localAxisC.SetZero();
|
||||
|
||||
coordinateA = aA - aC - m_referenceAngleA;
|
||||
}
|
||||
else
|
||||
{
|
||||
b2PrismaticJoint* prismatic = (b2PrismaticJoint*)def->joint1;
|
||||
m_localAnchorC = prismatic->m_localAnchorA;
|
||||
m_localAnchorA = prismatic->m_localAnchorB;
|
||||
m_referenceAngleA = prismatic->m_referenceAngle;
|
||||
m_localAxisC = prismatic->m_localXAxisA;
|
||||
|
||||
b2Vec2 pC = m_localAnchorC;
|
||||
b2Vec2 pA = b2MulT(xfC.q, b2Mul(xfA.q, m_localAnchorA) + (xfA.p - xfC.p));
|
||||
coordinateA = b2Dot(pA - pC, m_localAxisC);
|
||||
}
|
||||
|
||||
m_bodyD = m_joint2->GetBodyA();
|
||||
m_bodyB = m_joint2->GetBodyB();
|
||||
|
||||
// Get geometry of joint2
|
||||
b2Transform xfB = m_bodyB->m_xf;
|
||||
float32 aB = m_bodyB->m_sweep.a;
|
||||
b2Transform xfD = m_bodyD->m_xf;
|
||||
float32 aD = m_bodyD->m_sweep.a;
|
||||
|
||||
if (m_typeB == e_revoluteJoint)
|
||||
{
|
||||
b2RevoluteJoint* revolute = (b2RevoluteJoint*)def->joint2;
|
||||
m_localAnchorD = revolute->m_localAnchorA;
|
||||
m_localAnchorB = revolute->m_localAnchorB;
|
||||
m_referenceAngleB = revolute->m_referenceAngle;
|
||||
m_localAxisD.SetZero();
|
||||
|
||||
coordinateB = aB - aD - m_referenceAngleB;
|
||||
}
|
||||
else
|
||||
{
|
||||
b2PrismaticJoint* prismatic = (b2PrismaticJoint*)def->joint2;
|
||||
m_localAnchorD = prismatic->m_localAnchorA;
|
||||
m_localAnchorB = prismatic->m_localAnchorB;
|
||||
m_referenceAngleB = prismatic->m_referenceAngle;
|
||||
m_localAxisD = prismatic->m_localXAxisA;
|
||||
|
||||
b2Vec2 pD = m_localAnchorD;
|
||||
b2Vec2 pB = b2MulT(xfD.q, b2Mul(xfB.q, m_localAnchorB) + (xfB.p - xfD.p));
|
||||
coordinateB = b2Dot(pB - pD, m_localAxisD);
|
||||
}
|
||||
|
||||
m_ratio = def->ratio;
|
||||
|
||||
m_constant = coordinateA + m_ratio * coordinateB;
|
||||
|
||||
m_impulse = 0.0f;
|
||||
}
|
||||
|
||||
void b2GearJoint::InitVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
m_indexA = m_bodyA->m_islandIndex;
|
||||
m_indexB = m_bodyB->m_islandIndex;
|
||||
m_indexC = m_bodyC->m_islandIndex;
|
||||
m_indexD = m_bodyD->m_islandIndex;
|
||||
m_lcA = m_bodyA->m_sweep.localCenter;
|
||||
m_lcB = m_bodyB->m_sweep.localCenter;
|
||||
m_lcC = m_bodyC->m_sweep.localCenter;
|
||||
m_lcD = m_bodyD->m_sweep.localCenter;
|
||||
m_mA = m_bodyA->m_invMass;
|
||||
m_mB = m_bodyB->m_invMass;
|
||||
m_mC = m_bodyC->m_invMass;
|
||||
m_mD = m_bodyD->m_invMass;
|
||||
m_iA = m_bodyA->m_invI;
|
||||
m_iB = m_bodyB->m_invI;
|
||||
m_iC = m_bodyC->m_invI;
|
||||
m_iD = m_bodyD->m_invI;
|
||||
|
||||
float32 aA = data.positions[m_indexA].a;
|
||||
b2Vec2 vA = data.velocities[m_indexA].v;
|
||||
float32 wA = data.velocities[m_indexA].w;
|
||||
|
||||
float32 aB = data.positions[m_indexB].a;
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
|
||||
float32 aC = data.positions[m_indexC].a;
|
||||
b2Vec2 vC = data.velocities[m_indexC].v;
|
||||
float32 wC = data.velocities[m_indexC].w;
|
||||
|
||||
float32 aD = data.positions[m_indexD].a;
|
||||
b2Vec2 vD = data.velocities[m_indexD].v;
|
||||
float32 wD = data.velocities[m_indexD].w;
|
||||
|
||||
b2Rot qA(aA), qB(aB), qC(aC), qD(aD);
|
||||
|
||||
m_mass = 0.0f;
|
||||
|
||||
if (m_typeA == e_revoluteJoint)
|
||||
{
|
||||
m_JvAC.SetZero();
|
||||
m_JwA = 1.0f;
|
||||
m_JwC = 1.0f;
|
||||
m_mass += m_iA + m_iC;
|
||||
}
|
||||
else
|
||||
{
|
||||
b2Vec2 u = b2Mul(qC, m_localAxisC);
|
||||
b2Vec2 rC = b2Mul(qC, m_localAnchorC - m_lcC);
|
||||
b2Vec2 rA = b2Mul(qA, m_localAnchorA - m_lcA);
|
||||
m_JvAC = u;
|
||||
m_JwC = b2Cross(rC, u);
|
||||
m_JwA = b2Cross(rA, u);
|
||||
m_mass += m_mC + m_mA + m_iC * m_JwC * m_JwC + m_iA * m_JwA * m_JwA;
|
||||
}
|
||||
|
||||
if (m_typeB == e_revoluteJoint)
|
||||
{
|
||||
m_JvBD.SetZero();
|
||||
m_JwB = m_ratio;
|
||||
m_JwD = m_ratio;
|
||||
m_mass += m_ratio * m_ratio * (m_iB + m_iD);
|
||||
}
|
||||
else
|
||||
{
|
||||
b2Vec2 u = b2Mul(qD, m_localAxisD);
|
||||
b2Vec2 rD = b2Mul(qD, m_localAnchorD - m_lcD);
|
||||
b2Vec2 rB = b2Mul(qB, m_localAnchorB - m_lcB);
|
||||
m_JvBD = m_ratio * u;
|
||||
m_JwD = m_ratio * b2Cross(rD, u);
|
||||
m_JwB = m_ratio * b2Cross(rB, u);
|
||||
m_mass += m_ratio * m_ratio * (m_mD + m_mB) + m_iD * m_JwD * m_JwD + m_iB * m_JwB * m_JwB;
|
||||
}
|
||||
|
||||
// Compute effective mass.
|
||||
m_mass = m_mass > 0.0f ? 1.0f / m_mass : 0.0f;
|
||||
|
||||
if (data.step.warmStarting)
|
||||
{
|
||||
vA += (m_mA * m_impulse) * m_JvAC;
|
||||
wA += m_iA * m_impulse * m_JwA;
|
||||
vB += (m_mB * m_impulse) * m_JvBD;
|
||||
wB += m_iB * m_impulse * m_JwB;
|
||||
vC -= (m_mC * m_impulse) * m_JvAC;
|
||||
wC -= m_iC * m_impulse * m_JwC;
|
||||
vD -= (m_mD * m_impulse) * m_JvBD;
|
||||
wD -= m_iD * m_impulse * m_JwD;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_impulse = 0.0f;
|
||||
}
|
||||
|
||||
data.velocities[m_indexA].v = vA;
|
||||
data.velocities[m_indexA].w = wA;
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
data.velocities[m_indexC].v = vC;
|
||||
data.velocities[m_indexC].w = wC;
|
||||
data.velocities[m_indexD].v = vD;
|
||||
data.velocities[m_indexD].w = wD;
|
||||
}
|
||||
|
||||
void b2GearJoint::SolveVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
b2Vec2 vA = data.velocities[m_indexA].v;
|
||||
float32 wA = data.velocities[m_indexA].w;
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
b2Vec2 vC = data.velocities[m_indexC].v;
|
||||
float32 wC = data.velocities[m_indexC].w;
|
||||
b2Vec2 vD = data.velocities[m_indexD].v;
|
||||
float32 wD = data.velocities[m_indexD].w;
|
||||
|
||||
float32 Cdot = b2Dot(m_JvAC, vA - vC) + b2Dot(m_JvBD, vB - vD);
|
||||
Cdot += (m_JwA * wA - m_JwC * wC) + (m_JwB * wB - m_JwD * wD);
|
||||
|
||||
float32 impulse = -m_mass * Cdot;
|
||||
m_impulse += impulse;
|
||||
|
||||
vA += (m_mA * impulse) * m_JvAC;
|
||||
wA += m_iA * impulse * m_JwA;
|
||||
vB += (m_mB * impulse) * m_JvBD;
|
||||
wB += m_iB * impulse * m_JwB;
|
||||
vC -= (m_mC * impulse) * m_JvAC;
|
||||
wC -= m_iC * impulse * m_JwC;
|
||||
vD -= (m_mD * impulse) * m_JvBD;
|
||||
wD -= m_iD * impulse * m_JwD;
|
||||
|
||||
data.velocities[m_indexA].v = vA;
|
||||
data.velocities[m_indexA].w = wA;
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
data.velocities[m_indexC].v = vC;
|
||||
data.velocities[m_indexC].w = wC;
|
||||
data.velocities[m_indexD].v = vD;
|
||||
data.velocities[m_indexD].w = wD;
|
||||
}
|
||||
|
||||
bool b2GearJoint::SolvePositionConstraints(const b2SolverData& data)
|
||||
{
|
||||
b2Vec2 cA = data.positions[m_indexA].c;
|
||||
float32 aA = data.positions[m_indexA].a;
|
||||
b2Vec2 cB = data.positions[m_indexB].c;
|
||||
float32 aB = data.positions[m_indexB].a;
|
||||
b2Vec2 cC = data.positions[m_indexC].c;
|
||||
float32 aC = data.positions[m_indexC].a;
|
||||
b2Vec2 cD = data.positions[m_indexD].c;
|
||||
float32 aD = data.positions[m_indexD].a;
|
||||
|
||||
b2Rot qA(aA), qB(aB), qC(aC), qD(aD);
|
||||
|
||||
float32 linearError = 0.0f;
|
||||
|
||||
float32 coordinateA, coordinateB;
|
||||
|
||||
b2Vec2 JvAC, JvBD;
|
||||
float32 JwA, JwB, JwC, JwD;
|
||||
float32 mass = 0.0f;
|
||||
|
||||
if (m_typeA == e_revoluteJoint)
|
||||
{
|
||||
JvAC.SetZero();
|
||||
JwA = 1.0f;
|
||||
JwC = 1.0f;
|
||||
mass += m_iA + m_iC;
|
||||
|
||||
coordinateA = aA - aC - m_referenceAngleA;
|
||||
}
|
||||
else
|
||||
{
|
||||
b2Vec2 u = b2Mul(qC, m_localAxisC);
|
||||
b2Vec2 rC = b2Mul(qC, m_localAnchorC - m_lcC);
|
||||
b2Vec2 rA = b2Mul(qA, m_localAnchorA - m_lcA);
|
||||
JvAC = u;
|
||||
JwC = b2Cross(rC, u);
|
||||
JwA = b2Cross(rA, u);
|
||||
mass += m_mC + m_mA + m_iC * JwC * JwC + m_iA * JwA * JwA;
|
||||
|
||||
b2Vec2 pC = m_localAnchorC - m_lcC;
|
||||
b2Vec2 pA = b2MulT(qC, rA + (cA - cC));
|
||||
coordinateA = b2Dot(pA - pC, m_localAxisC);
|
||||
}
|
||||
|
||||
if (m_typeB == e_revoluteJoint)
|
||||
{
|
||||
JvBD.SetZero();
|
||||
JwB = m_ratio;
|
||||
JwD = m_ratio;
|
||||
mass += m_ratio * m_ratio * (m_iB + m_iD);
|
||||
|
||||
coordinateB = aB - aD - m_referenceAngleB;
|
||||
}
|
||||
else
|
||||
{
|
||||
b2Vec2 u = b2Mul(qD, m_localAxisD);
|
||||
b2Vec2 rD = b2Mul(qD, m_localAnchorD - m_lcD);
|
||||
b2Vec2 rB = b2Mul(qB, m_localAnchorB - m_lcB);
|
||||
JvBD = m_ratio * u;
|
||||
JwD = m_ratio * b2Cross(rD, u);
|
||||
JwB = m_ratio * b2Cross(rB, u);
|
||||
mass += m_ratio * m_ratio * (m_mD + m_mB) + m_iD * JwD * JwD + m_iB * JwB * JwB;
|
||||
|
||||
b2Vec2 pD = m_localAnchorD - m_lcD;
|
||||
b2Vec2 pB = b2MulT(qD, rB + (cB - cD));
|
||||
coordinateB = b2Dot(pB - pD, m_localAxisD);
|
||||
}
|
||||
|
||||
float32 C = (coordinateA + m_ratio * coordinateB) - m_constant;
|
||||
|
||||
float32 impulse = 0.0f;
|
||||
if (mass > 0.0f)
|
||||
{
|
||||
impulse = -C / mass;
|
||||
}
|
||||
|
||||
cA += m_mA * impulse * JvAC;
|
||||
aA += m_iA * impulse * JwA;
|
||||
cB += m_mB * impulse * JvBD;
|
||||
aB += m_iB * impulse * JwB;
|
||||
cC -= m_mC * impulse * JvAC;
|
||||
aC -= m_iC * impulse * JwC;
|
||||
cD -= m_mD * impulse * JvBD;
|
||||
aD -= m_iD * impulse * JwD;
|
||||
|
||||
data.positions[m_indexA].c = cA;
|
||||
data.positions[m_indexA].a = aA;
|
||||
data.positions[m_indexB].c = cB;
|
||||
data.positions[m_indexB].a = aB;
|
||||
data.positions[m_indexC].c = cC;
|
||||
data.positions[m_indexC].a = aC;
|
||||
data.positions[m_indexD].c = cD;
|
||||
data.positions[m_indexD].a = aD;
|
||||
|
||||
// TODO_ERIN not implemented
|
||||
return linearError < b2_linearSlop;
|
||||
}
|
||||
|
||||
b2Vec2 b2GearJoint::GetAnchorA() const
|
||||
{
|
||||
return m_bodyA->GetWorldPoint(m_localAnchorA);
|
||||
}
|
||||
|
||||
b2Vec2 b2GearJoint::GetAnchorB() const
|
||||
{
|
||||
return m_bodyB->GetWorldPoint(m_localAnchorB);
|
||||
}
|
||||
|
||||
b2Vec2 b2GearJoint::GetReactionForce(float32 inv_dt) const
|
||||
{
|
||||
b2Vec2 P = m_impulse * m_JvAC;
|
||||
return inv_dt * P;
|
||||
}
|
||||
|
||||
float32 b2GearJoint::GetReactionTorque(float32 inv_dt) const
|
||||
{
|
||||
float32 L = m_impulse * m_JwA;
|
||||
return inv_dt * L;
|
||||
}
|
||||
|
||||
void b2GearJoint::SetRatio(float32 ratio)
|
||||
{
|
||||
b2Assert(b2IsValid(ratio));
|
||||
m_ratio = ratio;
|
||||
}
|
||||
|
||||
float32 b2GearJoint::GetRatio() const
|
||||
{
|
||||
return m_ratio;
|
||||
}
|
||||
|
||||
void b2GearJoint::Dump()
|
||||
{
|
||||
int32 indexA = m_bodyA->m_islandIndex;
|
||||
int32 indexB = m_bodyB->m_islandIndex;
|
||||
|
||||
int32 index1 = m_joint1->m_index;
|
||||
int32 index2 = m_joint2->m_index;
|
||||
|
||||
b2Log(" b2GearJointDef jd;\n");
|
||||
b2Log(" jd.bodyA = bodies[%d];\n", indexA);
|
||||
b2Log(" jd.bodyB = bodies[%d];\n", indexB);
|
||||
b2Log(" jd.collideConnected = bool(%d);\n", m_collideConnected);
|
||||
b2Log(" jd.joint1 = joints[%d];\n", index1);
|
||||
b2Log(" jd.joint2 = joints[%d];\n", index2);
|
||||
b2Log(" jd.ratio = %.15lef;\n", m_ratio);
|
||||
b2Log(" joints[%d] = m_world->CreateJoint(&jd);\n", m_index);
|
||||
}
|
||||
|
||||
@@ -1,125 +1,125 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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"
|
||||
|
||||
/// Gear joint definition. This definition requires two existing
|
||||
/// revolute or prismatic joints (any combination will work).
|
||||
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 You have to manually destroy the gear joint if joint1 or joint2
|
||||
/// is destroyed.
|
||||
class b2GearJoint : public b2Joint
|
||||
{
|
||||
public:
|
||||
b2Vec2 GetAnchorA() const;
|
||||
b2Vec2 GetAnchorB() const;
|
||||
|
||||
b2Vec2 GetReactionForce(float32 inv_dt) const;
|
||||
float32 GetReactionTorque(float32 inv_dt) const;
|
||||
|
||||
/// Get the first joint.
|
||||
b2Joint* GetJoint1() { return m_joint1; }
|
||||
|
||||
/// Get the second joint.
|
||||
b2Joint* GetJoint2() { return m_joint2; }
|
||||
|
||||
/// Set/Get the gear ratio.
|
||||
void SetRatio(float32 ratio);
|
||||
float32 GetRatio() const;
|
||||
|
||||
/// Dump joint to dmLog
|
||||
void Dump();
|
||||
|
||||
protected:
|
||||
|
||||
friend class b2Joint;
|
||||
b2GearJoint(const b2GearJointDef* data);
|
||||
|
||||
void InitVelocityConstraints(const b2SolverData& data);
|
||||
void SolveVelocityConstraints(const b2SolverData& data);
|
||||
bool SolvePositionConstraints(const b2SolverData& data);
|
||||
|
||||
b2Joint* m_joint1;
|
||||
b2Joint* m_joint2;
|
||||
|
||||
b2JointType m_typeA;
|
||||
b2JointType m_typeB;
|
||||
|
||||
// Body A is connected to body C
|
||||
// Body B is connected to body D
|
||||
b2Body* m_bodyC;
|
||||
b2Body* m_bodyD;
|
||||
|
||||
// Solver shared
|
||||
b2Vec2 m_localAnchorA;
|
||||
b2Vec2 m_localAnchorB;
|
||||
b2Vec2 m_localAnchorC;
|
||||
b2Vec2 m_localAnchorD;
|
||||
|
||||
b2Vec2 m_localAxisC;
|
||||
b2Vec2 m_localAxisD;
|
||||
|
||||
float32 m_referenceAngleA;
|
||||
float32 m_referenceAngleB;
|
||||
|
||||
float32 m_constant;
|
||||
float32 m_ratio;
|
||||
|
||||
float32 m_impulse;
|
||||
|
||||
// Solver temp
|
||||
juce::int32 m_indexA, m_indexB, m_indexC, m_indexD;
|
||||
b2Vec2 m_lcA, m_lcB, m_lcC, m_lcD;
|
||||
float32 m_mA, m_mB, m_mC, m_mD;
|
||||
float32 m_iA, m_iB, m_iC, m_iD;
|
||||
b2Vec2 m_JvAC, m_JvBD;
|
||||
float32 m_JwA, m_JwB, m_JwC, m_JwD;
|
||||
float32 m_mass;
|
||||
};
|
||||
|
||||
#endif
|
||||
/*
|
||||
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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"
|
||||
|
||||
/// Gear joint definition. This definition requires two existing
|
||||
/// revolute or prismatic joints (any combination will work).
|
||||
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 You have to manually destroy the gear joint if joint1 or joint2
|
||||
/// is destroyed.
|
||||
class b2GearJoint : public b2Joint
|
||||
{
|
||||
public:
|
||||
b2Vec2 GetAnchorA() const;
|
||||
b2Vec2 GetAnchorB() const;
|
||||
|
||||
b2Vec2 GetReactionForce(float32 inv_dt) const;
|
||||
float32 GetReactionTorque(float32 inv_dt) const;
|
||||
|
||||
/// Get the first joint.
|
||||
b2Joint* GetJoint1() { return m_joint1; }
|
||||
|
||||
/// Get the second joint.
|
||||
b2Joint* GetJoint2() { return m_joint2; }
|
||||
|
||||
/// Set/Get the gear ratio.
|
||||
void SetRatio(float32 ratio);
|
||||
float32 GetRatio() const;
|
||||
|
||||
/// Dump joint to dmLog
|
||||
void Dump();
|
||||
|
||||
protected:
|
||||
|
||||
friend class b2Joint;
|
||||
b2GearJoint(const b2GearJointDef* data);
|
||||
|
||||
void InitVelocityConstraints(const b2SolverData& data);
|
||||
void SolveVelocityConstraints(const b2SolverData& data);
|
||||
bool SolvePositionConstraints(const b2SolverData& data);
|
||||
|
||||
b2Joint* m_joint1;
|
||||
b2Joint* m_joint2;
|
||||
|
||||
b2JointType m_typeA;
|
||||
b2JointType m_typeB;
|
||||
|
||||
// Body A is connected to body C
|
||||
// Body B is connected to body D
|
||||
b2Body* m_bodyC;
|
||||
b2Body* m_bodyD;
|
||||
|
||||
// Solver shared
|
||||
b2Vec2 m_localAnchorA;
|
||||
b2Vec2 m_localAnchorB;
|
||||
b2Vec2 m_localAnchorC;
|
||||
b2Vec2 m_localAnchorD;
|
||||
|
||||
b2Vec2 m_localAxisC;
|
||||
b2Vec2 m_localAxisD;
|
||||
|
||||
float32 m_referenceAngleA;
|
||||
float32 m_referenceAngleB;
|
||||
|
||||
float32 m_constant;
|
||||
float32 m_ratio;
|
||||
|
||||
float32 m_impulse;
|
||||
|
||||
// Solver temp
|
||||
juce::int32 m_indexA, m_indexB, m_indexC, m_indexD;
|
||||
b2Vec2 m_lcA, m_lcB, m_lcC, m_lcD;
|
||||
float32 m_mA, m_mB, m_mC, m_mD;
|
||||
float32 m_iA, m_iB, m_iC, m_iD;
|
||||
b2Vec2 m_JvAC, m_JvBD;
|
||||
float32 m_JwA, m_JwB, m_JwC, m_JwD;
|
||||
float32 m_mass;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,199 +1,199 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2007 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "b2WheelJoint.h"
|
||||
#include "b2MouseJoint.h"
|
||||
#include "b2RevoluteJoint.h"
|
||||
#include "b2PrismaticJoint.h"
|
||||
#include "b2PulleyJoint.h"
|
||||
#include "b2GearJoint.h"
|
||||
#include "b2WeldJoint.h"
|
||||
#include "b2FrictionJoint.h"
|
||||
#include "b2RopeJoint.h"
|
||||
#include "../b2Body.h"
|
||||
#include "../b2World.h"
|
||||
#include "../../Common/b2BlockAllocator.h"
|
||||
|
||||
#include <new>
|
||||
|
||||
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;
|
||||
|
||||
case e_wheelJoint:
|
||||
{
|
||||
void* mem = allocator->Allocate(sizeof(b2WheelJoint));
|
||||
joint = new (mem) b2WheelJoint((b2WheelJointDef*)def);
|
||||
}
|
||||
break;
|
||||
|
||||
case e_weldJoint:
|
||||
{
|
||||
void* mem = allocator->Allocate(sizeof(b2WeldJoint));
|
||||
joint = new (mem) b2WeldJoint((b2WeldJointDef*)def);
|
||||
}
|
||||
break;
|
||||
|
||||
case e_frictionJoint:
|
||||
{
|
||||
void* mem = allocator->Allocate(sizeof(b2FrictionJoint));
|
||||
joint = new (mem) b2FrictionJoint((b2FrictionJointDef*)def);
|
||||
}
|
||||
break;
|
||||
|
||||
case e_ropeJoint:
|
||||
{
|
||||
void* mem = allocator->Allocate(sizeof(b2RopeJoint));
|
||||
joint = new (mem) b2RopeJoint((b2RopeJointDef*)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;
|
||||
|
||||
case e_wheelJoint:
|
||||
allocator->Free(joint, sizeof(b2WheelJoint));
|
||||
break;
|
||||
|
||||
case e_weldJoint:
|
||||
allocator->Free(joint, sizeof(b2WeldJoint));
|
||||
break;
|
||||
|
||||
case e_frictionJoint:
|
||||
allocator->Free(joint, sizeof(b2FrictionJoint));
|
||||
break;
|
||||
|
||||
case e_ropeJoint:
|
||||
allocator->Free(joint, sizeof(b2RopeJoint));
|
||||
break;
|
||||
|
||||
default:
|
||||
b2Assert(false);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
b2Joint::b2Joint(const b2JointDef* def)
|
||||
{
|
||||
b2Assert(def->bodyA != def->bodyB);
|
||||
|
||||
m_type = def->type;
|
||||
m_prev = NULL;
|
||||
m_next = NULL;
|
||||
m_bodyA = def->bodyA;
|
||||
m_bodyB = def->bodyB;
|
||||
m_index = 0;
|
||||
m_collideConnected = def->collideConnected;
|
||||
m_islandFlag = false;
|
||||
m_userData = def->userData;
|
||||
|
||||
m_edgeA.joint = NULL;
|
||||
m_edgeA.other = NULL;
|
||||
m_edgeA.prev = NULL;
|
||||
m_edgeA.next = NULL;
|
||||
|
||||
m_edgeB.joint = NULL;
|
||||
m_edgeB.other = NULL;
|
||||
m_edgeB.prev = NULL;
|
||||
m_edgeB.next = NULL;
|
||||
}
|
||||
|
||||
bool b2Joint::IsActive() const
|
||||
{
|
||||
return m_bodyA->IsActive() && m_bodyB->IsActive();
|
||||
}
|
||||
/*
|
||||
* Copyright (c) 2006-2007 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "b2WheelJoint.h"
|
||||
#include "b2MouseJoint.h"
|
||||
#include "b2RevoluteJoint.h"
|
||||
#include "b2PrismaticJoint.h"
|
||||
#include "b2PulleyJoint.h"
|
||||
#include "b2GearJoint.h"
|
||||
#include "b2WeldJoint.h"
|
||||
#include "b2FrictionJoint.h"
|
||||
#include "b2RopeJoint.h"
|
||||
#include "../b2Body.h"
|
||||
#include "../b2World.h"
|
||||
#include "../../Common/b2BlockAllocator.h"
|
||||
|
||||
#include <new>
|
||||
|
||||
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;
|
||||
|
||||
case e_wheelJoint:
|
||||
{
|
||||
void* mem = allocator->Allocate(sizeof(b2WheelJoint));
|
||||
joint = new (mem) b2WheelJoint((b2WheelJointDef*)def);
|
||||
}
|
||||
break;
|
||||
|
||||
case e_weldJoint:
|
||||
{
|
||||
void* mem = allocator->Allocate(sizeof(b2WeldJoint));
|
||||
joint = new (mem) b2WeldJoint((b2WeldJointDef*)def);
|
||||
}
|
||||
break;
|
||||
|
||||
case e_frictionJoint:
|
||||
{
|
||||
void* mem = allocator->Allocate(sizeof(b2FrictionJoint));
|
||||
joint = new (mem) b2FrictionJoint((b2FrictionJointDef*)def);
|
||||
}
|
||||
break;
|
||||
|
||||
case e_ropeJoint:
|
||||
{
|
||||
void* mem = allocator->Allocate(sizeof(b2RopeJoint));
|
||||
joint = new (mem) b2RopeJoint((b2RopeJointDef*)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;
|
||||
|
||||
case e_wheelJoint:
|
||||
allocator->Free(joint, sizeof(b2WheelJoint));
|
||||
break;
|
||||
|
||||
case e_weldJoint:
|
||||
allocator->Free(joint, sizeof(b2WeldJoint));
|
||||
break;
|
||||
|
||||
case e_frictionJoint:
|
||||
allocator->Free(joint, sizeof(b2FrictionJoint));
|
||||
break;
|
||||
|
||||
case e_ropeJoint:
|
||||
allocator->Free(joint, sizeof(b2RopeJoint));
|
||||
break;
|
||||
|
||||
default:
|
||||
b2Assert(false);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
b2Joint::b2Joint(const b2JointDef* def)
|
||||
{
|
||||
b2Assert(def->bodyA != def->bodyB);
|
||||
|
||||
m_type = def->type;
|
||||
m_prev = NULL;
|
||||
m_next = NULL;
|
||||
m_bodyA = def->bodyA;
|
||||
m_bodyB = def->bodyB;
|
||||
m_index = 0;
|
||||
m_collideConnected = def->collideConnected;
|
||||
m_islandFlag = false;
|
||||
m_userData = def->userData;
|
||||
|
||||
m_edgeA.joint = NULL;
|
||||
m_edgeA.other = NULL;
|
||||
m_edgeA.prev = NULL;
|
||||
m_edgeA.next = NULL;
|
||||
|
||||
m_edgeB.joint = NULL;
|
||||
m_edgeB.other = NULL;
|
||||
m_edgeB.prev = NULL;
|
||||
m_edgeB.next = NULL;
|
||||
}
|
||||
|
||||
bool b2Joint::IsActive() const
|
||||
{
|
||||
return m_bodyA->IsActive() && m_bodyB->IsActive();
|
||||
}
|
||||
|
||||
@@ -1,222 +1,222 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2007 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_JOINT_H
|
||||
#define B2_JOINT_H
|
||||
|
||||
#include "../../Common/b2Math.h"
|
||||
|
||||
class b2Body;
|
||||
class b2Joint;
|
||||
struct b2SolverData;
|
||||
class b2BlockAllocator;
|
||||
|
||||
enum b2JointType
|
||||
{
|
||||
e_unknownJoint,
|
||||
e_revoluteJoint,
|
||||
e_prismaticJoint,
|
||||
e_distanceJoint,
|
||||
e_pulleyJoint,
|
||||
e_mouseJoint,
|
||||
e_gearJoint,
|
||||
e_wheelJoint,
|
||||
e_weldJoint,
|
||||
e_frictionJoint,
|
||||
e_ropeJoint
|
||||
};
|
||||
|
||||
enum b2LimitState
|
||||
{
|
||||
e_inactiveLimit,
|
||||
e_atLowerLimit,
|
||||
e_atUpperLimit,
|
||||
e_equalLimits
|
||||
};
|
||||
|
||||
struct b2Jacobian
|
||||
{
|
||||
b2Vec2 linear;
|
||||
float32 angularA;
|
||||
float32 angularB;
|
||||
};
|
||||
|
||||
/// 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;
|
||||
bodyA = NULL;
|
||||
bodyB = 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* bodyA;
|
||||
|
||||
/// The second attached body.
|
||||
b2Body* bodyB;
|
||||
|
||||
/// 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* GetBodyA();
|
||||
|
||||
/// Get the second body attached to this joint.
|
||||
b2Body* GetBodyB();
|
||||
|
||||
/// Get the anchor point on bodyA in world coordinates.
|
||||
virtual b2Vec2 GetAnchorA() const = 0;
|
||||
|
||||
/// Get the anchor point on bodyB in world coordinates.
|
||||
virtual b2Vec2 GetAnchorB() const = 0;
|
||||
|
||||
/// Get the reaction force on bodyB at the joint anchor in Newtons.
|
||||
virtual b2Vec2 GetReactionForce(float32 inv_dt) const = 0;
|
||||
|
||||
/// Get the reaction torque on bodyB in N*m.
|
||||
virtual float32 GetReactionTorque(float32 inv_dt) const = 0;
|
||||
|
||||
/// Get the next joint the world joint list.
|
||||
b2Joint* GetNext();
|
||||
const b2Joint* GetNext() const;
|
||||
|
||||
/// Get the user data pointer.
|
||||
void* GetUserData() const;
|
||||
|
||||
/// Set the user data pointer.
|
||||
void SetUserData(void* data);
|
||||
|
||||
/// Short-cut function to determine if either body is inactive.
|
||||
bool IsActive() const;
|
||||
|
||||
/// Get collide connected.
|
||||
/// Note: modifying the collide connect flag won't work correctly because
|
||||
/// the flag is only checked when fixture AABBs begin to overlap.
|
||||
bool GetCollideConnected() const;
|
||||
|
||||
/// Dump this joint to the log file.
|
||||
virtual void Dump() { b2Log("// Dump is not supported for this joint type.\n"); }
|
||||
|
||||
protected:
|
||||
friend class b2World;
|
||||
friend class b2Body;
|
||||
friend class b2Island;
|
||||
friend class b2GearJoint;
|
||||
|
||||
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 b2SolverData& data) = 0;
|
||||
virtual void SolveVelocityConstraints(const b2SolverData& data) = 0;
|
||||
|
||||
// This returns true if the position errors are within tolerance.
|
||||
virtual bool SolvePositionConstraints(const b2SolverData& data) = 0;
|
||||
|
||||
b2JointType m_type;
|
||||
b2Joint* m_prev;
|
||||
b2Joint* m_next;
|
||||
b2JointEdge m_edgeA;
|
||||
b2JointEdge m_edgeB;
|
||||
b2Body* m_bodyA;
|
||||
b2Body* m_bodyB;
|
||||
|
||||
juce::int32 m_index;
|
||||
|
||||
bool m_islandFlag;
|
||||
bool m_collideConnected;
|
||||
|
||||
void* m_userData;
|
||||
};
|
||||
|
||||
inline b2JointType b2Joint::GetType() const
|
||||
{
|
||||
return m_type;
|
||||
}
|
||||
|
||||
inline b2Body* b2Joint::GetBodyA()
|
||||
{
|
||||
return m_bodyA;
|
||||
}
|
||||
|
||||
inline b2Body* b2Joint::GetBodyB()
|
||||
{
|
||||
return m_bodyB;
|
||||
}
|
||||
|
||||
inline b2Joint* b2Joint::GetNext()
|
||||
{
|
||||
return m_next;
|
||||
}
|
||||
|
||||
inline const b2Joint* b2Joint::GetNext() const
|
||||
{
|
||||
return m_next;
|
||||
}
|
||||
|
||||
inline void* b2Joint::GetUserData() const
|
||||
{
|
||||
return m_userData;
|
||||
}
|
||||
|
||||
inline void b2Joint::SetUserData(void* data)
|
||||
{
|
||||
m_userData = data;
|
||||
}
|
||||
|
||||
inline bool b2Joint::GetCollideConnected() const
|
||||
{
|
||||
return m_collideConnected;
|
||||
}
|
||||
|
||||
#endif
|
||||
/*
|
||||
* Copyright (c) 2006-2007 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_JOINT_H
|
||||
#define B2_JOINT_H
|
||||
|
||||
#include "../../Common/b2Math.h"
|
||||
|
||||
class b2Body;
|
||||
class b2Joint;
|
||||
struct b2SolverData;
|
||||
class b2BlockAllocator;
|
||||
|
||||
enum b2JointType
|
||||
{
|
||||
e_unknownJoint,
|
||||
e_revoluteJoint,
|
||||
e_prismaticJoint,
|
||||
e_distanceJoint,
|
||||
e_pulleyJoint,
|
||||
e_mouseJoint,
|
||||
e_gearJoint,
|
||||
e_wheelJoint,
|
||||
e_weldJoint,
|
||||
e_frictionJoint,
|
||||
e_ropeJoint
|
||||
};
|
||||
|
||||
enum b2LimitState
|
||||
{
|
||||
e_inactiveLimit,
|
||||
e_atLowerLimit,
|
||||
e_atUpperLimit,
|
||||
e_equalLimits
|
||||
};
|
||||
|
||||
struct b2Jacobian
|
||||
{
|
||||
b2Vec2 linear;
|
||||
float32 angularA;
|
||||
float32 angularB;
|
||||
};
|
||||
|
||||
/// 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;
|
||||
bodyA = NULL;
|
||||
bodyB = 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* bodyA;
|
||||
|
||||
/// The second attached body.
|
||||
b2Body* bodyB;
|
||||
|
||||
/// 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* GetBodyA();
|
||||
|
||||
/// Get the second body attached to this joint.
|
||||
b2Body* GetBodyB();
|
||||
|
||||
/// Get the anchor point on bodyA in world coordinates.
|
||||
virtual b2Vec2 GetAnchorA() const = 0;
|
||||
|
||||
/// Get the anchor point on bodyB in world coordinates.
|
||||
virtual b2Vec2 GetAnchorB() const = 0;
|
||||
|
||||
/// Get the reaction force on bodyB at the joint anchor in Newtons.
|
||||
virtual b2Vec2 GetReactionForce(float32 inv_dt) const = 0;
|
||||
|
||||
/// Get the reaction torque on bodyB in N*m.
|
||||
virtual float32 GetReactionTorque(float32 inv_dt) const = 0;
|
||||
|
||||
/// Get the next joint the world joint list.
|
||||
b2Joint* GetNext();
|
||||
const b2Joint* GetNext() const;
|
||||
|
||||
/// Get the user data pointer.
|
||||
void* GetUserData() const;
|
||||
|
||||
/// Set the user data pointer.
|
||||
void SetUserData(void* data);
|
||||
|
||||
/// Short-cut function to determine if either body is inactive.
|
||||
bool IsActive() const;
|
||||
|
||||
/// Get collide connected.
|
||||
/// Note: modifying the collide connect flag won't work correctly because
|
||||
/// the flag is only checked when fixture AABBs begin to overlap.
|
||||
bool GetCollideConnected() const;
|
||||
|
||||
/// Dump this joint to the log file.
|
||||
virtual void Dump() { b2Log("// Dump is not supported for this joint type.\n"); }
|
||||
|
||||
protected:
|
||||
friend class b2World;
|
||||
friend class b2Body;
|
||||
friend class b2Island;
|
||||
friend class b2GearJoint;
|
||||
|
||||
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 b2SolverData& data) = 0;
|
||||
virtual void SolveVelocityConstraints(const b2SolverData& data) = 0;
|
||||
|
||||
// This returns true if the position errors are within tolerance.
|
||||
virtual bool SolvePositionConstraints(const b2SolverData& data) = 0;
|
||||
|
||||
b2JointType m_type;
|
||||
b2Joint* m_prev;
|
||||
b2Joint* m_next;
|
||||
b2JointEdge m_edgeA;
|
||||
b2JointEdge m_edgeB;
|
||||
b2Body* m_bodyA;
|
||||
b2Body* m_bodyB;
|
||||
|
||||
juce::int32 m_index;
|
||||
|
||||
bool m_islandFlag;
|
||||
bool m_collideConnected;
|
||||
|
||||
void* m_userData;
|
||||
};
|
||||
|
||||
inline b2JointType b2Joint::GetType() const
|
||||
{
|
||||
return m_type;
|
||||
}
|
||||
|
||||
inline b2Body* b2Joint::GetBodyA()
|
||||
{
|
||||
return m_bodyA;
|
||||
}
|
||||
|
||||
inline b2Body* b2Joint::GetBodyB()
|
||||
{
|
||||
return m_bodyB;
|
||||
}
|
||||
|
||||
inline b2Joint* b2Joint::GetNext()
|
||||
{
|
||||
return m_next;
|
||||
}
|
||||
|
||||
inline const b2Joint* b2Joint::GetNext() const
|
||||
{
|
||||
return m_next;
|
||||
}
|
||||
|
||||
inline void* b2Joint::GetUserData() const
|
||||
{
|
||||
return m_userData;
|
||||
}
|
||||
|
||||
inline void b2Joint::SetUserData(void* data)
|
||||
{
|
||||
m_userData = data;
|
||||
}
|
||||
|
||||
inline bool b2Joint::GetCollideConnected() const
|
||||
{
|
||||
return m_collideConnected;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,217 +1,217 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2007 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "../b2TimeStep.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)
|
||||
{
|
||||
b2Assert(def->target.IsValid());
|
||||
b2Assert(b2IsValid(def->maxForce) && def->maxForce >= 0.0f);
|
||||
b2Assert(b2IsValid(def->frequencyHz) && def->frequencyHz >= 0.0f);
|
||||
b2Assert(b2IsValid(def->dampingRatio) && def->dampingRatio >= 0.0f);
|
||||
|
||||
m_targetA = def->target;
|
||||
m_localAnchorB = b2MulT(m_bodyB->GetTransform(), m_targetA);
|
||||
|
||||
m_maxForce = def->maxForce;
|
||||
m_impulse.SetZero();
|
||||
|
||||
m_frequencyHz = def->frequencyHz;
|
||||
m_dampingRatio = def->dampingRatio;
|
||||
|
||||
m_beta = 0.0f;
|
||||
m_gamma = 0.0f;
|
||||
}
|
||||
|
||||
void b2MouseJoint::SetTarget(const b2Vec2& target)
|
||||
{
|
||||
if (m_bodyB->IsAwake() == false)
|
||||
{
|
||||
m_bodyB->SetAwake(true);
|
||||
}
|
||||
m_targetA = target;
|
||||
}
|
||||
|
||||
const b2Vec2& b2MouseJoint::GetTarget() const
|
||||
{
|
||||
return m_targetA;
|
||||
}
|
||||
|
||||
void b2MouseJoint::SetMaxForce(float32 force)
|
||||
{
|
||||
m_maxForce = force;
|
||||
}
|
||||
|
||||
float32 b2MouseJoint::GetMaxForce() const
|
||||
{
|
||||
return m_maxForce;
|
||||
}
|
||||
|
||||
void b2MouseJoint::SetFrequency(float32 hz)
|
||||
{
|
||||
m_frequencyHz = hz;
|
||||
}
|
||||
|
||||
float32 b2MouseJoint::GetFrequency() const
|
||||
{
|
||||
return m_frequencyHz;
|
||||
}
|
||||
|
||||
void b2MouseJoint::SetDampingRatio(float32 ratio)
|
||||
{
|
||||
m_dampingRatio = ratio;
|
||||
}
|
||||
|
||||
float32 b2MouseJoint::GetDampingRatio() const
|
||||
{
|
||||
return m_dampingRatio;
|
||||
}
|
||||
|
||||
void b2MouseJoint::InitVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
m_indexB = m_bodyB->m_islandIndex;
|
||||
m_localCenterB = m_bodyB->m_sweep.localCenter;
|
||||
m_invMassB = m_bodyB->m_invMass;
|
||||
m_invIB = m_bodyB->m_invI;
|
||||
|
||||
b2Vec2 cB = data.positions[m_indexB].c;
|
||||
float32 aB = data.positions[m_indexB].a;
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
|
||||
b2Rot qB(aB);
|
||||
|
||||
float32 mass = m_bodyB->GetMass();
|
||||
|
||||
// Frequency
|
||||
float32 omega = 2.0f * b2_pi * m_frequencyHz;
|
||||
|
||||
// Damping coefficient
|
||||
float32 d = 2.0f * mass * m_dampingRatio * omega;
|
||||
|
||||
// Spring stiffness
|
||||
float32 k = mass * (omega * omega);
|
||||
|
||||
// magic formulas
|
||||
// gamma has units of inverse mass.
|
||||
// beta has units of inverse time.
|
||||
float32 h = data.step.dt;
|
||||
b2Assert(d + h * k > b2_epsilon);
|
||||
m_gamma = h * (d + h * k);
|
||||
if (m_gamma != 0.0f)
|
||||
{
|
||||
m_gamma = 1.0f / m_gamma;
|
||||
}
|
||||
m_beta = h * k * m_gamma;
|
||||
|
||||
// Compute the effective mass matrix.
|
||||
m_rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
|
||||
|
||||
// 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]
|
||||
b2Mat22 K;
|
||||
K.ex.x = m_invMassB + m_invIB * m_rB.y * m_rB.y + m_gamma;
|
||||
K.ex.y = -m_invIB * m_rB.x * m_rB.y;
|
||||
K.ey.x = K.ex.y;
|
||||
K.ey.y = m_invMassB + m_invIB * m_rB.x * m_rB.x + m_gamma;
|
||||
|
||||
m_mass = K.GetInverse();
|
||||
|
||||
m_C = cB + m_rB - m_targetA;
|
||||
m_C *= m_beta;
|
||||
|
||||
// Cheat with some damping
|
||||
wB *= 0.98f;
|
||||
|
||||
if (data.step.warmStarting)
|
||||
{
|
||||
m_impulse *= data.step.dtRatio;
|
||||
vB += m_invMassB * m_impulse;
|
||||
wB += m_invIB * b2Cross(m_rB, m_impulse);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_impulse.SetZero();
|
||||
}
|
||||
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
}
|
||||
|
||||
void b2MouseJoint::SolveVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
|
||||
// Cdot = v + cross(w, r)
|
||||
b2Vec2 Cdot = vB + b2Cross(wB, m_rB);
|
||||
b2Vec2 impulse = b2Mul(m_mass, -(Cdot + m_C + m_gamma * m_impulse));
|
||||
|
||||
b2Vec2 oldImpulse = m_impulse;
|
||||
m_impulse += impulse;
|
||||
float32 maxImpulse = data.step.dt * m_maxForce;
|
||||
if (m_impulse.LengthSquared() > maxImpulse * maxImpulse)
|
||||
{
|
||||
m_impulse *= maxImpulse / m_impulse.Length();
|
||||
}
|
||||
impulse = m_impulse - oldImpulse;
|
||||
|
||||
vB += m_invMassB * impulse;
|
||||
wB += m_invIB * b2Cross(m_rB, impulse);
|
||||
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
}
|
||||
|
||||
bool b2MouseJoint::SolvePositionConstraints(const b2SolverData& data)
|
||||
{
|
||||
B2_NOT_USED(data);
|
||||
return true;
|
||||
}
|
||||
|
||||
b2Vec2 b2MouseJoint::GetAnchorA() const
|
||||
{
|
||||
return m_targetA;
|
||||
}
|
||||
|
||||
b2Vec2 b2MouseJoint::GetAnchorB() const
|
||||
{
|
||||
return m_bodyB->GetWorldPoint(m_localAnchorB);
|
||||
}
|
||||
|
||||
b2Vec2 b2MouseJoint::GetReactionForce(float32 inv_dt) const
|
||||
{
|
||||
return inv_dt * m_impulse;
|
||||
}
|
||||
|
||||
float32 b2MouseJoint::GetReactionTorque(float32 inv_dt) const
|
||||
{
|
||||
return inv_dt * 0.0f;
|
||||
}
|
||||
/*
|
||||
* Copyright (c) 2006-2007 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "../b2TimeStep.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)
|
||||
{
|
||||
b2Assert(def->target.IsValid());
|
||||
b2Assert(b2IsValid(def->maxForce) && def->maxForce >= 0.0f);
|
||||
b2Assert(b2IsValid(def->frequencyHz) && def->frequencyHz >= 0.0f);
|
||||
b2Assert(b2IsValid(def->dampingRatio) && def->dampingRatio >= 0.0f);
|
||||
|
||||
m_targetA = def->target;
|
||||
m_localAnchorB = b2MulT(m_bodyB->GetTransform(), m_targetA);
|
||||
|
||||
m_maxForce = def->maxForce;
|
||||
m_impulse.SetZero();
|
||||
|
||||
m_frequencyHz = def->frequencyHz;
|
||||
m_dampingRatio = def->dampingRatio;
|
||||
|
||||
m_beta = 0.0f;
|
||||
m_gamma = 0.0f;
|
||||
}
|
||||
|
||||
void b2MouseJoint::SetTarget(const b2Vec2& target)
|
||||
{
|
||||
if (m_bodyB->IsAwake() == false)
|
||||
{
|
||||
m_bodyB->SetAwake(true);
|
||||
}
|
||||
m_targetA = target;
|
||||
}
|
||||
|
||||
const b2Vec2& b2MouseJoint::GetTarget() const
|
||||
{
|
||||
return m_targetA;
|
||||
}
|
||||
|
||||
void b2MouseJoint::SetMaxForce(float32 force)
|
||||
{
|
||||
m_maxForce = force;
|
||||
}
|
||||
|
||||
float32 b2MouseJoint::GetMaxForce() const
|
||||
{
|
||||
return m_maxForce;
|
||||
}
|
||||
|
||||
void b2MouseJoint::SetFrequency(float32 hz)
|
||||
{
|
||||
m_frequencyHz = hz;
|
||||
}
|
||||
|
||||
float32 b2MouseJoint::GetFrequency() const
|
||||
{
|
||||
return m_frequencyHz;
|
||||
}
|
||||
|
||||
void b2MouseJoint::SetDampingRatio(float32 ratio)
|
||||
{
|
||||
m_dampingRatio = ratio;
|
||||
}
|
||||
|
||||
float32 b2MouseJoint::GetDampingRatio() const
|
||||
{
|
||||
return m_dampingRatio;
|
||||
}
|
||||
|
||||
void b2MouseJoint::InitVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
m_indexB = m_bodyB->m_islandIndex;
|
||||
m_localCenterB = m_bodyB->m_sweep.localCenter;
|
||||
m_invMassB = m_bodyB->m_invMass;
|
||||
m_invIB = m_bodyB->m_invI;
|
||||
|
||||
b2Vec2 cB = data.positions[m_indexB].c;
|
||||
float32 aB = data.positions[m_indexB].a;
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
|
||||
b2Rot qB(aB);
|
||||
|
||||
float32 mass = m_bodyB->GetMass();
|
||||
|
||||
// Frequency
|
||||
float32 omega = 2.0f * b2_pi * m_frequencyHz;
|
||||
|
||||
// Damping coefficient
|
||||
float32 d = 2.0f * mass * m_dampingRatio * omega;
|
||||
|
||||
// Spring stiffness
|
||||
float32 k = mass * (omega * omega);
|
||||
|
||||
// magic formulas
|
||||
// gamma has units of inverse mass.
|
||||
// beta has units of inverse time.
|
||||
float32 h = data.step.dt;
|
||||
b2Assert(d + h * k > b2_epsilon);
|
||||
m_gamma = h * (d + h * k);
|
||||
if (m_gamma != 0.0f)
|
||||
{
|
||||
m_gamma = 1.0f / m_gamma;
|
||||
}
|
||||
m_beta = h * k * m_gamma;
|
||||
|
||||
// Compute the effective mass matrix.
|
||||
m_rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
|
||||
|
||||
// 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]
|
||||
b2Mat22 K;
|
||||
K.ex.x = m_invMassB + m_invIB * m_rB.y * m_rB.y + m_gamma;
|
||||
K.ex.y = -m_invIB * m_rB.x * m_rB.y;
|
||||
K.ey.x = K.ex.y;
|
||||
K.ey.y = m_invMassB + m_invIB * m_rB.x * m_rB.x + m_gamma;
|
||||
|
||||
m_mass = K.GetInverse();
|
||||
|
||||
m_C = cB + m_rB - m_targetA;
|
||||
m_C *= m_beta;
|
||||
|
||||
// Cheat with some damping
|
||||
wB *= 0.98f;
|
||||
|
||||
if (data.step.warmStarting)
|
||||
{
|
||||
m_impulse *= data.step.dtRatio;
|
||||
vB += m_invMassB * m_impulse;
|
||||
wB += m_invIB * b2Cross(m_rB, m_impulse);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_impulse.SetZero();
|
||||
}
|
||||
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
}
|
||||
|
||||
void b2MouseJoint::SolveVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
|
||||
// Cdot = v + cross(w, r)
|
||||
b2Vec2 Cdot = vB + b2Cross(wB, m_rB);
|
||||
b2Vec2 impulse = b2Mul(m_mass, -(Cdot + m_C + m_gamma * m_impulse));
|
||||
|
||||
b2Vec2 oldImpulse = m_impulse;
|
||||
m_impulse += impulse;
|
||||
float32 maxImpulse = data.step.dt * m_maxForce;
|
||||
if (m_impulse.LengthSquared() > maxImpulse * maxImpulse)
|
||||
{
|
||||
m_impulse *= maxImpulse / m_impulse.Length();
|
||||
}
|
||||
impulse = m_impulse - oldImpulse;
|
||||
|
||||
vB += m_invMassB * impulse;
|
||||
wB += m_invIB * b2Cross(m_rB, impulse);
|
||||
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
}
|
||||
|
||||
bool b2MouseJoint::SolvePositionConstraints(const b2SolverData& data)
|
||||
{
|
||||
B2_NOT_USED(data);
|
||||
return true;
|
||||
}
|
||||
|
||||
b2Vec2 b2MouseJoint::GetAnchorA() const
|
||||
{
|
||||
return m_targetA;
|
||||
}
|
||||
|
||||
b2Vec2 b2MouseJoint::GetAnchorB() const
|
||||
{
|
||||
return m_bodyB->GetWorldPoint(m_localAnchorB);
|
||||
}
|
||||
|
||||
b2Vec2 b2MouseJoint::GetReactionForce(float32 inv_dt) const
|
||||
{
|
||||
return inv_dt * m_impulse;
|
||||
}
|
||||
|
||||
float32 b2MouseJoint::GetReactionTorque(float32 inv_dt) const
|
||||
{
|
||||
return inv_dt * 0.0f;
|
||||
}
|
||||
|
||||
@@ -1,126 +1,126 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2007 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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;
|
||||
}
|
||||
|
||||
/// 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;
|
||||
};
|
||||
|
||||
/// 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.
|
||||
/// NOTE: this joint is not documented in the manual because it was
|
||||
/// developed to be used in the testbed. If you want to learn how to
|
||||
/// use the mouse joint, look at the testbed.
|
||||
class b2MouseJoint : public b2Joint
|
||||
{
|
||||
public:
|
||||
|
||||
/// Implements b2Joint.
|
||||
b2Vec2 GetAnchorA() const;
|
||||
|
||||
/// Implements b2Joint.
|
||||
b2Vec2 GetAnchorB() const;
|
||||
|
||||
/// Implements b2Joint.
|
||||
b2Vec2 GetReactionForce(float32 inv_dt) const;
|
||||
|
||||
/// Implements b2Joint.
|
||||
float32 GetReactionTorque(float32 inv_dt) const;
|
||||
|
||||
/// Use this to update the target point.
|
||||
void SetTarget(const b2Vec2& target);
|
||||
const b2Vec2& GetTarget() const;
|
||||
|
||||
/// Set/get the maximum force in Newtons.
|
||||
void SetMaxForce(float32 force);
|
||||
float32 GetMaxForce() const;
|
||||
|
||||
/// Set/get the frequency in Hertz.
|
||||
void SetFrequency(float32 hz);
|
||||
float32 GetFrequency() const;
|
||||
|
||||
/// Set/get the damping ratio (dimensionless).
|
||||
void SetDampingRatio(float32 ratio);
|
||||
float32 GetDampingRatio() const;
|
||||
|
||||
/// The mouse joint does not support dumping.
|
||||
void Dump() { b2Log("Mouse joint dumping is not supported.\n"); }
|
||||
|
||||
protected:
|
||||
friend class b2Joint;
|
||||
|
||||
b2MouseJoint(const b2MouseJointDef* def);
|
||||
|
||||
void InitVelocityConstraints(const b2SolverData& data);
|
||||
void SolveVelocityConstraints(const b2SolverData& data);
|
||||
bool SolvePositionConstraints(const b2SolverData& data);
|
||||
|
||||
b2Vec2 m_localAnchorB;
|
||||
b2Vec2 m_targetA;
|
||||
float32 m_frequencyHz;
|
||||
float32 m_dampingRatio;
|
||||
float32 m_beta;
|
||||
|
||||
// Solver shared
|
||||
b2Vec2 m_impulse;
|
||||
float32 m_maxForce;
|
||||
float32 m_gamma;
|
||||
|
||||
// Solver temp
|
||||
juce::int32 m_indexA;
|
||||
juce::int32 m_indexB;
|
||||
b2Vec2 m_rB;
|
||||
b2Vec2 m_localCenterB;
|
||||
float32 m_invMassB;
|
||||
float32 m_invIB;
|
||||
b2Mat22 m_mass;
|
||||
b2Vec2 m_C;
|
||||
};
|
||||
|
||||
#endif
|
||||
/*
|
||||
* Copyright (c) 2006-2007 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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;
|
||||
}
|
||||
|
||||
/// 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;
|
||||
};
|
||||
|
||||
/// 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.
|
||||
/// NOTE: this joint is not documented in the manual because it was
|
||||
/// developed to be used in the testbed. If you want to learn how to
|
||||
/// use the mouse joint, look at the testbed.
|
||||
class b2MouseJoint : public b2Joint
|
||||
{
|
||||
public:
|
||||
|
||||
/// Implements b2Joint.
|
||||
b2Vec2 GetAnchorA() const;
|
||||
|
||||
/// Implements b2Joint.
|
||||
b2Vec2 GetAnchorB() const;
|
||||
|
||||
/// Implements b2Joint.
|
||||
b2Vec2 GetReactionForce(float32 inv_dt) const;
|
||||
|
||||
/// Implements b2Joint.
|
||||
float32 GetReactionTorque(float32 inv_dt) const;
|
||||
|
||||
/// Use this to update the target point.
|
||||
void SetTarget(const b2Vec2& target);
|
||||
const b2Vec2& GetTarget() const;
|
||||
|
||||
/// Set/get the maximum force in Newtons.
|
||||
void SetMaxForce(float32 force);
|
||||
float32 GetMaxForce() const;
|
||||
|
||||
/// Set/get the frequency in Hertz.
|
||||
void SetFrequency(float32 hz);
|
||||
float32 GetFrequency() const;
|
||||
|
||||
/// Set/get the damping ratio (dimensionless).
|
||||
void SetDampingRatio(float32 ratio);
|
||||
float32 GetDampingRatio() const;
|
||||
|
||||
/// The mouse joint does not support dumping.
|
||||
void Dump() { b2Log("Mouse joint dumping is not supported.\n"); }
|
||||
|
||||
protected:
|
||||
friend class b2Joint;
|
||||
|
||||
b2MouseJoint(const b2MouseJointDef* def);
|
||||
|
||||
void InitVelocityConstraints(const b2SolverData& data);
|
||||
void SolveVelocityConstraints(const b2SolverData& data);
|
||||
bool SolvePositionConstraints(const b2SolverData& data);
|
||||
|
||||
b2Vec2 m_localAnchorB;
|
||||
b2Vec2 m_targetA;
|
||||
float32 m_frequencyHz;
|
||||
float32 m_dampingRatio;
|
||||
float32 m_beta;
|
||||
|
||||
// Solver shared
|
||||
b2Vec2 m_impulse;
|
||||
float32 m_maxForce;
|
||||
float32 m_gamma;
|
||||
|
||||
// Solver temp
|
||||
juce::int32 m_indexA;
|
||||
juce::int32 m_indexB;
|
||||
b2Vec2 m_rB;
|
||||
b2Vec2 m_localCenterB;
|
||||
float32 m_invMassB;
|
||||
float32 m_invIB;
|
||||
b2Mat22 m_mass;
|
||||
b2Vec2 m_C;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,196 +1,196 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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;
|
||||
localAnchorA.SetZero();
|
||||
localAnchorB.SetZero();
|
||||
localAxisA.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 unit world axis.
|
||||
void Initialize(b2Body* bodyA, b2Body* bodyB, const b2Vec2& anchor, const b2Vec2& axis);
|
||||
|
||||
/// The local anchor point relative to bodyA's origin.
|
||||
b2Vec2 localAnchorA;
|
||||
|
||||
/// The local anchor point relative to bodyB's origin.
|
||||
b2Vec2 localAnchorB;
|
||||
|
||||
/// The local translation unit axis in bodyA.
|
||||
b2Vec2 localAxisA;
|
||||
|
||||
/// The constrained angle between the bodies: bodyB_angle - bodyA_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 bodyA. 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 GetAnchorA() const;
|
||||
b2Vec2 GetAnchorB() const;
|
||||
|
||||
b2Vec2 GetReactionForce(float32 inv_dt) const;
|
||||
float32 GetReactionTorque(float32 inv_dt) const;
|
||||
|
||||
/// The local anchor point relative to bodyA's origin.
|
||||
const b2Vec2& GetLocalAnchorA() const { return m_localAnchorA; }
|
||||
|
||||
/// The local anchor point relative to bodyB's origin.
|
||||
const b2Vec2& GetLocalAnchorB() const { return m_localAnchorB; }
|
||||
|
||||
/// The local joint axis relative to bodyA.
|
||||
const b2Vec2& GetLocalAxisA() const { return m_localXAxisA; }
|
||||
|
||||
/// Get the reference angle.
|
||||
float32 GetReferenceAngle() const { return m_referenceAngle; }
|
||||
|
||||
/// 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);
|
||||
float32 GetMaxMotorForce() const { return m_maxMotorForce; }
|
||||
|
||||
/// Get the current motor force given the inverse time step, usually in N.
|
||||
float32 GetMotorForce(float32 inv_dt) const;
|
||||
|
||||
/// Dump to b2Log
|
||||
void Dump();
|
||||
|
||||
protected:
|
||||
friend class b2Joint;
|
||||
friend class b2GearJoint;
|
||||
b2PrismaticJoint(const b2PrismaticJointDef* def);
|
||||
|
||||
void InitVelocityConstraints(const b2SolverData& data);
|
||||
void SolveVelocityConstraints(const b2SolverData& data);
|
||||
bool SolvePositionConstraints(const b2SolverData& data);
|
||||
|
||||
// Solver shared
|
||||
b2Vec2 m_localAnchorA;
|
||||
b2Vec2 m_localAnchorB;
|
||||
b2Vec2 m_localXAxisA;
|
||||
b2Vec2 m_localYAxisA;
|
||||
float32 m_referenceAngle;
|
||||
b2Vec3 m_impulse;
|
||||
float32 m_motorImpulse;
|
||||
float32 m_lowerTranslation;
|
||||
float32 m_upperTranslation;
|
||||
float32 m_maxMotorForce;
|
||||
float32 m_motorSpeed;
|
||||
bool m_enableLimit;
|
||||
bool m_enableMotor;
|
||||
b2LimitState m_limitState;
|
||||
|
||||
// Solver temp
|
||||
juce::int32 m_indexA;
|
||||
juce::int32 m_indexB;
|
||||
b2Vec2 m_localCenterA;
|
||||
b2Vec2 m_localCenterB;
|
||||
float32 m_invMassA;
|
||||
float32 m_invMassB;
|
||||
float32 m_invIA;
|
||||
float32 m_invIB;
|
||||
b2Vec2 m_axis, m_perp;
|
||||
float32 m_s1, m_s2;
|
||||
float32 m_a1, m_a2;
|
||||
b2Mat33 m_K;
|
||||
float32 m_motorMass;
|
||||
};
|
||||
|
||||
inline float32 b2PrismaticJoint::GetMotorSpeed() const
|
||||
{
|
||||
return m_motorSpeed;
|
||||
}
|
||||
|
||||
#endif
|
||||
/*
|
||||
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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;
|
||||
localAnchorA.SetZero();
|
||||
localAnchorB.SetZero();
|
||||
localAxisA.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 unit world axis.
|
||||
void Initialize(b2Body* bodyA, b2Body* bodyB, const b2Vec2& anchor, const b2Vec2& axis);
|
||||
|
||||
/// The local anchor point relative to bodyA's origin.
|
||||
b2Vec2 localAnchorA;
|
||||
|
||||
/// The local anchor point relative to bodyB's origin.
|
||||
b2Vec2 localAnchorB;
|
||||
|
||||
/// The local translation unit axis in bodyA.
|
||||
b2Vec2 localAxisA;
|
||||
|
||||
/// The constrained angle between the bodies: bodyB_angle - bodyA_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 bodyA. 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 GetAnchorA() const;
|
||||
b2Vec2 GetAnchorB() const;
|
||||
|
||||
b2Vec2 GetReactionForce(float32 inv_dt) const;
|
||||
float32 GetReactionTorque(float32 inv_dt) const;
|
||||
|
||||
/// The local anchor point relative to bodyA's origin.
|
||||
const b2Vec2& GetLocalAnchorA() const { return m_localAnchorA; }
|
||||
|
||||
/// The local anchor point relative to bodyB's origin.
|
||||
const b2Vec2& GetLocalAnchorB() const { return m_localAnchorB; }
|
||||
|
||||
/// The local joint axis relative to bodyA.
|
||||
const b2Vec2& GetLocalAxisA() const { return m_localXAxisA; }
|
||||
|
||||
/// Get the reference angle.
|
||||
float32 GetReferenceAngle() const { return m_referenceAngle; }
|
||||
|
||||
/// 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);
|
||||
float32 GetMaxMotorForce() const { return m_maxMotorForce; }
|
||||
|
||||
/// Get the current motor force given the inverse time step, usually in N.
|
||||
float32 GetMotorForce(float32 inv_dt) const;
|
||||
|
||||
/// Dump to b2Log
|
||||
void Dump();
|
||||
|
||||
protected:
|
||||
friend class b2Joint;
|
||||
friend class b2GearJoint;
|
||||
b2PrismaticJoint(const b2PrismaticJointDef* def);
|
||||
|
||||
void InitVelocityConstraints(const b2SolverData& data);
|
||||
void SolveVelocityConstraints(const b2SolverData& data);
|
||||
bool SolvePositionConstraints(const b2SolverData& data);
|
||||
|
||||
// Solver shared
|
||||
b2Vec2 m_localAnchorA;
|
||||
b2Vec2 m_localAnchorB;
|
||||
b2Vec2 m_localXAxisA;
|
||||
b2Vec2 m_localYAxisA;
|
||||
float32 m_referenceAngle;
|
||||
b2Vec3 m_impulse;
|
||||
float32 m_motorImpulse;
|
||||
float32 m_lowerTranslation;
|
||||
float32 m_upperTranslation;
|
||||
float32 m_maxMotorForce;
|
||||
float32 m_motorSpeed;
|
||||
bool m_enableLimit;
|
||||
bool m_enableMotor;
|
||||
b2LimitState m_limitState;
|
||||
|
||||
// Solver temp
|
||||
juce::int32 m_indexA;
|
||||
juce::int32 m_indexB;
|
||||
b2Vec2 m_localCenterA;
|
||||
b2Vec2 m_localCenterB;
|
||||
float32 m_invMassA;
|
||||
float32 m_invMassB;
|
||||
float32 m_invIA;
|
||||
float32 m_invIB;
|
||||
b2Vec2 m_axis, m_perp;
|
||||
float32 m_s1, m_s2;
|
||||
float32 m_a1, m_a2;
|
||||
b2Mat33 m_K;
|
||||
float32 m_motorMass;
|
||||
};
|
||||
|
||||
inline float32 b2PrismaticJoint::GetMotorSpeed() const
|
||||
{
|
||||
return m_motorSpeed;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,332 +1,332 @@
|
||||
/*
|
||||
* Copyright (c) 2007 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "../b2TimeStep.h"
|
||||
|
||||
// Pulley:
|
||||
// length1 = norm(p1 - s1)
|
||||
// length2 = norm(p2 - s2)
|
||||
// C0 = (length1 + ratio * length2)_initial
|
||||
// C = C0 - (length1 + ratio * length2)
|
||||
// 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)
|
||||
|
||||
void b2PulleyJointDef::Initialize(b2Body* bA, b2Body* bB,
|
||||
const b2Vec2& groundA, const b2Vec2& groundB,
|
||||
const b2Vec2& anchorA, const b2Vec2& anchorB,
|
||||
float32 r)
|
||||
{
|
||||
bodyA = bA;
|
||||
bodyB = bB;
|
||||
groundAnchorA = groundA;
|
||||
groundAnchorB = groundB;
|
||||
localAnchorA = bodyA->GetLocalPoint(anchorA);
|
||||
localAnchorB = bodyB->GetLocalPoint(anchorB);
|
||||
b2Vec2 dA = anchorA - groundA;
|
||||
lengthA = dA.Length();
|
||||
b2Vec2 dB = anchorB - groundB;
|
||||
lengthB = dB.Length();
|
||||
ratio = r;
|
||||
b2Assert(ratio > b2_epsilon);
|
||||
}
|
||||
|
||||
b2PulleyJoint::b2PulleyJoint(const b2PulleyJointDef* def)
|
||||
: b2Joint(def)
|
||||
{
|
||||
m_groundAnchorA = def->groundAnchorA;
|
||||
m_groundAnchorB = def->groundAnchorB;
|
||||
m_localAnchorA = def->localAnchorA;
|
||||
m_localAnchorB = def->localAnchorB;
|
||||
|
||||
m_lengthA = def->lengthA;
|
||||
m_lengthB = def->lengthB;
|
||||
|
||||
b2Assert(def->ratio != 0.0f);
|
||||
m_ratio = def->ratio;
|
||||
|
||||
m_constant = def->lengthA + m_ratio * def->lengthB;
|
||||
|
||||
m_impulse = 0.0f;
|
||||
}
|
||||
|
||||
void b2PulleyJoint::InitVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
m_indexA = m_bodyA->m_islandIndex;
|
||||
m_indexB = m_bodyB->m_islandIndex;
|
||||
m_localCenterA = m_bodyA->m_sweep.localCenter;
|
||||
m_localCenterB = m_bodyB->m_sweep.localCenter;
|
||||
m_invMassA = m_bodyA->m_invMass;
|
||||
m_invMassB = m_bodyB->m_invMass;
|
||||
m_invIA = m_bodyA->m_invI;
|
||||
m_invIB = m_bodyB->m_invI;
|
||||
|
||||
b2Vec2 cA = data.positions[m_indexA].c;
|
||||
float32 aA = data.positions[m_indexA].a;
|
||||
b2Vec2 vA = data.velocities[m_indexA].v;
|
||||
float32 wA = data.velocities[m_indexA].w;
|
||||
|
||||
b2Vec2 cB = data.positions[m_indexB].c;
|
||||
float32 aB = data.positions[m_indexB].a;
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
|
||||
b2Rot qA(aA), qB(aB);
|
||||
|
||||
m_rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
|
||||
m_rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
|
||||
|
||||
// Get the pulley axes.
|
||||
m_uA = cA + m_rA - m_groundAnchorA;
|
||||
m_uB = cB + m_rB - m_groundAnchorB;
|
||||
|
||||
float32 lengthA = m_uA.Length();
|
||||
float32 lengthB = m_uB.Length();
|
||||
|
||||
if (lengthA > 10.0f * b2_linearSlop)
|
||||
{
|
||||
m_uA *= 1.0f / lengthA;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_uA.SetZero();
|
||||
}
|
||||
|
||||
if (lengthB > 10.0f * b2_linearSlop)
|
||||
{
|
||||
m_uB *= 1.0f / lengthB;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_uB.SetZero();
|
||||
}
|
||||
|
||||
// Compute effective mass.
|
||||
float32 ruA = b2Cross(m_rA, m_uA);
|
||||
float32 ruB = b2Cross(m_rB, m_uB);
|
||||
|
||||
float32 mA = m_invMassA + m_invIA * ruA * ruA;
|
||||
float32 mB = m_invMassB + m_invIB * ruB * ruB;
|
||||
|
||||
m_mass = mA + m_ratio * m_ratio * mB;
|
||||
|
||||
if (m_mass > 0.0f)
|
||||
{
|
||||
m_mass = 1.0f / m_mass;
|
||||
}
|
||||
|
||||
if (data.step.warmStarting)
|
||||
{
|
||||
// Scale impulses to support variable time steps.
|
||||
m_impulse *= data.step.dtRatio;
|
||||
|
||||
// Warm starting.
|
||||
b2Vec2 PA = -(m_impulse) * m_uA;
|
||||
b2Vec2 PB = (-m_ratio * m_impulse) * m_uB;
|
||||
|
||||
vA += m_invMassA * PA;
|
||||
wA += m_invIA * b2Cross(m_rA, PA);
|
||||
vB += m_invMassB * PB;
|
||||
wB += m_invIB * b2Cross(m_rB, PB);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_impulse = 0.0f;
|
||||
}
|
||||
|
||||
data.velocities[m_indexA].v = vA;
|
||||
data.velocities[m_indexA].w = wA;
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
}
|
||||
|
||||
void b2PulleyJoint::SolveVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
b2Vec2 vA = data.velocities[m_indexA].v;
|
||||
float32 wA = data.velocities[m_indexA].w;
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
|
||||
b2Vec2 vpA = vA + b2Cross(wA, m_rA);
|
||||
b2Vec2 vpB = vB + b2Cross(wB, m_rB);
|
||||
|
||||
float32 Cdot = -b2Dot(m_uA, vpA) - m_ratio * b2Dot(m_uB, vpB);
|
||||
float32 impulse = -m_mass * Cdot;
|
||||
m_impulse += impulse;
|
||||
|
||||
b2Vec2 PA = -impulse * m_uA;
|
||||
b2Vec2 PB = -m_ratio * impulse * m_uB;
|
||||
vA += m_invMassA * PA;
|
||||
wA += m_invIA * b2Cross(m_rA, PA);
|
||||
vB += m_invMassB * PB;
|
||||
wB += m_invIB * b2Cross(m_rB, PB);
|
||||
|
||||
data.velocities[m_indexA].v = vA;
|
||||
data.velocities[m_indexA].w = wA;
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
}
|
||||
|
||||
bool b2PulleyJoint::SolvePositionConstraints(const b2SolverData& data)
|
||||
{
|
||||
b2Vec2 cA = data.positions[m_indexA].c;
|
||||
float32 aA = data.positions[m_indexA].a;
|
||||
b2Vec2 cB = data.positions[m_indexB].c;
|
||||
float32 aB = data.positions[m_indexB].a;
|
||||
|
||||
b2Rot qA(aA), qB(aB);
|
||||
|
||||
b2Vec2 rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
|
||||
b2Vec2 rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
|
||||
|
||||
// Get the pulley axes.
|
||||
b2Vec2 uA = cA + rA - m_groundAnchorA;
|
||||
b2Vec2 uB = cB + rB - m_groundAnchorB;
|
||||
|
||||
float32 lengthA = uA.Length();
|
||||
float32 lengthB = uB.Length();
|
||||
|
||||
if (lengthA > 10.0f * b2_linearSlop)
|
||||
{
|
||||
uA *= 1.0f / lengthA;
|
||||
}
|
||||
else
|
||||
{
|
||||
uA.SetZero();
|
||||
}
|
||||
|
||||
if (lengthB > 10.0f * b2_linearSlop)
|
||||
{
|
||||
uB *= 1.0f / lengthB;
|
||||
}
|
||||
else
|
||||
{
|
||||
uB.SetZero();
|
||||
}
|
||||
|
||||
// Compute effective mass.
|
||||
float32 ruA = b2Cross(rA, uA);
|
||||
float32 ruB = b2Cross(rB, uB);
|
||||
|
||||
float32 mA = m_invMassA + m_invIA * ruA * ruA;
|
||||
float32 mB = m_invMassB + m_invIB * ruB * ruB;
|
||||
|
||||
float32 mass = mA + m_ratio * m_ratio * mB;
|
||||
|
||||
if (mass > 0.0f)
|
||||
{
|
||||
mass = 1.0f / mass;
|
||||
}
|
||||
|
||||
float32 C = m_constant - lengthA - m_ratio * lengthB;
|
||||
float32 linearError = b2Abs(C);
|
||||
|
||||
float32 impulse = -mass * C;
|
||||
|
||||
b2Vec2 PA = -impulse * uA;
|
||||
b2Vec2 PB = -m_ratio * impulse * uB;
|
||||
|
||||
cA += m_invMassA * PA;
|
||||
aA += m_invIA * b2Cross(rA, PA);
|
||||
cB += m_invMassB * PB;
|
||||
aB += m_invIB * b2Cross(rB, PB);
|
||||
|
||||
data.positions[m_indexA].c = cA;
|
||||
data.positions[m_indexA].a = aA;
|
||||
data.positions[m_indexB].c = cB;
|
||||
data.positions[m_indexB].a = aB;
|
||||
|
||||
return linearError < b2_linearSlop;
|
||||
}
|
||||
|
||||
b2Vec2 b2PulleyJoint::GetAnchorA() const
|
||||
{
|
||||
return m_bodyA->GetWorldPoint(m_localAnchorA);
|
||||
}
|
||||
|
||||
b2Vec2 b2PulleyJoint::GetAnchorB() const
|
||||
{
|
||||
return m_bodyB->GetWorldPoint(m_localAnchorB);
|
||||
}
|
||||
|
||||
b2Vec2 b2PulleyJoint::GetReactionForce(float32 inv_dt) const
|
||||
{
|
||||
b2Vec2 P = m_impulse * m_uB;
|
||||
return inv_dt * P;
|
||||
}
|
||||
|
||||
float32 b2PulleyJoint::GetReactionTorque(float32 inv_dt) const
|
||||
{
|
||||
B2_NOT_USED(inv_dt);
|
||||
return 0.0f;
|
||||
}
|
||||
|
||||
b2Vec2 b2PulleyJoint::GetGroundAnchorA() const
|
||||
{
|
||||
return m_groundAnchorA;
|
||||
}
|
||||
|
||||
b2Vec2 b2PulleyJoint::GetGroundAnchorB() const
|
||||
{
|
||||
return m_groundAnchorB;
|
||||
}
|
||||
|
||||
float32 b2PulleyJoint::GetLengthA() const
|
||||
{
|
||||
b2Vec2 p = m_bodyA->GetWorldPoint(m_localAnchorA);
|
||||
b2Vec2 s = m_groundAnchorA;
|
||||
b2Vec2 d = p - s;
|
||||
return d.Length();
|
||||
}
|
||||
|
||||
float32 b2PulleyJoint::GetLengthB() const
|
||||
{
|
||||
b2Vec2 p = m_bodyB->GetWorldPoint(m_localAnchorB);
|
||||
b2Vec2 s = m_groundAnchorB;
|
||||
b2Vec2 d = p - s;
|
||||
return d.Length();
|
||||
}
|
||||
|
||||
float32 b2PulleyJoint::GetRatio() const
|
||||
{
|
||||
return m_ratio;
|
||||
}
|
||||
|
||||
void b2PulleyJoint::Dump()
|
||||
{
|
||||
int32 indexA = m_bodyA->m_islandIndex;
|
||||
int32 indexB = m_bodyB->m_islandIndex;
|
||||
|
||||
b2Log(" b2PulleyJointDef jd;\n");
|
||||
b2Log(" jd.bodyA = bodies[%d];\n", indexA);
|
||||
b2Log(" jd.bodyB = bodies[%d];\n", indexB);
|
||||
b2Log(" jd.collideConnected = bool(%d);\n", m_collideConnected);
|
||||
b2Log(" jd.groundAnchorA.Set(%.15lef, %.15lef);\n", m_groundAnchorA.x, m_groundAnchorA.y);
|
||||
b2Log(" jd.groundAnchorB.Set(%.15lef, %.15lef);\n", m_groundAnchorB.x, m_groundAnchorB.y);
|
||||
b2Log(" jd.localAnchorA.Set(%.15lef, %.15lef);\n", m_localAnchorA.x, m_localAnchorA.y);
|
||||
b2Log(" jd.localAnchorB.Set(%.15lef, %.15lef);\n", m_localAnchorB.x, m_localAnchorB.y);
|
||||
b2Log(" jd.lengthA = %.15lef;\n", m_lengthA);
|
||||
b2Log(" jd.lengthB = %.15lef;\n", m_lengthB);
|
||||
b2Log(" jd.ratio = %.15lef;\n", m_ratio);
|
||||
b2Log(" joints[%d] = m_world->CreateJoint(&jd);\n", m_index);
|
||||
}
|
||||
/*
|
||||
* Copyright (c) 2007 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "../b2TimeStep.h"
|
||||
|
||||
// Pulley:
|
||||
// length1 = norm(p1 - s1)
|
||||
// length2 = norm(p2 - s2)
|
||||
// C0 = (length1 + ratio * length2)_initial
|
||||
// C = C0 - (length1 + ratio * length2)
|
||||
// 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)
|
||||
|
||||
void b2PulleyJointDef::Initialize(b2Body* bA, b2Body* bB,
|
||||
const b2Vec2& groundA, const b2Vec2& groundB,
|
||||
const b2Vec2& anchorA, const b2Vec2& anchorB,
|
||||
float32 r)
|
||||
{
|
||||
bodyA = bA;
|
||||
bodyB = bB;
|
||||
groundAnchorA = groundA;
|
||||
groundAnchorB = groundB;
|
||||
localAnchorA = bodyA->GetLocalPoint(anchorA);
|
||||
localAnchorB = bodyB->GetLocalPoint(anchorB);
|
||||
b2Vec2 dA = anchorA - groundA;
|
||||
lengthA = dA.Length();
|
||||
b2Vec2 dB = anchorB - groundB;
|
||||
lengthB = dB.Length();
|
||||
ratio = r;
|
||||
b2Assert(ratio > b2_epsilon);
|
||||
}
|
||||
|
||||
b2PulleyJoint::b2PulleyJoint(const b2PulleyJointDef* def)
|
||||
: b2Joint(def)
|
||||
{
|
||||
m_groundAnchorA = def->groundAnchorA;
|
||||
m_groundAnchorB = def->groundAnchorB;
|
||||
m_localAnchorA = def->localAnchorA;
|
||||
m_localAnchorB = def->localAnchorB;
|
||||
|
||||
m_lengthA = def->lengthA;
|
||||
m_lengthB = def->lengthB;
|
||||
|
||||
b2Assert(def->ratio != 0.0f);
|
||||
m_ratio = def->ratio;
|
||||
|
||||
m_constant = def->lengthA + m_ratio * def->lengthB;
|
||||
|
||||
m_impulse = 0.0f;
|
||||
}
|
||||
|
||||
void b2PulleyJoint::InitVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
m_indexA = m_bodyA->m_islandIndex;
|
||||
m_indexB = m_bodyB->m_islandIndex;
|
||||
m_localCenterA = m_bodyA->m_sweep.localCenter;
|
||||
m_localCenterB = m_bodyB->m_sweep.localCenter;
|
||||
m_invMassA = m_bodyA->m_invMass;
|
||||
m_invMassB = m_bodyB->m_invMass;
|
||||
m_invIA = m_bodyA->m_invI;
|
||||
m_invIB = m_bodyB->m_invI;
|
||||
|
||||
b2Vec2 cA = data.positions[m_indexA].c;
|
||||
float32 aA = data.positions[m_indexA].a;
|
||||
b2Vec2 vA = data.velocities[m_indexA].v;
|
||||
float32 wA = data.velocities[m_indexA].w;
|
||||
|
||||
b2Vec2 cB = data.positions[m_indexB].c;
|
||||
float32 aB = data.positions[m_indexB].a;
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
|
||||
b2Rot qA(aA), qB(aB);
|
||||
|
||||
m_rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
|
||||
m_rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
|
||||
|
||||
// Get the pulley axes.
|
||||
m_uA = cA + m_rA - m_groundAnchorA;
|
||||
m_uB = cB + m_rB - m_groundAnchorB;
|
||||
|
||||
float32 lengthA = m_uA.Length();
|
||||
float32 lengthB = m_uB.Length();
|
||||
|
||||
if (lengthA > 10.0f * b2_linearSlop)
|
||||
{
|
||||
m_uA *= 1.0f / lengthA;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_uA.SetZero();
|
||||
}
|
||||
|
||||
if (lengthB > 10.0f * b2_linearSlop)
|
||||
{
|
||||
m_uB *= 1.0f / lengthB;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_uB.SetZero();
|
||||
}
|
||||
|
||||
// Compute effective mass.
|
||||
float32 ruA = b2Cross(m_rA, m_uA);
|
||||
float32 ruB = b2Cross(m_rB, m_uB);
|
||||
|
||||
float32 mA = m_invMassA + m_invIA * ruA * ruA;
|
||||
float32 mB = m_invMassB + m_invIB * ruB * ruB;
|
||||
|
||||
m_mass = mA + m_ratio * m_ratio * mB;
|
||||
|
||||
if (m_mass > 0.0f)
|
||||
{
|
||||
m_mass = 1.0f / m_mass;
|
||||
}
|
||||
|
||||
if (data.step.warmStarting)
|
||||
{
|
||||
// Scale impulses to support variable time steps.
|
||||
m_impulse *= data.step.dtRatio;
|
||||
|
||||
// Warm starting.
|
||||
b2Vec2 PA = -(m_impulse) * m_uA;
|
||||
b2Vec2 PB = (-m_ratio * m_impulse) * m_uB;
|
||||
|
||||
vA += m_invMassA * PA;
|
||||
wA += m_invIA * b2Cross(m_rA, PA);
|
||||
vB += m_invMassB * PB;
|
||||
wB += m_invIB * b2Cross(m_rB, PB);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_impulse = 0.0f;
|
||||
}
|
||||
|
||||
data.velocities[m_indexA].v = vA;
|
||||
data.velocities[m_indexA].w = wA;
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
}
|
||||
|
||||
void b2PulleyJoint::SolveVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
b2Vec2 vA = data.velocities[m_indexA].v;
|
||||
float32 wA = data.velocities[m_indexA].w;
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
|
||||
b2Vec2 vpA = vA + b2Cross(wA, m_rA);
|
||||
b2Vec2 vpB = vB + b2Cross(wB, m_rB);
|
||||
|
||||
float32 Cdot = -b2Dot(m_uA, vpA) - m_ratio * b2Dot(m_uB, vpB);
|
||||
float32 impulse = -m_mass * Cdot;
|
||||
m_impulse += impulse;
|
||||
|
||||
b2Vec2 PA = -impulse * m_uA;
|
||||
b2Vec2 PB = -m_ratio * impulse * m_uB;
|
||||
vA += m_invMassA * PA;
|
||||
wA += m_invIA * b2Cross(m_rA, PA);
|
||||
vB += m_invMassB * PB;
|
||||
wB += m_invIB * b2Cross(m_rB, PB);
|
||||
|
||||
data.velocities[m_indexA].v = vA;
|
||||
data.velocities[m_indexA].w = wA;
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
}
|
||||
|
||||
bool b2PulleyJoint::SolvePositionConstraints(const b2SolverData& data)
|
||||
{
|
||||
b2Vec2 cA = data.positions[m_indexA].c;
|
||||
float32 aA = data.positions[m_indexA].a;
|
||||
b2Vec2 cB = data.positions[m_indexB].c;
|
||||
float32 aB = data.positions[m_indexB].a;
|
||||
|
||||
b2Rot qA(aA), qB(aB);
|
||||
|
||||
b2Vec2 rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
|
||||
b2Vec2 rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
|
||||
|
||||
// Get the pulley axes.
|
||||
b2Vec2 uA = cA + rA - m_groundAnchorA;
|
||||
b2Vec2 uB = cB + rB - m_groundAnchorB;
|
||||
|
||||
float32 lengthA = uA.Length();
|
||||
float32 lengthB = uB.Length();
|
||||
|
||||
if (lengthA > 10.0f * b2_linearSlop)
|
||||
{
|
||||
uA *= 1.0f / lengthA;
|
||||
}
|
||||
else
|
||||
{
|
||||
uA.SetZero();
|
||||
}
|
||||
|
||||
if (lengthB > 10.0f * b2_linearSlop)
|
||||
{
|
||||
uB *= 1.0f / lengthB;
|
||||
}
|
||||
else
|
||||
{
|
||||
uB.SetZero();
|
||||
}
|
||||
|
||||
// Compute effective mass.
|
||||
float32 ruA = b2Cross(rA, uA);
|
||||
float32 ruB = b2Cross(rB, uB);
|
||||
|
||||
float32 mA = m_invMassA + m_invIA * ruA * ruA;
|
||||
float32 mB = m_invMassB + m_invIB * ruB * ruB;
|
||||
|
||||
float32 mass = mA + m_ratio * m_ratio * mB;
|
||||
|
||||
if (mass > 0.0f)
|
||||
{
|
||||
mass = 1.0f / mass;
|
||||
}
|
||||
|
||||
float32 C = m_constant - lengthA - m_ratio * lengthB;
|
||||
float32 linearError = b2Abs(C);
|
||||
|
||||
float32 impulse = -mass * C;
|
||||
|
||||
b2Vec2 PA = -impulse * uA;
|
||||
b2Vec2 PB = -m_ratio * impulse * uB;
|
||||
|
||||
cA += m_invMassA * PA;
|
||||
aA += m_invIA * b2Cross(rA, PA);
|
||||
cB += m_invMassB * PB;
|
||||
aB += m_invIB * b2Cross(rB, PB);
|
||||
|
||||
data.positions[m_indexA].c = cA;
|
||||
data.positions[m_indexA].a = aA;
|
||||
data.positions[m_indexB].c = cB;
|
||||
data.positions[m_indexB].a = aB;
|
||||
|
||||
return linearError < b2_linearSlop;
|
||||
}
|
||||
|
||||
b2Vec2 b2PulleyJoint::GetAnchorA() const
|
||||
{
|
||||
return m_bodyA->GetWorldPoint(m_localAnchorA);
|
||||
}
|
||||
|
||||
b2Vec2 b2PulleyJoint::GetAnchorB() const
|
||||
{
|
||||
return m_bodyB->GetWorldPoint(m_localAnchorB);
|
||||
}
|
||||
|
||||
b2Vec2 b2PulleyJoint::GetReactionForce(float32 inv_dt) const
|
||||
{
|
||||
b2Vec2 P = m_impulse * m_uB;
|
||||
return inv_dt * P;
|
||||
}
|
||||
|
||||
float32 b2PulleyJoint::GetReactionTorque(float32 inv_dt) const
|
||||
{
|
||||
B2_NOT_USED(inv_dt);
|
||||
return 0.0f;
|
||||
}
|
||||
|
||||
b2Vec2 b2PulleyJoint::GetGroundAnchorA() const
|
||||
{
|
||||
return m_groundAnchorA;
|
||||
}
|
||||
|
||||
b2Vec2 b2PulleyJoint::GetGroundAnchorB() const
|
||||
{
|
||||
return m_groundAnchorB;
|
||||
}
|
||||
|
||||
float32 b2PulleyJoint::GetLengthA() const
|
||||
{
|
||||
b2Vec2 p = m_bodyA->GetWorldPoint(m_localAnchorA);
|
||||
b2Vec2 s = m_groundAnchorA;
|
||||
b2Vec2 d = p - s;
|
||||
return d.Length();
|
||||
}
|
||||
|
||||
float32 b2PulleyJoint::GetLengthB() const
|
||||
{
|
||||
b2Vec2 p = m_bodyB->GetWorldPoint(m_localAnchorB);
|
||||
b2Vec2 s = m_groundAnchorB;
|
||||
b2Vec2 d = p - s;
|
||||
return d.Length();
|
||||
}
|
||||
|
||||
float32 b2PulleyJoint::GetRatio() const
|
||||
{
|
||||
return m_ratio;
|
||||
}
|
||||
|
||||
void b2PulleyJoint::Dump()
|
||||
{
|
||||
int32 indexA = m_bodyA->m_islandIndex;
|
||||
int32 indexB = m_bodyB->m_islandIndex;
|
||||
|
||||
b2Log(" b2PulleyJointDef jd;\n");
|
||||
b2Log(" jd.bodyA = bodies[%d];\n", indexA);
|
||||
b2Log(" jd.bodyB = bodies[%d];\n", indexB);
|
||||
b2Log(" jd.collideConnected = bool(%d);\n", m_collideConnected);
|
||||
b2Log(" jd.groundAnchorA.Set(%.15lef, %.15lef);\n", m_groundAnchorA.x, m_groundAnchorA.y);
|
||||
b2Log(" jd.groundAnchorB.Set(%.15lef, %.15lef);\n", m_groundAnchorB.x, m_groundAnchorB.y);
|
||||
b2Log(" jd.localAnchorA.Set(%.15lef, %.15lef);\n", m_localAnchorA.x, m_localAnchorA.y);
|
||||
b2Log(" jd.localAnchorB.Set(%.15lef, %.15lef);\n", m_localAnchorB.x, m_localAnchorB.y);
|
||||
b2Log(" jd.lengthA = %.15lef;\n", m_lengthA);
|
||||
b2Log(" jd.lengthB = %.15lef;\n", m_lengthB);
|
||||
b2Log(" jd.ratio = %.15lef;\n", m_ratio);
|
||||
b2Log(" joints[%d] = m_world->CreateJoint(&jd);\n", m_index);
|
||||
}
|
||||
|
||||
@@ -1,143 +1,143 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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, and a pulley ratio.
|
||||
struct b2PulleyJointDef : public b2JointDef
|
||||
{
|
||||
b2PulleyJointDef()
|
||||
{
|
||||
type = e_pulleyJoint;
|
||||
groundAnchorA.Set(-1.0f, 1.0f);
|
||||
groundAnchorB.Set(1.0f, 1.0f);
|
||||
localAnchorA.Set(-1.0f, 0.0f);
|
||||
localAnchorB.Set(1.0f, 0.0f);
|
||||
lengthA = 0.0f;
|
||||
lengthB = 0.0f;
|
||||
ratio = 1.0f;
|
||||
collideConnected = true;
|
||||
}
|
||||
|
||||
/// Initialize the bodies, anchors, lengths, max lengths, and ratio using the world anchors.
|
||||
void Initialize(b2Body* bodyA, b2Body* bodyB,
|
||||
const b2Vec2& groundAnchorA, const b2Vec2& groundAnchorB,
|
||||
const b2Vec2& anchorA, const b2Vec2& anchorB,
|
||||
float32 ratio);
|
||||
|
||||
/// The first ground anchor in world coordinates. This point never moves.
|
||||
b2Vec2 groundAnchorA;
|
||||
|
||||
/// The second ground anchor in world coordinates. This point never moves.
|
||||
b2Vec2 groundAnchorB;
|
||||
|
||||
/// The local anchor point relative to bodyA's origin.
|
||||
b2Vec2 localAnchorA;
|
||||
|
||||
/// The local anchor point relative to bodyB's origin.
|
||||
b2Vec2 localAnchorB;
|
||||
|
||||
/// The a reference length for the segment attached to bodyA.
|
||||
float32 lengthA;
|
||||
|
||||
/// The a reference length for the segment attached to bodyB.
|
||||
float32 lengthB;
|
||||
|
||||
/// 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.
|
||||
/// Warning: the pulley joint can get a bit squirrelly by itself. They often
|
||||
/// work better when combined with prismatic joints. You should also cover the
|
||||
/// the anchor points with static shapes to prevent one side from going to
|
||||
/// zero length.
|
||||
class b2PulleyJoint : public b2Joint
|
||||
{
|
||||
public:
|
||||
b2Vec2 GetAnchorA() const;
|
||||
b2Vec2 GetAnchorB() const;
|
||||
|
||||
b2Vec2 GetReactionForce(float32 inv_dt) const;
|
||||
float32 GetReactionTorque(float32 inv_dt) const;
|
||||
|
||||
/// Get the first ground anchor.
|
||||
b2Vec2 GetGroundAnchorA() const;
|
||||
|
||||
/// Get the second ground anchor.
|
||||
b2Vec2 GetGroundAnchorB() const;
|
||||
|
||||
/// Get the current length of the segment attached to bodyA.
|
||||
float32 GetLengthA() const;
|
||||
|
||||
/// Get the current length of the segment attached to bodyB.
|
||||
float32 GetLengthB() const;
|
||||
|
||||
/// Get the pulley ratio.
|
||||
float32 GetRatio() const;
|
||||
|
||||
/// Dump joint to dmLog
|
||||
void Dump();
|
||||
|
||||
protected:
|
||||
|
||||
friend class b2Joint;
|
||||
b2PulleyJoint(const b2PulleyJointDef* data);
|
||||
|
||||
void InitVelocityConstraints(const b2SolverData& data);
|
||||
void SolveVelocityConstraints(const b2SolverData& data);
|
||||
bool SolvePositionConstraints(const b2SolverData& data);
|
||||
|
||||
b2Vec2 m_groundAnchorA;
|
||||
b2Vec2 m_groundAnchorB;
|
||||
float32 m_lengthA;
|
||||
float32 m_lengthB;
|
||||
|
||||
// Solver shared
|
||||
b2Vec2 m_localAnchorA;
|
||||
b2Vec2 m_localAnchorB;
|
||||
float32 m_constant;
|
||||
float32 m_ratio;
|
||||
float32 m_impulse;
|
||||
|
||||
// Solver temp
|
||||
juce::int32 m_indexA;
|
||||
juce::int32 m_indexB;
|
||||
b2Vec2 m_uA;
|
||||
b2Vec2 m_uB;
|
||||
b2Vec2 m_rA;
|
||||
b2Vec2 m_rB;
|
||||
b2Vec2 m_localCenterA;
|
||||
b2Vec2 m_localCenterB;
|
||||
float32 m_invMassA;
|
||||
float32 m_invMassB;
|
||||
float32 m_invIA;
|
||||
float32 m_invIB;
|
||||
float32 m_mass;
|
||||
};
|
||||
|
||||
#endif
|
||||
/*
|
||||
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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, and a pulley ratio.
|
||||
struct b2PulleyJointDef : public b2JointDef
|
||||
{
|
||||
b2PulleyJointDef()
|
||||
{
|
||||
type = e_pulleyJoint;
|
||||
groundAnchorA.Set(-1.0f, 1.0f);
|
||||
groundAnchorB.Set(1.0f, 1.0f);
|
||||
localAnchorA.Set(-1.0f, 0.0f);
|
||||
localAnchorB.Set(1.0f, 0.0f);
|
||||
lengthA = 0.0f;
|
||||
lengthB = 0.0f;
|
||||
ratio = 1.0f;
|
||||
collideConnected = true;
|
||||
}
|
||||
|
||||
/// Initialize the bodies, anchors, lengths, max lengths, and ratio using the world anchors.
|
||||
void Initialize(b2Body* bodyA, b2Body* bodyB,
|
||||
const b2Vec2& groundAnchorA, const b2Vec2& groundAnchorB,
|
||||
const b2Vec2& anchorA, const b2Vec2& anchorB,
|
||||
float32 ratio);
|
||||
|
||||
/// The first ground anchor in world coordinates. This point never moves.
|
||||
b2Vec2 groundAnchorA;
|
||||
|
||||
/// The second ground anchor in world coordinates. This point never moves.
|
||||
b2Vec2 groundAnchorB;
|
||||
|
||||
/// The local anchor point relative to bodyA's origin.
|
||||
b2Vec2 localAnchorA;
|
||||
|
||||
/// The local anchor point relative to bodyB's origin.
|
||||
b2Vec2 localAnchorB;
|
||||
|
||||
/// The a reference length for the segment attached to bodyA.
|
||||
float32 lengthA;
|
||||
|
||||
/// The a reference length for the segment attached to bodyB.
|
||||
float32 lengthB;
|
||||
|
||||
/// 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.
|
||||
/// Warning: the pulley joint can get a bit squirrelly by itself. They often
|
||||
/// work better when combined with prismatic joints. You should also cover the
|
||||
/// the anchor points with static shapes to prevent one side from going to
|
||||
/// zero length.
|
||||
class b2PulleyJoint : public b2Joint
|
||||
{
|
||||
public:
|
||||
b2Vec2 GetAnchorA() const;
|
||||
b2Vec2 GetAnchorB() const;
|
||||
|
||||
b2Vec2 GetReactionForce(float32 inv_dt) const;
|
||||
float32 GetReactionTorque(float32 inv_dt) const;
|
||||
|
||||
/// Get the first ground anchor.
|
||||
b2Vec2 GetGroundAnchorA() const;
|
||||
|
||||
/// Get the second ground anchor.
|
||||
b2Vec2 GetGroundAnchorB() const;
|
||||
|
||||
/// Get the current length of the segment attached to bodyA.
|
||||
float32 GetLengthA() const;
|
||||
|
||||
/// Get the current length of the segment attached to bodyB.
|
||||
float32 GetLengthB() const;
|
||||
|
||||
/// Get the pulley ratio.
|
||||
float32 GetRatio() const;
|
||||
|
||||
/// Dump joint to dmLog
|
||||
void Dump();
|
||||
|
||||
protected:
|
||||
|
||||
friend class b2Joint;
|
||||
b2PulleyJoint(const b2PulleyJointDef* data);
|
||||
|
||||
void InitVelocityConstraints(const b2SolverData& data);
|
||||
void SolveVelocityConstraints(const b2SolverData& data);
|
||||
bool SolvePositionConstraints(const b2SolverData& data);
|
||||
|
||||
b2Vec2 m_groundAnchorA;
|
||||
b2Vec2 m_groundAnchorB;
|
||||
float32 m_lengthA;
|
||||
float32 m_lengthB;
|
||||
|
||||
// Solver shared
|
||||
b2Vec2 m_localAnchorA;
|
||||
b2Vec2 m_localAnchorB;
|
||||
float32 m_constant;
|
||||
float32 m_ratio;
|
||||
float32 m_impulse;
|
||||
|
||||
// Solver temp
|
||||
juce::int32 m_indexA;
|
||||
juce::int32 m_indexB;
|
||||
b2Vec2 m_uA;
|
||||
b2Vec2 m_uB;
|
||||
b2Vec2 m_rA;
|
||||
b2Vec2 m_rB;
|
||||
b2Vec2 m_localCenterA;
|
||||
b2Vec2 m_localCenterB;
|
||||
float32 m_invMassA;
|
||||
float32 m_invMassB;
|
||||
float32 m_invIA;
|
||||
float32 m_invIB;
|
||||
float32 m_mass;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,204 +1,204 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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;
|
||||
localAnchorA.Set(0.0f, 0.0f);
|
||||
localAnchorB.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 a world
|
||||
/// anchor point.
|
||||
void Initialize(b2Body* bodyA, b2Body* bodyB, const b2Vec2& anchor);
|
||||
|
||||
/// The local anchor point relative to bodyA's origin.
|
||||
b2Vec2 localAnchorA;
|
||||
|
||||
/// The local anchor point relative to bodyB's origin.
|
||||
b2Vec2 localAnchorB;
|
||||
|
||||
/// The bodyB angle minus bodyA 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 two 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 GetAnchorA() const;
|
||||
b2Vec2 GetAnchorB() const;
|
||||
|
||||
/// The local anchor point relative to bodyA's origin.
|
||||
const b2Vec2& GetLocalAnchorA() const { return m_localAnchorA; }
|
||||
|
||||
/// The local anchor point relative to bodyB's origin.
|
||||
const b2Vec2& GetLocalAnchorB() const { return m_localAnchorB; }
|
||||
|
||||
/// Get the reference angle.
|
||||
float32 GetReferenceAngle() const { return m_referenceAngle; }
|
||||
|
||||
/// 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);
|
||||
float32 GetMaxMotorTorque() const { return m_maxMotorTorque; }
|
||||
|
||||
/// Get the reaction force given the inverse time step.
|
||||
/// Unit is N.
|
||||
b2Vec2 GetReactionForce(float32 inv_dt) const;
|
||||
|
||||
/// Get the reaction torque due to the joint limit given the inverse time step.
|
||||
/// Unit is N*m.
|
||||
float32 GetReactionTorque(float32 inv_dt) const;
|
||||
|
||||
/// Get the current motor torque given the inverse time step.
|
||||
/// Unit is N*m.
|
||||
float32 GetMotorTorque(float32 inv_dt) const;
|
||||
|
||||
/// Dump to b2Log.
|
||||
void Dump();
|
||||
|
||||
protected:
|
||||
|
||||
friend class b2Joint;
|
||||
friend class b2GearJoint;
|
||||
|
||||
b2RevoluteJoint(const b2RevoluteJointDef* def);
|
||||
|
||||
void InitVelocityConstraints(const b2SolverData& data);
|
||||
void SolveVelocityConstraints(const b2SolverData& data);
|
||||
bool SolvePositionConstraints(const b2SolverData& data);
|
||||
|
||||
// Solver shared
|
||||
b2Vec2 m_localAnchorA;
|
||||
b2Vec2 m_localAnchorB;
|
||||
b2Vec3 m_impulse;
|
||||
float32 m_motorImpulse;
|
||||
|
||||
bool m_enableMotor;
|
||||
float32 m_maxMotorTorque;
|
||||
float32 m_motorSpeed;
|
||||
|
||||
bool m_enableLimit;
|
||||
float32 m_referenceAngle;
|
||||
float32 m_lowerAngle;
|
||||
float32 m_upperAngle;
|
||||
|
||||
// Solver temp
|
||||
juce::int32 m_indexA;
|
||||
juce::int32 m_indexB;
|
||||
b2Vec2 m_rA;
|
||||
b2Vec2 m_rB;
|
||||
b2Vec2 m_localCenterA;
|
||||
b2Vec2 m_localCenterB;
|
||||
float32 m_invMassA;
|
||||
float32 m_invMassB;
|
||||
float32 m_invIA;
|
||||
float32 m_invIB;
|
||||
b2Mat33 m_mass; // effective mass for point-to-point constraint.
|
||||
float32 m_motorMass; // effective mass for motor/limit angular constraint.
|
||||
b2LimitState m_limitState;
|
||||
};
|
||||
|
||||
inline float32 b2RevoluteJoint::GetMotorSpeed() const
|
||||
{
|
||||
return m_motorSpeed;
|
||||
}
|
||||
|
||||
#endif
|
||||
/*
|
||||
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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;
|
||||
localAnchorA.Set(0.0f, 0.0f);
|
||||
localAnchorB.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 a world
|
||||
/// anchor point.
|
||||
void Initialize(b2Body* bodyA, b2Body* bodyB, const b2Vec2& anchor);
|
||||
|
||||
/// The local anchor point relative to bodyA's origin.
|
||||
b2Vec2 localAnchorA;
|
||||
|
||||
/// The local anchor point relative to bodyB's origin.
|
||||
b2Vec2 localAnchorB;
|
||||
|
||||
/// The bodyB angle minus bodyA 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 two 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 GetAnchorA() const;
|
||||
b2Vec2 GetAnchorB() const;
|
||||
|
||||
/// The local anchor point relative to bodyA's origin.
|
||||
const b2Vec2& GetLocalAnchorA() const { return m_localAnchorA; }
|
||||
|
||||
/// The local anchor point relative to bodyB's origin.
|
||||
const b2Vec2& GetLocalAnchorB() const { return m_localAnchorB; }
|
||||
|
||||
/// Get the reference angle.
|
||||
float32 GetReferenceAngle() const { return m_referenceAngle; }
|
||||
|
||||
/// 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);
|
||||
float32 GetMaxMotorTorque() const { return m_maxMotorTorque; }
|
||||
|
||||
/// Get the reaction force given the inverse time step.
|
||||
/// Unit is N.
|
||||
b2Vec2 GetReactionForce(float32 inv_dt) const;
|
||||
|
||||
/// Get the reaction torque due to the joint limit given the inverse time step.
|
||||
/// Unit is N*m.
|
||||
float32 GetReactionTorque(float32 inv_dt) const;
|
||||
|
||||
/// Get the current motor torque given the inverse time step.
|
||||
/// Unit is N*m.
|
||||
float32 GetMotorTorque(float32 inv_dt) const;
|
||||
|
||||
/// Dump to b2Log.
|
||||
void Dump();
|
||||
|
||||
protected:
|
||||
|
||||
friend class b2Joint;
|
||||
friend class b2GearJoint;
|
||||
|
||||
b2RevoluteJoint(const b2RevoluteJointDef* def);
|
||||
|
||||
void InitVelocityConstraints(const b2SolverData& data);
|
||||
void SolveVelocityConstraints(const b2SolverData& data);
|
||||
bool SolvePositionConstraints(const b2SolverData& data);
|
||||
|
||||
// Solver shared
|
||||
b2Vec2 m_localAnchorA;
|
||||
b2Vec2 m_localAnchorB;
|
||||
b2Vec3 m_impulse;
|
||||
float32 m_motorImpulse;
|
||||
|
||||
bool m_enableMotor;
|
||||
float32 m_maxMotorTorque;
|
||||
float32 m_motorSpeed;
|
||||
|
||||
bool m_enableLimit;
|
||||
float32 m_referenceAngle;
|
||||
float32 m_lowerAngle;
|
||||
float32 m_upperAngle;
|
||||
|
||||
// Solver temp
|
||||
juce::int32 m_indexA;
|
||||
juce::int32 m_indexB;
|
||||
b2Vec2 m_rA;
|
||||
b2Vec2 m_rB;
|
||||
b2Vec2 m_localCenterA;
|
||||
b2Vec2 m_localCenterB;
|
||||
float32 m_invMassA;
|
||||
float32 m_invMassB;
|
||||
float32 m_invIA;
|
||||
float32 m_invIB;
|
||||
b2Mat33 m_mass; // effective mass for point-to-point constraint.
|
||||
float32 m_motorMass; // effective mass for motor/limit angular constraint.
|
||||
b2LimitState m_limitState;
|
||||
};
|
||||
|
||||
inline float32 b2RevoluteJoint::GetMotorSpeed() const
|
||||
{
|
||||
return m_motorSpeed;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,241 +1,241 @@
|
||||
/*
|
||||
* Copyright (c) 2007-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "b2RopeJoint.h"
|
||||
#include "../b2Body.h"
|
||||
#include "../b2TimeStep.h"
|
||||
|
||||
|
||||
// Limit:
|
||||
// C = norm(pB - pA) - L
|
||||
// u = (pB - pA) / norm(pB - pA)
|
||||
// Cdot = dot(u, vB + cross(wB, rB) - vA - cross(wA, rA))
|
||||
// J = [-u -cross(rA, u) u cross(rB, u)]
|
||||
// K = J * invM * JT
|
||||
// = invMassA + invIA * cross(rA, u)^2 + invMassB + invIB * cross(rB, u)^2
|
||||
|
||||
b2RopeJoint::b2RopeJoint(const b2RopeJointDef* def)
|
||||
: b2Joint(def)
|
||||
{
|
||||
m_localAnchorA = def->localAnchorA;
|
||||
m_localAnchorB = def->localAnchorB;
|
||||
|
||||
m_maxLength = def->maxLength;
|
||||
|
||||
m_mass = 0.0f;
|
||||
m_impulse = 0.0f;
|
||||
m_state = e_inactiveLimit;
|
||||
m_length = 0.0f;
|
||||
}
|
||||
|
||||
void b2RopeJoint::InitVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
m_indexA = m_bodyA->m_islandIndex;
|
||||
m_indexB = m_bodyB->m_islandIndex;
|
||||
m_localCenterA = m_bodyA->m_sweep.localCenter;
|
||||
m_localCenterB = m_bodyB->m_sweep.localCenter;
|
||||
m_invMassA = m_bodyA->m_invMass;
|
||||
m_invMassB = m_bodyB->m_invMass;
|
||||
m_invIA = m_bodyA->m_invI;
|
||||
m_invIB = m_bodyB->m_invI;
|
||||
|
||||
b2Vec2 cA = data.positions[m_indexA].c;
|
||||
float32 aA = data.positions[m_indexA].a;
|
||||
b2Vec2 vA = data.velocities[m_indexA].v;
|
||||
float32 wA = data.velocities[m_indexA].w;
|
||||
|
||||
b2Vec2 cB = data.positions[m_indexB].c;
|
||||
float32 aB = data.positions[m_indexB].a;
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
|
||||
b2Rot qA(aA), qB(aB);
|
||||
|
||||
m_rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
|
||||
m_rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
|
||||
m_u = cB + m_rB - cA - m_rA;
|
||||
|
||||
m_length = m_u.Length();
|
||||
|
||||
float32 C = m_length - m_maxLength;
|
||||
if (C > 0.0f)
|
||||
{
|
||||
m_state = e_atUpperLimit;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_state = e_inactiveLimit;
|
||||
}
|
||||
|
||||
if (m_length > b2_linearSlop)
|
||||
{
|
||||
m_u *= 1.0f / m_length;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_u.SetZero();
|
||||
m_mass = 0.0f;
|
||||
m_impulse = 0.0f;
|
||||
return;
|
||||
}
|
||||
|
||||
// Compute effective mass.
|
||||
float32 crA = b2Cross(m_rA, m_u);
|
||||
float32 crB = b2Cross(m_rB, m_u);
|
||||
float32 invMass = m_invMassA + m_invIA * crA * crA + m_invMassB + m_invIB * crB * crB;
|
||||
|
||||
m_mass = invMass != 0.0f ? 1.0f / invMass : 0.0f;
|
||||
|
||||
if (data.step.warmStarting)
|
||||
{
|
||||
// Scale the impulse to support a variable time step.
|
||||
m_impulse *= data.step.dtRatio;
|
||||
|
||||
b2Vec2 P = m_impulse * m_u;
|
||||
vA -= m_invMassA * P;
|
||||
wA -= m_invIA * b2Cross(m_rA, P);
|
||||
vB += m_invMassB * P;
|
||||
wB += m_invIB * b2Cross(m_rB, P);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_impulse = 0.0f;
|
||||
}
|
||||
|
||||
data.velocities[m_indexA].v = vA;
|
||||
data.velocities[m_indexA].w = wA;
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
}
|
||||
|
||||
void b2RopeJoint::SolveVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
b2Vec2 vA = data.velocities[m_indexA].v;
|
||||
float32 wA = data.velocities[m_indexA].w;
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
|
||||
// Cdot = dot(u, v + cross(w, r))
|
||||
b2Vec2 vpA = vA + b2Cross(wA, m_rA);
|
||||
b2Vec2 vpB = vB + b2Cross(wB, m_rB);
|
||||
float32 C = m_length - m_maxLength;
|
||||
float32 Cdot = b2Dot(m_u, vpB - vpA);
|
||||
|
||||
// Predictive constraint.
|
||||
if (C < 0.0f)
|
||||
{
|
||||
Cdot += data.step.inv_dt * C;
|
||||
}
|
||||
|
||||
float32 impulse = -m_mass * Cdot;
|
||||
float32 oldImpulse = m_impulse;
|
||||
m_impulse = b2Min(0.0f, m_impulse + impulse);
|
||||
impulse = m_impulse - oldImpulse;
|
||||
|
||||
b2Vec2 P = impulse * m_u;
|
||||
vA -= m_invMassA * P;
|
||||
wA -= m_invIA * b2Cross(m_rA, P);
|
||||
vB += m_invMassB * P;
|
||||
wB += m_invIB * b2Cross(m_rB, P);
|
||||
|
||||
data.velocities[m_indexA].v = vA;
|
||||
data.velocities[m_indexA].w = wA;
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
}
|
||||
|
||||
bool b2RopeJoint::SolvePositionConstraints(const b2SolverData& data)
|
||||
{
|
||||
b2Vec2 cA = data.positions[m_indexA].c;
|
||||
float32 aA = data.positions[m_indexA].a;
|
||||
b2Vec2 cB = data.positions[m_indexB].c;
|
||||
float32 aB = data.positions[m_indexB].a;
|
||||
|
||||
b2Rot qA(aA), qB(aB);
|
||||
|
||||
b2Vec2 rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
|
||||
b2Vec2 rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
|
||||
b2Vec2 u = cB + rB - cA - rA;
|
||||
|
||||
float32 length = u.Normalize();
|
||||
float32 C = length - m_maxLength;
|
||||
|
||||
C = b2Clamp(C, 0.0f, b2_maxLinearCorrection);
|
||||
|
||||
float32 impulse = -m_mass * C;
|
||||
b2Vec2 P = impulse * u;
|
||||
|
||||
cA -= m_invMassA * P;
|
||||
aA -= m_invIA * b2Cross(rA, P);
|
||||
cB += m_invMassB * P;
|
||||
aB += m_invIB * b2Cross(rB, P);
|
||||
|
||||
data.positions[m_indexA].c = cA;
|
||||
data.positions[m_indexA].a = aA;
|
||||
data.positions[m_indexB].c = cB;
|
||||
data.positions[m_indexB].a = aB;
|
||||
|
||||
return length - m_maxLength < b2_linearSlop;
|
||||
}
|
||||
|
||||
b2Vec2 b2RopeJoint::GetAnchorA() const
|
||||
{
|
||||
return m_bodyA->GetWorldPoint(m_localAnchorA);
|
||||
}
|
||||
|
||||
b2Vec2 b2RopeJoint::GetAnchorB() const
|
||||
{
|
||||
return m_bodyB->GetWorldPoint(m_localAnchorB);
|
||||
}
|
||||
|
||||
b2Vec2 b2RopeJoint::GetReactionForce(float32 inv_dt) const
|
||||
{
|
||||
b2Vec2 F = (inv_dt * m_impulse) * m_u;
|
||||
return F;
|
||||
}
|
||||
|
||||
float32 b2RopeJoint::GetReactionTorque(float32 inv_dt) const
|
||||
{
|
||||
B2_NOT_USED(inv_dt);
|
||||
return 0.0f;
|
||||
}
|
||||
|
||||
float32 b2RopeJoint::GetMaxLength() const
|
||||
{
|
||||
return m_maxLength;
|
||||
}
|
||||
|
||||
b2LimitState b2RopeJoint::GetLimitState() const
|
||||
{
|
||||
return m_state;
|
||||
}
|
||||
|
||||
void b2RopeJoint::Dump()
|
||||
{
|
||||
int32 indexA = m_bodyA->m_islandIndex;
|
||||
int32 indexB = m_bodyB->m_islandIndex;
|
||||
|
||||
b2Log(" b2RopeJointDef jd;\n");
|
||||
b2Log(" jd.bodyA = bodies[%d];\n", indexA);
|
||||
b2Log(" jd.bodyB = bodies[%d];\n", indexB);
|
||||
b2Log(" jd.collideConnected = bool(%d);\n", m_collideConnected);
|
||||
b2Log(" jd.localAnchorA.Set(%.15lef, %.15lef);\n", m_localAnchorA.x, m_localAnchorA.y);
|
||||
b2Log(" jd.localAnchorB.Set(%.15lef, %.15lef);\n", m_localAnchorB.x, m_localAnchorB.y);
|
||||
b2Log(" jd.maxLength = %.15lef;\n", m_maxLength);
|
||||
b2Log(" joints[%d] = m_world->CreateJoint(&jd);\n", m_index);
|
||||
}
|
||||
/*
|
||||
* Copyright (c) 2007-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "b2RopeJoint.h"
|
||||
#include "../b2Body.h"
|
||||
#include "../b2TimeStep.h"
|
||||
|
||||
|
||||
// Limit:
|
||||
// C = norm(pB - pA) - L
|
||||
// u = (pB - pA) / norm(pB - pA)
|
||||
// Cdot = dot(u, vB + cross(wB, rB) - vA - cross(wA, rA))
|
||||
// J = [-u -cross(rA, u) u cross(rB, u)]
|
||||
// K = J * invM * JT
|
||||
// = invMassA + invIA * cross(rA, u)^2 + invMassB + invIB * cross(rB, u)^2
|
||||
|
||||
b2RopeJoint::b2RopeJoint(const b2RopeJointDef* def)
|
||||
: b2Joint(def)
|
||||
{
|
||||
m_localAnchorA = def->localAnchorA;
|
||||
m_localAnchorB = def->localAnchorB;
|
||||
|
||||
m_maxLength = def->maxLength;
|
||||
|
||||
m_mass = 0.0f;
|
||||
m_impulse = 0.0f;
|
||||
m_state = e_inactiveLimit;
|
||||
m_length = 0.0f;
|
||||
}
|
||||
|
||||
void b2RopeJoint::InitVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
m_indexA = m_bodyA->m_islandIndex;
|
||||
m_indexB = m_bodyB->m_islandIndex;
|
||||
m_localCenterA = m_bodyA->m_sweep.localCenter;
|
||||
m_localCenterB = m_bodyB->m_sweep.localCenter;
|
||||
m_invMassA = m_bodyA->m_invMass;
|
||||
m_invMassB = m_bodyB->m_invMass;
|
||||
m_invIA = m_bodyA->m_invI;
|
||||
m_invIB = m_bodyB->m_invI;
|
||||
|
||||
b2Vec2 cA = data.positions[m_indexA].c;
|
||||
float32 aA = data.positions[m_indexA].a;
|
||||
b2Vec2 vA = data.velocities[m_indexA].v;
|
||||
float32 wA = data.velocities[m_indexA].w;
|
||||
|
||||
b2Vec2 cB = data.positions[m_indexB].c;
|
||||
float32 aB = data.positions[m_indexB].a;
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
|
||||
b2Rot qA(aA), qB(aB);
|
||||
|
||||
m_rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
|
||||
m_rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
|
||||
m_u = cB + m_rB - cA - m_rA;
|
||||
|
||||
m_length = m_u.Length();
|
||||
|
||||
float32 C = m_length - m_maxLength;
|
||||
if (C > 0.0f)
|
||||
{
|
||||
m_state = e_atUpperLimit;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_state = e_inactiveLimit;
|
||||
}
|
||||
|
||||
if (m_length > b2_linearSlop)
|
||||
{
|
||||
m_u *= 1.0f / m_length;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_u.SetZero();
|
||||
m_mass = 0.0f;
|
||||
m_impulse = 0.0f;
|
||||
return;
|
||||
}
|
||||
|
||||
// Compute effective mass.
|
||||
float32 crA = b2Cross(m_rA, m_u);
|
||||
float32 crB = b2Cross(m_rB, m_u);
|
||||
float32 invMass = m_invMassA + m_invIA * crA * crA + m_invMassB + m_invIB * crB * crB;
|
||||
|
||||
m_mass = invMass != 0.0f ? 1.0f / invMass : 0.0f;
|
||||
|
||||
if (data.step.warmStarting)
|
||||
{
|
||||
// Scale the impulse to support a variable time step.
|
||||
m_impulse *= data.step.dtRatio;
|
||||
|
||||
b2Vec2 P = m_impulse * m_u;
|
||||
vA -= m_invMassA * P;
|
||||
wA -= m_invIA * b2Cross(m_rA, P);
|
||||
vB += m_invMassB * P;
|
||||
wB += m_invIB * b2Cross(m_rB, P);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_impulse = 0.0f;
|
||||
}
|
||||
|
||||
data.velocities[m_indexA].v = vA;
|
||||
data.velocities[m_indexA].w = wA;
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
}
|
||||
|
||||
void b2RopeJoint::SolveVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
b2Vec2 vA = data.velocities[m_indexA].v;
|
||||
float32 wA = data.velocities[m_indexA].w;
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
|
||||
// Cdot = dot(u, v + cross(w, r))
|
||||
b2Vec2 vpA = vA + b2Cross(wA, m_rA);
|
||||
b2Vec2 vpB = vB + b2Cross(wB, m_rB);
|
||||
float32 C = m_length - m_maxLength;
|
||||
float32 Cdot = b2Dot(m_u, vpB - vpA);
|
||||
|
||||
// Predictive constraint.
|
||||
if (C < 0.0f)
|
||||
{
|
||||
Cdot += data.step.inv_dt * C;
|
||||
}
|
||||
|
||||
float32 impulse = -m_mass * Cdot;
|
||||
float32 oldImpulse = m_impulse;
|
||||
m_impulse = b2Min(0.0f, m_impulse + impulse);
|
||||
impulse = m_impulse - oldImpulse;
|
||||
|
||||
b2Vec2 P = impulse * m_u;
|
||||
vA -= m_invMassA * P;
|
||||
wA -= m_invIA * b2Cross(m_rA, P);
|
||||
vB += m_invMassB * P;
|
||||
wB += m_invIB * b2Cross(m_rB, P);
|
||||
|
||||
data.velocities[m_indexA].v = vA;
|
||||
data.velocities[m_indexA].w = wA;
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
}
|
||||
|
||||
bool b2RopeJoint::SolvePositionConstraints(const b2SolverData& data)
|
||||
{
|
||||
b2Vec2 cA = data.positions[m_indexA].c;
|
||||
float32 aA = data.positions[m_indexA].a;
|
||||
b2Vec2 cB = data.positions[m_indexB].c;
|
||||
float32 aB = data.positions[m_indexB].a;
|
||||
|
||||
b2Rot qA(aA), qB(aB);
|
||||
|
||||
b2Vec2 rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
|
||||
b2Vec2 rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
|
||||
b2Vec2 u = cB + rB - cA - rA;
|
||||
|
||||
float32 length = u.Normalize();
|
||||
float32 C = length - m_maxLength;
|
||||
|
||||
C = b2Clamp(C, 0.0f, b2_maxLinearCorrection);
|
||||
|
||||
float32 impulse = -m_mass * C;
|
||||
b2Vec2 P = impulse * u;
|
||||
|
||||
cA -= m_invMassA * P;
|
||||
aA -= m_invIA * b2Cross(rA, P);
|
||||
cB += m_invMassB * P;
|
||||
aB += m_invIB * b2Cross(rB, P);
|
||||
|
||||
data.positions[m_indexA].c = cA;
|
||||
data.positions[m_indexA].a = aA;
|
||||
data.positions[m_indexB].c = cB;
|
||||
data.positions[m_indexB].a = aB;
|
||||
|
||||
return length - m_maxLength < b2_linearSlop;
|
||||
}
|
||||
|
||||
b2Vec2 b2RopeJoint::GetAnchorA() const
|
||||
{
|
||||
return m_bodyA->GetWorldPoint(m_localAnchorA);
|
||||
}
|
||||
|
||||
b2Vec2 b2RopeJoint::GetAnchorB() const
|
||||
{
|
||||
return m_bodyB->GetWorldPoint(m_localAnchorB);
|
||||
}
|
||||
|
||||
b2Vec2 b2RopeJoint::GetReactionForce(float32 inv_dt) const
|
||||
{
|
||||
b2Vec2 F = (inv_dt * m_impulse) * m_u;
|
||||
return F;
|
||||
}
|
||||
|
||||
float32 b2RopeJoint::GetReactionTorque(float32 inv_dt) const
|
||||
{
|
||||
B2_NOT_USED(inv_dt);
|
||||
return 0.0f;
|
||||
}
|
||||
|
||||
float32 b2RopeJoint::GetMaxLength() const
|
||||
{
|
||||
return m_maxLength;
|
||||
}
|
||||
|
||||
b2LimitState b2RopeJoint::GetLimitState() const
|
||||
{
|
||||
return m_state;
|
||||
}
|
||||
|
||||
void b2RopeJoint::Dump()
|
||||
{
|
||||
int32 indexA = m_bodyA->m_islandIndex;
|
||||
int32 indexB = m_bodyB->m_islandIndex;
|
||||
|
||||
b2Log(" b2RopeJointDef jd;\n");
|
||||
b2Log(" jd.bodyA = bodies[%d];\n", indexA);
|
||||
b2Log(" jd.bodyB = bodies[%d];\n", indexB);
|
||||
b2Log(" jd.collideConnected = bool(%d);\n", m_collideConnected);
|
||||
b2Log(" jd.localAnchorA.Set(%.15lef, %.15lef);\n", m_localAnchorA.x, m_localAnchorA.y);
|
||||
b2Log(" jd.localAnchorB.Set(%.15lef, %.15lef);\n", m_localAnchorB.x, m_localAnchorB.y);
|
||||
b2Log(" jd.maxLength = %.15lef;\n", m_maxLength);
|
||||
b2Log(" joints[%d] = m_world->CreateJoint(&jd);\n", m_index);
|
||||
}
|
||||
|
||||
@@ -1,114 +1,114 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_ROPE_JOINT_H
|
||||
#define B2_ROPE_JOINT_H
|
||||
|
||||
#include "b2Joint.h"
|
||||
|
||||
/// Rope joint definition. This requires two body anchor points and
|
||||
/// a maximum lengths.
|
||||
/// Note: by default the connected objects will not collide.
|
||||
/// see collideConnected in b2JointDef.
|
||||
struct b2RopeJointDef : public b2JointDef
|
||||
{
|
||||
b2RopeJointDef()
|
||||
{
|
||||
type = e_ropeJoint;
|
||||
localAnchorA.Set(-1.0f, 0.0f);
|
||||
localAnchorB.Set(1.0f, 0.0f);
|
||||
maxLength = 0.0f;
|
||||
}
|
||||
|
||||
/// The local anchor point relative to bodyA's origin.
|
||||
b2Vec2 localAnchorA;
|
||||
|
||||
/// The local anchor point relative to bodyB's origin.
|
||||
b2Vec2 localAnchorB;
|
||||
|
||||
/// The maximum length of the rope.
|
||||
/// Warning: this must be larger than b2_linearSlop or
|
||||
/// the joint will have no effect.
|
||||
float32 maxLength;
|
||||
};
|
||||
|
||||
/// A rope joint enforces a maximum distance between two points
|
||||
/// on two bodies. It has no other effect.
|
||||
/// Warning: if you attempt to change the maximum length during
|
||||
/// the simulation you will get some non-physical behavior.
|
||||
/// A model that would allow you to dynamically modify the length
|
||||
/// would have some sponginess, so I chose not to implement it
|
||||
/// that way. See b2DistanceJoint if you want to dynamically
|
||||
/// control length.
|
||||
class b2RopeJoint : public b2Joint
|
||||
{
|
||||
public:
|
||||
b2Vec2 GetAnchorA() const;
|
||||
b2Vec2 GetAnchorB() const;
|
||||
|
||||
b2Vec2 GetReactionForce(float32 inv_dt) const;
|
||||
float32 GetReactionTorque(float32 inv_dt) const;
|
||||
|
||||
/// The local anchor point relative to bodyA's origin.
|
||||
const b2Vec2& GetLocalAnchorA() const { return m_localAnchorA; }
|
||||
|
||||
/// The local anchor point relative to bodyB's origin.
|
||||
const b2Vec2& GetLocalAnchorB() const { return m_localAnchorB; }
|
||||
|
||||
/// Set/Get the maximum length of the rope.
|
||||
void SetMaxLength(float32 length) { m_maxLength = length; }
|
||||
float32 GetMaxLength() const;
|
||||
|
||||
b2LimitState GetLimitState() const;
|
||||
|
||||
/// Dump joint to dmLog
|
||||
void Dump();
|
||||
|
||||
protected:
|
||||
|
||||
friend class b2Joint;
|
||||
b2RopeJoint(const b2RopeJointDef* data);
|
||||
|
||||
void InitVelocityConstraints(const b2SolverData& data);
|
||||
void SolveVelocityConstraints(const b2SolverData& data);
|
||||
bool SolvePositionConstraints(const b2SolverData& data);
|
||||
|
||||
// Solver shared
|
||||
b2Vec2 m_localAnchorA;
|
||||
b2Vec2 m_localAnchorB;
|
||||
float32 m_maxLength;
|
||||
float32 m_length;
|
||||
float32 m_impulse;
|
||||
|
||||
// Solver temp
|
||||
juce::int32 m_indexA;
|
||||
juce::int32 m_indexB;
|
||||
b2Vec2 m_u;
|
||||
b2Vec2 m_rA;
|
||||
b2Vec2 m_rB;
|
||||
b2Vec2 m_localCenterA;
|
||||
b2Vec2 m_localCenterB;
|
||||
float32 m_invMassA;
|
||||
float32 m_invMassB;
|
||||
float32 m_invIA;
|
||||
float32 m_invIB;
|
||||
float32 m_mass;
|
||||
b2LimitState m_state;
|
||||
};
|
||||
|
||||
#endif
|
||||
/*
|
||||
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_ROPE_JOINT_H
|
||||
#define B2_ROPE_JOINT_H
|
||||
|
||||
#include "b2Joint.h"
|
||||
|
||||
/// Rope joint definition. This requires two body anchor points and
|
||||
/// a maximum lengths.
|
||||
/// Note: by default the connected objects will not collide.
|
||||
/// see collideConnected in b2JointDef.
|
||||
struct b2RopeJointDef : public b2JointDef
|
||||
{
|
||||
b2RopeJointDef()
|
||||
{
|
||||
type = e_ropeJoint;
|
||||
localAnchorA.Set(-1.0f, 0.0f);
|
||||
localAnchorB.Set(1.0f, 0.0f);
|
||||
maxLength = 0.0f;
|
||||
}
|
||||
|
||||
/// The local anchor point relative to bodyA's origin.
|
||||
b2Vec2 localAnchorA;
|
||||
|
||||
/// The local anchor point relative to bodyB's origin.
|
||||
b2Vec2 localAnchorB;
|
||||
|
||||
/// The maximum length of the rope.
|
||||
/// Warning: this must be larger than b2_linearSlop or
|
||||
/// the joint will have no effect.
|
||||
float32 maxLength;
|
||||
};
|
||||
|
||||
/// A rope joint enforces a maximum distance between two points
|
||||
/// on two bodies. It has no other effect.
|
||||
/// Warning: if you attempt to change the maximum length during
|
||||
/// the simulation you will get some non-physical behavior.
|
||||
/// A model that would allow you to dynamically modify the length
|
||||
/// would have some sponginess, so I chose not to implement it
|
||||
/// that way. See b2DistanceJoint if you want to dynamically
|
||||
/// control length.
|
||||
class b2RopeJoint : public b2Joint
|
||||
{
|
||||
public:
|
||||
b2Vec2 GetAnchorA() const;
|
||||
b2Vec2 GetAnchorB() const;
|
||||
|
||||
b2Vec2 GetReactionForce(float32 inv_dt) const;
|
||||
float32 GetReactionTorque(float32 inv_dt) const;
|
||||
|
||||
/// The local anchor point relative to bodyA's origin.
|
||||
const b2Vec2& GetLocalAnchorA() const { return m_localAnchorA; }
|
||||
|
||||
/// The local anchor point relative to bodyB's origin.
|
||||
const b2Vec2& GetLocalAnchorB() const { return m_localAnchorB; }
|
||||
|
||||
/// Set/Get the maximum length of the rope.
|
||||
void SetMaxLength(float32 length) { m_maxLength = length; }
|
||||
float32 GetMaxLength() const;
|
||||
|
||||
b2LimitState GetLimitState() const;
|
||||
|
||||
/// Dump joint to dmLog
|
||||
void Dump();
|
||||
|
||||
protected:
|
||||
|
||||
friend class b2Joint;
|
||||
b2RopeJoint(const b2RopeJointDef* data);
|
||||
|
||||
void InitVelocityConstraints(const b2SolverData& data);
|
||||
void SolveVelocityConstraints(const b2SolverData& data);
|
||||
bool SolvePositionConstraints(const b2SolverData& data);
|
||||
|
||||
// Solver shared
|
||||
b2Vec2 m_localAnchorA;
|
||||
b2Vec2 m_localAnchorB;
|
||||
float32 m_maxLength;
|
||||
float32 m_length;
|
||||
float32 m_impulse;
|
||||
|
||||
// Solver temp
|
||||
juce::int32 m_indexA;
|
||||
juce::int32 m_indexB;
|
||||
b2Vec2 m_u;
|
||||
b2Vec2 m_rA;
|
||||
b2Vec2 m_rB;
|
||||
b2Vec2 m_localCenterA;
|
||||
b2Vec2 m_localCenterB;
|
||||
float32 m_invMassA;
|
||||
float32 m_invMassB;
|
||||
float32 m_invIA;
|
||||
float32 m_invIB;
|
||||
float32 m_mass;
|
||||
b2LimitState m_state;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,328 +1,328 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "b2WeldJoint.h"
|
||||
#include "../b2Body.h"
|
||||
#include "../b2TimeStep.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)
|
||||
|
||||
// Angle constraint
|
||||
// C = angle2 - angle1 - referenceAngle
|
||||
// Cdot = w2 - w1
|
||||
// J = [0 0 -1 0 0 1]
|
||||
// K = invI1 + invI2
|
||||
|
||||
void b2WeldJointDef::Initialize(b2Body* bA, b2Body* bB, const b2Vec2& anchor)
|
||||
{
|
||||
bodyA = bA;
|
||||
bodyB = bB;
|
||||
localAnchorA = bodyA->GetLocalPoint(anchor);
|
||||
localAnchorB = bodyB->GetLocalPoint(anchor);
|
||||
referenceAngle = bodyB->GetAngle() - bodyA->GetAngle();
|
||||
}
|
||||
|
||||
b2WeldJoint::b2WeldJoint(const b2WeldJointDef* def)
|
||||
: b2Joint(def)
|
||||
{
|
||||
m_localAnchorA = def->localAnchorA;
|
||||
m_localAnchorB = def->localAnchorB;
|
||||
m_referenceAngle = def->referenceAngle;
|
||||
m_frequencyHz = def->frequencyHz;
|
||||
m_dampingRatio = def->dampingRatio;
|
||||
|
||||
m_impulse.SetZero();
|
||||
}
|
||||
|
||||
void b2WeldJoint::InitVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
m_indexA = m_bodyA->m_islandIndex;
|
||||
m_indexB = m_bodyB->m_islandIndex;
|
||||
m_localCenterA = m_bodyA->m_sweep.localCenter;
|
||||
m_localCenterB = m_bodyB->m_sweep.localCenter;
|
||||
m_invMassA = m_bodyA->m_invMass;
|
||||
m_invMassB = m_bodyB->m_invMass;
|
||||
m_invIA = m_bodyA->m_invI;
|
||||
m_invIB = m_bodyB->m_invI;
|
||||
|
||||
float32 aA = data.positions[m_indexA].a;
|
||||
b2Vec2 vA = data.velocities[m_indexA].v;
|
||||
float32 wA = data.velocities[m_indexA].w;
|
||||
|
||||
float32 aB = data.positions[m_indexB].a;
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
|
||||
b2Rot qA(aA), qB(aB);
|
||||
|
||||
m_rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
|
||||
m_rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
|
||||
|
||||
// J = [-I -r1_skew I r2_skew]
|
||||
// [ 0 -1 0 1]
|
||||
// r_skew = [-ry; rx]
|
||||
|
||||
// Matlab
|
||||
// K = [ mA+r1y^2*iA+mB+r2y^2*iB, -r1y*iA*r1x-r2y*iB*r2x, -r1y*iA-r2y*iB]
|
||||
// [ -r1y*iA*r1x-r2y*iB*r2x, mA+r1x^2*iA+mB+r2x^2*iB, r1x*iA+r2x*iB]
|
||||
// [ -r1y*iA-r2y*iB, r1x*iA+r2x*iB, iA+iB]
|
||||
|
||||
float32 mA = m_invMassA, mB = m_invMassB;
|
||||
float32 iA = m_invIA, iB = m_invIB;
|
||||
|
||||
b2Mat33 K;
|
||||
K.ex.x = mA + mB + m_rA.y * m_rA.y * iA + m_rB.y * m_rB.y * iB;
|
||||
K.ey.x = -m_rA.y * m_rA.x * iA - m_rB.y * m_rB.x * iB;
|
||||
K.ez.x = -m_rA.y * iA - m_rB.y * iB;
|
||||
K.ex.y = K.ey.x;
|
||||
K.ey.y = mA + mB + m_rA.x * m_rA.x * iA + m_rB.x * m_rB.x * iB;
|
||||
K.ez.y = m_rA.x * iA + m_rB.x * iB;
|
||||
K.ex.z = K.ez.x;
|
||||
K.ey.z = K.ez.y;
|
||||
K.ez.z = iA + iB;
|
||||
|
||||
if (m_frequencyHz > 0.0f)
|
||||
{
|
||||
K.GetInverse22(&m_mass);
|
||||
|
||||
float32 invM = iA + iB;
|
||||
float32 m = invM > 0.0f ? 1.0f / invM : 0.0f;
|
||||
|
||||
float32 C = aB - aA - m_referenceAngle;
|
||||
|
||||
// Frequency
|
||||
float32 omega = 2.0f * b2_pi * m_frequencyHz;
|
||||
|
||||
// Damping coefficient
|
||||
float32 d = 2.0f * m * m_dampingRatio * omega;
|
||||
|
||||
// Spring stiffness
|
||||
float32 k = m * omega * omega;
|
||||
|
||||
// magic formulas
|
||||
float32 h = data.step.dt;
|
||||
m_gamma = h * (d + h * k);
|
||||
m_gamma = m_gamma != 0.0f ? 1.0f / m_gamma : 0.0f;
|
||||
m_bias = C * h * k * m_gamma;
|
||||
|
||||
invM += m_gamma;
|
||||
m_mass.ez.z = invM != 0.0f ? 1.0f / invM : 0.0f;
|
||||
}
|
||||
else
|
||||
{
|
||||
K.GetSymInverse33(&m_mass);
|
||||
m_gamma = 0.0f;
|
||||
m_bias = 0.0f;
|
||||
}
|
||||
|
||||
if (data.step.warmStarting)
|
||||
{
|
||||
// Scale impulses to support a variable time step.
|
||||
m_impulse *= data.step.dtRatio;
|
||||
|
||||
b2Vec2 P(m_impulse.x, m_impulse.y);
|
||||
|
||||
vA -= mA * P;
|
||||
wA -= iA * (b2Cross(m_rA, P) + m_impulse.z);
|
||||
|
||||
vB += mB * P;
|
||||
wB += iB * (b2Cross(m_rB, P) + m_impulse.z);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_impulse.SetZero();
|
||||
}
|
||||
|
||||
data.velocities[m_indexA].v = vA;
|
||||
data.velocities[m_indexA].w = wA;
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
}
|
||||
|
||||
void b2WeldJoint::SolveVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
b2Vec2 vA = data.velocities[m_indexA].v;
|
||||
float32 wA = data.velocities[m_indexA].w;
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
|
||||
float32 mA = m_invMassA, mB = m_invMassB;
|
||||
float32 iA = m_invIA, iB = m_invIB;
|
||||
|
||||
if (m_frequencyHz > 0.0f)
|
||||
{
|
||||
float32 Cdot2 = wB - wA;
|
||||
|
||||
float32 impulse2 = -m_mass.ez.z * (Cdot2 + m_bias + m_gamma * m_impulse.z);
|
||||
m_impulse.z += impulse2;
|
||||
|
||||
wA -= iA * impulse2;
|
||||
wB += iB * impulse2;
|
||||
|
||||
b2Vec2 Cdot1 = vB + b2Cross(wB, m_rB) - vA - b2Cross(wA, m_rA);
|
||||
|
||||
b2Vec2 impulse1 = -b2Mul22(m_mass, Cdot1);
|
||||
m_impulse.x += impulse1.x;
|
||||
m_impulse.y += impulse1.y;
|
||||
|
||||
b2Vec2 P = impulse1;
|
||||
|
||||
vA -= mA * P;
|
||||
wA -= iA * b2Cross(m_rA, P);
|
||||
|
||||
vB += mB * P;
|
||||
wB += iB * b2Cross(m_rB, P);
|
||||
}
|
||||
else
|
||||
{
|
||||
b2Vec2 Cdot1 = vB + b2Cross(wB, m_rB) - vA - b2Cross(wA, m_rA);
|
||||
float32 Cdot2 = wB - wA;
|
||||
b2Vec3 Cdot(Cdot1.x, Cdot1.y, Cdot2);
|
||||
|
||||
b2Vec3 impulse = -b2Mul(m_mass, Cdot);
|
||||
m_impulse += impulse;
|
||||
|
||||
b2Vec2 P(impulse.x, impulse.y);
|
||||
|
||||
vA -= mA * P;
|
||||
wA -= iA * (b2Cross(m_rA, P) + impulse.z);
|
||||
|
||||
vB += mB * P;
|
||||
wB += iB * (b2Cross(m_rB, P) + impulse.z);
|
||||
}
|
||||
|
||||
data.velocities[m_indexA].v = vA;
|
||||
data.velocities[m_indexA].w = wA;
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
}
|
||||
|
||||
bool b2WeldJoint::SolvePositionConstraints(const b2SolverData& data)
|
||||
{
|
||||
b2Vec2 cA = data.positions[m_indexA].c;
|
||||
float32 aA = data.positions[m_indexA].a;
|
||||
b2Vec2 cB = data.positions[m_indexB].c;
|
||||
float32 aB = data.positions[m_indexB].a;
|
||||
|
||||
b2Rot qA(aA), qB(aB);
|
||||
|
||||
float32 mA = m_invMassA, mB = m_invMassB;
|
||||
float32 iA = m_invIA, iB = m_invIB;
|
||||
|
||||
b2Vec2 rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
|
||||
b2Vec2 rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
|
||||
|
||||
float32 positionError, angularError;
|
||||
|
||||
b2Mat33 K;
|
||||
K.ex.x = mA + mB + rA.y * rA.y * iA + rB.y * rB.y * iB;
|
||||
K.ey.x = -rA.y * rA.x * iA - rB.y * rB.x * iB;
|
||||
K.ez.x = -rA.y * iA - rB.y * iB;
|
||||
K.ex.y = K.ey.x;
|
||||
K.ey.y = mA + mB + rA.x * rA.x * iA + rB.x * rB.x * iB;
|
||||
K.ez.y = rA.x * iA + rB.x * iB;
|
||||
K.ex.z = K.ez.x;
|
||||
K.ey.z = K.ez.y;
|
||||
K.ez.z = iA + iB;
|
||||
|
||||
if (m_frequencyHz > 0.0f)
|
||||
{
|
||||
b2Vec2 C1 = cB + rB - cA - rA;
|
||||
|
||||
positionError = C1.Length();
|
||||
angularError = 0.0f;
|
||||
|
||||
b2Vec2 P = -K.Solve22(C1);
|
||||
|
||||
cA -= mA * P;
|
||||
aA -= iA * b2Cross(rA, P);
|
||||
|
||||
cB += mB * P;
|
||||
aB += iB * b2Cross(rB, P);
|
||||
}
|
||||
else
|
||||
{
|
||||
b2Vec2 C1 = cB + rB - cA - rA;
|
||||
float32 C2 = aB - aA - m_referenceAngle;
|
||||
|
||||
positionError = C1.Length();
|
||||
angularError = b2Abs(C2);
|
||||
|
||||
b2Vec3 C(C1.x, C1.y, C2);
|
||||
|
||||
b2Vec3 impulse = -K.Solve33(C);
|
||||
b2Vec2 P(impulse.x, impulse.y);
|
||||
|
||||
cA -= mA * P;
|
||||
aA -= iA * (b2Cross(rA, P) + impulse.z);
|
||||
|
||||
cB += mB * P;
|
||||
aB += iB * (b2Cross(rB, P) + impulse.z);
|
||||
}
|
||||
|
||||
data.positions[m_indexA].c = cA;
|
||||
data.positions[m_indexA].a = aA;
|
||||
data.positions[m_indexB].c = cB;
|
||||
data.positions[m_indexB].a = aB;
|
||||
|
||||
return positionError <= b2_linearSlop && angularError <= b2_angularSlop;
|
||||
}
|
||||
|
||||
b2Vec2 b2WeldJoint::GetAnchorA() const
|
||||
{
|
||||
return m_bodyA->GetWorldPoint(m_localAnchorA);
|
||||
}
|
||||
|
||||
b2Vec2 b2WeldJoint::GetAnchorB() const
|
||||
{
|
||||
return m_bodyB->GetWorldPoint(m_localAnchorB);
|
||||
}
|
||||
|
||||
b2Vec2 b2WeldJoint::GetReactionForce(float32 inv_dt) const
|
||||
{
|
||||
b2Vec2 P(m_impulse.x, m_impulse.y);
|
||||
return inv_dt * P;
|
||||
}
|
||||
|
||||
float32 b2WeldJoint::GetReactionTorque(float32 inv_dt) const
|
||||
{
|
||||
return inv_dt * m_impulse.z;
|
||||
}
|
||||
|
||||
void b2WeldJoint::Dump()
|
||||
{
|
||||
int32 indexA = m_bodyA->m_islandIndex;
|
||||
int32 indexB = m_bodyB->m_islandIndex;
|
||||
|
||||
b2Log(" b2WeldJointDef jd;\n");
|
||||
b2Log(" jd.bodyA = bodies[%d];\n", indexA);
|
||||
b2Log(" jd.bodyB = bodies[%d];\n", indexB);
|
||||
b2Log(" jd.collideConnected = bool(%d);\n", m_collideConnected);
|
||||
b2Log(" jd.localAnchorA.Set(%.15lef, %.15lef);\n", m_localAnchorA.x, m_localAnchorA.y);
|
||||
b2Log(" jd.localAnchorB.Set(%.15lef, %.15lef);\n", m_localAnchorB.x, m_localAnchorB.y);
|
||||
b2Log(" jd.referenceAngle = %.15lef;\n", m_referenceAngle);
|
||||
b2Log(" jd.frequencyHz = %.15lef;\n", m_frequencyHz);
|
||||
b2Log(" jd.dampingRatio = %.15lef;\n", m_dampingRatio);
|
||||
b2Log(" joints[%d] = m_world->CreateJoint(&jd);\n", m_index);
|
||||
}
|
||||
/*
|
||||
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "b2WeldJoint.h"
|
||||
#include "../b2Body.h"
|
||||
#include "../b2TimeStep.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)
|
||||
|
||||
// Angle constraint
|
||||
// C = angle2 - angle1 - referenceAngle
|
||||
// Cdot = w2 - w1
|
||||
// J = [0 0 -1 0 0 1]
|
||||
// K = invI1 + invI2
|
||||
|
||||
void b2WeldJointDef::Initialize(b2Body* bA, b2Body* bB, const b2Vec2& anchor)
|
||||
{
|
||||
bodyA = bA;
|
||||
bodyB = bB;
|
||||
localAnchorA = bodyA->GetLocalPoint(anchor);
|
||||
localAnchorB = bodyB->GetLocalPoint(anchor);
|
||||
referenceAngle = bodyB->GetAngle() - bodyA->GetAngle();
|
||||
}
|
||||
|
||||
b2WeldJoint::b2WeldJoint(const b2WeldJointDef* def)
|
||||
: b2Joint(def)
|
||||
{
|
||||
m_localAnchorA = def->localAnchorA;
|
||||
m_localAnchorB = def->localAnchorB;
|
||||
m_referenceAngle = def->referenceAngle;
|
||||
m_frequencyHz = def->frequencyHz;
|
||||
m_dampingRatio = def->dampingRatio;
|
||||
|
||||
m_impulse.SetZero();
|
||||
}
|
||||
|
||||
void b2WeldJoint::InitVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
m_indexA = m_bodyA->m_islandIndex;
|
||||
m_indexB = m_bodyB->m_islandIndex;
|
||||
m_localCenterA = m_bodyA->m_sweep.localCenter;
|
||||
m_localCenterB = m_bodyB->m_sweep.localCenter;
|
||||
m_invMassA = m_bodyA->m_invMass;
|
||||
m_invMassB = m_bodyB->m_invMass;
|
||||
m_invIA = m_bodyA->m_invI;
|
||||
m_invIB = m_bodyB->m_invI;
|
||||
|
||||
float32 aA = data.positions[m_indexA].a;
|
||||
b2Vec2 vA = data.velocities[m_indexA].v;
|
||||
float32 wA = data.velocities[m_indexA].w;
|
||||
|
||||
float32 aB = data.positions[m_indexB].a;
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
|
||||
b2Rot qA(aA), qB(aB);
|
||||
|
||||
m_rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
|
||||
m_rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
|
||||
|
||||
// J = [-I -r1_skew I r2_skew]
|
||||
// [ 0 -1 0 1]
|
||||
// r_skew = [-ry; rx]
|
||||
|
||||
// Matlab
|
||||
// K = [ mA+r1y^2*iA+mB+r2y^2*iB, -r1y*iA*r1x-r2y*iB*r2x, -r1y*iA-r2y*iB]
|
||||
// [ -r1y*iA*r1x-r2y*iB*r2x, mA+r1x^2*iA+mB+r2x^2*iB, r1x*iA+r2x*iB]
|
||||
// [ -r1y*iA-r2y*iB, r1x*iA+r2x*iB, iA+iB]
|
||||
|
||||
float32 mA = m_invMassA, mB = m_invMassB;
|
||||
float32 iA = m_invIA, iB = m_invIB;
|
||||
|
||||
b2Mat33 K;
|
||||
K.ex.x = mA + mB + m_rA.y * m_rA.y * iA + m_rB.y * m_rB.y * iB;
|
||||
K.ey.x = -m_rA.y * m_rA.x * iA - m_rB.y * m_rB.x * iB;
|
||||
K.ez.x = -m_rA.y * iA - m_rB.y * iB;
|
||||
K.ex.y = K.ey.x;
|
||||
K.ey.y = mA + mB + m_rA.x * m_rA.x * iA + m_rB.x * m_rB.x * iB;
|
||||
K.ez.y = m_rA.x * iA + m_rB.x * iB;
|
||||
K.ex.z = K.ez.x;
|
||||
K.ey.z = K.ez.y;
|
||||
K.ez.z = iA + iB;
|
||||
|
||||
if (m_frequencyHz > 0.0f)
|
||||
{
|
||||
K.GetInverse22(&m_mass);
|
||||
|
||||
float32 invM = iA + iB;
|
||||
float32 m = invM > 0.0f ? 1.0f / invM : 0.0f;
|
||||
|
||||
float32 C = aB - aA - m_referenceAngle;
|
||||
|
||||
// Frequency
|
||||
float32 omega = 2.0f * b2_pi * m_frequencyHz;
|
||||
|
||||
// Damping coefficient
|
||||
float32 d = 2.0f * m * m_dampingRatio * omega;
|
||||
|
||||
// Spring stiffness
|
||||
float32 k = m * omega * omega;
|
||||
|
||||
// magic formulas
|
||||
float32 h = data.step.dt;
|
||||
m_gamma = h * (d + h * k);
|
||||
m_gamma = m_gamma != 0.0f ? 1.0f / m_gamma : 0.0f;
|
||||
m_bias = C * h * k * m_gamma;
|
||||
|
||||
invM += m_gamma;
|
||||
m_mass.ez.z = invM != 0.0f ? 1.0f / invM : 0.0f;
|
||||
}
|
||||
else
|
||||
{
|
||||
K.GetSymInverse33(&m_mass);
|
||||
m_gamma = 0.0f;
|
||||
m_bias = 0.0f;
|
||||
}
|
||||
|
||||
if (data.step.warmStarting)
|
||||
{
|
||||
// Scale impulses to support a variable time step.
|
||||
m_impulse *= data.step.dtRatio;
|
||||
|
||||
b2Vec2 P(m_impulse.x, m_impulse.y);
|
||||
|
||||
vA -= mA * P;
|
||||
wA -= iA * (b2Cross(m_rA, P) + m_impulse.z);
|
||||
|
||||
vB += mB * P;
|
||||
wB += iB * (b2Cross(m_rB, P) + m_impulse.z);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_impulse.SetZero();
|
||||
}
|
||||
|
||||
data.velocities[m_indexA].v = vA;
|
||||
data.velocities[m_indexA].w = wA;
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
}
|
||||
|
||||
void b2WeldJoint::SolveVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
b2Vec2 vA = data.velocities[m_indexA].v;
|
||||
float32 wA = data.velocities[m_indexA].w;
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
|
||||
float32 mA = m_invMassA, mB = m_invMassB;
|
||||
float32 iA = m_invIA, iB = m_invIB;
|
||||
|
||||
if (m_frequencyHz > 0.0f)
|
||||
{
|
||||
float32 Cdot2 = wB - wA;
|
||||
|
||||
float32 impulse2 = -m_mass.ez.z * (Cdot2 + m_bias + m_gamma * m_impulse.z);
|
||||
m_impulse.z += impulse2;
|
||||
|
||||
wA -= iA * impulse2;
|
||||
wB += iB * impulse2;
|
||||
|
||||
b2Vec2 Cdot1 = vB + b2Cross(wB, m_rB) - vA - b2Cross(wA, m_rA);
|
||||
|
||||
b2Vec2 impulse1 = -b2Mul22(m_mass, Cdot1);
|
||||
m_impulse.x += impulse1.x;
|
||||
m_impulse.y += impulse1.y;
|
||||
|
||||
b2Vec2 P = impulse1;
|
||||
|
||||
vA -= mA * P;
|
||||
wA -= iA * b2Cross(m_rA, P);
|
||||
|
||||
vB += mB * P;
|
||||
wB += iB * b2Cross(m_rB, P);
|
||||
}
|
||||
else
|
||||
{
|
||||
b2Vec2 Cdot1 = vB + b2Cross(wB, m_rB) - vA - b2Cross(wA, m_rA);
|
||||
float32 Cdot2 = wB - wA;
|
||||
b2Vec3 Cdot(Cdot1.x, Cdot1.y, Cdot2);
|
||||
|
||||
b2Vec3 impulse = -b2Mul(m_mass, Cdot);
|
||||
m_impulse += impulse;
|
||||
|
||||
b2Vec2 P(impulse.x, impulse.y);
|
||||
|
||||
vA -= mA * P;
|
||||
wA -= iA * (b2Cross(m_rA, P) + impulse.z);
|
||||
|
||||
vB += mB * P;
|
||||
wB += iB * (b2Cross(m_rB, P) + impulse.z);
|
||||
}
|
||||
|
||||
data.velocities[m_indexA].v = vA;
|
||||
data.velocities[m_indexA].w = wA;
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
}
|
||||
|
||||
bool b2WeldJoint::SolvePositionConstraints(const b2SolverData& data)
|
||||
{
|
||||
b2Vec2 cA = data.positions[m_indexA].c;
|
||||
float32 aA = data.positions[m_indexA].a;
|
||||
b2Vec2 cB = data.positions[m_indexB].c;
|
||||
float32 aB = data.positions[m_indexB].a;
|
||||
|
||||
b2Rot qA(aA), qB(aB);
|
||||
|
||||
float32 mA = m_invMassA, mB = m_invMassB;
|
||||
float32 iA = m_invIA, iB = m_invIB;
|
||||
|
||||
b2Vec2 rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
|
||||
b2Vec2 rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
|
||||
|
||||
float32 positionError, angularError;
|
||||
|
||||
b2Mat33 K;
|
||||
K.ex.x = mA + mB + rA.y * rA.y * iA + rB.y * rB.y * iB;
|
||||
K.ey.x = -rA.y * rA.x * iA - rB.y * rB.x * iB;
|
||||
K.ez.x = -rA.y * iA - rB.y * iB;
|
||||
K.ex.y = K.ey.x;
|
||||
K.ey.y = mA + mB + rA.x * rA.x * iA + rB.x * rB.x * iB;
|
||||
K.ez.y = rA.x * iA + rB.x * iB;
|
||||
K.ex.z = K.ez.x;
|
||||
K.ey.z = K.ez.y;
|
||||
K.ez.z = iA + iB;
|
||||
|
||||
if (m_frequencyHz > 0.0f)
|
||||
{
|
||||
b2Vec2 C1 = cB + rB - cA - rA;
|
||||
|
||||
positionError = C1.Length();
|
||||
angularError = 0.0f;
|
||||
|
||||
b2Vec2 P = -K.Solve22(C1);
|
||||
|
||||
cA -= mA * P;
|
||||
aA -= iA * b2Cross(rA, P);
|
||||
|
||||
cB += mB * P;
|
||||
aB += iB * b2Cross(rB, P);
|
||||
}
|
||||
else
|
||||
{
|
||||
b2Vec2 C1 = cB + rB - cA - rA;
|
||||
float32 C2 = aB - aA - m_referenceAngle;
|
||||
|
||||
positionError = C1.Length();
|
||||
angularError = b2Abs(C2);
|
||||
|
||||
b2Vec3 C(C1.x, C1.y, C2);
|
||||
|
||||
b2Vec3 impulse = -K.Solve33(C);
|
||||
b2Vec2 P(impulse.x, impulse.y);
|
||||
|
||||
cA -= mA * P;
|
||||
aA -= iA * (b2Cross(rA, P) + impulse.z);
|
||||
|
||||
cB += mB * P;
|
||||
aB += iB * (b2Cross(rB, P) + impulse.z);
|
||||
}
|
||||
|
||||
data.positions[m_indexA].c = cA;
|
||||
data.positions[m_indexA].a = aA;
|
||||
data.positions[m_indexB].c = cB;
|
||||
data.positions[m_indexB].a = aB;
|
||||
|
||||
return positionError <= b2_linearSlop && angularError <= b2_angularSlop;
|
||||
}
|
||||
|
||||
b2Vec2 b2WeldJoint::GetAnchorA() const
|
||||
{
|
||||
return m_bodyA->GetWorldPoint(m_localAnchorA);
|
||||
}
|
||||
|
||||
b2Vec2 b2WeldJoint::GetAnchorB() const
|
||||
{
|
||||
return m_bodyB->GetWorldPoint(m_localAnchorB);
|
||||
}
|
||||
|
||||
b2Vec2 b2WeldJoint::GetReactionForce(float32 inv_dt) const
|
||||
{
|
||||
b2Vec2 P(m_impulse.x, m_impulse.y);
|
||||
return inv_dt * P;
|
||||
}
|
||||
|
||||
float32 b2WeldJoint::GetReactionTorque(float32 inv_dt) const
|
||||
{
|
||||
return inv_dt * m_impulse.z;
|
||||
}
|
||||
|
||||
void b2WeldJoint::Dump()
|
||||
{
|
||||
int32 indexA = m_bodyA->m_islandIndex;
|
||||
int32 indexB = m_bodyB->m_islandIndex;
|
||||
|
||||
b2Log(" b2WeldJointDef jd;\n");
|
||||
b2Log(" jd.bodyA = bodies[%d];\n", indexA);
|
||||
b2Log(" jd.bodyB = bodies[%d];\n", indexB);
|
||||
b2Log(" jd.collideConnected = bool(%d);\n", m_collideConnected);
|
||||
b2Log(" jd.localAnchorA.Set(%.15lef, %.15lef);\n", m_localAnchorA.x, m_localAnchorA.y);
|
||||
b2Log(" jd.localAnchorB.Set(%.15lef, %.15lef);\n", m_localAnchorB.x, m_localAnchorB.y);
|
||||
b2Log(" jd.referenceAngle = %.15lef;\n", m_referenceAngle);
|
||||
b2Log(" jd.frequencyHz = %.15lef;\n", m_frequencyHz);
|
||||
b2Log(" jd.dampingRatio = %.15lef;\n", m_dampingRatio);
|
||||
b2Log(" joints[%d] = m_world->CreateJoint(&jd);\n", m_index);
|
||||
}
|
||||
|
||||
@@ -1,126 +1,126 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_WELD_JOINT_H
|
||||
#define B2_WELD_JOINT_H
|
||||
|
||||
#include "b2Joint.h"
|
||||
|
||||
/// Weld joint definition. You need to specify local anchor points
|
||||
/// where they are attached and the relative body angle. The position
|
||||
/// of the anchor points is important for computing the reaction torque.
|
||||
struct b2WeldJointDef : public b2JointDef
|
||||
{
|
||||
b2WeldJointDef()
|
||||
{
|
||||
type = e_weldJoint;
|
||||
localAnchorA.Set(0.0f, 0.0f);
|
||||
localAnchorB.Set(0.0f, 0.0f);
|
||||
referenceAngle = 0.0f;
|
||||
frequencyHz = 0.0f;
|
||||
dampingRatio = 0.0f;
|
||||
}
|
||||
|
||||
/// Initialize the bodies, anchors, and reference angle using a world
|
||||
/// anchor point.
|
||||
void Initialize(b2Body* bodyA, b2Body* bodyB, const b2Vec2& anchor);
|
||||
|
||||
/// The local anchor point relative to bodyA's origin.
|
||||
b2Vec2 localAnchorA;
|
||||
|
||||
/// The local anchor point relative to bodyB's origin.
|
||||
b2Vec2 localAnchorB;
|
||||
|
||||
/// The bodyB angle minus bodyA angle in the reference state (radians).
|
||||
float32 referenceAngle;
|
||||
|
||||
/// The mass-spring-damper frequency in Hertz. Rotation only.
|
||||
/// Disable softness with a value of 0.
|
||||
float32 frequencyHz;
|
||||
|
||||
/// The damping ratio. 0 = no damping, 1 = critical damping.
|
||||
float32 dampingRatio;
|
||||
};
|
||||
|
||||
/// A weld joint essentially glues two bodies together. A weld joint may
|
||||
/// distort somewhat because the island constraint solver is approximate.
|
||||
class b2WeldJoint : public b2Joint
|
||||
{
|
||||
public:
|
||||
b2Vec2 GetAnchorA() const;
|
||||
b2Vec2 GetAnchorB() const;
|
||||
|
||||
b2Vec2 GetReactionForce(float32 inv_dt) const;
|
||||
float32 GetReactionTorque(float32 inv_dt) const;
|
||||
|
||||
/// The local anchor point relative to bodyA's origin.
|
||||
const b2Vec2& GetLocalAnchorA() const { return m_localAnchorA; }
|
||||
|
||||
/// The local anchor point relative to bodyB's origin.
|
||||
const b2Vec2& GetLocalAnchorB() const { return m_localAnchorB; }
|
||||
|
||||
/// Get the reference angle.
|
||||
float32 GetReferenceAngle() const { return m_referenceAngle; }
|
||||
|
||||
/// Set/get frequency in Hz.
|
||||
void SetFrequency(float32 hz) { m_frequencyHz = hz; }
|
||||
float32 GetFrequency() const { return m_frequencyHz; }
|
||||
|
||||
/// Set/get damping ratio.
|
||||
void SetDampingRatio(float32 ratio) { m_dampingRatio = ratio; }
|
||||
float32 GetDampingRatio() const { return m_dampingRatio; }
|
||||
|
||||
/// Dump to b2Log
|
||||
void Dump();
|
||||
|
||||
protected:
|
||||
|
||||
friend class b2Joint;
|
||||
|
||||
b2WeldJoint(const b2WeldJointDef* def);
|
||||
|
||||
void InitVelocityConstraints(const b2SolverData& data);
|
||||
void SolveVelocityConstraints(const b2SolverData& data);
|
||||
bool SolvePositionConstraints(const b2SolverData& data);
|
||||
|
||||
float32 m_frequencyHz;
|
||||
float32 m_dampingRatio;
|
||||
float32 m_bias;
|
||||
|
||||
// Solver shared
|
||||
b2Vec2 m_localAnchorA;
|
||||
b2Vec2 m_localAnchorB;
|
||||
float32 m_referenceAngle;
|
||||
float32 m_gamma;
|
||||
b2Vec3 m_impulse;
|
||||
|
||||
// Solver temp
|
||||
juce::int32 m_indexA;
|
||||
juce::int32 m_indexB;
|
||||
b2Vec2 m_rA;
|
||||
b2Vec2 m_rB;
|
||||
b2Vec2 m_localCenterA;
|
||||
b2Vec2 m_localCenterB;
|
||||
float32 m_invMassA;
|
||||
float32 m_invMassB;
|
||||
float32 m_invIA;
|
||||
float32 m_invIB;
|
||||
b2Mat33 m_mass;
|
||||
};
|
||||
|
||||
#endif
|
||||
/*
|
||||
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_WELD_JOINT_H
|
||||
#define B2_WELD_JOINT_H
|
||||
|
||||
#include "b2Joint.h"
|
||||
|
||||
/// Weld joint definition. You need to specify local anchor points
|
||||
/// where they are attached and the relative body angle. The position
|
||||
/// of the anchor points is important for computing the reaction torque.
|
||||
struct b2WeldJointDef : public b2JointDef
|
||||
{
|
||||
b2WeldJointDef()
|
||||
{
|
||||
type = e_weldJoint;
|
||||
localAnchorA.Set(0.0f, 0.0f);
|
||||
localAnchorB.Set(0.0f, 0.0f);
|
||||
referenceAngle = 0.0f;
|
||||
frequencyHz = 0.0f;
|
||||
dampingRatio = 0.0f;
|
||||
}
|
||||
|
||||
/// Initialize the bodies, anchors, and reference angle using a world
|
||||
/// anchor point.
|
||||
void Initialize(b2Body* bodyA, b2Body* bodyB, const b2Vec2& anchor);
|
||||
|
||||
/// The local anchor point relative to bodyA's origin.
|
||||
b2Vec2 localAnchorA;
|
||||
|
||||
/// The local anchor point relative to bodyB's origin.
|
||||
b2Vec2 localAnchorB;
|
||||
|
||||
/// The bodyB angle minus bodyA angle in the reference state (radians).
|
||||
float32 referenceAngle;
|
||||
|
||||
/// The mass-spring-damper frequency in Hertz. Rotation only.
|
||||
/// Disable softness with a value of 0.
|
||||
float32 frequencyHz;
|
||||
|
||||
/// The damping ratio. 0 = no damping, 1 = critical damping.
|
||||
float32 dampingRatio;
|
||||
};
|
||||
|
||||
/// A weld joint essentially glues two bodies together. A weld joint may
|
||||
/// distort somewhat because the island constraint solver is approximate.
|
||||
class b2WeldJoint : public b2Joint
|
||||
{
|
||||
public:
|
||||
b2Vec2 GetAnchorA() const;
|
||||
b2Vec2 GetAnchorB() const;
|
||||
|
||||
b2Vec2 GetReactionForce(float32 inv_dt) const;
|
||||
float32 GetReactionTorque(float32 inv_dt) const;
|
||||
|
||||
/// The local anchor point relative to bodyA's origin.
|
||||
const b2Vec2& GetLocalAnchorA() const { return m_localAnchorA; }
|
||||
|
||||
/// The local anchor point relative to bodyB's origin.
|
||||
const b2Vec2& GetLocalAnchorB() const { return m_localAnchorB; }
|
||||
|
||||
/// Get the reference angle.
|
||||
float32 GetReferenceAngle() const { return m_referenceAngle; }
|
||||
|
||||
/// Set/get frequency in Hz.
|
||||
void SetFrequency(float32 hz) { m_frequencyHz = hz; }
|
||||
float32 GetFrequency() const { return m_frequencyHz; }
|
||||
|
||||
/// Set/get damping ratio.
|
||||
void SetDampingRatio(float32 ratio) { m_dampingRatio = ratio; }
|
||||
float32 GetDampingRatio() const { return m_dampingRatio; }
|
||||
|
||||
/// Dump to b2Log
|
||||
void Dump();
|
||||
|
||||
protected:
|
||||
|
||||
friend class b2Joint;
|
||||
|
||||
b2WeldJoint(const b2WeldJointDef* def);
|
||||
|
||||
void InitVelocityConstraints(const b2SolverData& data);
|
||||
void SolveVelocityConstraints(const b2SolverData& data);
|
||||
bool SolvePositionConstraints(const b2SolverData& data);
|
||||
|
||||
float32 m_frequencyHz;
|
||||
float32 m_dampingRatio;
|
||||
float32 m_bias;
|
||||
|
||||
// Solver shared
|
||||
b2Vec2 m_localAnchorA;
|
||||
b2Vec2 m_localAnchorB;
|
||||
float32 m_referenceAngle;
|
||||
float32 m_gamma;
|
||||
b2Vec3 m_impulse;
|
||||
|
||||
// Solver temp
|
||||
juce::int32 m_indexA;
|
||||
juce::int32 m_indexB;
|
||||
b2Vec2 m_rA;
|
||||
b2Vec2 m_rB;
|
||||
b2Vec2 m_localCenterA;
|
||||
b2Vec2 m_localCenterB;
|
||||
float32 m_invMassA;
|
||||
float32 m_invMassB;
|
||||
float32 m_invIA;
|
||||
float32 m_invIB;
|
||||
b2Mat33 m_mass;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,419 +1,419 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2007 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "b2WheelJoint.h"
|
||||
#include "../b2Body.h"
|
||||
#include "../b2TimeStep.h"
|
||||
|
||||
// Linear constraint (point-to-line)
|
||||
// d = pB - pA = xB + rB - xA - rA
|
||||
// C = dot(ay, d)
|
||||
// Cdot = dot(d, cross(wA, ay)) + dot(ay, vB + cross(wB, rB) - vA - cross(wA, rA))
|
||||
// = -dot(ay, vA) - dot(cross(d + rA, ay), wA) + dot(ay, vB) + dot(cross(rB, ay), vB)
|
||||
// J = [-ay, -cross(d + rA, ay), ay, cross(rB, ay)]
|
||||
|
||||
// Spring linear constraint
|
||||
// C = dot(ax, d)
|
||||
// Cdot = = -dot(ax, vA) - dot(cross(d + rA, ax), wA) + dot(ax, vB) + dot(cross(rB, ax), vB)
|
||||
// J = [-ax -cross(d+rA, ax) ax cross(rB, ax)]
|
||||
|
||||
// Motor rotational constraint
|
||||
// Cdot = wB - wA
|
||||
// J = [0 0 -1 0 0 1]
|
||||
|
||||
void b2WheelJointDef::Initialize(b2Body* bA, b2Body* bB, const b2Vec2& anchor, const b2Vec2& axis)
|
||||
{
|
||||
bodyA = bA;
|
||||
bodyB = bB;
|
||||
localAnchorA = bodyA->GetLocalPoint(anchor);
|
||||
localAnchorB = bodyB->GetLocalPoint(anchor);
|
||||
localAxisA = bodyA->GetLocalVector(axis);
|
||||
}
|
||||
|
||||
b2WheelJoint::b2WheelJoint(const b2WheelJointDef* def)
|
||||
: b2Joint(def)
|
||||
{
|
||||
m_localAnchorA = def->localAnchorA;
|
||||
m_localAnchorB = def->localAnchorB;
|
||||
m_localXAxisA = def->localAxisA;
|
||||
m_localYAxisA = b2Cross(1.0f, m_localXAxisA);
|
||||
|
||||
m_mass = 0.0f;
|
||||
m_impulse = 0.0f;
|
||||
m_motorMass = 0.0f;
|
||||
m_motorImpulse = 0.0f;
|
||||
m_springMass = 0.0f;
|
||||
m_springImpulse = 0.0f;
|
||||
|
||||
m_maxMotorTorque = def->maxMotorTorque;
|
||||
m_motorSpeed = def->motorSpeed;
|
||||
m_enableMotor = def->enableMotor;
|
||||
|
||||
m_frequencyHz = def->frequencyHz;
|
||||
m_dampingRatio = def->dampingRatio;
|
||||
|
||||
m_bias = 0.0f;
|
||||
m_gamma = 0.0f;
|
||||
|
||||
m_ax.SetZero();
|
||||
m_ay.SetZero();
|
||||
}
|
||||
|
||||
void b2WheelJoint::InitVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
m_indexA = m_bodyA->m_islandIndex;
|
||||
m_indexB = m_bodyB->m_islandIndex;
|
||||
m_localCenterA = m_bodyA->m_sweep.localCenter;
|
||||
m_localCenterB = m_bodyB->m_sweep.localCenter;
|
||||
m_invMassA = m_bodyA->m_invMass;
|
||||
m_invMassB = m_bodyB->m_invMass;
|
||||
m_invIA = m_bodyA->m_invI;
|
||||
m_invIB = m_bodyB->m_invI;
|
||||
|
||||
float32 mA = m_invMassA, mB = m_invMassB;
|
||||
float32 iA = m_invIA, iB = m_invIB;
|
||||
|
||||
b2Vec2 cA = data.positions[m_indexA].c;
|
||||
float32 aA = data.positions[m_indexA].a;
|
||||
b2Vec2 vA = data.velocities[m_indexA].v;
|
||||
float32 wA = data.velocities[m_indexA].w;
|
||||
|
||||
b2Vec2 cB = data.positions[m_indexB].c;
|
||||
float32 aB = data.positions[m_indexB].a;
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
|
||||
b2Rot qA(aA), qB(aB);
|
||||
|
||||
// Compute the effective masses.
|
||||
b2Vec2 rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
|
||||
b2Vec2 rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
|
||||
b2Vec2 d = cB + rB - cA - rA;
|
||||
|
||||
// Point to line constraint
|
||||
{
|
||||
m_ay = b2Mul(qA, m_localYAxisA);
|
||||
m_sAy = b2Cross(d + rA, m_ay);
|
||||
m_sBy = b2Cross(rB, m_ay);
|
||||
|
||||
m_mass = mA + mB + iA * m_sAy * m_sAy + iB * m_sBy * m_sBy;
|
||||
|
||||
if (m_mass > 0.0f)
|
||||
{
|
||||
m_mass = 1.0f / m_mass;
|
||||
}
|
||||
}
|
||||
|
||||
// Spring constraint
|
||||
m_springMass = 0.0f;
|
||||
m_bias = 0.0f;
|
||||
m_gamma = 0.0f;
|
||||
if (m_frequencyHz > 0.0f)
|
||||
{
|
||||
m_ax = b2Mul(qA, m_localXAxisA);
|
||||
m_sAx = b2Cross(d + rA, m_ax);
|
||||
m_sBx = b2Cross(rB, m_ax);
|
||||
|
||||
float32 invMass = mA + mB + iA * m_sAx * m_sAx + iB * m_sBx * m_sBx;
|
||||
|
||||
if (invMass > 0.0f)
|
||||
{
|
||||
m_springMass = 1.0f / invMass;
|
||||
|
||||
float32 C = b2Dot(d, m_ax);
|
||||
|
||||
// Frequency
|
||||
float32 omega = 2.0f * b2_pi * m_frequencyHz;
|
||||
|
||||
// Damping coefficient
|
||||
float32 damp = 2.0f * m_springMass * m_dampingRatio * omega;
|
||||
|
||||
// Spring stiffness
|
||||
float32 k = m_springMass * omega * omega;
|
||||
|
||||
// magic formulas
|
||||
float32 h = data.step.dt;
|
||||
m_gamma = h * (damp + h * k);
|
||||
if (m_gamma > 0.0f)
|
||||
{
|
||||
m_gamma = 1.0f / m_gamma;
|
||||
}
|
||||
|
||||
m_bias = C * h * k * m_gamma;
|
||||
|
||||
m_springMass = invMass + m_gamma;
|
||||
if (m_springMass > 0.0f)
|
||||
{
|
||||
m_springMass = 1.0f / m_springMass;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
m_springImpulse = 0.0f;
|
||||
}
|
||||
|
||||
// Rotational motor
|
||||
if (m_enableMotor)
|
||||
{
|
||||
m_motorMass = iA + iB;
|
||||
if (m_motorMass > 0.0f)
|
||||
{
|
||||
m_motorMass = 1.0f / m_motorMass;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
m_motorMass = 0.0f;
|
||||
m_motorImpulse = 0.0f;
|
||||
}
|
||||
|
||||
if (data.step.warmStarting)
|
||||
{
|
||||
// Account for variable time step.
|
||||
m_impulse *= data.step.dtRatio;
|
||||
m_springImpulse *= data.step.dtRatio;
|
||||
m_motorImpulse *= data.step.dtRatio;
|
||||
|
||||
b2Vec2 P = m_impulse * m_ay + m_springImpulse * m_ax;
|
||||
float32 LA = m_impulse * m_sAy + m_springImpulse * m_sAx + m_motorImpulse;
|
||||
float32 LB = m_impulse * m_sBy + m_springImpulse * m_sBx + m_motorImpulse;
|
||||
|
||||
vA -= m_invMassA * P;
|
||||
wA -= m_invIA * LA;
|
||||
|
||||
vB += m_invMassB * P;
|
||||
wB += m_invIB * LB;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_impulse = 0.0f;
|
||||
m_springImpulse = 0.0f;
|
||||
m_motorImpulse = 0.0f;
|
||||
}
|
||||
|
||||
data.velocities[m_indexA].v = vA;
|
||||
data.velocities[m_indexA].w = wA;
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
}
|
||||
|
||||
void b2WheelJoint::SolveVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
float32 mA = m_invMassA, mB = m_invMassB;
|
||||
float32 iA = m_invIA, iB = m_invIB;
|
||||
|
||||
b2Vec2 vA = data.velocities[m_indexA].v;
|
||||
float32 wA = data.velocities[m_indexA].w;
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
|
||||
// Solve spring constraint
|
||||
{
|
||||
float32 Cdot = b2Dot(m_ax, vB - vA) + m_sBx * wB - m_sAx * wA;
|
||||
float32 impulse = -m_springMass * (Cdot + m_bias + m_gamma * m_springImpulse);
|
||||
m_springImpulse += impulse;
|
||||
|
||||
b2Vec2 P = impulse * m_ax;
|
||||
float32 LA = impulse * m_sAx;
|
||||
float32 LB = impulse * m_sBx;
|
||||
|
||||
vA -= mA * P;
|
||||
wA -= iA * LA;
|
||||
|
||||
vB += mB * P;
|
||||
wB += iB * LB;
|
||||
}
|
||||
|
||||
// Solve rotational motor constraint
|
||||
{
|
||||
float32 Cdot = wB - wA - m_motorSpeed;
|
||||
float32 impulse = -m_motorMass * Cdot;
|
||||
|
||||
float32 oldImpulse = m_motorImpulse;
|
||||
float32 maxImpulse = data.step.dt * m_maxMotorTorque;
|
||||
m_motorImpulse = b2Clamp(m_motorImpulse + impulse, -maxImpulse, maxImpulse);
|
||||
impulse = m_motorImpulse - oldImpulse;
|
||||
|
||||
wA -= iA * impulse;
|
||||
wB += iB * impulse;
|
||||
}
|
||||
|
||||
// Solve point to line constraint
|
||||
{
|
||||
float32 Cdot = b2Dot(m_ay, vB - vA) + m_sBy * wB - m_sAy * wA;
|
||||
float32 impulse = -m_mass * Cdot;
|
||||
m_impulse += impulse;
|
||||
|
||||
b2Vec2 P = impulse * m_ay;
|
||||
float32 LA = impulse * m_sAy;
|
||||
float32 LB = impulse * m_sBy;
|
||||
|
||||
vA -= mA * P;
|
||||
wA -= iA * LA;
|
||||
|
||||
vB += mB * P;
|
||||
wB += iB * LB;
|
||||
}
|
||||
|
||||
data.velocities[m_indexA].v = vA;
|
||||
data.velocities[m_indexA].w = wA;
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
}
|
||||
|
||||
bool b2WheelJoint::SolvePositionConstraints(const b2SolverData& data)
|
||||
{
|
||||
b2Vec2 cA = data.positions[m_indexA].c;
|
||||
float32 aA = data.positions[m_indexA].a;
|
||||
b2Vec2 cB = data.positions[m_indexB].c;
|
||||
float32 aB = data.positions[m_indexB].a;
|
||||
|
||||
b2Rot qA(aA), qB(aB);
|
||||
|
||||
b2Vec2 rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
|
||||
b2Vec2 rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
|
||||
b2Vec2 d = (cB - cA) + rB - rA;
|
||||
|
||||
b2Vec2 ay = b2Mul(qA, m_localYAxisA);
|
||||
|
||||
float32 sAy = b2Cross(d + rA, ay);
|
||||
float32 sBy = b2Cross(rB, ay);
|
||||
|
||||
float32 C = b2Dot(d, ay);
|
||||
|
||||
float32 k = m_invMassA + m_invMassB + m_invIA * m_sAy * m_sAy + m_invIB * m_sBy * m_sBy;
|
||||
|
||||
float32 impulse;
|
||||
if (k != 0.0f)
|
||||
{
|
||||
impulse = - C / k;
|
||||
}
|
||||
else
|
||||
{
|
||||
impulse = 0.0f;
|
||||
}
|
||||
|
||||
b2Vec2 P = impulse * ay;
|
||||
float32 LA = impulse * sAy;
|
||||
float32 LB = impulse * sBy;
|
||||
|
||||
cA -= m_invMassA * P;
|
||||
aA -= m_invIA * LA;
|
||||
cB += m_invMassB * P;
|
||||
aB += m_invIB * LB;
|
||||
|
||||
data.positions[m_indexA].c = cA;
|
||||
data.positions[m_indexA].a = aA;
|
||||
data.positions[m_indexB].c = cB;
|
||||
data.positions[m_indexB].a = aB;
|
||||
|
||||
return b2Abs(C) <= b2_linearSlop;
|
||||
}
|
||||
|
||||
b2Vec2 b2WheelJoint::GetAnchorA() const
|
||||
{
|
||||
return m_bodyA->GetWorldPoint(m_localAnchorA);
|
||||
}
|
||||
|
||||
b2Vec2 b2WheelJoint::GetAnchorB() const
|
||||
{
|
||||
return m_bodyB->GetWorldPoint(m_localAnchorB);
|
||||
}
|
||||
|
||||
b2Vec2 b2WheelJoint::GetReactionForce(float32 inv_dt) const
|
||||
{
|
||||
return inv_dt * (m_impulse * m_ay + m_springImpulse * m_ax);
|
||||
}
|
||||
|
||||
float32 b2WheelJoint::GetReactionTorque(float32 inv_dt) const
|
||||
{
|
||||
return inv_dt * m_motorImpulse;
|
||||
}
|
||||
|
||||
float32 b2WheelJoint::GetJointTranslation() const
|
||||
{
|
||||
b2Body* bA = m_bodyA;
|
||||
b2Body* bB = m_bodyB;
|
||||
|
||||
b2Vec2 pA = bA->GetWorldPoint(m_localAnchorA);
|
||||
b2Vec2 pB = bB->GetWorldPoint(m_localAnchorB);
|
||||
b2Vec2 d = pB - pA;
|
||||
b2Vec2 axis = bA->GetWorldVector(m_localXAxisA);
|
||||
|
||||
float32 translation = b2Dot(d, axis);
|
||||
return translation;
|
||||
}
|
||||
|
||||
float32 b2WheelJoint::GetJointSpeed() const
|
||||
{
|
||||
float32 wA = m_bodyA->m_angularVelocity;
|
||||
float32 wB = m_bodyB->m_angularVelocity;
|
||||
return wB - wA;
|
||||
}
|
||||
|
||||
bool b2WheelJoint::IsMotorEnabled() const
|
||||
{
|
||||
return m_enableMotor;
|
||||
}
|
||||
|
||||
void b2WheelJoint::EnableMotor(bool flag)
|
||||
{
|
||||
m_bodyA->SetAwake(true);
|
||||
m_bodyB->SetAwake(true);
|
||||
m_enableMotor = flag;
|
||||
}
|
||||
|
||||
void b2WheelJoint::SetMotorSpeed(float32 speed)
|
||||
{
|
||||
m_bodyA->SetAwake(true);
|
||||
m_bodyB->SetAwake(true);
|
||||
m_motorSpeed = speed;
|
||||
}
|
||||
|
||||
void b2WheelJoint::SetMaxMotorTorque(float32 torque)
|
||||
{
|
||||
m_bodyA->SetAwake(true);
|
||||
m_bodyB->SetAwake(true);
|
||||
m_maxMotorTorque = torque;
|
||||
}
|
||||
|
||||
float32 b2WheelJoint::GetMotorTorque(float32 inv_dt) const
|
||||
{
|
||||
return inv_dt * m_motorImpulse;
|
||||
}
|
||||
|
||||
void b2WheelJoint::Dump()
|
||||
{
|
||||
int32 indexA = m_bodyA->m_islandIndex;
|
||||
int32 indexB = m_bodyB->m_islandIndex;
|
||||
|
||||
b2Log(" b2WheelJointDef jd;\n");
|
||||
b2Log(" jd.bodyA = bodies[%d];\n", indexA);
|
||||
b2Log(" jd.bodyB = bodies[%d];\n", indexB);
|
||||
b2Log(" jd.collideConnected = bool(%d);\n", m_collideConnected);
|
||||
b2Log(" jd.localAnchorA.Set(%.15lef, %.15lef);\n", m_localAnchorA.x, m_localAnchorA.y);
|
||||
b2Log(" jd.localAnchorB.Set(%.15lef, %.15lef);\n", m_localAnchorB.x, m_localAnchorB.y);
|
||||
b2Log(" jd.localAxisA.Set(%.15lef, %.15lef);\n", m_localXAxisA.x, m_localXAxisA.y);
|
||||
b2Log(" jd.enableMotor = bool(%d);\n", m_enableMotor);
|
||||
b2Log(" jd.motorSpeed = %.15lef;\n", m_motorSpeed);
|
||||
b2Log(" jd.maxMotorTorque = %.15lef;\n", m_maxMotorTorque);
|
||||
b2Log(" jd.frequencyHz = %.15lef;\n", m_frequencyHz);
|
||||
b2Log(" jd.dampingRatio = %.15lef;\n", m_dampingRatio);
|
||||
b2Log(" joints[%d] = m_world->CreateJoint(&jd);\n", m_index);
|
||||
}
|
||||
/*
|
||||
* Copyright (c) 2006-2007 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "b2WheelJoint.h"
|
||||
#include "../b2Body.h"
|
||||
#include "../b2TimeStep.h"
|
||||
|
||||
// Linear constraint (point-to-line)
|
||||
// d = pB - pA = xB + rB - xA - rA
|
||||
// C = dot(ay, d)
|
||||
// Cdot = dot(d, cross(wA, ay)) + dot(ay, vB + cross(wB, rB) - vA - cross(wA, rA))
|
||||
// = -dot(ay, vA) - dot(cross(d + rA, ay), wA) + dot(ay, vB) + dot(cross(rB, ay), vB)
|
||||
// J = [-ay, -cross(d + rA, ay), ay, cross(rB, ay)]
|
||||
|
||||
// Spring linear constraint
|
||||
// C = dot(ax, d)
|
||||
// Cdot = = -dot(ax, vA) - dot(cross(d + rA, ax), wA) + dot(ax, vB) + dot(cross(rB, ax), vB)
|
||||
// J = [-ax -cross(d+rA, ax) ax cross(rB, ax)]
|
||||
|
||||
// Motor rotational constraint
|
||||
// Cdot = wB - wA
|
||||
// J = [0 0 -1 0 0 1]
|
||||
|
||||
void b2WheelJointDef::Initialize(b2Body* bA, b2Body* bB, const b2Vec2& anchor, const b2Vec2& axis)
|
||||
{
|
||||
bodyA = bA;
|
||||
bodyB = bB;
|
||||
localAnchorA = bodyA->GetLocalPoint(anchor);
|
||||
localAnchorB = bodyB->GetLocalPoint(anchor);
|
||||
localAxisA = bodyA->GetLocalVector(axis);
|
||||
}
|
||||
|
||||
b2WheelJoint::b2WheelJoint(const b2WheelJointDef* def)
|
||||
: b2Joint(def)
|
||||
{
|
||||
m_localAnchorA = def->localAnchorA;
|
||||
m_localAnchorB = def->localAnchorB;
|
||||
m_localXAxisA = def->localAxisA;
|
||||
m_localYAxisA = b2Cross(1.0f, m_localXAxisA);
|
||||
|
||||
m_mass = 0.0f;
|
||||
m_impulse = 0.0f;
|
||||
m_motorMass = 0.0f;
|
||||
m_motorImpulse = 0.0f;
|
||||
m_springMass = 0.0f;
|
||||
m_springImpulse = 0.0f;
|
||||
|
||||
m_maxMotorTorque = def->maxMotorTorque;
|
||||
m_motorSpeed = def->motorSpeed;
|
||||
m_enableMotor = def->enableMotor;
|
||||
|
||||
m_frequencyHz = def->frequencyHz;
|
||||
m_dampingRatio = def->dampingRatio;
|
||||
|
||||
m_bias = 0.0f;
|
||||
m_gamma = 0.0f;
|
||||
|
||||
m_ax.SetZero();
|
||||
m_ay.SetZero();
|
||||
}
|
||||
|
||||
void b2WheelJoint::InitVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
m_indexA = m_bodyA->m_islandIndex;
|
||||
m_indexB = m_bodyB->m_islandIndex;
|
||||
m_localCenterA = m_bodyA->m_sweep.localCenter;
|
||||
m_localCenterB = m_bodyB->m_sweep.localCenter;
|
||||
m_invMassA = m_bodyA->m_invMass;
|
||||
m_invMassB = m_bodyB->m_invMass;
|
||||
m_invIA = m_bodyA->m_invI;
|
||||
m_invIB = m_bodyB->m_invI;
|
||||
|
||||
float32 mA = m_invMassA, mB = m_invMassB;
|
||||
float32 iA = m_invIA, iB = m_invIB;
|
||||
|
||||
b2Vec2 cA = data.positions[m_indexA].c;
|
||||
float32 aA = data.positions[m_indexA].a;
|
||||
b2Vec2 vA = data.velocities[m_indexA].v;
|
||||
float32 wA = data.velocities[m_indexA].w;
|
||||
|
||||
b2Vec2 cB = data.positions[m_indexB].c;
|
||||
float32 aB = data.positions[m_indexB].a;
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
|
||||
b2Rot qA(aA), qB(aB);
|
||||
|
||||
// Compute the effective masses.
|
||||
b2Vec2 rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
|
||||
b2Vec2 rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
|
||||
b2Vec2 d = cB + rB - cA - rA;
|
||||
|
||||
// Point to line constraint
|
||||
{
|
||||
m_ay = b2Mul(qA, m_localYAxisA);
|
||||
m_sAy = b2Cross(d + rA, m_ay);
|
||||
m_sBy = b2Cross(rB, m_ay);
|
||||
|
||||
m_mass = mA + mB + iA * m_sAy * m_sAy + iB * m_sBy * m_sBy;
|
||||
|
||||
if (m_mass > 0.0f)
|
||||
{
|
||||
m_mass = 1.0f / m_mass;
|
||||
}
|
||||
}
|
||||
|
||||
// Spring constraint
|
||||
m_springMass = 0.0f;
|
||||
m_bias = 0.0f;
|
||||
m_gamma = 0.0f;
|
||||
if (m_frequencyHz > 0.0f)
|
||||
{
|
||||
m_ax = b2Mul(qA, m_localXAxisA);
|
||||
m_sAx = b2Cross(d + rA, m_ax);
|
||||
m_sBx = b2Cross(rB, m_ax);
|
||||
|
||||
float32 invMass = mA + mB + iA * m_sAx * m_sAx + iB * m_sBx * m_sBx;
|
||||
|
||||
if (invMass > 0.0f)
|
||||
{
|
||||
m_springMass = 1.0f / invMass;
|
||||
|
||||
float32 C = b2Dot(d, m_ax);
|
||||
|
||||
// Frequency
|
||||
float32 omega = 2.0f * b2_pi * m_frequencyHz;
|
||||
|
||||
// Damping coefficient
|
||||
float32 damp = 2.0f * m_springMass * m_dampingRatio * omega;
|
||||
|
||||
// Spring stiffness
|
||||
float32 k = m_springMass * omega * omega;
|
||||
|
||||
// magic formulas
|
||||
float32 h = data.step.dt;
|
||||
m_gamma = h * (damp + h * k);
|
||||
if (m_gamma > 0.0f)
|
||||
{
|
||||
m_gamma = 1.0f / m_gamma;
|
||||
}
|
||||
|
||||
m_bias = C * h * k * m_gamma;
|
||||
|
||||
m_springMass = invMass + m_gamma;
|
||||
if (m_springMass > 0.0f)
|
||||
{
|
||||
m_springMass = 1.0f / m_springMass;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
m_springImpulse = 0.0f;
|
||||
}
|
||||
|
||||
// Rotational motor
|
||||
if (m_enableMotor)
|
||||
{
|
||||
m_motorMass = iA + iB;
|
||||
if (m_motorMass > 0.0f)
|
||||
{
|
||||
m_motorMass = 1.0f / m_motorMass;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
m_motorMass = 0.0f;
|
||||
m_motorImpulse = 0.0f;
|
||||
}
|
||||
|
||||
if (data.step.warmStarting)
|
||||
{
|
||||
// Account for variable time step.
|
||||
m_impulse *= data.step.dtRatio;
|
||||
m_springImpulse *= data.step.dtRatio;
|
||||
m_motorImpulse *= data.step.dtRatio;
|
||||
|
||||
b2Vec2 P = m_impulse * m_ay + m_springImpulse * m_ax;
|
||||
float32 LA = m_impulse * m_sAy + m_springImpulse * m_sAx + m_motorImpulse;
|
||||
float32 LB = m_impulse * m_sBy + m_springImpulse * m_sBx + m_motorImpulse;
|
||||
|
||||
vA -= m_invMassA * P;
|
||||
wA -= m_invIA * LA;
|
||||
|
||||
vB += m_invMassB * P;
|
||||
wB += m_invIB * LB;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_impulse = 0.0f;
|
||||
m_springImpulse = 0.0f;
|
||||
m_motorImpulse = 0.0f;
|
||||
}
|
||||
|
||||
data.velocities[m_indexA].v = vA;
|
||||
data.velocities[m_indexA].w = wA;
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
}
|
||||
|
||||
void b2WheelJoint::SolveVelocityConstraints(const b2SolverData& data)
|
||||
{
|
||||
float32 mA = m_invMassA, mB = m_invMassB;
|
||||
float32 iA = m_invIA, iB = m_invIB;
|
||||
|
||||
b2Vec2 vA = data.velocities[m_indexA].v;
|
||||
float32 wA = data.velocities[m_indexA].w;
|
||||
b2Vec2 vB = data.velocities[m_indexB].v;
|
||||
float32 wB = data.velocities[m_indexB].w;
|
||||
|
||||
// Solve spring constraint
|
||||
{
|
||||
float32 Cdot = b2Dot(m_ax, vB - vA) + m_sBx * wB - m_sAx * wA;
|
||||
float32 impulse = -m_springMass * (Cdot + m_bias + m_gamma * m_springImpulse);
|
||||
m_springImpulse += impulse;
|
||||
|
||||
b2Vec2 P = impulse * m_ax;
|
||||
float32 LA = impulse * m_sAx;
|
||||
float32 LB = impulse * m_sBx;
|
||||
|
||||
vA -= mA * P;
|
||||
wA -= iA * LA;
|
||||
|
||||
vB += mB * P;
|
||||
wB += iB * LB;
|
||||
}
|
||||
|
||||
// Solve rotational motor constraint
|
||||
{
|
||||
float32 Cdot = wB - wA - m_motorSpeed;
|
||||
float32 impulse = -m_motorMass * Cdot;
|
||||
|
||||
float32 oldImpulse = m_motorImpulse;
|
||||
float32 maxImpulse = data.step.dt * m_maxMotorTorque;
|
||||
m_motorImpulse = b2Clamp(m_motorImpulse + impulse, -maxImpulse, maxImpulse);
|
||||
impulse = m_motorImpulse - oldImpulse;
|
||||
|
||||
wA -= iA * impulse;
|
||||
wB += iB * impulse;
|
||||
}
|
||||
|
||||
// Solve point to line constraint
|
||||
{
|
||||
float32 Cdot = b2Dot(m_ay, vB - vA) + m_sBy * wB - m_sAy * wA;
|
||||
float32 impulse = -m_mass * Cdot;
|
||||
m_impulse += impulse;
|
||||
|
||||
b2Vec2 P = impulse * m_ay;
|
||||
float32 LA = impulse * m_sAy;
|
||||
float32 LB = impulse * m_sBy;
|
||||
|
||||
vA -= mA * P;
|
||||
wA -= iA * LA;
|
||||
|
||||
vB += mB * P;
|
||||
wB += iB * LB;
|
||||
}
|
||||
|
||||
data.velocities[m_indexA].v = vA;
|
||||
data.velocities[m_indexA].w = wA;
|
||||
data.velocities[m_indexB].v = vB;
|
||||
data.velocities[m_indexB].w = wB;
|
||||
}
|
||||
|
||||
bool b2WheelJoint::SolvePositionConstraints(const b2SolverData& data)
|
||||
{
|
||||
b2Vec2 cA = data.positions[m_indexA].c;
|
||||
float32 aA = data.positions[m_indexA].a;
|
||||
b2Vec2 cB = data.positions[m_indexB].c;
|
||||
float32 aB = data.positions[m_indexB].a;
|
||||
|
||||
b2Rot qA(aA), qB(aB);
|
||||
|
||||
b2Vec2 rA = b2Mul(qA, m_localAnchorA - m_localCenterA);
|
||||
b2Vec2 rB = b2Mul(qB, m_localAnchorB - m_localCenterB);
|
||||
b2Vec2 d = (cB - cA) + rB - rA;
|
||||
|
||||
b2Vec2 ay = b2Mul(qA, m_localYAxisA);
|
||||
|
||||
float32 sAy = b2Cross(d + rA, ay);
|
||||
float32 sBy = b2Cross(rB, ay);
|
||||
|
||||
float32 C = b2Dot(d, ay);
|
||||
|
||||
float32 k = m_invMassA + m_invMassB + m_invIA * m_sAy * m_sAy + m_invIB * m_sBy * m_sBy;
|
||||
|
||||
float32 impulse;
|
||||
if (k != 0.0f)
|
||||
{
|
||||
impulse = - C / k;
|
||||
}
|
||||
else
|
||||
{
|
||||
impulse = 0.0f;
|
||||
}
|
||||
|
||||
b2Vec2 P = impulse * ay;
|
||||
float32 LA = impulse * sAy;
|
||||
float32 LB = impulse * sBy;
|
||||
|
||||
cA -= m_invMassA * P;
|
||||
aA -= m_invIA * LA;
|
||||
cB += m_invMassB * P;
|
||||
aB += m_invIB * LB;
|
||||
|
||||
data.positions[m_indexA].c = cA;
|
||||
data.positions[m_indexA].a = aA;
|
||||
data.positions[m_indexB].c = cB;
|
||||
data.positions[m_indexB].a = aB;
|
||||
|
||||
return b2Abs(C) <= b2_linearSlop;
|
||||
}
|
||||
|
||||
b2Vec2 b2WheelJoint::GetAnchorA() const
|
||||
{
|
||||
return m_bodyA->GetWorldPoint(m_localAnchorA);
|
||||
}
|
||||
|
||||
b2Vec2 b2WheelJoint::GetAnchorB() const
|
||||
{
|
||||
return m_bodyB->GetWorldPoint(m_localAnchorB);
|
||||
}
|
||||
|
||||
b2Vec2 b2WheelJoint::GetReactionForce(float32 inv_dt) const
|
||||
{
|
||||
return inv_dt * (m_impulse * m_ay + m_springImpulse * m_ax);
|
||||
}
|
||||
|
||||
float32 b2WheelJoint::GetReactionTorque(float32 inv_dt) const
|
||||
{
|
||||
return inv_dt * m_motorImpulse;
|
||||
}
|
||||
|
||||
float32 b2WheelJoint::GetJointTranslation() const
|
||||
{
|
||||
b2Body* bA = m_bodyA;
|
||||
b2Body* bB = m_bodyB;
|
||||
|
||||
b2Vec2 pA = bA->GetWorldPoint(m_localAnchorA);
|
||||
b2Vec2 pB = bB->GetWorldPoint(m_localAnchorB);
|
||||
b2Vec2 d = pB - pA;
|
||||
b2Vec2 axis = bA->GetWorldVector(m_localXAxisA);
|
||||
|
||||
float32 translation = b2Dot(d, axis);
|
||||
return translation;
|
||||
}
|
||||
|
||||
float32 b2WheelJoint::GetJointSpeed() const
|
||||
{
|
||||
float32 wA = m_bodyA->m_angularVelocity;
|
||||
float32 wB = m_bodyB->m_angularVelocity;
|
||||
return wB - wA;
|
||||
}
|
||||
|
||||
bool b2WheelJoint::IsMotorEnabled() const
|
||||
{
|
||||
return m_enableMotor;
|
||||
}
|
||||
|
||||
void b2WheelJoint::EnableMotor(bool flag)
|
||||
{
|
||||
m_bodyA->SetAwake(true);
|
||||
m_bodyB->SetAwake(true);
|
||||
m_enableMotor = flag;
|
||||
}
|
||||
|
||||
void b2WheelJoint::SetMotorSpeed(float32 speed)
|
||||
{
|
||||
m_bodyA->SetAwake(true);
|
||||
m_bodyB->SetAwake(true);
|
||||
m_motorSpeed = speed;
|
||||
}
|
||||
|
||||
void b2WheelJoint::SetMaxMotorTorque(float32 torque)
|
||||
{
|
||||
m_bodyA->SetAwake(true);
|
||||
m_bodyB->SetAwake(true);
|
||||
m_maxMotorTorque = torque;
|
||||
}
|
||||
|
||||
float32 b2WheelJoint::GetMotorTorque(float32 inv_dt) const
|
||||
{
|
||||
return inv_dt * m_motorImpulse;
|
||||
}
|
||||
|
||||
void b2WheelJoint::Dump()
|
||||
{
|
||||
int32 indexA = m_bodyA->m_islandIndex;
|
||||
int32 indexB = m_bodyB->m_islandIndex;
|
||||
|
||||
b2Log(" b2WheelJointDef jd;\n");
|
||||
b2Log(" jd.bodyA = bodies[%d];\n", indexA);
|
||||
b2Log(" jd.bodyB = bodies[%d];\n", indexB);
|
||||
b2Log(" jd.collideConnected = bool(%d);\n", m_collideConnected);
|
||||
b2Log(" jd.localAnchorA.Set(%.15lef, %.15lef);\n", m_localAnchorA.x, m_localAnchorA.y);
|
||||
b2Log(" jd.localAnchorB.Set(%.15lef, %.15lef);\n", m_localAnchorB.x, m_localAnchorB.y);
|
||||
b2Log(" jd.localAxisA.Set(%.15lef, %.15lef);\n", m_localXAxisA.x, m_localXAxisA.y);
|
||||
b2Log(" jd.enableMotor = bool(%d);\n", m_enableMotor);
|
||||
b2Log(" jd.motorSpeed = %.15lef;\n", m_motorSpeed);
|
||||
b2Log(" jd.maxMotorTorque = %.15lef;\n", m_maxMotorTorque);
|
||||
b2Log(" jd.frequencyHz = %.15lef;\n", m_frequencyHz);
|
||||
b2Log(" jd.dampingRatio = %.15lef;\n", m_dampingRatio);
|
||||
b2Log(" joints[%d] = m_world->CreateJoint(&jd);\n", m_index);
|
||||
}
|
||||
|
||||
@@ -1,213 +1,213 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_WHEEL_JOINT_H
|
||||
#define B2_WHEEL_JOINT_H
|
||||
|
||||
#include "b2Joint.h"
|
||||
|
||||
/// Wheel 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 b2WheelJointDef : public b2JointDef
|
||||
{
|
||||
b2WheelJointDef()
|
||||
{
|
||||
type = e_wheelJoint;
|
||||
localAnchorA.SetZero();
|
||||
localAnchorB.SetZero();
|
||||
localAxisA.Set(1.0f, 0.0f);
|
||||
enableMotor = false;
|
||||
maxMotorTorque = 0.0f;
|
||||
motorSpeed = 0.0f;
|
||||
frequencyHz = 2.0f;
|
||||
dampingRatio = 0.7f;
|
||||
}
|
||||
|
||||
/// Initialize the bodies, anchors, axis, and reference angle using the world
|
||||
/// anchor and world axis.
|
||||
void Initialize(b2Body* bodyA, b2Body* bodyB, const b2Vec2& anchor, const b2Vec2& axis);
|
||||
|
||||
/// The local anchor point relative to bodyA's origin.
|
||||
b2Vec2 localAnchorA;
|
||||
|
||||
/// The local anchor point relative to bodyB's origin.
|
||||
b2Vec2 localAnchorB;
|
||||
|
||||
/// The local translation axis in bodyA.
|
||||
b2Vec2 localAxisA;
|
||||
|
||||
/// Enable/disable the joint motor.
|
||||
bool enableMotor;
|
||||
|
||||
/// The maximum motor torque, usually in N-m.
|
||||
float32 maxMotorTorque;
|
||||
|
||||
/// The desired motor speed in radians per second.
|
||||
float32 motorSpeed;
|
||||
|
||||
/// Suspension frequency, zero indicates no suspension
|
||||
float32 frequencyHz;
|
||||
|
||||
/// Suspension damping ratio, one indicates critical damping
|
||||
float32 dampingRatio;
|
||||
};
|
||||
|
||||
/// A wheel joint. This joint provides two degrees of freedom: translation
|
||||
/// along an axis fixed in bodyA and rotation in the plane. You can use a
|
||||
/// joint limit to restrict the range of motion and a joint motor to drive
|
||||
/// the rotation or to model rotational friction.
|
||||
/// This joint is designed for vehicle suspensions.
|
||||
class b2WheelJoint : public b2Joint
|
||||
{
|
||||
public:
|
||||
void GetDefinition(b2WheelJointDef* def) const;
|
||||
|
||||
b2Vec2 GetAnchorA() const;
|
||||
b2Vec2 GetAnchorB() const;
|
||||
|
||||
b2Vec2 GetReactionForce(float32 inv_dt) const;
|
||||
float32 GetReactionTorque(float32 inv_dt) const;
|
||||
|
||||
/// The local anchor point relative to bodyA's origin.
|
||||
const b2Vec2& GetLocalAnchorA() const { return m_localAnchorA; }
|
||||
|
||||
/// The local anchor point relative to bodyB's origin.
|
||||
const b2Vec2& GetLocalAnchorB() const { return m_localAnchorB; }
|
||||
|
||||
/// The local joint axis relative to bodyA.
|
||||
const b2Vec2& GetLocalAxisA() const { return m_localXAxisA; }
|
||||
|
||||
/// 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 motor enabled?
|
||||
bool IsMotorEnabled() const;
|
||||
|
||||
/// Enable/disable the joint motor.
|
||||
void EnableMotor(bool flag);
|
||||
|
||||
/// Set the motor speed, usually in radians per second.
|
||||
void SetMotorSpeed(float32 speed);
|
||||
|
||||
/// Get the motor speed, usually in radians per second.
|
||||
float32 GetMotorSpeed() const;
|
||||
|
||||
/// Set/Get the maximum motor force, usually in N-m.
|
||||
void SetMaxMotorTorque(float32 torque);
|
||||
float32 GetMaxMotorTorque() const;
|
||||
|
||||
/// Get the current motor torque given the inverse time step, usually in N-m.
|
||||
float32 GetMotorTorque(float32 inv_dt) const;
|
||||
|
||||
/// Set/Get the spring frequency in hertz. Setting the frequency to zero disables the spring.
|
||||
void SetSpringFrequencyHz(float32 hz);
|
||||
float32 GetSpringFrequencyHz() const;
|
||||
|
||||
/// Set/Get the spring damping ratio
|
||||
void SetSpringDampingRatio(float32 ratio);
|
||||
float32 GetSpringDampingRatio() const;
|
||||
|
||||
/// Dump to b2Log
|
||||
void Dump();
|
||||
|
||||
protected:
|
||||
|
||||
friend class b2Joint;
|
||||
b2WheelJoint(const b2WheelJointDef* def);
|
||||
|
||||
void InitVelocityConstraints(const b2SolverData& data);
|
||||
void SolveVelocityConstraints(const b2SolverData& data);
|
||||
bool SolvePositionConstraints(const b2SolverData& data);
|
||||
|
||||
float32 m_frequencyHz;
|
||||
float32 m_dampingRatio;
|
||||
|
||||
// Solver shared
|
||||
b2Vec2 m_localAnchorA;
|
||||
b2Vec2 m_localAnchorB;
|
||||
b2Vec2 m_localXAxisA;
|
||||
b2Vec2 m_localYAxisA;
|
||||
|
||||
float32 m_impulse;
|
||||
float32 m_motorImpulse;
|
||||
float32 m_springImpulse;
|
||||
|
||||
float32 m_maxMotorTorque;
|
||||
float32 m_motorSpeed;
|
||||
bool m_enableMotor;
|
||||
|
||||
// Solver temp
|
||||
juce::int32 m_indexA;
|
||||
juce::int32 m_indexB;
|
||||
b2Vec2 m_localCenterA;
|
||||
b2Vec2 m_localCenterB;
|
||||
float32 m_invMassA;
|
||||
float32 m_invMassB;
|
||||
float32 m_invIA;
|
||||
float32 m_invIB;
|
||||
|
||||
b2Vec2 m_ax, m_ay;
|
||||
float32 m_sAx, m_sBx;
|
||||
float32 m_sAy, m_sBy;
|
||||
|
||||
float32 m_mass;
|
||||
float32 m_motorMass;
|
||||
float32 m_springMass;
|
||||
|
||||
float32 m_bias;
|
||||
float32 m_gamma;
|
||||
};
|
||||
|
||||
inline float32 b2WheelJoint::GetMotorSpeed() const
|
||||
{
|
||||
return m_motorSpeed;
|
||||
}
|
||||
|
||||
inline float32 b2WheelJoint::GetMaxMotorTorque() const
|
||||
{
|
||||
return m_maxMotorTorque;
|
||||
}
|
||||
|
||||
inline void b2WheelJoint::SetSpringFrequencyHz(float32 hz)
|
||||
{
|
||||
m_frequencyHz = hz;
|
||||
}
|
||||
|
||||
inline float32 b2WheelJoint::GetSpringFrequencyHz() const
|
||||
{
|
||||
return m_frequencyHz;
|
||||
}
|
||||
|
||||
inline void b2WheelJoint::SetSpringDampingRatio(float32 ratio)
|
||||
{
|
||||
m_dampingRatio = ratio;
|
||||
}
|
||||
|
||||
inline float32 b2WheelJoint::GetSpringDampingRatio() const
|
||||
{
|
||||
return m_dampingRatio;
|
||||
}
|
||||
|
||||
#endif
|
||||
/*
|
||||
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_WHEEL_JOINT_H
|
||||
#define B2_WHEEL_JOINT_H
|
||||
|
||||
#include "b2Joint.h"
|
||||
|
||||
/// Wheel 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 b2WheelJointDef : public b2JointDef
|
||||
{
|
||||
b2WheelJointDef()
|
||||
{
|
||||
type = e_wheelJoint;
|
||||
localAnchorA.SetZero();
|
||||
localAnchorB.SetZero();
|
||||
localAxisA.Set(1.0f, 0.0f);
|
||||
enableMotor = false;
|
||||
maxMotorTorque = 0.0f;
|
||||
motorSpeed = 0.0f;
|
||||
frequencyHz = 2.0f;
|
||||
dampingRatio = 0.7f;
|
||||
}
|
||||
|
||||
/// Initialize the bodies, anchors, axis, and reference angle using the world
|
||||
/// anchor and world axis.
|
||||
void Initialize(b2Body* bodyA, b2Body* bodyB, const b2Vec2& anchor, const b2Vec2& axis);
|
||||
|
||||
/// The local anchor point relative to bodyA's origin.
|
||||
b2Vec2 localAnchorA;
|
||||
|
||||
/// The local anchor point relative to bodyB's origin.
|
||||
b2Vec2 localAnchorB;
|
||||
|
||||
/// The local translation axis in bodyA.
|
||||
b2Vec2 localAxisA;
|
||||
|
||||
/// Enable/disable the joint motor.
|
||||
bool enableMotor;
|
||||
|
||||
/// The maximum motor torque, usually in N-m.
|
||||
float32 maxMotorTorque;
|
||||
|
||||
/// The desired motor speed in radians per second.
|
||||
float32 motorSpeed;
|
||||
|
||||
/// Suspension frequency, zero indicates no suspension
|
||||
float32 frequencyHz;
|
||||
|
||||
/// Suspension damping ratio, one indicates critical damping
|
||||
float32 dampingRatio;
|
||||
};
|
||||
|
||||
/// A wheel joint. This joint provides two degrees of freedom: translation
|
||||
/// along an axis fixed in bodyA and rotation in the plane. You can use a
|
||||
/// joint limit to restrict the range of motion and a joint motor to drive
|
||||
/// the rotation or to model rotational friction.
|
||||
/// This joint is designed for vehicle suspensions.
|
||||
class b2WheelJoint : public b2Joint
|
||||
{
|
||||
public:
|
||||
void GetDefinition(b2WheelJointDef* def) const;
|
||||
|
||||
b2Vec2 GetAnchorA() const;
|
||||
b2Vec2 GetAnchorB() const;
|
||||
|
||||
b2Vec2 GetReactionForce(float32 inv_dt) const;
|
||||
float32 GetReactionTorque(float32 inv_dt) const;
|
||||
|
||||
/// The local anchor point relative to bodyA's origin.
|
||||
const b2Vec2& GetLocalAnchorA() const { return m_localAnchorA; }
|
||||
|
||||
/// The local anchor point relative to bodyB's origin.
|
||||
const b2Vec2& GetLocalAnchorB() const { return m_localAnchorB; }
|
||||
|
||||
/// The local joint axis relative to bodyA.
|
||||
const b2Vec2& GetLocalAxisA() const { return m_localXAxisA; }
|
||||
|
||||
/// 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 motor enabled?
|
||||
bool IsMotorEnabled() const;
|
||||
|
||||
/// Enable/disable the joint motor.
|
||||
void EnableMotor(bool flag);
|
||||
|
||||
/// Set the motor speed, usually in radians per second.
|
||||
void SetMotorSpeed(float32 speed);
|
||||
|
||||
/// Get the motor speed, usually in radians per second.
|
||||
float32 GetMotorSpeed() const;
|
||||
|
||||
/// Set/Get the maximum motor force, usually in N-m.
|
||||
void SetMaxMotorTorque(float32 torque);
|
||||
float32 GetMaxMotorTorque() const;
|
||||
|
||||
/// Get the current motor torque given the inverse time step, usually in N-m.
|
||||
float32 GetMotorTorque(float32 inv_dt) const;
|
||||
|
||||
/// Set/Get the spring frequency in hertz. Setting the frequency to zero disables the spring.
|
||||
void SetSpringFrequencyHz(float32 hz);
|
||||
float32 GetSpringFrequencyHz() const;
|
||||
|
||||
/// Set/Get the spring damping ratio
|
||||
void SetSpringDampingRatio(float32 ratio);
|
||||
float32 GetSpringDampingRatio() const;
|
||||
|
||||
/// Dump to b2Log
|
||||
void Dump();
|
||||
|
||||
protected:
|
||||
|
||||
friend class b2Joint;
|
||||
b2WheelJoint(const b2WheelJointDef* def);
|
||||
|
||||
void InitVelocityConstraints(const b2SolverData& data);
|
||||
void SolveVelocityConstraints(const b2SolverData& data);
|
||||
bool SolvePositionConstraints(const b2SolverData& data);
|
||||
|
||||
float32 m_frequencyHz;
|
||||
float32 m_dampingRatio;
|
||||
|
||||
// Solver shared
|
||||
b2Vec2 m_localAnchorA;
|
||||
b2Vec2 m_localAnchorB;
|
||||
b2Vec2 m_localXAxisA;
|
||||
b2Vec2 m_localYAxisA;
|
||||
|
||||
float32 m_impulse;
|
||||
float32 m_motorImpulse;
|
||||
float32 m_springImpulse;
|
||||
|
||||
float32 m_maxMotorTorque;
|
||||
float32 m_motorSpeed;
|
||||
bool m_enableMotor;
|
||||
|
||||
// Solver temp
|
||||
juce::int32 m_indexA;
|
||||
juce::int32 m_indexB;
|
||||
b2Vec2 m_localCenterA;
|
||||
b2Vec2 m_localCenterB;
|
||||
float32 m_invMassA;
|
||||
float32 m_invMassB;
|
||||
float32 m_invIA;
|
||||
float32 m_invIB;
|
||||
|
||||
b2Vec2 m_ax, m_ay;
|
||||
float32 m_sAx, m_sBx;
|
||||
float32 m_sAy, m_sBy;
|
||||
|
||||
float32 m_mass;
|
||||
float32 m_motorMass;
|
||||
float32 m_springMass;
|
||||
|
||||
float32 m_bias;
|
||||
float32 m_gamma;
|
||||
};
|
||||
|
||||
inline float32 b2WheelJoint::GetMotorSpeed() const
|
||||
{
|
||||
return m_motorSpeed;
|
||||
}
|
||||
|
||||
inline float32 b2WheelJoint::GetMaxMotorTorque() const
|
||||
{
|
||||
return m_maxMotorTorque;
|
||||
}
|
||||
|
||||
inline void b2WheelJoint::SetSpringFrequencyHz(float32 hz)
|
||||
{
|
||||
m_frequencyHz = hz;
|
||||
}
|
||||
|
||||
inline float32 b2WheelJoint::GetSpringFrequencyHz() const
|
||||
{
|
||||
return m_frequencyHz;
|
||||
}
|
||||
|
||||
inline void b2WheelJoint::SetSpringDampingRatio(float32 ratio)
|
||||
{
|
||||
m_dampingRatio = ratio;
|
||||
}
|
||||
|
||||
inline float32 b2WheelJoint::GetSpringDampingRatio() const
|
||||
{
|
||||
return m_dampingRatio;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
1030
deps/juce/modules/juce_box2d/box2d/Dynamics/b2Body.cpp
vendored
1030
deps/juce/modules/juce_box2d/box2d/Dynamics/b2Body.cpp
vendored
File diff suppressed because it is too large
Load Diff
1690
deps/juce/modules/juce_box2d/box2d/Dynamics/b2Body.h
vendored
1690
deps/juce/modules/juce_box2d/box2d/Dynamics/b2Body.h
vendored
File diff suppressed because it is too large
Load Diff
@@ -1,293 +1,293 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "b2Body.h"
|
||||
#include "b2Fixture.h"
|
||||
#include "b2WorldCallbacks.h"
|
||||
#include "Contacts/b2Contact.h"
|
||||
|
||||
b2ContactFilter b2_defaultFilter;
|
||||
b2ContactListener b2_defaultListener;
|
||||
|
||||
b2ContactManager::b2ContactManager()
|
||||
{
|
||||
m_contactList = NULL;
|
||||
m_contactCount = 0;
|
||||
m_contactFilter = &b2_defaultFilter;
|
||||
m_contactListener = &b2_defaultListener;
|
||||
m_allocator = NULL;
|
||||
}
|
||||
|
||||
void b2ContactManager::Destroy(b2Contact* c)
|
||||
{
|
||||
b2Fixture* fixtureA = c->GetFixtureA();
|
||||
b2Fixture* fixtureB = c->GetFixtureB();
|
||||
b2Body* bodyA = fixtureA->GetBody();
|
||||
b2Body* bodyB = fixtureB->GetBody();
|
||||
|
||||
if (m_contactListener && c->IsTouching())
|
||||
{
|
||||
m_contactListener->EndContact(c);
|
||||
}
|
||||
|
||||
// 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_contactList)
|
||||
{
|
||||
m_contactList = c->m_next;
|
||||
}
|
||||
|
||||
// Remove from body 1
|
||||
if (c->m_nodeA.prev)
|
||||
{
|
||||
c->m_nodeA.prev->next = c->m_nodeA.next;
|
||||
}
|
||||
|
||||
if (c->m_nodeA.next)
|
||||
{
|
||||
c->m_nodeA.next->prev = c->m_nodeA.prev;
|
||||
}
|
||||
|
||||
if (&c->m_nodeA == bodyA->m_contactList)
|
||||
{
|
||||
bodyA->m_contactList = c->m_nodeA.next;
|
||||
}
|
||||
|
||||
// Remove from body 2
|
||||
if (c->m_nodeB.prev)
|
||||
{
|
||||
c->m_nodeB.prev->next = c->m_nodeB.next;
|
||||
}
|
||||
|
||||
if (c->m_nodeB.next)
|
||||
{
|
||||
c->m_nodeB.next->prev = c->m_nodeB.prev;
|
||||
}
|
||||
|
||||
if (&c->m_nodeB == bodyB->m_contactList)
|
||||
{
|
||||
bodyB->m_contactList = c->m_nodeB.next;
|
||||
}
|
||||
|
||||
// Call the factory.
|
||||
b2Contact::Destroy(c, m_allocator);
|
||||
--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.
|
||||
b2Contact* c = m_contactList;
|
||||
while (c)
|
||||
{
|
||||
b2Fixture* fixtureA = c->GetFixtureA();
|
||||
b2Fixture* fixtureB = c->GetFixtureB();
|
||||
int32 indexA = c->GetChildIndexA();
|
||||
int32 indexB = c->GetChildIndexB();
|
||||
b2Body* bodyA = fixtureA->GetBody();
|
||||
b2Body* bodyB = fixtureB->GetBody();
|
||||
|
||||
// Is this contact flagged for filtering?
|
||||
if (c->m_flags & b2Contact::e_filterFlag)
|
||||
{
|
||||
// Should these bodies collide?
|
||||
if (bodyB->ShouldCollide(bodyA) == false)
|
||||
{
|
||||
b2Contact* cNuke = c;
|
||||
c = cNuke->GetNext();
|
||||
Destroy(cNuke);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Check user filtering.
|
||||
if (m_contactFilter && m_contactFilter->ShouldCollide(fixtureA, fixtureB) == false)
|
||||
{
|
||||
b2Contact* cNuke = c;
|
||||
c = cNuke->GetNext();
|
||||
Destroy(cNuke);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Clear the filtering flag.
|
||||
c->m_flags &= ~b2Contact::e_filterFlag;
|
||||
}
|
||||
|
||||
bool activeA = bodyA->IsAwake() && bodyA->m_type != b2_staticBody;
|
||||
bool activeB = bodyB->IsAwake() && bodyB->m_type != b2_staticBody;
|
||||
|
||||
// At least one body must be awake and it must be dynamic or kinematic.
|
||||
if (activeA == false && activeB == false)
|
||||
{
|
||||
c = c->GetNext();
|
||||
continue;
|
||||
}
|
||||
|
||||
int32 proxyIdA = fixtureA->m_proxies[indexA].proxyId;
|
||||
int32 proxyIdB = fixtureB->m_proxies[indexB].proxyId;
|
||||
bool overlap = m_broadPhase.TestOverlap(proxyIdA, proxyIdB);
|
||||
|
||||
// Here we destroy contacts that cease to overlap in the broad-phase.
|
||||
if (overlap == false)
|
||||
{
|
||||
b2Contact* cNuke = c;
|
||||
c = cNuke->GetNext();
|
||||
Destroy(cNuke);
|
||||
continue;
|
||||
}
|
||||
|
||||
// The contact persists.
|
||||
c->Update(m_contactListener);
|
||||
c = c->GetNext();
|
||||
}
|
||||
}
|
||||
|
||||
void b2ContactManager::FindNewContacts()
|
||||
{
|
||||
m_broadPhase.UpdatePairs(this);
|
||||
}
|
||||
|
||||
void b2ContactManager::AddPair(void* proxyUserDataA, void* proxyUserDataB)
|
||||
{
|
||||
b2FixtureProxy* proxyA = (b2FixtureProxy*)proxyUserDataA;
|
||||
b2FixtureProxy* proxyB = (b2FixtureProxy*)proxyUserDataB;
|
||||
|
||||
b2Fixture* fixtureA = proxyA->fixture;
|
||||
b2Fixture* fixtureB = proxyB->fixture;
|
||||
|
||||
int32 indexA = proxyA->childIndex;
|
||||
int32 indexB = proxyB->childIndex;
|
||||
|
||||
b2Body* bodyA = fixtureA->GetBody();
|
||||
b2Body* bodyB = fixtureB->GetBody();
|
||||
|
||||
// Are the fixtures on the same body?
|
||||
if (bodyA == bodyB)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// TODO_ERIN use a hash table to remove a potential bottleneck when both
|
||||
// bodies have a lot of contacts.
|
||||
// Does a contact already exist?
|
||||
b2ContactEdge* edge = bodyB->GetContactList();
|
||||
while (edge)
|
||||
{
|
||||
if (edge->other == bodyA)
|
||||
{
|
||||
b2Fixture* fA = edge->contact->GetFixtureA();
|
||||
b2Fixture* fB = edge->contact->GetFixtureB();
|
||||
int32 iA = edge->contact->GetChildIndexA();
|
||||
int32 iB = edge->contact->GetChildIndexB();
|
||||
|
||||
if (fA == fixtureA && fB == fixtureB && iA == indexA && iB == indexB)
|
||||
{
|
||||
// A contact already exists.
|
||||
return;
|
||||
}
|
||||
|
||||
if (fA == fixtureB && fB == fixtureA && iA == indexB && iB == indexA)
|
||||
{
|
||||
// A contact already exists.
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
edge = edge->next;
|
||||
}
|
||||
|
||||
// Does a joint override collision? Is at least one body dynamic?
|
||||
if (bodyB->ShouldCollide(bodyA) == false)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// Check user filtering.
|
||||
if (m_contactFilter && m_contactFilter->ShouldCollide(fixtureA, fixtureB) == false)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// Call the factory.
|
||||
b2Contact* c = b2Contact::Create(fixtureA, indexA, fixtureB, indexB, m_allocator);
|
||||
if (c == NULL)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// Contact creation may swap fixtures.
|
||||
fixtureA = c->GetFixtureA();
|
||||
fixtureB = c->GetFixtureB();
|
||||
// indexA = c->GetChildIndexA();
|
||||
// indexB = c->GetChildIndexB();
|
||||
bodyA = fixtureA->GetBody();
|
||||
bodyB = fixtureB->GetBody();
|
||||
|
||||
// Insert into the world.
|
||||
c->m_prev = NULL;
|
||||
c->m_next = m_contactList;
|
||||
if (m_contactList != NULL)
|
||||
{
|
||||
m_contactList->m_prev = c;
|
||||
}
|
||||
m_contactList = c;
|
||||
|
||||
// Connect to island graph.
|
||||
|
||||
// Connect to body A
|
||||
c->m_nodeA.contact = c;
|
||||
c->m_nodeA.other = bodyB;
|
||||
|
||||
c->m_nodeA.prev = NULL;
|
||||
c->m_nodeA.next = bodyA->m_contactList;
|
||||
if (bodyA->m_contactList != NULL)
|
||||
{
|
||||
bodyA->m_contactList->prev = &c->m_nodeA;
|
||||
}
|
||||
bodyA->m_contactList = &c->m_nodeA;
|
||||
|
||||
// Connect to body B
|
||||
c->m_nodeB.contact = c;
|
||||
c->m_nodeB.other = bodyA;
|
||||
|
||||
c->m_nodeB.prev = NULL;
|
||||
c->m_nodeB.next = bodyB->m_contactList;
|
||||
if (bodyB->m_contactList != NULL)
|
||||
{
|
||||
bodyB->m_contactList->prev = &c->m_nodeB;
|
||||
}
|
||||
bodyB->m_contactList = &c->m_nodeB;
|
||||
|
||||
// Wake up the bodies
|
||||
bodyA->SetAwake(true);
|
||||
bodyB->SetAwake(true);
|
||||
|
||||
++m_contactCount;
|
||||
}
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "b2Body.h"
|
||||
#include "b2Fixture.h"
|
||||
#include "b2WorldCallbacks.h"
|
||||
#include "Contacts/b2Contact.h"
|
||||
|
||||
b2ContactFilter b2_defaultFilter;
|
||||
b2ContactListener b2_defaultListener;
|
||||
|
||||
b2ContactManager::b2ContactManager()
|
||||
{
|
||||
m_contactList = NULL;
|
||||
m_contactCount = 0;
|
||||
m_contactFilter = &b2_defaultFilter;
|
||||
m_contactListener = &b2_defaultListener;
|
||||
m_allocator = NULL;
|
||||
}
|
||||
|
||||
void b2ContactManager::Destroy(b2Contact* c)
|
||||
{
|
||||
b2Fixture* fixtureA = c->GetFixtureA();
|
||||
b2Fixture* fixtureB = c->GetFixtureB();
|
||||
b2Body* bodyA = fixtureA->GetBody();
|
||||
b2Body* bodyB = fixtureB->GetBody();
|
||||
|
||||
if (m_contactListener && c->IsTouching())
|
||||
{
|
||||
m_contactListener->EndContact(c);
|
||||
}
|
||||
|
||||
// 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_contactList)
|
||||
{
|
||||
m_contactList = c->m_next;
|
||||
}
|
||||
|
||||
// Remove from body 1
|
||||
if (c->m_nodeA.prev)
|
||||
{
|
||||
c->m_nodeA.prev->next = c->m_nodeA.next;
|
||||
}
|
||||
|
||||
if (c->m_nodeA.next)
|
||||
{
|
||||
c->m_nodeA.next->prev = c->m_nodeA.prev;
|
||||
}
|
||||
|
||||
if (&c->m_nodeA == bodyA->m_contactList)
|
||||
{
|
||||
bodyA->m_contactList = c->m_nodeA.next;
|
||||
}
|
||||
|
||||
// Remove from body 2
|
||||
if (c->m_nodeB.prev)
|
||||
{
|
||||
c->m_nodeB.prev->next = c->m_nodeB.next;
|
||||
}
|
||||
|
||||
if (c->m_nodeB.next)
|
||||
{
|
||||
c->m_nodeB.next->prev = c->m_nodeB.prev;
|
||||
}
|
||||
|
||||
if (&c->m_nodeB == bodyB->m_contactList)
|
||||
{
|
||||
bodyB->m_contactList = c->m_nodeB.next;
|
||||
}
|
||||
|
||||
// Call the factory.
|
||||
b2Contact::Destroy(c, m_allocator);
|
||||
--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.
|
||||
b2Contact* c = m_contactList;
|
||||
while (c)
|
||||
{
|
||||
b2Fixture* fixtureA = c->GetFixtureA();
|
||||
b2Fixture* fixtureB = c->GetFixtureB();
|
||||
int32 indexA = c->GetChildIndexA();
|
||||
int32 indexB = c->GetChildIndexB();
|
||||
b2Body* bodyA = fixtureA->GetBody();
|
||||
b2Body* bodyB = fixtureB->GetBody();
|
||||
|
||||
// Is this contact flagged for filtering?
|
||||
if (c->m_flags & b2Contact::e_filterFlag)
|
||||
{
|
||||
// Should these bodies collide?
|
||||
if (bodyB->ShouldCollide(bodyA) == false)
|
||||
{
|
||||
b2Contact* cNuke = c;
|
||||
c = cNuke->GetNext();
|
||||
Destroy(cNuke);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Check user filtering.
|
||||
if (m_contactFilter && m_contactFilter->ShouldCollide(fixtureA, fixtureB) == false)
|
||||
{
|
||||
b2Contact* cNuke = c;
|
||||
c = cNuke->GetNext();
|
||||
Destroy(cNuke);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Clear the filtering flag.
|
||||
c->m_flags &= ~b2Contact::e_filterFlag;
|
||||
}
|
||||
|
||||
bool activeA = bodyA->IsAwake() && bodyA->m_type != b2_staticBody;
|
||||
bool activeB = bodyB->IsAwake() && bodyB->m_type != b2_staticBody;
|
||||
|
||||
// At least one body must be awake and it must be dynamic or kinematic.
|
||||
if (activeA == false && activeB == false)
|
||||
{
|
||||
c = c->GetNext();
|
||||
continue;
|
||||
}
|
||||
|
||||
int32 proxyIdA = fixtureA->m_proxies[indexA].proxyId;
|
||||
int32 proxyIdB = fixtureB->m_proxies[indexB].proxyId;
|
||||
bool overlap = m_broadPhase.TestOverlap(proxyIdA, proxyIdB);
|
||||
|
||||
// Here we destroy contacts that cease to overlap in the broad-phase.
|
||||
if (overlap == false)
|
||||
{
|
||||
b2Contact* cNuke = c;
|
||||
c = cNuke->GetNext();
|
||||
Destroy(cNuke);
|
||||
continue;
|
||||
}
|
||||
|
||||
// The contact persists.
|
||||
c->Update(m_contactListener);
|
||||
c = c->GetNext();
|
||||
}
|
||||
}
|
||||
|
||||
void b2ContactManager::FindNewContacts()
|
||||
{
|
||||
m_broadPhase.UpdatePairs(this);
|
||||
}
|
||||
|
||||
void b2ContactManager::AddPair(void* proxyUserDataA, void* proxyUserDataB)
|
||||
{
|
||||
b2FixtureProxy* proxyA = (b2FixtureProxy*)proxyUserDataA;
|
||||
b2FixtureProxy* proxyB = (b2FixtureProxy*)proxyUserDataB;
|
||||
|
||||
b2Fixture* fixtureA = proxyA->fixture;
|
||||
b2Fixture* fixtureB = proxyB->fixture;
|
||||
|
||||
int32 indexA = proxyA->childIndex;
|
||||
int32 indexB = proxyB->childIndex;
|
||||
|
||||
b2Body* bodyA = fixtureA->GetBody();
|
||||
b2Body* bodyB = fixtureB->GetBody();
|
||||
|
||||
// Are the fixtures on the same body?
|
||||
if (bodyA == bodyB)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// TODO_ERIN use a hash table to remove a potential bottleneck when both
|
||||
// bodies have a lot of contacts.
|
||||
// Does a contact already exist?
|
||||
b2ContactEdge* edge = bodyB->GetContactList();
|
||||
while (edge)
|
||||
{
|
||||
if (edge->other == bodyA)
|
||||
{
|
||||
b2Fixture* fA = edge->contact->GetFixtureA();
|
||||
b2Fixture* fB = edge->contact->GetFixtureB();
|
||||
int32 iA = edge->contact->GetChildIndexA();
|
||||
int32 iB = edge->contact->GetChildIndexB();
|
||||
|
||||
if (fA == fixtureA && fB == fixtureB && iA == indexA && iB == indexB)
|
||||
{
|
||||
// A contact already exists.
|
||||
return;
|
||||
}
|
||||
|
||||
if (fA == fixtureB && fB == fixtureA && iA == indexB && iB == indexA)
|
||||
{
|
||||
// A contact already exists.
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
edge = edge->next;
|
||||
}
|
||||
|
||||
// Does a joint override collision? Is at least one body dynamic?
|
||||
if (bodyB->ShouldCollide(bodyA) == false)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// Check user filtering.
|
||||
if (m_contactFilter && m_contactFilter->ShouldCollide(fixtureA, fixtureB) == false)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// Call the factory.
|
||||
b2Contact* c = b2Contact::Create(fixtureA, indexA, fixtureB, indexB, m_allocator);
|
||||
if (c == NULL)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// Contact creation may swap fixtures.
|
||||
fixtureA = c->GetFixtureA();
|
||||
fixtureB = c->GetFixtureB();
|
||||
// indexA = c->GetChildIndexA();
|
||||
// indexB = c->GetChildIndexB();
|
||||
bodyA = fixtureA->GetBody();
|
||||
bodyB = fixtureB->GetBody();
|
||||
|
||||
// Insert into the world.
|
||||
c->m_prev = NULL;
|
||||
c->m_next = m_contactList;
|
||||
if (m_contactList != NULL)
|
||||
{
|
||||
m_contactList->m_prev = c;
|
||||
}
|
||||
m_contactList = c;
|
||||
|
||||
// Connect to island graph.
|
||||
|
||||
// Connect to body A
|
||||
c->m_nodeA.contact = c;
|
||||
c->m_nodeA.other = bodyB;
|
||||
|
||||
c->m_nodeA.prev = NULL;
|
||||
c->m_nodeA.next = bodyA->m_contactList;
|
||||
if (bodyA->m_contactList != NULL)
|
||||
{
|
||||
bodyA->m_contactList->prev = &c->m_nodeA;
|
||||
}
|
||||
bodyA->m_contactList = &c->m_nodeA;
|
||||
|
||||
// Connect to body B
|
||||
c->m_nodeB.contact = c;
|
||||
c->m_nodeB.other = bodyA;
|
||||
|
||||
c->m_nodeB.prev = NULL;
|
||||
c->m_nodeB.next = bodyB->m_contactList;
|
||||
if (bodyB->m_contactList != NULL)
|
||||
{
|
||||
bodyB->m_contactList->prev = &c->m_nodeB;
|
||||
}
|
||||
bodyB->m_contactList = &c->m_nodeB;
|
||||
|
||||
// Wake up the bodies
|
||||
bodyA->SetAwake(true);
|
||||
bodyB->SetAwake(true);
|
||||
|
||||
++m_contactCount;
|
||||
}
|
||||
|
||||
@@ -1,52 +1,52 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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"
|
||||
|
||||
class b2Contact;
|
||||
class b2ContactFilter;
|
||||
class b2ContactListener;
|
||||
class b2BlockAllocator;
|
||||
|
||||
// Delegate of b2World.
|
||||
class b2ContactManager
|
||||
{
|
||||
public:
|
||||
b2ContactManager();
|
||||
|
||||
// Broad-phase callback.
|
||||
void AddPair(void* proxyUserDataA, void* proxyUserDataB);
|
||||
|
||||
void FindNewContacts();
|
||||
|
||||
void Destroy(b2Contact* c);
|
||||
|
||||
void Collide();
|
||||
|
||||
b2BroadPhase m_broadPhase;
|
||||
b2Contact* m_contactList;
|
||||
juce::int32 m_contactCount;
|
||||
b2ContactFilter* m_contactFilter;
|
||||
b2ContactListener* m_contactListener;
|
||||
b2BlockAllocator* m_allocator;
|
||||
};
|
||||
|
||||
#endif
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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"
|
||||
|
||||
class b2Contact;
|
||||
class b2ContactFilter;
|
||||
class b2ContactListener;
|
||||
class b2BlockAllocator;
|
||||
|
||||
// Delegate of b2World.
|
||||
class b2ContactManager
|
||||
{
|
||||
public:
|
||||
b2ContactManager();
|
||||
|
||||
// Broad-phase callback.
|
||||
void AddPair(void* proxyUserDataA, void* proxyUserDataB);
|
||||
|
||||
void FindNewContacts();
|
||||
|
||||
void Destroy(b2Contact* c);
|
||||
|
||||
void Collide();
|
||||
|
||||
b2BroadPhase m_broadPhase;
|
||||
b2Contact* m_contactList;
|
||||
juce::int32 m_contactCount;
|
||||
b2ContactFilter* m_contactFilter;
|
||||
b2ContactListener* m_contactListener;
|
||||
b2BlockAllocator* m_allocator;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,303 +1,303 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "b2Fixture.h"
|
||||
#include "Contacts/b2Contact.h"
|
||||
#include "b2World.h"
|
||||
#include "../Collision/Shapes/b2CircleShape.h"
|
||||
#include "../Collision/Shapes/b2EdgeShape.h"
|
||||
#include "../Collision/Shapes/b2PolygonShape.h"
|
||||
#include "../Collision/Shapes/b2ChainShape.h"
|
||||
#include "../Collision/b2BroadPhase.h"
|
||||
#include "../Collision/b2Collision.h"
|
||||
#include "../Common/b2BlockAllocator.h"
|
||||
|
||||
b2Fixture::b2Fixture()
|
||||
{
|
||||
m_userData = NULL;
|
||||
m_body = NULL;
|
||||
m_next = NULL;
|
||||
m_proxies = NULL;
|
||||
m_proxyCount = 0;
|
||||
m_shape = NULL;
|
||||
m_density = 0.0f;
|
||||
}
|
||||
|
||||
void b2Fixture::Create(b2BlockAllocator* allocator, b2Body* body, const b2FixtureDef* def)
|
||||
{
|
||||
m_userData = def->userData;
|
||||
m_friction = def->friction;
|
||||
m_restitution = def->restitution;
|
||||
|
||||
m_body = body;
|
||||
m_next = NULL;
|
||||
|
||||
m_filter = def->filter;
|
||||
|
||||
m_isSensor = def->isSensor;
|
||||
|
||||
m_shape = def->shape->Clone(allocator);
|
||||
|
||||
// Reserve proxy space
|
||||
int32 childCount = m_shape->GetChildCount();
|
||||
m_proxies = (b2FixtureProxy*)allocator->Allocate(childCount * sizeof(b2FixtureProxy));
|
||||
for (int32 i = 0; i < childCount; ++i)
|
||||
{
|
||||
m_proxies[i].fixture = NULL;
|
||||
m_proxies[i].proxyId = b2BroadPhase::e_nullProxy;
|
||||
}
|
||||
m_proxyCount = 0;
|
||||
|
||||
m_density = def->density;
|
||||
}
|
||||
|
||||
void b2Fixture::Destroy(b2BlockAllocator* allocator)
|
||||
{
|
||||
// The proxies must be destroyed before calling this.
|
||||
b2Assert(m_proxyCount == 0);
|
||||
|
||||
// Free the proxy array.
|
||||
int32 childCount = m_shape->GetChildCount();
|
||||
allocator->Free(m_proxies, childCount * sizeof(b2FixtureProxy));
|
||||
m_proxies = NULL;
|
||||
|
||||
// Free the child shape.
|
||||
switch (m_shape->m_type)
|
||||
{
|
||||
case b2Shape::e_circle:
|
||||
{
|
||||
b2CircleShape* s = (b2CircleShape*)m_shape;
|
||||
s->~b2CircleShape();
|
||||
allocator->Free(s, sizeof(b2CircleShape));
|
||||
}
|
||||
break;
|
||||
|
||||
case b2Shape::e_edge:
|
||||
{
|
||||
b2EdgeShape* s = (b2EdgeShape*)m_shape;
|
||||
s->~b2EdgeShape();
|
||||
allocator->Free(s, sizeof(b2EdgeShape));
|
||||
}
|
||||
break;
|
||||
|
||||
case b2Shape::e_polygon:
|
||||
{
|
||||
b2PolygonShape* s = (b2PolygonShape*)m_shape;
|
||||
s->~b2PolygonShape();
|
||||
allocator->Free(s, sizeof(b2PolygonShape));
|
||||
}
|
||||
break;
|
||||
|
||||
case b2Shape::e_chain:
|
||||
{
|
||||
b2ChainShape* s = (b2ChainShape*)m_shape;
|
||||
s->~b2ChainShape();
|
||||
allocator->Free(s, sizeof(b2ChainShape));
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
b2Assert(false);
|
||||
break;
|
||||
}
|
||||
|
||||
m_shape = NULL;
|
||||
}
|
||||
|
||||
void b2Fixture::CreateProxies(b2BroadPhase* broadPhase, const b2Transform& xf)
|
||||
{
|
||||
b2Assert(m_proxyCount == 0);
|
||||
|
||||
// Create proxies in the broad-phase.
|
||||
m_proxyCount = m_shape->GetChildCount();
|
||||
|
||||
for (int32 i = 0; i < m_proxyCount; ++i)
|
||||
{
|
||||
b2FixtureProxy* proxy = m_proxies + i;
|
||||
m_shape->ComputeAABB(&proxy->aabb, xf, i);
|
||||
proxy->proxyId = broadPhase->CreateProxy(proxy->aabb, proxy);
|
||||
proxy->fixture = this;
|
||||
proxy->childIndex = i;
|
||||
}
|
||||
}
|
||||
|
||||
void b2Fixture::DestroyProxies(b2BroadPhase* broadPhase)
|
||||
{
|
||||
// Destroy proxies in the broad-phase.
|
||||
for (int32 i = 0; i < m_proxyCount; ++i)
|
||||
{
|
||||
b2FixtureProxy* proxy = m_proxies + i;
|
||||
broadPhase->DestroyProxy(proxy->proxyId);
|
||||
proxy->proxyId = b2BroadPhase::e_nullProxy;
|
||||
}
|
||||
|
||||
m_proxyCount = 0;
|
||||
}
|
||||
|
||||
void b2Fixture::Synchronize(b2BroadPhase* broadPhase, const b2Transform& transform1, const b2Transform& transform2)
|
||||
{
|
||||
if (m_proxyCount == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
for (int32 i = 0; i < m_proxyCount; ++i)
|
||||
{
|
||||
b2FixtureProxy* proxy = m_proxies + i;
|
||||
|
||||
// Compute an AABB that covers the swept shape (may miss some rotation effect).
|
||||
b2AABB aabb1, aabb2;
|
||||
m_shape->ComputeAABB(&aabb1, transform1, proxy->childIndex);
|
||||
m_shape->ComputeAABB(&aabb2, transform2, proxy->childIndex);
|
||||
|
||||
proxy->aabb.Combine(aabb1, aabb2);
|
||||
|
||||
b2Vec2 displacement = transform2.p - transform1.p;
|
||||
|
||||
broadPhase->MoveProxy(proxy->proxyId, proxy->aabb, displacement);
|
||||
}
|
||||
}
|
||||
|
||||
void b2Fixture::SetFilterData(const b2Filter& filter)
|
||||
{
|
||||
m_filter = filter;
|
||||
|
||||
Refilter();
|
||||
}
|
||||
|
||||
void b2Fixture::Refilter()
|
||||
{
|
||||
if (m_body == NULL)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// Flag associated contacts for filtering.
|
||||
b2ContactEdge* edge = m_body->GetContactList();
|
||||
while (edge)
|
||||
{
|
||||
b2Contact* contact = edge->contact;
|
||||
b2Fixture* fixtureA = contact->GetFixtureA();
|
||||
b2Fixture* fixtureB = contact->GetFixtureB();
|
||||
if (fixtureA == this || fixtureB == this)
|
||||
{
|
||||
contact->FlagForFiltering();
|
||||
}
|
||||
|
||||
edge = edge->next;
|
||||
}
|
||||
|
||||
b2World* world = m_body->GetWorld();
|
||||
|
||||
if (world == NULL)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// Touch each proxy so that new pairs may be created
|
||||
b2BroadPhase* broadPhase = &world->m_contactManager.m_broadPhase;
|
||||
for (int32 i = 0; i < m_proxyCount; ++i)
|
||||
{
|
||||
broadPhase->TouchProxy(m_proxies[i].proxyId);
|
||||
}
|
||||
}
|
||||
|
||||
void b2Fixture::SetSensor(bool sensor)
|
||||
{
|
||||
if (sensor != m_isSensor)
|
||||
{
|
||||
m_body->SetAwake(true);
|
||||
m_isSensor = sensor;
|
||||
}
|
||||
}
|
||||
|
||||
void b2Fixture::Dump(int32 bodyIndex)
|
||||
{
|
||||
b2Log(" b2FixtureDef fd;\n");
|
||||
b2Log(" fd.friction = %.15lef;\n", m_friction);
|
||||
b2Log(" fd.restitution = %.15lef;\n", m_restitution);
|
||||
b2Log(" fd.density = %.15lef;\n", m_density);
|
||||
b2Log(" fd.isSensor = bool(%d);\n", m_isSensor);
|
||||
b2Log(" fd.filter.categoryBits = uint16(%d);\n", m_filter.categoryBits);
|
||||
b2Log(" fd.filter.maskBits = uint16(%d);\n", m_filter.maskBits);
|
||||
b2Log(" fd.filter.groupIndex = int16(%d);\n", m_filter.groupIndex);
|
||||
|
||||
switch (m_shape->m_type)
|
||||
{
|
||||
case b2Shape::e_circle:
|
||||
{
|
||||
b2CircleShape* s = (b2CircleShape*)m_shape;
|
||||
b2Log(" b2CircleShape shape;\n");
|
||||
b2Log(" shape.m_radius = %.15lef;\n", s->m_radius);
|
||||
b2Log(" shape.m_p.Set(%.15lef, %.15lef);\n", s->m_p.x, s->m_p.y);
|
||||
}
|
||||
break;
|
||||
|
||||
case b2Shape::e_edge:
|
||||
{
|
||||
b2EdgeShape* s = (b2EdgeShape*)m_shape;
|
||||
b2Log(" b2EdgeShape shape;\n");
|
||||
b2Log(" shape.m_radius = %.15lef;\n", s->m_radius);
|
||||
b2Log(" shape.m_vertex0.Set(%.15lef, %.15lef);\n", s->m_vertex0.x, s->m_vertex0.y);
|
||||
b2Log(" shape.m_vertex1.Set(%.15lef, %.15lef);\n", s->m_vertex1.x, s->m_vertex1.y);
|
||||
b2Log(" shape.m_vertex2.Set(%.15lef, %.15lef);\n", s->m_vertex2.x, s->m_vertex2.y);
|
||||
b2Log(" shape.m_vertex3.Set(%.15lef, %.15lef);\n", s->m_vertex3.x, s->m_vertex3.y);
|
||||
b2Log(" shape.m_hasVertex0 = bool(%d);\n", s->m_hasVertex0);
|
||||
b2Log(" shape.m_hasVertex3 = bool(%d);\n", s->m_hasVertex3);
|
||||
}
|
||||
break;
|
||||
|
||||
case b2Shape::e_polygon:
|
||||
{
|
||||
b2PolygonShape* s = (b2PolygonShape*)m_shape;
|
||||
b2Log(" b2PolygonShape shape;\n");
|
||||
b2Log(" b2Vec2 vs[%d];\n", b2_maxPolygonVertices);
|
||||
for (int32 i = 0; i < s->m_vertexCount; ++i)
|
||||
{
|
||||
b2Log(" vs[%d].Set(%.15lef, %.15lef);\n", i, s->m_vertices[i].x, s->m_vertices[i].y);
|
||||
}
|
||||
b2Log(" shape.Set(vs, %d);\n", s->m_vertexCount);
|
||||
}
|
||||
break;
|
||||
|
||||
case b2Shape::e_chain:
|
||||
{
|
||||
b2ChainShape* s = (b2ChainShape*)m_shape;
|
||||
b2Log(" b2ChainShape shape;\n");
|
||||
b2Log(" b2Vec2 vs[%d];\n", s->m_count);
|
||||
for (int32 i = 0; i < s->m_count; ++i)
|
||||
{
|
||||
b2Log(" vs[%d].Set(%.15lef, %.15lef);\n", i, s->m_vertices[i].x, s->m_vertices[i].y);
|
||||
}
|
||||
b2Log(" shape.CreateChain(vs, %d);\n", s->m_count);
|
||||
b2Log(" shape.m_prevVertex.Set(%.15lef, %.15lef);\n", s->m_prevVertex.x, s->m_prevVertex.y);
|
||||
b2Log(" shape.m_nextVertex.Set(%.15lef, %.15lef);\n", s->m_nextVertex.x, s->m_nextVertex.y);
|
||||
b2Log(" shape.m_hasPrevVertex = bool(%d);\n", s->m_hasPrevVertex);
|
||||
b2Log(" shape.m_hasNextVertex = bool(%d);\n", s->m_hasNextVertex);
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
return;
|
||||
}
|
||||
|
||||
b2Log("\n");
|
||||
b2Log(" fd.shape = &shape;\n");
|
||||
b2Log("\n");
|
||||
b2Log(" bodies[%d]->CreateFixture(&fd);\n", bodyIndex);
|
||||
}
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "b2Fixture.h"
|
||||
#include "Contacts/b2Contact.h"
|
||||
#include "b2World.h"
|
||||
#include "../Collision/Shapes/b2CircleShape.h"
|
||||
#include "../Collision/Shapes/b2EdgeShape.h"
|
||||
#include "../Collision/Shapes/b2PolygonShape.h"
|
||||
#include "../Collision/Shapes/b2ChainShape.h"
|
||||
#include "../Collision/b2BroadPhase.h"
|
||||
#include "../Collision/b2Collision.h"
|
||||
#include "../Common/b2BlockAllocator.h"
|
||||
|
||||
b2Fixture::b2Fixture()
|
||||
{
|
||||
m_userData = NULL;
|
||||
m_body = NULL;
|
||||
m_next = NULL;
|
||||
m_proxies = NULL;
|
||||
m_proxyCount = 0;
|
||||
m_shape = NULL;
|
||||
m_density = 0.0f;
|
||||
}
|
||||
|
||||
void b2Fixture::Create(b2BlockAllocator* allocator, b2Body* body, const b2FixtureDef* def)
|
||||
{
|
||||
m_userData = def->userData;
|
||||
m_friction = def->friction;
|
||||
m_restitution = def->restitution;
|
||||
|
||||
m_body = body;
|
||||
m_next = NULL;
|
||||
|
||||
m_filter = def->filter;
|
||||
|
||||
m_isSensor = def->isSensor;
|
||||
|
||||
m_shape = def->shape->Clone(allocator);
|
||||
|
||||
// Reserve proxy space
|
||||
int32 childCount = m_shape->GetChildCount();
|
||||
m_proxies = (b2FixtureProxy*)allocator->Allocate(childCount * sizeof(b2FixtureProxy));
|
||||
for (int32 i = 0; i < childCount; ++i)
|
||||
{
|
||||
m_proxies[i].fixture = NULL;
|
||||
m_proxies[i].proxyId = b2BroadPhase::e_nullProxy;
|
||||
}
|
||||
m_proxyCount = 0;
|
||||
|
||||
m_density = def->density;
|
||||
}
|
||||
|
||||
void b2Fixture::Destroy(b2BlockAllocator* allocator)
|
||||
{
|
||||
// The proxies must be destroyed before calling this.
|
||||
b2Assert(m_proxyCount == 0);
|
||||
|
||||
// Free the proxy array.
|
||||
int32 childCount = m_shape->GetChildCount();
|
||||
allocator->Free(m_proxies, childCount * sizeof(b2FixtureProxy));
|
||||
m_proxies = NULL;
|
||||
|
||||
// Free the child shape.
|
||||
switch (m_shape->m_type)
|
||||
{
|
||||
case b2Shape::e_circle:
|
||||
{
|
||||
b2CircleShape* s = (b2CircleShape*)m_shape;
|
||||
s->~b2CircleShape();
|
||||
allocator->Free(s, sizeof(b2CircleShape));
|
||||
}
|
||||
break;
|
||||
|
||||
case b2Shape::e_edge:
|
||||
{
|
||||
b2EdgeShape* s = (b2EdgeShape*)m_shape;
|
||||
s->~b2EdgeShape();
|
||||
allocator->Free(s, sizeof(b2EdgeShape));
|
||||
}
|
||||
break;
|
||||
|
||||
case b2Shape::e_polygon:
|
||||
{
|
||||
b2PolygonShape* s = (b2PolygonShape*)m_shape;
|
||||
s->~b2PolygonShape();
|
||||
allocator->Free(s, sizeof(b2PolygonShape));
|
||||
}
|
||||
break;
|
||||
|
||||
case b2Shape::e_chain:
|
||||
{
|
||||
b2ChainShape* s = (b2ChainShape*)m_shape;
|
||||
s->~b2ChainShape();
|
||||
allocator->Free(s, sizeof(b2ChainShape));
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
b2Assert(false);
|
||||
break;
|
||||
}
|
||||
|
||||
m_shape = NULL;
|
||||
}
|
||||
|
||||
void b2Fixture::CreateProxies(b2BroadPhase* broadPhase, const b2Transform& xf)
|
||||
{
|
||||
b2Assert(m_proxyCount == 0);
|
||||
|
||||
// Create proxies in the broad-phase.
|
||||
m_proxyCount = m_shape->GetChildCount();
|
||||
|
||||
for (int32 i = 0; i < m_proxyCount; ++i)
|
||||
{
|
||||
b2FixtureProxy* proxy = m_proxies + i;
|
||||
m_shape->ComputeAABB(&proxy->aabb, xf, i);
|
||||
proxy->proxyId = broadPhase->CreateProxy(proxy->aabb, proxy);
|
||||
proxy->fixture = this;
|
||||
proxy->childIndex = i;
|
||||
}
|
||||
}
|
||||
|
||||
void b2Fixture::DestroyProxies(b2BroadPhase* broadPhase)
|
||||
{
|
||||
// Destroy proxies in the broad-phase.
|
||||
for (int32 i = 0; i < m_proxyCount; ++i)
|
||||
{
|
||||
b2FixtureProxy* proxy = m_proxies + i;
|
||||
broadPhase->DestroyProxy(proxy->proxyId);
|
||||
proxy->proxyId = b2BroadPhase::e_nullProxy;
|
||||
}
|
||||
|
||||
m_proxyCount = 0;
|
||||
}
|
||||
|
||||
void b2Fixture::Synchronize(b2BroadPhase* broadPhase, const b2Transform& transform1, const b2Transform& transform2)
|
||||
{
|
||||
if (m_proxyCount == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
for (int32 i = 0; i < m_proxyCount; ++i)
|
||||
{
|
||||
b2FixtureProxy* proxy = m_proxies + i;
|
||||
|
||||
// Compute an AABB that covers the swept shape (may miss some rotation effect).
|
||||
b2AABB aabb1, aabb2;
|
||||
m_shape->ComputeAABB(&aabb1, transform1, proxy->childIndex);
|
||||
m_shape->ComputeAABB(&aabb2, transform2, proxy->childIndex);
|
||||
|
||||
proxy->aabb.Combine(aabb1, aabb2);
|
||||
|
||||
b2Vec2 displacement = transform2.p - transform1.p;
|
||||
|
||||
broadPhase->MoveProxy(proxy->proxyId, proxy->aabb, displacement);
|
||||
}
|
||||
}
|
||||
|
||||
void b2Fixture::SetFilterData(const b2Filter& filter)
|
||||
{
|
||||
m_filter = filter;
|
||||
|
||||
Refilter();
|
||||
}
|
||||
|
||||
void b2Fixture::Refilter()
|
||||
{
|
||||
if (m_body == NULL)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// Flag associated contacts for filtering.
|
||||
b2ContactEdge* edge = m_body->GetContactList();
|
||||
while (edge)
|
||||
{
|
||||
b2Contact* contact = edge->contact;
|
||||
b2Fixture* fixtureA = contact->GetFixtureA();
|
||||
b2Fixture* fixtureB = contact->GetFixtureB();
|
||||
if (fixtureA == this || fixtureB == this)
|
||||
{
|
||||
contact->FlagForFiltering();
|
||||
}
|
||||
|
||||
edge = edge->next;
|
||||
}
|
||||
|
||||
b2World* world = m_body->GetWorld();
|
||||
|
||||
if (world == NULL)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// Touch each proxy so that new pairs may be created
|
||||
b2BroadPhase* broadPhase = &world->m_contactManager.m_broadPhase;
|
||||
for (int32 i = 0; i < m_proxyCount; ++i)
|
||||
{
|
||||
broadPhase->TouchProxy(m_proxies[i].proxyId);
|
||||
}
|
||||
}
|
||||
|
||||
void b2Fixture::SetSensor(bool sensor)
|
||||
{
|
||||
if (sensor != m_isSensor)
|
||||
{
|
||||
m_body->SetAwake(true);
|
||||
m_isSensor = sensor;
|
||||
}
|
||||
}
|
||||
|
||||
void b2Fixture::Dump(int32 bodyIndex)
|
||||
{
|
||||
b2Log(" b2FixtureDef fd;\n");
|
||||
b2Log(" fd.friction = %.15lef;\n", m_friction);
|
||||
b2Log(" fd.restitution = %.15lef;\n", m_restitution);
|
||||
b2Log(" fd.density = %.15lef;\n", m_density);
|
||||
b2Log(" fd.isSensor = bool(%d);\n", m_isSensor);
|
||||
b2Log(" fd.filter.categoryBits = uint16(%d);\n", m_filter.categoryBits);
|
||||
b2Log(" fd.filter.maskBits = uint16(%d);\n", m_filter.maskBits);
|
||||
b2Log(" fd.filter.groupIndex = int16(%d);\n", m_filter.groupIndex);
|
||||
|
||||
switch (m_shape->m_type)
|
||||
{
|
||||
case b2Shape::e_circle:
|
||||
{
|
||||
b2CircleShape* s = (b2CircleShape*)m_shape;
|
||||
b2Log(" b2CircleShape shape;\n");
|
||||
b2Log(" shape.m_radius = %.15lef;\n", s->m_radius);
|
||||
b2Log(" shape.m_p.Set(%.15lef, %.15lef);\n", s->m_p.x, s->m_p.y);
|
||||
}
|
||||
break;
|
||||
|
||||
case b2Shape::e_edge:
|
||||
{
|
||||
b2EdgeShape* s = (b2EdgeShape*)m_shape;
|
||||
b2Log(" b2EdgeShape shape;\n");
|
||||
b2Log(" shape.m_radius = %.15lef;\n", s->m_radius);
|
||||
b2Log(" shape.m_vertex0.Set(%.15lef, %.15lef);\n", s->m_vertex0.x, s->m_vertex0.y);
|
||||
b2Log(" shape.m_vertex1.Set(%.15lef, %.15lef);\n", s->m_vertex1.x, s->m_vertex1.y);
|
||||
b2Log(" shape.m_vertex2.Set(%.15lef, %.15lef);\n", s->m_vertex2.x, s->m_vertex2.y);
|
||||
b2Log(" shape.m_vertex3.Set(%.15lef, %.15lef);\n", s->m_vertex3.x, s->m_vertex3.y);
|
||||
b2Log(" shape.m_hasVertex0 = bool(%d);\n", s->m_hasVertex0);
|
||||
b2Log(" shape.m_hasVertex3 = bool(%d);\n", s->m_hasVertex3);
|
||||
}
|
||||
break;
|
||||
|
||||
case b2Shape::e_polygon:
|
||||
{
|
||||
b2PolygonShape* s = (b2PolygonShape*)m_shape;
|
||||
b2Log(" b2PolygonShape shape;\n");
|
||||
b2Log(" b2Vec2 vs[%d];\n", b2_maxPolygonVertices);
|
||||
for (int32 i = 0; i < s->m_vertexCount; ++i)
|
||||
{
|
||||
b2Log(" vs[%d].Set(%.15lef, %.15lef);\n", i, s->m_vertices[i].x, s->m_vertices[i].y);
|
||||
}
|
||||
b2Log(" shape.Set(vs, %d);\n", s->m_vertexCount);
|
||||
}
|
||||
break;
|
||||
|
||||
case b2Shape::e_chain:
|
||||
{
|
||||
b2ChainShape* s = (b2ChainShape*)m_shape;
|
||||
b2Log(" b2ChainShape shape;\n");
|
||||
b2Log(" b2Vec2 vs[%d];\n", s->m_count);
|
||||
for (int32 i = 0; i < s->m_count; ++i)
|
||||
{
|
||||
b2Log(" vs[%d].Set(%.15lef, %.15lef);\n", i, s->m_vertices[i].x, s->m_vertices[i].y);
|
||||
}
|
||||
b2Log(" shape.CreateChain(vs, %d);\n", s->m_count);
|
||||
b2Log(" shape.m_prevVertex.Set(%.15lef, %.15lef);\n", s->m_prevVertex.x, s->m_prevVertex.y);
|
||||
b2Log(" shape.m_nextVertex.Set(%.15lef, %.15lef);\n", s->m_nextVertex.x, s->m_nextVertex.y);
|
||||
b2Log(" shape.m_hasPrevVertex = bool(%d);\n", s->m_hasPrevVertex);
|
||||
b2Log(" shape.m_hasNextVertex = bool(%d);\n", s->m_hasNextVertex);
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
return;
|
||||
}
|
||||
|
||||
b2Log("\n");
|
||||
b2Log(" fd.shape = &shape;\n");
|
||||
b2Log("\n");
|
||||
b2Log(" bodies[%d]->CreateFixture(&fd);\n", bodyIndex);
|
||||
}
|
||||
|
||||
@@ -1,345 +1,345 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_FIXTURE_H
|
||||
#define B2_FIXTURE_H
|
||||
|
||||
#include "b2Body.h"
|
||||
#include "../Collision/b2Collision.h"
|
||||
#include "../Collision/Shapes/b2Shape.h"
|
||||
|
||||
class b2BlockAllocator;
|
||||
class b2Body;
|
||||
class b2BroadPhase;
|
||||
class b2Fixture;
|
||||
|
||||
/// This holds contact filtering data.
|
||||
struct b2Filter
|
||||
{
|
||||
b2Filter()
|
||||
{
|
||||
categoryBits = 0x0001;
|
||||
maskBits = 0xFFFF;
|
||||
groupIndex = 0;
|
||||
}
|
||||
|
||||
/// The collision category bits. Normally you would just set one bit.
|
||||
juce::uint16 categoryBits;
|
||||
|
||||
/// The collision mask bits. This states the categories that this
|
||||
/// shape would accept for collision.
|
||||
juce::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.
|
||||
juce::int16 groupIndex;
|
||||
};
|
||||
|
||||
/// A fixture definition is used to create a fixture. This class defines an
|
||||
/// abstract fixture definition. You can reuse fixture definitions safely.
|
||||
struct b2FixtureDef
|
||||
{
|
||||
/// The constructor sets the default fixture definition values.
|
||||
b2FixtureDef()
|
||||
{
|
||||
shape = NULL;
|
||||
userData = NULL;
|
||||
friction = 0.2f;
|
||||
restitution = 0.0f;
|
||||
density = 0.0f;
|
||||
isSensor = false;
|
||||
}
|
||||
|
||||
/// The shape, this must be set. The shape will be cloned, so you
|
||||
/// can create the shape on the stack.
|
||||
const b2Shape* shape;
|
||||
|
||||
/// Use this to store application specific fixture data.
|
||||
void* userData;
|
||||
|
||||
/// The friction coefficient, usually in the range [0,1].
|
||||
float32 friction;
|
||||
|
||||
/// The restitution (elasticity) usually in the range [0,1].
|
||||
float32 restitution;
|
||||
|
||||
/// The 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.
|
||||
b2Filter filter;
|
||||
};
|
||||
|
||||
/// This proxy is used internally to connect fixtures to the broad-phase.
|
||||
struct b2FixtureProxy
|
||||
{
|
||||
b2AABB aabb;
|
||||
b2Fixture* fixture;
|
||||
juce::int32 childIndex;
|
||||
juce::int32 proxyId;
|
||||
};
|
||||
|
||||
/// A fixture is used to attach a shape to a body for collision detection. A fixture
|
||||
/// inherits its transform from its parent. Fixtures hold additional non-geometric data
|
||||
/// such as friction, collision filters, etc.
|
||||
/// Fixtures are created via b2Body::CreateFixture.
|
||||
/// @warning you cannot reuse fixtures.
|
||||
class b2Fixture
|
||||
{
|
||||
public:
|
||||
/// Get the type of the child shape. You can use this to down cast to the concrete shape.
|
||||
/// @return the shape type.
|
||||
b2Shape::Type GetType() const;
|
||||
|
||||
/// Get the child shape. You can modify the child shape, however you should not change the
|
||||
/// number of vertices because this will crash some collision caching mechanisms.
|
||||
/// Manipulating the shape may lead to non-physical behavior.
|
||||
b2Shape* GetShape();
|
||||
const b2Shape* GetShape() const;
|
||||
|
||||
/// Set if this fixture is a sensor.
|
||||
void SetSensor(bool sensor);
|
||||
|
||||
/// Is this fixture a sensor (non-solid)?
|
||||
/// @return the true if the shape is a sensor.
|
||||
bool IsSensor() const;
|
||||
|
||||
/// Set the contact filtering data. This will not update contacts until the next time
|
||||
/// step when either parent body is active and awake.
|
||||
/// This automatically calls Refilter.
|
||||
void SetFilterData(const b2Filter& filter);
|
||||
|
||||
/// Get the contact filtering data.
|
||||
const b2Filter& GetFilterData() const;
|
||||
|
||||
/// Call this if you want to establish collision that was previously disabled by b2ContactFilter::ShouldCollide.
|
||||
void Refilter();
|
||||
|
||||
/// Get the parent body of this fixture. This is NULL if the fixture is not attached.
|
||||
/// @return the parent body.
|
||||
b2Body* GetBody();
|
||||
const b2Body* GetBody() const;
|
||||
|
||||
/// Get the next fixture in the parent body's fixture list.
|
||||
/// @return the next shape.
|
||||
b2Fixture* GetNext();
|
||||
const b2Fixture* GetNext() const;
|
||||
|
||||
/// Get the user data that was assigned in the fixture definition. Use this to
|
||||
/// store your application specific data.
|
||||
void* GetUserData() const;
|
||||
|
||||
/// Set the user data. Use this to store your application specific data.
|
||||
void SetUserData(void* data);
|
||||
|
||||
/// Test a point for containment in this fixture.
|
||||
/// @param p a point in world coordinates.
|
||||
bool TestPoint(const b2Vec2& p) const;
|
||||
|
||||
/// Cast a ray against this shape.
|
||||
/// @param output the ray-cast results.
|
||||
/// @param input the ray-cast input parameters.
|
||||
bool RayCast(b2RayCastOutput* output, const b2RayCastInput& input, juce::int32 childIndex) const;
|
||||
|
||||
/// Get the mass data for this fixture. The mass data is based on the density and
|
||||
/// the shape. The rotational inertia is about the shape's origin. This operation
|
||||
/// may be expensive.
|
||||
void GetMassData(b2MassData* massData) const;
|
||||
|
||||
/// Set the density of this fixture. This will _not_ automatically adjust the mass
|
||||
/// of the body. You must call b2Body::ResetMassData to update the body's mass.
|
||||
void SetDensity(float32 density);
|
||||
|
||||
/// Get the density of this fixture.
|
||||
float32 GetDensity() const;
|
||||
|
||||
/// Get the coefficient of friction.
|
||||
float32 GetFriction() const;
|
||||
|
||||
/// Set the coefficient of friction. This will _not_ change the friction of
|
||||
/// existing contacts.
|
||||
void SetFriction(float32 friction);
|
||||
|
||||
/// Get the coefficient of restitution.
|
||||
float32 GetRestitution() const;
|
||||
|
||||
/// Set the coefficient of restitution. This will _not_ change the restitution of
|
||||
/// existing contacts.
|
||||
void SetRestitution(float32 restitution);
|
||||
|
||||
/// Get the fixture's AABB. This AABB may be enlarge and/or stale.
|
||||
/// If you need a more accurate AABB, compute it using the shape and
|
||||
/// the body transform.
|
||||
const b2AABB& GetAABB(juce::int32 childIndex) const;
|
||||
|
||||
/// Dump this fixture to the log file.
|
||||
void Dump(juce::int32 bodyIndex);
|
||||
|
||||
protected:
|
||||
|
||||
friend class b2Body;
|
||||
friend class b2World;
|
||||
friend class b2Contact;
|
||||
friend class b2ContactManager;
|
||||
|
||||
b2Fixture();
|
||||
|
||||
// We need separation create/destroy functions from the constructor/destructor because
|
||||
// the destructor cannot access the allocator (no destructor arguments allowed by C++).
|
||||
void Create(b2BlockAllocator* allocator, b2Body* body, const b2FixtureDef* def);
|
||||
void Destroy(b2BlockAllocator* allocator);
|
||||
|
||||
// These support body activation/deactivation.
|
||||
void CreateProxies(b2BroadPhase* broadPhase, const b2Transform& xf);
|
||||
void DestroyProxies(b2BroadPhase* broadPhase);
|
||||
|
||||
void Synchronize(b2BroadPhase* broadPhase, const b2Transform& xf1, const b2Transform& xf2);
|
||||
|
||||
float32 m_density;
|
||||
|
||||
b2Fixture* m_next;
|
||||
b2Body* m_body;
|
||||
|
||||
b2Shape* m_shape;
|
||||
|
||||
float32 m_friction;
|
||||
float32 m_restitution;
|
||||
|
||||
b2FixtureProxy* m_proxies;
|
||||
juce::int32 m_proxyCount;
|
||||
|
||||
b2Filter m_filter;
|
||||
|
||||
bool m_isSensor;
|
||||
|
||||
void* m_userData;
|
||||
};
|
||||
|
||||
inline b2Shape::Type b2Fixture::GetType() const
|
||||
{
|
||||
return m_shape->GetType();
|
||||
}
|
||||
|
||||
inline b2Shape* b2Fixture::GetShape()
|
||||
{
|
||||
return m_shape;
|
||||
}
|
||||
|
||||
inline const b2Shape* b2Fixture::GetShape() const
|
||||
{
|
||||
return m_shape;
|
||||
}
|
||||
|
||||
inline bool b2Fixture::IsSensor() const
|
||||
{
|
||||
return m_isSensor;
|
||||
}
|
||||
|
||||
inline const b2Filter& b2Fixture::GetFilterData() const
|
||||
{
|
||||
return m_filter;
|
||||
}
|
||||
|
||||
inline void* b2Fixture::GetUserData() const
|
||||
{
|
||||
return m_userData;
|
||||
}
|
||||
|
||||
inline void b2Fixture::SetUserData(void* data)
|
||||
{
|
||||
m_userData = data;
|
||||
}
|
||||
|
||||
inline b2Body* b2Fixture::GetBody()
|
||||
{
|
||||
return m_body;
|
||||
}
|
||||
|
||||
inline const b2Body* b2Fixture::GetBody() const
|
||||
{
|
||||
return m_body;
|
||||
}
|
||||
|
||||
inline b2Fixture* b2Fixture::GetNext()
|
||||
{
|
||||
return m_next;
|
||||
}
|
||||
|
||||
inline const b2Fixture* b2Fixture::GetNext() const
|
||||
{
|
||||
return m_next;
|
||||
}
|
||||
|
||||
inline void b2Fixture::SetDensity(float32 density)
|
||||
{
|
||||
b2Assert(b2IsValid(density) && density >= 0.0f);
|
||||
m_density = density;
|
||||
}
|
||||
|
||||
inline float32 b2Fixture::GetDensity() const
|
||||
{
|
||||
return m_density;
|
||||
}
|
||||
|
||||
inline float32 b2Fixture::GetFriction() const
|
||||
{
|
||||
return m_friction;
|
||||
}
|
||||
|
||||
inline void b2Fixture::SetFriction(float32 friction)
|
||||
{
|
||||
m_friction = friction;
|
||||
}
|
||||
|
||||
inline float32 b2Fixture::GetRestitution() const
|
||||
{
|
||||
return m_restitution;
|
||||
}
|
||||
|
||||
inline void b2Fixture::SetRestitution(float32 restitution)
|
||||
{
|
||||
m_restitution = restitution;
|
||||
}
|
||||
|
||||
inline bool b2Fixture::TestPoint(const b2Vec2& p) const
|
||||
{
|
||||
return m_shape->TestPoint(m_body->GetTransform(), p);
|
||||
}
|
||||
|
||||
inline bool b2Fixture::RayCast(b2RayCastOutput* output, const b2RayCastInput& input, juce::int32 childIndex) const
|
||||
{
|
||||
return m_shape->RayCast(output, input, m_body->GetTransform(), childIndex);
|
||||
}
|
||||
|
||||
inline void b2Fixture::GetMassData(b2MassData* massData) const
|
||||
{
|
||||
m_shape->ComputeMass(massData, m_density);
|
||||
}
|
||||
|
||||
inline const b2AABB& b2Fixture::GetAABB(juce::int32 childIndex) const
|
||||
{
|
||||
b2Assert(0 <= childIndex && childIndex < m_proxyCount);
|
||||
return m_proxies[childIndex].aabb;
|
||||
}
|
||||
|
||||
#endif
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_FIXTURE_H
|
||||
#define B2_FIXTURE_H
|
||||
|
||||
#include "b2Body.h"
|
||||
#include "../Collision/b2Collision.h"
|
||||
#include "../Collision/Shapes/b2Shape.h"
|
||||
|
||||
class b2BlockAllocator;
|
||||
class b2Body;
|
||||
class b2BroadPhase;
|
||||
class b2Fixture;
|
||||
|
||||
/// This holds contact filtering data.
|
||||
struct b2Filter
|
||||
{
|
||||
b2Filter()
|
||||
{
|
||||
categoryBits = 0x0001;
|
||||
maskBits = 0xFFFF;
|
||||
groupIndex = 0;
|
||||
}
|
||||
|
||||
/// The collision category bits. Normally you would just set one bit.
|
||||
juce::uint16 categoryBits;
|
||||
|
||||
/// The collision mask bits. This states the categories that this
|
||||
/// shape would accept for collision.
|
||||
juce::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.
|
||||
juce::int16 groupIndex;
|
||||
};
|
||||
|
||||
/// A fixture definition is used to create a fixture. This class defines an
|
||||
/// abstract fixture definition. You can reuse fixture definitions safely.
|
||||
struct b2FixtureDef
|
||||
{
|
||||
/// The constructor sets the default fixture definition values.
|
||||
b2FixtureDef()
|
||||
{
|
||||
shape = NULL;
|
||||
userData = NULL;
|
||||
friction = 0.2f;
|
||||
restitution = 0.0f;
|
||||
density = 0.0f;
|
||||
isSensor = false;
|
||||
}
|
||||
|
||||
/// The shape, this must be set. The shape will be cloned, so you
|
||||
/// can create the shape on the stack.
|
||||
const b2Shape* shape;
|
||||
|
||||
/// Use this to store application specific fixture data.
|
||||
void* userData;
|
||||
|
||||
/// The friction coefficient, usually in the range [0,1].
|
||||
float32 friction;
|
||||
|
||||
/// The restitution (elasticity) usually in the range [0,1].
|
||||
float32 restitution;
|
||||
|
||||
/// The 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.
|
||||
b2Filter filter;
|
||||
};
|
||||
|
||||
/// This proxy is used internally to connect fixtures to the broad-phase.
|
||||
struct b2FixtureProxy
|
||||
{
|
||||
b2AABB aabb;
|
||||
b2Fixture* fixture;
|
||||
juce::int32 childIndex;
|
||||
juce::int32 proxyId;
|
||||
};
|
||||
|
||||
/// A fixture is used to attach a shape to a body for collision detection. A fixture
|
||||
/// inherits its transform from its parent. Fixtures hold additional non-geometric data
|
||||
/// such as friction, collision filters, etc.
|
||||
/// Fixtures are created via b2Body::CreateFixture.
|
||||
/// @warning you cannot reuse fixtures.
|
||||
class b2Fixture
|
||||
{
|
||||
public:
|
||||
/// Get the type of the child shape. You can use this to down cast to the concrete shape.
|
||||
/// @return the shape type.
|
||||
b2Shape::Type GetType() const;
|
||||
|
||||
/// Get the child shape. You can modify the child shape, however you should not change the
|
||||
/// number of vertices because this will crash some collision caching mechanisms.
|
||||
/// Manipulating the shape may lead to non-physical behavior.
|
||||
b2Shape* GetShape();
|
||||
const b2Shape* GetShape() const;
|
||||
|
||||
/// Set if this fixture is a sensor.
|
||||
void SetSensor(bool sensor);
|
||||
|
||||
/// Is this fixture a sensor (non-solid)?
|
||||
/// @return the true if the shape is a sensor.
|
||||
bool IsSensor() const;
|
||||
|
||||
/// Set the contact filtering data. This will not update contacts until the next time
|
||||
/// step when either parent body is active and awake.
|
||||
/// This automatically calls Refilter.
|
||||
void SetFilterData(const b2Filter& filter);
|
||||
|
||||
/// Get the contact filtering data.
|
||||
const b2Filter& GetFilterData() const;
|
||||
|
||||
/// Call this if you want to establish collision that was previously disabled by b2ContactFilter::ShouldCollide.
|
||||
void Refilter();
|
||||
|
||||
/// Get the parent body of this fixture. This is NULL if the fixture is not attached.
|
||||
/// @return the parent body.
|
||||
b2Body* GetBody();
|
||||
const b2Body* GetBody() const;
|
||||
|
||||
/// Get the next fixture in the parent body's fixture list.
|
||||
/// @return the next shape.
|
||||
b2Fixture* GetNext();
|
||||
const b2Fixture* GetNext() const;
|
||||
|
||||
/// Get the user data that was assigned in the fixture definition. Use this to
|
||||
/// store your application specific data.
|
||||
void* GetUserData() const;
|
||||
|
||||
/// Set the user data. Use this to store your application specific data.
|
||||
void SetUserData(void* data);
|
||||
|
||||
/// Test a point for containment in this fixture.
|
||||
/// @param p a point in world coordinates.
|
||||
bool TestPoint(const b2Vec2& p) const;
|
||||
|
||||
/// Cast a ray against this shape.
|
||||
/// @param output the ray-cast results.
|
||||
/// @param input the ray-cast input parameters.
|
||||
bool RayCast(b2RayCastOutput* output, const b2RayCastInput& input, juce::int32 childIndex) const;
|
||||
|
||||
/// Get the mass data for this fixture. The mass data is based on the density and
|
||||
/// the shape. The rotational inertia is about the shape's origin. This operation
|
||||
/// may be expensive.
|
||||
void GetMassData(b2MassData* massData) const;
|
||||
|
||||
/// Set the density of this fixture. This will _not_ automatically adjust the mass
|
||||
/// of the body. You must call b2Body::ResetMassData to update the body's mass.
|
||||
void SetDensity(float32 density);
|
||||
|
||||
/// Get the density of this fixture.
|
||||
float32 GetDensity() const;
|
||||
|
||||
/// Get the coefficient of friction.
|
||||
float32 GetFriction() const;
|
||||
|
||||
/// Set the coefficient of friction. This will _not_ change the friction of
|
||||
/// existing contacts.
|
||||
void SetFriction(float32 friction);
|
||||
|
||||
/// Get the coefficient of restitution.
|
||||
float32 GetRestitution() const;
|
||||
|
||||
/// Set the coefficient of restitution. This will _not_ change the restitution of
|
||||
/// existing contacts.
|
||||
void SetRestitution(float32 restitution);
|
||||
|
||||
/// Get the fixture's AABB. This AABB may be enlarge and/or stale.
|
||||
/// If you need a more accurate AABB, compute it using the shape and
|
||||
/// the body transform.
|
||||
const b2AABB& GetAABB(juce::int32 childIndex) const;
|
||||
|
||||
/// Dump this fixture to the log file.
|
||||
void Dump(juce::int32 bodyIndex);
|
||||
|
||||
protected:
|
||||
|
||||
friend class b2Body;
|
||||
friend class b2World;
|
||||
friend class b2Contact;
|
||||
friend class b2ContactManager;
|
||||
|
||||
b2Fixture();
|
||||
|
||||
// We need separation create/destroy functions from the constructor/destructor because
|
||||
// the destructor cannot access the allocator (no destructor arguments allowed by C++).
|
||||
void Create(b2BlockAllocator* allocator, b2Body* body, const b2FixtureDef* def);
|
||||
void Destroy(b2BlockAllocator* allocator);
|
||||
|
||||
// These support body activation/deactivation.
|
||||
void CreateProxies(b2BroadPhase* broadPhase, const b2Transform& xf);
|
||||
void DestroyProxies(b2BroadPhase* broadPhase);
|
||||
|
||||
void Synchronize(b2BroadPhase* broadPhase, const b2Transform& xf1, const b2Transform& xf2);
|
||||
|
||||
float32 m_density;
|
||||
|
||||
b2Fixture* m_next;
|
||||
b2Body* m_body;
|
||||
|
||||
b2Shape* m_shape;
|
||||
|
||||
float32 m_friction;
|
||||
float32 m_restitution;
|
||||
|
||||
b2FixtureProxy* m_proxies;
|
||||
juce::int32 m_proxyCount;
|
||||
|
||||
b2Filter m_filter;
|
||||
|
||||
bool m_isSensor;
|
||||
|
||||
void* m_userData;
|
||||
};
|
||||
|
||||
inline b2Shape::Type b2Fixture::GetType() const
|
||||
{
|
||||
return m_shape->GetType();
|
||||
}
|
||||
|
||||
inline b2Shape* b2Fixture::GetShape()
|
||||
{
|
||||
return m_shape;
|
||||
}
|
||||
|
||||
inline const b2Shape* b2Fixture::GetShape() const
|
||||
{
|
||||
return m_shape;
|
||||
}
|
||||
|
||||
inline bool b2Fixture::IsSensor() const
|
||||
{
|
||||
return m_isSensor;
|
||||
}
|
||||
|
||||
inline const b2Filter& b2Fixture::GetFilterData() const
|
||||
{
|
||||
return m_filter;
|
||||
}
|
||||
|
||||
inline void* b2Fixture::GetUserData() const
|
||||
{
|
||||
return m_userData;
|
||||
}
|
||||
|
||||
inline void b2Fixture::SetUserData(void* data)
|
||||
{
|
||||
m_userData = data;
|
||||
}
|
||||
|
||||
inline b2Body* b2Fixture::GetBody()
|
||||
{
|
||||
return m_body;
|
||||
}
|
||||
|
||||
inline const b2Body* b2Fixture::GetBody() const
|
||||
{
|
||||
return m_body;
|
||||
}
|
||||
|
||||
inline b2Fixture* b2Fixture::GetNext()
|
||||
{
|
||||
return m_next;
|
||||
}
|
||||
|
||||
inline const b2Fixture* b2Fixture::GetNext() const
|
||||
{
|
||||
return m_next;
|
||||
}
|
||||
|
||||
inline void b2Fixture::SetDensity(float32 density)
|
||||
{
|
||||
b2Assert(b2IsValid(density) && density >= 0.0f);
|
||||
m_density = density;
|
||||
}
|
||||
|
||||
inline float32 b2Fixture::GetDensity() const
|
||||
{
|
||||
return m_density;
|
||||
}
|
||||
|
||||
inline float32 b2Fixture::GetFriction() const
|
||||
{
|
||||
return m_friction;
|
||||
}
|
||||
|
||||
inline void b2Fixture::SetFriction(float32 friction)
|
||||
{
|
||||
m_friction = friction;
|
||||
}
|
||||
|
||||
inline float32 b2Fixture::GetRestitution() const
|
||||
{
|
||||
return m_restitution;
|
||||
}
|
||||
|
||||
inline void b2Fixture::SetRestitution(float32 restitution)
|
||||
{
|
||||
m_restitution = restitution;
|
||||
}
|
||||
|
||||
inline bool b2Fixture::TestPoint(const b2Vec2& p) const
|
||||
{
|
||||
return m_shape->TestPoint(m_body->GetTransform(), p);
|
||||
}
|
||||
|
||||
inline bool b2Fixture::RayCast(b2RayCastOutput* output, const b2RayCastInput& input, juce::int32 childIndex) const
|
||||
{
|
||||
return m_shape->RayCast(output, input, m_body->GetTransform(), childIndex);
|
||||
}
|
||||
|
||||
inline void b2Fixture::GetMassData(b2MassData* massData) const
|
||||
{
|
||||
m_shape->ComputeMass(massData, m_density);
|
||||
}
|
||||
|
||||
inline const b2AABB& b2Fixture::GetAABB(juce::int32 childIndex) const
|
||||
{
|
||||
b2Assert(0 <= childIndex && childIndex < m_proxyCount);
|
||||
return m_proxies[childIndex].aabb;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
1078
deps/juce/modules/juce_box2d/box2d/Dynamics/b2Island.cpp
vendored
1078
deps/juce/modules/juce_box2d/box2d/Dynamics/b2Island.cpp
vendored
File diff suppressed because it is too large
Load Diff
@@ -1,93 +1,93 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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"
|
||||
#include "b2Body.h"
|
||||
#include "b2TimeStep.h"
|
||||
|
||||
class b2Contact;
|
||||
class b2Joint;
|
||||
class b2StackAllocator;
|
||||
class b2ContactListener;
|
||||
struct b2ContactVelocityConstraint;
|
||||
struct b2Profile;
|
||||
|
||||
/// This is an internal class.
|
||||
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(b2Profile* profile, const b2TimeStep& step, const b2Vec2& gravity, bool allowSleep);
|
||||
|
||||
void SolveTOI(const b2TimeStep& subStep, int32 toiIndexA, int32 toiIndexB);
|
||||
|
||||
void Add(b2Body* body)
|
||||
{
|
||||
b2Assert(m_bodyCount < m_bodyCapacity);
|
||||
body->m_islandIndex = m_bodyCount;
|
||||
m_bodies[m_bodyCount] = body;
|
||||
++m_bodyCount;
|
||||
}
|
||||
|
||||
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(const b2ContactVelocityConstraint* constraints);
|
||||
|
||||
b2StackAllocator* m_allocator;
|
||||
b2ContactListener* m_listener;
|
||||
|
||||
b2Body** m_bodies;
|
||||
b2Contact** m_contacts;
|
||||
b2Joint** m_joints;
|
||||
|
||||
b2Position* m_positions;
|
||||
b2Velocity* m_velocities;
|
||||
|
||||
int32 m_bodyCount;
|
||||
int32 m_jointCount;
|
||||
int32 m_contactCount;
|
||||
|
||||
int32 m_bodyCapacity;
|
||||
int32 m_contactCapacity;
|
||||
int32 m_jointCapacity;
|
||||
};
|
||||
|
||||
#endif
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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"
|
||||
#include "b2Body.h"
|
||||
#include "b2TimeStep.h"
|
||||
|
||||
class b2Contact;
|
||||
class b2Joint;
|
||||
class b2StackAllocator;
|
||||
class b2ContactListener;
|
||||
struct b2ContactVelocityConstraint;
|
||||
struct b2Profile;
|
||||
|
||||
/// This is an internal class.
|
||||
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(b2Profile* profile, const b2TimeStep& step, const b2Vec2& gravity, bool allowSleep);
|
||||
|
||||
void SolveTOI(const b2TimeStep& subStep, int32 toiIndexA, int32 toiIndexB);
|
||||
|
||||
void Add(b2Body* body)
|
||||
{
|
||||
b2Assert(m_bodyCount < m_bodyCapacity);
|
||||
body->m_islandIndex = m_bodyCount;
|
||||
m_bodies[m_bodyCount] = body;
|
||||
++m_bodyCount;
|
||||
}
|
||||
|
||||
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(const b2ContactVelocityConstraint* constraints);
|
||||
|
||||
b2StackAllocator* m_allocator;
|
||||
b2ContactListener* m_listener;
|
||||
|
||||
b2Body** m_bodies;
|
||||
b2Contact** m_contacts;
|
||||
b2Joint** m_joints;
|
||||
|
||||
b2Position* m_positions;
|
||||
b2Velocity* m_velocities;
|
||||
|
||||
int32 m_bodyCount;
|
||||
int32 m_jointCount;
|
||||
int32 m_contactCount;
|
||||
|
||||
int32 m_bodyCapacity;
|
||||
int32 m_contactCapacity;
|
||||
int32 m_jointCapacity;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,70 +1,70 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_TIME_STEP_H
|
||||
#define B2_TIME_STEP_H
|
||||
|
||||
#include "../Common/b2Math.h"
|
||||
|
||||
/// Profiling data. Times are in milliseconds.
|
||||
struct b2Profile
|
||||
{
|
||||
float32 step;
|
||||
float32 collide;
|
||||
float32 solve;
|
||||
float32 solveInit;
|
||||
float32 solveVelocity;
|
||||
float32 solvePosition;
|
||||
float32 broadphase;
|
||||
float32 solveTOI;
|
||||
};
|
||||
|
||||
/// This is an internal structure.
|
||||
struct b2TimeStep
|
||||
{
|
||||
float32 dt; // time step
|
||||
float32 inv_dt; // inverse time step (0 if dt == 0).
|
||||
float32 dtRatio; // dt * inv_dt0
|
||||
juce::int32 velocityIterations;
|
||||
juce::int32 positionIterations;
|
||||
bool warmStarting;
|
||||
};
|
||||
|
||||
/// This is an internal structure.
|
||||
struct b2Position
|
||||
{
|
||||
b2Vec2 c;
|
||||
float32 a;
|
||||
};
|
||||
|
||||
/// This is an internal structure.
|
||||
struct b2Velocity
|
||||
{
|
||||
b2Vec2 v;
|
||||
float32 w;
|
||||
};
|
||||
|
||||
/// Solver Data
|
||||
struct b2SolverData
|
||||
{
|
||||
b2TimeStep step;
|
||||
b2Position* positions;
|
||||
b2Velocity* velocities;
|
||||
};
|
||||
|
||||
#endif
|
||||
/*
|
||||
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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_TIME_STEP_H
|
||||
#define B2_TIME_STEP_H
|
||||
|
||||
#include "../Common/b2Math.h"
|
||||
|
||||
/// Profiling data. Times are in milliseconds.
|
||||
struct b2Profile
|
||||
{
|
||||
float32 step;
|
||||
float32 collide;
|
||||
float32 solve;
|
||||
float32 solveInit;
|
||||
float32 solveVelocity;
|
||||
float32 solvePosition;
|
||||
float32 broadphase;
|
||||
float32 solveTOI;
|
||||
};
|
||||
|
||||
/// This is an internal structure.
|
||||
struct b2TimeStep
|
||||
{
|
||||
float32 dt; // time step
|
||||
float32 inv_dt; // inverse time step (0 if dt == 0).
|
||||
float32 dtRatio; // dt * inv_dt0
|
||||
juce::int32 velocityIterations;
|
||||
juce::int32 positionIterations;
|
||||
bool warmStarting;
|
||||
};
|
||||
|
||||
/// This is an internal structure.
|
||||
struct b2Position
|
||||
{
|
||||
b2Vec2 c;
|
||||
float32 a;
|
||||
};
|
||||
|
||||
/// This is an internal structure.
|
||||
struct b2Velocity
|
||||
{
|
||||
b2Vec2 v;
|
||||
float32 w;
|
||||
};
|
||||
|
||||
/// Solver Data
|
||||
struct b2SolverData
|
||||
{
|
||||
b2TimeStep step;
|
||||
b2Position* positions;
|
||||
b2Velocity* velocities;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
2632
deps/juce/modules/juce_box2d/box2d/Dynamics/b2World.cpp
vendored
2632
deps/juce/modules/juce_box2d/box2d/Dynamics/b2World.cpp
vendored
File diff suppressed because it is too large
Load Diff
@@ -1,349 +1,349 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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"
|
||||
#include "b2TimeStep.h"
|
||||
|
||||
struct b2AABB;
|
||||
struct b2BodyDef;
|
||||
struct b2Color;
|
||||
struct b2JointDef;
|
||||
class b2Body;
|
||||
class b2Draw;
|
||||
class b2Fixture;
|
||||
class b2Joint;
|
||||
|
||||
/// 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 gravity the world gravity vector.
|
||||
b2World(const b2Vec2& gravity);
|
||||
|
||||
/// Destruct the world. All physics entities are destroyed and all heap memory is released.
|
||||
~b2World();
|
||||
|
||||
/// Register a destruction listener. The listener is owned by you and must
|
||||
/// remain in scope.
|
||||
void SetDestructionListener(b2DestructionListener* listener);
|
||||
|
||||
/// Register a contact filter to provide specific control over collision.
|
||||
/// Otherwise the default filter is used (b2_defaultFilter). The listener is
|
||||
/// owned by you and must remain in scope.
|
||||
void SetContactFilter(b2ContactFilter* filter);
|
||||
|
||||
/// Register a contact event listener. The listener is owned by you and must
|
||||
/// remain in scope.
|
||||
void SetContactListener(b2ContactListener* listener);
|
||||
|
||||
/// Register a routine for debug drawing. The debug draw functions are called
|
||||
/// inside with b2World::DrawDebugData method. The debug draw object is owned
|
||||
/// by you and must remain in scope.
|
||||
void SetDebugDraw(b2Draw* 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);
|
||||
|
||||
/// 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 velocityIterations for the velocity constraint solver.
|
||||
/// @param positionIterations for the position constraint solver.
|
||||
void Step( float32 timeStep,
|
||||
juce::int32 velocityIterations,
|
||||
juce::int32 positionIterations);
|
||||
|
||||
/// Manually clear the force buffer on all bodies. By default, forces are cleared automatically
|
||||
/// after each call to Step. The default behavior is modified by calling SetAutoClearForces.
|
||||
/// The purpose of this function is to support sub-stepping. Sub-stepping is often used to maintain
|
||||
/// a fixed sized time step under a variable frame-rate.
|
||||
/// When you perform sub-stepping you will disable auto clearing of forces and instead call
|
||||
/// ClearForces after all sub-steps are complete in one pass of your game loop.
|
||||
/// @see SetAutoClearForces
|
||||
void ClearForces();
|
||||
|
||||
/// Call this to draw shapes and other debug draw data.
|
||||
void DrawDebugData();
|
||||
|
||||
/// Query the world for all fixtures that potentially overlap the
|
||||
/// provided AABB.
|
||||
/// @param callback a user implemented callback class.
|
||||
/// @param aabb the query box.
|
||||
void QueryAABB(b2QueryCallback* callback, const b2AABB& aabb) const;
|
||||
|
||||
/// Ray-cast the world for all fixtures in the path of the ray. Your callback
|
||||
/// controls whether you get the closest point, any point, or n-points.
|
||||
/// The ray-cast ignores shapes that contain the starting point.
|
||||
/// @param callback a user implemented callback class.
|
||||
/// @param point1 the ray starting point
|
||||
/// @param point2 the ray ending point
|
||||
void RayCast(b2RayCastCallback* callback, const b2Vec2& point1, const b2Vec2& point2) const;
|
||||
|
||||
/// 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();
|
||||
const b2Body* GetBodyList() const;
|
||||
|
||||
/// 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();
|
||||
const b2Joint* GetJointList() const;
|
||||
|
||||
/// Get the world contact list. With the returned contact, use b2Contact::GetNext to get
|
||||
/// the next contact in the world list. A NULL contact indicates the end of the list.
|
||||
/// @return the head of the world contact list.
|
||||
/// @warning contacts are created and destroyed in the middle of a time step.
|
||||
/// Use b2ContactListener to avoid missing contacts.
|
||||
b2Contact* GetContactList();
|
||||
const b2Contact* GetContactList() const;
|
||||
|
||||
/// Enable/disable sleep.
|
||||
void SetAllowSleeping(bool flag);
|
||||
bool GetAllowSleeping() const { return m_allowSleep; }
|
||||
|
||||
/// Enable/disable warm starting. For testing.
|
||||
void SetWarmStarting(bool flag) { m_warmStarting = flag; }
|
||||
bool GetWarmStarting() const { return m_warmStarting; }
|
||||
|
||||
/// Enable/disable continuous physics. For testing.
|
||||
void SetContinuousPhysics(bool flag) { m_continuousPhysics = flag; }
|
||||
bool GetContinuousPhysics() const { return m_continuousPhysics; }
|
||||
|
||||
/// Enable/disable single stepped continuous physics. For testing.
|
||||
void SetSubStepping(bool flag) { m_subStepping = flag; }
|
||||
bool GetSubStepping() const { return m_subStepping; }
|
||||
|
||||
/// Get the number of broad-phase proxies.
|
||||
juce::int32 GetProxyCount() const;
|
||||
|
||||
/// Get the number of bodies.
|
||||
juce::int32 GetBodyCount() const;
|
||||
|
||||
/// Get the number of joints.
|
||||
juce::int32 GetJointCount() const;
|
||||
|
||||
/// Get the number of contacts (each may have 0 or more contact points).
|
||||
juce::int32 GetContactCount() const;
|
||||
|
||||
/// Get the height of the dynamic tree.
|
||||
juce::int32 GetTreeHeight() const;
|
||||
|
||||
/// Get the balance of the dynamic tree.
|
||||
juce::int32 GetTreeBalance() const;
|
||||
|
||||
/// Get the quality metric of the dynamic tree. The smaller the better.
|
||||
/// The minimum is 1.
|
||||
float32 GetTreeQuality() const;
|
||||
|
||||
/// Change the global gravity vector.
|
||||
void SetGravity(const b2Vec2& gravity);
|
||||
|
||||
/// Get the global gravity vector.
|
||||
b2Vec2 GetGravity() const;
|
||||
|
||||
/// Is the world locked (in the middle of a time step).
|
||||
bool IsLocked() const;
|
||||
|
||||
/// Set flag to control automatic clearing of forces after each time step.
|
||||
void SetAutoClearForces(bool flag);
|
||||
|
||||
/// Get the flag that controls automatic clearing of forces after each time step.
|
||||
bool GetAutoClearForces() const;
|
||||
|
||||
/// Get the contact manager for testing.
|
||||
const b2ContactManager& GetContactManager() const;
|
||||
|
||||
/// Get the current profile.
|
||||
const b2Profile& GetProfile() const;
|
||||
|
||||
/// Dump the world into the log file.
|
||||
/// @warning this should be called outside of a time step.
|
||||
void Dump();
|
||||
|
||||
private:
|
||||
|
||||
// m_flags
|
||||
enum
|
||||
{
|
||||
e_newFixture = 0x0001,
|
||||
e_locked = 0x0002,
|
||||
e_clearForces = 0x0004
|
||||
};
|
||||
|
||||
friend class b2Body;
|
||||
friend class b2Fixture;
|
||||
friend class b2ContactManager;
|
||||
friend class b2Controller;
|
||||
|
||||
void Solve(const b2TimeStep& step);
|
||||
void SolveTOI(const b2TimeStep& step);
|
||||
|
||||
void DrawJoint(b2Joint* joint);
|
||||
void DrawShape(b2Fixture* shape, const b2Transform& xf, const b2Color& color);
|
||||
|
||||
b2BlockAllocator m_blockAllocator;
|
||||
b2StackAllocator m_stackAllocator;
|
||||
|
||||
juce::int32 m_flags;
|
||||
|
||||
b2ContactManager m_contactManager;
|
||||
|
||||
b2Body* m_bodyList;
|
||||
b2Joint* m_jointList;
|
||||
|
||||
juce::int32 m_bodyCount;
|
||||
juce::int32 m_jointCount;
|
||||
|
||||
b2Vec2 m_gravity;
|
||||
bool m_allowSleep;
|
||||
|
||||
b2DestructionListener* m_destructionListener;
|
||||
b2Draw* m_debugDraw;
|
||||
|
||||
// This is used to compute the time step ratio to
|
||||
// support a variable time step.
|
||||
float32 m_inv_dt0;
|
||||
|
||||
// These are for debugging the solver.
|
||||
bool m_warmStarting;
|
||||
bool m_continuousPhysics;
|
||||
bool m_subStepping;
|
||||
|
||||
bool m_stepComplete;
|
||||
|
||||
b2Profile m_profile;
|
||||
};
|
||||
|
||||
inline b2Body* b2World::GetBodyList()
|
||||
{
|
||||
return m_bodyList;
|
||||
}
|
||||
|
||||
inline const b2Body* b2World::GetBodyList() const
|
||||
{
|
||||
return m_bodyList;
|
||||
}
|
||||
|
||||
inline b2Joint* b2World::GetJointList()
|
||||
{
|
||||
return m_jointList;
|
||||
}
|
||||
|
||||
inline const b2Joint* b2World::GetJointList() const
|
||||
{
|
||||
return m_jointList;
|
||||
}
|
||||
|
||||
inline b2Contact* b2World::GetContactList()
|
||||
{
|
||||
return m_contactManager.m_contactList;
|
||||
}
|
||||
|
||||
inline const b2Contact* b2World::GetContactList() const
|
||||
{
|
||||
return m_contactManager.m_contactList;
|
||||
}
|
||||
|
||||
inline juce::int32 b2World::GetBodyCount() const
|
||||
{
|
||||
return m_bodyCount;
|
||||
}
|
||||
|
||||
inline juce::int32 b2World::GetJointCount() const
|
||||
{
|
||||
return m_jointCount;
|
||||
}
|
||||
|
||||
inline juce::int32 b2World::GetContactCount() const
|
||||
{
|
||||
return m_contactManager.m_contactCount;
|
||||
}
|
||||
|
||||
inline void b2World::SetGravity(const b2Vec2& gravity)
|
||||
{
|
||||
m_gravity = gravity;
|
||||
}
|
||||
|
||||
inline b2Vec2 b2World::GetGravity() const
|
||||
{
|
||||
return m_gravity;
|
||||
}
|
||||
|
||||
inline bool b2World::IsLocked() const
|
||||
{
|
||||
return (m_flags & e_locked) == e_locked;
|
||||
}
|
||||
|
||||
inline void b2World::SetAutoClearForces(bool flag)
|
||||
{
|
||||
if (flag)
|
||||
{
|
||||
m_flags |= e_clearForces;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_flags &= ~e_clearForces;
|
||||
}
|
||||
}
|
||||
|
||||
/// Get the flag that controls automatic clearing of forces after each time step.
|
||||
inline bool b2World::GetAutoClearForces() const
|
||||
{
|
||||
return (m_flags & e_clearForces) == e_clearForces;
|
||||
}
|
||||
|
||||
inline const b2ContactManager& b2World::GetContactManager() const
|
||||
{
|
||||
return m_contactManager;
|
||||
}
|
||||
|
||||
inline const b2Profile& b2World::GetProfile() const
|
||||
{
|
||||
return m_profile;
|
||||
}
|
||||
|
||||
#endif
|
||||
/*
|
||||
* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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"
|
||||
#include "b2TimeStep.h"
|
||||
|
||||
struct b2AABB;
|
||||
struct b2BodyDef;
|
||||
struct b2Color;
|
||||
struct b2JointDef;
|
||||
class b2Body;
|
||||
class b2Draw;
|
||||
class b2Fixture;
|
||||
class b2Joint;
|
||||
|
||||
/// 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 gravity the world gravity vector.
|
||||
b2World(const b2Vec2& gravity);
|
||||
|
||||
/// Destruct the world. All physics entities are destroyed and all heap memory is released.
|
||||
~b2World();
|
||||
|
||||
/// Register a destruction listener. The listener is owned by you and must
|
||||
/// remain in scope.
|
||||
void SetDestructionListener(b2DestructionListener* listener);
|
||||
|
||||
/// Register a contact filter to provide specific control over collision.
|
||||
/// Otherwise the default filter is used (b2_defaultFilter). The listener is
|
||||
/// owned by you and must remain in scope.
|
||||
void SetContactFilter(b2ContactFilter* filter);
|
||||
|
||||
/// Register a contact event listener. The listener is owned by you and must
|
||||
/// remain in scope.
|
||||
void SetContactListener(b2ContactListener* listener);
|
||||
|
||||
/// Register a routine for debug drawing. The debug draw functions are called
|
||||
/// inside with b2World::DrawDebugData method. The debug draw object is owned
|
||||
/// by you and must remain in scope.
|
||||
void SetDebugDraw(b2Draw* 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);
|
||||
|
||||
/// 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 velocityIterations for the velocity constraint solver.
|
||||
/// @param positionIterations for the position constraint solver.
|
||||
void Step( float32 timeStep,
|
||||
juce::int32 velocityIterations,
|
||||
juce::int32 positionIterations);
|
||||
|
||||
/// Manually clear the force buffer on all bodies. By default, forces are cleared automatically
|
||||
/// after each call to Step. The default behavior is modified by calling SetAutoClearForces.
|
||||
/// The purpose of this function is to support sub-stepping. Sub-stepping is often used to maintain
|
||||
/// a fixed sized time step under a variable frame-rate.
|
||||
/// When you perform sub-stepping you will disable auto clearing of forces and instead call
|
||||
/// ClearForces after all sub-steps are complete in one pass of your game loop.
|
||||
/// @see SetAutoClearForces
|
||||
void ClearForces();
|
||||
|
||||
/// Call this to draw shapes and other debug draw data.
|
||||
void DrawDebugData();
|
||||
|
||||
/// Query the world for all fixtures that potentially overlap the
|
||||
/// provided AABB.
|
||||
/// @param callback a user implemented callback class.
|
||||
/// @param aabb the query box.
|
||||
void QueryAABB(b2QueryCallback* callback, const b2AABB& aabb) const;
|
||||
|
||||
/// Ray-cast the world for all fixtures in the path of the ray. Your callback
|
||||
/// controls whether you get the closest point, any point, or n-points.
|
||||
/// The ray-cast ignores shapes that contain the starting point.
|
||||
/// @param callback a user implemented callback class.
|
||||
/// @param point1 the ray starting point
|
||||
/// @param point2 the ray ending point
|
||||
void RayCast(b2RayCastCallback* callback, const b2Vec2& point1, const b2Vec2& point2) const;
|
||||
|
||||
/// 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();
|
||||
const b2Body* GetBodyList() const;
|
||||
|
||||
/// 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();
|
||||
const b2Joint* GetJointList() const;
|
||||
|
||||
/// Get the world contact list. With the returned contact, use b2Contact::GetNext to get
|
||||
/// the next contact in the world list. A NULL contact indicates the end of the list.
|
||||
/// @return the head of the world contact list.
|
||||
/// @warning contacts are created and destroyed in the middle of a time step.
|
||||
/// Use b2ContactListener to avoid missing contacts.
|
||||
b2Contact* GetContactList();
|
||||
const b2Contact* GetContactList() const;
|
||||
|
||||
/// Enable/disable sleep.
|
||||
void SetAllowSleeping(bool flag);
|
||||
bool GetAllowSleeping() const { return m_allowSleep; }
|
||||
|
||||
/// Enable/disable warm starting. For testing.
|
||||
void SetWarmStarting(bool flag) { m_warmStarting = flag; }
|
||||
bool GetWarmStarting() const { return m_warmStarting; }
|
||||
|
||||
/// Enable/disable continuous physics. For testing.
|
||||
void SetContinuousPhysics(bool flag) { m_continuousPhysics = flag; }
|
||||
bool GetContinuousPhysics() const { return m_continuousPhysics; }
|
||||
|
||||
/// Enable/disable single stepped continuous physics. For testing.
|
||||
void SetSubStepping(bool flag) { m_subStepping = flag; }
|
||||
bool GetSubStepping() const { return m_subStepping; }
|
||||
|
||||
/// Get the number of broad-phase proxies.
|
||||
juce::int32 GetProxyCount() const;
|
||||
|
||||
/// Get the number of bodies.
|
||||
juce::int32 GetBodyCount() const;
|
||||
|
||||
/// Get the number of joints.
|
||||
juce::int32 GetJointCount() const;
|
||||
|
||||
/// Get the number of contacts (each may have 0 or more contact points).
|
||||
juce::int32 GetContactCount() const;
|
||||
|
||||
/// Get the height of the dynamic tree.
|
||||
juce::int32 GetTreeHeight() const;
|
||||
|
||||
/// Get the balance of the dynamic tree.
|
||||
juce::int32 GetTreeBalance() const;
|
||||
|
||||
/// Get the quality metric of the dynamic tree. The smaller the better.
|
||||
/// The minimum is 1.
|
||||
float32 GetTreeQuality() const;
|
||||
|
||||
/// Change the global gravity vector.
|
||||
void SetGravity(const b2Vec2& gravity);
|
||||
|
||||
/// Get the global gravity vector.
|
||||
b2Vec2 GetGravity() const;
|
||||
|
||||
/// Is the world locked (in the middle of a time step).
|
||||
bool IsLocked() const;
|
||||
|
||||
/// Set flag to control automatic clearing of forces after each time step.
|
||||
void SetAutoClearForces(bool flag);
|
||||
|
||||
/// Get the flag that controls automatic clearing of forces after each time step.
|
||||
bool GetAutoClearForces() const;
|
||||
|
||||
/// Get the contact manager for testing.
|
||||
const b2ContactManager& GetContactManager() const;
|
||||
|
||||
/// Get the current profile.
|
||||
const b2Profile& GetProfile() const;
|
||||
|
||||
/// Dump the world into the log file.
|
||||
/// @warning this should be called outside of a time step.
|
||||
void Dump();
|
||||
|
||||
private:
|
||||
|
||||
// m_flags
|
||||
enum
|
||||
{
|
||||
e_newFixture = 0x0001,
|
||||
e_locked = 0x0002,
|
||||
e_clearForces = 0x0004
|
||||
};
|
||||
|
||||
friend class b2Body;
|
||||
friend class b2Fixture;
|
||||
friend class b2ContactManager;
|
||||
friend class b2Controller;
|
||||
|
||||
void Solve(const b2TimeStep& step);
|
||||
void SolveTOI(const b2TimeStep& step);
|
||||
|
||||
void DrawJoint(b2Joint* joint);
|
||||
void DrawShape(b2Fixture* shape, const b2Transform& xf, const b2Color& color);
|
||||
|
||||
b2BlockAllocator m_blockAllocator;
|
||||
b2StackAllocator m_stackAllocator;
|
||||
|
||||
juce::int32 m_flags;
|
||||
|
||||
b2ContactManager m_contactManager;
|
||||
|
||||
b2Body* m_bodyList;
|
||||
b2Joint* m_jointList;
|
||||
|
||||
juce::int32 m_bodyCount;
|
||||
juce::int32 m_jointCount;
|
||||
|
||||
b2Vec2 m_gravity;
|
||||
bool m_allowSleep;
|
||||
|
||||
b2DestructionListener* m_destructionListener;
|
||||
b2Draw* m_debugDraw;
|
||||
|
||||
// This is used to compute the time step ratio to
|
||||
// support a variable time step.
|
||||
float32 m_inv_dt0;
|
||||
|
||||
// These are for debugging the solver.
|
||||
bool m_warmStarting;
|
||||
bool m_continuousPhysics;
|
||||
bool m_subStepping;
|
||||
|
||||
bool m_stepComplete;
|
||||
|
||||
b2Profile m_profile;
|
||||
};
|
||||
|
||||
inline b2Body* b2World::GetBodyList()
|
||||
{
|
||||
return m_bodyList;
|
||||
}
|
||||
|
||||
inline const b2Body* b2World::GetBodyList() const
|
||||
{
|
||||
return m_bodyList;
|
||||
}
|
||||
|
||||
inline b2Joint* b2World::GetJointList()
|
||||
{
|
||||
return m_jointList;
|
||||
}
|
||||
|
||||
inline const b2Joint* b2World::GetJointList() const
|
||||
{
|
||||
return m_jointList;
|
||||
}
|
||||
|
||||
inline b2Contact* b2World::GetContactList()
|
||||
{
|
||||
return m_contactManager.m_contactList;
|
||||
}
|
||||
|
||||
inline const b2Contact* b2World::GetContactList() const
|
||||
{
|
||||
return m_contactManager.m_contactList;
|
||||
}
|
||||
|
||||
inline juce::int32 b2World::GetBodyCount() const
|
||||
{
|
||||
return m_bodyCount;
|
||||
}
|
||||
|
||||
inline juce::int32 b2World::GetJointCount() const
|
||||
{
|
||||
return m_jointCount;
|
||||
}
|
||||
|
||||
inline juce::int32 b2World::GetContactCount() const
|
||||
{
|
||||
return m_contactManager.m_contactCount;
|
||||
}
|
||||
|
||||
inline void b2World::SetGravity(const b2Vec2& gravity)
|
||||
{
|
||||
m_gravity = gravity;
|
||||
}
|
||||
|
||||
inline b2Vec2 b2World::GetGravity() const
|
||||
{
|
||||
return m_gravity;
|
||||
}
|
||||
|
||||
inline bool b2World::IsLocked() const
|
||||
{
|
||||
return (m_flags & e_locked) == e_locked;
|
||||
}
|
||||
|
||||
inline void b2World::SetAutoClearForces(bool flag)
|
||||
{
|
||||
if (flag)
|
||||
{
|
||||
m_flags |= e_clearForces;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_flags &= ~e_clearForces;
|
||||
}
|
||||
}
|
||||
|
||||
/// Get the flag that controls automatic clearing of forces after each time step.
|
||||
inline bool b2World::GetAutoClearForces() const
|
||||
{
|
||||
return (m_flags & e_clearForces) == e_clearForces;
|
||||
}
|
||||
|
||||
inline const b2ContactManager& b2World::GetContactManager() const
|
||||
{
|
||||
return m_contactManager;
|
||||
}
|
||||
|
||||
inline const b2Profile& b2World::GetProfile() const
|
||||
{
|
||||
return m_profile;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,36 +1,36 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "b2Fixture.h"
|
||||
|
||||
// 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(b2Fixture* fixtureA, b2Fixture* fixtureB)
|
||||
{
|
||||
const b2Filter& filterA = fixtureA->GetFilterData();
|
||||
const b2Filter& filterB = fixtureB->GetFilterData();
|
||||
|
||||
if (filterA.groupIndex == filterB.groupIndex && filterA.groupIndex != 0)
|
||||
{
|
||||
return filterA.groupIndex > 0;
|
||||
}
|
||||
|
||||
bool collide = (filterA.maskBits & filterB.categoryBits) != 0 && (filterA.categoryBits & filterB.maskBits) != 0;
|
||||
return collide;
|
||||
}
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 "b2Fixture.h"
|
||||
|
||||
// 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(b2Fixture* fixtureA, b2Fixture* fixtureB)
|
||||
{
|
||||
const b2Filter& filterA = fixtureA->GetFilterData();
|
||||
const b2Filter& filterB = fixtureB->GetFilterData();
|
||||
|
||||
if (filterA.groupIndex == filterB.groupIndex && filterA.groupIndex != 0)
|
||||
{
|
||||
return filterA.groupIndex > 0;
|
||||
}
|
||||
|
||||
bool collide = (filterA.maskBits & filterB.categoryBits) != 0 && (filterA.categoryBits & filterB.maskBits) != 0;
|
||||
return collide;
|
||||
}
|
||||
|
||||
@@ -1,155 +1,155 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 b2Transform;
|
||||
class b2Fixture;
|
||||
class b2Body;
|
||||
class b2Joint;
|
||||
class b2Contact;
|
||||
struct b2ContactResult;
|
||||
struct b2Manifold;
|
||||
|
||||
/// Joints and fixtures 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 fixture is about to be destroyed due
|
||||
/// to the destruction of its parent body.
|
||||
virtual void SayGoodbye(b2Fixture* fixture) = 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(b2Fixture* fixtureA, b2Fixture* fixtureB);
|
||||
};
|
||||
|
||||
/// Contact impulses for reporting. Impulses are used instead of forces because
|
||||
/// sub-step forces may approach infinity for rigid body collisions. These
|
||||
/// match up one-to-one with the contact points in b2Manifold.
|
||||
struct b2ContactImpulse
|
||||
{
|
||||
float32 normalImpulses[b2_maxManifoldPoints];
|
||||
float32 tangentImpulses[b2_maxManifoldPoints];
|
||||
juce::int32 count;
|
||||
};
|
||||
|
||||
/// Implement this class to get contact information. 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 You cannot create/destroy Box2D entities inside these callbacks.
|
||||
class b2ContactListener
|
||||
{
|
||||
public:
|
||||
virtual ~b2ContactListener() {}
|
||||
|
||||
/// Called when two fixtures begin to touch.
|
||||
virtual void BeginContact(b2Contact* contact) { B2_NOT_USED(contact); }
|
||||
|
||||
/// Called when two fixtures cease to touch.
|
||||
virtual void EndContact(b2Contact* contact) { B2_NOT_USED(contact); }
|
||||
|
||||
/// This is called after a contact is updated. This allows you to inspect a
|
||||
/// contact before it goes to the solver. If you are careful, you can modify the
|
||||
/// contact manifold (e.g. disable contact).
|
||||
/// A copy of the old manifold is provided so that you can detect changes.
|
||||
/// Note: this is called only for awake bodies.
|
||||
/// Note: this is called even when the number of contact points is zero.
|
||||
/// Note: this is not called for sensors.
|
||||
/// Note: if you set the number of contact points to zero, you will not
|
||||
/// get an EndContact callback. However, you may get a BeginContact callback
|
||||
/// the next step.
|
||||
virtual void PreSolve(b2Contact* contact, const b2Manifold* oldManifold)
|
||||
{
|
||||
B2_NOT_USED(contact);
|
||||
B2_NOT_USED(oldManifold);
|
||||
}
|
||||
|
||||
/// This lets you inspect a contact after the solver is finished. This is useful
|
||||
/// for inspecting impulses.
|
||||
/// Note: the contact manifold does not include time of impact impulses, which can be
|
||||
/// arbitrarily large if the sub-step is small. Hence the impulse is provided explicitly
|
||||
/// in a separate data structure.
|
||||
/// Note: this is only called for contacts that are touching, solid, and awake.
|
||||
virtual void PostSolve(b2Contact* contact, const b2ContactImpulse* impulse)
|
||||
{
|
||||
B2_NOT_USED(contact);
|
||||
B2_NOT_USED(impulse);
|
||||
}
|
||||
};
|
||||
|
||||
/// Callback class for AABB queries.
|
||||
/// See b2World::Query
|
||||
class b2QueryCallback
|
||||
{
|
||||
public:
|
||||
virtual ~b2QueryCallback() {}
|
||||
|
||||
/// Called for each fixture found in the query AABB.
|
||||
/// @return false to terminate the query.
|
||||
virtual bool ReportFixture(b2Fixture* fixture) = 0;
|
||||
};
|
||||
|
||||
/// Callback class for ray casts.
|
||||
/// See b2World::RayCast
|
||||
class b2RayCastCallback
|
||||
{
|
||||
public:
|
||||
virtual ~b2RayCastCallback() {}
|
||||
|
||||
/// Called for each fixture found in the query. You control how the ray cast
|
||||
/// proceeds by returning a float:
|
||||
/// return -1: ignore this fixture and continue
|
||||
/// return 0: terminate the ray cast
|
||||
/// return fraction: clip the ray to this point
|
||||
/// return 1: don't clip the ray and continue
|
||||
/// @param fixture the fixture hit by the ray
|
||||
/// @param point the point of initial intersection
|
||||
/// @param normal the normal vector at the point of intersection
|
||||
/// @return -1 to filter, 0 to terminate, fraction to clip the ray for
|
||||
/// closest hit, 1 to continue
|
||||
virtual float32 ReportFixture( b2Fixture* fixture, const b2Vec2& point,
|
||||
const b2Vec2& normal, float32 fraction) = 0;
|
||||
};
|
||||
|
||||
#endif
|
||||
/*
|
||||
* Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
|
||||
*
|
||||
* 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 b2Transform;
|
||||
class b2Fixture;
|
||||
class b2Body;
|
||||
class b2Joint;
|
||||
class b2Contact;
|
||||
struct b2ContactResult;
|
||||
struct b2Manifold;
|
||||
|
||||
/// Joints and fixtures 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 fixture is about to be destroyed due
|
||||
/// to the destruction of its parent body.
|
||||
virtual void SayGoodbye(b2Fixture* fixture) = 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(b2Fixture* fixtureA, b2Fixture* fixtureB);
|
||||
};
|
||||
|
||||
/// Contact impulses for reporting. Impulses are used instead of forces because
|
||||
/// sub-step forces may approach infinity for rigid body collisions. These
|
||||
/// match up one-to-one with the contact points in b2Manifold.
|
||||
struct b2ContactImpulse
|
||||
{
|
||||
float32 normalImpulses[b2_maxManifoldPoints];
|
||||
float32 tangentImpulses[b2_maxManifoldPoints];
|
||||
juce::int32 count;
|
||||
};
|
||||
|
||||
/// Implement this class to get contact information. 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 You cannot create/destroy Box2D entities inside these callbacks.
|
||||
class b2ContactListener
|
||||
{
|
||||
public:
|
||||
virtual ~b2ContactListener() {}
|
||||
|
||||
/// Called when two fixtures begin to touch.
|
||||
virtual void BeginContact(b2Contact* contact) { B2_NOT_USED(contact); }
|
||||
|
||||
/// Called when two fixtures cease to touch.
|
||||
virtual void EndContact(b2Contact* contact) { B2_NOT_USED(contact); }
|
||||
|
||||
/// This is called after a contact is updated. This allows you to inspect a
|
||||
/// contact before it goes to the solver. If you are careful, you can modify the
|
||||
/// contact manifold (e.g. disable contact).
|
||||
/// A copy of the old manifold is provided so that you can detect changes.
|
||||
/// Note: this is called only for awake bodies.
|
||||
/// Note: this is called even when the number of contact points is zero.
|
||||
/// Note: this is not called for sensors.
|
||||
/// Note: if you set the number of contact points to zero, you will not
|
||||
/// get an EndContact callback. However, you may get a BeginContact callback
|
||||
/// the next step.
|
||||
virtual void PreSolve(b2Contact* contact, const b2Manifold* oldManifold)
|
||||
{
|
||||
B2_NOT_USED(contact);
|
||||
B2_NOT_USED(oldManifold);
|
||||
}
|
||||
|
||||
/// This lets you inspect a contact after the solver is finished. This is useful
|
||||
/// for inspecting impulses.
|
||||
/// Note: the contact manifold does not include time of impact impulses, which can be
|
||||
/// arbitrarily large if the sub-step is small. Hence the impulse is provided explicitly
|
||||
/// in a separate data structure.
|
||||
/// Note: this is only called for contacts that are touching, solid, and awake.
|
||||
virtual void PostSolve(b2Contact* contact, const b2ContactImpulse* impulse)
|
||||
{
|
||||
B2_NOT_USED(contact);
|
||||
B2_NOT_USED(impulse);
|
||||
}
|
||||
};
|
||||
|
||||
/// Callback class for AABB queries.
|
||||
/// See b2World::Query
|
||||
class b2QueryCallback
|
||||
{
|
||||
public:
|
||||
virtual ~b2QueryCallback() {}
|
||||
|
||||
/// Called for each fixture found in the query AABB.
|
||||
/// @return false to terminate the query.
|
||||
virtual bool ReportFixture(b2Fixture* fixture) = 0;
|
||||
};
|
||||
|
||||
/// Callback class for ray casts.
|
||||
/// See b2World::RayCast
|
||||
class b2RayCastCallback
|
||||
{
|
||||
public:
|
||||
virtual ~b2RayCastCallback() {}
|
||||
|
||||
/// Called for each fixture found in the query. You control how the ray cast
|
||||
/// proceeds by returning a float:
|
||||
/// return -1: ignore this fixture and continue
|
||||
/// return 0: terminate the ray cast
|
||||
/// return fraction: clip the ray to this point
|
||||
/// return 1: don't clip the ray and continue
|
||||
/// @param fixture the fixture hit by the ray
|
||||
/// @param point the point of initial intersection
|
||||
/// @param normal the normal vector at the point of intersection
|
||||
/// @return -1 to filter, 0 to terminate, fraction to clip the ray for
|
||||
/// closest hit, 1 to continue
|
||||
virtual float32 ReportFixture( b2Fixture* fixture, const b2Vec2& point,
|
||||
const b2Vec2& normal, float32 fraction) = 0;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
Reference in New Issue
Block a user