PHANToM_Device.h

Go to the documentation of this file.

#ifndef PHANTOM_H
#define PHANTOM_H


#ifndef COMPILE_PHANTOM_DEVICE
    #include "PHANToM_compile.inc"
#endif


#ifdef COMPILE_PHANTOM_DEVICE

#include <vrecko/IOPins.h>
#include <vrecko/Ability.h>
#include <vrecko/Device.h>
#include <vrecko/EventDispatcher.h>
#include <vrecko/MTLock.h>
#include <helpers/DynamicArray.h>

#include <HD/hd.h>
#include <HDU/hduVector.h>
#include <HDU/hduError.h>

#include <osg/Matrix>

namespace vreckoDP_PHANToM {

class DP_EXPORT PHANToMFilter;

typedef struct {
    osg::Vec3 position;
    osg::Matrix orientation;
    osg::Vec3 velocity;
    osg::Vec3 acceleration;
    HDint nCurrentButtons;
    HDint nLastButtons;

// If Phantom is relative to the camera, then the following variables hold different values than the [position] and [orientation]
// (the untransformed ones)
    osg::Vec3 absolutePosition;
    osg::Matrix absoluteOrientation;
} PHANToMSTATE;


struct PHANTOM_HELD_OBJECT {
    unsigned long objectID;
    osg::Matrix transform; // sub-transform of this particular object from the center of gravity/rotation (of the whole group of held objects)

    PHANTOM_HELD_OBJECT & operator= (const PHANTOM_HELD_OBJECT & other) {
        objectID = other.objectID;
        transform = other.transform;
        return *this;
    }

};

typedef DynamicArray<PHANTOM_HELD_OBJECT> PHANTOM_HELD_OBJECTS_ARRAY;


class DP_EXPORT PHANToM : public vrecko::Device  {
    public:
        PHANToM(void);
//      PHANToM(int freq);
        ~PHANToM();

        virtual bool loadXMLParameters(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *);

        virtual void preInitialize(void);
        virtual void postInitialize(void);

        void processEvent(const std::string &input_name, void *value);
        
        virtual int openDevice(void);
        int closeDevice(void);
        int calibrateDevice(void);

        void update(void);

        // filters
        void addFilter(PHANToMFilter* newFilter);
            // filter is added to the correct position using its priority.
            // If there is already a filter with the same priority, it will be added after that.

        void removeFilter(unsigned int);
        void removeFilter(PHANToMFilter*);
//      std::vector<PHANToMFilter*> &getAdditionalFilterVector(void) {return filter;}
        void applyFilters(PHANToMSTATE &pState, osg::Vec3 &temp_force, osg::Vec3 &temp_torque);

        void resetFilters(void);
            // All filter will return to the initial state - useful for example after grabbing a new object
            // WARNING: The caller must acquire call acquireMainLock()/releaseMainLock() (i.e. filters don't have to - it's already done)

        bool isForceApplied() { return !bDontApplyForce; }

        inline void acquireMainLock() { filterVectorLock.lock(); }
        inline void releaseMainLock() { filterVectorLock.unlock(); }

        void setHeldObjects(PHANTOM_HELD_OBJECTS_ARRAY * newHeldObjects);
            // [newHeldObjects] might be NULL, the object list is copied, so the caller may deallocate the memory.
            // WARNING: Whoever calls this must also call acquireMainLock()/releaseMainLock(),
            // i.e. filters doesn't need to lock it, but callers from outside the Phantom thread MUST OBTAIN THE LOCK !
            // WARNING 2: Inside the lock, the resetFilters() SHOULD ALSO BE CALLED !

        PHANTOM_HELD_OBJECTS_ARRAY * getHeldObjects(bool *bIsDefault = NULL);
            // WARNING: Whoever calls this must also call acquireMainLock()/releaseMainLock(),
            // i.e. filters doesn't need to lock it, but callers from outside the Phantom thread MUST OBTAIN THE LOCK
            // WARNING 2: Only the pointer is returned, so you have to process the returned information (or copy it elsewhere)
            // BEFORE releasing the lock.
            // if [bIsDefault] is not NULL, it will receive whether the returned array are the default held objects or not.

        inline PHANTOM_HELD_OBJECTS_ARRAY * getDefaultHeldObjects(void) { return &defaultHeldObjects; }
            // And again:
            // WARNING: Whoever calls this must also call acquireMainLock()/releaseMainLock(),
            // i.e. filters doesn't need to lock it, but callers from outside the Phantom thread MUST OBTAIN THE LOCK
            // WARNING 2: Only the pointer is returned, so you have to process the returned information (or copy it elsewhere)
            // BEFORE releasing the lock.

        // For shared use in filters, should be used after setting/getting the held objects
        // inside the same acquireMainLock()/releaseMainLock() sequence
        inline const osg::Matrix &getHeldObjectsTransform() const { return heldObjectsTransform; }
        inline void setHeldObjectsTransform(osg::Matrix const &newTransform) { heldObjectsTransform = newTransform; }
            // The transformation should not include the scaling, just rotation and translation

        void setLastPhantomTrans(osg::Matrix &newMat);
            // Set the last phantom transformation.
            // For use in methods outside of this class. Will use the [lastPhantomTransLock] automatically.
        void getLastPhantomTrans(osg::Matrix *outMat);
            // Get the last phantom transformation.
            // For use in methods outside of this class. Will use the [lastPhantomTransLock] automatically.


