2013-09-09 10:29:02 +08:00
|
|
|
/****************************************************************************
|
2014-01-07 11:47:11 +08:00
|
|
|
Copyright (c) 2013 Chukong Technologies Inc.
|
2013-09-09 10:29:02 +08:00
|
|
|
|
|
|
|
http://www.cocos2d-x.org
|
|
|
|
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
|
|
in the Software without restriction, including without limitation the rights
|
|
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
|
|
all copies or substantial portions of the Software.
|
|
|
|
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
THE SOFTWARE.
|
|
|
|
****************************************************************************/
|
|
|
|
|
2014-04-27 01:35:57 +08:00
|
|
|
#include "physics/CCPhysicsWorld.h"
|
2013-12-26 23:55:05 +08:00
|
|
|
#if CC_USE_PHYSICS
|
2015-01-06 10:29:07 +08:00
|
|
|
#include <algorithm>
|
2013-11-06 15:43:29 +08:00
|
|
|
#include <climits>
|
|
|
|
|
2013-09-17 17:39:08 +08:00
|
|
|
#include "chipmunk.h"
|
2015-01-06 10:29:07 +08:00
|
|
|
#include "CCPhysicsBody.h"
|
|
|
|
#include "CCPhysicsShape.h"
|
2013-09-16 21:22:22 +08:00
|
|
|
#include "CCPhysicsContact.h"
|
2015-01-06 10:29:07 +08:00
|
|
|
#include "CCPhysicsJoint.h"
|
2013-10-18 15:34:13 +08:00
|
|
|
#include "CCPhysicsContact.h"
|
2015-01-06 10:29:07 +08:00
|
|
|
#include "CCPhysicsHelper.h"
|
2013-09-16 21:22:22 +08:00
|
|
|
|
2014-04-27 01:11:22 +08:00
|
|
|
#include "2d/CCDrawNode.h"
|
2014-05-02 07:42:35 +08:00
|
|
|
#include "2d/CCScene.h"
|
2014-04-30 08:37:36 +08:00
|
|
|
#include "base/CCDirector.h"
|
|
|
|
#include "base/CCEventDispatcher.h"
|
|
|
|
#include "base/CCEventCustom.h"
|
2013-09-09 10:29:02 +08:00
|
|
|
|
|
|
|
NS_CC_BEGIN
|
2013-11-27 17:33:33 +08:00
|
|
|
const float PHYSICS_INFINITY = INFINITY;
|
2013-11-01 16:26:03 +08:00
|
|
|
extern const char* PHYSICSCONTACT_EVENT_NAME;
|
2015-01-06 10:29:07 +08:00
|
|
|
extern std::unordered_map<cpShape*, PhysicsShape*> s_physicsShapeMap;
|
2013-11-01 16:26:03 +08:00
|
|
|
|
2013-12-06 11:46:13 +08:00
|
|
|
const int PhysicsWorld::DEBUGDRAW_NONE = 0x00;
|
|
|
|
const int PhysicsWorld::DEBUGDRAW_SHAPE = 0x01;
|
|
|
|
const int PhysicsWorld::DEBUGDRAW_JOINT = 0x02;
|
|
|
|
const int PhysicsWorld::DEBUGDRAW_CONTACT = 0x04;
|
|
|
|
const int PhysicsWorld::DEBUGDRAW_ALL = DEBUGDRAW_SHAPE | DEBUGDRAW_JOINT | DEBUGDRAW_CONTACT;
|
|
|
|
|
2013-10-21 23:16:21 +08:00
|
|
|
namespace
|
|
|
|
{
|
|
|
|
typedef struct RayCastCallbackInfo
|
|
|
|
{
|
|
|
|
PhysicsWorld* world;
|
2013-11-07 16:23:50 +08:00
|
|
|
PhysicsRayCastCallbackFunc func;
|
2014-05-15 01:07:09 +08:00
|
|
|
Vec2 p1;
|
|
|
|
Vec2 p2;
|
2013-10-21 23:16:21 +08:00
|
|
|
void* data;
|
|
|
|
}RayCastCallbackInfo;
|
|
|
|
|
|
|
|
typedef struct RectQueryCallbackInfo
|
|
|
|
{
|
|
|
|
PhysicsWorld* world;
|
2013-12-13 16:26:26 +08:00
|
|
|
PhysicsQueryRectCallbackFunc func;
|
2013-10-21 23:16:21 +08:00
|
|
|
void* data;
|
|
|
|
}RectQueryCallbackInfo;
|
2013-11-11 16:23:42 +08:00
|
|
|
|
|
|
|
typedef struct PointQueryCallbackInfo
|
|
|
|
{
|
|
|
|
PhysicsWorld* world;
|
2013-12-13 16:26:26 +08:00
|
|
|
PhysicsQueryPointCallbackFunc func;
|
2013-11-11 16:23:42 +08:00
|
|
|
void* data;
|
|
|
|
}PointQueryCallbackInfo;
|
2013-10-21 23:16:21 +08:00
|
|
|
}
|
2013-10-09 13:41:19 +08:00
|
|
|
|
2013-10-21 23:16:21 +08:00
|
|
|
class PhysicsWorldCallback
|
2013-09-09 10:29:02 +08:00
|
|
|
{
|
2013-10-21 23:16:21 +08:00
|
|
|
public:
|
|
|
|
static int collisionBeginCallbackFunc(cpArbiter *arb, struct cpSpace *space, PhysicsWorld *world);
|
|
|
|
static int collisionPreSolveCallbackFunc(cpArbiter *arb, cpSpace *space, PhysicsWorld *world);
|
|
|
|
static void collisionPostSolveCallbackFunc(cpArbiter *arb, cpSpace *space, PhysicsWorld *world);
|
|
|
|
static void collisionSeparateCallbackFunc(cpArbiter *arb, cpSpace *space, PhysicsWorld *world);
|
|
|
|
static void rayCastCallbackFunc(cpShape *shape, cpFloat t, cpVect n, RayCastCallbackInfo *info);
|
2013-11-18 03:10:13 +08:00
|
|
|
static void queryRectCallbackFunc(cpShape *shape, RectQueryCallbackInfo *info);
|
|
|
|
static void queryPointFunc(cpShape *shape, cpFloat distance, cpVect point, PointQueryCallbackInfo *info);
|
2013-12-07 10:48:02 +08:00
|
|
|
static void getShapesAtPointFunc(cpShape *shape, cpFloat distance, cpVect point, Vector<PhysicsShape*>* arr);
|
2013-09-09 10:29:02 +08:00
|
|
|
|
2013-10-22 18:00:24 +08:00
|
|
|
public:
|
2013-10-21 23:16:21 +08:00
|
|
|
static bool continues;
|
|
|
|
};
|
|
|
|
|
|
|
|
bool PhysicsWorldCallback::continues = true;
|
|
|
|
|
|
|
|
int PhysicsWorldCallback::collisionBeginCallbackFunc(cpArbiter *arb, struct cpSpace *space, PhysicsWorld *world)
|
|
|
|
{
|
2013-09-16 22:51:48 +08:00
|
|
|
CP_ARBITER_GET_SHAPES(arb, a, b);
|
2013-09-16 21:22:22 +08:00
|
|
|
|
2015-01-06 10:29:07 +08:00
|
|
|
auto ita = s_physicsShapeMap.find(a);
|
|
|
|
auto itb = s_physicsShapeMap.find(b);
|
|
|
|
CC_ASSERT(ita != s_physicsShapeMap.end() && itb != s_physicsShapeMap.end());
|
2013-09-16 21:22:22 +08:00
|
|
|
|
2015-01-06 10:29:07 +08:00
|
|
|
auto contact = PhysicsContact::construct(ita->second, itb->second);
|
2013-09-16 22:51:48 +08:00
|
|
|
arb->data = contact;
|
2013-10-25 10:31:22 +08:00
|
|
|
contact->_contactInfo = arb;
|
2013-09-16 22:51:48 +08:00
|
|
|
|
2013-10-25 10:31:22 +08:00
|
|
|
return world->collisionBeginCallback(*contact);
|
2013-09-16 22:51:48 +08:00
|
|
|
}
|
|
|
|
|
2013-10-21 23:16:21 +08:00
|
|
|
int PhysicsWorldCallback::collisionPreSolveCallbackFunc(cpArbiter *arb, cpSpace *space, PhysicsWorld *world)
|
2013-09-16 22:51:48 +08:00
|
|
|
{
|
2013-10-25 10:31:22 +08:00
|
|
|
return world->collisionPreSolveCallback(*static_cast<PhysicsContact*>(arb->data));
|
2013-09-16 22:51:48 +08:00
|
|
|
}
|
|
|
|
|
2013-10-21 23:16:21 +08:00
|
|
|
void PhysicsWorldCallback::collisionPostSolveCallbackFunc(cpArbiter *arb, cpSpace *space, PhysicsWorld *world)
|
2013-09-16 22:51:48 +08:00
|
|
|
{
|
2013-10-25 10:31:22 +08:00
|
|
|
world->collisionPostSolveCallback(*static_cast<PhysicsContact*>(arb->data));
|
2013-09-16 22:51:48 +08:00
|
|
|
}
|
|
|
|
|
2013-10-21 23:16:21 +08:00
|
|
|
void PhysicsWorldCallback::collisionSeparateCallbackFunc(cpArbiter *arb, cpSpace *space, PhysicsWorld *world)
|
2013-09-16 22:51:48 +08:00
|
|
|
{
|
|
|
|
PhysicsContact* contact = static_cast<PhysicsContact*>(arb->data);
|
|
|
|
|
|
|
|
world->collisionSeparateCallback(*contact);
|
|
|
|
|
|
|
|
delete contact;
|
2013-09-16 21:22:22 +08:00
|
|
|
}
|
2013-09-09 10:29:02 +08:00
|
|
|
|
2013-10-21 23:16:21 +08:00
|
|
|
void PhysicsWorldCallback::rayCastCallbackFunc(cpShape *shape, cpFloat t, cpVect n, RayCastCallbackInfo *info)
|
|
|
|
{
|
|
|
|
if (!PhysicsWorldCallback::continues)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-01-06 10:29:07 +08:00
|
|
|
auto it = s_physicsShapeMap.find(shape);
|
|
|
|
CC_ASSERT(it != s_physicsShapeMap.end());
|
2013-10-21 23:16:21 +08:00
|
|
|
|
2013-11-07 16:23:50 +08:00
|
|
|
PhysicsRayCastInfo callbackInfo =
|
2013-11-05 15:54:33 +08:00
|
|
|
{
|
2015-01-06 10:29:07 +08:00
|
|
|
it->second,
|
2013-11-05 15:54:33 +08:00
|
|
|
info->p1,
|
|
|
|
info->p2,
|
2014-05-15 01:07:09 +08:00
|
|
|
Vec2(info->p1.x+(info->p2.x-info->p1.x)*t, info->p1.y+(info->p2.y-info->p1.y)*t),
|
|
|
|
Vec2(n.x, n.y),
|
2013-11-05 15:54:33 +08:00
|
|
|
(float)t,
|
|
|
|
};
|
|
|
|
|
2013-11-07 16:23:50 +08:00
|
|
|
PhysicsWorldCallback::continues = info->func(*info->world, callbackInfo, info->data);
|
2013-10-21 23:16:21 +08:00
|
|
|
}
|
|
|
|
|
2013-11-18 03:10:13 +08:00
|
|
|
void PhysicsWorldCallback::queryRectCallbackFunc(cpShape *shape, RectQueryCallbackInfo *info)
|
2013-10-21 23:16:21 +08:00
|
|
|
{
|
2015-01-06 10:29:07 +08:00
|
|
|
auto it = s_physicsShapeMap.find(shape);
|
2013-10-21 23:16:21 +08:00
|
|
|
|
2015-01-06 10:29:07 +08:00
|
|
|
CC_ASSERT(it != s_physicsShapeMap.end());
|
2013-10-21 23:16:21 +08:00
|
|
|
|
|
|
|
if (!PhysicsWorldCallback::continues)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-01-06 10:29:07 +08:00
|
|
|
PhysicsWorldCallback::continues = info->func(*info->world, *it->second, info->data);
|
2013-10-21 23:16:21 +08:00
|
|
|
}
|
|
|
|
|
2013-12-07 10:48:02 +08:00
|
|
|
void PhysicsWorldCallback::getShapesAtPointFunc(cpShape *shape, cpFloat distance, cpVect point, Vector<PhysicsShape*>* arr)
|
2013-10-23 17:28:23 +08:00
|
|
|
{
|
2015-01-06 10:29:07 +08:00
|
|
|
auto it = s_physicsShapeMap.find(shape);
|
2013-10-23 17:28:23 +08:00
|
|
|
|
2015-01-06 10:29:07 +08:00
|
|
|
CC_ASSERT(it != s_physicsShapeMap.end());
|
2013-10-23 17:28:23 +08:00
|
|
|
|
2015-01-06 10:29:07 +08:00
|
|
|
arr->pushBack(it->second);
|
2013-10-23 17:28:23 +08:00
|
|
|
}
|
|
|
|
|
2013-11-18 03:10:13 +08:00
|
|
|
void PhysicsWorldCallback::queryPointFunc(cpShape *shape, cpFloat distance, cpVect point, PointQueryCallbackInfo *info)
|
2013-11-11 16:23:42 +08:00
|
|
|
{
|
2015-01-06 10:29:07 +08:00
|
|
|
auto it = s_physicsShapeMap.find(shape);
|
2013-11-11 16:23:42 +08:00
|
|
|
|
2015-01-06 10:29:07 +08:00
|
|
|
CC_ASSERT(it != s_physicsShapeMap.end());
|
2013-11-11 16:23:42 +08:00
|
|
|
|
2015-01-06 10:29:07 +08:00
|
|
|
PhysicsWorldCallback::continues = info->func(*info->world, *it->second, info->data);
|
2013-11-11 16:23:42 +08:00
|
|
|
}
|
|
|
|
|
2013-09-16 21:22:22 +08:00
|
|
|
void PhysicsWorld::debugDraw()
|
|
|
|
{
|
2013-11-08 14:25:03 +08:00
|
|
|
if (_debugDraw == nullptr)
|
|
|
|
{
|
2014-08-28 07:31:57 +08:00
|
|
|
_debugDraw = new (std::nothrow) PhysicsDebugDraw(*this);
|
2013-11-08 14:25:03 +08:00
|
|
|
}
|
|
|
|
|
2013-12-07 10:48:02 +08:00
|
|
|
if (_debugDraw && !_bodies.empty())
|
2013-09-16 21:22:22 +08:00
|
|
|
{
|
2013-11-08 14:25:03 +08:00
|
|
|
if (_debugDraw->begin())
|
2013-09-16 21:22:22 +08:00
|
|
|
{
|
2013-11-18 10:10:37 +08:00
|
|
|
if (_debugDrawMask & DEBUGDRAW_SHAPE)
|
2013-09-16 21:22:22 +08:00
|
|
|
{
|
2014-02-20 10:53:49 +08:00
|
|
|
for (Ref* obj : _bodies)
|
2013-11-08 14:25:03 +08:00
|
|
|
{
|
|
|
|
PhysicsBody* body = dynamic_cast<PhysicsBody*>(obj);
|
|
|
|
|
2014-03-13 20:56:51 +08:00
|
|
|
if (!body->isEnabled())
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2013-12-07 10:48:02 +08:00
|
|
|
for (auto& shape : body->getShapes())
|
2013-11-08 14:25:03 +08:00
|
|
|
{
|
|
|
|
_debugDraw->drawShape(*dynamic_cast<PhysicsShape*>(shape));
|
|
|
|
}
|
|
|
|
}
|
2013-09-16 21:22:22 +08:00
|
|
|
}
|
2013-10-29 17:31:35 +08:00
|
|
|
|
2013-11-18 10:10:37 +08:00
|
|
|
if (_debugDrawMask & DEBUGDRAW_JOINT)
|
2013-11-08 14:25:03 +08:00
|
|
|
{
|
|
|
|
for (auto joint : _joints)
|
|
|
|
{
|
|
|
|
_debugDraw->drawJoint(*joint);
|
|
|
|
}
|
|
|
|
}
|
2013-10-29 17:31:35 +08:00
|
|
|
|
2013-11-08 14:25:03 +08:00
|
|
|
_debugDraw->end();
|
2013-10-29 17:31:35 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-10-18 15:34:13 +08:00
|
|
|
int PhysicsWorld::collisionBeginCallback(PhysicsContact& contact)
|
2013-09-16 21:22:22 +08:00
|
|
|
{
|
2013-10-18 15:34:13 +08:00
|
|
|
bool ret = true;
|
2013-11-01 14:50:06 +08:00
|
|
|
|
2013-10-29 17:31:35 +08:00
|
|
|
PhysicsShape* shapeA = contact.getShapeA();
|
|
|
|
PhysicsShape* shapeB = contact.getShapeB();
|
|
|
|
PhysicsBody* bodyA = shapeA->getBody();
|
|
|
|
PhysicsBody* bodyB = shapeB->getBody();
|
2013-10-25 10:31:22 +08:00
|
|
|
std::vector<PhysicsJoint*> jointsA = bodyA->getJoints();
|
|
|
|
|
|
|
|
// check the joint is collision enable or not
|
|
|
|
for (PhysicsJoint* joint : jointsA)
|
|
|
|
{
|
2013-10-28 11:08:41 +08:00
|
|
|
if (std::find(_joints.begin(), _joints.end(), joint) == _joints.end())
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2013-11-06 15:43:29 +08:00
|
|
|
if (!joint->isCollisionEnabled())
|
2013-10-25 10:31:22 +08:00
|
|
|
{
|
2013-10-28 16:17:19 +08:00
|
|
|
PhysicsBody* body = joint->getBodyA() == bodyA ? joint->getBodyB() : joint->getBodyA();
|
2013-10-25 10:31:22 +08:00
|
|
|
|
|
|
|
if (body == bodyB)
|
|
|
|
{
|
2013-11-06 15:43:29 +08:00
|
|
|
contact.setNotificationEnable(false);
|
2013-10-25 10:31:22 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-10-18 15:34:13 +08:00
|
|
|
|
2013-10-25 10:31:22 +08:00
|
|
|
// bitmask check
|
2013-10-29 17:31:35 +08:00
|
|
|
if ((shapeA->getCategoryBitmask() & shapeB->getContactTestBitmask()) == 0
|
2014-02-25 10:24:20 +08:00
|
|
|
|| (shapeA->getContactTestBitmask() & shapeB->getCategoryBitmask()) == 0)
|
2013-09-16 21:22:22 +08:00
|
|
|
{
|
2013-11-06 15:43:29 +08:00
|
|
|
contact.setNotificationEnable(false);
|
2013-09-16 21:22:22 +08:00
|
|
|
}
|
|
|
|
|
2013-10-29 17:31:35 +08:00
|
|
|
if (shapeA->getGroup() != 0 && shapeA->getGroup() == shapeB->getGroup())
|
|
|
|
{
|
|
|
|
ret = shapeA->getGroup() > 0;
|
2013-11-01 16:26:03 +08:00
|
|
|
}
|
|
|
|
else
|
2013-10-18 15:34:13 +08:00
|
|
|
{
|
2013-10-29 17:31:35 +08:00
|
|
|
if ((shapeA->getCategoryBitmask() & shapeB->getCollisionBitmask()) == 0
|
|
|
|
|| (shapeB->getCategoryBitmask() & shapeA->getCollisionBitmask()) == 0)
|
|
|
|
{
|
|
|
|
ret = false;
|
|
|
|
}
|
2013-10-18 15:34:13 +08:00
|
|
|
}
|
|
|
|
|
2014-02-25 15:27:25 +08:00
|
|
|
if (contact.isNotificationEnabled())
|
|
|
|
{
|
|
|
|
contact.setEventCode(PhysicsContact::EventCode::BEGIN);
|
|
|
|
contact.setWorld(this);
|
2014-05-02 07:42:35 +08:00
|
|
|
_scene->getEventDispatcher()->dispatchEvent(&contact);
|
2014-02-25 15:27:25 +08:00
|
|
|
}
|
2013-10-18 15:34:13 +08:00
|
|
|
|
2013-11-01 14:50:06 +08:00
|
|
|
return ret ? contact.resetResult() : false;
|
2013-09-16 21:22:22 +08:00
|
|
|
}
|
2013-09-09 10:29:02 +08:00
|
|
|
|
2013-10-25 10:31:22 +08:00
|
|
|
int PhysicsWorld::collisionPreSolveCallback(PhysicsContact& contact)
|
2013-09-09 10:29:02 +08:00
|
|
|
{
|
2013-11-06 15:43:29 +08:00
|
|
|
if (!contact.isNotificationEnabled())
|
2013-11-01 16:26:03 +08:00
|
|
|
{
|
2013-11-05 15:54:33 +08:00
|
|
|
cpArbiterIgnore(static_cast<cpArbiter*>(contact._contactInfo));
|
2013-11-01 16:26:03 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2013-11-01 14:50:06 +08:00
|
|
|
contact.setEventCode(PhysicsContact::EventCode::PRESOLVE);
|
|
|
|
contact.setWorld(this);
|
2014-05-02 07:42:35 +08:00
|
|
|
_scene->getEventDispatcher()->dispatchEvent(&contact);
|
2013-10-18 15:34:13 +08:00
|
|
|
|
2013-11-01 14:50:06 +08:00
|
|
|
return contact.resetResult();
|
2013-09-16 21:22:22 +08:00
|
|
|
}
|
|
|
|
|
2013-10-25 10:31:22 +08:00
|
|
|
void PhysicsWorld::collisionPostSolveCallback(PhysicsContact& contact)
|
2013-09-16 21:22:22 +08:00
|
|
|
{
|
2013-11-06 15:43:29 +08:00
|
|
|
if (!contact.isNotificationEnabled())
|
2013-11-01 16:26:03 +08:00
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-11-01 14:50:06 +08:00
|
|
|
contact.setEventCode(PhysicsContact::EventCode::POSTSOLVE);
|
|
|
|
contact.setWorld(this);
|
2014-05-02 07:42:35 +08:00
|
|
|
_scene->getEventDispatcher()->dispatchEvent(&contact);
|
2013-09-16 21:22:22 +08:00
|
|
|
}
|
|
|
|
|
2013-10-18 15:34:13 +08:00
|
|
|
void PhysicsWorld::collisionSeparateCallback(PhysicsContact& contact)
|
2013-09-16 21:22:22 +08:00
|
|
|
{
|
2013-11-06 15:43:29 +08:00
|
|
|
if (!contact.isNotificationEnabled())
|
2013-11-01 16:26:03 +08:00
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-11-01 14:50:06 +08:00
|
|
|
contact.setEventCode(PhysicsContact::EventCode::SEPERATE);
|
|
|
|
contact.setWorld(this);
|
2014-05-02 07:42:35 +08:00
|
|
|
_scene->getEventDispatcher()->dispatchEvent(&contact);
|
2013-09-16 21:22:22 +08:00
|
|
|
}
|
|
|
|
|
2014-05-15 01:07:09 +08:00
|
|
|
void PhysicsWorld::rayCast(PhysicsRayCastCallbackFunc func, const Vec2& point1, const Vec2& point2, void* data)
|
2013-09-17 14:31:43 +08:00
|
|
|
{
|
2013-11-25 17:57:06 +08:00
|
|
|
CCASSERT(func != nullptr, "func shouldn't be nullptr");
|
|
|
|
|
|
|
|
if (func != nullptr)
|
2013-10-22 18:00:24 +08:00
|
|
|
{
|
2015-01-16 14:15:06 +08:00
|
|
|
if (!_delayAddBodies.empty() || !_delayRemoveBodies.empty())
|
|
|
|
{
|
|
|
|
_scene->updatePhysicsBodyTransform(_scene, _scene->getNodeToParentTransform(), 0, 1.0f, 1.0f);
|
|
|
|
updateBodies();
|
|
|
|
}
|
2013-11-07 16:23:50 +08:00
|
|
|
RayCastCallbackInfo info = { this, func, point1, point2, data };
|
2013-10-22 18:00:24 +08:00
|
|
|
|
|
|
|
PhysicsWorldCallback::continues = true;
|
2015-01-06 10:29:07 +08:00
|
|
|
cpSpaceSegmentQuery(_cpSpace,
|
2013-10-22 18:00:24 +08:00
|
|
|
PhysicsHelper::point2cpv(point1),
|
|
|
|
PhysicsHelper::point2cpv(point2),
|
|
|
|
CP_ALL_LAYERS,
|
|
|
|
CP_NO_GROUP,
|
|
|
|
(cpSpaceSegmentQueryFunc)PhysicsWorldCallback::rayCastCallbackFunc,
|
|
|
|
&info);
|
|
|
|
}
|
2013-10-21 23:16:21 +08:00
|
|
|
}
|
|
|
|
|
2013-12-13 16:26:26 +08:00
|
|
|
void PhysicsWorld::queryRect(PhysicsQueryRectCallbackFunc func, const Rect& rect, void* data)
|
2013-10-21 23:16:21 +08:00
|
|
|
{
|
2013-11-11 15:31:20 +08:00
|
|
|
CCASSERT(func != nullptr, "func shouldn't be nullptr");
|
2013-11-05 15:54:33 +08:00
|
|
|
|
2013-11-07 16:23:50 +08:00
|
|
|
if (func != nullptr)
|
2013-10-22 18:00:24 +08:00
|
|
|
{
|
2015-01-16 14:15:06 +08:00
|
|
|
if (!_delayAddBodies.empty() || !_delayRemoveBodies.empty())
|
|
|
|
{
|
|
|
|
_scene->updatePhysicsBodyTransform(_scene, _scene->getNodeToParentTransform(), 0, 1.0f, 1.0f);
|
|
|
|
updateBodies();
|
|
|
|
}
|
2013-11-07 16:23:50 +08:00
|
|
|
RectQueryCallbackInfo info = {this, func, data};
|
2013-10-22 18:00:24 +08:00
|
|
|
|
|
|
|
PhysicsWorldCallback::continues = true;
|
2015-01-06 10:29:07 +08:00
|
|
|
cpSpaceBBQuery(_cpSpace,
|
2013-10-22 18:00:24 +08:00
|
|
|
PhysicsHelper::rect2cpbb(rect),
|
|
|
|
CP_ALL_LAYERS,
|
|
|
|
CP_NO_GROUP,
|
2013-11-18 03:10:13 +08:00
|
|
|
(cpSpaceBBQueryFunc)PhysicsWorldCallback::queryRectCallbackFunc,
|
2013-10-22 18:00:24 +08:00
|
|
|
&info);
|
|
|
|
}
|
2013-10-21 23:16:21 +08:00
|
|
|
}
|
|
|
|
|
2014-05-15 01:07:09 +08:00
|
|
|
void PhysicsWorld::queryPoint(PhysicsQueryPointCallbackFunc func, const Vec2& point, void* data)
|
2013-11-11 15:03:17 +08:00
|
|
|
{
|
2013-11-11 15:31:20 +08:00
|
|
|
CCASSERT(func != nullptr, "func shouldn't be nullptr");
|
2013-11-11 15:03:17 +08:00
|
|
|
|
|
|
|
if (func != nullptr)
|
|
|
|
{
|
2015-01-16 14:15:06 +08:00
|
|
|
if (!_delayAddBodies.empty() || !_delayRemoveBodies.empty())
|
|
|
|
{
|
|
|
|
_scene->updatePhysicsBodyTransform(_scene, _scene->getNodeToParentTransform(), 0, 1.0f, 1.0f);
|
|
|
|
updateBodies();
|
|
|
|
}
|
2013-11-11 16:23:42 +08:00
|
|
|
PointQueryCallbackInfo info = {this, func, data};
|
2013-11-11 15:03:17 +08:00
|
|
|
|
|
|
|
PhysicsWorldCallback::continues = true;
|
2015-01-06 10:29:07 +08:00
|
|
|
cpSpaceNearestPointQuery(_cpSpace,
|
2013-11-11 16:23:42 +08:00
|
|
|
PhysicsHelper::point2cpv(point),
|
|
|
|
0,
|
|
|
|
CP_ALL_LAYERS,
|
|
|
|
CP_NO_GROUP,
|
2013-11-18 03:10:13 +08:00
|
|
|
(cpSpaceNearestPointQueryFunc)PhysicsWorldCallback::queryPointFunc,
|
2013-11-11 16:23:42 +08:00
|
|
|
&info);
|
2013-11-11 15:03:17 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-05-15 01:07:09 +08:00
|
|
|
Vector<PhysicsShape*> PhysicsWorld::getShapes(const Vec2& point) const
|
2013-10-23 17:28:23 +08:00
|
|
|
{
|
2013-12-07 10:48:02 +08:00
|
|
|
Vector<PhysicsShape*> arr;
|
2015-01-06 10:29:07 +08:00
|
|
|
cpSpaceNearestPointQuery(_cpSpace,
|
2013-10-23 17:28:23 +08:00
|
|
|
PhysicsHelper::point2cpv(point),
|
|
|
|
0,
|
|
|
|
CP_ALL_LAYERS,
|
|
|
|
CP_NO_GROUP,
|
2013-11-18 03:10:13 +08:00
|
|
|
(cpSpaceNearestPointQueryFunc)PhysicsWorldCallback::getShapesAtPointFunc,
|
2013-12-07 10:48:02 +08:00
|
|
|
&arr);
|
2013-10-23 17:28:23 +08:00
|
|
|
|
2013-12-10 16:06:05 +08:00
|
|
|
return arr;
|
2013-10-23 17:28:23 +08:00
|
|
|
}
|
|
|
|
|
2014-05-15 01:07:09 +08:00
|
|
|
PhysicsShape* PhysicsWorld::getShape(const Vec2& point) const
|
2013-10-23 10:11:08 +08:00
|
|
|
{
|
2015-01-06 10:29:07 +08:00
|
|
|
cpShape* shape = cpSpaceNearestPointQueryNearest(_cpSpace,
|
2013-10-23 17:28:23 +08:00
|
|
|
PhysicsHelper::point2cpv(point),
|
|
|
|
0,
|
|
|
|
CP_ALL_LAYERS,
|
|
|
|
CP_NO_GROUP,
|
|
|
|
nullptr);
|
2013-10-23 10:11:08 +08:00
|
|
|
|
2015-01-06 10:29:07 +08:00
|
|
|
return shape == nullptr ? nullptr : s_physicsShapeMap.find(shape)->second;
|
2013-10-23 10:11:08 +08:00
|
|
|
}
|
|
|
|
|
2014-05-02 07:42:35 +08:00
|
|
|
PhysicsWorld* PhysicsWorld::construct(Scene& scene)
|
2013-09-09 10:29:02 +08:00
|
|
|
{
|
2014-08-28 07:31:57 +08:00
|
|
|
PhysicsWorld * world = new (std::nothrow) PhysicsWorld();
|
2014-05-02 07:42:35 +08:00
|
|
|
if(world && world->init(scene))
|
2013-09-09 10:29:02 +08:00
|
|
|
{
|
2013-09-10 17:36:49 +08:00
|
|
|
return world;
|
2013-09-09 10:29:02 +08:00
|
|
|
}
|
|
|
|
|
2013-09-10 17:36:49 +08:00
|
|
|
CC_SAFE_DELETE(world);
|
|
|
|
return nullptr;
|
2013-09-09 10:29:02 +08:00
|
|
|
}
|
|
|
|
|
2014-05-02 07:42:35 +08:00
|
|
|
bool PhysicsWorld::init(Scene& scene)
|
2013-11-25 10:08:52 +08:00
|
|
|
{
|
|
|
|
do
|
|
|
|
{
|
2015-01-06 10:29:07 +08:00
|
|
|
_cpSpace = cpSpaceNew();
|
|
|
|
CC_BREAK_IF(_cpSpace == nullptr);
|
2013-11-25 10:08:52 +08:00
|
|
|
|
2014-05-02 07:42:35 +08:00
|
|
|
_scene = &scene;
|
2013-11-25 10:08:52 +08:00
|
|
|
|
2015-01-06 10:29:07 +08:00
|
|
|
cpSpaceSetGravity(_cpSpace, PhysicsHelper::point2cpv(_gravity));
|
2013-11-25 10:08:52 +08:00
|
|
|
|
2015-01-06 10:29:07 +08:00
|
|
|
cpSpaceSetDefaultCollisionHandler(_cpSpace,
|
2013-11-25 10:08:52 +08:00
|
|
|
(cpCollisionBeginFunc)PhysicsWorldCallback::collisionBeginCallbackFunc,
|
|
|
|
(cpCollisionPreSolveFunc)PhysicsWorldCallback::collisionPreSolveCallbackFunc,
|
|
|
|
(cpCollisionPostSolveFunc)PhysicsWorldCallback::collisionPostSolveCallbackFunc,
|
|
|
|
(cpCollisionSeparateFunc)PhysicsWorldCallback::collisionSeparateCallbackFunc,
|
|
|
|
this);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
} while (false);
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void PhysicsWorld::addBody(PhysicsBody* body)
|
|
|
|
{
|
|
|
|
CCASSERT(body != nullptr, "the body can not be nullptr");
|
|
|
|
|
|
|
|
if (body->getWorld() == this)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (body->getWorld() != nullptr)
|
|
|
|
{
|
|
|
|
body->removeFromWorld();
|
|
|
|
}
|
|
|
|
|
|
|
|
addBodyOrDelay(body);
|
2013-12-07 10:48:02 +08:00
|
|
|
_bodies.pushBack(body);
|
2013-11-25 10:08:52 +08:00
|
|
|
body->_world = this;
|
|
|
|
}
|
|
|
|
|
|
|
|
void PhysicsWorld::doAddBody(PhysicsBody* body)
|
|
|
|
{
|
|
|
|
if (body->isEnabled())
|
|
|
|
{
|
|
|
|
// add body to space
|
2015-01-06 10:29:07 +08:00
|
|
|
if (body->isDynamic() && !cpSpaceContainsBody(_cpSpace, body->_cpBody))
|
2013-11-25 10:08:52 +08:00
|
|
|
{
|
2015-01-06 10:29:07 +08:00
|
|
|
cpSpaceAddBody(_cpSpace, body->_cpBody);
|
2013-11-25 10:08:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// add shapes to space
|
2013-12-07 10:48:02 +08:00
|
|
|
for (auto& shape : body->getShapes())
|
2013-11-25 10:08:52 +08:00
|
|
|
{
|
|
|
|
addShape(dynamic_cast<PhysicsShape*>(shape));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void PhysicsWorld::addBodyOrDelay(PhysicsBody* body)
|
|
|
|
{
|
2013-12-11 18:07:14 +08:00
|
|
|
auto removeBodyIter = _delayRemoveBodies.find(body);
|
|
|
|
if (removeBodyIter != _delayRemoveBodies.end())
|
2013-11-25 10:08:52 +08:00
|
|
|
{
|
2013-12-11 18:07:14 +08:00
|
|
|
_delayRemoveBodies.erase(removeBodyIter);
|
2013-11-25 10:08:52 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-01-07 17:08:04 +08:00
|
|
|
if (_delayAddBodies.find(body) == _delayAddBodies.end())
|
2013-11-25 10:08:52 +08:00
|
|
|
{
|
2015-01-07 17:08:04 +08:00
|
|
|
_delayAddBodies.pushBack(body);
|
2013-11-25 10:08:52 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void PhysicsWorld::updateBodies()
|
|
|
|
{
|
2015-01-06 10:29:07 +08:00
|
|
|
if (cpSpaceIsLocked(_cpSpace))
|
2013-11-25 10:08:52 +08:00
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-05-21 16:07:49 +08:00
|
|
|
// issue #4944, contact callback will be invoked when add/remove body, _delayAddBodies maybe changed, so we need make a copy.
|
|
|
|
auto addCopy = _delayAddBodies;
|
|
|
|
_delayAddBodies.clear();
|
|
|
|
for (auto& body : addCopy)
|
2013-11-25 10:08:52 +08:00
|
|
|
{
|
2013-12-07 10:48:02 +08:00
|
|
|
doAddBody(body);
|
2013-11-25 10:08:52 +08:00
|
|
|
}
|
|
|
|
|
2014-05-21 16:07:49 +08:00
|
|
|
auto removeCopy = _delayRemoveBodies;
|
|
|
|
_delayRemoveBodies.clear();
|
|
|
|
for (auto& body : removeCopy)
|
2013-11-25 10:08:52 +08:00
|
|
|
{
|
2013-12-07 10:48:02 +08:00
|
|
|
doRemoveBody(body);
|
2013-11-25 10:08:52 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void PhysicsWorld::removeBody(int tag)
|
|
|
|
{
|
2013-12-07 10:48:02 +08:00
|
|
|
for (auto& body : _bodies)
|
2013-11-25 10:08:52 +08:00
|
|
|
{
|
|
|
|
if (body->getTag() == tag)
|
|
|
|
{
|
|
|
|
removeBody(body);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void PhysicsWorld::removeBody(PhysicsBody* body)
|
|
|
|
{
|
|
|
|
if (body->getWorld() != this)
|
|
|
|
{
|
|
|
|
CCLOG("Physics Warnning: this body doesn't belong to this world");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// destory the body's joints
|
2015-01-07 17:08:04 +08:00
|
|
|
auto removeCopy = body->_joints;
|
|
|
|
for (auto joint : removeCopy)
|
2013-11-25 10:08:52 +08:00
|
|
|
{
|
2015-01-07 17:08:04 +08:00
|
|
|
removeJoint(joint, true);
|
2013-11-25 10:08:52 +08:00
|
|
|
}
|
|
|
|
body->_joints.clear();
|
|
|
|
|
|
|
|
removeBodyOrDelay(body);
|
2013-12-12 14:45:30 +08:00
|
|
|
_bodies.eraseObject(body);
|
2013-11-25 10:08:52 +08:00
|
|
|
body->_world = nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void PhysicsWorld::removeBodyOrDelay(PhysicsBody* body)
|
|
|
|
{
|
2013-12-07 10:48:02 +08:00
|
|
|
if (_delayAddBodies.getIndex(body) != CC_INVALID_INDEX)
|
2013-11-25 10:08:52 +08:00
|
|
|
{
|
2013-12-12 14:45:30 +08:00
|
|
|
_delayAddBodies.eraseObject(body);
|
2013-11-25 10:08:52 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-01-06 10:29:07 +08:00
|
|
|
if (cpSpaceIsLocked(_cpSpace))
|
2013-11-25 10:08:52 +08:00
|
|
|
{
|
2013-12-07 10:48:02 +08:00
|
|
|
if (_delayRemoveBodies.getIndex(body) == CC_INVALID_INDEX)
|
2013-11-25 10:08:52 +08:00
|
|
|
{
|
2013-12-07 10:48:02 +08:00
|
|
|
_delayRemoveBodies.pushBack(body);
|
2013-11-25 10:08:52 +08:00
|
|
|
}
|
|
|
|
}else
|
|
|
|
{
|
|
|
|
doRemoveBody(body);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-11-25 17:57:06 +08:00
|
|
|
void PhysicsWorld::removeJoint(PhysicsJoint* joint, bool destroy)
|
|
|
|
{
|
2015-01-07 17:08:04 +08:00
|
|
|
if (joint)
|
2013-11-25 17:57:06 +08:00
|
|
|
{
|
2015-01-07 17:08:04 +08:00
|
|
|
if (joint->getWorld() != this && destroy)
|
2013-11-25 17:57:06 +08:00
|
|
|
{
|
|
|
|
CCLOG("physics warnning: the joint is not in this world, it won't be destoried utill the body it conntect is destoried");
|
2015-01-07 17:08:04 +08:00
|
|
|
return;
|
2013-11-25 17:57:06 +08:00
|
|
|
}
|
2015-01-07 17:08:04 +08:00
|
|
|
|
|
|
|
joint->_destoryMark = destroy;
|
|
|
|
if (cpSpaceIsLocked(_cpSpace))
|
2013-11-25 17:57:06 +08:00
|
|
|
{
|
2015-01-07 17:08:04 +08:00
|
|
|
auto it = std::find(_delayAddJoints.begin(), _delayAddJoints.end(), joint);
|
|
|
|
if (it != _delayAddJoints.end())
|
|
|
|
{
|
|
|
|
_delayAddJoints.erase(it);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (std::find(_delayRemoveJoints.rbegin(), _delayRemoveJoints.rend(), joint) == _delayRemoveJoints.rend())
|
|
|
|
{
|
|
|
|
_delayRemoveJoints.push_back(joint);
|
|
|
|
}
|
2013-11-25 17:57:06 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-01-07 17:08:04 +08:00
|
|
|
doRemoveJoint(joint);
|
2013-11-25 17:57:06 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void PhysicsWorld::updateJoints()
|
|
|
|
{
|
2015-01-06 10:29:07 +08:00
|
|
|
if (cpSpaceIsLocked(_cpSpace))
|
2013-11-25 17:57:06 +08:00
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-01-07 17:08:04 +08:00
|
|
|
for (auto joint : _delayAddJoints)
|
2013-11-25 17:57:06 +08:00
|
|
|
{
|
2015-01-07 17:08:04 +08:00
|
|
|
joint->_world = this;
|
|
|
|
if (joint->initJoint())
|
|
|
|
{
|
|
|
|
_joints.push_back(joint);
|
|
|
|
}
|
|
|
|
else
|
2013-11-25 17:57:06 +08:00
|
|
|
{
|
|
|
|
delete joint;
|
|
|
|
}
|
|
|
|
}
|
2015-01-07 17:08:04 +08:00
|
|
|
_delayAddJoints.clear();
|
|
|
|
|
|
|
|
for (auto joint : _delayRemoveJoints)
|
|
|
|
{
|
|
|
|
doRemoveJoint(joint);
|
|
|
|
}
|
|
|
|
_delayRemoveJoints.clear();
|
2013-11-25 17:57:06 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void PhysicsWorld::removeShape(PhysicsShape* shape)
|
|
|
|
{
|
2015-01-06 10:29:07 +08:00
|
|
|
if (shape)
|
2013-11-25 17:57:06 +08:00
|
|
|
{
|
2015-01-06 10:29:07 +08:00
|
|
|
for (auto cps : shape->_cpShapes)
|
|
|
|
{
|
|
|
|
if (cpSpaceContainsShape(_cpSpace, cps))
|
|
|
|
{
|
|
|
|
cpSpaceRemoveShape(_cpSpace, cps);
|
|
|
|
}
|
|
|
|
}
|
2013-11-25 17:57:06 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-01-07 17:08:04 +08:00
|
|
|
void PhysicsWorld::addJoint(PhysicsJoint* joint)
|
2013-11-25 17:57:06 +08:00
|
|
|
{
|
2015-01-07 17:08:04 +08:00
|
|
|
if (joint)
|
2013-11-25 17:57:06 +08:00
|
|
|
{
|
2015-01-07 17:08:04 +08:00
|
|
|
if (joint->getWorld() && joint->getWorld() != this)
|
2013-11-25 17:57:06 +08:00
|
|
|
{
|
2015-01-07 17:08:04 +08:00
|
|
|
joint->removeFormWorld();
|
2013-11-25 17:57:06 +08:00
|
|
|
}
|
|
|
|
|
2015-01-07 17:08:04 +08:00
|
|
|
auto it = std::find(_delayRemoveJoints.begin(), _delayRemoveJoints.end(), joint);
|
|
|
|
if (it != _delayRemoveJoints.end())
|
2013-11-25 17:57:06 +08:00
|
|
|
{
|
2015-01-07 17:08:04 +08:00
|
|
|
_delayRemoveJoints.erase(it);
|
|
|
|
return;
|
2013-11-25 17:57:06 +08:00
|
|
|
}
|
|
|
|
|
2015-01-07 17:08:04 +08:00
|
|
|
if (std::find(_delayAddJoints.begin(), _delayAddJoints.end(), joint) == _delayAddJoints.end())
|
|
|
|
{
|
|
|
|
_delayAddJoints.push_back(joint);
|
|
|
|
}
|
2013-11-25 17:57:06 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void PhysicsWorld::removeAllJoints(bool destroy)
|
|
|
|
{
|
2015-01-07 17:08:04 +08:00
|
|
|
auto removeCopy = _joints;
|
|
|
|
for (auto joint : removeCopy)
|
2013-11-25 17:57:06 +08:00
|
|
|
{
|
2015-01-07 17:08:04 +08:00
|
|
|
removeJoint(joint, destroy);
|
2013-11-25 17:57:06 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-01-06 10:29:07 +08:00
|
|
|
void PhysicsWorld::addShape(PhysicsShape* physicsShape)
|
2013-11-25 17:57:06 +08:00
|
|
|
{
|
2015-01-06 10:29:07 +08:00
|
|
|
if (physicsShape)
|
2013-11-25 17:57:06 +08:00
|
|
|
{
|
2015-01-06 10:29:07 +08:00
|
|
|
for (auto shape : physicsShape->_cpShapes)
|
|
|
|
{
|
|
|
|
cpSpaceAddShape(_cpSpace, shape);
|
|
|
|
}
|
2013-11-25 17:57:06 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void PhysicsWorld::doRemoveBody(PhysicsBody* body)
|
|
|
|
{
|
|
|
|
CCASSERT(body != nullptr, "the body can not be nullptr");
|
|
|
|
|
|
|
|
// remove shaps
|
2013-12-07 14:28:14 +08:00
|
|
|
for (auto& shape : body->getShapes())
|
2013-11-25 17:57:06 +08:00
|
|
|
{
|
2013-12-11 22:09:59 +08:00
|
|
|
removeShape(shape);
|
2013-11-25 17:57:06 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// remove body
|
2015-01-06 10:29:07 +08:00
|
|
|
if (cpSpaceContainsBody(_cpSpace, body->_cpBody))
|
|
|
|
{
|
|
|
|
cpSpaceRemoveBody(_cpSpace, body->_cpBody);
|
|
|
|
}
|
2013-11-25 17:57:06 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void PhysicsWorld::doRemoveJoint(PhysicsJoint* joint)
|
|
|
|
{
|
2015-01-06 10:29:07 +08:00
|
|
|
for (auto constraint : joint->_cpConstraints)
|
|
|
|
{
|
|
|
|
cpSpaceRemoveConstraint(_cpSpace, constraint);
|
|
|
|
}
|
2015-01-07 17:08:04 +08:00
|
|
|
_joints.remove(joint);
|
|
|
|
joint->_world = nullptr;
|
|
|
|
|
|
|
|
if (joint->getBodyA())
|
|
|
|
{
|
|
|
|
joint->getBodyA()->removeJoint(joint);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (joint->getBodyB())
|
|
|
|
{
|
|
|
|
joint->getBodyB()->removeJoint(joint);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (joint->_destoryMark)
|
|
|
|
{
|
|
|
|
delete joint;
|
|
|
|
}
|
2013-11-25 17:57:06 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void PhysicsWorld::removeAllBodies()
|
|
|
|
{
|
2013-12-11 22:09:59 +08:00
|
|
|
for (auto& child : _bodies)
|
2013-11-25 17:57:06 +08:00
|
|
|
{
|
|
|
|
removeBodyOrDelay(child);
|
|
|
|
child->_world = nullptr;
|
|
|
|
}
|
|
|
|
|
2013-12-07 14:28:14 +08:00
|
|
|
_bodies.clear();
|
2013-11-25 17:57:06 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void PhysicsWorld::setDebugDrawMask(int mask)
|
|
|
|
{
|
|
|
|
if (mask == DEBUGDRAW_NONE)
|
|
|
|
{
|
|
|
|
CC_SAFE_DELETE(_debugDraw);
|
|
|
|
}
|
|
|
|
|
|
|
|
_debugDrawMask = mask;
|
|
|
|
}
|
|
|
|
|
2013-12-07 14:28:14 +08:00
|
|
|
const Vector<PhysicsBody*>& PhysicsWorld::getAllBodies() const
|
2013-11-25 17:57:06 +08:00
|
|
|
{
|
|
|
|
return _bodies;
|
|
|
|
}
|
|
|
|
|
|
|
|
PhysicsBody* PhysicsWorld::getBody(int tag) const
|
|
|
|
{
|
2013-12-07 14:28:14 +08:00
|
|
|
for (auto& body : _bodies)
|
2013-11-25 17:57:06 +08:00
|
|
|
{
|
2013-12-07 14:28:14 +08:00
|
|
|
if (body->getTag() == tag)
|
2013-11-25 17:57:06 +08:00
|
|
|
{
|
2013-12-07 14:28:14 +08:00
|
|
|
return body;
|
2013-11-25 17:57:06 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void PhysicsWorld::setGravity(const Vect& gravity)
|
|
|
|
{
|
|
|
|
_gravity = gravity;
|
2015-01-06 10:29:07 +08:00
|
|
|
cpSpaceSetGravity(_cpSpace, PhysicsHelper::point2cpv(gravity));
|
2013-11-25 17:57:06 +08:00
|
|
|
}
|
|
|
|
|
2014-09-08 06:14:40 +08:00
|
|
|
void PhysicsWorld::setSubsteps(int steps)
|
|
|
|
{
|
|
|
|
if(steps > 0)
|
|
|
|
{
|
|
|
|
_substeps = steps;
|
|
|
|
if (steps > 1)
|
|
|
|
{
|
|
|
|
_updateRate = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-12 12:45:21 +08:00
|
|
|
void PhysicsWorld::step(float delta)
|
|
|
|
{
|
|
|
|
if (_autoStep)
|
|
|
|
{
|
|
|
|
CCLOG("Physics Warning: You need to close auto step( setAutoStep(false) ) first");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
update(delta, true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void PhysicsWorld::update(float delta, bool userCall/* = false*/)
|
2013-11-25 17:57:06 +08:00
|
|
|
{
|
2015-01-07 17:08:04 +08:00
|
|
|
if (delta < FLT_EPSILON)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
_scene->updatePhysicsBodyTransform(_scene, _scene->getNodeToParentTransform(), 0, 1.0f, 1.0f);
|
|
|
|
|
2015-01-16 14:15:06 +08:00
|
|
|
if (!_delayAddBodies.empty() || !_delayRemoveBodies.empty())
|
2013-11-25 17:57:06 +08:00
|
|
|
{
|
|
|
|
updateBodies();
|
2015-01-16 14:15:06 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!_delayAddJoints.empty() || !_delayRemoveJoints.empty())
|
|
|
|
{
|
2015-01-07 17:08:04 +08:00
|
|
|
updateJoints();
|
2013-11-25 17:57:06 +08:00
|
|
|
}
|
|
|
|
|
2014-06-12 12:45:21 +08:00
|
|
|
if (userCall)
|
2013-12-13 16:26:26 +08:00
|
|
|
{
|
2015-01-06 10:29:07 +08:00
|
|
|
cpSpaceStep(_cpSpace, delta);
|
2014-02-24 16:17:42 +08:00
|
|
|
for (auto& body : _bodies)
|
|
|
|
{
|
2014-06-12 12:45:21 +08:00
|
|
|
body->update(delta);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
_updateTime += delta;
|
|
|
|
if (++_updateRateCount >= _updateRate)
|
|
|
|
{
|
2014-09-08 06:14:40 +08:00
|
|
|
const float dt = _updateTime * _speed / _substeps;
|
|
|
|
for (int i = 0; i < _substeps; ++i)
|
2014-06-12 12:45:21 +08:00
|
|
|
{
|
2015-01-06 10:29:07 +08:00
|
|
|
cpSpaceStep(_cpSpace, dt);
|
2014-09-08 06:14:40 +08:00
|
|
|
for (auto& body : _bodies)
|
|
|
|
{
|
|
|
|
body->update(dt);
|
|
|
|
}
|
2014-06-12 12:45:21 +08:00
|
|
|
}
|
|
|
|
_updateRateCount = 0;
|
|
|
|
_updateTime = 0.0f;
|
2014-02-24 16:17:42 +08:00
|
|
|
}
|
2013-12-13 16:26:26 +08:00
|
|
|
}
|
2013-11-25 17:57:06 +08:00
|
|
|
|
|
|
|
if (_debugDrawMask != DEBUGDRAW_NONE)
|
|
|
|
{
|
|
|
|
debugDraw();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-09-10 17:36:49 +08:00
|
|
|
PhysicsWorld::PhysicsWorld()
|
2014-05-15 01:07:09 +08:00
|
|
|
: _gravity(Vec2(0.0f, -98.0f))
|
2013-09-16 21:22:22 +08:00
|
|
|
, _speed(1.0f)
|
2013-12-13 16:26:26 +08:00
|
|
|
, _updateRate(1)
|
|
|
|
, _updateRateCount(0)
|
|
|
|
, _updateTime(0.0f)
|
2014-09-08 06:14:40 +08:00
|
|
|
, _substeps(1)
|
2015-01-06 10:29:07 +08:00
|
|
|
, _cpSpace(nullptr)
|
2014-05-02 07:42:35 +08:00
|
|
|
, _scene(nullptr)
|
2014-06-12 12:45:21 +08:00
|
|
|
, _autoStep(true)
|
2013-11-08 14:25:03 +08:00
|
|
|
, _debugDraw(nullptr)
|
2013-11-18 10:10:37 +08:00
|
|
|
, _debugDrawMask(DEBUGDRAW_NONE)
|
2013-09-09 10:29:02 +08:00
|
|
|
{
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
PhysicsWorld::~PhysicsWorld()
|
|
|
|
{
|
2013-11-07 14:17:57 +08:00
|
|
|
removeAllJoints(true);
|
2013-10-29 17:31:35 +08:00
|
|
|
removeAllBodies();
|
2015-01-06 10:29:07 +08:00
|
|
|
if (_cpSpace)
|
|
|
|
{
|
|
|
|
cpSpaceFree(_cpSpace);
|
|
|
|
}
|
2013-11-08 14:25:03 +08:00
|
|
|
CC_SAFE_DELETE(_debugDraw);
|
|
|
|
}
|
|
|
|
|
|
|
|
PhysicsDebugDraw::PhysicsDebugDraw(PhysicsWorld& world)
|
|
|
|
: _drawNode(nullptr)
|
|
|
|
, _world(world)
|
|
|
|
{
|
2014-03-21 15:49:18 +08:00
|
|
|
_drawNode = DrawNode::create();
|
2014-05-02 07:42:35 +08:00
|
|
|
_world.getScene().addChild(_drawNode);
|
2013-11-08 14:25:03 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
PhysicsDebugDraw::~PhysicsDebugDraw()
|
|
|
|
{
|
2014-03-21 15:49:18 +08:00
|
|
|
_drawNode->removeFromParent();
|
|
|
|
_drawNode = nullptr;
|
2013-11-08 14:25:03 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
bool PhysicsDebugDraw::begin()
|
|
|
|
{
|
2014-03-21 15:49:18 +08:00
|
|
|
_drawNode->clear();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void PhysicsDebugDraw::end()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void PhysicsDebugDraw::drawShape(PhysicsShape& shape)
|
|
|
|
{
|
|
|
|
const Color4F fillColor(1.0f, 0.0f, 0.0f, 0.3f);
|
|
|
|
const Color4F outlineColor(1.0f, 0.0f, 0.0f, 1.0f);
|
|
|
|
|
2015-01-06 10:29:07 +08:00
|
|
|
for (auto it = shape._cpShapes.begin(); it != shape._cpShapes.end(); ++it)
|
2013-11-08 14:25:03 +08:00
|
|
|
{
|
2014-03-21 15:49:18 +08:00
|
|
|
cpShape *subShape = *it;
|
|
|
|
|
|
|
|
switch ((*it)->klass_private->type)
|
|
|
|
{
|
|
|
|
case CP_CIRCLE_SHAPE:
|
|
|
|
{
|
|
|
|
float radius = PhysicsHelper::cpfloat2float(cpCircleShapeGetRadius(subShape));
|
2014-05-15 01:07:09 +08:00
|
|
|
Vec2 centre = PhysicsHelper::cpv2point(cpBodyGetPos(cpShapeGetBody(subShape)))
|
2014-03-21 15:49:18 +08:00
|
|
|
+ PhysicsHelper::cpv2point(cpCircleShapeGetOffset(subShape));
|
|
|
|
|
|
|
|
static const int CIRCLE_SEG_NUM = 12;
|
2014-05-15 01:07:09 +08:00
|
|
|
Vec2 seg[CIRCLE_SEG_NUM] = {};
|
2014-03-21 15:49:18 +08:00
|
|
|
|
|
|
|
for (int i = 0; i < CIRCLE_SEG_NUM; ++i)
|
|
|
|
{
|
|
|
|
float angle = (float)i * M_PI / (float)CIRCLE_SEG_NUM * 2.0f;
|
2014-05-15 01:07:09 +08:00
|
|
|
Vec2 d(radius * cosf(angle), radius * sinf(angle));
|
2014-03-21 15:49:18 +08:00
|
|
|
seg[i] = centre + d;
|
|
|
|
}
|
|
|
|
_drawNode->drawPolygon(seg, CIRCLE_SEG_NUM, fillColor, 1, outlineColor);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case CP_SEGMENT_SHAPE:
|
|
|
|
{
|
|
|
|
cpSegmentShape *seg = (cpSegmentShape *)subShape;
|
|
|
|
_drawNode->drawSegment(PhysicsHelper::cpv2point(seg->ta),
|
|
|
|
PhysicsHelper::cpv2point(seg->tb),
|
|
|
|
PhysicsHelper::cpfloat2float(seg->r==0 ? 1 : seg->r), outlineColor);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case CP_POLY_SHAPE:
|
|
|
|
{
|
|
|
|
cpPolyShape* poly = (cpPolyShape*)subShape;
|
|
|
|
int num = poly->numVerts;
|
2014-08-28 07:31:57 +08:00
|
|
|
Vec2* seg = new (std::nothrow) Vec2[num];
|
2014-03-21 15:49:18 +08:00
|
|
|
|
|
|
|
PhysicsHelper::cpvs2points(poly->tVerts, seg, num);
|
|
|
|
|
|
|
|
_drawNode->drawPolygon(seg, num, fillColor, 1.0f, outlineColor);
|
|
|
|
|
|
|
|
delete[] seg;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2013-11-08 14:25:03 +08:00
|
|
|
}
|
2014-03-21 15:49:18 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void PhysicsDebugDraw::drawJoint(PhysicsJoint& joint)
|
|
|
|
{
|
|
|
|
const Color4F lineColor(0.0f, 0.0f, 1.0f, 1.0f);
|
|
|
|
const Color4F jointPointColor(0.0f, 1.0f, 0.0f, 1.0f);
|
2013-11-08 14:25:03 +08:00
|
|
|
|
2015-01-06 10:29:07 +08:00
|
|
|
for (auto it = joint._cpConstraints.begin(); it != joint._cpConstraints.end(); ++it)
|
2013-11-08 14:25:03 +08:00
|
|
|
{
|
2014-03-21 15:49:18 +08:00
|
|
|
cpConstraint *constraint = *it;
|
|
|
|
|
|
|
|
|
|
|
|
cpBody *body_a = constraint->a;
|
|
|
|
cpBody *body_b = constraint->b;
|
|
|
|
|
|
|
|
const cpConstraintClass *klass = constraint->klass_private;
|
|
|
|
if(klass == cpPinJointGetClass())
|
|
|
|
{
|
|
|
|
cpPinJoint *subJoint = (cpPinJoint *)constraint;
|
|
|
|
|
|
|
|
cpVect a = cpvadd(body_a->p, cpvrotate(subJoint->anchr1, body_a->rot));
|
|
|
|
cpVect b = cpvadd(body_b->p, cpvrotate(subJoint->anchr2, body_b->rot));
|
|
|
|
|
|
|
|
_drawNode->drawSegment(PhysicsHelper::cpv2point(a), PhysicsHelper::cpv2point(b), 1, lineColor);
|
|
|
|
_drawNode->drawDot(PhysicsHelper::cpv2point(a), 2, jointPointColor);
|
|
|
|
_drawNode->drawDot(PhysicsHelper::cpv2point(b), 2, jointPointColor);
|
|
|
|
}
|
|
|
|
else if(klass == cpSlideJointGetClass())
|
|
|
|
{
|
|
|
|
cpSlideJoint *subJoint = (cpSlideJoint *)constraint;
|
|
|
|
|
|
|
|
cpVect a = cpvadd(body_a->p, cpvrotate(subJoint->anchr1, body_a->rot));
|
|
|
|
cpVect b = cpvadd(body_b->p, cpvrotate(subJoint->anchr2, body_b->rot));
|
|
|
|
|
|
|
|
_drawNode->drawSegment(PhysicsHelper::cpv2point(a), PhysicsHelper::cpv2point(b), 1, lineColor);
|
|
|
|
_drawNode->drawDot(PhysicsHelper::cpv2point(a), 2, jointPointColor);
|
|
|
|
_drawNode->drawDot(PhysicsHelper::cpv2point(b), 2, jointPointColor);
|
|
|
|
}
|
|
|
|
else if(klass == cpPivotJointGetClass())
|
|
|
|
{
|
|
|
|
cpPivotJoint *subJoint = (cpPivotJoint *)constraint;
|
|
|
|
|
|
|
|
cpVect a = cpvadd(body_a->p, cpvrotate(subJoint->anchr1, body_a->rot));
|
|
|
|
cpVect b = cpvadd(body_b->p, cpvrotate(subJoint->anchr2, body_b->rot));
|
|
|
|
|
|
|
|
_drawNode->drawDot(PhysicsHelper::cpv2point(a), 2, jointPointColor);
|
|
|
|
_drawNode->drawDot(PhysicsHelper::cpv2point(b), 2, jointPointColor);
|
|
|
|
}
|
|
|
|
else if(klass == cpGrooveJointGetClass())
|
|
|
|
{
|
|
|
|
cpGrooveJoint *subJoint = (cpGrooveJoint *)constraint;
|
|
|
|
|
|
|
|
cpVect a = cpvadd(body_a->p, cpvrotate(subJoint->grv_a, body_a->rot));
|
|
|
|
cpVect b = cpvadd(body_a->p, cpvrotate(subJoint->grv_b, body_a->rot));
|
|
|
|
cpVect c = cpvadd(body_b->p, cpvrotate(subJoint->anchr2, body_b->rot));
|
|
|
|
|
|
|
|
_drawNode->drawSegment(PhysicsHelper::cpv2point(a), PhysicsHelper::cpv2point(b), 1, lineColor);
|
|
|
|
_drawNode->drawDot(PhysicsHelper::cpv2point(c), 2, jointPointColor);
|
|
|
|
}
|
|
|
|
else if(klass == cpDampedSpringGetClass())
|
|
|
|
{
|
|
|
|
cpDampedSpring *subJoint = (cpDampedSpring *)constraint;
|
|
|
|
|
|
|
|
cpVect a = cpvadd(body_a->p, cpvrotate(subJoint->anchr1, body_a->rot));
|
|
|
|
cpVect b = cpvadd(body_b->p, cpvrotate(subJoint->anchr2, body_b->rot));
|
|
|
|
|
|
|
|
_drawNode->drawSegment(PhysicsHelper::cpv2point(a), PhysicsHelper::cpv2point(b), 1, lineColor);
|
|
|
|
_drawNode->drawDot(PhysicsHelper::cpv2point(a), 2, jointPointColor);
|
|
|
|
_drawNode->drawDot(PhysicsHelper::cpv2point(b), 2, jointPointColor);
|
|
|
|
}
|
2013-11-08 14:25:03 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-21 15:49:18 +08:00
|
|
|
void PhysicsDebugDraw::drawContact()
|
2013-11-08 14:25:03 +08:00
|
|
|
{
|
2014-03-21 15:49:18 +08:00
|
|
|
|
2013-09-09 10:29:02 +08:00
|
|
|
}
|
|
|
|
|
2013-09-09 10:40:31 +08:00
|
|
|
NS_CC_END
|
2013-09-16 21:22:22 +08:00
|
|
|
|
|
|
|
#endif // CC_USE_PHYSICS
|