Body.h

/*
 * Copyright (C) 2014 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef BODY_H
#define BODY_H

#include <QObject>
#include <QPointF>
#include <QQmlListProperty>
#include <QSet>
#include <QVariant>
#include <functional>
#include <queue>

class Actor;
class Joint;
class b2Body;
class b2Fixture;
class b2Shape;
struct b2BodyDef;
struct b2FixtureDef;

class Body : public QObject {
    Q_OBJECT

    Q_PROPERTY(Actor* actor READ getActor)

    
    Q_PROPERTY(BodyType bodyType READ getBodyType WRITE setBodyType NOTIFY bodyTypeChanged)

    Q_PROPERTY(bool active READ isActive WRITE setActive NOTIFY activeChanged)

    Q_PROPERTY(float linearDamping READ getLinearDamping WRITE setLinearDamping
            NOTIFY linearDampingChanged)

    Q_PROPERTY(float angularDamping READ getAngularDamping WRITE setAngularDamping
            NOTIFY angularDampingChanged)

    Q_PROPERTY(float gravityScale READ getGravityScale WRITE setGravityScale
            NOTIFY gravityScaleChanged)

    Q_PROPERTY(bool magnetic READ isMagnetic WRITE setMagnetic NOTIFY magneticChanged)

    Q_PROPERTY(float magneticStrength READ getMagneticStrength WRITE setMagneticStrength
            NOTIFY magneticStrengthChanged)

    Q_PROPERTY(QPointF position READ getPosition WRITE setPosition NOTIFY positionSet)

    Q_PROPERTY(float angleInRadians READ getAngleInRadians WRITE setAngleInRadians
            NOTIFY angleInRadiansSet)

    Q_PROPERTY(QPointF linearVelocity READ getLinearVelocity WRITE setLinearVelocity
            NOTIFY linearVelocitySet)

    Q_PROPERTY(float angularVelocity READ getAngularVelocity WRITE setAngularVelocity
            NOTIFY angularVelocitySet)

    Q_PROPERTY(bool sensor READ isSensor WRITE setSensor NOTIFY sensorChanged)

    Q_PROPERTY(float density READ getDensity WRITE setDensity NOTIFY densityChanged)

    Q_PROPERTY(float friction READ getFriction WRITE setFriction NOTIFY frictionChanged)

    Q_PROPERTY(float restitution READ getRestitution WRITE setRestitution NOTIFY restitutionChanged)

    Q_PROPERTY(QQmlListProperty<Joint> joints READ getJointListProperty NOTIFY jointsChanged)

public:

    Q_ENUMS(BodyType)
    enum BodyType {

        StaticBody = 0,

        KinematicBody,

        DynamicBody
    };

    explicit Body(QObject* parent = 0);

    virtual ~Body();

    Actor* getActor() const;

    BodyType getBodyType() const;

    void setBodyType(BodyType value);

    bool isActive() const;

    void setActive(bool value);

    float getLinearDamping() const;

    void setLinearDamping(float value);

    float getAngularDamping() const;

    void setAngularDamping(float value);

    float getGravityScale() const;

    void setGravityScale(float value);

    bool isMagnetic() const { return mMagnetic; }

    void setMagnetic(bool value);

    float getMagneticStrength() const { return mMagneticStrength; }

    void setMagneticStrength(float value);

    QPointF getPosition() const;

    void setPosition(const QPointF& value);

    float getAngleInRadians() const;

    void setAngleInRadians(float value);

    QPointF getLinearVelocity() const;

    void setLinearVelocity(const QPointF& value);

    float getAngularVelocity() const;

    void setAngularVelocity(float value);

    bool isSensor() const { return mIsSensor; }

    void setSensor(bool value);

    float getDensity() const { return mDensity; }

    void setDensity(float value);

    float getFriction() const { return mFriction; }

    void setFriction(float value);

    float getRestitution() const { return mRestitution; }

    void setRestitution(float value);

    const QList<Joint*>& getJoints() const { return mJoints; }

    QQmlListProperty<Joint> getJointListProperty();

    void setJoints(const QList<Joint*>& value);

    Q_INVOKABLE Joint* getJoint(int index) { return mJoints[index]; }

    Q_INVOKABLE int getJointCount() const { return mJoints.size(); }

    Q_INVOKABLE void addJoint(Joint* joint);

    Q_INVOKABLE void removeJoint(Joint* joint);

    Q_INVOKABLE void clearJoints();

    Q_INVOKABLE void clearAllAttachedJoints();

    b2Body* getBody() { return mBody; }

    Q_INVOKABLE void applyTorque(float torque);

    Q_INVOKABLE void applyForceToCenter(const QPointF& force);

    void invalidateTransform() { mTransformDirty = true; }

    virtual void updateBeforePhysics();

    virtual void updateAfterPhysics();

    QList<Body*> getContactedBodies() const;

    void beginContact(Body* otherBody, const QPointF& normal);

    void endContact(Body* otherBody, const QPointF& normal);

    virtual void forEachShape(const std::function<void(b2Shape*)>& func) { (void) func; }

protected:
    void invalidateFixtures() { mFixturesDirty = true; }
    void forEachFixture(const std::function<void(b2Fixture*)>& func);

signals:

    void bodyTypeChanged();

    void activeChanged();

    void linearDampingChanged();

    void angularDampingChanged();

    void gravityScaleChanged();

    void magneticChanged();

    void magneticStrengthChanged();

    void positionSet();

    void angleInRadiansSet();

    void linearVelocitySet();

    void angularVelocitySet();

    void sensorChanged();

    void densityChanged();

    void frictionChanged();

    void restitutionChanged();

    void jointsChanged();

    void contactBegun(Body* otherBody, QPointF normal);

    void contactEnded(Body* otherBody, QPointF normal);

    void queuedContactBegun(Body* otherBody, QPointF normal);

    void queuedContactEnded(Body* otherBody, QPointF normal);

private:
    b2BodyDef getBodyDef();
    b2FixtureDef getFixtureDef();
    void addFixtures(b2FixtureDef* def);
    void createFixtures();
    void destroyFixtures();

    friend class Joint;
    void registerAttachedJoint(Joint* joint);
    void unregisterAttachedJoint(Joint* joint);

    // --------------------------------------------------------------------------------------
    // Internal methods to implement QQmlListProperty<Joint*>
    // --------------------------------------------------------------------------------------
    static void appendJoint(QQmlListProperty<Joint>* property, Joint* value);
    static Joint* jointAt(QQmlListProperty<Joint>* property, int index);
    static void clearJoints(QQmlListProperty<Joint>* property);
    static int countJoints(QQmlListProperty<Joint>* property);

    mutable Actor* mActor = nullptr;

    b2Body* mBody = nullptr;
    bool mFixturesDirty = true;
    bool mTransformDirty = true;

    bool mMagnetic = false;
    float mMagneticStrength = 1.0f;

    bool mIsSensor = false;
    float mDensity = 1.0f;
    float mFriction = 0.3f;
    float mRestitution = 0.3f;

    QList<Joint*> mAttachedJoints;
    QMap<Body*, int> mContactCountMap;
    QList<Joint*> mJoints;
};
Q_DECLARE_METATYPE(Body*)

#endif // BODY_H