        void setCollisionOccurred(bool bNewValue) { bCollisionOccurred = bNewValue; }
        bool getCollisionOccurred() { return bCollisionOccurred; }


        float workspace_scale;
        bool bRelativeToCamera;
        float fCameraOffset;
        bool bVisualizeAxes; // requires objects with IDs 999804, 999805 and 999806 

        vrecko::MTLock avatarDataLock;
        bool avatarPosModifiedByUs; // [avatarDataLock] must be used before accessing the variable
                    // were the variables below modified by this class or Phantom filters? 
                    // i.e. should we set the avatar pos on the next update instead of reading it.
        osg::Vec3 avatarPos; // [avatarDataLock] must be used before accessing the variable
        osg::Vec3 avatarLookAt; // normalized. [avatarDataLock] must be used before accessing the variable
        osg::Vec3 avatarUp; // normalized. [avatarDataLock] must be used before accessing the variable

        bool bInitializeHeldObjectsTransform;
            // Initial condition, because the Device is created BEFORE the Scene creation.
            // Therefore the objects' transformations have to be queried in the first update() or similarly.

        bool stopMotion(bool state);
        bool bStopMotion;

    protected:
        HHD hHD;
        HDSchedulerHandle hHSCallback;
        osg::Vec3 position, velocity;
        osg::Matrix orientation, transform;
        bool button_state;
        vrecko::EventDispatcher *pEventDispatcher;
        bool last_button_state;

        bool bDeviceOpened;

        bool bDontApplyForce;
            // A "debug" switch to disable the force.
            // The force is still calculated, but the results are thrown away.

        // additional filters
        std::vector<PHANToMFilter*> filters;
        vrecko::MTLock filterVectorLock;

        osg::Matrix heldObjectsTransform;
            // The transformation should not include the scaling, just rotation and translation
        PHANTOM_HELD_OBJECTS_ARRAY heldObjects;
        PHANTOM_HELD_OBJECTS_ARRAY defaultHeldObjects;
            // (Operated by setHeldObjects()/getHeldObjects())
            // The list of objects which the user holds in their hand AND
            // the list of objects which are used as a backup when the user "doesn't hold" anything (so typically we can display a hand)


        bool bCollisionOccurred; // has collision occurred _in this frame_

        
        vrecko::MTLock lastPhantomTransLock;
        osg::Matrix lastPhantomTrans;
            // Last phantom transformation, use the [lastPhantomTransLock] for access or getLastPhantomTrans() method.
            // For use in the methods outside this class, filters receive the position/rotation automatically.


        void readHeldObjectsFromXML( XERCES_CPP_NAMESPACE_QUALIFIER DOMNode * tmpNode, PHANTOM_HELD_OBJECTS_ARRAY* defaultHeldObjects );

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

        DECLARE_OUTPUT(Position, vrecko::MessageVec3);
        DECLARE_OUTPUT(Orientation, vrecko::MessageQuat);
        DECLARE_OUTPUT(Button, vrecko::MessageBool);
};


class DP_EXPORT PHANToMFilter : public vrecko::Ability {
    public:
        PHANToMFilter(const char* abName) : Ability(abName), filter_enabled(true), bIsAfterReset(true), bActiveAfterReset(true), resetTime(0) {};
        //~PHANToMFilter() {}; -> no default constructor -> force to name the Ability

        virtual void apply(PHANToMSTATE &pState, osg::Vec3 &force, osg::Vec3 &torque) {};

        void enableFilter(void) {filter_enabled = true;}
        void disableFilter(void) {filter_enabled = false;}
        bool isFilterEnabled(void) {return filter_enabled;}

        inline bool isAfterReset(void) { return bIsAfterReset; }
        inline void setIsAfterReset(bool bNewAfterReset) { bIsAfterReset = bNewAfterReset; if (bNewAfterReset) { resetTime = osg::Timer::instance()->tick(); }  }
        inline osg::Timer_t getResetTime() { return resetTime; }

        inline bool isActiveFirstTime() { return bActiveAfterReset; }
        inline void setActiveAfterReset(bool bNewActiveAfterReset) { bActiveAfterReset = bNewActiveAfterReset; }

//      inline int getFilterPriority() { return iFilterPriority; }
//      void setFilterPriorty(int newPriority) { iFilterPriority = newPriority; } // Note: This will NOT reorder the filters (i.e. it must be done before adding the filter to the phantom filter "stack")
 
    protected:
        bool filter_enabled;
        bool bIsAfterReset;
            // Is this the FIRST time the filter would be applied (if the [bActiveAfterReset] is "true")?
            // (Managed automatically by the PHANToM device plugin through our setIsAfterReset() method.)
            // Use isAfterReset() to get the value.
        bool bActiveAfterReset;
            // Is the filter executed in the first run?
            // (Managed automatically by the PHANToM device plugin through our setActiveAfterReset() method.)
            // Use isActiveFirstTime() to get the value.
        osg::Timer_t resetTime;
//      int iFilterPriority;
            // The default priority is 0.
};

}

#endif //COMPILE_PHANTOM_DEVICE

#endif //PHANTOM_H