D:/SoftwareEntwicklung/C++/HLC/Tools/SoftPixelEngine/repository/sources/Base/spInputOutputControl.hpp

Go to the documentation of this file.

/*
 * Input control header
 * 
 * This file is part of the "SoftPixel Engine" (Copyright (c) 2008 by Lukas Hermanns)
 * See "SoftPixelEngine.hpp" for license information.
 */

#ifndef __SP_INPUTOUTPUT_CONTROL_H__
#define __SP_INPUTOUTPUT_CONTROL_H__


#include "Base/spStandard.hpp"
#include "Base/spInputKeyCodes.hpp"
#include "Base/spDimensionPoint2D.hpp"
#include "Base/spDimensionVector3D.hpp"
#include "Base/spInputOutputLog.hpp"
#include "Base/spXBox360GamePad.hpp"

#include <math.h>
#include <boost/shared_ptr.hpp>

#if defined(SP_PLATFORM_LINUX)
#   include <X11/X.h>
#   include <X11/Xlib.h>
#   include <X11/Xutil.h>
#elif defined(SP_PLATFORM_ANDROID)
#   include <android/input.h>
#   include "Platform/Android/android_native_app_glue.h"
#endif


namespace sp
{

class SoftPixelDevice;

#if defined(SP_PLATFORM_WINDOWS)
class SoftPixelDeviceWin32;
#elif defined(SP_PLATFORM_LINUX)
class SoftPixelDeviceLinux;
#elif defined(SP_PLATFORM_ANDROID)
class SoftPixelDeviceAndroid;
#elif defined(SP_PLATFORM_IOS)
class SoftPixelDeviceIOS;
#endif

#ifdef SP_COMPILE_WITH_OPENGL
namespace video
{
    class RenderContext;
}
#endif

namespace io
{


#if defined(SP_PLATFORM_WINDOWS) || defined(SP_PLATFORM_LINUX)

class SP_EXPORT InputControl
{
    
    public:
        
        InputControl();
        ~InputControl();
        
        /* === Functions === */
        
        void setCursorPosition(const dim::point2di &Position, bool UpdateCursorSpeed = true);
        dim::point2di getCursorPosition() const;
        
        dim::point2di getCursorSpeed();
        
        bool& keyDown(const EKeyCodes KeyCode);
        bool& keyHit(const EKeyCodes KeyCode);
        bool& keyReleased(const EKeyCodes KeyCode);
        
        void keyDownSimulation(const EKeyCodes KeyCode) const;
        void keyReleasedSimulation(const EKeyCodes KeyCode) const;
        
        bool& mouseDown(const EMouseKeyCodes KeyCode);
        bool& mouseHit(const EMouseKeyCodes KeyCode);
        bool& mouseReleased(const EMouseKeyCodes KeyCode);
        bool& mouseDoubleClicked(const EMouseKeyCodes KeyCode);
        
        void mouseDownSimulation(const EMouseKeyCodes KeyCode) const;
        void mouseReleasedSimulation(const EMouseKeyCodes KeyCode) const;
        
        s16 getMouseWheel() const;
        
        void setMouseWheel(s16 Value);
        
        void setCursorVisible(bool Visible);
        
        bool joystickDown(const EJoystickKeyCodes KeyCode) const;
        
        dim::vector3df getJoystickPosition() const;
        
        /* === Static functions === */
        
        static void clearInput();
        static void resetInput();
        
        static void keyEventDown(u32 KeyCode);
        static void keyEventUp(u32 KeyCode);
        
        /* === Inline functions === */
        
        inline void setWordInput(bool Enable)
        {
            WordInput_ = Enable;
        }
        inline bool getWordInput() const
        {
            return WordInput_;
        }
        
        inline io::stringc getEnteredWord() const
        {
            return WordString_;
        }
        inline io::stringc& getEnteredWord()
        {
            return WordString_;
        }
        inline void releaseEnteredWord(io::stringc &Str)
        {
            Str = WordString_;
            WordString_.clear();
        }
        
        #ifdef SP_COMPILE_WITH_XBOX360GAMEPAD
        
        inline XBox360GamePadPtr getXBox360GamePad(s32 Number) const
        {
            return XBox360GamePads_[math::MinMax(Number, 0, 3)];
        }
        
        #endif
        
    private:
        
        friend class sp::SoftPixelDevice;
        friend class video::RenderContext;
        
        #if defined(SP_PLATFORM_WINDOWS)
        friend class sp::SoftPixelDeviceWin32;
        #elif defined(SP_PLATFORM_LINUX)
        friend class sp::SoftPixelDeviceLinux;
        #endif
        
