Windows系统窗口消息支持

example/Vulkan/VulkanAppFramework.h

@@ -43,6 +43,8 @@ public:
 
     virtual bool Init(int w,int h) 
     {
+        InitNativeWindowSystem();
+
         win=CreateRenderWindow(OS_TEXT("VulkanTest"));
         if(!win)
             return(false);
@@ -80,14 +82,9 @@ public:
         device->QueuePresent();
     }
 
-    void Wait(double seconds) 
+    bool Run()
     {
-    #ifdef WIN32
+        win->MessageProc();
-        Sleep(seconds * 1000.0f);
+        return !win->IsClose();
-    #elif defined(__ANDROID__)
-        sleep(seconds);
-    #else
-        sleep(seconds);
-    #endif
     }
 };//class VulkanApplicationFramework

example/Vulkan/main.cpp

@@ -169,7 +169,7 @@ int main(int,char **)
     app.AcquireNextFrame();
     app.Draw();
 
-    app.Wait(0.5);
+    while(app.Run());
     
     return 0;
 }

inc/hgl/platform/InputDevice.h

@@ -4,26 +4,26 @@
 namespace hgl
 {
     /**
-	* 鼠标按钮枚举
+    * 鼠标状态枚举定义
     */
-	enum MouseButton:int
+    enum MouseButton
     {
-		mbLeft=0,
+        mbMove				=0x00000001,    ///<鼠标移动了
-		mbRight,
-		mbMiddle,
 
-		mbX1,
+        mbLeft				=0x00000010,    ///<鼠标左键处于按下状态
-		mbX2,
+        mbMid				=0x00000100,	///<鼠标中键处于按下状态
+        mbRight				=0x00001000,    ///<鼠标右键处于按下状态
 
-		mbEnd
+        mbShift				=0x10000000,    ///<Shift键处于按下状态
-	};//enum MouseButton
+        mbCtrl				=0x20000000,    ///<Ctrl键处于按下状态
+    };
 
 	/**
 	* 按键枚举定义
 	*/
 	enum KeyboardButton
 	{
-		kb_NONE=0,			///<起始定义，无意义
+        kbBeginRange=0,
 
 		//主键盘区
 		kbEsc,              ///<ESC
@@ -154,7 +154,8 @@ namespace hgl
 		kbNumDecimal,       ///<小键盘 . (小数点/删除键)
 		kbNumEnter,         ///<小键盘 回车键
 
-		kb_END				///<结束定义，无意义
+		kbEndRange,
+        kbRangeSize=kbEndRange-kbBeginRange+1
 	};//enum KeyboardButton
 
 	/**
@@ -162,7 +163,7 @@ namespace hgl
 	*/
 	enum JoystickButton
 	{
-		jbNone=0,
+		jbBeginRange=0,
 
 		jbUp,
 		jbDown,
@@ -195,6 +196,9 @@ namespace hgl
 
 		//XBOX/XBOX360
 		jbXBOX,						//西瓜键
+
+        jbEndRange,
+        jbRangeSize=jbEndRange-jbBeginRange+1
 	};
 }//namespace hgl
 #endif//HGL_INPUT_DEVICE_INCLUDE

inc/hgl/platform/Window.h

@@ -2,29 +2,60 @@
 #define HGL_GRAPH_WINDOW_INCLUDE
 
 #include<hgl/type/BaseString.h>
+#include<hgl/platform/InputDevice.h>
 namespace hgl
 {
-    namespace graph
-    {
     class Window
     {
     protected:
 
         uint width,height;
+        bool full_screen;
 
         OSString win_name;
 
+        bool active;
+        bool is_close;
+
+        bool key_push[kbRangeSize];
+
     public:
 
         uint GetWidth()const{return width;}
         uint GetHeight()const{return height;}
 
+    public:
+
+        virtual void OnMouseMove        (int,int){}
+        virtual void OnMouseWheel       (int,int, int){}
+        virtual void OnMouseDown        (int,int,uint){}
+        virtual void OnMouseUp          (int,int,uint){}
+        virtual void OnMouseDoubleClick (int,int,uint){}
+
+        //virtual void OnJoystickDown     (uint){}
+        //virtual void OnJoystickPress	(uint){}
+        //virtual void OnJoystickUp		(uint){}
+
+        virtual void OnKeyDown  (KeyboardButton);
+        virtual void OnKeyPress (KeyboardButton){}
+        virtual void OnKeyUp    (KeyboardButton);
+
+        virtual void OnChar     (os_char){}
+
+        virtual void OnResize   (int w,int h){width=w;height=h;}
+
+        virtual void OnActive   (bool a){active=a;}
+        virtual void OnClose    (){is_close=true;}
+
     public:
 
         Window(const OSString &wn)
         {
             width=height=0;
             win_name=wn;
+            active=false;
+            is_close=true;
+            hgl_zero(key_push);
         }
         virtual ~Window()=default;
 
@@ -32,11 +63,23 @@ namespace hgl
         virtual bool Create(uint,uint,uint)=0;
         virtual void Close()=0;
 
+                bool IsClose()const{return is_close;}
+
+        virtual void SetCaption(const OSString &)=0;
+
         virtual void Show()=0;
         virtual void Hide()=0;
+
+        virtual void ToMinWindow(){}
+        virtual void ToMaxWindow(){}
+
+        virtual void SetSystemCursor(bool){}
+
+        virtual bool MessageProc()=0;
     };//class Window
 
     Window *CreateRenderWindow(const OSString &win_name);
-    }//namespace graph
+    
+    void InitNativeWindowSystem();
 }//namespace hgl
 #endif//HGL_GRAPH_WINDOW_INCLUDE

