added files of io/event

inc/hgl/io/event/InputEvent.h

@@ -0,0 +1,104 @@
+#ifndef HGL_IO_INPUT_EVENT_INCLUDE
+#define HGL_IO_INPUT_EVENT_INCLUDE
+
+#include<hgl/type/Sets.h>
+#include<hgl/io/event/InputEventSource.h>
+namespace hgl
+{
+    namespace io
+    {
+        struct EventHeader
+        {
+            uint8 type;      ///<输入源类型
+            uint8 index;     ///<输入源索引(比如同一设备有多个)
+            uint16 id;       ///<事件id
+        };
+
+        constexpr size_t EventHeaderBytes=sizeof(EventHeader);
+
+        /**
+         * 事件处理结果
+         */
+        enum class EventProcResult
+        {
+            Continue,
+            Break,
+        };
+
+        class InputEvent
+        {
+        protected:
+
+            InputEventSource source_type;
+
+            Sets<InputEvent *> sub_event_proc[size_t(InputEventSource::RANGE_SIZE)];
+
+        public:
+
+            const InputEventSource GetInputEventSource()const{return source_type;}
+
+            virtual EventProcResult OnEvent(const EventHeader &header,const uint64 data)
+            {
+                if(!RangeCheck((InputEventSource)header.type))
+                    return(EventProcResult::Break);
+
+                if(sub_event_proc[header.type].GetCount()>0)
+                {
+                    for(InputEvent *ie:sub_event_proc[header.type])
+                        if(ie->OnEvent(header,data)==EventProcResult::Break)
+                            return EventProcResult::Break;
+
+                    if(sub_event_proc[size_t(InputEventSource::Root)].GetCount()>0
+                     &&InputEventSource(header.type)!=InputEventSource::Root)
+                    {
+                        for(InputEvent *ie:sub_event_proc[size_t(InputEventSource::Root)])
+                            if(ie->OnEvent(header,data)==EventProcResult::Break)
+                                return EventProcResult::Break;
+                    }
+                }
+
+                return(EventProcResult::Continue);
+            }
+
+        public:
+
+            InputEvent()
+            {
+                source_type=InputEventSource::Root;
+            }
+
+            InputEvent(InputEventSource ies)
+            {
+                source_type=ies;
+            }
+
+            virtual ~InputEvent()=default;
+
+            virtual bool Join(InputEvent *ie)
+            {
+                if(!ie)
+                    return(false);
+
+                const InputEventSource ies=ie->GetInputEventSource();
+
+                if(!RangeCheck(ies))
+                    return(false);
+
+                return(sub_event_proc[size_t(ies)].Add(ie)!=-1);
+            }
+
+            bool Unjoin(InputEvent *ie)
+            {
+                if(!ie)return(false);
+
+                const InputEventSource ies=ie->GetInputEventSource();
+
+                if(!RangeCheck(ies))
+                    return(false);
+
+                return sub_event_proc[size_t(ies)].Delete(ie);
+            }
+        };//class InputEvent
+    }//namespace io
+}//namespace hgl
+#endif//HGL_IO_INPUT_EVENT_INCLUDE

inc/hgl/io/event/InputEventSource.h

@@ -0,0 +1,24 @@
+#ifndef HGL_IO_INPUT_DEVICE_SOURCE_INCLUDE
+#define HGL_IO_INPUT_DEVICE_SOURCE_INCLUDE
+
+#include<hgl/TypeFunc.h>
+namespace hgl
+{
+    namespace io
+    {
+        enum class InputEventSource
+        {
+            Root=0,
+
+            OS,
+            Window,
+
+            Keyboard,
+            Mouse,
+            Joystick,
+
+            ENUM_CLASS_RANGE(Root,Joystick)
+        };
+    }//namespace io
+}//namespace hgl
+#endif//HGL_IO_INPUT_DEVICE_SOURCE_INCLUDE

inc/hgl/io/event/JoystickEvent.h