        /* === Functions === */
        
        void updatePrevCursorPosition(const dim::point2di &PositionShift);
        void setupInitialCursorPosition();
        
        void updateBaseEvents();
        
        static void recordKey(u32 KeyCode);
        
        /* === Members === */
        
        bool isCursorSpeedBlocked_;
        dim::point2di LastCursorPos_, CursorSpeed_;
        
        bool WordInput_;
        io::stringc WordString_;
        
        #ifdef SP_COMPILE_WITH_XBOX360GAMEPAD
        XBox360GamePadPtr XBox360GamePads_[MAX_XBOX_CONTROLLERS];
        #endif
        
};

#elif defined(SP_PLATFORM_ANDROID)

class SP_EXPORT InputControl
{
    
    public:
        
        InputControl();
        ~InputControl();
        
        /* === Functions === */
        
        s32 processEvent(android_app* App, AInputEvent* Event);
        
        dim::point2df getPointerPosition(u32 Index = 0) const;
        
        f32 getPointerSize(u32 Index = 0) const;
        
        dim::point2df getMotionSpeed(u32 Index = 0);
        
        bool isPointerActive(u32 Index = 0) const;
        
        f32 getPinchSpeed();
        
        bool& keyDown(const EKeyCodes KeyCode);
        bool& keyHit(const EKeyCodes KeyCode);
        bool& keyReleased(const EKeyCodes KeyCode);
        
        /* === Inline functions === */
        
        inline u32 getPointerCount() const
        {
            return PointerCount_;
        }
        
        inline bool isMotionEvent() const
        {
            return isMotionEvent_;
        }
        
        inline dim::vector3df getGyroscopeSensor() const
        {
            return GyroscopeSensor_;
        }
        inline dim::vector3df getAccelerometerSensor() const
        {
            return AccelerometerSensor_;
        }
        inline f32 getLightSensor() const
        {
            return LightSensor_;
        }
        
        inline void setDefaultKeyEventHandling(bool Enable)
        {
            isDefaultKeyEventHandling_ = Enable;
        }
        inline bool getDefaultKeyEventHandling() const
        {
            return isDefaultKeyEventHandling_;
        }
        
        inline void setKeyEnable(const EKeyCodes KeyCode, bool Enable)
        {
            isKeyEnabled_[KeyCode] = Enable;
        }
        inline bool getKeyEnable(const EKeyCodes KeyCode) const
        {
            return isKeyEnabled_[KeyCode];
        }
        
    private:
        
        friend class sp::SoftPixelDevice;
        friend class sp::SoftPixelDeviceAndroid;
        
        /* Macros */
        
        static const s32 POINTER_COUNT = 5;
        
        /* Structures */
        
        struct STouchPointer
        {
            dim::point2df Position;
            f32 Size;
        };
        
        /* Functions */
        
        void setPointer(u32 Index, const dim::point2df &Position, f32 Size);
        void resetInputEvents();
        
        /* Members */
        
        bool isCursorSpeedBlocked_;
        bool isMotionEvent_;
        
        bool isDefaultKeyEventHandling_;
        bool isKeyEnabled_[KEY_BUTTON_MODE + 1];
        
        u32 PointerCount_;
        STouchPointer Pointer_[POINTER_COUNT];
        dim::point2df MotionSpeed_[POINTER_COUNT], MotionPointerPos_[POINTER_COUNT], LastPointerPos_[POINTER_COUNT];
        f32 DragDistance_, LastDragDistance_;
        
        dim::vector3df GyroscopeSensor_, AccelerometerSensor_;
        f32 LightSensor_;
        
};

#elif defined(SP_PLATFORM_IOS)

class SP_EXPORT InputControl
{
    
    public:
        
        InputControl();
        ~InputControl();
        
        /* === Functions === */
        
        dim::point2di getPointerPosition(u32 Index = 0) const;
        
        dim::point2di getMotionSpeed(u32 Index = 0) const;
        
        bool isPointerActive(u32 Index = 0) const;
        
        f32 getPinchSpeed();
        
        u32 getPointerCount() const;
        
    private:
        
        friend class sp::SoftPixelDevice;
        friend class sp::SoftPixelDeviceIOS;
        
        /* Macros */
        
        static const s32 POINTER_COUNT = 5;
        
        /* Functions */
        
        void resetInputEvents();
        
        /* Members */
        
        bool isCursorSpeedBlocked_;
        
        f32 DragDistance_, LastDragDistance_;
        
};

#endif


} // /namespace io

} // /namespace sp


#endif



// ================================================================================