src/Platform/CMakeLists.txt

@@ -89,10 +89,14 @@ IF(WIN32)
 
     SET(PLATFORM_DESKTOP_SOURCE         Win/Desktop.cpp)
 
-    SET(PLATFORM_WINDOW_SOURCE          Win/WinWindow.cpp)
+    SET(PLATFORM_WINDOW_SOURCE          Win/WinWindow.h
-    SET(PLATFORM_INPUT_DEVICE_SOURCE    Win/KeyConvert.cpp)
+										Win/WinWindow.cpp
+										Win/WinMessage.cpp
+										Win/WinVulkan.cpp)
 ENDIF(WIN32)
 
+SET(PLATFORM_WINDOW_SOURCE ${PLATFORM_WINDOW_SOURCE} Window.cpp)
+
 SOURCE_GROUP("InputDevice"  FILES ${PLATFORM_INPUT_DEVICE_SOURCE})
 SOURCE_GROUP("CodePage"     FILES ${PLATFORM_CODEPAGE_SOURCE})
 SOURCE_GROUP("File"         FILES ${PLATFORM_FILE_SOURCE})

src/Platform/Win/KeyConvert.cpp

@@ -1,171 +0,0 @@
-#include<hgl/type/DataType.h>
-#include<hgl/platform/InputDevice.h>
-#include<Windows.h>
-
-#ifdef _DEBUG
-#include<hgl/LogInfo.h>
-#endif//_DEBUG
-
-namespace hgl
-{
-	static KeyboardButton KeyConvert[256];
-
-	void InitKeyConvert()
-	{
-		int i;
-
-		memset(KeyConvert,0,sizeof(KeyConvert));
-
-		KeyConvert[VK_ESCAPE    ]=kbEsc;
-		for(i=VK_F1;i<=VK_F12;i++)KeyConvert[i]=(KeyboardButton)(kbF1+i-VK_F1);
-
-		KeyConvert['`'          ]=kbGrave;
-		for(i='0';i<='9';i++)KeyConvert[i]=(KeyboardButton)(kb0+i-'0');
-		KeyConvert['-'          ]=kbMinus;
-		KeyConvert['='          ]=kbEquals;
-		KeyConvert['\\'         ]=kbBackSlash;
-		KeyConvert[VK_BACK      ]=kbBackSpace;
-
-		KeyConvert[VK_TAB       ]=kbTab;
-		KeyConvert['Q'          ]=kbQ;
-		KeyConvert['W'          ]=kbW;
-		KeyConvert['E'          ]=kbE;
-		KeyConvert['R'          ]=kbR;
-		KeyConvert['T'          ]=kbT;
-		KeyConvert['Y'          ]=kbY;
-		KeyConvert['U'          ]=kbU;
-		KeyConvert['I'          ]=kbI;
-		KeyConvert['O'          ]=kbO;
-		KeyConvert['P'          ]=kbP;
-		KeyConvert['['          ]=kbLeftBracket;
-		KeyConvert[']'          ]=kbRightBracket;
-
-		KeyConvert[VK_CAPITAL   ]=kbCapsLock;
-		KeyConvert['A'          ]=kbA;
-		KeyConvert['S'          ]=kbS;
-		KeyConvert['D'          ]=kbD;
-		KeyConvert['F'          ]=kbF;
-		KeyConvert['G'          ]=kbG;
-		KeyConvert['H'          ]=kbH;
-		KeyConvert['J'          ]=kbJ;
-		KeyConvert['K'          ]=kbK;
-		KeyConvert['L'          ]=kbL;
-		KeyConvert[';'          ]=kbSemicolon;
-		KeyConvert['\''         ]=kbApostrophe;
-		KeyConvert[VK_RETURN    ]=kbEnter;
-
-		KeyConvert[VK_LSHIFT    ]=kbLeftShift;
-		KeyConvert['Z'          ]=kbZ;
-		KeyConvert['X'          ]=kbX;
-		KeyConvert['C'          ]=kbC;
-		KeyConvert['V'          ]=kbV;
-		KeyConvert['B'          ]=kbB;
-		KeyConvert['N'          ]=kbN;
-		KeyConvert['M'          ]=kbM;
-		KeyConvert[','          ]=kbComma;
-		KeyConvert['.'          ]=kbPeriod;
-		KeyConvert['/'          ]=kbSlash;
-		KeyConvert[VK_RSHIFT    ]=kbRightShift;
-
-		KeyConvert[VK_LCONTROL  ]=kbLeftCtrl;
-		KeyConvert[VK_LWIN		]=kbLeftOS;
-		KeyConvert[VK_LMENU		]=kbLeftAlt;
-		KeyConvert[VK_SPACE     ]=kbSpace;
-		KeyConvert[VK_RMENU		]=kbRightAlt;
-		KeyConvert[VK_RWIN		]=kbRightOS;
-		KeyConvert[VK_RCONTROL  ]=kbRightCtrl;
-
-		KeyConvert[VK_PAUSE     ]=kbPause;
-	//        KeyConvert[VK_CLEAR     ]=kbClear;
-
-		KeyConvert[VK_NUMPAD0   ]=kbNum0;
-		KeyConvert[VK_NUMPAD1   ]=kbNum1;
-		KeyConvert[VK_NUMPAD2   ]=kbNum2;
-		KeyConvert[VK_NUMPAD3   ]=kbNum3;
-		KeyConvert[VK_NUMPAD4   ]=kbNum4;
-		KeyConvert[VK_NUMPAD5   ]=kbNum5;
-		KeyConvert[VK_NUMPAD6   ]=kbNum6;
-		KeyConvert[VK_NUMPAD7   ]=kbNum7;
-		KeyConvert[VK_NUMPAD8   ]=kbNum8;
-		KeyConvert[VK_NUMPAD9   ]=kbNum9;
-
-		KeyConvert[VK_DECIMAL   ]=kbNumDecimal;
-		KeyConvert[VK_DIVIDE    ]=kbNumDivide;
-		KeyConvert[VK_MULTIPLY  ]=kbNumMultiply;
-		KeyConvert[VK_SUBTRACT  ]=kbNumSubtract;
-		KeyConvert[VK_ADD       ]=kbNumAdd;
-
-		KeyConvert[VK_UP        ]=kbUp;
-		KeyConvert[VK_DOWN      ]=kbDown;
-		KeyConvert[VK_LEFT      ]=kbLeft;
-		KeyConvert[VK_RIGHT     ]=kbRight;
-
-		KeyConvert[VK_INSERT    ]=kbInsert;
-		KeyConvert[VK_DELETE    ]=kbDelete;
-		KeyConvert[VK_HOME      ]=kbHome;
-		KeyConvert[VK_END       ]=kbEnd;
-		KeyConvert[VK_PRIOR     ]=kbPageUp;
-		KeyConvert[VK_NEXT      ]=kbPageDown;
-
-		KeyConvert[VK_NUMLOCK   ]=kbNumLock;
-		KeyConvert[VK_SCROLL    ]=kbScrollLock;
-
-		//KeyConvert[VK_SHIFT		]=kbLeftShift;
-		//KeyConvert[VK_CONTROL	]=kbLeftCtrl;
-		//KeyConvert[VK_MENU		]=kbLeftAlt;
-
-		KeyConvert[VK_OEM_1		]=kbSemicolon;
-		KeyConvert[VK_OEM_PLUS	]=kbEquals;
-		KeyConvert[VK_OEM_COMMA	]=kbComma;
-		KeyConvert[VK_OEM_MINUS	]=kbMinus;
-		KeyConvert[VK_OEM_PERIOD]=kbPeriod;
-		KeyConvert[VK_OEM_2		]=kbSlash;
-		KeyConvert[VK_OEM_3		]=kbGrave;
-		KeyConvert[VK_OEM_4		]=kbLeftBracket;
-		KeyConvert[VK_OEM_5		]=kbBackSlash;
-		KeyConvert[VK_OEM_6		]=kbRightBracket;
-		KeyConvert[VK_OEM_7		]=kbApostrophe;
-	}
-
-	KeyboardButton ConvertOSKey(uint key)
-	{
-		if(key<0||key>=256)return(kb_NONE);
-
-		if(key==VK_SHIFT)
-		{
-			if((GetAsyncKeyState(VK_LSHIFT)>>15)&1)
-				return kbLeftShift;
-			else
-				return kbRightShift;
-		}
-		else
-		if(key==VK_CONTROL)
-		{
-			if((GetAsyncKeyState(VK_LCONTROL)>>15)&1)
-				return kbLeftCtrl;
-			else
-				return kbRightCtrl;
-		}
-		if(key==VK_MENU)
-		{
-			if((GetAsyncKeyState(VK_LMENU)>>15)&1)
-				return kbLeftAlt;
-			else
-				return kbRightAlt;
-		}
-
-#ifdef _DEBUG
-		if(KeyConvert[key]==0)
-		{
-			wchar_t name[64];
-
-			::GetKeyNameTextW(key,name,64);
-
-			LOG_INFO(WideString(L"Unknow Key: " )+WideString(key)
-                    +WideString(L" ,name: "     )+WideString(name));
-		}
-#endif _DEBUG
-
-		return KeyConvert[key];
-	}
-}//namespace hgl

