Body.cpp

浏览该文件的文档.

#include "physics/Body.h"
#include "physics/Fixture.h"
#include "physics/Joint2D.h"
#include "physics/World.h"
 
#include "common/Exception.h"
 
#include <Box2D/Box2D.h>
 
#include <cmath>
#include <cstring>
#include <vector>
 
namespace eve::physics {
namespace {
 
b2BodyType parseBodyType(const std::string &type) {
    if (type == "static") return b2_staticBody;
    if (type == "kinematic") return b2_kinematicBody;
    if (type == "dynamic") return b2_dynamicBody;
    throw eve::Exception("Body.setType: unknown body type '%s'", type.c_str());
}
 
const char *bodyTypeName(b2BodyType t) {
    switch (t) {
        case b2_staticBody: return "static";
        case b2_kinematicBody: return "kinematic";
        case b2_dynamicBody: return "dynamic";
        default: return "static";
    }
}
 
}  // namespace
 
Body::Body(World *world, b2Body *body, int id, PhysicsBodyHandle runtimeHandle)
    : world_(world), body_(body), id_(id), runtimeHandle_(runtimeHandle) {}
 
Body::~Body() {
    if (body_ && world_ && world_->raw()) {
        std::vector<Joint2D *> joints(world_->joints_.begin(), world_->joints_.end());
        for (Joint2D *joint : joints) {
            if (joint && joint->isValid() && (joint->bodyA_ == this || joint->bodyB_ == this))
                joint->destroy();
        }
        // Invalidate fixture wrappers before DestroyBody frees b2Fixtures.
        b2Fixture *f = body_->GetFixtureList();
        while (f) {
            b2Fixture *next = f->GetNext();
            auto *wrap = static_cast<Fixture *>(f->GetUserData());
            if (wrap) {
                world_->forgetFixture(wrap);
                wrap->invalidate();
            }
            f = next;
        }
        body_->SetUserData(nullptr);
        world_->raw()->DestroyBody(body_);
        world_->forgetBody(this);
    }
    body_  = nullptr;
    world_ = nullptr;
    runtimeHandle_ = PhysicsBodyHandle::invalid();
}
 
void Body::invalidate() {
    if (body_) body_->SetUserData(nullptr);
    body_  = nullptr;
    world_ = nullptr;
    runtimeHandle_ = PhysicsBodyHandle::invalid();
}
 
void Body::destroy() {
    if (!body_ || !world_ || !world_->raw()) {
        invalidate();
        return;
    }
    std::vector<Joint2D *> joints(world_->joints_.begin(), world_->joints_.end());
    for (Joint2D *joint : joints) {
        if (joint && joint->isValid() && (joint->bodyA_ == this || joint->bodyB_ == this))
            joint->destroy();
    }
    b2Fixture *f = body_->GetFixtureList();
    while (f) {
        b2Fixture *next = f->GetNext();
        auto *wrap = static_cast<Fixture *>(f->GetUserData());
        if (wrap) {
            world_->forgetFixture(wrap);
            wrap->invalidate();
        }
        f = next;
    }
    body_->SetUserData(nullptr);
    world_->raw()->DestroyBody(body_);
    world_->forgetBody(this);
    body_  = nullptr;
    world_ = nullptr;
    runtimeHandle_ = PhysicsBodyHandle::invalid();
}
 
void Body::setPosition(float x, float y) {
    if (!body_ || !world_) return;
    body_->SetTransform(b2Vec2(world_->toMeters(x), world_->toMeters(y)), body_->GetAngle());
}
 
float Body::getX() const {
    if (!body_ || !world_) return 0.f;
    return world_->toPixels(body_->GetPosition().x);
}
 
float Body::getY() const {
    if (!body_ || !world_) return 0.f;
    return world_->toPixels(body_->GetPosition().y);
}
 
void Body::setAngle(float radians) {
    if (!body_) return;
    body_->SetTransform(body_->GetPosition(), radians);
}
 
float Body::getAngle() const {
    if (!body_) return 0.f;
    return body_->GetAngle();
}
 
void Body::setLinearVelocity(float vx, float vy) {
    if (!body_ || !world_) return;
    body_->SetLinearVelocity(b2Vec2(world_->toMeters(vx), world_->toMeters(vy)));
}
 
float Body::getLinearVelocityX() const {
    if (!body_ || !world_) return 0.f;
    return world_->toPixels(body_->GetLinearVelocity().x);
}
 
float Body::getLinearVelocityY() const {
    if (!body_ || !world_) return 0.f;
    return world_->toPixels(body_->GetLinearVelocity().y);
}
 
float Body::getLinearSpeed() const {
    if (!body_ || !world_) return 0.f;
    return world_->toPixels(body_->GetLinearVelocity().Length());
}
 
float Body::getMass() const { return body_ ? body_->GetMass() : 0.f; }
 
float Body::getWorldCenterX() const {
    if (!body_ || !world_) return 0.f;
    return world_->toPixels(body_->GetWorldCenter().x);
}
 
float Body::getWorldCenterY() const {
    if (!body_ || !world_) return 0.f;
    return world_->toPixels(body_->GetWorldCenter().y);
}
 
void Body::setAngularVelocity(float omega) {
    if (!body_) return;
    body_->SetAngularVelocity(omega);
}
 
float Body::getAngularVelocity() const {
    if (!body_) return 0.f;
    return body_->GetAngularVelocity();
}
 
void Body::applyForce(float fx, float fy) {
    if (!body_ || !world_) return;
    // Force in Newtons ≈ (pixels/s² * mass) with mass in kg; convert like LÖVE.
    body_->ApplyForceToCenter(b2Vec2(world_->toMeters(fx), world_->toMeters(fy)), true);
}
 
void Body::applyForceAt(float fx, float fy, float x, float y) {
    if (!body_ || !world_) return;
    body_->ApplyForce(b2Vec2(world_->toMeters(fx), world_->toMeters(fy)),
                      b2Vec2(world_->toMeters(x), world_->toMeters(y)), true);
}
 
void Body::applyLinearImpulse(float ix, float iy) {
    if (!body_ || !world_) return;
    body_->ApplyLinearImpulse(b2Vec2(world_->toMeters(ix), world_->toMeters(iy)),
                              body_->GetWorldCenter(), true);
}
 
void Body::applyAngularImpulse(float impulse) {
    if (!body_) return;
    body_->ApplyAngularImpulse(impulse, true);
}
 
void Body::setType(const std::string &bodyType) {
    if (!body_) return;
    body_->SetType(parseBodyType(bodyType));
}
 
std::string Body::getType() const {
    if (!body_) return "static";
    return bodyTypeName(body_->GetType());
}
 
void Body::setFixedRotation(bool fixed) {
    if (!body_) return;
    body_->SetFixedRotation(fixed);
}
 
bool Body::isFixedRotation() const { return body_ ? body_->IsFixedRotation() : false; }
 
void Body::setActive(bool active) {
    if (!body_) return;
    body_->SetActive(active);
}
 
bool Body::isActive() const { return body_ ? body_->IsActive() : false; }
 
void Body::setBullet(bool bullet) {
    if (!body_) return;
    body_->SetBullet(bullet);
}
 
bool Body::isBullet() const { return body_ ? body_->IsBullet() : false; }
 
void Body::setAwake(bool awake) {
    if (!body_) return;
    body_->SetAwake(awake);
}
 
bool Body::isAwake() const { return body_ ? body_->IsAwake() : false; }
 
Fixture *Body::newRectangleFixture(float width, float height, float density, float friction,
                                   float restitution) {
    return newRectangleFixtureAt(width, height, 0.f, 0.f, density, friction, restitution);
}
 
Fixture *Body::newRectangleFixtureAt(float width, float height, float offsetX, float offsetY,
                                     float density, float friction, float restitution) {
    if (!body_ || !world_) throw eve::Exception("Body.newRectangleFixture: body destroyed");
    if (width <= 0.f || height <= 0.f)
        throw eve::Exception("Body.newRectangleFixture: width/height must be > 0");
 
    b2PolygonShape shape;
    shape.SetAsBox(world_->toMeters(width) * 0.5f, world_->toMeters(height) * 0.5f,
                   b2Vec2(world_->toMeters(offsetX), world_->toMeters(offsetY)), 0.f);
 
    b2FixtureDef def;
    def.shape       = &shape;
    def.density     = density;
    def.friction    = friction;
    def.restitution = restitution;
 
    b2Fixture *raw = body_->CreateFixture(&def);
    auto *fx = new Fixture(world_, this, raw);
    raw->SetUserData(fx);
    world_->fixtures_.insert(fx);
    return fx;
}
 
Fixture *Body::newCircleFixture(float radius, float density, float friction, float restitution) {
    if (!body_ || !world_) throw eve::Exception("Body.newCircleFixture: body destroyed");
    if (radius <= 0.f) throw eve::Exception("Body.newCircleFixture: radius must be > 0");
 
    b2CircleShape shape;
    shape.m_radius = world_->toMeters(radius);
 
    b2FixtureDef def;
    def.shape       = &shape;
    def.density     = density;
    def.friction    = friction;
    def.restitution = restitution;
 
    b2Fixture *raw = body_->CreateFixture(&def);
    auto *fx = new Fixture(world_, this, raw);
    raw->SetUserData(fx);
    world_->fixtures_.insert(fx);
    return fx;
}
 
Fixture *Body::newPolygonFixture(const std::vector<float> &vertices, float density,
                                 float friction, float restitution) {
    if (!body_ || !world_) throw eve::Exception("Body.newPolygonFixture: body destroyed");
    if (vertices.size() < 6 || vertices.size() > 16 || vertices.size() % 2 != 0)
        throw eve::Exception("Body.newPolygonFixture: expected 3..8 packed XY vertices");
    std::vector<b2Vec2> points;
    points.reserve(vertices.size() / 2);
    for (size_t index = 0; index < vertices.size(); index += 2) {
        if (!std::isfinite(vertices[index]) || !std::isfinite(vertices[index + 1]))
            throw eve::Exception("Body.newPolygonFixture: vertices must be finite");
        points.emplace_back(world_->toMeters(vertices[index]), world_->toMeters(vertices[index + 1]));
    }
    b2PolygonShape shape;
    shape.Set(points.data(), static_cast<int32>(points.size()));
    if (shape.GetVertexCount() < 3)
        throw eve::Exception("Body.newPolygonFixture: vertices do not form a convex polygon");
    b2FixtureDef def;
    def.shape = &shape;
    def.density = density;
    def.friction = friction;
    def.restitution = restitution;
    b2Fixture *raw = body_->CreateFixture(&def);
    if (!raw) throw eve::Exception("Body.newPolygonFixture: Box2D rejected the fixture");
    auto *fixture = new Fixture(world_, this, raw);
    raw->SetUserData(fixture);
    world_->fixtures_.insert(fixture);
    return fixture;
}
 
Fixture *Body::newChainFixture(const std::vector<float> &vertices, bool loop, float friction,
                               float restitution) {
    if (!body_ || !world_) throw eve::Exception("Body.newChainFixture: body destroyed");
    const size_t count = vertices.size() / 2;
    if (vertices.size() % 2 != 0 || count < (loop ? 3U : 2U) || count > 100000U)
        throw eve::Exception("Body.newChainFixture: invalid packed XY vertex count");
    std::vector<b2Vec2> points;
    points.reserve(count);
    for (size_t index = 0; index < vertices.size(); index += 2) {
        if (!std::isfinite(vertices[index]) || !std::isfinite(vertices[index + 1]))
            throw eve::Exception("Body.newChainFixture: vertices must be finite");
        const b2Vec2 point(world_->toMeters(vertices[index]), world_->toMeters(vertices[index + 1]));
        if (!points.empty() && point == points.back())
            throw eve::Exception("Body.newChainFixture: consecutive vertices must be distinct");
        points.push_back(point);
    }
    if (loop && points.front() == points.back())
        throw eve::Exception("Body.newChainFixture: loop endpoint is implicit and must not be repeated");
    b2ChainShape shape;
    if (loop)
        shape.CreateLoop(points.data(), static_cast<int32>(points.size()));
    else
        shape.CreateChain(points.data(), static_cast<int32>(points.size()));
    b2FixtureDef def;
    def.shape = &shape;
    def.friction = friction;
    def.restitution = restitution;
    b2Fixture *raw = body_->CreateFixture(&def);
    if (!raw) throw eve::Exception("Body.newChainFixture: Box2D rejected the fixture");
    auto *fixture = new Fixture(world_, this, raw);
    raw->SetUserData(fixture);
    world_->fixtures_.insert(fixture);
    return fixture;
}
 
}  // namespace eve::physics