ControllableAbility.h

Go to the documentation of this file.

#ifndef CONTROLLABLEABILITY_H
#define CONTROLLABLEABILITY_H

/*

I/O CHANGES:

16 Feb 2008
    It is possible to obtain full scene graph path for the selected object (requestSelectionPath())
24 Aug 2007
    Instead of overriding the createInfo() method, you have to override the fillDefaultInfo().
*/


#include <vrecko/Ability.h>
#include <vrecko/IOPins.h>
#include <osg/Quat>
#include <osg/Node>


namespace vrecko {


    #ifndef ANIMATOR_IMP_EXP
        #ifdef AP_EDITORCONTROLLER_EXPORTS
            #define EDITORCONTROLLER_IMP_EXP __declspec(dllexport)
        #else
            #define EDITORCONTROLLER_IMP_EXP __declspec(dllimport)
        #endif
    #endif



    #define POINTERPOS_REQUEST_NAME         "PointerPosition"
    #define POINTERROT_REQUEST_NAME         "PointerRotation"
    #define POINTERPOS_RAW_REQUEST_NAME     "PointerPositionRaw"
    #define POINTERROT_RAW_REQUEST_NAME     "PointerRotationRaw"
    #define SELECTIONID_REQUEST_NAME        "SelectionID"
    #define SELECTIONPATH_REQUEST_NAME      "SelectionPath"
        // Returns the same "std::vector<osg::Node*>" as
        // ObjectUtils/ObjectSelector/"SelectionByPointerPos_Path" request

#pragma pack(push, 1)
    struct CABUTTONEVENT {
        /*  Size of the structure. Newer versions could have additional information
            attached at the end. */
        unsigned long dwSize;
        /* ID of the pointer assigned to the button */
        int iPointerID;
        /* ID of the button that generated the event */
        int iButtonID;
        /* New state of the button (pressed = true, not pressed = false) */
        bool bState;
    };

    class MessageCAButtonEvent : public VreckoMessage {
    public:
        virtual const char* getMessageId() { return "MessageCAButtonEvent"; }
        CABUTTONEVENT data;
    };

// Constants for CAINFO::dwFlags:
    #define CAINFO_FLAGS_POINTERLOC_REQUESTOUTPUTS      0x00000001

    #define CAINFO_FLAGS_SELECTIONID_REQUESTOUTPUT      0x00000002

    #define CAINFO_FLAGS_ALL_ACTIVEPOINTER_BUTTONS      0x00000004

    #define CAINFO_FLAGS_ALL_OTHERPOINTER_BUTTONS       0x00000008

    #define CAINFO_FLAGS_POINTERLOC_RAW_REQUESTOUTPUTS  0x00000010

    #define CAINFO_FLAGS_NO_AUTO_DEACTIVATE             0x80000000


    // Constants for CAINFO::dwActiveFlags:
    /* Constants to set the preference... Should the selection be visible or not?
        We have to determine the visibility of the selection of the active pointer (ACTPTR)
        and other pointers (OTHERPTR).
        The preference could be DONTCARE, FORCESHOW, SHOW, HIDE and FORCEHIDE.
        Multiple abilities can be active at the same time, so the preferences could be conflicting.
        The SHOW/HIDE are suggestions, FORCESHOW/FORCEHIDE are stronger suggestions
        (a single active ability returning FORCESHOW will override any number of FORCEHIDEs) */
    #define CAINFO_AFLAGS_SELSHOW_ACTPTR__SHIFT         0
    #define CAINFO_AFLAGS_SELSHOW_ACTPTR__MASK          0x00000007
    #define CAINFO_AFLAGS_SELSHOW_ACTPTR_DONTCARE       0x00000000
    #define CAINFO_AFLAGS_SELSHOW_ACTPTR_HIDE           0x00000001  // Side note: The flags are sorted by their priorities
    #define CAINFO_AFLAGS_SELSHOW_ACTPTR_SHOW           0x00000002  // (The EditorController::SelectionVisibilityUpdate() expects it to be so, so don't change the numbers)
    #define CAINFO_AFLAGS_SELSHOW_ACTPTR_FORCEHIDE      0x00000003
    #define CAINFO_AFLAGS_SELSHOW_ACTPTR_FORCESHOW      0x00000004
    #define CAINFO_AFLAGS_SELSHOW_OTHERPTR__SHIFT       3
    #define CAINFO_AFLAGS_SELSHOW_OTHERPTR__MASK        0x00000038
    #define CAINFO_AFLAGS_SELSHOW_OTHERPTR_DONTCARE     (CAINFO_AFLAGS_SELSHOW_ACTPTR_DONTCARE >> CAINFO_AFLAGS_SELSHOW_ACTPTR__SHIFT << CAINFO_AFLAGS_SELSHOW_OTHERPTR__SHIFT)
    #define CAINFO_AFLAGS_SELSHOW_OTHERPTR_SHOW         (CAINFO_AFLAGS_SELSHOW_ACTPTR_SHOW >> CAINFO_AFLAGS_SELSHOW_ACTPTR__SHIFT << CAINFO_AFLAGS_SELSHOW_OTHERPTR__SHIFT)
    #define CAINFO_AFLAGS_SELSHOW_OTHERPTR_HIDE         (CAINFO_AFLAGS_SELSHOW_ACTPTR_HIDE >> CAINFO_AFLAGS_SELSHOW_ACTPTR__SHIFT << CAINFO_AFLAGS_SELSHOW_OTHERPTR__SHIFT)
    #define CAINFO_AFLAGS_SELSHOW_OTHERPTR_FORCEHIDE    (CAINFO_AFLAGS_SELSHOW_ACTPTR_FORCEHIDE >> CAINFO_AFLAGS_SELSHOW_ACTPTR__SHIFT << CAINFO_AFLAGS_SELSHOW_OTHERPTR__SHIFT)
    #define CAINFO_AFLAGS_SELSHOW_OTHERPTR_FORCESHOW    (CAINFO_AFLAGS_SELSHOW_ACTPTR_FORCESHOW >> CAINFO_AFLAGS_SELSHOW_ACTPTR__SHIFT << CAINFO_AFLAGS_SELSHOW_OTHERPTR__SHIFT)