src/Platform/Win/WinMessage.cpp

@@ -0,0 +1,315 @@
+#include"WinWindow.h"
+#include<hgl/platform/InputDevice.h>
+#include<Windows.h>
+
+#ifdef _DEBUG
+#include<hgl/LogInfo.h>
+#endif//_DEBUG
+
+namespace hgl
+{
+    namespace
+    {
+	    static KeyboardButton KeyConvert[256];
+        static void (*WMProc[2048])(WinWindow *,uint32,uint32);					//消息处理队列
+
+        uint32 GetKeyFlags(uint32 wflags)
+        {
+            uint32 flag=0;
+
+            if(wflags&MK_LBUTTON)flag|=mbLeft;
+            if(wflags&MK_RBUTTON)flag|=mbRight;
+            if(wflags&MK_MBUTTON)flag|=mbMid;
+
+            if(wflags&MK_SHIFT  )flag|=mbShift;
+            if(wflags&MK_CONTROL)flag|=mbCtrl;
+
+            return(flag);
+        }
+
+	    void InitKeyConvert()
+	    {
+		    int i;
+
+		    memset(KeyConvert,0,sizeof(KeyConvert));
+
+		    KeyConvert[VK_ESCAPE    ]=kbEsc;
+		    for(i=VK_F1;i<=VK_F12;i++)KeyConvert[i]=(KeyboardButton)(kbF1+i-VK_F1);
+
+		    KeyConvert['`'          ]=kbGrave;
+		    for(i='0';i<='9';i++)KeyConvert[i]=(KeyboardButton)(kb0+i-'0');
+		    KeyConvert['-'          ]=kbMinus;
+		    KeyConvert['='          ]=kbEquals;
+		    KeyConvert['\\'         ]=kbBackSlash;
+		    KeyConvert[VK_BACK      ]=kbBackSpace;
+
+		    KeyConvert[VK_TAB       ]=kbTab;
+		    KeyConvert['Q'          ]=kbQ;
+		    KeyConvert['W'          ]=kbW;
+		    KeyConvert['E'          ]=kbE;
+		    KeyConvert['R'          ]=kbR;
+		    KeyConvert['T'          ]=kbT;
+		    KeyConvert['Y'          ]=kbY;
+		    KeyConvert['U'          ]=kbU;
+		    KeyConvert['I'          ]=kbI;
+		    KeyConvert['O'          ]=kbO;
+		    KeyConvert['P'          ]=kbP;
+		    KeyConvert['['          ]=kbLeftBracket;
+		    KeyConvert[']'          ]=kbRightBracket;
+
+		    KeyConvert[VK_CAPITAL   ]=kbCapsLock;
+		    KeyConvert['A'          ]=kbA;
+		    KeyConvert['S'          ]=kbS;
+		    KeyConvert['D'          ]=kbD;
+		    KeyConvert['F'          ]=kbF;
+		    KeyConvert['G'          ]=kbG;
+		    KeyConvert['H'          ]=kbH;
+		    KeyConvert['J'          ]=kbJ;
+		    KeyConvert['K'          ]=kbK;
+		    KeyConvert['L'          ]=kbL;
+		    KeyConvert[';'          ]=kbSemicolon;
+		    KeyConvert['\''         ]=kbApostrophe;
+		    KeyConvert[VK_RETURN    ]=kbEnter;
+
+		    KeyConvert[VK_LSHIFT    ]=kbLeftShift;
+		    KeyConvert['Z'          ]=kbZ;
+		    KeyConvert['X'          ]=kbX;
+		    KeyConvert['C'          ]=kbC;
+		    KeyConvert['V'          ]=kbV;
+		    KeyConvert['B'          ]=kbB;
+		    KeyConvert['N'          ]=kbN;
+		    KeyConvert['M'          ]=kbM;
+		    KeyConvert[','          ]=kbComma;
+		    KeyConvert['.'          ]=kbPeriod;
+		    KeyConvert['/'          ]=kbSlash;
+		    KeyConvert[VK_RSHIFT    ]=kbRightShift;
+
+		    KeyConvert[VK_LCONTROL  ]=kbLeftCtrl;
+		    KeyConvert[VK_LWIN		]=kbLeftOS;
+		    KeyConvert[VK_LMENU		]=kbLeftAlt;
+		    KeyConvert[VK_SPACE     ]=kbSpace;
+		    KeyConvert[VK_RMENU		]=kbRightAlt;
+		    KeyConvert[VK_RWIN		]=kbRightOS;
+		    KeyConvert[VK_RCONTROL  ]=kbRightCtrl;
+
+		    KeyConvert[VK_PAUSE     ]=kbPause;
+	    //        KeyConvert[VK_CLEAR     ]=kbClear;
+
+		    KeyConvert[VK_NUMPAD0   ]=kbNum0;
+		    KeyConvert[VK_NUMPAD1   ]=kbNum1;
+		    KeyConvert[VK_NUMPAD2   ]=kbNum2;
+		    KeyConvert[VK_NUMPAD3   ]=kbNum3;
+		    KeyConvert[VK_NUMPAD4   ]=kbNum4;
+		    KeyConvert[VK_NUMPAD5   ]=kbNum5;
+		    KeyConvert[VK_NUMPAD6   ]=kbNum6;
+		    KeyConvert[VK_NUMPAD7   ]=kbNum7;
+		    KeyConvert[VK_NUMPAD8   ]=kbNum8;
+		    KeyConvert[VK_NUMPAD9   ]=kbNum9;
+
+		    KeyConvert[VK_DECIMAL   ]=kbNumDecimal;
+		    KeyConvert[VK_DIVIDE    ]=kbNumDivide;
+		    KeyConvert[VK_MULTIPLY  ]=kbNumMultiply;
+		    KeyConvert[VK_SUBTRACT  ]=kbNumSubtract;
+		    KeyConvert[VK_ADD       ]=kbNumAdd;
+
+		    KeyConvert[VK_UP        ]=kbUp;
+		    KeyConvert[VK_DOWN      ]=kbDown;
+		    KeyConvert[VK_LEFT      ]=kbLeft;
+		    KeyConvert[VK_RIGHT     ]=kbRight;
+
+		    KeyConvert[VK_INSERT    ]=kbInsert;
+		    KeyConvert[VK_DELETE    ]=kbDelete;
+		    KeyConvert[VK_HOME      ]=kbHome;
+		    KeyConvert[VK_END       ]=kbEnd;
+		    KeyConvert[VK_PRIOR     ]=kbPageUp;
+		    KeyConvert[VK_NEXT      ]=kbPageDown;
+
+		    KeyConvert[VK_NUMLOCK   ]=kbNumLock;
+		    KeyConvert[VK_SCROLL    ]=kbScrollLock;
+
+		    //KeyConvert[VK_SHIFT		]=kbLeftShift;
+		    //KeyConvert[VK_CONTROL	]=kbLeftCtrl;
+		    //KeyConvert[VK_MENU		]=kbLeftAlt;
+
+		    KeyConvert[VK_OEM_1		]=kbSemicolon;
+		    KeyConvert[VK_OEM_PLUS	]=kbEquals;
+		    KeyConvert[VK_OEM_COMMA	]=kbComma;
+		    KeyConvert[VK_OEM_MINUS	]=kbMinus;
+		    KeyConvert[VK_OEM_PERIOD]=kbPeriod;
+		    KeyConvert[VK_OEM_2		]=kbSlash;
+		    KeyConvert[VK_OEM_3		]=kbGrave;
+		    KeyConvert[VK_OEM_4		]=kbLeftBracket;
+		    KeyConvert[VK_OEM_5		]=kbBackSlash;
+		    KeyConvert[VK_OEM_6		]=kbRightBracket;
+		    KeyConvert[VK_OEM_7		]=kbApostrophe;
+	    }
+
+	    KeyboardButton ConvertOSKey(uint key)
+	    {
+		    if(key<kbBeginRange||key>=kbEndRange)return(kbBeginRange);
+
+		    if(key==VK_SHIFT)
+		    {
+			    if((GetAsyncKeyState(VK_LSHIFT)>>15)&1)
+				    return kbLeftShift;
+			    else
+				    return kbRightShift;
+		    }
+		    else
+		    if(key==VK_CONTROL)
+		    {
+			    if((GetAsyncKeyState(VK_LCONTROL)>>15)&1)
+				    return kbLeftCtrl;
+			    else
+				    return kbRightCtrl;
+		    }
+		    if(key==VK_MENU)
+		    {
+			    if((GetAsyncKeyState(VK_LMENU)>>15)&1)
+				    return kbLeftAlt;
+			    else
+				    return kbRightAlt;
+		    }
+
+    #ifdef _DEBUG
+		    if(KeyConvert[key]==0)
+		    {
+			    wchar_t name[64];
+
+			    ::GetKeyNameTextW(key,name,64);
+
+			    LOG_INFO(WideString(L"Unknow Key: " )+WideString(key)
+                        +WideString(L" ,name: "     )+WideString(name));
+		    }
+    #endif _DEBUG
+
+		    return KeyConvert[key];
+	    }
+
+        void WMProcDestroy(WinWindow *,uint32,uint32)
+        {
+            PostQuitMessage(0);
+        }
+
+        #define WMEF_MOUSE(button,action)	void WMProcMouse##button##action(WinWindow *win,uint32 wParam,uint32 lParam)	\
+	        {	\
+                const int x=LOWORD(lParam); \
+                const int y=HIWORD(lParam); \
+                \
+                win->OnMouseMove(x,y);  \
+		        win->OnMouse##action(x,y,mb##button|GetKeyFlags(wParam));	\
+	        }
+
+            WMEF_MOUSE(Left,Down);
+            WMEF_MOUSE(Left,Up);
+            WMEF_MOUSE(Left,DoubleClick);
+
+            WMEF_MOUSE(Mid,Down);
+            WMEF_MOUSE(Mid,Up);
+            WMEF_MOUSE(Mid,DoubleClick);
+
+            WMEF_MOUSE(Right,Down);
+            WMEF_MOUSE(Right,Up);
+            WMEF_MOUSE(Right,DoubleClick);
+
+            void WMProcMouseMove(WinWindow *win,uint32 wParam,uint32 lParam)
+	        {
+                win->OnMouseMove(LOWORD(lParam),HIWORD(lParam));
+	        }
+        #undef WMEF_MOUSE
+
+        #define WMEF2(name) void name(WinWindow *win,uint32 wParam,uint32 lParam)
+            WMEF2(WMProcMouseWheel)
+            {
+                const int x=LOWORD(lParam);
+                const int y=HIWORD(lParam);
+
+                win->OnMouseMove(x,y);
+                win->OnMouseWheel(x,y,(short)HIWORD(wParam));
+            }
+
+            WMEF2(WMProcSize)
+            {
+                win->OnResize(LOWORD(lParam),HIWORD(lParam));
+            }
+        #undef WMEF2
+
+        #define WMEF1(name) void name(WinWindow *win,uint32 wParam,uint32)
+            WMEF1(WMProcKeyDown)
+            {
+                win->OnKeyDown(ConvertOSKey(wParam));
+            }
+
+            WMEF1(WMProcKeyUp)
+            {
+                win->OnKeyUp(ConvertOSKey(wParam));
+            }
+
+            WMEF1(WMProcChar)
+            {
+                win->OnChar((wchar_t)wParam);
+            }
+
+            WMEF1(WMProcActive)
+            {
+                //if(JoyPlugIn)
+                //    JoyInterface.SetInputActive(wParam);
+
+                win->OnActive(wParam);
+            }
+        #undef WMEF1
+    }//namespace
+
+    void InitMessageProc()
+    {
+        memset(WMProc,0,sizeof(WMProc));
+        InitKeyConvert();
+
+        //if(joy)
+        //    LoadJoystick(win->hInstance,win->hWnd);
+
+    #define WM_MAP(wm,func)	WMProc[wm]=func;
+
+        WM_MAP(WM_CLOSE				,WMProcDestroy);
+        WM_MAP(WM_LBUTTONDOWN		,WMProcMouseLeftDown);
+        WM_MAP(WM_LBUTTONUP			,WMProcMouseLeftUp);
+        WM_MAP(WM_LBUTTONDBLCLK		,WMProcMouseLeftDoubleClick);
+        WM_MAP(WM_MBUTTONDOWN		,WMProcMouseMidDown);
+        WM_MAP(WM_MBUTTONUP			,WMProcMouseMidUp);
+        WM_MAP(WM_MBUTTONDBLCLK		,WMProcMouseMidDoubleClick);
+        WM_MAP(WM_RBUTTONDOWN		,WMProcMouseRightDown);
+        WM_MAP(WM_RBUTTONUP			,WMProcMouseRightUp);
+        WM_MAP(WM_RBUTTONDBLCLK		,WMProcMouseRightDoubleClick);
+        WM_MAP(WM_MOUSEWHEEL		,WMProcMouseWheel);
+        WM_MAP(WM_MOUSEMOVE			,WMProcMouseMove);
+        WM_MAP(WM_KEYDOWN			,WMProcKeyDown);
+        WM_MAP(WM_KEYUP				,WMProcKeyUp);
+        WM_MAP(WM_SYSKEYDOWN		,WMProcKeyDown);
+        WM_MAP(WM_SYSKEYUP			,WMProcKeyUp);
+        WM_MAP(WM_CHAR				,WMProcChar);
+        WM_MAP(WM_SYSCHAR			,WMProcChar);
+        WM_MAP(WM_ACTIVATE			,WMProcActive);
+        WM_MAP(WM_SIZE				,WMProcSize);
+
+    #undef WM_MAP
+    }
+
+    LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+    {
+        if(uMsg<2048)
+            if(WMProc[uMsg])
+            {
+                WinWindow *win=(WinWindow *)GetWindowLongPtrW(hWnd,GWLP_USERDATA);
+
+                if(win)
+                    WMProc[uMsg](win,wParam,lParam);
+            }
+
+        return (DefWindowProcW(hWnd, uMsg, wParam, lParam));
+    }
+
+    void InitNativeWindowSystem()
+    {
+        InitMessageProc();
+    }
+}//namespace hgl