@@ -0,0 +1,61 @@
+#ifndef HGL_IO_DEVICE_MOUSE_EVENT_INCLUDE
+#define HGL_IO_DEVICE_MOUSE_EVENT_INCLUDE
+
+#include<hgl/TypeFunc.h>
+namespace hgl
+{
+    namespace io
+    {        
+        /**
+        * 手柄按键枚举
+        */
+        enum class JoystickButton
+        {
+            NONE=0,
+
+            Up,
+            Down,
+            Left,
+            Right,
+
+            _0,        _1,        _2,        _3,        _4,        _5,        _6,        _7,
+            _8,        _9,        _10,       _11,       _12,       _13,       _14,       _15,
+            _16,       _17,       _18,       _19,       _20,       _21,       _22,       _23,
+            _24,       _25,       _26,       _27,       _28,       _29,       _30,       _31,
+
+            ENUM_CLASS_RANGE(NONE,_31)
+        };
+
+        enum class PlayStationButton
+        {
+            Up          =JoystickButton::Up,
+            Down        =JoystickButton::Down,
+            Left        =JoystickButton::Left,
+            Right       =JoystickButton::Right,
+
+            Fork        =JoystickButton::_0,           // 叉
+            Circle      =JoystickButton::_1,           // 圆
+            Square      =JoystickButton::_2,           // 方
+            Triangle    =JoystickButton::_3,           // 三角
+
+            L1          =JoystickButton::_6,       L2        =JoystickButton::_4,
+            R1          =JoystickButton::_7,       R2        =JoystickButton::_5,
+            Select      =JoystickButton::_8,       Start     =JoystickButton::_9,
+        };
+
+        //enum class XBoxButton
+        //{
+        //    //DreamCast/XBOX
+        //    X=JoystickButton::_2,
+        //    Y=JoystickButton::_3,
+        //    A=JoystickButton::_0,
+        //    B=JoystickButton::_1,
+        //    L=JoystickButton::_4,
+        //    R=JoystickButton::_5,
+
+        //    //XBOX/XBOX360
+        //    //XBOX,                     //西瓜键
+        //};
+    }//namespace io
+}//namespace hgl
+#endif//HGL_IO_DEVICE_MOUSE_EVENT_INCLUDE

inc/hgl/io/event/KeyboardEvent.h

