AnnEvents.hpp

Go to the documentation of this file.

#pragma once

#include "systemMacro.h"
#include "AnnUserSpaceEvent.hpp"
#include "AnnKeyCode.h"
#include "AnnHandController.hpp"

namespace Annwvyn
{
    class AnnTimer;
    class AnnTriggerObject;
    class AnnPlayerBody;

    enum AnnEventType {
        NO_TYPE,
        USER_INPUT,
        TIMER_TIMEOUT,
        TRIGGER_CONTACT,
        HAND_CONTROLLER,
        COLLISION,
        PLAYER_COLLISION
    };
    class AnnDllExport AnnEvent
    {
    public:
        AnnEvent();
        AnnEventType getType() const;

    protected:
        AnnEventType type;
        friend class AnnEventManager;
    };

    class AnnDllExport AnnKeyEvent : public AnnEvent
    {
        AnnKeyEvent();

    public:
        KeyCode::code getKey() const;
        bool isPressed() const;
        bool isReleased() const;
        bool shouldIgnore() const;

    private:
        friend class AnnEventManager;
        KeyCode::code key;
        bool pressed;
        bool ignored;
        void setPressed();
        void setReleased();
        void setCode(KeyCode::code c);
    };

    enum MouseAxisID { X,
                       Y,
                       Z,
                       AxisCount,
                       InvalidAxis };

    enum MouseButtonId { Left,
                         Right,
                         Middle,
                         Button3,
                         Button4,
                         Button5,
                         Button6,
                         Button7,
                         ButtonCount,
                         InvalidButton };

    class AnnDllExport AnnMouseAxis
    {
    public:
        AnnMouseAxis();
        MouseAxisID getMouseAxisId() const;
        int getRelValue() const;
        int getAbsValue() const;

    private:
        friend class AnnEventManager;
        friend class AnnMouseEvent;
        MouseAxisID id;
        int rel;
        int abs;

        void setAxis(MouseAxisID ax);
        void setRelValue(int rel);
        void setAbsValue(int abs);
        AnnMouseAxis(MouseAxisID ax, int rel, int abs);
    };

    class AnnDllExport AnnMouseEvent : public AnnEvent
    {
    public:
        AnnMouseEvent();
        bool getButtonState(MouseButtonId id);

        AnnMouseAxis getAxis(MouseAxisID id);

    private:
        AnnMouseAxis axes[AxisCount];
        bool buttonsStatus[ButtonCount];

        friend class AnnEventManager;

        void setButtonStatus(MouseButtonId id, bool value);

        void setAxisInformation(MouseAxisID id, AnnMouseAxis information);
    };

    using ButtonId         = int;
    using ControllerAxisID = int;
    using PovId            = int;
    using ControllerID   = int;

    static constexpr ControllerAxisID InvalidStickAxisId = -1;
    static constexpr float INVALID                       = 42.0f;

    class AnnDllExport AnnControllerAxis
    {
    public:
        AnnControllerAxis();
        ControllerAxisID getAxisId() const;
        float getRelValue() const;
        float getAbsValue() const;

    private:
        friend class AnnEventManager;
        friend class AnnControllerEvent;

        int a, r;
        ControllerAxisID id;
        void setAxis(ControllerAxisID ax);
        void setRelValue(int rel);
        void setAbsValue(int abs);
        AnnControllerAxis(ControllerAxisID ax, int rel, int abs);
        bool noRel;
    };

    class AnnDllExport AnnControllerPov
    {
    public:
        AnnControllerPov();

        bool getNorth() const;
        bool getSouth() const;
        bool getEast() const;
        bool getWest() const;

        bool getNorthEast() const;
        bool getSouthEast() const;
        bool getNorthWest() const;
        bool getSouthWest() const;

        bool isCentred() const;

    private:
        bool north;
        bool south;
        bool east;
        bool west;

        friend class AnnEventManager;
        friend class AnnControllerEvent;

        AnnControllerPov(unsigned int binaryDirection);
    };

    class AnnDllExport AnnControllerEvent : public AnnEvent
    {
    public:
        AnnControllerEvent();
        ~AnnControllerEvent();

        size_t getNbButtons() const;

        std::vector<unsigned short> getPressed() const;
        std::vector<unsigned short> getReleased() const;