src/Platform/Win/WinVulkan.cpp

@@ -0,0 +1,25 @@
+#include"WinWindow.h"
+#include<hgl/graph/vulkan/VK.h>
+#include<vulkan/vulkan_win32.h>
+
+VK_NAMESPACE_BEGIN
+VkSurfaceKHR CreateRenderDevice(VkInstance vk_inst,Window *win)
+{
+    WinWindow *ww=(WinWindow *)win;
+
+    VkWin32SurfaceCreateInfoKHR createInfo={};
+    createInfo.sType=VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
+    createInfo.pNext=nullptr;
+    createInfo.hinstance=ww->GetHInstance();
+    createInfo.hwnd=ww->GetHWnd();
+
+    VkSurfaceKHR surface;
+
+    VkResult res=vkCreateWin32SurfaceKHR(vk_inst,&createInfo,nullptr,&surface);
+
+    if(res!=VK_SUCCESS)
+        return(nullptr);
+
+    return(surface);
+}
+VK_NAMESPACE_END

src/Platform/Win/WinWindow.cpp

@@ -1,47 +1,15 @@
-#include<hgl/platform/Window.h>
+#include"WinWindow.h"
-#include<hgl/graph/vulkan/VK.h>
-#include<Windows.h>
-#include<vulkan/vulkan_win32.h>
 
 namespace hgl
 {
-	namespace graph
-	{
 	namespace
 	{
 		constexpr wchar_t WIN_CLASS_NAME[] = L"CMGameEngine/ULRE Window Class";
-
-			LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
-			{
-				Window *win=(Window *)GetWindowLongPtrW(hWnd, GWLP_USERDATA);
-
-				switch (uMsg)
-				{
-					case WM_CLOSE:
-						PostQuitMessage(0);
-						break;
-                    case WM_PAINT:
-                        return 0;
-					default:
-						break;
 	}
 
-				return (DefWindowProcW(hWnd, uMsg, wParam, lParam));
+    LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
-			}
-		}
 
-		/**
+	bool WinWindow::Registry()
-		 * Windows平台窗口实现
-		 */
-		class WinWindow :public Window
-		{
-			HINSTANCE hInstance = nullptr;
-			HWND win_hwnd=nullptr;
-			HDC win_dc = nullptr;
-
-		protected:
-
-			bool Registry()
 	{
 		WNDCLASSEXW win_class;
 
@@ -49,7 +17,7 @@ namespace hgl
 
 		win_class.cbSize = sizeof(WNDCLASSEXW);
 		win_class.style = CS_HREDRAW | CS_VREDRAW;
-				win_class.lpfnWndProc = WndProc;
+		win_class.lpfnWndProc = WindowProc;
 		win_class.cbClsExtra = 0;
 		win_class.cbWndExtra = 0;
 		win_class.hInstance = hInstance;
@@ -63,7 +31,7 @@ namespace hgl
 		return RegisterClassExW(&win_class);
 	}
 
-			bool Create()
+	bool WinWindow::Create()
 	{
 		constexpr DWORD win_style = WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_SYSMENU ;
 
@@ -118,16 +86,14 @@ namespace hgl
 		return(true);
 	}
 
-		public:
+    WinWindow::~WinWindow()
-
-			using Window::Window;
-			~WinWindow()
 	{
 		Close();
 	}
 
-			bool Create(uint w, uint h) override
+	bool WinWindow::Create(uint w, uint h)
 	{
+        full_screen=false;
 		width = w;
 		height = h;
 
@@ -136,15 +102,25 @@ namespace hgl
 		if (!Registry())
 			return(false);
 
-				return Create();
+		if(!Create())
+        {
+            is_close=true;
+            return(false);
+        }
+        else
+        {
+            is_close=false;
+            return(true);
+        }
 	}
 
-			bool Create(uint, uint, uint)override
+	bool WinWindow::Create(uint, uint, uint)
 	{
+        full_screen=true;
 		return(false);
 	}
 
-			void Close()override
+	void WinWindow::Close()
 	{
 		ReleaseDC(win_hwnd, win_dc);
 		DestroyWindow(win_hwnd);
@@ -152,9 +128,16 @@ namespace hgl
 
 		win_dc = nullptr;
 		win_hwnd = nullptr;
+        is_close = true;
 	}
 
-			void Show()override
+    void WinWindow::SetCaption(const OSString &caption)
+    {
+        win_name=caption;
+        SetWindowTextW(win_hwnd,caption.c_str());
+    }
+
+	void WinWindow::Show()
 	{
 		ShowWindow(win_hwnd, SW_SHOW);
 		SetForegroundWindow(win_hwnd);
@@ -163,41 +146,54 @@ namespace hgl
 		UpdateWindow(win_hwnd);
 	}
 
-			void Hide()override
+	void WinWindow::Hide()
 	{
 		ShowWindow(win_hwnd, SW_HIDE);
 		UpdateWindow(win_hwnd);
 	}
 
-            HINSTANCE GetHInstance(){return hInstance;}
+    void WinWindow::ToMinWindow()
-            HWND GetHWnd(){return win_hwnd;}
+    {
-		};//class WinWindow :public Window
+        if(!full_screen)
+            ShowWindow(win_hwnd,SW_MINIMIZE);
+    }
 
-		Window* CreateRenderWindow(const WideString& win_name)
+    void WinWindow::ToMaxWindow()
+    {
+        if(!full_screen)
+            ShowWindow(win_hwnd,SW_MAXIMIZE);
+    }
+
+    void WinWindow::SetSystemCursor(bool visible)
+    {
+        ::ShowCursor(visible);
+    }
+
+    bool WinWindow::MessageProc()
+    {
+        if(PeekMessage(&win_msg,NULL,0,0,PM_REMOVE))
+        {
+            TranslateMessage(&win_msg);
+            DispatchMessage(&win_msg);
+
+            if(win_msg.message==WM_QUIT)
+                OnClose();
+
+            return(true);
+        }
+        else
+        {
+            //if(JoyPlugIn)
+            //{
+            //    JoyInterface.Update();
+            //}
+
+            return(false);
+        }
+    }
+
+	Window *CreateRenderWindow(const WideString& win_name)
 	{
 		return(new WinWindow(win_name));
 	}
-	}//namespace graph
 }//namespace hgl