@@ -0,0 +1,277 @@
+#ifndef HGL_IO_KEYBOARD_EVENT_INCLUDE
+#define HGL_IO_KEYBOARD_EVENT_INCLUDE
+
+#include<hgl/io/event/InputEvent.h>
+namespace hgl
+{
+    namespace io
+    {
+        /**
+        * 按键枚举定义
+        */
+        enum class KeyboardButton
+        {
+            NONE=0,
+                                //主键盘区
+            Esc,                ///<ESC
+
+                                //F功能键
+            F1,                 ///<F1
+            F2,                 ///<F2
+            F3,                 ///<F3
+            F4,                 ///<F4
+            F5,                 ///<F5
+            F6,                 ///<F6
+            F7,                 ///<F7
+            F8,                 ///<F8
+            F9,                 ///<F9
+            F10,                ///<F10
+            F11,                ///<F11
+            F12,                ///<F12
+
+            Grave,              //<`号(主键盘数字键1左边的按钮)
+
+                                //10个数字
+            _0,                 ///<数字键0
+            _1,                 ///<数字键1
+            _2,                 ///<数字键2
+            _3,                 ///<数字键3
+            _4,                 ///<数字键4
+            _5,                 ///<数字键5
+            _6,                 ///<数字键6
+            _7,                 ///<数字键7
+            _8,                 ///<数字键8
+            _9,                 ///<数字键9
+
+            Minus,              ///< - (减号)
+            Equals,             ///< = (等号)
+            BackSlash,          ///< \ (反斜杠)
+            BackSpace,          ///< 退格键
+
+            Tab,                ///<Tab键
+
+            A,                  ///<A
+            B,                  ///<B
+            C,                  ///<C
+            D,                  ///<D
+            E,                  ///<E
+            F,                  ///<F
+            G,                  ///<G
+            H,                  ///<H
+            I,                  ///<I
+            J,                  ///<J
+            K,                  ///<K
+            L,                  ///<L
+            M,                  ///<M
+            N,                  ///<N
+            O,                  ///<O
+            P,                  ///<P
+            Q,                  ///<Q
+            R,                  ///<R
+            S,                  ///<S
+            T,                  ///<T
+            U,                  ///<U
+            V,                  ///<V
+            W,                  ///<W
+            X,                  ///<X
+            Y,                  ///<Y
+            Z,                  ///<Z
+
+            LeftBracket,        ///<[
+            RightBracket,       ///<]
+
+            CapsLock,           ///<大写锁定键
+
+            Semicolon,          ///<; (分号)
+            Apostrophe,         ///<' (单引号)
+            Enter,              ///<回车键
+
+            LeftShift,          ///<左边的Shift键
+
+            Comma,              ///<, (逗号)
+            Period,             ///<. (句号)
+            Slash,              ///</ (除号)
+            RightShift,         ///<右边的Shift键
+
+            LeftCtrl,           ///<左边的Ctrl键
+            LeftOS,             ///<左边的OS键(Win/Apple键)
+            LeftAlt,            ///<左边的Alt键
+            Space,              ///<空格键
+            RightAlt,           ///<右边的Alt键
+            RightOS,            ///<右边的OS键(Win/Apple键)
+            RightMenu,          ///<右边的Menu键
+            RightCtrl,          ///<右边的Ctrl键
+
+                                //中键盘区
+            PrintScreen,        ///<打印屏幕键
+            ScrollLock,         ///<滚动锁定键
+            Pause,              ///<暂停键
+
+            Insert,             ///<插入键
+            Delete,             ///<删除键
+            Home,               ///<行首键
+            End,                ///<行尾键
+            PageUp,             ///<向前翻页键
+            PageDown,           ///<向后翻页键
+
+            Up,                 ///<↑光标键
+            Down,               ///<↓光标键
+            Left,               ///<←光标键
+            Right,              ///<→光标键
+
+                                //小键盘区
+            NumLock,            ///<小键盘 数字锁定键
+
+            NumAdd,             ///<小键盘 +
+            NumSubtract,        ///<小键盘 -
+            NumMultiply,        ///<小键盘 *
+            NumDivide,          ///<小键盘 /
+
+            Num0,               ///<小键盘 0
+            Num1,               ///<小键盘 1
+            Num2,               ///<小键盘 2
+            Num3,               ///<小键盘 3
+            Num4,               ///<小键盘 4
+            Num5,               ///<小键盘 5
+            Num6,               ///<小键盘 6
+            Num7,               ///<小键盘 7
+            Num8,               ///<小键盘 8
+            Num9,               ///<小键盘 9
+
+            NumDecimal,         ///<小键盘 . (小数点/删除键)
+            NumEnter,           ///<小键盘 回车键
+
+            ENUM_CLASS_RANGE(NONE,NumEnter)
+        };//enum KeyboardButton
+
+        enum class KeyboardEventID
+        {
+            Pressed=0,
+            Released,
+            Char
+        };
+
+        union KeyboardEventData
+        {
+            uint64 data;
+            uint32 key;
+            os_char ch;
+        };
+
+        class KeyboardEvent:public InputEvent
+        {
+        public:
+
+            KeyboardEvent():InputEvent(InputEventSource::Keyboard){}
+            virtual ~KeyboardEvent()=default;
+
+            EventProcResult OnEvent(const EventHeader &header,const uint64 data) override
+            {
+                if(InputEvent::OnEvent(header,data)==EventProcResult::Break)
+                    return EventProcResult::Break;
+
+                switch(KeyboardEventID(header.id))
+                {
+                    case KeyboardEventID::Pressed:  if(OnPressed    (KeyboardButton(((KeyboardEventData *)&data)->key)))return EventProcResult::Break;break;
+                    case KeyboardEventID::Released: if(OnReleased   (KeyboardButton(((KeyboardEventData *)&data)->key)))return EventProcResult::Break;break;
+                    case KeyboardEventID::Char:     if(OnChar       (               ((KeyboardEventData *)&data)->ch ) )return EventProcResult::Break;break;
+                }
+
+                return EventProcResult::Continue;
+            }
+
+            virtual bool OnPressed(const KeyboardButton &kb){}
+            virtual bool OnReleased(const KeyboardButton &kb){}
+            virtual bool OnChar(const wchar_t &){}
+        };//class KeyboardEvent
+
+        class KeyboardStateEvent:public KeyboardEvent
+        {
+        protected:
+
+            double cur_time;
+            bool press_states[size_t(KeyboardButton::RANGE_SIZE)];
+            double pressed_time[size_t(KeyboardButton::RANGE_SIZE)];
+
+        public:
+
+            KeyboardStateEvent():KeyboardEvent()
+            {
+                cur_time=0;
+                hgl_zero(press_states);
+                hgl_zero(pressed_time);
+            }
+
+            virtual ~KeyboardStateEvent()=default;
+
+            virtual bool OnPressed(const KeyboardButton &kb) override
+            {
+                if(!RangeCheck(kb))return(false);
+
+                press_states[(size_t)kb]=true;
+                pressed_time[(size_t)kb]=cur_time;
+
+                return(true);
+            }
+
+            virtual bool OnReleased(const KeyboardButton &kb) override
+            {
+                if(!RangeCheck(kb))return(false);
+
+                press_states[(size_t)kb]=false;                
+                pressed_time[(size_t)kb]=0;
+
+                return(true);
+            }
+
+        public:
+
+            /**
+             * 某按键是否按下状态
+             */
+            const bool HasPressed(const KeyboardButton &kb)const
+            {
+                if(!RangeCheck(kb))return(false);
+
+                return press_states[size_t(kb)];
+            }
+
+            /**
+             * 设定当前时间
+             */
+            void SetCurTime(const double &ct)
+            {
+                cur_time=ct;
+            }
+
+            /**
+             * 获取按键按下的时间 
+             */
+            const double GetPressedTime(const KeyboardButton &kb)const
+            {   
+                if(!RangeCheck(kb))return(0);
+
+                return pressed_time[size_t(kb)];
+            }
+
+            const bool ShiftPressed()const
+            {
+                return press_states[size_t(KeyboardButton::LeftShift)]
+                     ||press_states[size_t(KeyboardButton::RightShift)];
+            }
+
+            const bool CtrlPressed()const
+            {
+                return press_states[size_t(KeyboardButton::LeftCtrl)]
+                     ||press_states[size_t(KeyboardButton::RightCtrl)];
+            }
+
+            const bool AltPressed()const
+            {
+                return press_states[size_t(KeyboardButton::LeftAlt)]
+                     ||press_states[size_t(KeyboardButton::RightAlt)];
+            }
+        };//class KeyboardStateEvent
+    }//namespace io
+}//namespace hgl
+#endif//HGL_IO_KEYBOARD_EVENT_INCLUDE