    struct CAINFO__VER1 {
        unsigned long dwSize;
        enum CAType {
            Unknown = 0,
            SimpleVREdit = 1,
            AbilityMapper = 2,
            DummyCATypeToDWORD = 0xFFFFFFFF,
        };
        CAType type;
        unsigned long dwFlags;
    };

    struct CAINFO__VER2 : public CAINFO__VER1 {
        unsigned long dwActiveFlags;
    };

    typedef CAINFO__VER2 CAINFO;

    #define IS_CAINFO_VER(info, ver) \
        ((info).dwSize >= sizeof(CAINFO__VER##ver))


#pragma pack(pop)

    class EDITORCONTROLLER_IMP_EXP ControllableAbility : public Ability {
    public:

        class MessageCAINFO : public VreckoMessage {
        public:
            virtual const char* getMessageId() { return "MessageCAINFO"; }
            CAINFO data;
        };

        ControllableAbility(const char *abilityName);
        virtual ~ControllableAbility();

        virtual bool initialize(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *parameters = NULL);

        virtual void update() {}

        // Called mostly by the VRECKO to handle a received event
        // CAN be overridden, but it HAS TO CALL the ancestor's method
        //      (if the event is not fully processed by your method)
//      virtual void processEvent(const std::string &strInputName, void *pValue);

        virtual bool isActive();

    protected:
        EnvironmentObject *owner;   

        int activePointerID; 

        int lastEventButtonID; 

        osg::Vec3 actPointerPos;
            
        osg::Vec3 actPointerPosRaw;
        
        osg::Quat actPointerRot;
            
        osg::Quat actPointerRotRaw;

        unsigned long actSelectedObjectID;
            
            std::vector<osg::Node*> *actSelectedPath;
            
        int actPosInPath;



        virtual void createInterface();
        
        virtual void destroyInterface();

        virtual void processButtonPress(CABUTTONEVENT* eventData) {}

        virtual void processButtonRelease(CABUTTONEVENT* eventData) {}

        virtual int processNotification(BaseClass *sender, unsigned long notificationType, void *notificationData);

        virtual bool activate() { return true; }

        virtual void deactivate();

        virtual CAINFO* createInfo();

        CAINFO defaultInfo; // the base info, that will be used in createInfo() method.

        virtual void fillDefaultInfo() = 0;

        bool requestPointerLoc(bool bCancelIfNotActive = true);

        bool requestPointerLocRaw(bool bCancelIfNotActive = true);

        bool requestSelectionID(bool bCancelIfNotActive = true);

        bool requestSelectionPath(bool bCancelIfNotActive = true);

        Ability *menu;
        bool bMenuVisible; // "cached" value, which may be updated in an isMenuCreated() call
        inline bool isMenuCreated() { return (menu != NULL); }
        
        bool isMenuVisible();

        virtual bool createMenu(const char *menuString, bool bForceCreate = true);
        virtual void destroyMenu();
        virtual bool showMenu();
        virtual bool hideMenu();

        virtual void processMenuButtonPress(CABUTTONEVENT* eventData);
            
        virtual void processMenuButtonRelease(CABUTTONEVENT* eventData);


        virtual void menuItemClicked(const char* itemID) {};

        virtual void menuSliderChanged(const char* sliderID, float sliderPos) {};

        DECLARE_INPUT(ButtonStateChange, MessageCAButtonEvent);
        DECLARE_INPUT(Menu_Clicked, MessageString);

        DECLARE_REQUEST_INPUT(ActivePointerID, MessageInt, MessageInt);
        DECLARE_REQUEST_INPUT(GetInfo, MessageVoid, MessageCAINFO);

        DECLARE_REQUEST_OUTPUT(PointerPos, MessageInt, MessageVec3);
        DECLARE_REQUEST_OUTPUT(PointerRot, MessageInt, MessageQuat);

        DECLARE_REQUEST_OUTPUT(PointerPosRaw, MessageInt, MessageVec3);
        DECLARE_REQUEST_OUTPUT(PointerRotRaw, MessageInt, MessageQuat);

        DECLARE_REQUEST_OUTPUT(SelectionID, MessageInt, MessageObjectID);
        DECLARE_REQUEST_OUTPUT(SelectionPath, MessageInt, MessageNodeList);

    private:
        virtual void preInitialize() { };

        virtual void postInitialize() {}

        virtual bool loadXMLParameters(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *pParametersNode) { return true; }

    };

}

#endif