-
-VK_NAMESPACE_BEGIN
-VkSurfaceKHR CreateRenderDevice(VkInstance vk_inst,Window *win)
-{
-    WinWindow *ww=(WinWindow *)win;
-
-    VkWin32SurfaceCreateInfoKHR createInfo={};
-    createInfo.sType=VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
-    createInfo.pNext=nullptr;
-    createInfo.hinstance=ww->GetHInstance();
-    createInfo.hwnd=ww->GetHWnd();
-
-    VkSurfaceKHR surface;
-
-    VkResult res=vkCreateWin32SurfaceKHR(vk_inst,&createInfo,nullptr,&surface);
-
-    if(res!=VK_SUCCESS)
-        return(nullptr);
-
-    return(surface);
-}
-VK_NAMESPACE_END

src/Platform/Win/WinWindow.h

@@ -0,0 +1,51 @@
+#pragma once
+#include<hgl/platform/Window.h>
+#include<Windows.h>
+
+namespace hgl
+{
+    /**
+    * Windows平台窗口实现
+    */
+    class WinWindow:public Window
+    {
+        HINSTANCE hInstance = nullptr;
+        HWND win_hwnd = nullptr;
+        HDC win_dc = nullptr;
+
+        MSG win_msg;
+
+    protected:
+
+        bool Registry();
+        bool Create();
+
+        void OnClose() override{Close();}
+
+    public:
+
+        using Window::Window;
+        ~WinWindow();
+
+        HINSTANCE GetHInstance(){return hInstance;}
+        HWND GetHWnd(){return win_hwnd;}
+
+    public:
+
+        bool Create(uint w, uint h) override;
+        bool Create(uint, uint, uint) override;
+        void Close() override;
+
+        void SetCaption(const OSString &caption) override;
+
+        void Show() override;
+        void Hide() override;
+
+        void ToMinWindow() override;
+        void ToMaxWindow() override;
+
+        void SetSystemCursor(bool visible) override;
+
+        bool MessageProc() override;
+    };//class WinWindow :public Window
+}//namespace win