actor.hpp

Go to the documentation of this file.

#ifndef OPENMW_MWPHYSICS_ACTOR_H
#define OPENMW_MWPHYSICS_ACTOR_H

#include <memory>

#include "../mwworld/ptr.hpp"

#include <osg/Vec3f>
#include <osg/Quat>
#include <osg/ref_ptr>

class btCollisionWorld;
class btCollisionShape;
class btCollisionObject;
class btConvexShape;

namespace Resource
{
    class BulletShape;
}

namespace MWPhysics
{

    class PtrHolder
    {
    public:
        virtual ~PtrHolder() {}

        void updatePtr(const MWWorld::Ptr& updated)
        {
            mPtr = updated;
        }

        MWWorld::Ptr getPtr()
        {
            return mPtr;
        }

        MWWorld::ConstPtr getPtr() const
        {
            return mPtr;
        }

    protected:
        MWWorld::Ptr mPtr;
    };

    class Actor : public PtrHolder
    {
    public:
        Actor(const MWWorld::Ptr& ptr, osg::ref_ptr<const Resource::BulletShape> shape, btCollisionWorld* world);
        ~Actor();

        void enableCollisionMode(bool collision);

        bool getCollisionMode() const
        {
            return mInternalCollisionMode;
        }

        btConvexShape* getConvexShape() const { return mConvexShape; }

        void enableCollisionBody(bool collision);

        void updateScale();
        void updateRotation();

        bool isRotationallyInvariant() const;

        void updatePosition();

        void updateCollisionObjectPosition();

        osg::Vec3f getHalfExtents() const;

        osg::Vec3f getCollisionObjectPosition() const;

        void setPosition(const osg::Vec3f& position);

        osg::Vec3f getPosition() const;

        osg::Vec3f getPreviousPosition() const;

        osg::Vec3f getRenderingHalfExtents() const;

        void setInertialForce(const osg::Vec3f &force);

        const osg::Vec3f &getInertialForce() const
        {
            return mForce;
        }

        void setOnGround(bool grounded);

        bool getOnGround() const
        {
            return mInternalCollisionMode && mOnGround;
        }

        void setOnSlope(bool slope);

        bool getOnSlope() const
        {
            return mInternalCollisionMode && mOnSlope;
        }

        btCollisionObject* getCollisionObject() const
        {
            return mCollisionObject.get();
        }

        void setCanWaterWalk(bool waterWalk);

        void setWalkingOnWater(bool walkingOnWater);
        bool isWalkingOnWater() const;

    private:
        void updateCollisionMask();
        void addCollisionMask(int collisionMask);
        int getCollisionMask();

        bool mCanWaterWalk;
        bool mWalkingOnWater;

        bool mRotationallyInvariant;

        std::unique_ptr<btCollisionShape> mShape;
        btConvexShape* mConvexShape;

        std::unique_ptr<btCollisionObject> mCollisionObject;

        osg::Vec3f mMeshTranslation;
        osg::Vec3f mHalfExtents;
        osg::Quat mRotation;

        osg::Vec3f mScale;
        osg::Vec3f mRenderingScale;
        osg::Vec3f mPosition;
        osg::Vec3f mPreviousPosition;

        osg::Vec3f mForce;
        bool mOnGround;
        bool mOnSlope;
        bool mInternalCollisionMode;
        bool mExternalCollisionMode;

        btCollisionWorld* mCollisionWorld;

        Actor(const Actor&);
        Actor& operator=(const Actor&);
    };

}


#endif