        bool isPressed(ButtonId id);
        bool isReleased(ButtonId id);
        bool isDown(ButtonId id);
        AnnControllerAxis getAxis(ControllerAxisID ax);
        size_t getAxisCount() const;
        ControllerID getControllerID() const;
        std::string getVendor() const;
        size_t getPovCount() const;
        AnnControllerPov getPov(PovId pov);

        bool isXboxController() const;

    private:
        bool xbox;
        friend class AnnEventManager;
        std::vector<byte> buttons;
        std::vector<AnnControllerAxis> axes;
        std::vector<AnnControllerPov> povs;
        std::vector<unsigned short> pressed;
        std::vector<unsigned short> released;
        std::string vendor;
        int stickID;
    };
    class AnnHandController;

    class AnnDllExport AnnHandControllerEvent : public AnnEvent
    {
    public:
        AnnHandControllerEvent();
        AnnHandControllerEvent(AnnHandController* controller);
        AnnVect3 getPosition() const;
        AnnQuaternion getOrientation() const;
        AnnVect3 getPointingDirection() const;
        AnnVect3 getLinearSpeed() const;
        AnnVect3 getAngularSpeed() const;
        AnnHandControllerAxis& getAxis(uint8_t id) const;
        size_t getAxisCount() const;
        size_t getButtonCount() const;
        bool buttonPressed(uint8_t id) const;
        bool buttonReleased(uint8_t id) const;
        bool buttonState(uint8_t id) const;
        AnnHandController::AnnHandControllerSide getSide() const;
        AnnHandController::AnnHandControllerTypeHash getType() const;
        AnnHandController* _getController() const;

    private:
        friend class AnnEventManager;
        AnnHandController* controller;
    };

    using AnnTimerID = int;

    class AnnDllExport AnnTimeEvent : public AnnEvent
    {
    public:
        AnnTimeEvent();
        AnnTimeEvent(const AnnTimer& timer);
        AnnTimerID getID() const;

    private:
        friend class AnnEventManager;
        void setTimerID(AnnTimerID id);
        AnnTimerID tID;
    };

    class AnnGameObject;

    class AnnDllExport AnnCollisionEvent : public AnnEvent
    {
    public:
        AnnCollisionEvent(AnnGameObject* first, AnnGameObject* second, AnnVect3 position, AnnVect3 normal);
        bool hasObject(AnnGameObject* obj) const;
        AnnGameObject* getA() const;
        AnnGameObject* getB() const;
        AnnVect3 getPosition() const;
        AnnVect3 getNormal() const;

        bool isWallCollision(float scalarApprox = 0.0125) const;
        bool isGroundCollision(float scalarApprox = 0.125) const;
        bool isCeilingCollision(float scalarApprox = 0.125) const;

    private:
        AnnGameObject *a, *b;
        const AnnVect3 position, normal;
    };

    class AnnDllExport AnnPlayerCollisionEvent : public AnnEvent
    {
    public:
        AnnPlayerCollisionEvent(AnnGameObject* collided);
        AnnGameObject* getObject() const;

    private:
        AnnGameObject* col;
    };

    class AnnDllExport AnnTriggerEvent : public AnnEvent
    {
    public:
        AnnTriggerEvent();
        bool getContactStatus() const;
        AnnTriggerObject* getSender() const;

    private:
        friend class AnnEventManager;
        bool contact;
        AnnTriggerObject* sender;
    };

    class AnnDllExport AnnTimer
    {
    public:
        AnnTimerID getID() const;

    private:
        friend class AnnEventManager;
        AnnTimer(AnnTimerID id, double delay);
        bool isTimeout() const;
        AnnTimerID tID;
        double timeoutTime;
    };

    class AnnDllExport AnnControllerBuffer
    {
    public:
        friend class AnnEventManager;
        AnnControllerBuffer(OIS::JoyStick* joystick);
        AnnControllerBuffer(const AnnControllerBuffer&) = delete;
        AnnControllerBuffer& operator=(const AnnControllerBuffer&) = delete;
        AnnControllerBuffer(AnnControllerBuffer&& buffer) = default;
        AnnControllerBuffer& operator=(AnnControllerBuffer&& buffer) = default;
        ~AnnControllerBuffer();

        void capture() const;

    private:
        OIS::JoyStick* oisJoystick;
        std::vector<byte> previousStickButtonStates;
        unsigned int getID() const { return id; }
        unsigned int id;
        static unsigned int idcounter;
    };
}