physics.hpp

Go to the documentation of this file.

#pragma once
#include "definitions.hpp"
#include "../../core/definitions.hpp"
#include "../../core/node/components.hpp"
 
#include <box2d/base.h>
#include <box2d/box2d.h>
#include <box2d/collision.h>
#include <box2d/id.h>
#include <box2d/types.h>
 
#include <functional>
 
template <>
struct std::hash<b2ShapeId>
{
    std::size_t operator()(const b2ShapeId &id) const noexcept
    {
        // b2ShapeId has index1, world0, and revision fields
        std::size_t h = std::hash<uint32_t>{}(id.index1);
        h ^= std::hash<uint16_t>{}(id.world0) + 0x9e3779b9 + (h << 6) + (h >> 2);
        h ^= std::hash<uint16_t>{}(id.generation) + 0x9e3779b9 + (h << 6) + (h >> 2);
        return h;
    }
};
 
inline bool operator==(const b2ShapeId &a, const b2ShapeId &b) noexcept
{
    return a.index1 == b.index1 && a.world0 == b.world0 && a.generation == b.generation;
}
 
class PhysicsBody : public Component
{
public:
    void exit() override;
    virtual void physicsUpdate() = 0;
    void initialize() override;
    virtual void initCompute();
 
    Signal<PhysicsBody *> collisionEnter;
    Signal<PhysicsBody *> collisionExit;
    Signal<PhysicsBody *> collisionHit;
    Signal<> mouseEntered;
    Signal<> mouseExited;
    std::shared_ptr<Shape> shape;
 
    template <class Archive>
    void save(Archive &ar) const
    {
        ar(CEREAL_NVP(shape), CEREAL_NVP(storedTransform), CEREAL_NVP(sensor));
    }
 
    template <class Archive>
    void load(Archive &ar)
    {
        ar(CEREAL_NVP(shape), CEREAL_NVP(storedTransform), CEREAL_NVP(sensor));
        initCompute();
 
        const float angle = storedTransform.getAngleRadians();
        b2Body_SetTransform(bodyId, storedTransform.position, {cos(angle), sin(angle)});
    }
 
    b2BodyId getBodyId() { return bodyId; };
    b2ShapeId getShapeId() { return shapeId; };
 
protected:
    bool sensor;
    b2BodyDef bodyDef;
    b2BodyId bodyId;
    b2ShapeId shapeId;
 
    Transform storedTransform;
};
 
class Physics
{
public:
    Physics(Vector2 gravity = {0.0f, 9.81f});
    void exit();
 
    friend bool b2callback(b2ShapeId shapeId, void *ctx);
    void physicsUpdate(float timeStep);
    int subSteps = 4;
 
    void registerBody(PhysicsBody *body);
    void deRegisterBody(PhysicsBody *body);
 
    Vector2 gravity = {0.0f, 9.81f};
    b2WorldDef worldDef;
    b2WorldId worldId;
 
    PhysicsBody* findBodyFromShape(b2ShapeId id);
private:
    std::unordered_map<b2ShapeId, PhysicsBody *> bodyMap;
 
    std::vector<b2ShapeId> currentHovered;
    std::vector<b2ShapeId> lastHovered;
};
 
class StaticBody : public PhysicsBody
{
public:
    StaticBody();
    StaticBody(const std::shared_ptr<Shape> &shape);
 
    void physicsUpdate() override;
    void initCompute() override;
 
    void setPosition(Vector2 pos) const;
    void setAngle(float angle) const;
 
    template <class Archive>
    void save(Archive &ar) const
    {
        ar(cereal::base_class<PhysicsBody>(this));
    }
 
    template <class Archive>
    void load(Archive &ar)
    {
        ar(cereal::base_class<PhysicsBody>(this));
    }
};
 
class RigidBody : public PhysicsBody
{
public:
    RigidBody();
    explicit RigidBody(const std::shared_ptr<Shape> &shape);
 
    void physicsUpdate() override;
    void initCompute() override;
 
    void setPosition(Vector2 pos) const;
    void setAngle(float angle) const;
 
    void setLinearVelocity(Vector2 vel) const;
    void applyForce(Vector2 force) const;
    void applyImpulse(Vector2 impulse) const;
 
    bool isOnGround();
    void lockRotation(bool value);
    Vector2 getLinearVelocity() const;
 
    template <class Archive>
    void save(Archive &ar) const
    {
        ar(cereal::base_class<PhysicsBody>(this), CEREAL_NVP(rotationLocked));
    }
 
    template <class Archive>
    void load(Archive &ar)
    {
        ar(cereal::base_class<PhysicsBody>(this), CEREAL_NVP(rotationLocked));
    }
 
private:
    bool rotationLocked = false;
};
 
class KinematicBody : public PhysicsBody
{
public:
    KinematicBody();
    explicit KinematicBody(const std::shared_ptr<Shape> &shape);
 
    void physicsUpdate() override;
    void initCompute() override;
 
    void setLinearVelocity(Vector2 vel) const;
    void applyForce(Vector2 force) const;
    void applyImpulse(Vector2 impulse) const;
 
    Vector2 getLinearVelocity() const;
 
    template <class Archive>
    void save(Archive &ar) const
    {
        ar(cereal::base_class<PhysicsBody>(this));
    }
 
    template <class Archive>
    void load(Archive &ar)
    {
        ar(cereal::base_class<PhysicsBody>(this));
    }
};
 
CEREAL_REGISTER_TYPE(RigidBody);
CEREAL_REGISTER_TYPE(StaticBody);
CEREAL_REGISTER_POLYMORPHIC_RELATION(Component, RigidBody);
CEREAL_REGISTER_POLYMORPHIC_RELATION(Component, StaticBody);