EditorController.h

Go to the documentation of this file.

#ifndef EDITORCONTROLLER_H
#define EDITORCONTROLLER_H

#include <vrecko/Ability.h>
#include <osg/Quat>
#include "ControllableAbility.h"
#include "AbilityMapper.h"


using namespace vrecko;

namespace APEditorController
{

class EditorController: public Ability {
public:
    static const int maxPointers = 2;
    static const int maxButtonsPerPointer = 4;

    EditorController();
    ~EditorController();

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

    virtual void update();
    

protected:
    class ECPOINTERBUTTONINFO {
    public:
        ECPOINTERBUTTONINFO() { bState = false; cachedInfo = NULL; }
        ~ECPOINTERBUTTONINFO() { setMappedAbility(NULL); };

        void setOwner(EditorController *_owner) { owner = _owner; }

        bool bState; // current state (pressed or released)

        bool setMappedAbility(const char *strID);
            
        std::string& getMappedAbilityID() { return mappedAbilityID; }
        CAINFO* getMappedAbilityInfo(bool bForceRefresh);

    protected:
        EditorController *owner;
        std::string mappedAbilityID; 
        CAINFO *cachedInfo; 
    };

    class ECPOINTERINFO {
    public:
        ECPOINTERINFO() { actSelection = 0; lastButtonPressed = 0; selPath = NULL; }
        ~ECPOINTERINFO() { if (selPath) { delete selPath; selPath = NULL; } }

        osg::Vec3 pos, posRaw; 
        osg::Quat rot, rotRaw; 

        unsigned long actSelection; 
        std::vector<osg::Node*> *selPath;

        int lastButtonPressed; 

        ECPOINTERBUTTONINFO buttons[maxButtonsPerPointer + 1];
    };

    EnvironmentObject *owner;

//  std::string strSelectionID, strP1Selection, strP2Selection;
//  std::string strP1Visible, strP2Visible;
//  std::string strSelectionReq;

    std::string activeAbilityName; // the name of the active ability
        // "" if no ability is active
    int activeAbilityPointerID, activeAbilityButtonID; // which pointer and button activated the ability

    osg::Vec3 actViewPosition;
        // actual view position
    ECPOINTERINFO pointers[maxPointers + 1];
        // Pointer 0 is only a filler, so it is not necessary to "shift" indexes

    Ability *abilityMapper;
        // automatically created editing ability to map other abilities to the buttons
//  std::string strAbilityMapping;

    bool createAbilityMapper();
    void removeAbilityMapper();
    void setAbilityMapping(AbilityMapper::MAPPING *newMapping);
    AbilityMapper::MessageMapping *compileAbilityMapping();
        // retrieves current mapping and sends it to the AbilityMapped

    unsigned long actSelection;

    void setNewSelection(unsigned long newSelection);

    void pointerPosUpdate(int pointerID, const osg::Vec3 &newPos, bool bRaw = false);

    void pointerRotUpdate(int pointerID, const osg::Quat &newRot, bool bRaw = false);

    void pointerBtnUpdate(int poinerID, int buttonID, bool newState);
    void sendPointerBtnToRelevantOutputs(int pointerID, int buttonID);

    void pointerSelUpdate(int pointerID, unsigned long newSelection);
    void sendPointerSelectionEvent(int pointerID, unsigned long newSelection);

    void abilityActivationTest();
        // Returns whether an ability is active.
        // AND: If the ability is internally marked as "active" and the real state
        // is different, then the internal state is also changed.

    void selectionVisibilityUpdate();
        // Checks active abilities and sets the correct visibility
        // of selection of each pointer.

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


    DECLARE_INPUT(Pointer1Pos, MessageVec3);
    DECLARE_INPUT(Pointer1Rot, MessageQuat);
    DECLARE_INPUT(Pointer1PosRaw, MessageVec3);
    DECLARE_INPUT(Pointer1RotRaw, MessageQuat);
    DECLARE_INPUT(Pointer1Btn1, MessageBool);
    DECLARE_INPUT(Pointer1Btn2, MessageBool);
    DECLARE_INPUT(Pointer1Btn3, MessageBool);
    DECLARE_INPUT(Pointer1Btn4, MessageBool);


    DECLARE_INPUT(Pointer2Pos, MessageVec3);
    DECLARE_INPUT(Pointer2Rot, MessageQuat);
    DECLARE_INPUT(Pointer2PosRaw, MessageVec3);
    DECLARE_INPUT(Pointer2RotRaw, MessageQuat);
    DECLARE_INPUT(Pointer2Btn1, MessageBool);
    DECLARE_INPUT(Pointer2Btn2, MessageBool);
    DECLARE_INPUT(Pointer2Btn3, MessageBool);
    DECLARE_INPUT(Pointer2Btn4, MessageBool);

    DECLARE_OUTPUT(SelectionID, MessageObjectID);
    DECLARE_OUTPUT(Pointer1Selection, MessageObjectID);
    DECLARE_OUTPUT(Pointer1Visible, MessageBool);
    DECLARE_OUTPUT(Pointer2Selection, MessageObjectID);
    DECLARE_OUTPUT(Pointer2Visible, MessageBool);

    // for setting/getting the mapping from the AbilityMapper

    DECLARE_INPUT(AbilityMapping, AbilityMapper::MessageMapping);
    DECLARE_OUTPUT(AbilityMapping, AbilityMapper::MessageMapping);
    DECLARE_REQUEST_INPUT(AbilityMapping, MessageVoid, AbilityMapper::MessageMapping);


    DECLARE_REQUEST_OUTPUT(SelectionByPointerPos_Path, MessageVec3, MessageNodeList);

    DECLARE_REQUEST_INPUT(SelectionID, MessageInt, MessageObjectID);
    DECLARE_REQUEST_INPUT(SelectionPath, MessageInt, MessageNodeList);
    DECLARE_REQUEST_INPUT(PointerPos, MessageInt, MessageVec3);
    DECLARE_REQUEST_INPUT(PointerRot, MessageInt, MessageQuat);
    DECLARE_REQUEST_INPUT(PointerPosRaw, MessageInt, MessageVec3);
    DECLARE_REQUEST_INPUT(PointerRotRaw, MessageInt, MessageQuat);
};

}

#endif