gameControlInformation.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2015 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/



#pragma once

#include <joystickCore/joystickCore.h>
#include <joystickCore/gameControllerEvents.h>

#include <vrvUtil/DtUnicode.h>

#include <boost/serialization/access.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/list.hpp>
#include <boost/serialization/map.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/string.hpp>
#include <boost/archive/xml_oarchive.hpp>
#include <boost/archive/xml_iarchive.hpp>

namespace makVrv
{
   class DT_DLL_JOYSTICKCORE DtGameControlInformation
   {
   public:
      enum GameControllerFlags
      {
         TransitionUp = 0x00000001,
         TransitionDown = 0x00000002,
         Repeat = 0x00000004,
         ResetToZeroOnRelease = 0x00000008,
         Reverse = 0x00000010,
         Toggle = 0x00000020,
         SetTo = 0x00000040,
      };

      struct GameControlEvent
      {
         GameControlEvent() : controlEvent(0), flags(0), transitionValue(0), deviceIndex(-1) {};
         virtual ~GameControlEvent() { delete controlEvent; };
         GameControlEvent(const GameControlEvent& orig) : flags(orig.flags), transitionValue(orig.transitionValue), controlEvent(0),
            controllerName(orig.controllerName), controllerGuid(orig.controllerGuid), deviceIndex(orig.deviceIndex)
         {
            if (orig.controlEvent)
            {
               controlEvent = orig.controlEvent->clone();
            }
         }

         GameControlEvent& operator=(const GameControlEvent& rhs)
         {
            if (this != &rhs)
            {
               flags = rhs.flags;
               transitionValue = rhs.transitionValue;
               controllerName = rhs.controllerName;
               controllerGuid = rhs.controllerGuid;

               delete controlEvent;
               controlEvent = 0;

               if (rhs.controlEvent)
               {
                  controlEvent = rhs.controlEvent->clone();
               }
            }

            return *this;
         }

         bool needsTransition() const { return transitionUp() || transitionDown(); };
         bool transitionUp() const { return ((flags & TransitionUp) != 0); };
         bool transitionDown() const { return ((flags & TransitionDown) != 0); };
         bool repeat() const { return ((flags & Repeat) != 0); };
         bool resetToZeroOnRelease() const { return ((flags & ResetToZeroOnRelease) != 0); };
         bool reverse() const { return ((flags & Reverse) != 0); };
         bool toggle() const { return ((flags & Toggle) != 0); };
         bool setTo() const { return ((flags & SetTo) != 0); };
         void setControlEvent(DtGenericControllerEvent* e)
         {
            delete controlEvent;
            controlEvent = 0;

            if (e)
            {
               controlEvent = e->clone();
            }
         }

         bool eventMatches(DtGenericControllerEvent* rhs) const
         {
            return (controlEvent && rhs && (*controlEvent == *rhs));
         }

         bool isMatchingUpEvent(DtGenericControllerEvent* e) const
         {
            return (controlEvent && controlEvent->isReleaseEvent(e));
         }

         bool isIdle(double value) const
         {            
            int eventType = GameControllerEventUnknown;
            if (controlEvent)
            {
               eventType = controlEvent->myType;
            }

            if (value == 0.)
            {
               if (eventType == GameControlEventKeyboard)
               {
                  return resetToZeroOnRelease();
               }

               return true;
            }

            return false;
         }

         DtGenericControllerEvent* controlEvent;
         std::string controllerName;
         std::string controllerGuid;
         int flags;
         double transitionValue;
         int deviceIndex;

      protected:
         friend class boost::serialization::access;

         template<class Archive>
            void serialize(Archive & ar, const unsigned int version)
         {
            int eventType = GameControllerEventUnknown;

            ar & BOOST_SERIALIZATION_NVP(controllerName);
            ar & BOOST_SERIALIZATION_NVP(controllerGuid);
            ar & BOOST_SERIALIZATION_NVP(deviceIndex);
            ar & BOOST_SERIALIZATION_NVP(flags);
            ar & BOOST_SERIALIZATION_NVP(transitionValue);

            if (Archive::is_loading::value)
            {
               ar & BOOST_SERIALIZATION_NVP(eventType);

               if (eventType != GameControllerEventUnknown)
               {
                  if (eventType == GameControlEventJoystick)
                  {
                     controlEvent = new DtGameControllerJoystickEvent;
                  }
                  else if (eventType == GameControlEventKeyboard)
                  {
                     controlEvent = new DtGameControllerKeyboardEvent;
                  }

                  if (controlEvent)
                  {
                     controlEvent->read(*(boost::archive::xml_iarchive*)&ar,version);
                  }
               }
            }
            else
            {
               if (controlEvent)
               {
                  eventType = controlEvent->myType;
               }

               ar & BOOST_SERIALIZATION_NVP(eventType);

               if (controlEvent)
               {
                  controlEvent->write(*(boost::archive::xml_oarchive*)&ar,version);
               }
            }
         }
      };
      typedef std::vector<GameControlEvent> GameControlEvents;

      DtGameControlInformation();

      virtual ~DtGameControlInformation();

      void addControllerEvent(const DtGenericControllerEvent&, int flags, double transitionValue,
         const std::string& controllerName, const std::string& controllerGuid);

      void addControllerEvent(int flags, double transitionValue,
         const std::string& controllerName, const std::string& controllerGuid);
      void addControllerEvent(const GameControlEvent&);
      void addControllerEvents(const GameControlEvents&);
      void removeControllerEvent(const DtGenericControllerEvent&);

      bool eventMatches(DtGenericControllerEvent* rhs) const;

      bool isMatchingUpEvent(DtGenericControllerEvent* e) const;

      const GameControlEvents& controllerEvents() const
      {
         return myControllerEvents;
      }

      bool isSpecified() const
      {
         return (myControllerEvents.size() != 0);
      }

      void clear();
      DtUnicode controllerName() const;
      DtUnicode descriptiveString() const;

      DtGameControlInformation& operator=(const DtGameControlInformation&);

   protected:
      friend class boost::serialization::access;

      template<class Archive>
         void serialize(Archive & ar, const unsigned int version)
      {
         ar & BOOST_SERIALIZATION_NVP(myControllerEvents);
      }

   protected:
      GameControlEvents myControllerEvents;
   };
}