Lothario
/
axmol
mirror of https://github.com/axmolengine/axmol.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

issue #2771: change some coding style

This commit is contained in:
boyu0 2013-11-05 20:02:58 +08:00
parent 8c62bf813f
commit af129e25f0
24 changed files with 325 additions and 286 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
cocos/base/CCGeometry.cpp
View File

@ -96,6 +96,16 @@ bool Point::operator!=(const Point& right)
return this->x != right.x || this->y != right.y;
}
bool Point::operator==(const Point& right) const
{
return this->x == right.x && this->y == right.y;
}
bool Point::operator!=(const Point& right) const
{
return this->x != right.x || this->y != right.y;
}
Point Point::operator*(float a) const
{
return Point(this->x * a, this->y * a);

10
cocos/base/CCGeometry.h
View File

@ -123,6 +123,16 @@ public:
* @lua NA
*/
bool operator!=(const Point& right);
/**
* @js NA
* @lua NA
*/
bool operator==(const Point& right) const;
/**
* @js NA
* @lua NA
*/
bool operator!=(const Point& right) const;
/**
* @js NA
* @lua NA

100
cocos/physics/CCPhysicsBody.cpp
View File

@ -157,7 +157,7 @@ PhysicsBody* PhysicsBody::create(float mass, float moment)
}
PhysicsBody* PhysicsBody::createCircle(float radius, PhysicsMaterial material, Point offset)
PhysicsBody* PhysicsBody::createCircle(float radius, const PhysicsMaterial& material, const Point& offset)
{
PhysicsBody* body = new PhysicsBody();
if (body && body->init())
@ -171,7 +171,7 @@ PhysicsBody* PhysicsBody::createCircle(float radius, PhysicsMaterial material, P
return nullptr;
}
PhysicsBody* PhysicsBody::createBox(Size size, PhysicsMaterial material, Point offset)
PhysicsBody* PhysicsBody::createBox(const Size& size, const PhysicsMaterial& material, const Point& offset)
{
PhysicsBody* body = new PhysicsBody();
if (body && body->init())
@ -185,7 +185,7 @@ PhysicsBody* PhysicsBody::createBox(Size size, PhysicsMaterial material, Point o
return nullptr;
}
PhysicsBody* PhysicsBody::createPolygon(Point* points, int count, PhysicsMaterial material, Point offset)
PhysicsBody* PhysicsBody::createPolygon(const Point* points, int count, const PhysicsMaterial& material, const Point& offset)
{
PhysicsBody* body = new PhysicsBody();
if (body && body->init())
@ -199,7 +199,7 @@ PhysicsBody* PhysicsBody::createPolygon(Point* points, int count, PhysicsMateria
return nullptr;
}
PhysicsBody* PhysicsBody::createEdgeSegment(Point a, Point b, PhysicsMaterial material, float border/* = 1*/)
PhysicsBody* PhysicsBody::createEdgeSegment(const Point& a, const Point& b, const PhysicsMaterial& material, float border/* = 1*/)
{
PhysicsBody* body = new PhysicsBody();
if (body && body->init())
@ -214,7 +214,7 @@ PhysicsBody* PhysicsBody::createEdgeSegment(Point a, Point b, PhysicsMaterial ma
return nullptr;
}
PhysicsBody* PhysicsBody::createEdgeBox(Size size, PhysicsMaterial material, float border/* = 1*/, Point offset)
PhysicsBody* PhysicsBody::createEdgeBox(const Size& size, const PhysicsMaterial& material, float border/* = 1*/, const Point& offset)
{
PhysicsBody* body = new PhysicsBody();
if (body && body->init())
@ -230,7 +230,7 @@ PhysicsBody* PhysicsBody::createEdgeBox(Size size, PhysicsMaterial material, flo
return nullptr;
}
PhysicsBody* PhysicsBody::createEdgePolygon(Point* points, int count, PhysicsMaterial material, float border/* = 1*/)
PhysicsBody* PhysicsBody::createEdgePolygon(const Point* points, int count, const PhysicsMaterial& material, float border/* = 1*/)
{
PhysicsBody* body = new PhysicsBody();
if (body && body->init())
@ -246,7 +246,7 @@ PhysicsBody* PhysicsBody::createEdgePolygon(Point* points, int count, PhysicsMat
return nullptr;
}
PhysicsBody* PhysicsBody::createEdgeChain(Point* points, int count, PhysicsMaterial material, float border/* = 1*/)
PhysicsBody* PhysicsBody::createEdgeChain(const Point* points, int count, const PhysicsMaterial& material, float border/* = 1*/)
{
PhysicsBody* body = new PhysicsBody();
if (body && body->init())
@ -272,9 +272,9 @@ bool PhysicsBody::init()
CC_BREAK_IF(_shapes == nullptr);
_shapes->retain();
_info->body = cpBodyNew(PhysicsHelper::float2cpfloat(_mass), PhysicsHelper::float2cpfloat(_moment));
_info->setBody(cpBodyNew(PhysicsHelper::float2cpfloat(_mass), PhysicsHelper::float2cpfloat(_moment)));
CC_BREAK_IF(_info->body == nullptr);
CC_BREAK_IF(_info->getBody() == nullptr);
return true;
} while (false);
@ -289,19 +289,19 @@ void PhysicsBody::setDynamic(bool dynamic)
_dynamic = dynamic;
if (dynamic)
{
cpBodySetMass(_info->body, _mass);
cpBodySetMass(_info->getBody(), _mass);
if (_world != nullptr)
{
cpSpaceAddBody(_world->_info->space, _info->body);
cpSpaceAddBody(_world->_info->getSpace(), _info->getBody());
}
}else
{
cpBodySetMass(_info->body, PHYSICS_INFINITY);
cpBodySetMass(_info->getBody(), PHYSICS_INFINITY);
if (_world != nullptr)
{
cpSpaceRemoveBody(_world->_info->space, _info->body);
cpSpaceRemoveBody(_world->_info->getSpace(), _info->getBody());
}
}
@ -312,7 +312,7 @@ void PhysicsBody::setRotationEnable(bool enable)
{
if (_rotationEnable != enable)
{
cpBodySetMoment(_info->body, enable ? _moment : PHYSICS_INFINITY);
cpBodySetMoment(_info->getBody(), enable ? _moment : PHYSICS_INFINITY);
_rotationEnable = enable;
}
}
@ -338,23 +338,23 @@ void PhysicsBody::setGravityEnable(bool enable)
void PhysicsBody::setPosition(Point position)
{
cpBodySetPos(_info->body, PhysicsHelper::point2cpv(position));
cpBodySetPos(_info->getBody(), PhysicsHelper::point2cpv(position));
}
void PhysicsBody::setRotation(float rotation)
{
cpBodySetAngle(_info->body, PhysicsHelper::float2cpfloat(rotation));
cpBodySetAngle(_info->getBody(), PhysicsHelper::float2cpfloat(rotation));
}
Point PhysicsBody::getPosition() const
{
cpVect vec = cpBodyGetPos(_info->body);
cpVect vec = cpBodyGetPos(_info->getBody());
return PhysicsHelper::cpv2point(vec);
}
float PhysicsBody::getRotation() const
{
return -PhysicsHelper::cpfloat2float(cpBodyGetAngle(_info->body) / 3.14f * 180.0f);
return -PhysicsHelper::cpfloat2float(cpBodyGetAngle(_info->getBody()) / 3.14f * 180.0f);
}
PhysicsShape* PhysicsBody::addShape(PhysicsShape* shape)
@ -388,29 +388,29 @@ PhysicsShape* PhysicsBody::addShape(PhysicsShape* shape)
return shape;
}
void PhysicsBody::applyForce(Point force)
void PhysicsBody::applyForce(const Vect& force)
{
applyForce(force, Point::ZERO);
}
void PhysicsBody::applyForce(Point force, Point offset)
void PhysicsBody::applyForce(const Vect& force, const Point& offset)
{
cpBodyApplyForce(_info->body, PhysicsHelper::point2cpv(force), PhysicsHelper::point2cpv(offset));
cpBodyApplyForce(_info->getBody(), PhysicsHelper::point2cpv(force), PhysicsHelper::point2cpv(offset));
}
void PhysicsBody::applyImpulse(Point impulse)
void PhysicsBody::applyImpulse(const Vect& impulse)
{
applyImpulse(impulse, Point());
}
void PhysicsBody::applyImpulse(Point impulse, Point offset)
void PhysicsBody::applyImpulse(const Vect& impulse, const Point& offset)
{
cpBodyApplyImpulse(_info->body, PhysicsHelper::point2cpv(impulse), PhysicsHelper::point2cpv(offset));
cpBodyApplyImpulse(_info->getBody(), PhysicsHelper::point2cpv(impulse), PhysicsHelper::point2cpv(offset));
}
void PhysicsBody::applyTorque(float torque)
{
cpBodySetTorque(_info->body, PhysicsHelper::float2cpfloat(torque));
cpBodySetTorque(_info->getBody(), PhysicsHelper::float2cpfloat(torque));
}
void PhysicsBody::setMass(float mass)
@ -439,7 +439,7 @@ void PhysicsBody::setMass(float mass)
}
}
cpBodySetMass(_info->body, PhysicsHelper::float2cpfloat(_mass));
cpBodySetMass(_info->getBody(), PhysicsHelper::float2cpfloat(_mass));
}
void PhysicsBody::addMass(float mass)
@ -481,7 +481,7 @@ void PhysicsBody::addMass(float mass)
}
}
cpBodySetMass(_info->body, PhysicsHelper::float2cpfloat(_mass));
cpBodySetMass(_info->getBody(), PhysicsHelper::float2cpfloat(_mass));
}
void PhysicsBody::addMoment(float moment)
@ -522,58 +522,58 @@ void PhysicsBody::addMoment(float moment)
if (_rotationEnable)
{
cpBodySetMoment(_info->body, PhysicsHelper::float2cpfloat(_moment));
cpBodySetMoment(_info->getBody(), PhysicsHelper::float2cpfloat(_moment));
}
}
void PhysicsBody::setVelocity(Point velocity)
void PhysicsBody::setVelocity(const Point& velocity)
{
cpBodySetVel(_info->body, PhysicsHelper::point2cpv(velocity));
cpBodySetVel(_info->getBody(), PhysicsHelper::point2cpv(velocity));
}
Point PhysicsBody::getVelocity()
{
return PhysicsHelper::cpv2point(cpBodyGetVel(_info->body));
return PhysicsHelper::cpv2point(cpBodyGetVel(_info->getBody()));
}
Point PhysicsBody::getVelocityAtLocalPoint(Point point)
Point PhysicsBody::getVelocityAtLocalPoint(const Point& point)
{
return PhysicsHelper::cpv2point(cpBodyGetVelAtLocalPoint(_info->body, PhysicsHelper::point2cpv(point)));
return PhysicsHelper::cpv2point(cpBodyGetVelAtLocalPoint(_info->getBody(), PhysicsHelper::point2cpv(point)));
}
Point PhysicsBody::getVelocityAtWorldPoint(Point point)
Point PhysicsBody::getVelocityAtWorldPoint(const Point& point)
{
return PhysicsHelper::cpv2point(cpBodyGetVelAtWorldPoint(_info->body, PhysicsHelper::point2cpv(point)));
return PhysicsHelper::cpv2point(cpBodyGetVelAtWorldPoint(_info->getBody(), PhysicsHelper::point2cpv(point)));
}
void PhysicsBody::setAngularVelocity(float velocity)
{
cpBodySetAngVel(_info->body, PhysicsHelper::float2cpfloat(velocity));
cpBodySetAngVel(_info->getBody(), PhysicsHelper::float2cpfloat(velocity));
}
float PhysicsBody::getAngularVelocity()
{
return PhysicsHelper::cpfloat2float(cpBodyGetAngVel(_info->body));
return PhysicsHelper::cpfloat2float(cpBodyGetAngVel(_info->getBody()));
}
void PhysicsBody::setVelocityLimit(float limit)
{
cpBodySetVelLimit(_info->body, PhysicsHelper::float2cpfloat(limit));
cpBodySetVelLimit(_info->getBody(), PhysicsHelper::float2cpfloat(limit));
}
float PhysicsBody::getVelocityLimit()
{
return PhysicsHelper::cpfloat2float(cpBodyGetVelLimit(_info->body));
return PhysicsHelper::cpfloat2float(cpBodyGetVelLimit(_info->getBody()));
}
void PhysicsBody::setAngularVelocityLimit(float limit)
{
cpBodySetVelLimit(_info->body, PhysicsHelper::float2cpfloat(limit));
cpBodySetVelLimit(_info->getBody(), PhysicsHelper::float2cpfloat(limit));
}
float PhysicsBody::getAngularVelocityLimit()
{
return PhysicsHelper::cpfloat2float(cpBodyGetAngVelLimit(_info->body));
return PhysicsHelper::cpfloat2float(cpBodyGetAngVelLimit(_info->getBody()));
}
void PhysicsBody::setMoment(float moment)
@ -583,11 +583,11 @@ void PhysicsBody::setMoment(float moment)
if (_rotationEnable)
{
cpBodySetMoment(_info->body, PhysicsHelper::float2cpfloat(_moment));
cpBodySetMoment(_info->getBody(), PhysicsHelper::float2cpfloat(_moment));
}
}
PhysicsShape* PhysicsBody::getShapeByTag(int tag) const
PhysicsShape* PhysicsBody::getShape(int tag) const
{
for (auto child : *_shapes)
{
@ -601,7 +601,7 @@ PhysicsShape* PhysicsBody::getShapeByTag(int tag) const
return nullptr;
}
void PhysicsBody::removeShapeByTag(int tag)
void PhysicsBody::removeShape(int tag)
{
for (auto child : *_shapes)
{
@ -685,7 +685,7 @@ void PhysicsBody::setEnable(bool enable)
bool PhysicsBody::isResting() const
{
return cpBodyIsSleeping(_info->body) == cpTrue;
return cpBodyIsSleeping(_info->getBody()) == cpTrue;
}
void PhysicsBody::update(float delta)
@ -693,9 +693,9 @@ void PhysicsBody::update(float delta)
// damping compute
if (_dynamic)
{
_info->body->v.x *= cpfclamp(1.0f - delta * _linearDamping, 0.0f, 1.0f);
_info->body->v.y *= cpfclamp(1.0f - delta * _linearDamping, 0.0f, 1.0f);
_info->body->w *= cpfclamp(1.0f - delta * _angularDamping, 0.0f, 1.0f);
_info->getBody()->v.x *= cpfclamp(1.0f - delta * _linearDamping, 0.0f, 1.0f);
_info->getBody()->v.y *= cpfclamp(1.0f - delta * _linearDamping, 0.0f, 1.0f);
_info->getBody()->w *= cpfclamp(1.0f - delta * _angularDamping, 0.0f, 1.0f);
}
}
@ -739,12 +739,12 @@ void PhysicsBody::setGroup(int group)
Point PhysicsBody::world2Local(const Point& point)
{
return PhysicsHelper::cpv2point(cpBodyWorld2Local(_info->body, PhysicsHelper::point2cpv(point)));
return PhysicsHelper::cpv2point(cpBodyWorld2Local(_info->getBody(), PhysicsHelper::point2cpv(point)));
}
Point PhysicsBody::local2World(const Point& point)
{
return PhysicsHelper::cpv2point(cpBodyLocal2World(_info->body, PhysicsHelper::point2cpv(point)));
return PhysicsHelper::cpv2point(cpBodyLocal2World(_info->getBody(), PhysicsHelper::point2cpv(point)));
}
#elif (CC_PHYSICS_ENGINE == CC_PHYSICS_BOX2D)

32
cocos/physics/CCPhysicsBody.h
View File

@ -59,62 +59,62 @@ public:
/**
* @brief Create a body contains a circle shape.
*/
static PhysicsBody* createCircle(float radius, PhysicsMaterial material = PHYSICSBODY_MATERIAL_DEFAULT, Point offset = Point::ZERO);
static PhysicsBody* createCircle(float radius, const PhysicsMaterial& material = PHYSICSBODY_MATERIAL_DEFAULT, const Point& offset = Point::ZERO);
/**
* @brief Create a body contains a box shape.
*/
static PhysicsBody* createBox(Size size, PhysicsMaterial material = PHYSICSBODY_MATERIAL_DEFAULT, Point offset = Point::ZERO);
static PhysicsBody* createBox(const Size& size, const PhysicsMaterial& material = PHYSICSBODY_MATERIAL_DEFAULT, const Point& offset = Point::ZERO);
/**
* @brief Create a body contains a polygon shape.
* points is an array of Point structs defining a convex hull with a clockwise winding.
*/
static PhysicsBody* createPolygon(Point* points, int count, PhysicsMaterial material = PHYSICSBODY_MATERIAL_DEFAULT, Point offset = Point::ZERO);
static PhysicsBody* createPolygon(const Point* points, int count, const PhysicsMaterial& material = PHYSICSBODY_MATERIAL_DEFAULT, const Point& offset = Point::ZERO);
/**
* @brief Create a body contains a EdgeSegment shape.
*/
static PhysicsBody* createEdgeSegment(Point a, Point b, PhysicsMaterial material = PHYSICSBODY_MATERIAL_DEFAULT, float border = 1);
static PhysicsBody* createEdgeSegment(const Point& a, const Point& b, const PhysicsMaterial& material = PHYSICSBODY_MATERIAL_DEFAULT, float border = 1);
/**
* @brief Create a body contains a EdgeBox shape.
*/
static PhysicsBody* createEdgeBox(Size size, PhysicsMaterial material = PHYSICSBODY_MATERIAL_DEFAULT, float border = 1, Point offset = Point::ZERO);
static PhysicsBody* createEdgeBox(const Size& size, const PhysicsMaterial& material = PHYSICSBODY_MATERIAL_DEFAULT, float border = 1, const Point& offset = Point::ZERO);
/**
* @brief Create a body contains a EdgePolygon shape.
*/
static PhysicsBody* createEdgePolygon(Point* points, int count, PhysicsMaterial material = PHYSICSBODY_MATERIAL_DEFAULT, float border = 1);
static PhysicsBody* createEdgePolygon(const Point* points, int count, const PhysicsMaterial& material = PHYSICSBODY_MATERIAL_DEFAULT, float border = 1);
/**
* @brief Create a body contains a EdgeChain shape.
*/
static PhysicsBody* createEdgeChain(Point* points, int count, PhysicsMaterial material = PHYSICSBODY_MATERIAL_DEFAULT, float border = 1);
static PhysicsBody* createEdgeChain(const Point* points, int count, const PhysicsMaterial& material = PHYSICSBODY_MATERIAL_DEFAULT, float border = 1);
virtual PhysicsShape* addShape(PhysicsShape* shape);
/**
* @brief Applies a immediate force to body.
*/
virtual void applyForce(Point force);
virtual void applyForce(const Vect& force);
/**
* @brief Applies a immediate force to body.
*/
virtual void applyForce(Point force, Point offset);
virtual void applyForce(const Vect& force, const Point& offset);
/**
* @brief Applies a continuous force to body.
*/
virtual void applyImpulse(Point impulse);
virtual void applyImpulse(const Vect& impulse);
/**
* @brief Applies a continuous force to body.
*/
virtual void applyImpulse(Point impulse, Point offset);
virtual void applyImpulse(const Vect& impulse, const Point& offset);
/**
* @brief Applies a torque force to body.
*/
virtual void applyTorque(float torque);
virtual void setVelocity(Point velocity);
virtual void setVelocity(const Vect& velocity);
virtual Point getVelocity();
virtual void setAngularVelocity(float velocity);
virtual Point getVelocityAtLocalPoint(Point point);
virtual Point getVelocityAtWorldPoint(Point point);
virtual Point getVelocityAtLocalPoint(const Point& point);
virtual Point getVelocityAtWorldPoint(const Point& point);
virtual float getAngularVelocity();
virtual void setVelocityLimit(float limit);
virtual float getVelocityLimit();
@ -129,12 +129,12 @@ public:
* @brief get the first body shapes.
*/
inline PhysicsShape* getShape() const { return _shapes->count() >= 1 ? dynamic_cast<PhysicsShape*>(_shapes->getObjectAtIndex(0)) : nullptr; }
PhysicsShape* getShapeByTag(int tag) const;
PhysicsShape* getShape(int tag) const;
/*
* @brief remove a shape from body
*/
void removeShape(PhysicsShape* shape);
void removeShapeByTag(int tag);
void removeShape(int tag);
/*
* @brief remove all shapes
*/

4
cocos/physics/CCPhysicsContact.cpp
View File

@ -150,9 +150,9 @@ void PhysicsContactPreSolve::setFriction(float friction)
static_cast<cpArbiter*>(_contactInfo)->u = friction;
}
void PhysicsContactPreSolve::setSurfaceVelocity(Point surfaceVelocity)
void PhysicsContactPreSolve::setSurfaceVelocity(const Vect& velocity)
{
static_cast<cpArbiter*>(_contactInfo)->surface_vr = PhysicsHelper::point2cpv(surfaceVelocity);
static_cast<cpArbiter*>(_contactInfo)->surface_vr = PhysicsHelper::point2cpv(velocity);
}
void PhysicsContactPreSolve::ignore()

2
cocos/physics/CCPhysicsContact.h
View File

@ -138,7 +138,7 @@ public:
Point getSurfaceVelocity() const;
void setElasticity(float elasticity);
void setFriction(float friction);
void setSurfaceVelocity(Point surfaceVelocity);
void setSurfaceVelocity(const Vect& velocity);
void ignore();
private:

26
cocos/physics/CCPhysicsJoint.cpp
View File

@ -197,13 +197,13 @@ bool PhysicsJointFixed::init(PhysicsBody* a, PhysicsBody* b, const Point& anchr)
getBodyNode(b)->setPosition(anchr);
// add a pivot joint to fixed two body together
cpConstraint* joint = cpPivotJointNew(getBodyInfo(a)->body, getBodyInfo(b)->body,
cpConstraint* joint = cpPivotJointNew(getBodyInfo(a)->getBody(), getBodyInfo(b)->getBody(),
PhysicsHelper::point2cpv(anchr));
CC_BREAK_IF(joint == nullptr);
_info->add(joint);
// add a gear joint to make two body have the same rotation.
joint = cpGearJointNew(getBodyInfo(a)->body, getBodyInfo(b)->body, 0, 1);
joint = cpGearJointNew(getBodyInfo(a)->getBody(), getBodyInfo(b)->getBody(), 0, 1);
CC_BREAK_IF(joint == nullptr);
_info->add(joint);
@ -233,7 +233,7 @@ bool PhysicsJointPin::init(PhysicsBody *a, PhysicsBody *b, const Point& anchr)
do
{
CC_BREAK_IF(!PhysicsJoint::init(a, b));
cpConstraint* joint = cpPivotJointNew(getBodyInfo(a)->body, getBodyInfo(b)->body,
cpConstraint* joint = cpPivotJointNew(getBodyInfo(a)->getBody(), getBodyInfo(b)->getBody(),
PhysicsHelper::point2cpv(anchr));
CC_BREAK_IF(joint == nullptr);
@ -248,12 +248,12 @@ bool PhysicsJointPin::init(PhysicsBody *a, PhysicsBody *b, const Point& anchr)
void PhysicsJointPin::setMaxForce(float force)
{
_info->joints.front()->maxForce = PhysicsHelper::float2cpfloat(force);
_info->getJoints().front()->maxForce = PhysicsHelper::float2cpfloat(force);
}
float PhysicsJointPin::getMaxForce() const
{
return PhysicsHelper::cpfloat2float(_info->joints.front()->maxForce);
return PhysicsHelper::cpfloat2float(_info->getJoints().front()->maxForce);
}
PhysicsJointSliding* PhysicsJointSliding::create(PhysicsBody* a, PhysicsBody* b, const Point& grooveA, const Point& grooveB, const Point& anchr)
@ -275,7 +275,7 @@ bool PhysicsJointSliding::init(PhysicsBody* a, PhysicsBody* b, const Point& groo
{
CC_BREAK_IF(!PhysicsJoint::init(a, b));
cpConstraint* joint = cpGrooveJointNew(getBodyInfo(a)->body, getBodyInfo(b)->body,
cpConstraint* joint = cpGrooveJointNew(getBodyInfo(a)->getBody(), getBodyInfo(b)->getBody(),
PhysicsHelper::point2cpv(grooveA),
PhysicsHelper::point2cpv(grooveB),
PhysicsHelper::point2cpv(anchr));
@ -310,7 +310,7 @@ bool PhysicsJointLimit::init(PhysicsBody* a, PhysicsBody* b, const Point& anchr1
{
CC_BREAK_IF(!PhysicsJoint::init(a, b));
cpConstraint* joint = cpSlideJointNew(getBodyInfo(a)->body, getBodyInfo(b)->body,
cpConstraint* joint = cpSlideJointNew(getBodyInfo(a)->getBody(), getBodyInfo(b)->getBody(),
PhysicsHelper::point2cpv(anchr1),
PhysicsHelper::point2cpv(anchr2),
0,
@ -328,22 +328,22 @@ bool PhysicsJointLimit::init(PhysicsBody* a, PhysicsBody* b, const Point& anchr1
float PhysicsJointLimit::getMin() const
{
return PhysicsHelper::cpfloat2float(cpSlideJointGetMin(_info->joints.front()));
return PhysicsHelper::cpfloat2float(cpSlideJointGetMin(_info->getJoints().front()));
}
void PhysicsJointLimit::setMin(float min)
{
cpSlideJointSetMin(_info->joints.front(), PhysicsHelper::float2cpfloat(min));
cpSlideJointSetMin(_info->getJoints().front(), PhysicsHelper::float2cpfloat(min));
}
float PhysicsJointLimit::getMax() const
{
return PhysicsHelper::cpfloat2float(cpSlideJointGetMax(_info->joints.front()));
return PhysicsHelper::cpfloat2float(cpSlideJointGetMax(_info->getJoints().front()));
}
void PhysicsJointLimit::setMax(float max)
{
cpSlideJointSetMax(_info->joints.front(), PhysicsHelper::float2cpfloat(max));
cpSlideJointSetMax(_info->getJoints().front(), PhysicsHelper::float2cpfloat(max));
}
PhysicsJointDistance* PhysicsJointDistance::create(PhysicsBody* a, PhysicsBody* b, const Point& anchr1, const Point& anchr2)
@ -365,8 +365,8 @@ bool PhysicsJointDistance::init(PhysicsBody* a, PhysicsBody* b, const Point& anc
{
CC_BREAK_IF(!PhysicsJoint::init(a, b));
cpConstraint* joint = cpPinJointNew(getBodyInfo(a)->body,
getBodyInfo(b)->body,
cpConstraint* joint = cpPinJointNew(getBodyInfo(a)->getBody(),
getBodyInfo(b)->getBody(),
PhysicsHelper::point2cpv(anchr1), PhysicsHelper::point2cpv(anchr2));
CC_BREAK_IF(joint == nullptr);

3
cocos/physics/CCPhysicsSetting.h
View File

@ -47,6 +47,9 @@ namespace cocos2d
{
extern const float PHYSICS_INFINITY;
class Point;
typedef Point Vect;
#if (CC_PHYSICS_ENGINE == CC_PHYSICS_CHIPMUNK)
static const int PHYSICS_CONTACT_POINT_MAX = 4;
#else

104
cocos/physics/CCPhysicsShape.cpp
View File

@ -105,7 +105,7 @@ void PhysicsShape::setMoment(float moment)
_moment = moment;
}
void PhysicsShape::setMaterial(PhysicsMaterial material)
void PhysicsShape::setMaterial(const PhysicsMaterial& material)
{
setDensity(material.density);
setRestitution(material.restitution);
@ -216,7 +216,7 @@ void PhysicsShape::setRestitution(float restitution)
{
_material.restitution = restitution;
for (cpShape* shape : _info->shapes)
for (cpShape* shape : _info->getShapes())
{
cpShapeSetElasticity(shape, PhysicsHelper::float2cpfloat(restitution));
}
@ -226,14 +226,14 @@ void PhysicsShape::setFriction(float friction)
{
_material.friction = friction;
for (cpShape* shape : _info->shapes)
for (cpShape* shape : _info->getShapes())
{
cpShapeSetFriction(shape, PhysicsHelper::float2cpfloat(friction));
}
}
Point* PhysicsShape::recenterPoints(Point* points, int count, Point center)
Point* PhysicsShape::recenterPoints(Point* points, int count, const Point& center)
{
cpVect* cpvs = new cpVect[count];
cpRecenterPoly(count, PhysicsHelper::points2cpvs(points, cpvs, count));
@ -251,7 +251,7 @@ Point* PhysicsShape::recenterPoints(Point* points, int count, Point center)
return points;
}
Point PhysicsShape::getPolyonCenter(Point* points, int count)
Point PhysicsShape::getPolyonCenter(const Point* points, int count)
{
cpVect* cpvs = new cpVect[count];
cpVect center = cpCentroidForPoly(count, PhysicsHelper::points2cpvs(points, cpvs, count));
@ -280,14 +280,14 @@ void PhysicsShape::setBody(PhysicsBody *body)
_body = nullptr;
}else
{
_info->setBody(body->_info->body);
_info->setBody(body->_info->getBody());
//_info->setGroup(body->_info->group);
_body = body;
}
}
// PhysicsShapeCircle
PhysicsShapeCircle* PhysicsShapeCircle::create(float radius, PhysicsMaterial material/* = MaterialDefault*/, Point offset/* = Point(0, 0)*/)
PhysicsShapeCircle* PhysicsShapeCircle::create(float radius, const PhysicsMaterial& material/* = MaterialDefault*/, const Point& offset/* = Point(0, 0)*/)
{
PhysicsShapeCircle* shape = new PhysicsShapeCircle();
if (shape && shape->init(radius, material, offset))
@ -300,13 +300,13 @@ PhysicsShapeCircle* PhysicsShapeCircle::create(float radius, PhysicsMaterial mat
return nullptr;
}
bool PhysicsShapeCircle::init(float radius, PhysicsMaterial material/* = MaterialDefault*/, Point offset /*= Point(0, 0)*/)
bool PhysicsShapeCircle::init(float radius, const PhysicsMaterial& material/* = MaterialDefault*/, const Point& offset /*= Point(0, 0)*/)
{
do
{
CC_BREAK_IF(!PhysicsShape::init(Type::CIRCLE));
cpShape* shape = cpCircleShapeNew(_info->shareBody, radius, PhysicsHelper::point2cpv(offset));
cpShape* shape = cpCircleShapeNew(_info->getSharedBody(), radius, PhysicsHelper::point2cpv(offset));
CC_BREAK_IF(shape == nullptr);
@ -328,7 +328,7 @@ float PhysicsShapeCircle::calculateArea(float radius)
return PhysicsHelper::cpfloat2float(cpAreaForCircle(0, radius));
}
float PhysicsShapeCircle::calculateMoment(float mass, float radius, Point offset)
float PhysicsShapeCircle::calculateMoment(float mass, float radius, const Point& offset)
{
return mass == PHYSICS_INFINITY ? PHYSICS_INFINITY
: PhysicsHelper::cpfloat2float(cpMomentForCircle(PhysicsHelper::float2cpfloat(mass),
@ -339,12 +339,12 @@ float PhysicsShapeCircle::calculateMoment(float mass, float radius, Point offset
float PhysicsShapeCircle::calculateDefaultArea()
{
return PhysicsHelper::cpfloat2float(cpAreaForCircle(0, cpCircleShapeGetRadius(_info->shapes.front())));
return PhysicsHelper::cpfloat2float(cpAreaForCircle(0, cpCircleShapeGetRadius(_info->getShapes().front())));
}
float PhysicsShapeCircle::calculateDefaultMoment()
{
cpShape* shape = _info->shapes.front();
cpShape* shape = _info->getShapes().front();
return _mass == PHYSICS_INFINITY ? PHYSICS_INFINITY
: PhysicsHelper::cpfloat2float(cpMomentForCircle(PhysicsHelper::float2cpfloat(_mass),
@ -355,16 +355,16 @@ float PhysicsShapeCircle::calculateDefaultMoment()
float PhysicsShapeCircle::getRadius() const
{
return PhysicsHelper::cpfloat2float(cpCircleShapeGetRadius(_info->shapes.front()));
return PhysicsHelper::cpfloat2float(cpCircleShapeGetRadius(_info->getShapes().front()));
}
Point PhysicsShapeCircle::getOffset()
{
return PhysicsHelper::cpv2point(cpCircleShapeGetOffset(_info->shapes.front()));
return PhysicsHelper::cpv2point(cpCircleShapeGetOffset(_info->getShapes().front()));
}
// PhysicsShapeEdgeSegment
PhysicsShapeEdgeSegment* PhysicsShapeEdgeSegment::create(Point a, Point b, PhysicsMaterial material/* = MaterialDefault*/, float border/* = 1*/)
PhysicsShapeEdgeSegment* PhysicsShapeEdgeSegment::create(const Point& a, const Point& b, const PhysicsMaterial& material/* = MaterialDefault*/, float border/* = 1*/)
{
PhysicsShapeEdgeSegment* shape = new PhysicsShapeEdgeSegment();
if (shape && shape->init(a, b, material, border))
@ -377,13 +377,13 @@ PhysicsShapeEdgeSegment* PhysicsShapeEdgeSegment::create(Point a, Point b, Physi
return nullptr;
}
bool PhysicsShapeEdgeSegment::init(Point a, Point b, PhysicsMaterial material/* = MaterialDefault*/, float border/* = 1*/)
bool PhysicsShapeEdgeSegment::init(const Point& a, const Point& b, const PhysicsMaterial& material/* = MaterialDefault*/, float border/* = 1*/)
{
do
{
CC_BREAK_IF(!PhysicsShape::init(Type::EDGESEGMENT));
cpShape* shape = cpSegmentShapeNew(_info->shareBody,
cpShape* shape = cpSegmentShapeNew(_info->getSharedBody(),
PhysicsHelper::point2cpv(a),
PhysicsHelper::point2cpv(b),
PhysicsHelper::float2cpfloat(border));
@ -407,12 +407,12 @@ bool PhysicsShapeEdgeSegment::init(Point a, Point b, PhysicsMaterial material/*
Point PhysicsShapeEdgeSegment::getPointA() const
{
return PhysicsHelper::cpv2point(((cpSegmentShape*)(_info->shapes.front()))->ta);
return PhysicsHelper::cpv2point(((cpSegmentShape*)(_info->getShapes().front()))->ta);
}
Point PhysicsShapeEdgeSegment::getPointB() const
{
return PhysicsHelper::cpv2point(((cpSegmentShape*)(_info->shapes.front()))->tb);
return PhysicsHelper::cpv2point(((cpSegmentShape*)(_info->getShapes().front()))->tb);
}
Point PhysicsShapeEdgeSegment::getCenter()
@ -421,7 +421,7 @@ Point PhysicsShapeEdgeSegment::getCenter()
}
// PhysicsShapeBox
PhysicsShapeBox* PhysicsShapeBox::create(Size size, PhysicsMaterial material/* = MaterialDefault*/, Point offset/* = Point(0, 0)*/)
PhysicsShapeBox* PhysicsShapeBox::create(const Size& size, const PhysicsMaterial& material/* = MaterialDefault*/, const Point& offset/* = Point(0, 0)*/)
{
PhysicsShapeBox* shape = new PhysicsShapeBox();
if (shape && shape->init(size, material, offset))
@ -434,7 +434,7 @@ PhysicsShapeBox* PhysicsShapeBox::create(Size size, PhysicsMaterial material/* =
return nullptr;
}
bool PhysicsShapeBox::init(Size size, PhysicsMaterial material/* = MaterialDefault*/, Point offset /*= Point(0, 0)*/)
bool PhysicsShapeBox::init(const Size& size, const PhysicsMaterial& material/* = MaterialDefault*/, const Point& offset /*= Point(0, 0)*/)
{
do
{
@ -446,7 +446,7 @@ bool PhysicsShapeBox::init(Size size, PhysicsMaterial material/* = MaterialDefau
{-wh.x/2.0f, -wh.y/2.0f}, {-wh.x/2.0f, wh.y/2.0f}, {wh.x/2.0f, wh.y/2.0f}, {wh.x/2.0f, -wh.y/2.0f}
};
cpShape* shape = cpPolyShapeNew(_info->shareBody, 4, vec, PhysicsHelper::point2cpv(offset));
cpShape* shape = cpPolyShapeNew(_info->getSharedBody(), 4, vec, PhysicsHelper::point2cpv(offset));
CC_BREAK_IF(shape == nullptr);
@ -465,7 +465,7 @@ bool PhysicsShapeBox::init(Size size, PhysicsMaterial material/* = MaterialDefau
return false;
}
float PhysicsShapeBox::calculateArea(Size size)
float PhysicsShapeBox::calculateArea(const Size& size)
{
cpVect wh = PhysicsHelper::size2cpv(size);
cpVect vec[4] =
@ -475,7 +475,7 @@ float PhysicsShapeBox::calculateArea(Size size)
return PhysicsHelper::cpfloat2float(cpAreaForPoly(4, vec));
}
float PhysicsShapeBox::calculateMoment(float mass, Size size, Point offset)
float PhysicsShapeBox::calculateMoment(float mass, const Size& size, const Point& offset)
{
cpVect wh = PhysicsHelper::size2cpv(size);
cpVect vec[4] =
@ -492,20 +492,20 @@ float PhysicsShapeBox::calculateMoment(float mass, Size size, Point offset)
float PhysicsShapeBox::calculateDefaultArea()
{
cpShape* shape = _info->shapes.front();
cpShape* shape = _info->getShapes().front();
return PhysicsHelper::cpfloat2float(cpAreaForPoly(((cpPolyShape*)shape)->numVerts, ((cpPolyShape*)shape)->verts));
}
float PhysicsShapeBox::calculateDefaultMoment()
{
cpShape* shape = _info->shapes.front();
cpShape* shape = _info->getShapes().front();
return _mass == PHYSICS_INFINITY ? PHYSICS_INFINITY
: PhysicsHelper::cpfloat2float(cpMomentForPoly(_mass, ((cpPolyShape*)shape)->numVerts, ((cpPolyShape*)shape)->verts, cpvzero));
}
Point* PhysicsShapeBox::getPoints(Point* points) const
{
cpShape* shape = _info->shapes.front();
cpShape* shape = _info->getShapes().front();
return PhysicsHelper::cpvs2points(((cpPolyShape*)shape)->verts, points, ((cpPolyShape*)shape)->numVerts);
return points;
@ -513,13 +513,13 @@ Point* PhysicsShapeBox::getPoints(Point* points) const
Size PhysicsShapeBox::getSize() const
{
cpShape* shape = _info->shapes.front();
cpShape* shape = _info->getShapes().front();
return PhysicsHelper::cpv2size(cpv(cpvdist(cpPolyShapeGetVert(shape, 0), cpPolyShapeGetVert(shape, 1)),
cpvdist(cpPolyShapeGetVert(shape, 1), cpPolyShapeGetVert(shape, 2))));
}
// PhysicsShapePolygon
PhysicsShapePolygon* PhysicsShapePolygon::create(Point* points, int count, PhysicsMaterial material/* = MaterialDefault*/, Point offset/* = Point(0, 0)*/)
PhysicsShapePolygon* PhysicsShapePolygon::create(const Point* points, int count, const PhysicsMaterial& material/* = MaterialDefault*/, const Point& offset/* = Point(0, 0)*/)
{
PhysicsShapePolygon* shape = new PhysicsShapePolygon();
if (shape && shape->init(points, count, material, offset))
@ -532,7 +532,7 @@ PhysicsShapePolygon* PhysicsShapePolygon::create(Point* points, int count, Physi
return nullptr;
}
bool PhysicsShapePolygon::init(Point* points, int count, PhysicsMaterial material/* = MaterialDefault*/, Point offset/* = Point(0, 0)*/)
bool PhysicsShapePolygon::init(const Point* points, int count, const PhysicsMaterial& material/* = MaterialDefault*/, const Point& offset/* = Point(0, 0)*/)
{
do
{
@ -540,7 +540,7 @@ bool PhysicsShapePolygon::init(Point* points, int count, PhysicsMaterial materia
cpVect* vecs = new cpVect[count];
PhysicsHelper::points2cpvs(points, vecs, count);
cpShape* shape = cpPolyShapeNew(_info->shareBody, count, vecs, PhysicsHelper::point2cpv(offset));
cpShape* shape = cpPolyShapeNew(_info->getSharedBody(), count, vecs, PhysicsHelper::point2cpv(offset));
CC_SAFE_DELETE(vecs);
CC_BREAK_IF(shape == nullptr);
@ -560,7 +560,7 @@ bool PhysicsShapePolygon::init(Point* points, int count, PhysicsMaterial materia
return false;
}
float PhysicsShapePolygon::calculateArea(Point* points, int count)
float PhysicsShapePolygon::calculateArea(const Point* points, int count)
{
cpVect* vecs = new cpVect[count];
PhysicsHelper::points2cpvs(points, vecs, count);
@ -570,7 +570,7 @@ float PhysicsShapePolygon::calculateArea(Point* points, int count)
return area;
}
float PhysicsShapePolygon::calculateMoment(float mass, Point* points, int count, Point offset)
float PhysicsShapePolygon::calculateMoment(float mass, const Point* points, int count, const Point& offset)
{
cpVect* vecs = new cpVect[count];
PhysicsHelper::points2cpvs(points, vecs, count);
@ -583,31 +583,31 @@ float PhysicsShapePolygon::calculateMoment(float mass, Point* points, int count,
float PhysicsShapePolygon::calculateDefaultArea()
{
cpShape* shape = _info->shapes.front();
cpShape* shape = _info->getShapes().front();
return PhysicsHelper::cpfloat2float(cpAreaForPoly(((cpPolyShape*)shape)->numVerts, ((cpPolyShape*)shape)->verts));
}
float PhysicsShapePolygon::calculateDefaultMoment()
{
cpShape* shape = _info->shapes.front();
cpShape* shape = _info->getShapes().front();
return _mass == PHYSICS_INFINITY ? PHYSICS_INFINITY
: PhysicsHelper::cpfloat2float(cpMomentForPoly(_mass, ((cpPolyShape*)shape)->numVerts, ((cpPolyShape*)shape)->verts, cpvzero));
}
Point PhysicsShapePolygon::getPoint(int i) const
{
return PhysicsHelper::cpv2point(cpPolyShapeGetVert(_info->shapes.front(), i));
return PhysicsHelper::cpv2point(cpPolyShapeGetVert(_info->getShapes().front(), i));
}
Point* PhysicsShapePolygon::getPoints(Point* points) const
{
cpShape* shape = _info->shapes.front();
cpShape* shape = _info->getShapes().front();
return PhysicsHelper::cpvs2points(((cpPolyShape*)shape)->verts, points, ((cpPolyShape*)shape)->numVerts);
}
int PhysicsShapePolygon::getPointsCount() const
{
return ((cpPolyShape*)_info->shapes.front())->numVerts;
return ((cpPolyShape*)_info->getShapes().front())->numVerts;
}
Point PhysicsShapePolygon::getCenter()
@ -616,7 +616,7 @@ Point PhysicsShapePolygon::getCenter()
}
// PhysicsShapeEdgeBox
PhysicsShapeEdgeBox* PhysicsShapeEdgeBox::create(Size size, PhysicsMaterial material/* = MaterialDefault*/, float border/* = 1*/, Point offset/* = Point(0, 0)*/)
PhysicsShapeEdgeBox* PhysicsShapeEdgeBox::create(const Size& size, const PhysicsMaterial& material/* = MaterialDefault*/, float border/* = 1*/, const Point& offset/* = Point(0, 0)*/)
{
PhysicsShapeEdgeBox* shape = new PhysicsShapeEdgeBox();
if (shape && shape->init(size, material, border, offset))
@ -629,7 +629,7 @@ PhysicsShapeEdgeBox* PhysicsShapeEdgeBox::create(Size size, PhysicsMaterial mate
return nullptr;
}
bool PhysicsShapeEdgeBox::init(Size size, PhysicsMaterial material/* = MaterialDefault*/, float border/* = 1*/, Point offset/*= Point(0, 0)*/)
bool PhysicsShapeEdgeBox::init(const Size& size, const PhysicsMaterial& material/* = MaterialDefault*/, float border/* = 1*/, const Point& offset/*= Point(0, 0)*/)
{
do
{
@ -644,7 +644,7 @@ bool PhysicsShapeEdgeBox::init(Size size, PhysicsMaterial material/* = MaterialD
int i = 0;
for (; i < 4; ++i)
{
cpShape* shape = cpSegmentShapeNew(_info->shareBody, vec[i], vec[(i+1)%4],
cpShape* shape = cpSegmentShapeNew(_info->getSharedBody(), vec[i], vec[(i+1)%4],
PhysicsHelper::float2cpfloat(border));
CC_BREAK_IF(shape == nullptr);
_info->add(shape);
@ -664,7 +664,7 @@ bool PhysicsShapeEdgeBox::init(Size size, PhysicsMaterial material/* = MaterialD
}
// PhysicsShapeEdgeBox
PhysicsShapeEdgePolygon* PhysicsShapeEdgePolygon::create(Point* points, int count, PhysicsMaterial material/* = MaterialDefault*/, float border/* = 1*/)
PhysicsShapeEdgePolygon* PhysicsShapeEdgePolygon::create(const Point* points, int count, const PhysicsMaterial& material/* = MaterialDefault*/, float border/* = 1*/)
{
PhysicsShapeEdgePolygon* shape = new PhysicsShapeEdgePolygon();
if (shape && shape->init(points, count, material, border))
@ -677,7 +677,7 @@ PhysicsShapeEdgePolygon* PhysicsShapeEdgePolygon::create(Point* points, int coun
return nullptr;
}
bool PhysicsShapeEdgePolygon::init(Point* points, int count, PhysicsMaterial material/* = MaterialDefault*/, float border/* = 1*/)
bool PhysicsShapeEdgePolygon::init(const Point* points, int count, const PhysicsMaterial& material/* = MaterialDefault*/, float border/* = 1*/)
{
cpVect* vec = nullptr;
do
@ -691,7 +691,7 @@ bool PhysicsShapeEdgePolygon::init(Point* points, int count, PhysicsMaterial mat
int i = 0;
for (; i < count; ++i)
{
cpShape* shape = cpSegmentShapeNew(_info->shareBody, vec[i], vec[(i+1)%count],
cpShape* shape = cpSegmentShapeNew(_info->getSharedBody(), vec[i], vec[(i+1)%count],
PhysicsHelper::float2cpfloat(border));
CC_BREAK_IF(shape == nullptr);
cpShapeSetElasticity(shape, 1.0f);
@ -722,11 +722,11 @@ Point PhysicsShapeEdgePolygon::getCenter()
int PhysicsShapeEdgePolygon::getPointsCount() const
{
return _info->shapes.size() + 1;
return _info->getShapes().size() + 1;
}
// PhysicsShapeEdgeChain
PhysicsShapeEdgeChain* PhysicsShapeEdgeChain::create(Point* points, int count, PhysicsMaterial material/* = MaterialDefault*/, float border/* = 1*/)
PhysicsShapeEdgeChain* PhysicsShapeEdgeChain::create(const Point* points, int count, const PhysicsMaterial& material/* = MaterialDefault*/, float border/* = 1*/)
{
PhysicsShapeEdgeChain* shape = new PhysicsShapeEdgeChain();
if (shape && shape->init(points, count, material, border))
@ -739,7 +739,7 @@ PhysicsShapeEdgeChain* PhysicsShapeEdgeChain::create(Point* points, int count, P
return nullptr;
}
bool PhysicsShapeEdgeChain::init(Point* points, int count, PhysicsMaterial material/* = MaterialDefault*/, float border/* = 1*/)
bool PhysicsShapeEdgeChain::init(const Point* points, int count, const PhysicsMaterial& material/* = MaterialDefault*/, float border/* = 1*/)
{
cpVect* vec = nullptr;
do
@ -753,7 +753,7 @@ bool PhysicsShapeEdgeChain::init(Point* points, int count, PhysicsMaterial mater
int i = 0;
for (; i < count - 1; ++i)
{
cpShape* shape = cpSegmentShapeNew(_info->shareBody, vec[i], vec[i+1],
cpShape* shape = cpSegmentShapeNew(_info->getSharedBody(), vec[i], vec[i+1],
PhysicsHelper::float2cpfloat(border));
CC_BREAK_IF(shape == nullptr);
cpShapeSetElasticity(shape, 1.0f);
@ -783,23 +783,23 @@ Point PhysicsShapeEdgeChain::getCenter()
int PhysicsShapeEdgeChain::getPointsCount() const
{
return _info->shapes.size() + 1;
return _info->getShapes().size() + 1;
}
void PhysicsShape::setGroup(int group)
{
if (group < 0)
{
for (auto shape : _info->shapes)
for (auto shape : _info->getShapes())
{
cpShapeSetGroup(shape, (cpGroup)group);
}
}
}
bool PhysicsShape::containsPoint(Point point) const
bool PhysicsShape::containsPoint(const Point& point) const
{
for (auto shape : _info->shapes)
for (auto shape : _info->getShapes())
{
if (cpShapePointQuery(shape, PhysicsHelper::point2cpv(point)))
{

48
cocos/physics/CCPhysicsShape.h
View File

@ -92,16 +92,16 @@ public:
void setDensity(float density);
void setRestitution(float restitution);
void setFriction(float friction);
void setMaterial(PhysicsMaterial material);
void setMaterial(const PhysicsMaterial& material);
virtual float calculateDefaultMoment() { return 0; }
virtual float calculateDefaultArea() { return 0; }
virtual Point getOffset() { return Point::ZERO; }
virtual Point getCenter() { return getOffset(); }
bool containsPoint(Point point) const;
bool containsPoint(const Point& point) const;
static Point* recenterPoints(Point* points, int count, Point center = Point::ZERO);
static Point getPolyonCenter(Point* points, int count);
static Point* recenterPoints(Point* points, int count, const Point& center = Point::ZERO);
static Point getPolyonCenter(const Point* points, int count);
inline void setCategoryBitmask(int bitmask) { _categoryBitmask = bitmask; }
inline int getCategoryBitmask() const { return _categoryBitmask; }
@ -150,9 +150,9 @@ protected:
class PhysicsShapeCircle : public PhysicsShape
{
public:
static PhysicsShapeCircle* create(float radius, PhysicsMaterial material = PHYSICSSHAPE_MATERIAL_DEFAULT, Point offset = Point(0, 0));
static PhysicsShapeCircle* create(float radius, const PhysicsMaterial& material = PHYSICSSHAPE_MATERIAL_DEFAULT, const Point& offset = Point(0, 0));
static float calculateArea(float radius);
static float calculateMoment(float mass, float radius, Point offset = Point(0, 0));
static float calculateMoment(float mass, float radius, const Point& offset = Point::ZERO);
float calculateDefaultArea() override;
float calculateDefaultMoment() override;
@ -160,7 +160,7 @@ public:
float getRadius() const;
Point getOffset() override;
protected:
bool init(float radius, PhysicsMaterial material = PHYSICSSHAPE_MATERIAL_DEFAULT, Point offset = Point(0, 0));
bool init(float radius, const PhysicsMaterial& material = PHYSICSSHAPE_MATERIAL_DEFAULT, const Point& offset = Point::ZERO);
protected:
PhysicsShapeCircle();
@ -171,9 +171,9 @@ protected:
class PhysicsShapeBox : public PhysicsShape
{
public:
static PhysicsShapeBox* create(Size size, PhysicsMaterial material = PHYSICSSHAPE_MATERIAL_DEFAULT, Point offset = Point(0, 0));
static float calculateArea(Size size);
static float calculateMoment(float mass, Size size, Point offset = Point(0, 0));
static PhysicsShapeBox* create(const Size& size, const PhysicsMaterial& material = PHYSICSSHAPE_MATERIAL_DEFAULT, const Point& offset = Point::ZERO);
static float calculateArea(const Size& size);
static float calculateMoment(float mass, const Size& size, const Point& offset = Point::ZERO);
float calculateDefaultArea() override;
float calculateDefaultMoment() override;
@ -183,7 +183,7 @@ public:
Point getOffset() override { return _offset; }
protected:
bool init(Size size, PhysicsMaterial material = PHYSICSSHAPE_MATERIAL_DEFAULT, Point offset = Point(0, 0));
bool init(const Size& size, const PhysicsMaterial& material = PHYSICSSHAPE_MATERIAL_DEFAULT, const Point& offset = Point::ZERO);
protected:
PhysicsShapeBox();
@ -197,9 +197,9 @@ protected:
class PhysicsShapePolygon : public PhysicsShape
{
public:
static PhysicsShapePolygon* create(Point* points, int count, PhysicsMaterial material = PHYSICSSHAPE_MATERIAL_DEFAULT, Point offset = Point(0, 0));
static float calculateArea(Point* points, int count);
static float calculateMoment(float mass, Point* points, int count, Point offset = Point(0, 0));
static PhysicsShapePolygon* create(const Point* points, int count, const PhysicsMaterial& material = PHYSICSSHAPE_MATERIAL_DEFAULT, const Point& offset = Point::ZERO);
static float calculateArea(const Point* points, int count);
static float calculateMoment(float mass, const Point* points, int count, const Point& offset = Point::ZERO);
float calculateDefaultArea() override;
float calculateDefaultMoment() override;
@ -209,7 +209,7 @@ public:
int getPointsCount() const;
Point getCenter() override;
protected:
bool init(Point* points, int count, PhysicsMaterial material = PHYSICSSHAPE_MATERIAL_DEFAULT, Point offset = Point(0, 0));
bool init(const Point* points, int count, const PhysicsMaterial& material = PHYSICSSHAPE_MATERIAL_DEFAULT, const Point& offset = Point::ZERO);
protected:
PhysicsShapePolygon();
@ -223,14 +223,14 @@ protected:
class PhysicsShapeEdgeSegment : public PhysicsShape
{
public:
static PhysicsShapeEdgeSegment* create(Point a, Point b, PhysicsMaterial material = PHYSICSSHAPE_MATERIAL_DEFAULT, float border = 1);
static PhysicsShapeEdgeSegment* create(const Point& a, const Point& b, const PhysicsMaterial& material = PHYSICSSHAPE_MATERIAL_DEFAULT, float border = 1);
Point getPointA() const;
Point getPointB() const;
Point getCenter() override;
protected:
bool init(Point a, Point b, PhysicsMaterial material = PHYSICSSHAPE_MATERIAL_DEFAULT, float border = 1);
bool init(const Point& a, const Point& b, const PhysicsMaterial& material = PHYSICSSHAPE_MATERIAL_DEFAULT, float border = 1);
protected:
PhysicsShapeEdgeSegment();
@ -246,13 +246,13 @@ protected:
class PhysicsShapeEdgeBox : public PhysicsShape
{
public:
static PhysicsShapeEdgeBox* create(Size size, PhysicsMaterial material = PHYSICSSHAPE_MATERIAL_DEFAULT, float border = 0, Point offset = Point(0, 0));
static PhysicsShapeEdgeBox* create(const Size& size, const PhysicsMaterial& material = PHYSICSSHAPE_MATERIAL_DEFAULT, float border = 0, const Point& offset = Point::ZERO);
Point getOffset() override { return _offset; }
Point* getPoints(Point* points) const;
Point* getPoints(const Point* points) const;
int getPointsCount() const;
protected:
bool init(Size size, PhysicsMaterial material = PHYSICSSHAPE_MATERIAL_DEFAULT, float border = 1, Point offset = Point(0, 0));
bool init(const Size& size, const PhysicsMaterial& material = PHYSICSSHAPE_MATERIAL_DEFAULT, float border = 1, const Point& offset = Point::ZERO);
protected:
PhysicsShapeEdgeBox();
@ -268,13 +268,13 @@ protected:
class PhysicsShapeEdgePolygon : public PhysicsShape
{
public:
static PhysicsShapeEdgePolygon* create(Point* points, int count, PhysicsMaterial material = PHYSICSSHAPE_MATERIAL_DEFAULT, float border = 1);
static PhysicsShapeEdgePolygon* create(const Point* points, int count, const PhysicsMaterial& material = PHYSICSSHAPE_MATERIAL_DEFAULT, float border = 1);
Point getCenter() override;
Point* getPoints(Point* points) const;
int getPointsCount() const;
protected:
bool init(Point* points, int count, PhysicsMaterial material = PHYSICSSHAPE_MATERIAL_DEFAULT, float border = 1);
bool init(const Point* points, int count, const PhysicsMaterial& material = PHYSICSSHAPE_MATERIAL_DEFAULT, float border = 1);
protected:
PhysicsShapeEdgePolygon();
@ -290,13 +290,13 @@ protected:
class PhysicsShapeEdgeChain : public PhysicsShape
{
public:
static PhysicsShapeEdgeChain* create(Point* points, int count, PhysicsMaterial material = PHYSICSSHAPE_MATERIAL_DEFAULT, float border = 1);
static PhysicsShapeEdgeChain* create(const Point* points, int count, const PhysicsMaterial& material = PHYSICSSHAPE_MATERIAL_DEFAULT, float border = 1);
Point getCenter() override;
Point* getPoints(Point* points) const;
int getPointsCount() const;
protected:
bool init(Point* points, int count, PhysicsMaterial material = PHYSICSSHAPE_MATERIAL_DEFAULT, float border = 1);
bool init(const Point* points, int count, const PhysicsMaterial& material = PHYSICSSHAPE_MATERIAL_DEFAULT, float border = 1);
protected:
PhysicsShapeEdgeChain();

88
cocos/physics/CCPhysicsWorld.cpp
View File

@ -106,11 +106,11 @@ int PhysicsWorldCallback::collisionBeginCallbackFunc(cpArbiter *arb, struct cpSp
{
CP_ARBITER_GET_SHAPES(arb, a, b);
auto ita = PhysicsShapeInfo::map.find(a);
auto itb = PhysicsShapeInfo::map.find(b);
CC_ASSERT(ita != PhysicsShapeInfo::map.end() && itb != PhysicsShapeInfo::map.end());
auto ita = PhysicsShapeInfo::getMap().find(a);
auto itb = PhysicsShapeInfo::getMap().find(b);
CC_ASSERT(ita != PhysicsShapeInfo::getMap().end() && itb != PhysicsShapeInfo::getMap().end());
PhysicsContact* contact = PhysicsContact::create(ita->second->shape, itb->second->shape);
PhysicsContact* contact = PhysicsContact::create(ita->second->getShape(), itb->second->getShape());
arb->data = contact;
contact->_contactInfo = arb;
@ -143,12 +143,12 @@ void PhysicsWorldCallback::rayCastCallbackFunc(cpShape *shape, cpFloat t, cpVect
return;
}
auto it = PhysicsShapeInfo::map.find(shape);
CC_ASSERT(it != PhysicsShapeInfo::map.end());
auto it = PhysicsShapeInfo::getMap().find(shape);
CC_ASSERT(it != PhysicsShapeInfo::getMap().end());
PhysicsRayCastCallback::Info callbackInfo =
{
it->second->shape,
it->second->getShape(),
info->p1,
info->p2,
Point(info->p1.x+(info->p2.x-info->p1.x)*t, info->p1.y+(info->p2.y-info->p1.y)*t),
@ -161,9 +161,9 @@ void PhysicsWorldCallback::rayCastCallbackFunc(cpShape *shape, cpFloat t, cpVect
void PhysicsWorldCallback::rectQueryCallbackFunc(cpShape *shape, RectQueryCallbackInfo *info)
{
auto it = PhysicsShapeInfo::map.find(shape);
auto it = PhysicsShapeInfo::getMap().find(shape);
CC_ASSERT(it != PhysicsShapeInfo::map.end());
CC_ASSERT(it != PhysicsShapeInfo::getMap().end());
if (!PhysicsWorldCallback::continues)
{
@ -171,17 +171,17 @@ void PhysicsWorldCallback::rectQueryCallbackFunc(cpShape *shape, RectQueryCallba
}
PhysicsWorldCallback::continues = info->callback->report(*info->world,
*it->second->shape,
*it->second->getShape(),
info->data);
}
void PhysicsWorldCallback::nearestPointQueryFunc(cpShape *shape, cpFloat distance, cpVect point, Array *arr)
{
auto it = PhysicsShapeInfo::map.find(shape);
auto it = PhysicsShapeInfo::getMap().find(shape);
CC_ASSERT(it != PhysicsShapeInfo::map.end());
CC_ASSERT(it != PhysicsShapeInfo::getMap().end());
arr->addObject(it->second->shape);
arr->addObject(it->second->getShape());
}
bool PhysicsWorld::init(Scene& scene)
@ -202,9 +202,9 @@ bool PhysicsWorld::init(Scene& scene)
_scene = &scene;
cpSpaceSetGravity(_info->space, PhysicsHelper::point2cpv(_gravity));
cpSpaceSetGravity(_info->getSpace(), PhysicsHelper::point2cpv(_gravity));
cpSpaceSetDefaultCollisionHandler(_info->space,
cpSpaceSetDefaultCollisionHandler(_info->getSpace(),
(cpCollisionBeginFunc)PhysicsWorldCallback::collisionBeginCallbackFunc,
(cpCollisionPreSolveFunc)PhysicsWorldCallback::collisionPreSolveCallbackFunc,
(cpCollisionPostSolveFunc)PhysicsWorldCallback::collisionPostSolveCallbackFunc,
@ -225,7 +225,7 @@ void PhysicsWorld::delayTestAddBody(PhysicsBody* body)
return;
}
if (_info->space->locked_private)
if (_info->getSpace()->locked_private)
{
if (_delayAddBodies->getIndexOfObject(body) == UINT_MAX)
{
@ -246,7 +246,7 @@ void PhysicsWorld::delayTestRemoveBody(PhysicsBody* body)
return;
}
if (_info->space->locked_private)
if (_info->getSpace()->locked_private)
{
if (_delayRemoveBodies->getIndexOfObject(body) == UINT_MAX)
{
@ -268,7 +268,7 @@ void PhysicsWorld::delayTestAddJoint(PhysicsJoint* joint)
return;
}
if (_info->space->locked_private)
if (_info->getSpace()->locked_private)
{
if (std::find(_delayAddJoints.begin(), _delayAddJoints.end(), joint) == _delayAddJoints.end())
{
@ -290,7 +290,7 @@ void PhysicsWorld::delayTestRemoveJoint(PhysicsJoint* joint)
return;
}
if (_info->space->locked_private)
if (_info->getSpace()->locked_private)
{
if (std::find(_delayRemoveJoints.begin(), _delayRemoveJoints.end(), joint) == _delayRemoveJoints.end())
{
@ -338,7 +338,7 @@ void PhysicsWorld::removeAllJoints()
PhysicsShape* PhysicsWorld::addShape(PhysicsShape* shape)
{
for (auto cps : shape->_info->shapes)
for (auto cps : shape->_info->getShapes())
{
_info->addShape(cps);
}
@ -348,7 +348,7 @@ PhysicsShape* PhysicsWorld::addShape(PhysicsShape* shape)
void PhysicsWorld::realAddJoint(PhysicsJoint *joint)
{
for (auto subjoint : joint->_info->joints)
for (auto subjoint : joint->_info->getJoints())
{
_info->addJoint(subjoint);
}
@ -374,7 +374,7 @@ void PhysicsWorld::realAddBody(PhysicsBody* body)
// add body to space
if (body->isDynamic())
{
_info->addBody(body->_info->body);
_info->addBody(body->_info->getBody());
}
// add shapes to space
@ -401,7 +401,7 @@ void PhysicsWorld::removeBody(PhysicsBody* body)
_bodies->removeObject(body);
}
void PhysicsWorld::removeBodyByTag(int tag)
void PhysicsWorld::removeBody(int tag)
{
for (Object* obj : *_bodies)
{
@ -442,14 +442,14 @@ void PhysicsWorld::realRemoveBody(PhysicsBody* body)
}
// remove body
_info->removeBody(body->_info->body);
_info->removeBody(body->_info->getBody());
body->_world = nullptr;
}
void PhysicsWorld::realRemoveJoint(PhysicsJoint* joint)
{
for (auto subjoint : joint->_info->joints)
for (auto subjoint : joint->_info->getJoints())
{
_info->removeJoint(subjoint);
}
@ -468,18 +468,18 @@ void PhysicsWorld::removeAllBodies()
void PhysicsWorld::removeShape(PhysicsShape* shape)
{
for (auto cps : shape->_info->shapes)
for (auto cps : shape->_info->getShapes())
{
if (cpSpaceContainsShape(_info->space, cps))
if (cpSpaceContainsShape(_info->getSpace(), cps))
{
cpSpaceRemoveShape(_info->space, cps);
cpSpaceRemoveShape(_info->getSpace(), cps);
}
}
}
void PhysicsWorld::updateBodies()
{
if (_info->space->locked_private)
if (_info->getSpace()->locked_private)
{
return;
}
@ -500,7 +500,7 @@ void PhysicsWorld::updateBodies()
void PhysicsWorld::updateJoints()
{
if (_info->space->locked_private)
if (_info->getSpace()->locked_private)
{
return;
}
@ -533,7 +533,7 @@ void PhysicsWorld::update(float delta)
body->update(delta);
}
cpSpaceStep(_info->space, delta);
cpSpaceStep(_info->getSpace(), delta);
if (_drawNode)
{
@ -577,7 +577,7 @@ void PhysicsWorld::debugDraw()
void PhysicsWorld::drawWithJoint(DrawNode* node, PhysicsJoint* joint)
{
for (auto it = joint->_info->joints.begin(); it != joint->_info->joints.end(); ++it)
for (auto it = joint->_info->getJoints().begin(); it != joint->_info->getJoints().end(); ++it)
{
cpConstraint *constraint = *it;
@ -638,7 +638,7 @@ void PhysicsWorld::drawWithJoint(DrawNode* node, PhysicsJoint* joint)
void PhysicsWorld::drawWithShape(DrawNode* node, PhysicsShape* shape)
{
for (auto it = shape->_info->shapes.begin(); it != shape->_info->shapes.end(); ++it)
for (auto it = shape->_info->getShapes().begin(); it != shape->_info->getShapes().end(); ++it)
{
cpShape *shape = *it;
@ -811,11 +811,11 @@ void PhysicsWorld::setGravity(Point gravity)
}
_gravity = gravity;
cpSpaceSetGravity(_info->space, PhysicsHelper::point2cpv(gravity));
cpSpaceSetGravity(_info->getSpace(), PhysicsHelper::point2cpv(gravity));
}
void PhysicsWorld::rayCast(PhysicsRayCastCallback& callback, Point point1, Point point2, void* data)
void PhysicsWorld::rayCast(PhysicsRayCastCallback& callback, const Point& point1, const Point& point2, void* data)
{
CCASSERT(callback.report != nullptr, "callback.report shouldn't be nullptr");
@ -824,7 +824,7 @@ void PhysicsWorld::rayCast(PhysicsRayCastCallback& callback, Point point1, Point
RayCastCallbackInfo info = { this, &callback, point1, point2, data };
PhysicsWorldCallback::continues = true;
cpSpaceSegmentQuery(this->_info->space,
cpSpaceSegmentQuery(this->_info->getSpace(),
PhysicsHelper::point2cpv(point1),
PhysicsHelper::point2cpv(point2),
CP_ALL_LAYERS,
@ -835,7 +835,7 @@ void PhysicsWorld::rayCast(PhysicsRayCastCallback& callback, Point point1, Point
}
void PhysicsWorld::rectQuery(PhysicsRectQueryCallback& callback, Rect rect, void* data)
void PhysicsWorld::rectQuery(PhysicsRectQueryCallback& callback, const Rect& rect, void* data)
{
CCASSERT(callback.report != nullptr, "callback.report shouldn't be nullptr");
@ -844,7 +844,7 @@ void PhysicsWorld::rectQuery(PhysicsRectQueryCallback& callback, Rect rect, void
RectQueryCallbackInfo info = {this, &callback, data};
PhysicsWorldCallback::continues = true;
cpSpaceBBQuery(this->_info->space,
cpSpaceBBQuery(this->_info->getSpace(),
PhysicsHelper::rect2cpbb(rect),
CP_ALL_LAYERS,
CP_NO_GROUP,
@ -853,10 +853,10 @@ void PhysicsWorld::rectQuery(PhysicsRectQueryCallback& callback, Rect rect, void
}
}
Array* PhysicsWorld::getShapesAtPoint(Point point) const
Array* PhysicsWorld::getShapes(const Point& point) const
{
Array* arr = Array::create();
cpSpaceNearestPointQuery(this->_info->space,
cpSpaceNearestPointQuery(this->_info->getSpace(),
PhysicsHelper::point2cpv(point),
0,
CP_ALL_LAYERS,
@ -867,16 +867,16 @@ Array* PhysicsWorld::getShapesAtPoint(Point point) const
return arr;
}
PhysicsShape* PhysicsWorld::getShapeAtPoint(Point point) const
PhysicsShape* PhysicsWorld::getShape(const Point& point) const
{
cpShape* shape = cpSpaceNearestPointQueryNearest(this->_info->space,
cpShape* shape = cpSpaceNearestPointQueryNearest(this->_info->getSpace(),
PhysicsHelper::point2cpv(point),
0,
CP_ALL_LAYERS,
CP_NO_GROUP,
nullptr);
return shape == nullptr ? nullptr : PhysicsShapeInfo::map.find(shape)->second->shape;
return shape == nullptr ? nullptr : PhysicsShapeInfo::getMap().find(shape)->second->getShape();
}
Array* PhysicsWorld::getAllBodies() const
@ -884,7 +884,7 @@ Array* PhysicsWorld::getAllBodies() const
return _bodies;
}
PhysicsBody* PhysicsWorld::getBodyByTag(int tag) const
PhysicsBody* PhysicsWorld::getBody(int tag) const
{
for (auto body : *_bodies)
{

14
cocos/physics/CCPhysicsWorld.h
View File

@ -77,7 +77,7 @@ public:
* @param normal the normal vector at the point of intersection
* @return true to continue, false to terminate
*/
std::function<bool(PhysicsWorld& world, Info& info, void* data)> report;
std::function<bool(PhysicsWorld& world, const Info& info, void* data)> report;
};
class PhysicsRectQueryCallback
@ -106,15 +106,15 @@ public:
virtual void removeAllJoints();
virtual void removeBody(PhysicsBody* body);
virtual void removeBodyByTag(int tag);
virtual void removeBody(int tag);
virtual void removeAllBodies();
void rayCast(PhysicsRayCastCallback& callback, Point point1, Point point2, void* data);
void rectQuery(PhysicsRectQueryCallback& callback, Rect rect, void* data);
Array* getShapesAtPoint(Point point) const;
PhysicsShape* getShapeAtPoint(Point point) const;
void rayCast(PhysicsRayCastCallback& callback, const Point& point1, const Point& point2, void* data);
void rectQuery(PhysicsRectQueryCallback& callback, const Rect& rect, void* data);
Array* getShapes(const Point& point) const;
PhysicsShape* getShape(const Point& point) const;
Array* getAllBodies() const;
PhysicsBody* getBodyByTag(int tag) const;
PhysicsBody* getBody(int tag) const;
/** Register a listener to receive contact callbacks*/
//inline void registerContactListener(EventListenerPhysicsContact* delegate) { _listener = delegate; }

9
cocos/physics/chipmunk/CCPhysicsBodyInfo_chipmunk.cpp
View File

@ -27,18 +27,13 @@
NS_CC_BEGIN
PhysicsBodyInfo::PhysicsBodyInfo()
: body(nullptr)
: _body(nullptr)
{
}
PhysicsBodyInfo::~PhysicsBodyInfo()
{
if (body) cpBodyFree(body);
}
Clonable* PhysicsBodyInfo::clone() const
{
return nullptr;
if (_body) cpBodyFree(_body);
}
NS_CC_END

8
cocos/physics/chipmunk/CCPhysicsBodyInfo_chipmunk.h
View File

@ -34,16 +34,18 @@
NS_CC_BEGIN
class PhysicsBodyInfo : public Clonable
class PhysicsBodyInfo
{
public:
cpBody* body;
inline cpBody* getBody() const { return _body; }
inline void setBody(cpBody* body) { _body = body; }
private:
PhysicsBodyInfo();
~PhysicsBodyInfo();
Clonable* clone() const override;
private:
cpBody* _body;
friend class PhysicsBody;
};

2
cocos/physics/chipmunk/CCPhysicsContactInfo_chipmunk.cpp
View File

@ -27,7 +27,7 @@
NS_CC_BEGIN
PhysicsContactInfo::PhysicsContactInfo(PhysicsContact* contact)
: contact(contact)
: _contact(contact)
{
}

5
cocos/physics/chipmunk/CCPhysicsContactInfo_chipmunk.h
View File

@ -36,12 +36,15 @@ class PhysicsContact;
class PhysicsContactInfo
{
public:
PhysicsContact* contact;
inline PhysicsContact* getContact() const { return _contact; }
private:
PhysicsContactInfo(PhysicsContact* contact);
~PhysicsContactInfo();
private:
PhysicsContact* _contact;
friend class PhysicsContact;
};

28
cocos/physics/chipmunk/CCPhysicsJointInfo_chipmunk.cpp
View File

@ -27,16 +27,16 @@
#include <algorithm>
NS_CC_BEGIN
std::map<cpConstraint*, PhysicsJointInfo*> PhysicsJointInfo::map;
std::map<cpConstraint*, PhysicsJointInfo*> PhysicsJointInfo::_map;
PhysicsJointInfo::PhysicsJointInfo(PhysicsJoint* joint)
: joint(joint)
: _joint(joint)
{
}
PhysicsJointInfo::~PhysicsJointInfo()
{
for (cpConstraint* joint : joints)
for (cpConstraint* joint : _joints)
{
cpConstraintFree(joint);
}
@ -46,21 +46,21 @@ void PhysicsJointInfo::add(cpConstraint* joint)
{
if (joint == nullptr) return;
joints.push_back(joint);
map.insert(std::pair<cpConstraint*, PhysicsJointInfo*>(joint, this));
_joints.push_back(joint);
_map.insert(std::pair<cpConstraint*, PhysicsJointInfo*>(joint, this));
}
void PhysicsJointInfo::remove(cpConstraint* joint)
{
if (joint == nullptr) return;
auto it = std::find(joints.begin(), joints.end(), joint);
if (it != joints.end())
auto it = std::find(_joints.begin(), _joints.end(), joint);
if (it != _joints.end())
{
joints.erase(it);
_joints.erase(it);
auto mit = map.find(joint);
if (mit != map.end()) map.erase(mit);
auto mit = _map.find(joint);
if (mit != _map.end()) _map.erase(mit);
cpConstraintFree(joint);
}
@ -68,14 +68,14 @@ void PhysicsJointInfo::remove(cpConstraint* joint)
void PhysicsJointInfo::removeAll()
{
for (cpConstraint* joint : joints)
for (cpConstraint* joint : _joints)
{
auto mit = map.find(joint);
if (mit != map.end()) map.erase(mit);
auto mit = _map.find(joint);
if (mit != _map.end()) _map.erase(mit);
cpConstraintFree(joint);
}
joints.clear();
_joints.clear();
}
NS_CC_END

12
cocos/physics/chipmunk/CCPhysicsJointInfo_chipmunk.h
View File

@ -43,15 +43,19 @@ public:
void remove(cpConstraint* shape);
void removeAll();
public:
std::vector<cpConstraint*> joints;
PhysicsJoint* joint;
static std::map<cpConstraint*, PhysicsJointInfo*> map;
PhysicsJoint* getJoint() const { return _joint; }
std::vector<cpConstraint*>& getJoints() { return _joints; }
static std::map<cpConstraint*, PhysicsJointInfo*>& getMap() { return _map; }
private:
PhysicsJointInfo(PhysicsJoint* joint);
~PhysicsJointInfo();
private:
std::vector<cpConstraint*> _joints;
PhysicsJoint* _joint;
static std::map<cpConstraint*, PhysicsJointInfo*> _map;
friend class PhysicsJoint;
};

56
cocos/physics/chipmunk/CCPhysicsShapeInfo_chipmunk.cpp
View File

@ -27,27 +27,27 @@
#include <algorithm>
NS_CC_BEGIN
std::map<cpShape*, PhysicsShapeInfo*> PhysicsShapeInfo::map;
cpBody* PhysicsShapeInfo::shareBody = nullptr;
std::map<cpShape*, PhysicsShapeInfo*> PhysicsShapeInfo::_map;
cpBody* PhysicsShapeInfo::_sharedBody = nullptr;
PhysicsShapeInfo::PhysicsShapeInfo(PhysicsShape* shape)
: shape(shape)
, group(CP_NO_GROUP)
: _shape(shape)
, _group(CP_NO_GROUP)
{
if (shareBody == nullptr)
if (_sharedBody == nullptr)
{
shareBody = cpBodyNewStatic();
_sharedBody = cpBodyNewStatic();
}
body = shareBody;
_body = _sharedBody;
}
PhysicsShapeInfo::~PhysicsShapeInfo()
{
for (auto shape : shapes)
for (auto shape : _shapes)
{
auto it = map.find(shape);
if (it != map.end()) map.erase(shape);
auto it = _map.find(shape);
if (it != _map.end()) _map.erase(shape);
cpShapeFree(shape);
}
@ -55,9 +55,9 @@ PhysicsShapeInfo::~PhysicsShapeInfo()
void PhysicsShapeInfo::setGroup(cpGroup group)
{
this->group = group;
this->_group = group;
for (cpShape* shape : shapes)
for (cpShape* shape : _shapes)
{
cpShapeSetGroup(shape, group);
}
@ -65,12 +65,12 @@ void PhysicsShapeInfo::setGroup(cpGroup group)
void PhysicsShapeInfo::setBody(cpBody* body)
{
if (this->body != body)
if (this->_body != body)
{
this->body = body;
for (cpShape* shape : shapes)
this->_body = body;
for (cpShape* shape : _shapes)
{
cpShapeSetBody(shape, body == nullptr ? shareBody : body);
cpShapeSetBody(shape, body == nullptr ? _sharedBody : body);
}
}
}
@ -79,22 +79,22 @@ void PhysicsShapeInfo::add(cpShape* shape)
{
if (shape == nullptr) return;
cpShapeSetGroup(shape, group);
shapes.push_back(shape);
map.insert(std::pair<cpShape*, PhysicsShapeInfo*>(shape, this));
cpShapeSetGroup(shape, _group);
_shapes.push_back(shape);
_map.insert(std::pair<cpShape*, PhysicsShapeInfo*>(shape, this));
}
void PhysicsShapeInfo::remove(cpShape* shape)
{
if (shape == nullptr) return;
auto it = std::find(shapes.begin(), shapes.end(), shape);
if (it != shapes.end())
auto it = std::find(_shapes.begin(), _shapes.end(), shape);
if (it != _shapes.end())
{
shapes.erase(it);
_shapes.erase(it);
auto mit = map.find(shape);
if (mit != map.end()) map.erase(mit);
auto mit = _map.find(shape);
if (mit != _map.end()) _map.erase(mit);
cpShapeFree(shape);
}
@ -102,14 +102,14 @@ void PhysicsShapeInfo::remove(cpShape* shape)
void PhysicsShapeInfo::removeAll()
{
for (cpShape* shape : shapes)
for (cpShape* shape : _shapes)
{
auto mit = map.find(shape);
if (mit != map.end()) map.erase(mit);
auto mit = _map.find(shape);
if (mit != _map.end()) _map.erase(mit);
cpShapeFree(shape);
}
shapes.clear();
_shapes.clear();
}
NS_CC_END

20
cocos/physics/chipmunk/CCPhysicsShapeInfo_chipmunk.h
View File

@ -47,17 +47,25 @@ public:
void setBody(cpBody* body);
public:
std::vector<cpShape*> shapes;
PhysicsShape* shape;
cpBody* body;
cpGroup group;
static std::map<cpShape*, PhysicsShapeInfo*> map;
static cpBody* shareBody;
PhysicsShape* getShape() const { return _shape; }
std::vector<cpShape*>& getShapes() { return _shapes; }
cpBody* getBody() const { return _body; }
cpGroup getGourp() const { return _group; }
static std::map<cpShape*, PhysicsShapeInfo*>& getMap() { return _map; }
static cpBody* getSharedBody() { return _sharedBody; }
private:
PhysicsShapeInfo(PhysicsShape* shape);
~PhysicsShapeInfo();
private:
std::vector<cpShape*> _shapes;
PhysicsShape* _shape;
cpBody* _body;
cpGroup _group;
static std::map<cpShape*, PhysicsShapeInfo*> _map;
static cpBody* _sharedBody;
friend class PhysicsShape;
};

8
cocos/physics/chipmunk/CCPhysicsWorldInfo_chipmunk.cpp
View File

@ -29,12 +29,12 @@ NS_CC_BEGIN
#define PHYSICS_WORLD_INFO_FUNCTION_IMPLEMENTS(name, type) \
void PhysicsWorldInfo::add##name(cp##type* data) \
{ \
if (!cpSpaceContains##type(space, data)) cpSpaceAdd##type(space, data); \
if (!cpSpaceContains##type(_space, data)) cpSpaceAdd##type(_space, data); \
} \
\
void PhysicsWorldInfo::remove##name(cp##type* data) \
{ \
if (cpSpaceContains##type(space, data)) cpSpaceRemove##type(space, data); \
if (cpSpaceContains##type(_space, data)) cpSpaceRemove##type(_space, data); \
} \
PHYSICS_WORLD_INFO_FUNCTION_IMPLEMENTS(Shape, Shape)
@ -43,12 +43,12 @@ PHYSICS_WORLD_INFO_FUNCTION_IMPLEMENTS(Joint, Constraint)
PhysicsWorldInfo::PhysicsWorldInfo()
{
space = cpSpaceNew();
_space = cpSpaceNew();
}
PhysicsWorldInfo::~PhysicsWorldInfo()
{
cpSpaceFree(space);
cpSpaceFree(_space);
}
NS_CC_END

6
cocos/physics/chipmunk/CCPhysicsWorldInfo_chipmunk.h
View File

@ -36,8 +36,7 @@ NS_CC_BEGIN
class PhysicsWorldInfo
{
public:
cpSpace* space;
cpSpace* getSpace() const { return _space; }
void addShape(cpShape* shape);
void removeShape(cpShape* shape);
void addBody(cpBody* body);
@ -49,6 +48,9 @@ private:
PhysicsWorldInfo();
~PhysicsWorldInfo();
private:
cpSpace* _space;
friend class PhysicsWorld;
};

12
samples/Cpp/TestCpp/Classes/PhysicsTest/PhysicsTest.cpp
View File

@ -602,7 +602,7 @@ void PhysicsDemoRayCast::changeModeCallback(Object* sender)
}
}
bool PhysicsDemoRayCast::anyRay(PhysicsWorld& world, PhysicsRayCastCallback::Info& info, void* data)
bool PhysicsDemoRayCast::anyRay(PhysicsWorld& world, const PhysicsRayCastCallback::Info& info, void* data)
{
*((Point*)data) = info.contact;
return false;
@ -620,7 +620,7 @@ private:
PhysicsDemoNearestRayCastCallback::PhysicsDemoNearestRayCastCallback()
: _friction(1.0f)
{
report = [this](PhysicsWorld& world, PhysicsRayCastCallback::Info& info, void* data)->bool
report = [this](PhysicsWorld& world, const PhysicsRayCastCallback::Info& info, void* data)->bool
{
if (_friction > info.fraction)
{
@ -650,7 +650,7 @@ public:
PhysicsDemoMultiRayCastCallback::PhysicsDemoMultiRayCastCallback()
: num(0)
{
report = [this](PhysicsWorld& world, PhysicsRayCastCallback::Info& info, void* data)->bool
report = [this](PhysicsWorld& world, const PhysicsRayCastCallback::Info& info, void* data)->bool
{
if (num < MAX_MULTI_RAYCAST_NUM)
{
@ -1089,7 +1089,7 @@ void PhysicsDemoSlice::onEnter()
addChild(box);
}
bool PhysicsDemoSlice::slice(PhysicsWorld &world, PhysicsRayCastCallback::Info &info, void *data)
bool PhysicsDemoSlice::slice(PhysicsWorld &world, const PhysicsRayCastCallback::Info &info, void *data)
{
if (info.shape->getBody()->getTag() != _sliceTag)
{
@ -1150,6 +1150,8 @@ void PhysicsDemoSlice::clipPoly(PhysicsShapePolygon* shape, Point normal, float
polyon->setAngularVelocity(body->getAngularVelocity());
polyon->setTag(_sliceTag);
addChild(node);
delete[] points;
}
void PhysicsDemoSlice::onTouchEnded(Touch *touch, Event *event)
@ -1171,7 +1173,7 @@ std::string PhysicsDemoSlice::subtitle()
void PhysicsDemoWater::onEnter()
{
PhysicsDemo::onEnter();
}
std::string PhysicsDemoWater::title()

4
samples/Cpp/TestCpp/Classes/PhysicsTest/PhysicsTest.h
View File

@ -96,7 +96,7 @@ public:
void changeModeCallback(Object* sender);
bool anyRay(PhysicsWorld& world, PhysicsRayCastCallback::Info& info, void* data);
bool anyRay(PhysicsWorld& world, const PhysicsRayCastCallback::Info& info, void* data);
private:
float _angle;
@ -150,7 +150,7 @@ public:
std::string title() override;
std::string subtitle() override;
bool slice(PhysicsWorld& world, PhysicsRayCastCallback::Info& info, void* data);
bool slice(PhysicsWorld& world, const PhysicsRayCastCallback::Info& info, void* data);
void clipPoly(PhysicsShapePolygon* shape, Point normal, float distance);
bool onTouchBegan(Touch *touch, Event *event);