LOL地图放大工具

大宝

使用Windows放大API，目前仅在1366x768分辨率下进行了测试。 您必须将游戏设置为全屏无边框。
您可以使用`键（波浪号）来切换叠加层。


源代码：

1. 
   
2. // Ensure that the following definition is in effect before winuser.h is included.
   
3. #define _WIN32_WINNT 0x0501   
   
4. 
   
5. #include <windows.h>
   
6. #include <wincodec.h>
   
7. #include <magnification.h>
   
8. 
   
9. // Global variables and strings.
   
10. HINSTANCE           hInst;
    
11. float               MagFactor;
    
12. const TCHAR         WindowClassName[]= TEXT("MagnifierWindow");
    
13. const TCHAR         WindowTitle[]= TEXT("Screen Magnifier");
    
14. const UINT          timerInterval = 16; // close to the refresh rate @60hz
    
15. HWND                hwndMag;
    
16. HWND                hwndView;
    
17. HWND                hwndHost;
    
18. RECT                magWindowRect;
    
19. HHOOK               hHook;
    
20. bool                showMagnifier = true;
    
21. 
    
22. // Forward declarations.
    
23. LRESULT CALLBACK    LowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam);
    
24. ATOM                RegisterHostWindowClass(HINSTANCE hInstance);
    
25. BOOL                SetupMagnifier(HINSTANCE hinst);
    
26. LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
    
27. void CALLBACK       UpdateMagWindow(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime);
    
28. float               GetMagnificationFactor();
    
29. 
    
30. //
    
31. // FUNCTION: WinMain()
    
32. //
    
33. // PURPOSE: Entry point for the application.
    
34. //
    
35. int APIENTRY WinMain(HINSTANCE hInstance,
    
36.                      HINSTANCE /*hPrevInstance*/,
    
37.                      LPSTR     /*lpCmdLine*/,
    
38.                      int       nCmdShow)
    
39. {
    
40.     if (FALSE == MagInitialize())
    
41.     {
    
42.         return 0;
    
43.     }
    
44.     if (FALSE == SetupMagnifier(hInstance))
    
45.     {
    
46.         return 0;
    
47.     }
    
48. 
    
49.     ShowWindow(hwndHost, nCmdShow);
    
50.     UpdateWindow(hwndHost);
    
51.     //ShowCursor(false);
    
52.     // Create a timer to update the control.
    
53.     UINT_PTR timerId = SetTimer(hwndHost, 0, timerInterval, UpdateMagWindow);
    
54. 
    
55.     hHook = SetWindowsHookEx(WH_KEYBOARD_LL, LowLevelKeyboardProc, hInstance, 0);
    
56. 
    
57.     // Main message loop.
    
58.     MSG msg;
    
59.     while (GetMessage(&msg, NULL, 0, 0))
    
60.     {
    
61.         TranslateMessage(&msg);
    
62.         DispatchMessage(&msg);
    
63.     }
    
64. 
    
65.     // Shut down.
    
66.     KillTimer(NULL, timerId);
    
67.     MagUninitialize();
    
68.     return (int) msg.wParam;
    
69. }
    
70. 
    
71. 
    
72. LRESULT CALLBACK LowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam)
    
73. {
    
74.     PKBDLLHOOKSTRUCT press = (PKBDLLHOOKSTRUCT)lParam;
    
75.     if (wParam == WM_KEYDOWN && press->vkCode == VK_OEM_3) {
    
76.         showMagnifier = !showMagnifier;
    
77. 
    
78.         if (showMagnifier) {
    
79.             ShowWindow(hwndHost, SW_SHOW);
    
80.         }
    
81.         else {
    
82.             ShowWindow(hwndHost, SW_HIDE);
    
83.         }
    
84.     }
    
85.     return CallNextHookEx(hHook, nCode, wParam, lParam);
    
86. }
    
87. 
    
88. 
    
89. //
    
90. // FUNCTION: HostWndProc()
    
91. //
    
92. // PURPOSE: Window procedure for the window that hosts the magnifier control.
    
93. //
    
94. LRESULT CALLBACK HostWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
    
95. {
    
96.     switch (message)
    
97.     {
    
98.     case WM_KEYDOWN:
    
99.         if (wParam == VK_ESCAPE)
    
100.         {
     
101.             ShowCursor(true);
     
102.             PostQuitMessage(0);
     
103.             break;
     
104.         }
     
105. 
     
106.      case WM_SYSCOMMAND:
     
107.         return DefWindowProc(hWnd, message, wParam, lParam);
     
108.         break;
     
109. 
     
110.     case WM_DESTROY:
     
111.         ShowCursor(true);
     
112.         PostQuitMessage(0);
     
113.         break;
     
114. 
     
115.     case WM_SIZE:
     
116.         if ( hwndMag != NULL )
     
117.         {
     
118.             GetClientRect(hWnd, &magWindowRect);
     
119.             // Resize the control to fill the window.
     
120.             SetWindowPos(hwndMag, NULL,
     
121.                 magWindowRect.left, magWindowRect.top, magWindowRect.right, magWindowRect.bottom, 0);
     
122.         }
     
123.         break;
     
124. 
     
125.     default:
     
126.         return DefWindowProc(hWnd, message, wParam, lParam);
     
127.     }
     
128.     return 0;  
     
129. }
     
130. 
     
131. //
     
132. //  FUNCTION: RegisterHostWindowClass()
     
133. //
     
134. //  PURPOSE: Registers the window class for the window that contains the magnification control.
     
135. //
     
136. ATOM RegisterHostWindowClass(HINSTANCE hInstance)
     
137. {
     
138.     WNDCLASSEX wcex = {};
     
139. 
     
140.     wcex.cbSize = sizeof(WNDCLASSEX);
     
141.     wcex.style          = CS_HREDRAW | CS_VREDRAW;
     
142.     wcex.lpfnWndProc    = HostWndProc;
     
143.     wcex.hInstance      = hInstance;
     
144.     wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
     
145.     wcex.hbrBackground  = (HBRUSH)(1 + COLOR_BTNFACE);
     
146.     wcex.lpszClassName  = WindowClassName;
     
147. 
     
148.     return RegisterClassEx(&wcex);
     
149. }
     
150. 
     
151. //
     
152. // FUNCTION: SetupMagnifier
     
153. //
     
154. // PURPOSE: Creates the windows and initializes magnification.
     
155. //
     
156. BOOL SetupMagnifier(HINSTANCE hinst)
     
157. {
     
158.     int sx = GetSystemMetrics(SM_CXSCREEN);
     
159.     int sy = GetSystemMetrics(SM_CYSCREEN);
     
160. 
     
161.     // Create the host window.
     
162.     RegisterHostWindowClass(hinst);
     
163.     hwndHost = CreateWindowEx(WS_EX_TOPMOST | WS_EX_LAYERED | WS_EX_TRANSPARENT,
     
164.         WindowClassName, WindowTitle,
     
165.         WS_POPUP | WS_CLIPCHILDREN,
     
166.         sx / 2 + 100, sy / 2 - 180, 360, 360, NULL, NULL, hInst, NULL);
     
167.     if (!hwndHost)
     
168.     {
     
169.         return FALSE;
     
170.     }
     
171.     SetLayeredWindowAttributes(hwndHost, 0, (255 * 35) / 100, LWA_ALPHA);
     
172. 
     
173.     // Create a magnifier control that fills the client area.
     
174.     GetClientRect(hwndHost, &magWindowRect);
     
175.     hwndMag = CreateWindow(WC_MAGNIFIER, TEXT("MagnifierWindow"),
     
176.         WS_CHILD | MS_SHOWMAGNIFIEDCURSOR | WS_VISIBLE ,
     
177.         magWindowRect.left, magWindowRect.top, magWindowRect.right, magWindowRect.bottom, hwndHost, NULL, hInst, NULL );
     
178.     if (!hwndMag)
     
179.     {
     
180.         return FALSE;
     
181.     }
     
182. 
     
183.     MagFactor = GetMagnificationFactor();
     
184.     // Set the magnification factor.
     
185.     MAGTRANSFORM matrix;
     
186.     memset(&matrix, 0, sizeof(matrix));
     
187.     matrix.v[0][0] = MagFactor;
     
188.     matrix.v[1][1] = MagFactor;
     
189.     matrix.v[2][2] = 1.0f;
     
190. 
     
191.     BOOL ret = MagSetWindowTransform(hwndMag, &matrix);
     
192.    
     
193.     return ret;  
     
194. }
     
195. 
     
196. 
     
197. //
     
198. // FUNCTION: UpdateMagWindow()
     
199. //
     
200. // PURPOSE: Sets the source rectangle and updates the window. Called by a timer.
     
201. //
     
202. void CALLBACK UpdateMagWindow(HWND /*hwnd*/, UINT /*uMsg*/, UINT_PTR /*idEvent*/, DWORD /*dwTime*/)
     
203. {
     
204.     if (showMagnifier) {
     
205.         RECT sourceRect;
     
206.         sourceRect.left = 1181;
     
207.         sourceRect.top = 578;
     
208.         sourceRect.right = 1181 + 181;
     
209.         sourceRect.bottom = 578 + 181;
     
210. 
     
211.         // Set the source rectangle for the magnifier control.
     
212.         MagSetWindowSource(hwndMag, sourceRect);
     
213. 
     
214.         // Reclaim topmost status, to prevent unmagnified menus from remaining in view.
     
215.         SetWindowPos(hwndHost, HWND_TOPMOST, 0, 0, 0, 0,
     
216.             SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
     
217. 
     
218.         // Force redraw.
     
219.         InvalidateRect(hwndMag, NULL, TRUE);
     
220.     }
     
221. }
     
222. 
     
223. 
     
224. float GetMagnificationFactor(){
     
225.     // For simplicity, the sample uses a constant magnification factor.
     
226.     return 2.0f;
     
227. }
     

复制代码