inc/hgl/io/event/MouseEvent.h

@@ -0,0 +1,99 @@
+#ifndef HGL_IO_MOUSE_EVENT_INCLUDE
+#define HGL_IO_MOUSE_EVENT_INCLUDE
+
+#include<hgl/io/event/InputEvent.h>
+namespace hgl
+{
+    namespace io
+    {
+        /**
+        * Êó±ê°´Å¥Ã¶¾Ù
+        */
+        enum class MouseButton
+        {
+            None=0,
+
+            Left,
+            Mid,
+            Right,
+
+            X1,X2,
+
+            ENUM_CLASS_RANGE(Left,X2)
+        };
+
+        enum class MouseEventID
+        {
+            Move    =0,
+            Pressed,
+            Released,
+            DblClicked,
+            Wheel
+        };
+
+        union MouseEventData
+        {
+            uint64 data;
+
+            struct
+            {
+                int16 x,y;
+                uint8 button;
+            };
+        };
+
+        constexpr size_t MouseEventDataBytes=sizeof(MouseEventData);
+        
+        class MouseEvent:public InputEvent
+        {
+            MouseEventData *med;
+
+            int x,y;
+
+        public:
+
+            MouseEvent():InputEvent(InputEventSource::Mouse){}
+            virtual ~MouseEvent()=default;
+            
+            EventProcResult OnEvent(const EventHeader &header,const uint64 data) override
+            {
+                if(InputEvent::OnEvent(header,data)==EventProcResult::Break)
+                    return EventProcResult::Break;
+
+                med=(MouseEventData *)&data;
+
+                if(MouseEventID(header.id)==MouseEventID::Wheel)
+                {                    
+                    if(OnWheel      (med->x,med->y)             )return EventProcResult::Break;
+                }
+                else
+                {
+                    x=med->x;y=med->y;
+
+                    switch(MouseEventID(header.id))
+                    {
+                        case MouseEventID::Move:        if(OnMove       (med->x,med->y)                         )return EventProcResult::Break;break;
+                        case MouseEventID::Pressed:     if(OnPressed    (med->x,med->y,MouseButton(med->button)))return EventProcResult::Break;break;
+                        case MouseEventID::Released:    if(OnReleased   (med->x,med->y,MouseButton(med->button)))return EventProcResult::Break;break;
+                        case MouseEventID::DblClicked:  if(OnDblClicked (med->x,med->y,MouseButton(med->button)))return EventProcResult::Break;break;
+                    }
+                }
+
+                return EventProcResult::Continue;
+            }
+
+            virtual bool OnMove      (int,int){return false;}
+            virtual bool OnWheel     (int,int){return false;}
+
+            virtual bool OnPressed   (int,int,MouseButton){return false;}
+            virtual bool OnReleased  (int,int,MouseButton){return false;}
+            virtual bool OnDblClicked(int,int,MouseButton){return false;}
+
+        public:
+
+            const int GetX()const{return x;}
+            const int GetY()const{return y;}
+        };//class MouseEvent
+    }//namespace io
+}//namespace hgl
+#endif//HGL_IO_MOUSE_EVENT_INCLUDE

