void CollisionEdge2D::RecreateFixture()
{
ReleaseFixture();
Vector2 worldScale(cachedWorldScale_.x_, cachedWorldScale_.y_);
edgeShape_.Set(ToB2Vec2(vertex1_ * worldScale), ToB2Vec2(vertex2_ * worldScale));
CreateFixture();
}
b2JointDef* ConstraintDistance2D::GetJointDef()
{
if (!ownerBody_ || !otherBody_)
return 0;
b2Body* bodyA = ownerBody_->GetBody();
b2Body* bodyB = otherBody_->GetBody();
if (!bodyA || !bodyB)
return 0;
jointDef_.Initialize(bodyA, bodyB, ToB2Vec2(ownerBodyAnchor_), ToB2Vec2(otherBodyAnchor_));
return &jointDef_;
}
b2JointDef* ConstraintWheel2D::GetJointDef()
{
if (!ownerBody_ || !otherBody_)
return nullptr;
b2Body* bodyA = ownerBody_->GetBody();
b2Body* bodyB = otherBody_->GetBody();
if (!bodyA || !bodyB)
return nullptr;
jointDef_.Initialize(bodyA, bodyB, ToB2Vec2(anchor_), ToB2Vec2(axis_));
return &jointDef_;
}
void RigidBody2D::CreateBody()
{
if (body_)
return;
if (!physicsWorld_ || !physicsWorld_->GetWorld())
return;
bodyDef_.position = ToB2Vec2(node_->GetWorldPosition());;
bodyDef_.angle = node_->GetWorldRotation().RollAngle() * M_DEGTORAD;
body_ = physicsWorld_->GetWorld()->CreateBody(&bodyDef_);
body_->SetUserData(this);
for (unsigned i = 0; i < collisionShapes_.Size(); ++i)
{
if (collisionShapes_[i])
collisionShapes_[i]->CreateFixture();
}
if (!useFixtureMass_)
body_->SetMassData(&massData_);
for (unsigned i = 0; i < constraints_.Size(); ++i)
{
if (constraints_[i])
constraints_[i]->CreateJoint();
}
}
b2JointDef* ConstraintRope2D::GetJointDef()
{
if (!ownerBody_ || !otherBody_)
return 0;
b2Body* bodyA = ownerBody_->GetBody();
b2Body* bodyB = otherBody_->GetBody();
if (!bodyA || !bodyB)
return 0;
InitializeJointDef(&jointDef_);
jointDef_.localAnchorA = ToB2Vec2(ownerBodyAnchor_);
jointDef_.localAnchorB = ToB2Vec2(otherBodyAnchor_);
return &jointDef_;
}
b2JointDef* ConstraintRope2D::CreateJointDef()
{
if (!ownerBody_ || !otherBody_)
return 0;
b2Body* bodyA = ownerBody_->GetBody();
b2Body* bodyB = otherBody_->GetBody();
if (!bodyA || !bodyB)
return 0;
b2RopeJointDef* jointDef = new b2RopeJointDef;
InitializeJointDef(jointDef);
jointDef->localAnchorA = ToB2Vec2(ownerBodyAnchor_);
jointDef->localAnchorB = ToB2Vec2(otherBodyAnchor_);
jointDef->maxLength = maxLength_;
return jointDef;
}
void CollisionCircle2D::RecreateFixture()
{
ReleaseFixture();
// Only use scale in x axis for circle
float worldScale = cachedWorldScale_.x_;
circleShape_.m_radius = radius_ * worldScale;
circleShape_.m_p = ToB2Vec2(center_ * worldScale);
CreateFixture();
}
void RigidBody2D::SetLinearVelocity(Vector2 linearVelocity)
{
b2Vec2 b2linearVelocity = ToB2Vec2(linearVelocity);
if (bodyDef_.linearVelocity == b2linearVelocity)
return;
bodyDef_.linearVelocity = b2linearVelocity;
if (body_)
body_->SetLinearVelocity(b2linearVelocity);
MarkNetworkUpdate();
}
void RigidBody2D::SetMassCenter(Vector2 center)
{
b2Vec2 b2Center = ToB2Vec2(center);
if (massData_.center == b2Center)
return;
massData_.center = b2Center;
if (useFixtureMass_ && body_)
body_->SetMassData(&massData_);
MarkNetworkUpdate();
}
void ConstraintMotor2D::SetLinearOffset(const Vector2& linearOffset)
{
if (linearOffset == linearOffset_)
return;
linearOffset_ = linearOffset;
if (joint_)
static_cast<b2MotorJoint*>(joint_)->SetLinearOffset(ToB2Vec2(linearOffset));
else
RecreateJoint();
MarkNetworkUpdate();
}
void ConstraintMouse2D::SetTarget(const Vector2& target)
{
if (target == target_)
return;
target_ = target;
if (joint_)
static_cast<b2MouseJoint*>(joint_)->SetTarget(ToB2Vec2(target));
else
RecreateJoint();
MarkNetworkUpdate();
}
b2JointDef* ConstraintMotor2D::GetJointDef()
{
if (!ownerBody_ || !otherBody_)
return nullptr;
b2Body* bodyA = ownerBody_->GetBody();
b2Body* bodyB = otherBody_->GetBody();
if (!bodyA || !bodyB)
return nullptr;
jointDef_.Initialize(bodyA, bodyB);
jointDef_.linearOffset = ToB2Vec2(linearOffset_);
return &jointDef_;
}
void CollisionBox2D::RecreateFixture()
{
ReleaseFixture();
float worlsScaleX = cachedWorldScale_.x_;
float worldScaleY = cachedWorldScale_.y_;
float halfWidth = size_.x_ * 0.5f * worlsScaleX;
float halfHeight = size_.y_ * 0.5f * worldScaleY;
Vector2 scaledCenter = center_ * Vector2(worlsScaleX, worldScaleY);
if (scaledCenter == Vector2::ZERO && angle_ == 0.0f)
boxShape_.SetAsBox(halfWidth, halfHeight);
else
boxShape_.SetAsBox(halfWidth, halfHeight, ToB2Vec2(scaledCenter), angle_ * M_DEGTORAD);
CreateFixture();
}
b2JointDef* ConstraintMouse2D::GetJointDef()
{
if (!ownerBody_ || !otherBody_)
return nullptr;
b2Body* bodyA = otherBody_->GetBody();
b2Body* bodyB = ownerBody_->GetBody();
if (!bodyA || !bodyB)
return nullptr;
jointDef_.bodyA = bodyA;
jointDef_.bodyB = bodyB;
jointDef_.collideConnected = collideConnected_;
jointDef_.target = ToB2Vec2(target_);
return &jointDef_;
}
void CollisionPolygon2D::RecreateFixture()
{
ReleaseFixture();
if (vertices_.Size() < 3)
return;
PODVector<b2Vec2> b2Vertices;
unsigned count = vertices_.Size();
b2Vertices.Resize(count);
Vector2 worldScale(cachedWorldScale_.x_, cachedWorldScale_.y_);
for (unsigned i = 0; i < count; ++i)
b2Vertices[i] = ToB2Vec2(vertices_[i] * worldScale);
polygonShape_.Set(&b2Vertices[0], count);
CreateFixture();
}
void CollisionChain2D::RecreateFixture()
{
ReleaseFixture();
PODVector<b2Vec2> b2Vertices;
unsigned count = vertices_.Size();
b2Vertices.Resize(count);
Vector2 worldScale(cachedWorldScale_.x_, cachedWorldScale_.y_);
for (unsigned i = 0; i < count; ++i)
b2Vertices[i] = ToB2Vec2(vertices_[i] * worldScale);
if (loop_)
chainShape_.CreateLoop(&b2Vertices[0], count);
else
chainShape_.CreateChain(&b2Vertices[0], count);
CreateFixture();
}
void CollisionChain2D::RecreateFixture()
{
ReleaseFixture();
std::vector<b2Vec2> b2Vertices;
size_t count = vertices_.size();
b2Vertices.resize(count);
Vector2 worldScale(cachedWorldScale_.x_, cachedWorldScale_.y_);
for (size_t i = 0; i < count; ++i)
b2Vertices[i] = ToB2Vec2(vertices_[i] * worldScale);
chainShape_.Clear();
if (loop_)
chainShape_.CreateLoop(&b2Vertices[0], count);
else
chainShape_.CreateChain(&b2Vertices[0], count);
CreateFixture();
}
void ConstraintMouse2D::SetTarget(const Vector2& target)
{
if (target == target_)
return;
target_ = target;
if (joint_ && targetSetted_)
{
b2MouseJoint* mouseJoint = (b2MouseJoint*)joint_;
mouseJoint->SetTarget(ToB2Vec2(target_));
MarkNetworkUpdate();
return;
}
targetSetted_ = true;
RecreateJoint();
MarkNetworkUpdate();
}
b2JointDef* ConstraintRevolute2D::CreateJointDef()
{
if (!ownerBody_ || !otherBody_)
return 0;
b2Body* bodyA = ownerBody_->GetBody();
b2Body* bodyB = otherBody_->GetBody();
if (!bodyA || !bodyB)
return 0;
b2RevoluteJointDef* jointDef = new b2RevoluteJointDef;
jointDef->Initialize(bodyA, bodyB, ToB2Vec2(anchor_));
jointDef->enableLimit = enableLimit_;
jointDef->lowerAngle = lowerAngle_;
jointDef->upperAngle = upperAngle_;
jointDef->enableMotor = enableMotor_;
jointDef->motorSpeed = motorSpeed_;
jointDef->maxMotorTorque = maxMotorTorque_;
return jointDef;
}
void RigidBody2D::OnMarkedDirty(Node* node)
{
if (physicsWorld_ && physicsWorld_->IsApplyingTransforms())
return;
// Physics operations are not safe from worker threads
Scene* scene = GetScene();
if (scene && scene->IsThreadedUpdate())
{
scene->DelayedMarkedDirty(this);
return;
}
// Check if transform has changed from the last one set in ApplyWorldTransform()
b2Vec2 newPosition = ToB2Vec2(node_->GetWorldPosition());
float newAngle = node_->GetWorldRotation().RollAngle() * M_DEGTORAD;
if (newPosition != bodyDef_.position || newAngle != bodyDef_.angle)
{
bodyDef_.position = newPosition;
bodyDef_.angle = newAngle;
if (body_)
body_->SetTransform(newPosition, newAngle);
}
}
void RigidBody2D::ApplyLinearImpulse(const Vector2& impulse, const Vector2& point, bool wake)
{
if (body_ && impulse != 0)
body_->ApplyLinearImpulse(ToB2Vec2(impulse), ToB2Vec2(point), wake);
}
void RigidBody2D::ApplyForceToCenter(const Vector2& force, bool wake)
{
if (body_ && force != Vector2::ZERO)
body_->ApplyForceToCenter(ToB2Vec2(force), wake);
}
void RigidBody2D::ApplyForce(const Vector2& force, const Vector2& point, bool wake)
{
if (body_ && force != Vector2::ZERO)
body_->ApplyForce(ToB2Vec2(force), ToB2Vec2(point), wake);
}