inc/hgl/io/event/WindowEvent.h

@@ -0,0 +1,64 @@
+#ifndef HGL_IO_WINDOW_EVENT_INCLUDE
+#define HGL_IO_WINDOW_EVENT_INCLUDE
+
+#include<hgl/io/event/InputEvent.h>
+namespace hgl
+{
+    namespace io
+    {
+        enum class WindowEventID
+        {
+            Active,
+            Resize,
+            Close
+        };//enum class WindowEventID
+
+        union WindowEventData
+        {
+            uint64 data;
+
+            struct
+            {
+                int16 width,height;
+            };
+
+            bool active;
+        };
+
+        constexpr size_t WindowEventDataBytes=sizeof(WindowEventData);
+
+        class WindowEvent:public InputEvent
+        {
+            WindowEventData *wed;
+
+        public:
+
+            WindowEvent():InputEvent(InputEventSource::Window){}
+            virtual ~WindowEvent()=default;
+
+            EventProcResult OnEvent(const EventHeader &header,const uint64 data) override
+            {
+                wed=(WindowEventData *)&data;
+
+                switch(WindowEventID(header.id))
+                {
+                    case WindowEventID::Active:OnActive  (wed->active)           ;break;
+                    case WindowEventID::Resize:OnResize  (wed->width,wed->height);break;
+                    case WindowEventID::Close: OnClose   ()                      ;break;
+                }
+
+                if(InputEvent::OnEvent(header,data)==EventProcResult::Break)
+                    return EventProcResult::Break;
+
+                return EventProcResult::Continue;
+            }
+
+        public:
+
+            virtual void OnResize(uint,uint){}
+            virtual void OnActive(bool){}
+            virtual void OnClose (){}
+        };//class WindowEvent:public InputEvent
+    }//namespace io
+}//namespace hgl
+#endif//HGL_IO_WINDOW_EVENT_INCLUDE

src/CMakeLists.txt

@@ -119,6 +119,13 @@ SET(IO_JAVA_FILES   ${IO_INCLUDE_PATH}/JavaInputStream.h
 
 SET(IO_TEXT_FILES   IO/TextOutputStream.cpp)
 
+SET(INPUT_EVENT_FILES   ${IO_INCLUDE_PATH}/event/KeyboardEvent.h
+                        ${IO_INCLUDE_PATH}/event/MouseEvent.h
+                        ${IO_INCLUDE_PATH}/event/JoystickEvent.h
+                        ${IO_INCLUDE_PATH}/event/InputEvent.h)
+
+SOURCE_GROUP("IO\\Event"   FILES ${INPUT_EVENT_FILES})
+
 SOURCE_GROUP("IO\\Base"    FILES ${IO_BASE_FILES})
 SOURCE_GROUP("IO\\Data"    FILES ${IO_DATA_FILES})
 SOURCE_GROUP("IO\\Memory"  FILES ${IO_MEMORY_FILES})
@@ -131,7 +138,8 @@ SET(IO_SOURCE_FILES ${IO_BASE_FILES}
                     ${IO_MEMORY_FILES}
                     ${IO_FILE_FILES}
                     ${IO_JAVA_FILES}
-                    ${IO_TEXT_FILES})
+                    ${IO_TEXT_FILES}
+                    ${INPUT_EVENT_FILES})
 
 SET(FILESYSTEM_INCLUDE_PATH ${CMCORE_ROOT_INCLUDE_PATH}/hgl/filesystem)