3476 lines
103 KiB
Plaintext
3476 lines
103 KiB
Plaintext
; Listing generated by Microsoft (R) Optimizing Compiler Version 19.37.32824.0
|
|
|
|
include listing.inc
|
|
|
|
INCLUDELIB OLDNAMES
|
|
|
|
PUBLIC ??_C@_1BA@PICGEGJB@?$AAD?$AAI?$AAS?$AAP?$AAL?$AAA?$AAY@ ; `string'
|
|
PUBLIC ??_C@_0O@NIPGCINC@Unknown?5error@ ; `string'
|
|
PUBLIC ??_C@_0BJ@EJOHFDHH@The?5system?5uses?5DualView@ ; `string'
|
|
PUBLIC ??_C@_0O@IHOLGAKK@Invalid?5flags@ ; `string'
|
|
PUBLIC ??_C@_0BM@KPJJBADD@Graphics?5mode?5not?5supported@ ; `string'
|
|
PUBLIC ??_C@_0BC@DBAKKFEN@Invalid?5parameter@ ; `string'
|
|
PUBLIC ??_C@_0BF@JHMFGJBN@Graphics?5mode?5failed@ ; `string'
|
|
PUBLIC ??_C@_0BM@IGBABBBF@Failed?5to?5write?5to?5registry@ ; `string'
|
|
PUBLIC ??_C@_0BK@OEGBAIFC@Computer?5restart?5required@ ; `string'
|
|
PUBLIC ??_C@_0CE@IKOICJPN@Win32?3?5Failed?5to?5set?5video?5mode@ ; `string'
|
|
PUBLIC ??_C@_0CD@IGHBCNOG@Win32?3?5Failed?5to?5query?5monitor?5@ ; `string'
|
|
PUBLIC ??_C@_0CD@EGEEPFHF@Win32?3?5Gamma?5ramp?5size?5must?5be?5@ ; `string'
|
|
EXTRN __imp_ChangeDisplaySettingsExW:PROC
|
|
EXTRN __imp_SetDeviceGammaRamp:PROC
|
|
EXTRN __imp_EnumDisplayMonitors:PROC
|
|
EXTRN __imp_CreateDCW:PROC
|
|
EXTRN __imp_GetMonitorInfoW:PROC
|
|
EXTRN __imp_EnumDisplaySettingsExW:PROC
|
|
EXTRN __imp_GetDeviceGammaRamp:PROC
|
|
EXTRN __imp_GetDeviceCaps:PROC
|
|
EXTRN __imp_DeleteDC:PROC
|
|
EXTRN __imp_EnumDisplayDevicesW:PROC
|
|
EXTRN __imp_EnumDisplaySettingsW:PROC
|
|
EXTRN __imp_ReleaseDC:PROC
|
|
; COMDAT ??_C@_0CD@EGEEPFHF@Win32?3?5Gamma?5ramp?5size?5must?5be?5@
|
|
CONST SEGMENT
|
|
??_C@_0CD@EGEEPFHF@Win32?3?5Gamma?5ramp?5size?5must?5be?5@ DB 'Win32: Gam'
|
|
DB 'ma ramp size must be 256', 00H ; `string'
|
|
CONST ENDS
|
|
; COMDAT ??_C@_0CD@IGHBCNOG@Win32?3?5Failed?5to?5query?5monitor?5@
|
|
CONST SEGMENT
|
|
??_C@_0CD@IGHBCNOG@Win32?3?5Failed?5to?5query?5monitor?5@ DB 'Win32: Fail'
|
|
DB 'ed to query monitor DPI', 00H ; `string'
|
|
CONST ENDS
|
|
; COMDAT ??_C@_0CE@IKOICJPN@Win32?3?5Failed?5to?5set?5video?5mode@
|
|
CONST SEGMENT
|
|
??_C@_0CE@IKOICJPN@Win32?3?5Failed?5to?5set?5video?5mode@ DB 'Win32: Fail'
|
|
DB 'ed to set video mode: %s', 00H ; `string'
|
|
CONST ENDS
|
|
; COMDAT ??_C@_0BK@OEGBAIFC@Computer?5restart?5required@
|
|
CONST SEGMENT
|
|
??_C@_0BK@OEGBAIFC@Computer?5restart?5required@ DB 'Computer restart requ'
|
|
DB 'ired', 00H ; `string'
|
|
CONST ENDS
|
|
; COMDAT ??_C@_0BM@IGBABBBF@Failed?5to?5write?5to?5registry@
|
|
CONST SEGMENT
|
|
??_C@_0BM@IGBABBBF@Failed?5to?5write?5to?5registry@ DB 'Failed to write t'
|
|
DB 'o registry', 00H ; `string'
|
|
CONST ENDS
|
|
; COMDAT ??_C@_0BF@JHMFGJBN@Graphics?5mode?5failed@
|
|
CONST SEGMENT
|
|
??_C@_0BF@JHMFGJBN@Graphics?5mode?5failed@ DB 'Graphics mode failed', 00H ; `string'
|
|
CONST ENDS
|
|
; COMDAT ??_C@_0BC@DBAKKFEN@Invalid?5parameter@
|
|
CONST SEGMENT
|
|
??_C@_0BC@DBAKKFEN@Invalid?5parameter@ DB 'Invalid parameter', 00H ; `string'
|
|
CONST ENDS
|
|
; COMDAT ??_C@_0BM@KPJJBADD@Graphics?5mode?5not?5supported@
|
|
CONST SEGMENT
|
|
??_C@_0BM@KPJJBADD@Graphics?5mode?5not?5supported@ DB 'Graphics mode not '
|
|
DB 'supported', 00H ; `string'
|
|
CONST ENDS
|
|
; COMDAT ??_C@_0O@IHOLGAKK@Invalid?5flags@
|
|
CONST SEGMENT
|
|
??_C@_0O@IHOLGAKK@Invalid?5flags@ DB 'Invalid flags', 00H ; `string'
|
|
CONST ENDS
|
|
; COMDAT ??_C@_0BJ@EJOHFDHH@The?5system?5uses?5DualView@
|
|
CONST SEGMENT
|
|
??_C@_0BJ@EJOHFDHH@The?5system?5uses?5DualView@ DB 'The system uses DualV'
|
|
DB 'iew', 00H ; `string'
|
|
CONST ENDS
|
|
; COMDAT ??_C@_0O@NIPGCINC@Unknown?5error@
|
|
CONST SEGMENT
|
|
??_C@_0O@NIPGCINC@Unknown?5error@ DB 'Unknown error', 00H ; `string'
|
|
CONST ENDS
|
|
; COMDAT ??_C@_1BA@PICGEGJB@?$AAD?$AAI?$AAS?$AAP?$AAL?$AAA?$AAY@
|
|
CONST SEGMENT
|
|
??_C@_1BA@PICGEGJB@?$AAD?$AAI?$AAS?$AAP?$AAL?$AAA?$AAY@ DB 'D', 00H, 'I', 00H
|
|
DB 'S', 00H, 'P', 00H, 'L', 00H, 'A', 00H, 'Y', 00H, 00H, 00H ; `string'
|
|
PUBLIC glfwGetWin32Monitor
|
|
PUBLIC glfwGetWin32Adapter
|
|
PUBLIC _glfwGetHMONITORContentScaleWin32
|
|
PUBLIC _glfwRestoreVideoModeWin32
|
|
PUBLIC _glfwSetVideoModeWin32
|
|
PUBLIC _glfwFreeMonitorWin32
|
|
PUBLIC _glfwGetMonitorContentScaleWin32
|
|
PUBLIC _glfwSetGammaRampWin32
|
|
PUBLIC _glfwPollMonitorsWin32
|
|
PUBLIC _glfwGetVideoModesWin32
|
|
PUBLIC _glfwGetMonitorPosWin32
|
|
PUBLIC _glfwGetGammaRampWin32
|
|
PUBLIC _glfwGetMonitorWorkareaWin32
|
|
PUBLIC _glfwGetVideoModeWin32
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$glfwGetWin32Monitor DD imagerel $LN5
|
|
DD imagerel $LN5+44
|
|
DD imagerel $unwind$glfwGetWin32Monitor
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$glfwGetWin32Adapter DD imagerel $LN5
|
|
DD imagerel $LN5+44
|
|
DD imagerel $unwind$glfwGetWin32Adapter
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$_glfwGetHMONITORContentScaleWin32 DD imagerel $LN17
|
|
DD imagerel $LN17+244
|
|
DD imagerel $unwind$_glfwGetHMONITORContentScaleWin32
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$_glfwRestoreVideoModeWin32 DD imagerel $LN6
|
|
DD imagerel $LN6+67
|
|
DD imagerel $unwind$_glfwRestoreVideoModeWin32
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$_glfwSetVideoModeWin32 DD imagerel $LN42
|
|
DD imagerel $LN42+163
|
|
DD imagerel $unwind$_glfwSetVideoModeWin32
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$0$_glfwSetVideoModeWin32 DD imagerel $LN42+163
|
|
DD imagerel $LN42+323
|
|
DD imagerel $chain$0$_glfwSetVideoModeWin32
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$1$_glfwSetVideoModeWin32 DD imagerel $LN42+323
|
|
DD imagerel $LN42+484
|
|
DD imagerel $chain$1$_glfwSetVideoModeWin32
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$createMonitor DD imagerel createMonitor
|
|
DD imagerel createMonitor+67
|
|
DD imagerel $unwind$createMonitor
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$0$createMonitor DD imagerel createMonitor+67
|
|
DD imagerel createMonitor+80
|
|
DD imagerel $chain$0$createMonitor
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$1$createMonitor DD imagerel createMonitor+80
|
|
DD imagerel createMonitor+96
|
|
DD imagerel $chain$1$createMonitor
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$3$createMonitor DD imagerel createMonitor+96
|
|
DD imagerel createMonitor+237
|
|
DD imagerel $chain$3$createMonitor
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$4$createMonitor DD imagerel createMonitor+237
|
|
DD imagerel createMonitor+344
|
|
DD imagerel $chain$4$createMonitor
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$5$createMonitor DD imagerel createMonitor+344
|
|
DD imagerel createMonitor+415
|
|
DD imagerel $chain$5$createMonitor
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$6$createMonitor DD imagerel createMonitor+415
|
|
DD imagerel createMonitor+533
|
|
DD imagerel $chain$6$createMonitor
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$7$createMonitor DD imagerel createMonitor+533
|
|
DD imagerel createMonitor+708
|
|
DD imagerel $chain$7$createMonitor
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$8$createMonitor DD imagerel createMonitor+708
|
|
DD imagerel createMonitor+736
|
|
DD imagerel $chain$8$createMonitor
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$monitorCallback DD imagerel monitorCallback
|
|
DD imagerel monitorCallback+204
|
|
DD imagerel $unwind$monitorCallback
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$_glfwSetGammaRampWin32 DD imagerel $LN12
|
|
DD imagerel $LN12+472
|
|
DD imagerel $unwind$_glfwSetGammaRampWin32
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$_glfwPollMonitorsWin32 DD imagerel $LN116
|
|
DD imagerel $LN116+891
|
|
DD imagerel $unwind$_glfwPollMonitorsWin32
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$_glfwGetVideoModesWin32 DD imagerel $LN91
|
|
DD imagerel $LN91+33
|
|
DD imagerel $unwind$_glfwGetVideoModesWin32
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$2$_glfwGetVideoModesWin32 DD imagerel $LN91+33
|
|
DD imagerel $LN91+127
|
|
DD imagerel $chain$2$_glfwGetVideoModesWin32
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$3$_glfwGetVideoModesWin32 DD imagerel $LN91+127
|
|
DD imagerel $LN91+743
|
|
DD imagerel $chain$3$_glfwGetVideoModesWin32
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$4$_glfwGetVideoModesWin32 DD imagerel $LN91+743
|
|
DD imagerel $LN91+773
|
|
DD imagerel $chain$4$_glfwGetVideoModesWin32
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$5$_glfwGetVideoModesWin32 DD imagerel $LN91+773
|
|
DD imagerel $LN91+882
|
|
DD imagerel $chain$5$_glfwGetVideoModesWin32
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$_glfwGetMonitorPosWin32 DD imagerel $LN8
|
|
DD imagerel $LN8+153
|
|
DD imagerel $unwind$_glfwGetMonitorPosWin32
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$_glfwGetGammaRampWin32 DD imagerel $LN10
|
|
DD imagerel $LN10+427
|
|
DD imagerel $unwind$_glfwGetGammaRampWin32
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$_glfwGetMonitorWorkareaWin32 DD imagerel $LN12
|
|
DD imagerel $LN12+159
|
|
DD imagerel $unwind$_glfwGetMonitorWorkareaWin32
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$_glfwGetVideoModeWin32 DD imagerel $LN13
|
|
DD imagerel $LN13+237
|
|
DD imagerel $unwind$_glfwGetVideoModeWin32
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$_glfwGetVideoModeWin32 DD 072419H
|
|
DD 0276412H
|
|
DD 0263412H
|
|
DD 0220112H
|
|
DD 0700bH
|
|
DD imagerel __GSHandlerCheck
|
|
DD 0100H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$_glfwGetMonitorWorkareaWin32 DD 051919H
|
|
DD 0e006a20aH
|
|
DD 060037004H
|
|
DD 03002H
|
|
DD imagerel __GSHandlerCheck
|
|
DD 048H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$_glfwGetGammaRampWin32 DD 051f19H
|
|
DD 0ca340dH
|
|
DD 0c6010dH
|
|
DD 07006H
|
|
DD imagerel __GSHandlerCheck
|
|
DD 0620H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$_glfwGetMonitorPosWin32 DD 072119H
|
|
DD 029340fH
|
|
DD 022010fH
|
|
DD 060077008H
|
|
DD 05006H
|
|
DD imagerel __GSHandlerCheck
|
|
DD 0100H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$5$_glfwGetVideoModesWin32 DD 021H
|
|
DD imagerel $LN91
|
|
DD imagerel $LN91+33
|
|
DD imagerel $unwind$_glfwGetVideoModesWin32
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$4$_glfwGetVideoModesWin32 DD 021H
|
|
DD imagerel $LN91+33
|
|
DD imagerel $LN91+127
|
|
DD imagerel $chain$2$_glfwGetVideoModesWin32
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$3$_glfwGetVideoModesWin32 DD 020821H
|
|
DD 0325408H
|
|
DD imagerel $LN91+33
|
|
DD imagerel $LN91+127
|
|
DD imagerel $chain$2$_glfwGetVideoModesWin32
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$2$_glfwGetVideoModesWin32 DD 062021H
|
|
DD 028f420H
|
|
DD 029d40bH
|
|
DD 02ac404H
|
|
DD imagerel $LN91
|
|
DD imagerel $LN91+33
|
|
DD imagerel $unwind$_glfwGetVideoModesWin32
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$_glfwGetVideoModesWin32 DD 062119H
|
|
DD 02b010fH
|
|
DD 07006e008H
|
|
DD 030046005H
|
|
DD imagerel __GSHandlerCheck
|
|
DD 0130H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$_glfwPollMonitorsWin32 DD 0dc019H
|
|
DD 0e1f4c0H
|
|
DD 0e054b1H
|
|
DD 0e23414H
|
|
DD 0da0114H
|
|
DD 0d00be00dH
|
|
DD 07007c009H
|
|
DD 06006H
|
|
DD imagerel __GSHandlerCheck
|
|
DD 06c0H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$_glfwSetGammaRampWin32 DD 046619H
|
|
DD 0c63466H
|
|
DD 0c70107H
|
|
DD imagerel __GSHandlerCheck
|
|
DD 0620H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$monitorCallback DD 051f19H
|
|
DD 017340dH
|
|
DD 014010dH
|
|
DD 07006H
|
|
DD imagerel __GSHandlerCheck
|
|
DD 090H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$8$createMonitor DD 021H
|
|
DD imagerel createMonitor
|
|
DD imagerel createMonitor+67
|
|
DD imagerel $unwind$createMonitor
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$7$createMonitor DD 021H
|
|
DD imagerel createMonitor+67
|
|
DD imagerel createMonitor+80
|
|
DD imagerel $chain$0$createMonitor
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$6$createMonitor DD 021H
|
|
DD imagerel createMonitor+80
|
|
DD imagerel createMonitor+96
|
|
DD imagerel $chain$1$createMonitor
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$5$createMonitor DD 021H
|
|
DD imagerel createMonitor+96
|
|
DD imagerel createMonitor+237
|
|
DD imagerel $chain$3$createMonitor
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$4$createMonitor DD 020821H
|
|
DD 0146808H
|
|
DD imagerel createMonitor+96
|
|
DD imagerel createMonitor+237
|
|
DD imagerel $chain$3$createMonitor
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$3$createMonitor DD 041221H
|
|
DD 02af412H
|
|
DD 02bc408H
|
|
DD imagerel createMonitor+80
|
|
DD imagerel createMonitor+96
|
|
DD imagerel $chain$1$createMonitor
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$1$createMonitor DD 020821H
|
|
DD 0337408H
|
|
DD imagerel createMonitor+67
|
|
DD imagerel createMonitor+80
|
|
DD imagerel $chain$0$createMonitor
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$0$createMonitor DD 020821H
|
|
DD 0323408H
|
|
DD imagerel createMonitor
|
|
DD imagerel createMonitor+67
|
|
DD imagerel $unwind$createMonitor
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$createMonitor DD 051e19H
|
|
DD 02c010cH
|
|
DD 06003e005H
|
|
DD 05002H
|
|
DD imagerel __GSHandlerCheck
|
|
DD 0130H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$1$_glfwSetVideoModeWin32 DD 021H
|
|
DD imagerel $LN42
|
|
DD imagerel $LN42+163
|
|
DD imagerel $unwind$_glfwSetVideoModeWin32
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$0$_glfwSetVideoModeWin32 DD 020821H
|
|
DD 02e5408H
|
|
DD imagerel $LN42
|
|
DD imagerel $LN42+163
|
|
DD imagerel $unwind$_glfwSetVideoModeWin32
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$_glfwSetVideoModeWin32 DD 051d19H
|
|
DD 028010bH
|
|
DD 060037004H
|
|
DD 03002H
|
|
DD imagerel __GSHandlerCheck
|
|
DD 0130H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$_glfwRestoreVideoModeWin32 DD 020601H
|
|
DD 030025206H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$_glfwGetHMONITORContentScaleWin32 DD 041719H
|
|
DD 070045208H
|
|
DD 030026003H
|
|
DD imagerel __GSHandlerCheck
|
|
DD 028H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$glfwGetWin32Adapter DD 010401H
|
|
DD 04204H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$glfwGetWin32Monitor DD 010401H
|
|
DD 04204H
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
; COMDAT _glfwGetVideoModeWin32
|
|
_TEXT SEGMENT
|
|
dm$ = 32
|
|
__$ArrayPad$ = 256
|
|
monitor$ = 288
|
|
mode$ = 296
|
|
_glfwGetVideoModeWin32 PROC ; COMDAT
|
|
|
|
; 476 : {
|
|
|
|
$LN13:
|
|
00000 48 89 5c 24 18 mov QWORD PTR [rsp+24], rbx
|
|
00005 48 89 74 24 20 mov QWORD PTR [rsp+32], rsi
|
|
0000a 57 push rdi
|
|
0000b 48 81 ec 10 01
|
|
00 00 sub rsp, 272 ; 00000110H
|
|
00012 48 8b 05 00 00
|
|
00 00 mov rax, QWORD PTR __security_cookie
|
|
00019 48 33 c4 xor rax, rsp
|
|
0001c 48 89 84 24 00
|
|
01 00 00 mov QWORD PTR __$ArrayPad$[rsp], rax
|
|
00024 48 8b fa mov rdi, rdx
|
|
00027 48 8b d9 mov rbx, rcx
|
|
|
|
; 477 : DEVMODEW dm;
|
|
; 478 : ZeroMemory(&dm, sizeof(dm));
|
|
|
|
0002a be dc 00 00 00 mov esi, 220 ; 000000dcH
|
|
0002f 48 8d 4c 24 20 lea rcx, QWORD PTR dm$[rsp]
|
|
00034 44 8b c6 mov r8d, esi
|
|
00037 33 d2 xor edx, edx
|
|
00039 e8 00 00 00 00 call memset
|
|
|
|
; 479 : dm.dmSize = sizeof(dm);
|
|
; 480 :
|
|
; 481 : EnumDisplaySettingsW(monitor->win32.adapterName, ENUM_CURRENT_SETTINGS, &dm);
|
|
|
|
0003e 48 8d 8b 08 01
|
|
00 00 lea rcx, QWORD PTR [rbx+264]
|
|
00045 66 89 74 24 64 mov WORD PTR dm$[rsp+68], si
|
|
0004a 4c 8d 44 24 20 lea r8, QWORD PTR dm$[rsp]
|
|
0004f ba ff ff ff ff mov edx, -1 ; ffffffffH
|
|
00054 ff 15 00 00 00
|
|
00 call QWORD PTR __imp_EnumDisplaySettingsW
|
|
|
|
; 482 :
|
|
; 483 : mode->width = dm.dmPelsWidth;
|
|
|
|
0005a 8b 84 24 cc 00
|
|
00 00 mov eax, DWORD PTR dm$[rsp+172]
|
|
|
|
; 484 : mode->height = dm.dmPelsHeight;
|
|
; 485 : mode->refreshRate = dm.dmDisplayFrequency;
|
|
; 486 : _glfwSplitBPP(dm.dmBitsPerPel,
|
|
|
|
00061 8b 8c 24 c8 00
|
|
00 00 mov ecx, DWORD PTR dm$[rsp+168]
|
|
00068 89 07 mov DWORD PTR [rdi], eax
|
|
0006a 8b 84 24 d0 00
|
|
00 00 mov eax, DWORD PTR dm$[rsp+176]
|
|
00071 89 47 04 mov DWORD PTR [rdi+4], eax
|
|
00074 8b 84 24 d8 00
|
|
00 00 mov eax, DWORD PTR dm$[rsp+184]
|
|
0007b 89 47 14 mov DWORD PTR [rdi+20], eax
|
|
0007e 83 f9 20 cmp ecx, 32 ; 00000020H
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
|
|
; 287 : if (bpp == 32)
|
|
|
|
00081 75 17 jne SHORT $LN4@glfwGetVid
|
|
|
|
; 288 : bpp = 24;
|
|
|
|
00083 c7 47 10 08 00
|
|
00 00 mov DWORD PTR [rdi+16], 8
|
|
0008a c7 47 0c 08 00
|
|
00 00 mov DWORD PTR [rdi+12], 8
|
|
00091 c7 47 08 08 00
|
|
00 00 mov DWORD PTR [rdi+8], 8
|
|
|
|
; 295 : *green = *green + 1;
|
|
|
|
00098 eb 2e jmp SHORT $LN6@glfwGetVid
|
|
$LN4@glfwGetVid:
|
|
|
|
; 289 :
|
|
; 290 : // Convert "bits per pixel" to red, green & blue sizes
|
|
; 291 :
|
|
; 292 : *red = *green = *blue = bpp / 3;
|
|
|
|
0009a b8 56 55 55 55 mov eax, 1431655766 ; 55555556H
|
|
0009f f7 e9 imul ecx
|
|
000a1 8b c2 mov eax, edx
|
|
000a3 c1 e8 1f shr eax, 31
|
|
000a6 03 d0 add edx, eax
|
|
000a8 89 57 10 mov DWORD PTR [rdi+16], edx
|
|
000ab 89 57 0c mov DWORD PTR [rdi+12], edx
|
|
000ae 89 57 08 mov DWORD PTR [rdi+8], edx
|
|
|
|
; 293 : delta = bpp - (*red * 3);
|
|
|
|
000b1 8d 04 52 lea eax, DWORD PTR [rdx+rdx*2]
|
|
000b4 2b c8 sub ecx, eax
|
|
|
|
; 294 : if (delta >= 1)
|
|
|
|
000b6 83 f9 01 cmp ecx, 1
|
|
000b9 7c 0d jl SHORT $LN6@glfwGetVid
|
|
|
|
; 295 : *green = *green + 1;
|
|
|
|
000bb ff c2 inc edx
|
|
000bd 89 57 0c mov DWORD PTR [rdi+12], edx
|
|
|
|
; 296 :
|
|
; 297 : if (delta == 2)
|
|
|
|
000c0 83 f9 02 cmp ecx, 2
|
|
000c3 75 03 jne SHORT $LN6@glfwGetVid
|
|
|
|
; 298 : *red = *red + 1;
|
|
|
|
000c5 89 57 08 mov DWORD PTR [rdi+8], edx
|
|
$LN6@glfwGetVid:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
|
|
; 490 : }
|
|
|
|
000c8 48 8b 8c 24 00
|
|
01 00 00 mov rcx, QWORD PTR __$ArrayPad$[rsp]
|
|
000d0 48 33 cc xor rcx, rsp
|
|
000d3 e8 00 00 00 00 call __security_check_cookie
|
|
000d8 4c 8d 9c 24 10
|
|
01 00 00 lea r11, QWORD PTR [rsp+272]
|
|
000e0 49 8b 5b 20 mov rbx, QWORD PTR [r11+32]
|
|
000e4 49 8b 73 28 mov rsi, QWORD PTR [r11+40]
|
|
000e8 49 8b e3 mov rsp, r11
|
|
000eb 5f pop rdi
|
|
000ec c3 ret 0
|
|
_glfwGetVideoModeWin32 ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
; COMDAT _glfwGetMonitorWorkareaWin32
|
|
_TEXT SEGMENT
|
|
mi$ = 32
|
|
__$ArrayPad$ = 72
|
|
monitor$ = 128
|
|
xpos$ = 136
|
|
ypos$ = 144
|
|
width$ = 152
|
|
height$ = 160
|
|
_glfwGetMonitorWorkareaWin32 PROC ; COMDAT
|
|
|
|
; 384 : {
|
|
|
|
$LN12:
|
|
00000 40 53 push rbx
|
|
00002 56 push rsi
|
|
00003 57 push rdi
|
|
00004 41 56 push r14
|
|
00006 48 83 ec 58 sub rsp, 88 ; 00000058H
|
|
0000a 48 8b 05 00 00
|
|
00 00 mov rax, QWORD PTR __security_cookie
|
|
00011 48 33 c4 xor rax, rsp
|
|
00014 48 89 44 24 48 mov QWORD PTR __$ArrayPad$[rsp], rax
|
|
|
|
; 385 : MONITORINFO mi = { sizeof(mi) };
|
|
; 386 : GetMonitorInfoW(monitor->win32.handle, &mi);
|
|
|
|
00019 48 8b 89 00 01
|
|
00 00 mov rcx, QWORD PTR [rcx+256]
|
|
00020 0f 57 c0 xorps xmm0, xmm0
|
|
00023 48 8b 9c 24 a0
|
|
00 00 00 mov rbx, QWORD PTR height$[rsp]
|
|
0002b 4c 8b f2 mov r14, rdx
|
|
0002e 33 c0 xor eax, eax
|
|
00030 c7 44 24 20 28
|
|
00 00 00 mov DWORD PTR mi$[rsp], 40 ; 00000028H
|
|
00038 48 8d 54 24 20 lea rdx, QWORD PTR mi$[rsp]
|
|
0003d 89 44 24 44 mov DWORD PTR mi$[rsp+36], eax
|
|
00041 0f 11 44 24 24 movups XMMWORD PTR mi$[rsp+4], xmm0
|
|
00046 49 8b f1 mov rsi, r9
|
|
00049 49 8b f8 mov rdi, r8
|
|
0004c 0f 11 44 24 34 movups XMMWORD PTR mi$[rsp+20], xmm0
|
|
00051 ff 15 00 00 00
|
|
00 call QWORD PTR __imp_GetMonitorInfoW
|
|
|
|
; 387 :
|
|
; 388 : if (xpos)
|
|
|
|
00057 8b 54 24 34 mov edx, DWORD PTR mi$[rsp+20]
|
|
0005b 4d 85 f6 test r14, r14
|
|
0005e 74 03 je SHORT $LN2@glfwGetMon
|
|
|
|
; 389 : *xpos = mi.rcWork.left;
|
|
|
|
00060 41 89 16 mov DWORD PTR [r14], edx
|
|
$LN2@glfwGetMon:
|
|
|
|
; 390 : if (ypos)
|
|
|
|
00063 8b 4c 24 38 mov ecx, DWORD PTR mi$[rsp+24]
|
|
00067 48 85 ff test rdi, rdi
|
|
0006a 74 02 je SHORT $LN3@glfwGetMon
|
|
|
|
; 391 : *ypos = mi.rcWork.top;
|
|
|
|
0006c 89 0f mov DWORD PTR [rdi], ecx
|
|
$LN3@glfwGetMon:
|
|
|
|
; 392 : if (width)
|
|
|
|
0006e 48 85 f6 test rsi, rsi
|
|
00071 74 08 je SHORT $LN4@glfwGetMon
|
|
|
|
; 393 : *width = mi.rcWork.right - mi.rcWork.left;
|
|
|
|
00073 8b 44 24 3c mov eax, DWORD PTR mi$[rsp+28]
|
|
00077 2b c2 sub eax, edx
|
|
00079 89 06 mov DWORD PTR [rsi], eax
|
|
$LN4@glfwGetMon:
|
|
|
|
; 394 : if (height)
|
|
|
|
0007b 48 85 db test rbx, rbx
|
|
0007e 74 08 je SHORT $LN5@glfwGetMon
|
|
|
|
; 395 : *height = mi.rcWork.bottom - mi.rcWork.top;
|
|
|
|
00080 8b 44 24 40 mov eax, DWORD PTR mi$[rsp+32]
|
|
00084 2b c1 sub eax, ecx
|
|
00086 89 03 mov DWORD PTR [rbx], eax
|
|
$LN5@glfwGetMon:
|
|
|
|
; 396 : }
|
|
|
|
00088 48 8b 4c 24 48 mov rcx, QWORD PTR __$ArrayPad$[rsp]
|
|
0008d 48 33 cc xor rcx, rsp
|
|
00090 e8 00 00 00 00 call __security_check_cookie
|
|
00095 48 83 c4 58 add rsp, 88 ; 00000058H
|
|
00099 41 5e pop r14
|
|
0009b 5f pop rdi
|
|
0009c 5e pop rsi
|
|
0009d 5b pop rbx
|
|
0009e c3 ret 0
|
|
_glfwGetMonitorWorkareaWin32 ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
; COMDAT _glfwGetGammaRampWin32
|
|
_TEXT SEGMENT
|
|
values$ = 32
|
|
__$ArrayPad$ = 1568
|
|
monitor$ = 1600
|
|
ramp$ = 1608
|
|
_glfwGetGammaRampWin32 PROC ; COMDAT
|
|
|
|
; 493 : {
|
|
|
|
$LN10:
|
|
00000 48 89 5c 24 18 mov QWORD PTR [rsp+24], rbx
|
|
00005 57 push rdi
|
|
00006 48 81 ec 30 06
|
|
00 00 sub rsp, 1584 ; 00000630H
|
|
0000d 48 8b 05 00 00
|
|
00 00 mov rax, QWORD PTR __security_cookie
|
|
00014 48 33 c4 xor rax, rsp
|
|
00017 48 89 84 24 20
|
|
06 00 00 mov QWORD PTR __$ArrayPad$[rsp], rax
|
|
0001f 48 8b fa mov rdi, rdx
|
|
|
|
; 494 : HDC dc;
|
|
; 495 : WORD values[3][256];
|
|
; 496 :
|
|
; 497 : dc = CreateDCW(L"DISPLAY", monitor->win32.adapterName, NULL, NULL);
|
|
|
|
00022 45 33 c9 xor r9d, r9d
|
|
00025 48 8d 91 08 01
|
|
00 00 lea rdx, QWORD PTR [rcx+264]
|
|
0002c 45 33 c0 xor r8d, r8d
|
|
0002f 48 8d 0d 00 00
|
|
00 00 lea rcx, OFFSET FLAT:??_C@_1BA@PICGEGJB@?$AAD?$AAI?$AAS?$AAP?$AAL?$AAA?$AAY@
|
|
00036 ff 15 00 00 00
|
|
00 call QWORD PTR __imp_CreateDCW
|
|
|
|
; 498 : GetDeviceGammaRamp(dc, values);
|
|
|
|
0003c 48 8b c8 mov rcx, rax
|
|
0003f 48 8d 54 24 20 lea rdx, QWORD PTR values$[rsp]
|
|
00044 48 8b d8 mov rbx, rax
|
|
00047 ff 15 00 00 00
|
|
00 call QWORD PTR __imp_GetDeviceGammaRamp
|
|
|
|
; 499 : DeleteDC(dc);
|
|
|
|
0004d 48 8b cb mov rcx, rbx
|
|
00050 ff 15 00 00 00
|
|
00 call QWORD PTR __imp_DeleteDC
|
|
|
|
; 500 :
|
|
; 501 : _glfwAllocGammaArrays(ramp, 256);
|
|
|
|
00056 ba 00 01 00 00 mov edx, 256 ; 00000100H
|
|
0005b 48 8b cf mov rcx, rdi
|
|
0005e e8 00 00 00 00 call _glfwAllocGammaArrays
|
|
|
|
; 502 :
|
|
; 503 : memcpy(ramp->red, values[0], sizeof(values[0]));
|
|
|
|
00063 48 8b 07 mov rax, QWORD PTR [rdi]
|
|
00066 48 8d 4c 24 20 lea rcx, QWORD PTR values$[rsp]
|
|
0006b ba 04 00 00 00 mov edx, 4
|
|
00070 44 8b c2 mov r8d, edx
|
|
$LL5@glfwGetGam:
|
|
00073 48 8d 80 80 00
|
|
00 00 lea rax, QWORD PTR [rax+128]
|
|
0007a 0f 10 01 movups xmm0, XMMWORD PTR [rcx]
|
|
0007d 48 8d 89 80 00
|
|
00 00 lea rcx, QWORD PTR [rcx+128]
|
|
00084 0f 11 40 80 movups XMMWORD PTR [rax-128], xmm0
|
|
00088 0f 10 49 90 movups xmm1, XMMWORD PTR [rcx-112]
|
|
0008c 0f 11 48 90 movups XMMWORD PTR [rax-112], xmm1
|
|
00090 0f 10 41 a0 movups xmm0, XMMWORD PTR [rcx-96]
|
|
00094 0f 11 40 a0 movups XMMWORD PTR [rax-96], xmm0
|
|
00098 0f 10 49 b0 movups xmm1, XMMWORD PTR [rcx-80]
|
|
0009c 0f 11 48 b0 movups XMMWORD PTR [rax-80], xmm1
|
|
000a0 0f 10 41 c0 movups xmm0, XMMWORD PTR [rcx-64]
|
|
000a4 0f 11 40 c0 movups XMMWORD PTR [rax-64], xmm0
|
|
000a8 0f 10 49 d0 movups xmm1, XMMWORD PTR [rcx-48]
|
|
000ac 0f 11 48 d0 movups XMMWORD PTR [rax-48], xmm1
|
|
000b0 0f 10 41 e0 movups xmm0, XMMWORD PTR [rcx-32]
|
|
000b4 0f 11 40 e0 movups XMMWORD PTR [rax-32], xmm0
|
|
000b8 0f 10 49 f0 movups xmm1, XMMWORD PTR [rcx-16]
|
|
000bc 0f 11 48 f0 movups XMMWORD PTR [rax-16], xmm1
|
|
000c0 49 83 e8 01 sub r8, 1
|
|
000c4 75 ad jne SHORT $LL5@glfwGetGam
|
|
|
|
; 504 : memcpy(ramp->green, values[1], sizeof(values[1]));
|
|
|
|
000c6 48 8b 47 08 mov rax, QWORD PTR [rdi+8]
|
|
000ca 48 8d 8c 24 20
|
|
02 00 00 lea rcx, QWORD PTR values$[rsp+512]
|
|
000d2 4c 8b c2 mov r8, rdx
|
|
$LL4@glfwGetGam:
|
|
000d5 48 8d 80 80 00
|
|
00 00 lea rax, QWORD PTR [rax+128]
|
|
000dc 0f 10 01 movups xmm0, XMMWORD PTR [rcx]
|
|
000df 48 8d 89 80 00
|
|
00 00 lea rcx, QWORD PTR [rcx+128]
|
|
000e6 0f 11 40 80 movups XMMWORD PTR [rax-128], xmm0
|
|
000ea 0f 10 49 90 movups xmm1, XMMWORD PTR [rcx-112]
|
|
000ee 0f 11 48 90 movups XMMWORD PTR [rax-112], xmm1
|
|
000f2 0f 10 41 a0 movups xmm0, XMMWORD PTR [rcx-96]
|
|
000f6 0f 11 40 a0 movups XMMWORD PTR [rax-96], xmm0
|
|
000fa 0f 10 49 b0 movups xmm1, XMMWORD PTR [rcx-80]
|
|
000fe 0f 11 48 b0 movups XMMWORD PTR [rax-80], xmm1
|
|
00102 0f 10 41 c0 movups xmm0, XMMWORD PTR [rcx-64]
|
|
00106 0f 11 40 c0 movups XMMWORD PTR [rax-64], xmm0
|
|
0010a 0f 10 49 d0 movups xmm1, XMMWORD PTR [rcx-48]
|
|
0010e 0f 11 48 d0 movups XMMWORD PTR [rax-48], xmm1
|
|
00112 0f 10 41 e0 movups xmm0, XMMWORD PTR [rcx-32]
|
|
00116 0f 11 40 e0 movups XMMWORD PTR [rax-32], xmm0
|
|
0011a 0f 10 49 f0 movups xmm1, XMMWORD PTR [rcx-16]
|
|
0011e 0f 11 48 f0 movups XMMWORD PTR [rax-16], xmm1
|
|
00122 49 83 e8 01 sub r8, 1
|
|
00126 75 ad jne SHORT $LL4@glfwGetGam
|
|
|
|
; 505 : memcpy(ramp->blue, values[2], sizeof(values[2]));
|
|
|
|
00128 48 8b 4f 10 mov rcx, QWORD PTR [rdi+16]
|
|
0012c 48 8d 84 24 20
|
|
04 00 00 lea rax, QWORD PTR values$[rsp+1024]
|
|
$LL3@glfwGetGam:
|
|
00134 48 8d 89 80 00
|
|
00 00 lea rcx, QWORD PTR [rcx+128]
|
|
0013b 0f 10 00 movups xmm0, XMMWORD PTR [rax]
|
|
0013e 48 8d 80 80 00
|
|
00 00 lea rax, QWORD PTR [rax+128]
|
|
00145 0f 11 41 80 movups XMMWORD PTR [rcx-128], xmm0
|
|
00149 0f 10 48 90 movups xmm1, XMMWORD PTR [rax-112]
|
|
0014d 0f 11 49 90 movups XMMWORD PTR [rcx-112], xmm1
|
|
00151 0f 10 40 a0 movups xmm0, XMMWORD PTR [rax-96]
|
|
00155 0f 11 41 a0 movups XMMWORD PTR [rcx-96], xmm0
|
|
00159 0f 10 48 b0 movups xmm1, XMMWORD PTR [rax-80]
|
|
0015d 0f 11 49 b0 movups XMMWORD PTR [rcx-80], xmm1
|
|
00161 0f 10 40 c0 movups xmm0, XMMWORD PTR [rax-64]
|
|
00165 0f 11 41 c0 movups XMMWORD PTR [rcx-64], xmm0
|
|
00169 0f 10 48 d0 movups xmm1, XMMWORD PTR [rax-48]
|
|
0016d 0f 11 49 d0 movups XMMWORD PTR [rcx-48], xmm1
|
|
00171 0f 10 40 e0 movups xmm0, XMMWORD PTR [rax-32]
|
|
00175 0f 11 41 e0 movups XMMWORD PTR [rcx-32], xmm0
|
|
00179 0f 10 48 f0 movups xmm1, XMMWORD PTR [rax-16]
|
|
0017d 0f 11 49 f0 movups XMMWORD PTR [rcx-16], xmm1
|
|
00181 48 83 ea 01 sub rdx, 1
|
|
00185 75 ad jne SHORT $LL3@glfwGetGam
|
|
|
|
; 506 :
|
|
; 507 : return GLFW_TRUE;
|
|
|
|
00187 8d 42 01 lea eax, QWORD PTR [rdx+1]
|
|
|
|
; 508 : }
|
|
|
|
0018a 48 8b 8c 24 20
|
|
06 00 00 mov rcx, QWORD PTR __$ArrayPad$[rsp]
|
|
00192 48 33 cc xor rcx, rsp
|
|
00195 e8 00 00 00 00 call __security_check_cookie
|
|
0019a 48 8b 9c 24 50
|
|
06 00 00 mov rbx, QWORD PTR [rsp+1616]
|
|
001a2 48 81 c4 30 06
|
|
00 00 add rsp, 1584 ; 00000630H
|
|
001a9 5f pop rdi
|
|
001aa c3 ret 0
|
|
_glfwGetGammaRampWin32 ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
; COMDAT _glfwGetMonitorPosWin32
|
|
_TEXT SEGMENT
|
|
dm$ = 32
|
|
__$ArrayPad$ = 256
|
|
monitor$ = 304
|
|
xpos$ = 312
|
|
ypos$ = 320
|
|
_glfwGetMonitorPosWin32 PROC ; COMDAT
|
|
|
|
; 359 : {
|
|
|
|
$LN8:
|
|
00000 48 89 5c 24 20 mov QWORD PTR [rsp+32], rbx
|
|
00005 55 push rbp
|
|
00006 56 push rsi
|
|
00007 57 push rdi
|
|
00008 48 81 ec 10 01
|
|
00 00 sub rsp, 272 ; 00000110H
|
|
0000f 48 8b 05 00 00
|
|
00 00 mov rax, QWORD PTR __security_cookie
|
|
00016 48 33 c4 xor rax, rsp
|
|
00019 48 89 84 24 00
|
|
01 00 00 mov QWORD PTR __$ArrayPad$[rsp], rax
|
|
00021 49 8b f8 mov rdi, r8
|
|
00024 48 8b f2 mov rsi, rdx
|
|
00027 48 8b d9 mov rbx, rcx
|
|
|
|
; 360 : DEVMODEW dm;
|
|
; 361 : ZeroMemory(&dm, sizeof(dm));
|
|
|
|
0002a bd dc 00 00 00 mov ebp, 220 ; 000000dcH
|
|
0002f 44 8b c5 mov r8d, ebp
|
|
00032 48 8d 4c 24 20 lea rcx, QWORD PTR dm$[rsp]
|
|
00037 33 d2 xor edx, edx
|
|
00039 e8 00 00 00 00 call memset
|
|
|
|
; 362 : dm.dmSize = sizeof(dm);
|
|
; 363 :
|
|
; 364 : EnumDisplaySettingsExW(monitor->win32.adapterName,
|
|
|
|
0003e 48 8d 8b 08 01
|
|
00 00 lea rcx, QWORD PTR [rbx+264]
|
|
00045 66 89 6c 24 64 mov WORD PTR dm$[rsp+68], bp
|
|
0004a 41 b9 04 00 00
|
|
00 mov r9d, 4
|
|
00050 4c 8d 44 24 20 lea r8, QWORD PTR dm$[rsp]
|
|
00055 ba ff ff ff ff mov edx, -1 ; ffffffffH
|
|
0005a ff 15 00 00 00
|
|
00 call QWORD PTR __imp_EnumDisplaySettingsExW
|
|
|
|
; 365 : ENUM_CURRENT_SETTINGS,
|
|
; 366 : &dm,
|
|
; 367 : EDS_ROTATEDMODE);
|
|
; 368 :
|
|
; 369 : if (xpos)
|
|
|
|
00060 48 85 f6 test rsi, rsi
|
|
00063 74 06 je SHORT $LN2@glfwGetMon
|
|
|
|
; 370 : *xpos = dm.dmPosition.x;
|
|
|
|
00065 8b 44 24 6c mov eax, DWORD PTR dm$[rsp+76]
|
|
00069 89 06 mov DWORD PTR [rsi], eax
|
|
$LN2@glfwGetMon:
|
|
|
|
; 371 : if (ypos)
|
|
|
|
0006b 48 85 ff test rdi, rdi
|
|
0006e 74 06 je SHORT $LN3@glfwGetMon
|
|
|
|
; 372 : *ypos = dm.dmPosition.y;
|
|
|
|
00070 8b 44 24 70 mov eax, DWORD PTR dm$[rsp+80]
|
|
00074 89 07 mov DWORD PTR [rdi], eax
|
|
$LN3@glfwGetMon:
|
|
|
|
; 373 : }
|
|
|
|
00076 48 8b 8c 24 00
|
|
01 00 00 mov rcx, QWORD PTR __$ArrayPad$[rsp]
|
|
0007e 48 33 cc xor rcx, rsp
|
|
00081 e8 00 00 00 00 call __security_check_cookie
|
|
00086 48 8b 9c 24 48
|
|
01 00 00 mov rbx, QWORD PTR [rsp+328]
|
|
0008e 48 81 c4 10 01
|
|
00 00 add rsp, 272 ; 00000110H
|
|
00095 5f pop rdi
|
|
00096 5e pop rsi
|
|
00097 5d pop rbp
|
|
00098 c3 ret 0
|
|
_glfwGetMonitorPosWin32 ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
; COMDAT _glfwGetVideoModesWin32
|
|
_TEXT SEGMENT
|
|
monitor$GSCopy$1$ = 48
|
|
mode$1 = 56
|
|
dm$2 = 80
|
|
__$ArrayPad$ = 304
|
|
monitor$ = 384
|
|
count$ = 392
|
|
_glfwGetVideoModesWin32 PROC ; COMDAT
|
|
|
|
; 399 : {
|
|
|
|
$LN91:
|
|
00000 4c 8b dc mov r11, rsp
|
|
00003 53 push rbx
|
|
00004 56 push rsi
|
|
00005 57 push rdi
|
|
00006 41 56 push r14
|
|
00008 48 81 ec 58 01
|
|
00 00 sub rsp, 344 ; 00000158H
|
|
0000f 48 8b 05 00 00
|
|
00 00 mov rax, QWORD PTR __security_cookie
|
|
00016 48 33 c4 xor rax, rsp
|
|
00019 48 89 84 24 30
|
|
01 00 00 mov QWORD PTR __$ArrayPad$[rsp], rax
|
|
00021 4d 89 63 d8 mov QWORD PTR [r11-40], r12
|
|
00025 4c 8b f2 mov r14, rdx
|
|
00028 4d 89 6b d0 mov QWORD PTR [r11-48], r13
|
|
0002c 48 8b f1 mov rsi, rcx
|
|
0002f 48 89 4c 24 30 mov QWORD PTR monitor$GSCopy$1$[rsp], rcx
|
|
|
|
; 400 : int modeIndex = 0, size = 0;
|
|
; 401 : GLFWvidmode* result = NULL;
|
|
|
|
00034 33 ff xor edi, edi
|
|
|
|
; 402 :
|
|
; 403 : *count = 0;
|
|
|
|
00036 89 3a mov DWORD PTR [rdx], edi
|
|
|
|
; 404 :
|
|
; 405 : for (;;)
|
|
; 406 : {
|
|
; 407 : int i;
|
|
; 408 : GLFWvidmode mode;
|
|
; 409 : DEVMODEW dm;
|
|
; 410 :
|
|
; 411 : ZeroMemory(&dm, sizeof(dm));
|
|
|
|
00038 48 8d 4c 24 50 lea rcx, QWORD PTR dm$2[rsp]
|
|
0003d 4d 89 7b c8 mov QWORD PTR [r11-56], r15
|
|
00041 41 bd dc 00 00
|
|
00 mov r13d, 220 ; 000000dcH
|
|
00047 45 8b c5 mov r8d, r13d
|
|
0004a 33 d2 xor edx, edx
|
|
0004c 45 33 e4 xor r12d, r12d
|
|
0004f 45 33 ff xor r15d, r15d
|
|
00052 e8 00 00 00 00 call memset
|
|
|
|
; 412 : dm.dmSize = sizeof(dm);
|
|
|
|
00057 66 44 89 ac 24
|
|
94 00 00 00 mov WORD PTR dm$2[rsp+68], r13w
|
|
|
|
; 413 :
|
|
; 414 : if (!EnumDisplaySettingsW(monitor->win32.adapterName, modeIndex, &dm))
|
|
|
|
00060 4c 8d 44 24 50 lea r8, QWORD PTR dm$2[rsp]
|
|
00065 4c 8d ae 08 01
|
|
00 00 lea r13, QWORD PTR [rsi+264]
|
|
0006c 33 d2 xor edx, edx
|
|
0006e 49 8b cd mov rcx, r13
|
|
00071 ff 15 00 00 00
|
|
00 call QWORD PTR __imp_EnumDisplaySettingsW
|
|
00077 85 c0 test eax, eax
|
|
00079 0f 84 68 02 00
|
|
00 je $LN58@glfwGetVid
|
|
0007f 48 89 ac 24 90
|
|
01 00 00 mov QWORD PTR [rsp+400], rbp
|
|
00087 bb dc 00 00 00 mov ebx, 220 ; 000000dcH
|
|
0008c 0f 1f 40 00 npad 4
|
|
$LL2@glfwGetVid:
|
|
|
|
; 415 : break;
|
|
; 416 :
|
|
; 417 : modeIndex++;
|
|
; 418 :
|
|
; 419 : // Skip modes with less than 15 BPP
|
|
; 420 : if (dm.dmBitsPerPel < 15)
|
|
|
|
00090 8b 8c 24 f8 00
|
|
00 00 mov ecx, DWORD PTR dm$2[rsp+168]
|
|
00097 41 ff c4 inc r12d
|
|
0009a 83 f9 0f cmp ecx, 15
|
|
0009d 0f 82 0c 02 00
|
|
00 jb $LN60@glfwGetVid
|
|
|
|
; 421 : continue;
|
|
; 422 :
|
|
; 423 : mode.width = dm.dmPelsWidth;
|
|
|
|
000a3 44 8b 9c 24 fc
|
|
00 00 00 mov r11d, DWORD PTR dm$2[rsp+172]
|
|
|
|
; 424 : mode.height = dm.dmPelsHeight;
|
|
|
|
000ab 8b 9c 24 00 01
|
|
00 00 mov ebx, DWORD PTR dm$2[rsp+176]
|
|
|
|
; 425 : mode.refreshRate = dm.dmDisplayFrequency;
|
|
|
|
000b2 8b ac 24 08 01
|
|
00 00 mov ebp, DWORD PTR dm$2[rsp+184]
|
|
000b9 44 89 5c 24 38 mov DWORD PTR mode$1[rsp], r11d
|
|
000be 89 5c 24 3c mov DWORD PTR mode$1[rsp+4], ebx
|
|
000c2 89 6c 24 4c mov DWORD PTR mode$1[rsp+20], ebp
|
|
|
|
; 426 : _glfwSplitBPP(dm.dmBitsPerPel,
|
|
|
|
000c6 83 f9 20 cmp ecx, 32 ; 00000020H
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
|
|
; 287 : if (bpp == 32)
|
|
|
|
000c9 75 6a jne SHORT $LN18@glfwGetVid
|
|
|
|
; 288 : bpp = 24;
|
|
|
|
000cb ba 08 00 00 00 mov edx, 8
|
|
000d0 33 c9 xor ecx, ecx
|
|
000d2 89 54 24 48 mov DWORD PTR mode$1[rsp+16], edx
|
|
000d6 44 8b c2 mov r8d, edx
|
|
000d9 44 8b ca mov r9d, edx
|
|
000dc 89 54 24 44 mov DWORD PTR mode$1[rsp+12], edx
|
|
000e0 44 8b d2 mov r10d, edx
|
|
$LN66@glfwGetVid:
|
|
|
|
; 295 : *green = *green + 1;
|
|
|
|
000e3 41 ff c2 inc r10d
|
|
$LN19@glfwGetVid:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
|
|
; 431 : for (i = 0; i < *count; i++)
|
|
|
|
000e6 41 8b 36 mov esi, DWORD PTR [r14]
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
|
|
; 297 : if (delta == 2)
|
|
|
|
000e9 83 f9 02 cmp ecx, 2
|
|
000ec 41 8b c0 mov eax, r8d
|
|
000ef 41 0f 44 c2 cmove eax, r10d
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
|
|
; 431 : for (i = 0; i < *count; i++)
|
|
|
|
000f3 45 0f 45 d0 cmovne r10d, r8d
|
|
000f7 45 33 c0 xor r8d, r8d
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
|
|
; 297 : if (delta == 2)
|
|
|
|
000fa 89 44 24 40 mov DWORD PTR mode$1[rsp+8], eax
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
|
|
; 431 : for (i = 0; i < *count; i++)
|
|
|
|
000fe 85 f6 test esi, esi
|
|
00100 0f 8e a3 00 00
|
|
00 jle $LN65@glfwGetVid
|
|
00106 45 03 ca add r9d, r10d
|
|
00109 48 8d 4f 0c lea rcx, QWORD PTR [rdi+12]
|
|
0010d 44 03 ca add r9d, edx
|
|
00110 41 0f af db imul ebx, r11d
|
|
00114 0f 1f 40 00 0f
|
|
1f 84 00 00 00
|
|
00 00 npad 12
|
|
$LL7@glfwGetVid:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
|
|
; 46 : const int fbpp = fm->redBits + fm->greenBits + fm->blueBits;
|
|
|
|
00120 8b 41 fc mov eax, DWORD PTR [rcx-4]
|
|
00123 03 41 04 add eax, DWORD PTR [rcx+4]
|
|
00126 03 01 add eax, DWORD PTR [rcx]
|
|
|
|
; 47 : const int sbpp = sm->redBits + sm->greenBits + sm->blueBits;
|
|
; 48 : const int farea = fm->width * fm->height;
|
|
|
|
00128 8b 51 f4 mov edx, DWORD PTR [rcx-12]
|
|
|
|
; 49 : const int sarea = sm->width * sm->height;
|
|
; 50 :
|
|
; 51 : // First sort on color bits per pixel
|
|
; 52 : if (fbpp != sbpp)
|
|
|
|
0012b 41 3b c1 cmp eax, r9d
|
|
0012e 74 3f je SHORT $LN25@glfwGetVid
|
|
|
|
; 53 : return fbpp - sbpp;
|
|
|
|
00130 41 2b c1 sub eax, r9d
|
|
00133 eb 59 jmp SHORT $LN24@glfwGetVid
|
|
$LN18@glfwGetVid:
|
|
|
|
; 292 : *red = *green = *blue = bpp / 3;
|
|
|
|
00135 b8 56 55 55 55 mov eax, 1431655766 ; 55555556H
|
|
0013a f7 e9 imul ecx
|
|
0013c 8b c2 mov eax, edx
|
|
0013e c1 e8 1f shr eax, 31
|
|
00141 03 d0 add edx, eax
|
|
00143 44 8b d2 mov r10d, edx
|
|
00146 89 54 24 48 mov DWORD PTR mode$1[rsp+16], edx
|
|
0014a 44 8b c2 mov r8d, edx
|
|
|
|
; 293 : delta = bpp - (*red * 3);
|
|
|
|
0014d 89 54 24 44 mov DWORD PTR mode$1[rsp+12], edx
|
|
00151 44 8b ca mov r9d, edx
|
|
00154 8d 04 52 lea eax, DWORD PTR [rdx+rdx*2]
|
|
00157 2b c8 sub ecx, eax
|
|
|
|
; 294 : if (delta >= 1)
|
|
|
|
00159 83 f9 01 cmp ecx, 1
|
|
0015c 7c 85 jl SHORT $LN66@glfwGetVid
|
|
|
|
; 295 : *green = *green + 1;
|
|
|
|
0015e 44 8d 4a 01 lea r9d, DWORD PTR [rdx+1]
|
|
00162 44 89 4c 24 44 mov DWORD PTR mode$1[rsp+12], r9d
|
|
00167 45 8b d1 mov r10d, r9d
|
|
0016a e9 77 ff ff ff jmp $LN19@glfwGetVid
|
|
$LN25@glfwGetVid:
|
|
|
|
; 48 : const int farea = fm->width * fm->height;
|
|
|
|
0016f 8b c2 mov eax, edx
|
|
00171 0f af 41 f8 imul eax, DWORD PTR [rcx-8]
|
|
|
|
; 54 :
|
|
; 55 : // Then sort on screen area
|
|
; 56 : if (farea != sarea)
|
|
|
|
00175 3b c3 cmp eax, ebx
|
|
00177 74 04 je SHORT $LN26@glfwGetVid
|
|
|
|
; 57 : return farea - sarea;
|
|
|
|
00179 2b c3 sub eax, ebx
|
|
0017b eb 11 jmp SHORT $LN24@glfwGetVid
|
|
$LN26@glfwGetVid:
|
|
|
|
; 58 :
|
|
; 59 : // Then sort on width
|
|
; 60 : if (fm->width != sm->width)
|
|
|
|
0017d 41 3b d3 cmp edx, r11d
|
|
00180 74 07 je SHORT $LN27@glfwGetVid
|
|
|
|
; 61 : return fm->width - sm->width;
|
|
|
|
00182 8b c2 mov eax, edx
|
|
00184 41 2b c3 sub eax, r11d
|
|
00187 eb 05 jmp SHORT $LN24@glfwGetVid
|
|
$LN27@glfwGetVid:
|
|
|
|
; 62 :
|
|
; 63 : // Lastly sort on refresh rate
|
|
; 64 : return fm->refreshRate - sm->refreshRate;
|
|
|
|
00189 8b 41 08 mov eax, DWORD PTR [rcx+8]
|
|
0018c 2b c5 sub eax, ebp
|
|
$LN24@glfwGetVid:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
|
|
; 433 : if (_glfwCompareVideoModes(result + i, &mode) == 0)
|
|
|
|
0018e 85 c0 test eax, eax
|
|
00190 74 0e je SHORT $LN57@glfwGetVid
|
|
|
|
; 431 : for (i = 0; i < *count; i++)
|
|
|
|
00192 41 ff c0 inc r8d
|
|
00195 48 83 c1 18 add rcx, 24
|
|
00199 44 3b c6 cmp r8d, esi
|
|
0019c 7c 82 jl SHORT $LL7@glfwGetVid
|
|
|
|
; 438 : if (i < *count)
|
|
|
|
0019e eb 09 jmp SHORT $LN65@glfwGetVid
|
|
$LN57@glfwGetVid:
|
|
001a0 44 3b c6 cmp r8d, esi
|
|
001a3 0f 8c fc 00 00
|
|
00 jl $LN68@glfwGetVid
|
|
$LN65@glfwGetVid:
|
|
|
|
; 439 : continue;
|
|
; 440 :
|
|
; 441 : if (monitor->win32.modesPruned)
|
|
|
|
001a9 48 8b 74 24 30 mov rsi, QWORD PTR monitor$GSCopy$1$[rsp]
|
|
001ae 83 be c8 01 00
|
|
00 00 cmp DWORD PTR [rsi+456], 0
|
|
001b5 74 28 je SHORT $LN13@glfwGetVid
|
|
|
|
; 442 : {
|
|
; 443 : // Skip modes not supported by the connected displays
|
|
; 444 : if (ChangeDisplaySettingsExW(monitor->win32.adapterName,
|
|
; 445 : &dm,
|
|
; 446 : NULL,
|
|
; 447 : CDS_TEST,
|
|
; 448 : NULL) != DISP_CHANGE_SUCCESSFUL)
|
|
|
|
001b7 41 b9 02 00 00
|
|
00 mov r9d, 2
|
|
001bd 48 c7 44 24 20
|
|
00 00 00 00 mov QWORD PTR [rsp+32], 0
|
|
001c6 45 33 c0 xor r8d, r8d
|
|
001c9 48 8d 54 24 50 lea rdx, QWORD PTR dm$2[rsp]
|
|
001ce 49 8b cd mov rcx, r13
|
|
001d1 ff 15 00 00 00
|
|
00 call QWORD PTR __imp_ChangeDisplaySettingsExW
|
|
001d7 85 c0 test eax, eax
|
|
001d9 0f 85 cb 00 00
|
|
00 jne $LN69@glfwGetVid
|
|
$LN13@glfwGetVid:
|
|
|
|
; 449 : {
|
|
; 450 : continue;
|
|
; 451 : }
|
|
; 452 : }
|
|
; 453 :
|
|
; 454 : if (*count == size)
|
|
|
|
001df 45 39 3e cmp DWORD PTR [r14], r15d
|
|
001e2 75 42 jne SHORT $LN42@glfwGetVid
|
|
|
|
; 455 : {
|
|
; 456 : size += 128;
|
|
|
|
001e4 41 83 ef 80 sub r15d, -128 ; ffffffffffffff80H
|
|
|
|
; 457 : result = (GLFWvidmode*) _glfw_realloc(result, size * sizeof(GLFWvidmode));
|
|
|
|
001e8 49 63 c7 movsxd rax, r15d
|
|
001eb 48 8d 1c 40 lea rbx, QWORD PTR [rax+rax*2]
|
|
001ef 48 c1 e3 03 shl rbx, 3
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 298 : if (block && size)
|
|
|
|
001f3 48 85 ff test rdi, rdi
|
|
001f6 74 61 je SHORT $LN34@glfwGetVid
|
|
001f8 48 8b cf mov rcx, rdi
|
|
001fb 48 85 db test rbx, rbx
|
|
001fe 74 4a je SHORT $LN30@glfwGetVid
|
|
|
|
; 299 : {
|
|
; 300 : void* resized = _glfw.allocator.reallocate(block, size, _glfw.allocator.user);
|
|
|
|
00200 4c 8b 05 20 00
|
|
00 00 mov r8, QWORD PTR _glfw+32
|
|
00207 48 8b d3 mov rdx, rbx
|
|
0020a ff 15 10 00 00
|
|
00 call QWORD PTR _glfw+16
|
|
00210 48 8b f8 mov rdi, rax
|
|
|
|
; 301 : if (resized)
|
|
|
|
00213 48 85 c0 test rax, rax
|
|
00216 75 0e jne SHORT $LN42@glfwGetVid
|
|
$LN44@glfwGetVid:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
|
|
; 460 : (*count)++;
|
|
|
|
00218 33 d2 xor edx, edx
|
|
0021a b9 05 00 01 00 mov ecx, 65541 ; 00010005H
|
|
$LN89@glfwGetVid:
|
|
0021f e8 00 00 00 00 call _glfwInputError
|
|
$LN41@glfwGetVid:
|
|
00224 33 ff xor edi, edi
|
|
$LN42@glfwGetVid:
|
|
00226 49 63 0e movsxd rcx, DWORD PTR [r14]
|
|
|
|
; 461 : result[*count - 1] = mode;
|
|
|
|
00229 0f 10 44 24 38 movups xmm0, XMMWORD PTR mode$1[rsp]
|
|
0022e f2 0f 10 4c 24
|
|
48 movsd xmm1, QWORD PTR mode$1[rsp+16]
|
|
00234 8d 41 01 lea eax, DWORD PTR [rcx+1]
|
|
00237 48 8d 0c 49 lea rcx, QWORD PTR [rcx+rcx*2]
|
|
0023b 41 89 06 mov DWORD PTR [r14], eax
|
|
0023e 0f 11 04 cf movups XMMWORD PTR [rdi+rcx*8], xmm0
|
|
00242 f2 0f 11 4c cf
|
|
10 movsd QWORD PTR [rdi+rcx*8+16], xmm1
|
|
00248 eb 60 jmp SHORT $LN69@glfwGetVid
|
|
$LN30@glfwGetVid:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 321 : _glfw.allocator.deallocate(block, _glfw.allocator.user);
|
|
|
|
0024a 48 8b 15 20 00
|
|
00 00 mov rdx, QWORD PTR _glfw+32
|
|
00251 ff 15 18 00 00
|
|
00 call QWORD PTR _glfw+24
|
|
|
|
; 312 : return NULL;
|
|
|
|
00257 eb cb jmp SHORT $LN41@glfwGetVid
|
|
$LN34@glfwGetVid:
|
|
|
|
; 273 : if (count && size)
|
|
|
|
00259 48 85 db test rbx, rbx
|
|
0025c 74 c6 je SHORT $LN41@glfwGetVid
|
|
|
|
; 274 : {
|
|
; 275 : void* block;
|
|
; 276 :
|
|
; 277 : if (count > SIZE_MAX / size)
|
|
|
|
0025e 33 d2 xor edx, edx
|
|
00260 48 c7 c0 ff ff
|
|
ff ff mov rax, -1
|
|
00267 48 f7 f3 div rbx
|
|
0026a 48 83 f8 01 cmp rax, 1
|
|
0026e 73 0e jae SHORT $LN43@glfwGetVid
|
|
|
|
; 278 : {
|
|
; 279 : _glfwInputError(GLFW_INVALID_VALUE, "Allocation size overflow");
|
|
|
|
00270 48 8d 15 00 00
|
|
00 00 lea rdx, OFFSET FLAT:??_C@_0BJ@IHHANIOG@Allocation?5size?5overflow@
|
|
00277 b9 04 00 01 00 mov ecx, 65540 ; 00010004H
|
|
|
|
; 280 : return NULL;
|
|
|
|
0027c eb a1 jmp SHORT $LN89@glfwGetVid
|
|
$LN43@glfwGetVid:
|
|
|
|
; 283 : block = _glfw.allocator.allocate(count * size, _glfw.allocator.user);
|
|
|
|
0027e 48 8b 15 20 00
|
|
00 00 mov rdx, QWORD PTR _glfw+32
|
|
00285 48 8b cb mov rcx, rbx
|
|
00288 ff 15 08 00 00
|
|
00 call QWORD PTR _glfw+8
|
|
|
|
; 284 : if (block)
|
|
|
|
0028e 48 85 c0 test rax, rax
|
|
00291 74 85 je SHORT $LN44@glfwGetVid
|
|
|
|
; 285 : return memset(block, 0, count * size);
|
|
|
|
00293 4c 8b c3 mov r8, rbx
|
|
00296 33 d2 xor edx, edx
|
|
00298 48 8b c8 mov rcx, rax
|
|
0029b e8 00 00 00 00 call memset
|
|
002a0 48 8b f8 mov rdi, rax
|
|
002a3 eb 81 jmp SHORT $LN42@glfwGetVid
|
|
$LN68@glfwGetVid:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
|
|
; 438 : if (i < *count)
|
|
|
|
002a5 48 8b 74 24 30 mov rsi, QWORD PTR monitor$GSCopy$1$[rsp]
|
|
$LN69@glfwGetVid:
|
|
|
|
; 404 :
|
|
; 405 : for (;;)
|
|
; 406 : {
|
|
; 407 : int i;
|
|
; 408 : GLFWvidmode mode;
|
|
; 409 : DEVMODEW dm;
|
|
; 410 :
|
|
; 411 : ZeroMemory(&dm, sizeof(dm));
|
|
|
|
002aa bb dc 00 00 00 mov ebx, 220 ; 000000dcH
|
|
$LN60@glfwGetVid:
|
|
002af 4c 8b c3 mov r8, rbx
|
|
002b2 48 8d 4c 24 50 lea rcx, QWORD PTR dm$2[rsp]
|
|
002b7 33 d2 xor edx, edx
|
|
002b9 e8 00 00 00 00 call memset
|
|
|
|
; 413 :
|
|
; 414 : if (!EnumDisplaySettingsW(monitor->win32.adapterName, modeIndex, &dm))
|
|
|
|
002be 4c 8d 44 24 50 lea r8, QWORD PTR dm$2[rsp]
|
|
002c3 66 89 9c 24 94
|
|
00 00 00 mov WORD PTR dm$2[rsp+68], bx
|
|
002cb 41 8b d4 mov edx, r12d
|
|
002ce 49 8b cd mov rcx, r13
|
|
002d1 ff 15 00 00 00
|
|
00 call QWORD PTR __imp_EnumDisplaySettingsW
|
|
002d7 85 c0 test eax, eax
|
|
002d9 0f 85 b1 fd ff
|
|
ff jne $LL2@glfwGetVid
|
|
002df 48 8b ac 24 90
|
|
01 00 00 mov rbp, QWORD PTR [rsp+400]
|
|
$LN58@glfwGetVid:
|
|
|
|
; 462 : }
|
|
; 463 :
|
|
; 464 : if (!*count)
|
|
|
|
002e7 41 83 3e 00 cmp DWORD PTR [r14], 0
|
|
002eb 4c 8b bc 24 40
|
|
01 00 00 mov r15, QWORD PTR [rsp+320]
|
|
002f3 4c 8b ac 24 48
|
|
01 00 00 mov r13, QWORD PTR [rsp+328]
|
|
002fb 4c 8b a4 24 50
|
|
01 00 00 mov r12, QWORD PTR [rsp+336]
|
|
00303 75 4d jne SHORT $LN67@glfwGetVid
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 283 : block = _glfw.allocator.allocate(count * size, _glfw.allocator.user);
|
|
|
|
00305 48 8b 15 20 00
|
|
00 00 mov rdx, QWORD PTR _glfw+32
|
|
0030c b9 18 00 00 00 mov ecx, 24
|
|
00311 ff 15 08 00 00
|
|
00 call QWORD PTR _glfw+8
|
|
00317 48 8b d8 mov rbx, rax
|
|
|
|
; 284 : if (block)
|
|
|
|
0031a 48 85 c0 test rax, rax
|
|
0031d 74 0e je SHORT $LN51@glfwGetVid
|
|
0031f 0f 57 c0 xorps xmm0, xmm0
|
|
|
|
; 285 : return memset(block, 0, count * size);
|
|
|
|
00322 33 c0 xor eax, eax
|
|
00324 0f 11 03 movups XMMWORD PTR [rbx], xmm0
|
|
00327 48 89 43 10 mov QWORD PTR [rbx+16], rax
|
|
0032b eb 0e jmp SHORT $LN49@glfwGetVid
|
|
$LN51@glfwGetVid:
|
|
|
|
; 286 : else
|
|
; 287 : {
|
|
; 288 : _glfwInputError(GLFW_OUT_OF_MEMORY, NULL);
|
|
|
|
0032d 33 d2 xor edx, edx
|
|
0032f b9 05 00 01 00 mov ecx, 65541 ; 00010005H
|
|
00334 e8 00 00 00 00 call _glfwInputError
|
|
|
|
; 289 : return NULL;
|
|
|
|
00339 33 db xor ebx, ebx
|
|
$LN49@glfwGetVid:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
|
|
; 468 : _glfwGetVideoModeWin32(monitor, result);
|
|
|
|
0033b 48 8b d3 mov rdx, rbx
|
|
0033e 48 8b ce mov rcx, rsi
|
|
00341 e8 00 00 00 00 call _glfwGetVideoModeWin32
|
|
|
|
; 469 : *count = 1;
|
|
; 470 : }
|
|
; 471 :
|
|
; 472 : return result;
|
|
|
|
00346 48 8b c3 mov rax, rbx
|
|
00349 41 c7 06 01 00
|
|
00 00 mov DWORD PTR [r14], 1
|
|
00350 eb 03 jmp SHORT $LN15@glfwGetVid
|
|
$LN67@glfwGetVid:
|
|
00352 48 8b c7 mov rax, rdi
|
|
$LN15@glfwGetVid:
|
|
|
|
; 473 : }
|
|
|
|
00355 48 8b 8c 24 30
|
|
01 00 00 mov rcx, QWORD PTR __$ArrayPad$[rsp]
|
|
0035d 48 33 cc xor rcx, rsp
|
|
00360 e8 00 00 00 00 call __security_check_cookie
|
|
00365 48 81 c4 58 01
|
|
00 00 add rsp, 344 ; 00000158H
|
|
0036c 41 5e pop r14
|
|
0036e 5f pop rdi
|
|
0036f 5e pop rsi
|
|
00370 5b pop rbx
|
|
00371 c3 ret 0
|
|
_glfwGetVideoModesWin32 ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
; COMDAT _glfwPollMonitorsWin32
|
|
_TEXT SEGMENT
|
|
adapter$ = 32
|
|
display$ = 880
|
|
__$ArrayPad$ = 1728
|
|
_glfwPollMonitorsWin32 PROC ; COMDAT
|
|
|
|
; 139 : {
|
|
|
|
$LN116:
|
|
00000 48 89 5c 24 18 mov QWORD PTR [rsp+24], rbx
|
|
00005 56 push rsi
|
|
00006 57 push rdi
|
|
00007 41 54 push r12
|
|
00009 41 55 push r13
|
|
0000b 41 56 push r14
|
|
0000d 48 81 ec d0 06
|
|
00 00 sub rsp, 1744 ; 000006d0H
|
|
00014 48 8b 05 00 00
|
|
00 00 mov rax, QWORD PTR __security_cookie
|
|
0001b 48 33 c4 xor rax, rsp
|
|
0001e 48 89 84 24 c0
|
|
06 00 00 mov QWORD PTR __$ArrayPad$[rsp], rax
|
|
|
|
; 140 : int i, disconnectedCount;
|
|
; 141 : _GLFWmonitor** disconnected = NULL;
|
|
; 142 : DWORD adapterIndex, displayIndex;
|
|
; 143 : DISPLAY_DEVICEW adapter, display;
|
|
; 144 : _GLFWmonitor* monitor;
|
|
; 145 :
|
|
; 146 : disconnectedCount = _glfw.monitorCount;
|
|
|
|
00026 4c 63 25 88 07
|
|
00 00 movsxd r12, DWORD PTR _glfw+1928
|
|
0002d 33 f6 xor esi, esi
|
|
0002f 44 8b f6 mov r14d, esi
|
|
|
|
; 147 : if (disconnectedCount)
|
|
|
|
00032 45 85 e4 test r12d, r12d
|
|
00035 74 72 je SHORT $LN76@glfwPollMo
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 277 : if (count > SIZE_MAX / size)
|
|
|
|
00037 48 b8 ff ff ff
|
|
ff ff ff ff 1f mov rax, 2305843009213693951 ; 1fffffffffffffffH
|
|
00041 4c 3b e0 cmp r12, rax
|
|
00044 76 0e jbe SHORT $LN35@glfwPollMo
|
|
|
|
; 278 : {
|
|
; 279 : _glfwInputError(GLFW_INVALID_VALUE, "Allocation size overflow");
|
|
|
|
00046 48 8d 15 00 00
|
|
00 00 lea rdx, OFFSET FLAT:??_C@_0BJ@IHHANIOG@Allocation?5size?5overflow@
|
|
0004d b9 04 00 01 00 mov ecx, 65540 ; 00010004H
|
|
|
|
; 280 : return NULL;
|
|
|
|
00052 eb 36 jmp SHORT $LN113@glfwPollMo
|
|
$LN35@glfwPollMo:
|
|
|
|
; 281 : }
|
|
; 282 :
|
|
; 283 : block = _glfw.allocator.allocate(count * size, _glfw.allocator.user);
|
|
|
|
00054 48 8b 15 20 00
|
|
00 00 mov rdx, QWORD PTR _glfw+32
|
|
0005b 4a 8d 1c e5 00
|
|
00 00 00 lea rbx, QWORD PTR [r12*8]
|
|
00063 48 8b cb mov rcx, rbx
|
|
00066 ff 15 08 00 00
|
|
00 call QWORD PTR _glfw+8
|
|
|
|
; 284 : if (block)
|
|
|
|
0006c 48 85 c0 test rax, rax
|
|
0006f 74 12 je SHORT $LN36@glfwPollMo
|
|
|
|
; 285 : return memset(block, 0, count * size);
|
|
|
|
00071 4c 8b c3 mov r8, rbx
|
|
00074 33 d2 xor edx, edx
|
|
00076 48 8b c8 mov rcx, rax
|
|
00079 e8 00 00 00 00 call memset
|
|
0007e 4c 8b f0 mov r14, rax
|
|
00081 eb 0c jmp SHORT $LN34@glfwPollMo
|
|
$LN36@glfwPollMo:
|
|
|
|
; 286 : else
|
|
; 287 : {
|
|
; 288 : _glfwInputError(GLFW_OUT_OF_MEMORY, NULL);
|
|
|
|
00083 33 d2 xor edx, edx
|
|
00085 b9 05 00 01 00 mov ecx, 65541 ; 00010005H
|
|
$LN113@glfwPollMo:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
|
|
; 150 : memcpy(disconnected,
|
|
|
|
0008a e8 00 00 00 00 call _glfwInputError
|
|
$LN34@glfwPollMo:
|
|
0008f 4c 63 05 88 07
|
|
00 00 movsxd r8, DWORD PTR _glfw+1928
|
|
00096 49 8b ce mov rcx, r14
|
|
00099 48 8b 15 80 07
|
|
00 00 mov rdx, QWORD PTR _glfw+1920
|
|
000a0 49 c1 e0 03 shl r8, 3
|
|
000a4 e8 00 00 00 00 call memcpy
|
|
$LN76@glfwPollMo:
|
|
|
|
; 151 : _glfw.monitors,
|
|
; 152 : _glfw.monitorCount * sizeof(_GLFWmonitor*));
|
|
; 153 : }
|
|
; 154 :
|
|
; 155 : for (adapterIndex = 0; ; adapterIndex++)
|
|
; 156 : {
|
|
; 157 : int type = _GLFW_INSERT_LAST;
|
|
; 158 :
|
|
; 159 : ZeroMemory(&adapter, sizeof(adapter));
|
|
|
|
000a9 48 89 ac 24 00
|
|
07 00 00 mov QWORD PTR [rsp+1792], rbp
|
|
000b1 48 8d 4c 24 24 lea rcx, QWORD PTR adapter$[rsp+4]
|
|
000b6 33 d2 xor edx, edx
|
|
000b8 4c 89 bc 24 08
|
|
07 00 00 mov QWORD PTR [rsp+1800], r15
|
|
000c0 41 b8 44 03 00
|
|
00 mov r8d, 836 ; 00000344H
|
|
000c6 44 8b ee mov r13d, esi
|
|
000c9 e8 00 00 00 00 call memset
|
|
|
|
; 160 : adapter.cb = sizeof(adapter);
|
|
; 161 :
|
|
; 162 : if (!EnumDisplayDevicesW(NULL, adapterIndex, &adapter, 0))
|
|
|
|
000ce 45 33 c9 xor r9d, r9d
|
|
000d1 c7 44 24 20 48
|
|
03 00 00 mov DWORD PTR adapter$[rsp], 840 ; 00000348H
|
|
000d9 4c 8d 44 24 20 lea r8, QWORD PTR adapter$[rsp]
|
|
000de 33 d2 xor edx, edx
|
|
000e0 33 c9 xor ecx, ecx
|
|
000e2 ff 15 00 00 00
|
|
00 call QWORD PTR __imp_EnumDisplayDevicesW
|
|
000e8 85 c0 test eax, eax
|
|
000ea 0f 84 16 02 00
|
|
00 je $LN59@glfwPollMo
|
|
$LL4@glfwPollMo:
|
|
|
|
; 163 : break;
|
|
; 164 :
|
|
; 165 : if (!(adapter.StateFlags & DISPLAY_DEVICE_ACTIVE))
|
|
|
|
000f0 44 8b bc 24 64
|
|
01 00 00 mov r15d, DWORD PTR adapter$[rsp+324]
|
|
000f8 41 f6 c7 01 test r15b, 1
|
|
000fc 0f 84 cc 01 00
|
|
00 je $LN2@glfwPollMo
|
|
|
|
; 166 : continue;
|
|
; 167 :
|
|
; 168 : if (adapter.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE)
|
|
|
|
00102 41 c1 ef 02 shr r15d, 2
|
|
|
|
; 169 : type = _GLFW_INSERT_FIRST;
|
|
; 170 :
|
|
; 171 : for (displayIndex = 0; ; displayIndex++)
|
|
; 172 : {
|
|
; 173 : ZeroMemory(&display, sizeof(display));
|
|
|
|
00106 48 8d 8c 24 74
|
|
03 00 00 lea rcx, QWORD PTR display$[rsp+4]
|
|
0010e 41 f7 d7 not r15d
|
|
00111 33 d2 xor edx, edx
|
|
00113 41 b8 44 03 00
|
|
00 mov r8d, 836 ; 00000344H
|
|
00119 41 83 e7 01 and r15d, 1
|
|
0011d 8b ee mov ebp, esi
|
|
0011f e8 00 00 00 00 call memset
|
|
|
|
; 174 : display.cb = sizeof(display);
|
|
; 175 :
|
|
; 176 : if (!EnumDisplayDevicesW(adapter.DeviceName, displayIndex, &display, 0))
|
|
|
|
00124 45 33 c9 xor r9d, r9d
|
|
00127 c7 84 24 70 03
|
|
00 00 48 03 00
|
|
00 mov DWORD PTR display$[rsp], 840 ; 00000348H
|
|
00132 4c 8d 84 24 70
|
|
03 00 00 lea r8, QWORD PTR display$[rsp]
|
|
0013a 33 d2 xor edx, edx
|
|
0013c 48 8d 4c 24 24 lea rcx, QWORD PTR adapter$[rsp+4]
|
|
00141 ff 15 00 00 00
|
|
00 call QWORD PTR __imp_EnumDisplayDevicesW
|
|
00147 85 c0 test eax, eax
|
|
00149 0f 84 07 01 00
|
|
00 je $LN75@glfwPollMo
|
|
0014f 90 npad 1
|
|
$LL7@glfwPollMo:
|
|
|
|
; 177 : break;
|
|
; 178 :
|
|
; 179 : if (!(display.StateFlags & DISPLAY_DEVICE_ACTIVE))
|
|
|
|
00150 f6 84 24 b4 04
|
|
00 00 01 test BYTE PTR display$[rsp+324], 1
|
|
00158 0f 84 ae 00 00
|
|
00 je $LN5@glfwPollMo
|
|
|
|
; 180 : continue;
|
|
; 181 :
|
|
; 182 : for (i = 0; i < disconnectedCount; i++)
|
|
|
|
0015e 8b de mov ebx, esi
|
|
00160 4c 8b ce mov r9, rsi
|
|
00163 45 85 e4 test r12d, r12d
|
|
00166 7e 6e jle SHORT $LN77@glfwPollMo
|
|
00168 0f 1f 84 00 00
|
|
00 00 00 npad 8
|
|
$LL10@glfwPollMo:
|
|
|
|
; 183 : {
|
|
; 184 : if (disconnected[i] &&
|
|
|
|
00170 4e 8d 14 cd 00
|
|
00 00 00 lea r10, QWORD PTR [r9*8]
|
|
00178 4b 8b 04 32 mov rax, QWORD PTR [r10+r14]
|
|
0017c 48 85 c0 test rax, rax
|
|
0017f 74 29 je SHORT $LN8@glfwPollMo
|
|
00181 48 05 48 01 00
|
|
00 add rax, 328 ; 00000148H
|
|
00187 4c 8d 84 24 74
|
|
03 00 00 lea r8, QWORD PTR display$[rsp+4]
|
|
0018f 4c 2b c0 sub r8, rax
|
|
$LL83@glfwPollMo:
|
|
00192 0f b7 10 movzx edx, WORD PTR [rax]
|
|
00195 42 0f b7 0c 00 movzx ecx, WORD PTR [rax+r8]
|
|
0019a 2b d1 sub edx, ecx
|
|
0019c 75 08 jne SHORT $LN84@glfwPollMo
|
|
0019e 48 83 c0 02 add rax, 2
|
|
001a2 85 c9 test ecx, ecx
|
|
001a4 75 ec jne SHORT $LL83@glfwPollMo
|
|
$LN84@glfwPollMo:
|
|
001a6 85 d2 test edx, edx
|
|
001a8 74 0c je SHORT $LN55@glfwPollMo
|
|
$LN8@glfwPollMo:
|
|
|
|
; 180 : continue;
|
|
; 181 :
|
|
; 182 : for (i = 0; i < disconnectedCount; i++)
|
|
|
|
001aa ff c3 inc ebx
|
|
001ac 49 ff c1 inc r9
|
|
001af 4d 3b cc cmp r9, r12
|
|
001b2 7c bc jl SHORT $LL10@glfwPollMo
|
|
001b4 eb 20 jmp SHORT $LN77@glfwPollMo
|
|
$LN55@glfwPollMo:
|
|
|
|
; 185 : wcscmp(disconnected[i]->win32.displayName,
|
|
; 186 : display.DeviceName) == 0)
|
|
; 187 : {
|
|
; 188 : disconnected[i] = NULL;
|
|
|
|
001b6 4b 89 34 32 mov QWORD PTR [r10+r14], rsi
|
|
|
|
; 189 : // handle may have changed, update
|
|
; 190 : EnumDisplayMonitors(NULL, NULL, monitorCallback, (LPARAM) _glfw.monitors[i]);
|
|
|
|
001ba 4c 8d 05 00 00
|
|
00 00 lea r8, OFFSET FLAT:monitorCallback
|
|
001c1 4c 8b 0d 80 07
|
|
00 00 mov r9, QWORD PTR _glfw+1920
|
|
001c8 33 d2 xor edx, edx
|
|
001ca 33 c9 xor ecx, ecx
|
|
001cc 4f 8b 0c 0a mov r9, QWORD PTR [r10+r9]
|
|
001d0 ff 15 00 00 00
|
|
00 call QWORD PTR __imp_EnumDisplayMonitors
|
|
$LN77@glfwPollMo:
|
|
|
|
; 191 : break;
|
|
; 192 : }
|
|
; 193 : }
|
|
; 194 :
|
|
; 195 : if (i < disconnectedCount)
|
|
|
|
001d6 41 3b dc cmp ebx, r12d
|
|
001d9 7c 31 jl SHORT $LN5@glfwPollMo
|
|
|
|
; 196 : continue;
|
|
; 197 :
|
|
; 198 : monitor = createMonitor(&adapter, &display);
|
|
|
|
001db 48 8d 94 24 70
|
|
03 00 00 lea rdx, QWORD PTR display$[rsp]
|
|
001e3 48 8d 4c 24 20 lea rcx, QWORD PTR adapter$[rsp]
|
|
001e8 e8 00 00 00 00 call createMonitor
|
|
|
|
; 199 : if (!monitor)
|
|
|
|
001ed 48 85 c0 test rax, rax
|
|
001f0 0f 84 38 01 00
|
|
00 je $LN15@glfwPollMo
|
|
|
|
; 200 : {
|
|
; 201 : _glfw_free(disconnected);
|
|
; 202 : return;
|
|
; 203 : }
|
|
; 204 :
|
|
; 205 : _glfwInputMonitor(monitor, GLFW_CONNECTED, type);
|
|
|
|
001f6 45 8b c7 mov r8d, r15d
|
|
001f9 ba 01 00 04 00 mov edx, 262145 ; 00040001H
|
|
001fe 48 8b c8 mov rcx, rax
|
|
00201 e8 00 00 00 00 call _glfwInputMonitor
|
|
|
|
; 206 :
|
|
; 207 : type = _GLFW_INSERT_LAST;
|
|
|
|
00206 41 bf 01 00 00
|
|
00 mov r15d, 1
|
|
$LN5@glfwPollMo:
|
|
|
|
; 169 : type = _GLFW_INSERT_FIRST;
|
|
; 170 :
|
|
; 171 : for (displayIndex = 0; ; displayIndex++)
|
|
; 172 : {
|
|
; 173 : ZeroMemory(&display, sizeof(display));
|
|
|
|
0020c 33 d2 xor edx, edx
|
|
0020e 48 8d 8c 24 74
|
|
03 00 00 lea rcx, QWORD PTR display$[rsp+4]
|
|
00216 41 b8 44 03 00
|
|
00 mov r8d, 836 ; 00000344H
|
|
0021c ff c5 inc ebp
|
|
0021e e8 00 00 00 00 call memset
|
|
|
|
; 174 : display.cb = sizeof(display);
|
|
; 175 :
|
|
; 176 : if (!EnumDisplayDevicesW(adapter.DeviceName, displayIndex, &display, 0))
|
|
|
|
00223 45 33 c9 xor r9d, r9d
|
|
00226 c7 84 24 70 03
|
|
00 00 48 03 00
|
|
00 mov DWORD PTR display$[rsp], 840 ; 00000348H
|
|
00231 4c 8d 84 24 70
|
|
03 00 00 lea r8, QWORD PTR display$[rsp]
|
|
00239 8b d5 mov edx, ebp
|
|
0023b 48 8d 4c 24 24 lea rcx, QWORD PTR adapter$[rsp+4]
|
|
00240 ff 15 00 00 00
|
|
00 call QWORD PTR __imp_EnumDisplayDevicesW
|
|
00246 85 c0 test eax, eax
|
|
00248 0f 85 02 ff ff
|
|
ff jne $LL7@glfwPollMo
|
|
|
|
; 208 : }
|
|
; 209 :
|
|
; 210 : // HACK: If an active adapter does not have any display devices
|
|
; 211 : // (as sometimes happens), add it directly as a monitor
|
|
; 212 : if (displayIndex == 0)
|
|
|
|
0024e 85 ed test ebp, ebp
|
|
00250 0f 85 78 00 00
|
|
00 jne $LN2@glfwPollMo
|
|
$LN75@glfwPollMo:
|
|
|
|
; 213 : {
|
|
; 214 : for (i = 0; i < disconnectedCount; i++)
|
|
|
|
00256 44 8b d6 mov r10d, esi
|
|
00259 4c 8b ce mov r9, rsi
|
|
0025c 45 85 e4 test r12d, r12d
|
|
0025f 7e 47 jle SHORT $LN79@glfwPollMo
|
|
$LL13@glfwPollMo:
|
|
|
|
; 215 : {
|
|
; 216 : if (disconnected[i] &&
|
|
|
|
00261 4b 8b 04 ce mov rax, QWORD PTR [r14+r9*8]
|
|
00265 4f 8d 1c ce lea r11, QWORD PTR [r14+r9*8]
|
|
00269 48 85 c0 test rax, rax
|
|
0026c 74 2a je SHORT $LN11@glfwPollMo
|
|
0026e 48 05 08 01 00
|
|
00 add rax, 264 ; 00000108H
|
|
00274 4c 8d 44 24 24 lea r8, QWORD PTR adapter$[rsp+4]
|
|
00279 4c 2b c0 sub r8, rax
|
|
0027c 0f 1f 40 00 npad 4
|
|
$LL81@glfwPollMo:
|
|
00280 0f b7 10 movzx edx, WORD PTR [rax]
|
|
00283 42 0f b7 0c 00 movzx ecx, WORD PTR [rax+r8]
|
|
00288 2b d1 sub edx, ecx
|
|
0028a 75 08 jne SHORT $LN82@glfwPollMo
|
|
0028c 48 83 c0 02 add rax, 2
|
|
00290 85 c9 test ecx, ecx
|
|
00292 75 ec jne SHORT $LL81@glfwPollMo
|
|
$LN82@glfwPollMo:
|
|
00294 85 d2 test edx, edx
|
|
00296 74 0d je SHORT $LN58@glfwPollMo
|
|
$LN11@glfwPollMo:
|
|
|
|
; 213 : {
|
|
; 214 : for (i = 0; i < disconnectedCount; i++)
|
|
|
|
00298 41 ff c2 inc r10d
|
|
0029b 49 ff c1 inc r9
|
|
0029e 4d 3b cc cmp r9, r12
|
|
002a1 7c be jl SHORT $LL13@glfwPollMo
|
|
002a3 eb 03 jmp SHORT $LN79@glfwPollMo
|
|
$LN58@glfwPollMo:
|
|
|
|
; 217 : wcscmp(disconnected[i]->win32.adapterName,
|
|
; 218 : adapter.DeviceName) == 0)
|
|
; 219 : {
|
|
; 220 : disconnected[i] = NULL;
|
|
|
|
002a5 49 89 33 mov QWORD PTR [r11], rsi
|
|
$LN79@glfwPollMo:
|
|
|
|
; 221 : break;
|
|
; 222 : }
|
|
; 223 : }
|
|
; 224 :
|
|
; 225 : if (i < disconnectedCount)
|
|
|
|
002a8 45 3b d4 cmp r10d, r12d
|
|
002ab 7c 21 jl SHORT $LN2@glfwPollMo
|
|
|
|
; 226 : continue;
|
|
; 227 :
|
|
; 228 : monitor = createMonitor(&adapter, NULL);
|
|
|
|
002ad 33 d2 xor edx, edx
|
|
002af 48 8d 4c 24 20 lea rcx, QWORD PTR adapter$[rsp]
|
|
002b4 e8 00 00 00 00 call createMonitor
|
|
|
|
; 229 : if (!monitor)
|
|
|
|
002b9 48 85 c0 test rax, rax
|
|
002bc 74 70 je SHORT $LN15@glfwPollMo
|
|
|
|
; 230 : {
|
|
; 231 : _glfw_free(disconnected);
|
|
; 232 : return;
|
|
; 233 : }
|
|
; 234 :
|
|
; 235 : _glfwInputMonitor(monitor, GLFW_CONNECTED, type);
|
|
|
|
002be 45 8b c7 mov r8d, r15d
|
|
002c1 ba 01 00 04 00 mov edx, 262145 ; 00040001H
|
|
002c6 48 8b c8 mov rcx, rax
|
|
002c9 e8 00 00 00 00 call _glfwInputMonitor
|
|
$LN2@glfwPollMo:
|
|
|
|
; 151 : _glfw.monitors,
|
|
; 152 : _glfw.monitorCount * sizeof(_GLFWmonitor*));
|
|
; 153 : }
|
|
; 154 :
|
|
; 155 : for (adapterIndex = 0; ; adapterIndex++)
|
|
; 156 : {
|
|
; 157 : int type = _GLFW_INSERT_LAST;
|
|
; 158 :
|
|
; 159 : ZeroMemory(&adapter, sizeof(adapter));
|
|
|
|
002ce 33 d2 xor edx, edx
|
|
002d0 48 8d 4c 24 24 lea rcx, QWORD PTR adapter$[rsp+4]
|
|
002d5 41 b8 44 03 00
|
|
00 mov r8d, 836 ; 00000344H
|
|
002db 41 ff c5 inc r13d
|
|
002de e8 00 00 00 00 call memset
|
|
|
|
; 160 : adapter.cb = sizeof(adapter);
|
|
; 161 :
|
|
; 162 : if (!EnumDisplayDevicesW(NULL, adapterIndex, &adapter, 0))
|
|
|
|
002e3 45 33 c9 xor r9d, r9d
|
|
002e6 c7 44 24 20 48
|
|
03 00 00 mov DWORD PTR adapter$[rsp], 840 ; 00000348H
|
|
002ee 4c 8d 44 24 20 lea r8, QWORD PTR adapter$[rsp]
|
|
002f3 41 8b d5 mov edx, r13d
|
|
002f6 33 c9 xor ecx, ecx
|
|
002f8 ff 15 00 00 00
|
|
00 call QWORD PTR __imp_EnumDisplayDevicesW
|
|
002fe 85 c0 test eax, eax
|
|
00300 0f 85 ea fd ff
|
|
ff jne $LL4@glfwPollMo
|
|
$LN59@glfwPollMo:
|
|
|
|
; 236 : }
|
|
; 237 : }
|
|
; 238 :
|
|
; 239 : for (i = 0; i < disconnectedCount; i++)
|
|
|
|
00306 45 85 e4 test r12d, r12d
|
|
00309 7e 23 jle SHORT $LN15@glfwPollMo
|
|
0030b 0f 1f 44 00 00 npad 5
|
|
$LL16@glfwPollMo:
|
|
|
|
; 240 : {
|
|
; 241 : if (disconnected[i])
|
|
|
|
00310 49 8b 0c f6 mov rcx, QWORD PTR [r14+rsi*8]
|
|
00314 48 85 c9 test rcx, rcx
|
|
00317 74 0d je SHORT $LN14@glfwPollMo
|
|
|
|
; 242 : _glfwInputMonitor(disconnected[i], GLFW_DISCONNECTED, 0);
|
|
|
|
00319 45 33 c0 xor r8d, r8d
|
|
0031c ba 02 00 04 00 mov edx, 262146 ; 00040002H
|
|
00321 e8 00 00 00 00 call _glfwInputMonitor
|
|
$LN14@glfwPollMo:
|
|
|
|
; 236 : }
|
|
; 237 : }
|
|
; 238 :
|
|
; 239 : for (i = 0; i < disconnectedCount; i++)
|
|
|
|
00326 48 ff c6 inc rsi
|
|
00329 49 3b f4 cmp rsi, r12
|
|
0032c 7c e2 jl SHORT $LL16@glfwPollMo
|
|
$LN15@glfwPollMo:
|
|
|
|
; 243 : }
|
|
; 244 :
|
|
; 245 : _glfw_free(disconnected);
|
|
; 246 : }
|
|
|
|
0032e 4d 85 f6 test r14, r14
|
|
00331 74 10 je SHORT $LN40@glfwPollMo
|
|
00333 48 8b 15 20 00
|
|
00 00 mov rdx, QWORD PTR _glfw+32
|
|
0033a 49 8b ce mov rcx, r14
|
|
0033d ff 15 18 00 00
|
|
00 call QWORD PTR _glfw+24
|
|
$LN40@glfwPollMo:
|
|
00343 4c 8b bc 24 08
|
|
07 00 00 mov r15, QWORD PTR [rsp+1800]
|
|
0034b 48 8b ac 24 00
|
|
07 00 00 mov rbp, QWORD PTR [rsp+1792]
|
|
00353 48 8b 8c 24 c0
|
|
06 00 00 mov rcx, QWORD PTR __$ArrayPad$[rsp]
|
|
0035b 48 33 cc xor rcx, rsp
|
|
0035e e8 00 00 00 00 call __security_check_cookie
|
|
00363 48 8b 9c 24 10
|
|
07 00 00 mov rbx, QWORD PTR [rsp+1808]
|
|
0036b 48 81 c4 d0 06
|
|
00 00 add rsp, 1744 ; 000006d0H
|
|
00372 41 5e pop r14
|
|
00374 41 5d pop r13
|
|
00376 41 5c pop r12
|
|
00378 5f pop rdi
|
|
00379 5e pop rsi
|
|
0037a c3 ret 0
|
|
_glfwPollMonitorsWin32 ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
; COMDAT _glfwSetGammaRampWin32
|
|
_TEXT SEGMENT
|
|
values$ = 32
|
|
__$ArrayPad$ = 1568
|
|
monitor$ = 1600
|
|
ramp$ = 1608
|
|
_glfwSetGammaRampWin32 PROC ; COMDAT
|
|
|
|
; 511 : {
|
|
|
|
$LN12:
|
|
00000 48 81 ec 38 06
|
|
00 00 sub rsp, 1592 ; 00000638H
|
|
00007 48 8b 05 00 00
|
|
00 00 mov rax, QWORD PTR __security_cookie
|
|
0000e 48 33 c4 xor rax, rsp
|
|
00011 48 89 84 24 20
|
|
06 00 00 mov QWORD PTR __$ArrayPad$[rsp], rax
|
|
|
|
; 512 : HDC dc;
|
|
; 513 : WORD values[3][256];
|
|
; 514 :
|
|
; 515 : if (ramp->size != 256)
|
|
|
|
00019 81 7a 18 00 01
|
|
00 00 cmp DWORD PTR [rdx+24], 256 ; 00000100H
|
|
00020 4c 8b c2 mov r8, rdx
|
|
00023 4c 8b d1 mov r10, rcx
|
|
00026 74 29 je SHORT $LN2@glfwSetGam
|
|
|
|
; 516 : {
|
|
; 517 : _glfwInputError(GLFW_PLATFORM_ERROR,
|
|
|
|
00028 48 8d 15 00 00
|
|
00 00 lea rdx, OFFSET FLAT:??_C@_0CD@EGEEPFHF@Win32?3?5Gamma?5ramp?5size?5must?5be?5@
|
|
0002f b9 08 00 01 00 mov ecx, 65544 ; 00010008H
|
|
00034 e8 00 00 00 00 call _glfwInputError
|
|
|
|
; 529 : }
|
|
|
|
00039 48 8b 8c 24 20
|
|
06 00 00 mov rcx, QWORD PTR __$ArrayPad$[rsp]
|
|
00041 48 33 cc xor rcx, rsp
|
|
00044 e8 00 00 00 00 call __security_check_cookie
|
|
00049 48 81 c4 38 06
|
|
00 00 add rsp, 1592 ; 00000638H
|
|
00050 c3 ret 0
|
|
$LN2@glfwSetGam:
|
|
|
|
; 518 : "Win32: Gamma ramp size must be 256");
|
|
; 519 : return;
|
|
; 520 : }
|
|
; 521 :
|
|
; 522 : memcpy(values[0], ramp->red, sizeof(values[0]));
|
|
|
|
00051 48 8b 02 mov rax, QWORD PTR [rdx]
|
|
00054 48 8d 4c 24 20 lea rcx, QWORD PTR values$[rsp]
|
|
00059 ba 04 00 00 00 mov edx, 4
|
|
0005e 48 89 9c 24 30
|
|
06 00 00 mov QWORD PTR [rsp+1584], rbx
|
|
00066 44 8b ca mov r9d, edx
|
|
00069 0f 1f 80 00 00
|
|
00 00 npad 7
|
|
$LL6@glfwSetGam:
|
|
00070 48 8d 89 80 00
|
|
00 00 lea rcx, QWORD PTR [rcx+128]
|
|
00077 0f 10 00 movups xmm0, XMMWORD PTR [rax]
|
|
0007a 48 8d 80 80 00
|
|
00 00 lea rax, QWORD PTR [rax+128]
|
|
00081 0f 11 41 80 movups XMMWORD PTR [rcx-128], xmm0
|
|
00085 0f 10 48 90 movups xmm1, XMMWORD PTR [rax-112]
|
|
00089 0f 11 49 90 movups XMMWORD PTR [rcx-112], xmm1
|
|
0008d 0f 10 40 a0 movups xmm0, XMMWORD PTR [rax-96]
|
|
00091 0f 11 41 a0 movups XMMWORD PTR [rcx-96], xmm0
|
|
00095 0f 10 48 b0 movups xmm1, XMMWORD PTR [rax-80]
|
|
00099 0f 11 49 b0 movups XMMWORD PTR [rcx-80], xmm1
|
|
0009d 0f 10 40 c0 movups xmm0, XMMWORD PTR [rax-64]
|
|
000a1 0f 11 41 c0 movups XMMWORD PTR [rcx-64], xmm0
|
|
000a5 0f 10 48 d0 movups xmm1, XMMWORD PTR [rax-48]
|
|
000a9 0f 11 49 d0 movups XMMWORD PTR [rcx-48], xmm1
|
|
000ad 0f 10 40 e0 movups xmm0, XMMWORD PTR [rax-32]
|
|
000b1 0f 11 41 e0 movups XMMWORD PTR [rcx-32], xmm0
|
|
000b5 0f 10 48 f0 movups xmm1, XMMWORD PTR [rax-16]
|
|
000b9 0f 11 49 f0 movups XMMWORD PTR [rcx-16], xmm1
|
|
000bd 49 83 e9 01 sub r9, 1
|
|
000c1 75 ad jne SHORT $LL6@glfwSetGam
|
|
|
|
; 523 : memcpy(values[1], ramp->green, sizeof(values[1]));
|
|
|
|
000c3 49 8b 40 08 mov rax, QWORD PTR [r8+8]
|
|
000c7 48 8d 8c 24 20
|
|
02 00 00 lea rcx, QWORD PTR values$[rsp+512]
|
|
000cf 4c 8b ca mov r9, rdx
|
|
$LL5@glfwSetGam:
|
|
000d2 48 8d 89 80 00
|
|
00 00 lea rcx, QWORD PTR [rcx+128]
|
|
000d9 0f 10 00 movups xmm0, XMMWORD PTR [rax]
|
|
000dc 48 8d 80 80 00
|
|
00 00 lea rax, QWORD PTR [rax+128]
|
|
000e3 0f 11 41 80 movups XMMWORD PTR [rcx-128], xmm0
|
|
000e7 0f 10 48 90 movups xmm1, XMMWORD PTR [rax-112]
|
|
000eb 0f 11 49 90 movups XMMWORD PTR [rcx-112], xmm1
|
|
000ef 0f 10 40 a0 movups xmm0, XMMWORD PTR [rax-96]
|
|
000f3 0f 11 41 a0 movups XMMWORD PTR [rcx-96], xmm0
|
|
000f7 0f 10 48 b0 movups xmm1, XMMWORD PTR [rax-80]
|
|
000fb 0f 11 49 b0 movups XMMWORD PTR [rcx-80], xmm1
|
|
000ff 0f 10 40 c0 movups xmm0, XMMWORD PTR [rax-64]
|
|
00103 0f 11 41 c0 movups XMMWORD PTR [rcx-64], xmm0
|
|
00107 0f 10 48 d0 movups xmm1, XMMWORD PTR [rax-48]
|
|
0010b 0f 11 49 d0 movups XMMWORD PTR [rcx-48], xmm1
|
|
0010f 0f 10 40 e0 movups xmm0, XMMWORD PTR [rax-32]
|
|
00113 0f 11 41 e0 movups XMMWORD PTR [rcx-32], xmm0
|
|
00117 0f 10 48 f0 movups xmm1, XMMWORD PTR [rax-16]
|
|
0011b 0f 11 49 f0 movups XMMWORD PTR [rcx-16], xmm1
|
|
0011f 49 83 e9 01 sub r9, 1
|
|
00123 75 ad jne SHORT $LL5@glfwSetGam
|
|
|
|
; 524 : memcpy(values[2], ramp->blue, sizeof(values[2]));
|
|
|
|
00125 49 8b 48 10 mov rcx, QWORD PTR [r8+16]
|
|
00129 48 8d 84 24 20
|
|
04 00 00 lea rax, QWORD PTR values$[rsp+1024]
|
|
$LL4@glfwSetGam:
|
|
00131 48 8d 80 80 00
|
|
00 00 lea rax, QWORD PTR [rax+128]
|
|
00138 0f 10 01 movups xmm0, XMMWORD PTR [rcx]
|
|
0013b 48 8d 89 80 00
|
|
00 00 lea rcx, QWORD PTR [rcx+128]
|
|
00142 0f 11 40 80 movups XMMWORD PTR [rax-128], xmm0
|
|
00146 0f 10 49 90 movups xmm1, XMMWORD PTR [rcx-112]
|
|
0014a 0f 11 48 90 movups XMMWORD PTR [rax-112], xmm1
|
|
0014e 0f 10 41 a0 movups xmm0, XMMWORD PTR [rcx-96]
|
|
00152 0f 11 40 a0 movups XMMWORD PTR [rax-96], xmm0
|
|
00156 0f 10 49 b0 movups xmm1, XMMWORD PTR [rcx-80]
|
|
0015a 0f 11 48 b0 movups XMMWORD PTR [rax-80], xmm1
|
|
0015e 0f 10 41 c0 movups xmm0, XMMWORD PTR [rcx-64]
|
|
00162 0f 11 40 c0 movups XMMWORD PTR [rax-64], xmm0
|
|
00166 0f 10 49 d0 movups xmm1, XMMWORD PTR [rcx-48]
|
|
0016a 0f 11 48 d0 movups XMMWORD PTR [rax-48], xmm1
|
|
0016e 0f 10 41 e0 movups xmm0, XMMWORD PTR [rcx-32]
|
|
00172 0f 11 40 e0 movups XMMWORD PTR [rax-32], xmm0
|
|
00176 0f 10 49 f0 movups xmm1, XMMWORD PTR [rcx-16]
|
|
0017a 0f 11 48 f0 movups XMMWORD PTR [rax-16], xmm1
|
|
0017e 48 83 ea 01 sub rdx, 1
|
|
00182 75 ad jne SHORT $LL4@glfwSetGam
|
|
|
|
; 525 :
|
|
; 526 : dc = CreateDCW(L"DISPLAY", monitor->win32.adapterName, NULL, NULL);
|
|
|
|
00184 49 8d 92 08 01
|
|
00 00 lea rdx, QWORD PTR [r10+264]
|
|
0018b 45 33 c9 xor r9d, r9d
|
|
0018e 45 33 c0 xor r8d, r8d
|
|
00191 48 8d 0d 00 00
|
|
00 00 lea rcx, OFFSET FLAT:??_C@_1BA@PICGEGJB@?$AAD?$AAI?$AAS?$AAP?$AAL?$AAA?$AAY@
|
|
00198 ff 15 00 00 00
|
|
00 call QWORD PTR __imp_CreateDCW
|
|
|
|
; 527 : SetDeviceGammaRamp(dc, values);
|
|
|
|
0019e 48 8b c8 mov rcx, rax
|
|
001a1 48 8d 54 24 20 lea rdx, QWORD PTR values$[rsp]
|
|
001a6 48 8b d8 mov rbx, rax
|
|
001a9 ff 15 00 00 00
|
|
00 call QWORD PTR __imp_SetDeviceGammaRamp
|
|
|
|
; 528 : DeleteDC(dc);
|
|
|
|
001af 48 8b cb mov rcx, rbx
|
|
001b2 ff 15 00 00 00
|
|
00 call QWORD PTR __imp_DeleteDC
|
|
001b8 48 8b 9c 24 30
|
|
06 00 00 mov rbx, QWORD PTR [rsp+1584]
|
|
|
|
; 529 : }
|
|
|
|
001c0 48 8b 8c 24 20
|
|
06 00 00 mov rcx, QWORD PTR __$ArrayPad$[rsp]
|
|
001c8 48 33 cc xor rcx, rsp
|
|
001cb e8 00 00 00 00 call __security_check_cookie
|
|
001d0 48 81 c4 38 06
|
|
00 00 add rsp, 1592 ; 00000638H
|
|
001d7 c3 ret 0
|
|
_glfwSetGammaRampWin32 ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
; COMDAT _glfwGetMonitorContentScaleWin32
|
|
_TEXT SEGMENT
|
|
monitor$ = 8
|
|
xscale$ = 16
|
|
yscale$ = 24
|
|
_glfwGetMonitorContentScaleWin32 PROC ; COMDAT
|
|
|
|
; 378 : _glfwGetHMONITORContentScaleWin32(monitor->win32.handle, xscale, yscale);
|
|
|
|
00000 48 8b 89 00 01
|
|
00 00 mov rcx, QWORD PTR [rcx+256]
|
|
00007 e9 00 00 00 00 jmp _glfwGetHMONITORContentScaleWin32
|
|
_glfwGetMonitorContentScaleWin32 ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
; COMDAT _glfwFreeMonitorWin32
|
|
_TEXT SEGMENT
|
|
monitor$ = 8
|
|
_glfwFreeMonitorWin32 PROC ; COMDAT
|
|
|
|
; 356 : }
|
|
|
|
00000 c2 00 00 ret 0
|
|
_glfwFreeMonitorWin32 ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
; COMDAT monitorCallback
|
|
_TEXT SEGMENT
|
|
mi$ = 32
|
|
__$ArrayPad$ = 144
|
|
handle$ = 176
|
|
dc$ = 184
|
|
rect$ = 192
|
|
data$ = 200
|
|
monitorCallback PROC ; COMDAT
|
|
|
|
; 46 : {
|
|
|
|
00000 48 89 5c 24 10 mov QWORD PTR [rsp+16], rbx
|
|
00005 57 push rdi
|
|
00006 48 81 ec a0 00
|
|
00 00 sub rsp, 160 ; 000000a0H
|
|
0000d 48 8b 05 00 00
|
|
00 00 mov rax, QWORD PTR __security_cookie
|
|
00014 48 33 c4 xor rax, rsp
|
|
00017 48 89 84 24 90
|
|
00 00 00 mov QWORD PTR __$ArrayPad$[rsp], rax
|
|
0001f 0f 57 c0 xorps xmm0, xmm0
|
|
|
|
; 47 : MONITORINFOEXW mi;
|
|
; 48 : ZeroMemory(&mi, sizeof(mi));
|
|
; 49 : mi.cbSize = sizeof(mi);
|
|
|
|
00022 c7 44 24 20 68
|
|
00 00 00 mov DWORD PTR mi$[rsp], 104 ; 00000068H
|
|
0002a 33 c0 xor eax, eax
|
|
|
|
; 50 :
|
|
; 51 : if (GetMonitorInfoW(handle, (MONITORINFO*) &mi))
|
|
|
|
0002c 48 8d 54 24 20 lea rdx, QWORD PTR mi$[rsp]
|
|
00031 0f 11 44 24 24 movups XMMWORD PTR mi$[rsp+4], xmm0
|
|
00036 89 84 24 84 00
|
|
00 00 mov DWORD PTR mi$[rsp+100], eax
|
|
0003d 49 8b d9 mov rbx, r9
|
|
00040 0f 11 44 24 34 movups XMMWORD PTR mi$[rsp+20], xmm0
|
|
00045 48 8b f9 mov rdi, rcx
|
|
00048 0f 11 44 24 44 movups XMMWORD PTR mi$[rsp+36], xmm0
|
|
0004d 0f 11 44 24 54 movups XMMWORD PTR mi$[rsp+52], xmm0
|
|
00052 0f 11 44 24 64 movups XMMWORD PTR mi$[rsp+68], xmm0
|
|
00057 0f 11 44 24 74 movups XMMWORD PTR mi$[rsp+84], xmm0
|
|
0005c ff 15 00 00 00
|
|
00 call QWORD PTR __imp_GetMonitorInfoW
|
|
00062 85 c0 test eax, eax
|
|
00064 74 40 je SHORT $LN8@monitorCal
|
|
|
|
; 52 : {
|
|
; 53 : _GLFWmonitor* monitor = (_GLFWmonitor*) data;
|
|
; 54 : if (wcscmp(mi.szDevice, monitor->win32.adapterName) == 0)
|
|
|
|
00066 4c 8d 83 08 01
|
|
00 00 lea r8, QWORD PTR [rbx+264]
|
|
0006d 48 8d 44 24 48 lea rax, QWORD PTR mi$[rsp+40]
|
|
00072 4c 2b c0 sub r8, rax
|
|
00075 66 66 66 0f 1f
|
|
84 00 00 00 00
|
|
00 npad 11
|
|
$LL5@monitorCal:
|
|
00080 0f b7 10 movzx edx, WORD PTR [rax]
|
|
00083 42 0f b7 0c 00 movzx ecx, WORD PTR [rax+r8]
|
|
00088 2b d1 sub edx, ecx
|
|
0008a 75 08 jne SHORT $LN6@monitorCal
|
|
0008c 48 83 c0 02 add rax, 2
|
|
00090 85 c9 test ecx, ecx
|
|
00092 75 ec jne SHORT $LL5@monitorCal
|
|
$LN6@monitorCal:
|
|
00094 b8 01 00 00 00 mov eax, 1
|
|
00099 85 d2 test edx, edx
|
|
0009b 75 0e jne SHORT $LN3@monitorCal
|
|
|
|
; 55 : monitor->win32.handle = handle;
|
|
|
|
0009d 48 89 bb 00 01
|
|
00 00 mov QWORD PTR [rbx+256], rdi
|
|
000a4 eb 05 jmp SHORT $LN3@monitorCal
|
|
$LN8@monitorCal:
|
|
|
|
; 56 : }
|
|
; 57 :
|
|
; 58 : return TRUE;
|
|
|
|
000a6 b8 01 00 00 00 mov eax, 1
|
|
$LN3@monitorCal:
|
|
|
|
; 59 : }
|
|
|
|
000ab 48 8b 8c 24 90
|
|
00 00 00 mov rcx, QWORD PTR __$ArrayPad$[rsp]
|
|
000b3 48 33 cc xor rcx, rsp
|
|
000b6 e8 00 00 00 00 call __security_check_cookie
|
|
000bb 48 8b 9c 24 b8
|
|
00 00 00 mov rbx, QWORD PTR [rsp+184]
|
|
000c3 48 81 c4 a0 00
|
|
00 00 add rsp, 160 ; 000000a0H
|
|
000ca 5f pop rdi
|
|
000cb c3 ret 0
|
|
monitorCallback ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
; COMDAT createMonitor
|
|
_TEXT SEGMENT
|
|
rect$ = 64
|
|
dm$ = 80
|
|
__$ArrayPad$ = 304
|
|
adapter$ = 384
|
|
display$ = 392
|
|
createMonitor PROC ; COMDAT
|
|
|
|
; 65 : {
|
|
|
|
00000 40 55 push rbp
|
|
00002 56 push rsi
|
|
00003 41 56 push r14
|
|
00005 48 81 ec 60 01
|
|
00 00 sub rsp, 352 ; 00000160H
|
|
0000c 48 8b 05 00 00
|
|
00 00 mov rax, QWORD PTR __security_cookie
|
|
00013 48 33 c4 xor rax, rsp
|
|
00016 48 89 84 24 30
|
|
01 00 00 mov QWORD PTR __$ArrayPad$[rsp], rax
|
|
0001e 4c 8b f1 mov r14, rcx
|
|
|
|
; 66 : _GLFWmonitor* monitor;
|
|
; 67 : int widthMM, heightMM;
|
|
; 68 : char* name;
|
|
; 69 : HDC dc;
|
|
; 70 : DEVMODEW dm;
|
|
; 71 : RECT rect;
|
|
; 72 :
|
|
; 73 : if (display)
|
|
; 74 : name = _glfwCreateUTF8FromWideStringWin32(display->DeviceString);
|
|
; 75 : else
|
|
; 76 : name = _glfwCreateUTF8FromWideStringWin32(adapter->DeviceString);
|
|
; 77 : if (!name)
|
|
|
|
00021 48 85 d2 test rdx, rdx
|
|
00024 48 8b ca mov rcx, rdx
|
|
00027 48 8b f2 mov rsi, rdx
|
|
0002a 49 0f 44 ce cmove rcx, r14
|
|
0002e 48 83 c1 44 add rcx, 68 ; 00000044H
|
|
00032 e8 00 00 00 00 call _glfwCreateUTF8FromWideStringWin32
|
|
00037 48 8b e8 mov rbp, rax
|
|
0003a 48 85 c0 test rax, rax
|
|
0003d 0f 84 81 02 00
|
|
00 je $LN1@createMoni
|
|
$LN4@createMoni:
|
|
00043 48 89 9c 24 90
|
|
01 00 00 mov QWORD PTR [rsp+400], rbx
|
|
|
|
; 78 : return NULL;
|
|
; 79 :
|
|
; 80 : ZeroMemory(&dm, sizeof(dm));
|
|
|
|
0004b 48 8d 4c 24 50 lea rcx, QWORD PTR dm$[rsp]
|
|
00050 48 89 bc 24 98
|
|
01 00 00 mov QWORD PTR [rsp+408], rdi
|
|
00058 bb dc 00 00 00 mov ebx, 220 ; 000000dcH
|
|
0005d 44 8b c3 mov r8d, ebx
|
|
00060 4c 89 a4 24 58
|
|
01 00 00 mov QWORD PTR [rsp+344], r12
|
|
00068 33 d2 xor edx, edx
|
|
0006a 4c 89 bc 24 50
|
|
01 00 00 mov QWORD PTR [rsp+336], r15
|
|
00072 e8 00 00 00 00 call memset
|
|
|
|
; 81 : dm.dmSize = sizeof(dm);
|
|
; 82 : EnumDisplaySettingsW(adapter->DeviceName, ENUM_CURRENT_SETTINGS, &dm);
|
|
|
|
00077 49 8d 7e 04 lea rdi, QWORD PTR [r14+4]
|
|
0007b 66 89 9c 24 94
|
|
00 00 00 mov WORD PTR dm$[rsp+68], bx
|
|
00083 48 8b cf mov rcx, rdi
|
|
00086 4c 8d 44 24 50 lea r8, QWORD PTR dm$[rsp]
|
|
0008b ba ff ff ff ff mov edx, -1 ; ffffffffH
|
|
00090 ff 15 00 00 00
|
|
00 call QWORD PTR __imp_EnumDisplaySettingsW
|
|
|
|
; 83 :
|
|
; 84 : dc = CreateDCW(L"DISPLAY", adapter->DeviceName, NULL, NULL);
|
|
|
|
00096 45 33 c9 xor r9d, r9d
|
|
00099 48 8d 0d 00 00
|
|
00 00 lea rcx, OFFSET FLAT:??_C@_1BA@PICGEGJB@?$AAD?$AAI?$AAS?$AAP?$AAL?$AAA?$AAY@
|
|
000a0 45 33 c0 xor r8d, r8d
|
|
000a3 48 8b d7 mov rdx, rdi
|
|
000a6 ff 15 00 00 00
|
|
00 call QWORD PTR __imp_CreateDCW
|
|
|
|
; 85 :
|
|
; 86 : if (IsWindows8Point1OrGreater())
|
|
|
|
000ac ba 03 00 00 00 mov edx, 3
|
|
000b1 48 8b d8 mov rbx, rax
|
|
000b4 e8 00 00 00 00 call _glfwIsWindowsVersionOrGreaterWin32
|
|
000b9 48 8b cb mov rcx, rbx
|
|
000bc 85 c0 test eax, eax
|
|
000be 74 21 je SHORT $LN5@createMoni
|
|
|
|
; 87 : {
|
|
; 88 : widthMM = GetDeviceCaps(dc, HORZSIZE);
|
|
|
|
000c0 ba 04 00 00 00 mov edx, 4
|
|
000c5 ff 15 00 00 00
|
|
00 call QWORD PTR __imp_GetDeviceCaps
|
|
|
|
; 89 : heightMM = GetDeviceCaps(dc, VERTSIZE);
|
|
|
|
000cb ba 06 00 00 00 mov edx, 6
|
|
000d0 48 8b cb mov rcx, rbx
|
|
000d3 44 8b f8 mov r15d, eax
|
|
000d6 ff 15 00 00 00
|
|
00 call QWORD PTR __imp_GetDeviceCaps
|
|
000dc 44 8b e0 mov r12d, eax
|
|
|
|
; 90 : }
|
|
|
|
000df eb 77 jmp SHORT $LN6@createMoni
|
|
$LN5@createMoni:
|
|
|
|
; 91 : else
|
|
; 92 : {
|
|
; 93 : widthMM = (int) (dm.dmPelsWidth * 25.4f / GetDeviceCaps(dc, LOGPIXELSX));
|
|
|
|
000e1 8b 84 24 fc 00
|
|
00 00 mov eax, DWORD PTR dm$[rsp+172]
|
|
000e8 ba 58 00 00 00 mov edx, 88 ; 00000058H
|
|
000ed 0f 29 b4 24 40
|
|
01 00 00 movaps XMMWORD PTR [rsp+320], xmm6
|
|
000f5 0f 57 f6 xorps xmm6, xmm6
|
|
000f8 f3 48 0f 2a f0 cvtsi2ss xmm6, rax
|
|
000fd f3 0f 59 35 00
|
|
00 00 00 mulss xmm6, DWORD PTR __real@41cb3333
|
|
00105 ff 15 00 00 00
|
|
00 call QWORD PTR __imp_GetDeviceCaps
|
|
|
|
; 94 : heightMM = (int) (dm.dmPelsHeight * 25.4f / GetDeviceCaps(dc, LOGPIXELSY));
|
|
|
|
0010b ba 5a 00 00 00 mov edx, 90 ; 0000005aH
|
|
00110 48 8b cb mov rcx, rbx
|
|
00113 66 0f 6e c0 movd xmm0, eax
|
|
00117 8b 84 24 00 01
|
|
00 00 mov eax, DWORD PTR dm$[rsp+176]
|
|
0011e 0f 5b c0 cvtdq2ps xmm0, xmm0
|
|
00121 f3 0f 5e f0 divss xmm6, xmm0
|
|
00125 f3 44 0f 2c fe cvttss2si r15d, xmm6
|
|
0012a 0f 57 f6 xorps xmm6, xmm6
|
|
0012d f3 48 0f 2a f0 cvtsi2ss xmm6, rax
|
|
00132 f3 0f 59 35 00
|
|
00 00 00 mulss xmm6, DWORD PTR __real@41cb3333
|
|
0013a ff 15 00 00 00
|
|
00 call QWORD PTR __imp_GetDeviceCaps
|
|
00140 66 0f 6e c0 movd xmm0, eax
|
|
00144 0f 5b c0 cvtdq2ps xmm0, xmm0
|
|
00147 f3 0f 5e f0 divss xmm6, xmm0
|
|
0014b f3 44 0f 2c e6 cvttss2si r12d, xmm6
|
|
00150 0f 28 b4 24 40
|
|
01 00 00 movaps xmm6, XMMWORD PTR [rsp+320]
|
|
$LN6@createMoni:
|
|
|
|
; 95 : }
|
|
; 96 :
|
|
; 97 : DeleteDC(dc);
|
|
|
|
00158 48 8b cb mov rcx, rbx
|
|
0015b ff 15 00 00 00
|
|
00 call QWORD PTR __imp_DeleteDC
|
|
|
|
; 99 : monitor = _glfwAllocMonitor(name, widthMM, heightMM);
|
|
|
|
00161 45 8b c4 mov r8d, r12d
|
|
00164 41 8b d7 mov edx, r15d
|
|
00167 48 8b cd mov rcx, rbp
|
|
0016a e8 00 00 00 00 call _glfwAllocMonitor
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 321 : _glfw.allocator.deallocate(block, _glfw.allocator.user);
|
|
|
|
0016f 48 8b 15 20 00
|
|
00 00 mov rdx, QWORD PTR _glfw+32
|
|
00176 48 8b cd mov rcx, rbp
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
|
|
; 99 : monitor = _glfwAllocMonitor(name, widthMM, heightMM);
|
|
|
|
00179 48 8b d8 mov rbx, rax
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 321 : _glfw.allocator.deallocate(block, _glfw.allocator.user);
|
|
|
|
0017c ff 15 18 00 00
|
|
00 call QWORD PTR _glfw+24
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
|
|
; 102 : if (adapter->StateFlags & DISPLAY_DEVICE_MODESPRUNED)
|
|
|
|
00182 41 f7 86 44 01
|
|
00 00 00 00 00
|
|
08 test DWORD PTR [r14+324], 134217728 ; 08000000H
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 321 : _glfw.allocator.deallocate(block, _glfw.allocator.user);
|
|
|
|
0018d 4c 8b bc 24 50
|
|
01 00 00 mov r15, QWORD PTR [rsp+336]
|
|
00195 4c 8b a4 24 58
|
|
01 00 00 mov r12, QWORD PTR [rsp+344]
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
|
|
; 102 : if (adapter->StateFlags & DISPLAY_DEVICE_MODESPRUNED)
|
|
|
|
0019d 74 0a je SHORT $LN7@createMoni
|
|
|
|
; 103 : monitor->win32.modesPruned = GLFW_TRUE;
|
|
|
|
0019f c7 83 c8 01 00
|
|
00 01 00 00 00 mov DWORD PTR [rbx+456], 1
|
|
$LN7@createMoni:
|
|
|
|
; 104 :
|
|
; 105 : wcscpy(monitor->win32.adapterName, adapter->DeviceName);
|
|
|
|
001a9 48 8b d3 mov rdx, rbx
|
|
001ac 48 8b cf mov rcx, rdi
|
|
001af 48 2b d7 sub rdx, rdi
|
|
001b2 0f 1f 40 00 66
|
|
66 0f 1f 84 00
|
|
00 00 00 00 npad 14
|
|
$LL10@createMoni:
|
|
001c0 0f b7 01 movzx eax, WORD PTR [rcx]
|
|
001c3 66 89 84 0a 08
|
|
01 00 00 mov WORD PTR [rdx+rcx+264], ax
|
|
001cb 48 8d 49 02 lea rcx, QWORD PTR [rcx+2]
|
|
001cf 66 85 c0 test ax, ax
|
|
001d2 75 ec jne SHORT $LL10@createMoni
|
|
|
|
; 106 : WideCharToMultiByte(CP_UTF8, 0,
|
|
|
|
001d4 33 ed xor ebp, ebp
|
|
001d6 48 8d 83 88 01
|
|
00 00 lea rax, QWORD PTR [rbx+392]
|
|
001dd 48 89 6c 24 38 mov QWORD PTR [rsp+56], rbp
|
|
001e2 4c 8b c7 mov r8, rdi
|
|
001e5 48 89 6c 24 30 mov QWORD PTR [rsp+48], rbp
|
|
001ea 33 d2 xor edx, edx
|
|
001ec c7 44 24 28 20
|
|
00 00 00 mov DWORD PTR [rsp+40], 32 ; 00000020H
|
|
001f4 b9 e9 fd 00 00 mov ecx, 65001 ; 0000fde9H
|
|
001f9 44 8d 4d ff lea r9d, QWORD PTR [rbp-1]
|
|
001fd 48 89 44 24 20 mov QWORD PTR [rsp+32], rax
|
|
00202 ff 15 00 00 00
|
|
00 call QWORD PTR __imp_WideCharToMultiByte
|
|
00208 48 8b bc 24 98
|
|
01 00 00 mov rdi, QWORD PTR [rsp+408]
|
|
|
|
; 107 : adapter->DeviceName, -1,
|
|
; 108 : monitor->win32.publicAdapterName,
|
|
; 109 : sizeof(monitor->win32.publicAdapterName),
|
|
; 110 : NULL, NULL);
|
|
; 111 :
|
|
; 112 : if (display)
|
|
|
|
00210 48 85 f6 test rsi, rsi
|
|
00213 74 5f je SHORT $LN8@createMoni
|
|
|
|
; 113 : {
|
|
; 114 : wcscpy(monitor->win32.displayName, display->DeviceName);
|
|
|
|
00215 4c 8d 46 04 lea r8, QWORD PTR [rsi+4]
|
|
00219 4c 8b d3 mov r10, rbx
|
|
0021c 49 8b d0 mov rdx, r8
|
|
0021f 4d 2b d0 sub r10, r8
|
|
00222 0f 1f 40 00 66
|
|
66 0f 1f 84 00
|
|
00 00 00 00 npad 14
|
|
$LL11@createMoni:
|
|
00230 0f b7 02 movzx eax, WORD PTR [rdx]
|
|
00233 66 41 89 84 12
|
|
48 01 00 00 mov WORD PTR [r10+rdx+328], ax
|
|
0023c 48 8d 52 02 lea rdx, QWORD PTR [rdx+2]
|
|
00240 66 85 c0 test ax, ax
|
|
00243 75 eb jne SHORT $LL11@createMoni
|
|
|
|
; 115 : WideCharToMultiByte(CP_UTF8, 0,
|
|
|
|
00245 48 89 6c 24 38 mov QWORD PTR [rsp+56], rbp
|
|
0024a 48 8d 83 a8 01
|
|
00 00 lea rax, QWORD PTR [rbx+424]
|
|
00251 33 d2 xor edx, edx
|
|
00253 48 89 6c 24 30 mov QWORD PTR [rsp+48], rbp
|
|
00258 c7 44 24 28 20
|
|
00 00 00 mov DWORD PTR [rsp+40], 32 ; 00000020H
|
|
00260 b9 e9 fd 00 00 mov ecx, 65001 ; 0000fde9H
|
|
00265 48 89 44 24 20 mov QWORD PTR [rsp+32], rax
|
|
0026a 44 8d 4a ff lea r9d, QWORD PTR [rdx-1]
|
|
0026e ff 15 00 00 00
|
|
00 call QWORD PTR __imp_WideCharToMultiByte
|
|
$LN8@createMoni:
|
|
|
|
; 116 : display->DeviceName, -1,
|
|
; 117 : monitor->win32.publicDisplayName,
|
|
; 118 : sizeof(monitor->win32.publicDisplayName),
|
|
; 119 : NULL, NULL);
|
|
; 120 : }
|
|
; 121 :
|
|
; 122 : rect.left = dm.dmPosition.x;
|
|
|
|
00274 8b 8c 24 9c 00
|
|
00 00 mov ecx, DWORD PTR dm$[rsp+76]
|
|
|
|
; 123 : rect.top = dm.dmPosition.y;
|
|
; 124 : rect.right = dm.dmPosition.x + dm.dmPelsWidth;
|
|
; 125 : rect.bottom = dm.dmPosition.y + dm.dmPelsHeight;
|
|
; 126 :
|
|
; 127 : EnumDisplayMonitors(NULL, &rect, monitorCallback, (LPARAM) monitor);
|
|
|
|
0027b 4c 8d 05 00 00
|
|
00 00 lea r8, OFFSET FLAT:monitorCallback
|
|
00282 8b 94 24 a0 00
|
|
00 00 mov edx, DWORD PTR dm$[rsp+80]
|
|
00289 4c 8b cb mov r9, rbx
|
|
0028c 89 4c 24 40 mov DWORD PTR rect$[rsp], ecx
|
|
00290 03 8c 24 fc 00
|
|
00 00 add ecx, DWORD PTR dm$[rsp+172]
|
|
00297 89 4c 24 48 mov DWORD PTR rect$[rsp+8], ecx
|
|
0029b 8b 8c 24 00 01
|
|
00 00 mov ecx, DWORD PTR dm$[rsp+176]
|
|
002a2 03 ca add ecx, edx
|
|
002a4 89 54 24 44 mov DWORD PTR rect$[rsp+4], edx
|
|
002a8 89 4c 24 4c mov DWORD PTR rect$[rsp+12], ecx
|
|
002ac 48 8d 54 24 40 lea rdx, QWORD PTR rect$[rsp]
|
|
002b1 33 c9 xor ecx, ecx
|
|
002b3 ff 15 00 00 00
|
|
00 call QWORD PTR __imp_EnumDisplayMonitors
|
|
|
|
; 128 : return monitor;
|
|
|
|
002b9 48 8b c3 mov rax, rbx
|
|
002bc 48 8b 9c 24 90
|
|
01 00 00 mov rbx, QWORD PTR [rsp+400]
|
|
$LN1@createMoni:
|
|
|
|
; 129 : }
|
|
|
|
002c4 48 8b 8c 24 30
|
|
01 00 00 mov rcx, QWORD PTR __$ArrayPad$[rsp]
|
|
002cc 48 33 cc xor rcx, rsp
|
|
002cf e8 00 00 00 00 call __security_check_cookie
|
|
002d4 48 81 c4 60 01
|
|
00 00 add rsp, 352 ; 00000160H
|
|
002db 41 5e pop r14
|
|
002dd 5e pop rsi
|
|
002de 5d pop rbp
|
|
002df c3 ret 0
|
|
createMonitor ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
; COMDAT _glfwSetVideoModeWin32
|
|
_TEXT SEGMENT
|
|
current$ = 48
|
|
dm$ = 80
|
|
__$ArrayPad$ = 304
|
|
monitor$ = 352
|
|
desired$ = 360
|
|
_glfwSetVideoModeWin32 PROC ; COMDAT
|
|
|
|
; 251 : {
|
|
|
|
$LN42:
|
|
00000 40 53 push rbx
|
|
00002 56 push rsi
|
|
00003 57 push rdi
|
|
00004 48 81 ec 40 01
|
|
00 00 sub rsp, 320 ; 00000140H
|
|
0000b 48 8b 05 00 00
|
|
00 00 mov rax, QWORD PTR __security_cookie
|
|
00012 48 33 c4 xor rax, rsp
|
|
00015 48 89 84 24 30
|
|
01 00 00 mov QWORD PTR __$ArrayPad$[rsp], rax
|
|
0001d 48 8b f9 mov rdi, rcx
|
|
|
|
; 252 : GLFWvidmode current;
|
|
; 253 : const GLFWvidmode* best;
|
|
; 254 : DEVMODEW dm;
|
|
; 255 : LONG result;
|
|
; 256 :
|
|
; 257 : best = _glfwChooseVideoMode(monitor, desired);
|
|
|
|
00020 e8 00 00 00 00 call _glfwChooseVideoMode
|
|
|
|
; 258 : _glfwGetVideoModeWin32(monitor, ¤t);
|
|
|
|
00025 48 8d 54 24 30 lea rdx, QWORD PTR current$[rsp]
|
|
0002a 48 8b cf mov rcx, rdi
|
|
0002d 48 8b d8 mov rbx, rax
|
|
00030 e8 00 00 00 00 call _glfwGetVideoModeWin32
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
|
|
; 46 : const int fbpp = fm->redBits + fm->greenBits + fm->blueBits;
|
|
|
|
00035 44 8b 44 24 38 mov r8d, DWORD PTR current$[rsp+8]
|
|
0003a 44 03 44 24 3c add r8d, DWORD PTR current$[rsp+12]
|
|
|
|
; 47 : const int sbpp = sm->redBits + sm->greenBits + sm->blueBits;
|
|
|
|
0003f 8b 43 0c mov eax, DWORD PTR [rbx+12]
|
|
00042 03 43 10 add eax, DWORD PTR [rbx+16]
|
|
|
|
; 48 : const int farea = fm->width * fm->height;
|
|
|
|
00045 44 8b 4c 24 30 mov r9d, DWORD PTR current$[rsp]
|
|
0004a 41 8b d1 mov edx, r9d
|
|
0004d 44 03 44 24 40 add r8d, DWORD PTR current$[rsp+16]
|
|
00052 03 43 08 add eax, DWORD PTR [rbx+8]
|
|
00055 0f af 54 24 34 imul edx, DWORD PTR current$[rsp+4]
|
|
|
|
; 49 : const int sarea = sm->width * sm->height;
|
|
|
|
0005a 8b 0b mov ecx, DWORD PTR [rbx]
|
|
|
|
; 50 :
|
|
; 51 : // First sort on color bits per pixel
|
|
; 52 : if (fbpp != sbpp)
|
|
|
|
0005c 44 3b c0 cmp r8d, eax
|
|
0005f 74 05 je SHORT $LN24@glfwSetVid
|
|
|
|
; 53 : return fbpp - sbpp;
|
|
|
|
00061 44 2b c0 sub r8d, eax
|
|
00064 eb 28 jmp SHORT $LN40@glfwSetVid
|
|
$LN24@glfwSetVid:
|
|
|
|
; 49 : const int sarea = sm->width * sm->height;
|
|
|
|
00066 8b c1 mov eax, ecx
|
|
00068 0f af 43 04 imul eax, DWORD PTR [rbx+4]
|
|
|
|
; 54 :
|
|
; 55 : // Then sort on screen area
|
|
; 56 : if (farea != sarea)
|
|
|
|
0006c 3b d0 cmp edx, eax
|
|
0006e 74 08 je SHORT $LN25@glfwSetVid
|
|
|
|
; 57 : return farea - sarea;
|
|
|
|
00070 44 8b c2 mov r8d, edx
|
|
00073 44 2b c0 sub r8d, eax
|
|
00076 eb 16 jmp SHORT $LN40@glfwSetVid
|
|
$LN25@glfwSetVid:
|
|
|
|
; 58 :
|
|
; 59 : // Then sort on width
|
|
; 60 : if (fm->width != sm->width)
|
|
|
|
00078 44 3b c9 cmp r9d, ecx
|
|
0007b 74 08 je SHORT $LN26@glfwSetVid
|
|
|
|
; 61 : return fm->width - sm->width;
|
|
|
|
0007d 45 8b c1 mov r8d, r9d
|
|
00080 44 2b c1 sub r8d, ecx
|
|
00083 eb 09 jmp SHORT $LN40@glfwSetVid
|
|
$LN26@glfwSetVid:
|
|
|
|
; 62 :
|
|
; 63 : // Lastly sort on refresh rate
|
|
; 64 : return fm->refreshRate - sm->refreshRate;
|
|
|
|
00085 44 8b 44 24 44 mov r8d, DWORD PTR current$[rsp+20]
|
|
0008a 44 2b 43 14 sub r8d, DWORD PTR [rbx+20]
|
|
$LN40@glfwSetVid:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
|
|
; 259 : if (_glfwCompareVideoModes(¤t, best) == 0)
|
|
|
|
0008e b9 04 00 00 00 mov ecx, 4
|
|
00093 48 8b c3 mov rax, rbx
|
|
00096 48 8d 34 0b lea rsi, QWORD PTR [rbx+rcx]
|
|
0009a 45 85 c0 test r8d, r8d
|
|
0009d 0f 84 26 01 00
|
|
00 je $LN6@glfwSetVid
|
|
000a3 48 89 ac 24 70
|
|
01 00 00 mov QWORD PTR [rsp+368], rbp
|
|
|
|
; 260 : return;
|
|
; 261 :
|
|
; 262 : ZeroMemory(&dm, sizeof(dm));
|
|
|
|
000ab 48 8d 4c 24 50 lea rcx, QWORD PTR dm$[rsp]
|
|
000b0 bd dc 00 00 00 mov ebp, 220 ; 000000dcH
|
|
000b5 33 d2 xor edx, edx
|
|
000b7 44 8b c5 mov r8d, ebp
|
|
000ba e8 00 00 00 00 call memset
|
|
|
|
; 263 : dm.dmSize = sizeof(dm);
|
|
|
|
000bf 66 89 ac 24 94
|
|
00 00 00 mov WORD PTR dm$[rsp+68], bp
|
|
|
|
; 264 : dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL |
|
|
; 265 : DM_DISPLAYFREQUENCY;
|
|
; 266 : dm.dmPelsWidth = best->width;
|
|
; 267 : dm.dmPelsHeight = best->height;
|
|
; 268 : dm.dmBitsPerPel = best->redBits + best->greenBits + best->blueBits;
|
|
; 269 : dm.dmDisplayFrequency = best->refreshRate;
|
|
|
|
000c7 b9 20 00 00 00 mov ecx, 32 ; 00000020H
|
|
000cc c7 84 24 98 00
|
|
00 00 00 00 5c
|
|
00 mov DWORD PTR dm$[rsp+72], 6029312 ; 005c0000H
|
|
|
|
; 270 :
|
|
; 271 : if (dm.dmBitsPerPel < 15 || dm.dmBitsPerPel >= 24)
|
|
; 272 : dm.dmBitsPerPel = 32;
|
|
; 273 :
|
|
; 274 : result = ChangeDisplaySettingsExW(monitor->win32.adapterName,
|
|
|
|
000d7 41 b9 04 00 00
|
|
00 mov r9d, 4
|
|
000dd 8b 03 mov eax, DWORD PTR [rbx]
|
|
000df 89 84 24 fc 00
|
|
00 00 mov DWORD PTR dm$[rsp+172], eax
|
|
000e6 8b 06 mov eax, DWORD PTR [rsi]
|
|
000e8 89 84 24 00 01
|
|
00 00 mov DWORD PTR dm$[rsp+176], eax
|
|
000ef 8b 53 0c mov edx, DWORD PTR [rbx+12]
|
|
000f2 03 53 10 add edx, DWORD PTR [rbx+16]
|
|
000f5 03 53 08 add edx, DWORD PTR [rbx+8]
|
|
000f8 89 94 24 f8 00
|
|
00 00 mov DWORD PTR dm$[rsp+168], edx
|
|
000ff 8b 43 14 mov eax, DWORD PTR [rbx+20]
|
|
00102 89 84 24 08 01
|
|
00 00 mov DWORD PTR dm$[rsp+184], eax
|
|
00109 8d 42 f1 lea eax, DWORD PTR [rdx-15]
|
|
0010c 48 c7 44 24 20
|
|
00 00 00 00 mov QWORD PTR [rsp+32], 0
|
|
00115 83 f8 08 cmp eax, 8
|
|
00118 0f 47 d1 cmova edx, ecx
|
|
0011b 48 8d 8f 08 01
|
|
00 00 lea rcx, QWORD PTR [rdi+264]
|
|
00122 89 94 24 f8 00
|
|
00 00 mov DWORD PTR dm$[rsp+168], edx
|
|
00129 45 33 c0 xor r8d, r8d
|
|
0012c 48 8d 54 24 50 lea rdx, QWORD PTR dm$[rsp]
|
|
00131 ff 15 00 00 00
|
|
00 call QWORD PTR __imp_ChangeDisplaySettingsExW
|
|
00137 48 8b ac 24 70
|
|
01 00 00 mov rbp, QWORD PTR [rsp+368]
|
|
|
|
; 275 : &dm,
|
|
; 276 : NULL,
|
|
; 277 : CDS_FULLSCREEN,
|
|
; 278 : NULL);
|
|
; 279 : if (result == DISP_CHANGE_SUCCESSFUL)
|
|
|
|
0013f 85 c0 test eax, eax
|
|
00141 75 0c jne SHORT $LN5@glfwSetVid
|
|
|
|
; 280 : monitor->win32.modeChanged = GLFW_TRUE;
|
|
|
|
00143 c7 87 cc 01 00
|
|
00 01 00 00 00 mov DWORD PTR [rdi+460], 1
|
|
0014d eb 7a jmp SHORT $LN6@glfwSetVid
|
|
$LN5@glfwSetVid:
|
|
|
|
; 281 : else
|
|
; 282 : {
|
|
; 283 : const char* description = "Unknown error";
|
|
|
|
0014f 48 8d 0d 00 00
|
|
00 00 lea rcx, OFFSET FLAT:??_C@_0O@NIPGCINC@Unknown?5error@
|
|
|
|
; 284 :
|
|
; 285 : if (result == DISP_CHANGE_BADDUALVIEW)
|
|
|
|
00156 83 f8 fa cmp eax, -6
|
|
00159 75 09 jne SHORT $LN7@glfwSetVid
|
|
|
|
; 286 : description = "The system uses DualView";
|
|
|
|
0015b 4c 8d 05 00 00
|
|
00 00 lea r8, OFFSET FLAT:??_C@_0BJ@EJOHFDHH@The?5system?5uses?5DualView@
|
|
00162 eb 54 jmp SHORT $LN19@glfwSetVid
|
|
$LN7@glfwSetVid:
|
|
|
|
; 287 : else if (result == DISP_CHANGE_BADFLAGS)
|
|
|
|
00164 83 f8 fc cmp eax, -4
|
|
00167 75 09 jne SHORT $LN9@glfwSetVid
|
|
|
|
; 288 : description = "Invalid flags";
|
|
|
|
00169 4c 8d 05 00 00
|
|
00 00 lea r8, OFFSET FLAT:??_C@_0O@IHOLGAKK@Invalid?5flags@
|
|
00170 eb 46 jmp SHORT $LN19@glfwSetVid
|
|
$LN9@glfwSetVid:
|
|
|
|
; 289 : else if (result == DISP_CHANGE_BADMODE)
|
|
|
|
00172 83 f8 fe cmp eax, -2
|
|
00175 75 09 jne SHORT $LN11@glfwSetVid
|
|
|
|
; 290 : description = "Graphics mode not supported";
|
|
|
|
00177 4c 8d 05 00 00
|
|
00 00 lea r8, OFFSET FLAT:??_C@_0BM@KPJJBADD@Graphics?5mode?5not?5supported@
|
|
0017e eb 38 jmp SHORT $LN19@glfwSetVid
|
|
$LN11@glfwSetVid:
|
|
|
|
; 291 : else if (result == DISP_CHANGE_BADPARAM)
|
|
|
|
00180 83 f8 fb cmp eax, -5
|
|
00183 75 09 jne SHORT $LN13@glfwSetVid
|
|
|
|
; 292 : description = "Invalid parameter";
|
|
|
|
00185 4c 8d 05 00 00
|
|
00 00 lea r8, OFFSET FLAT:??_C@_0BC@DBAKKFEN@Invalid?5parameter@
|
|
0018c eb 2a jmp SHORT $LN19@glfwSetVid
|
|
$LN13@glfwSetVid:
|
|
|
|
; 293 : else if (result == DISP_CHANGE_FAILED)
|
|
|
|
0018e 83 f8 ff cmp eax, -1
|
|
00191 75 09 jne SHORT $LN15@glfwSetVid
|
|
|
|
; 294 : description = "Graphics mode failed";
|
|
|
|
00193 4c 8d 05 00 00
|
|
00 00 lea r8, OFFSET FLAT:??_C@_0BF@JHMFGJBN@Graphics?5mode?5failed@
|
|
0019a eb 1c jmp SHORT $LN19@glfwSetVid
|
|
$LN15@glfwSetVid:
|
|
|
|
; 295 : else if (result == DISP_CHANGE_NOTUPDATED)
|
|
|
|
0019c 83 f8 fd cmp eax, -3
|
|
0019f 75 09 jne SHORT $LN17@glfwSetVid
|
|
|
|
; 296 : description = "Failed to write to registry";
|
|
|
|
001a1 4c 8d 05 00 00
|
|
00 00 lea r8, OFFSET FLAT:??_C@_0BM@IGBABBBF@Failed?5to?5write?5to?5registry@
|
|
001a8 eb 0e jmp SHORT $LN19@glfwSetVid
|
|
$LN17@glfwSetVid:
|
|
|
|
; 297 : else if (result == DISP_CHANGE_RESTART)
|
|
|
|
001aa 83 f8 01 cmp eax, 1
|
|
001ad 4c 8d 05 00 00
|
|
00 00 lea r8, OFFSET FLAT:??_C@_0BK@OEGBAIFC@Computer?5restart?5required@
|
|
001b4 4c 0f 45 c1 cmovne r8, rcx
|
|
$LN19@glfwSetVid:
|
|
|
|
; 298 : description = "Computer restart required";
|
|
; 299 :
|
|
; 300 : _glfwInputError(GLFW_PLATFORM_ERROR,
|
|
|
|
001b8 48 8d 15 00 00
|
|
00 00 lea rdx, OFFSET FLAT:??_C@_0CE@IKOICJPN@Win32?3?5Failed?5to?5set?5video?5mode@
|
|
001bf b9 08 00 01 00 mov ecx, 65544 ; 00010008H
|
|
001c4 e8 00 00 00 00 call _glfwInputError
|
|
$LN6@glfwSetVid:
|
|
|
|
; 301 : "Win32: Failed to set video mode: %s",
|
|
; 302 : description);
|
|
; 303 : }
|
|
; 304 : }
|
|
|
|
001c9 48 8b 8c 24 30
|
|
01 00 00 mov rcx, QWORD PTR __$ArrayPad$[rsp]
|
|
001d1 48 33 cc xor rcx, rsp
|
|
001d4 e8 00 00 00 00 call __security_check_cookie
|
|
001d9 48 81 c4 40 01
|
|
00 00 add rsp, 320 ; 00000140H
|
|
001e0 5f pop rdi
|
|
001e1 5e pop rsi
|
|
001e2 5b pop rbx
|
|
001e3 c3 ret 0
|
|
_glfwSetVideoModeWin32 ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
; COMDAT _glfwRestoreVideoModeWin32
|
|
_TEXT SEGMENT
|
|
monitor$ = 64
|
|
_glfwRestoreVideoModeWin32 PROC ; COMDAT
|
|
|
|
; 309 : {
|
|
|
|
$LN6:
|
|
00000 40 53 push rbx
|
|
00002 48 83 ec 30 sub rsp, 48 ; 00000030H
|
|
|
|
; 310 : if (monitor->win32.modeChanged)
|
|
|
|
00006 83 b9 cc 01 00
|
|
00 00 cmp DWORD PTR [rcx+460], 0
|
|
0000d 48 8b d9 mov rbx, rcx
|
|
00010 74 2b je SHORT $LN2@glfwRestor
|
|
|
|
; 311 : {
|
|
; 312 : ChangeDisplaySettingsExW(monitor->win32.adapterName,
|
|
|
|
00012 48 81 c1 08 01
|
|
00 00 add rcx, 264 ; 00000108H
|
|
00019 48 c7 44 24 20
|
|
00 00 00 00 mov QWORD PTR [rsp+32], 0
|
|
00022 41 b9 04 00 00
|
|
00 mov r9d, 4
|
|
00028 45 33 c0 xor r8d, r8d
|
|
0002b 33 d2 xor edx, edx
|
|
0002d ff 15 00 00 00
|
|
00 call QWORD PTR __imp_ChangeDisplaySettingsExW
|
|
|
|
; 313 : NULL, NULL, CDS_FULLSCREEN, NULL);
|
|
; 314 : monitor->win32.modeChanged = GLFW_FALSE;
|
|
|
|
00033 c7 83 cc 01 00
|
|
00 00 00 00 00 mov DWORD PTR [rbx+460], 0
|
|
$LN2@glfwRestor:
|
|
|
|
; 315 : }
|
|
; 316 : }
|
|
|
|
0003d 48 83 c4 30 add rsp, 48 ; 00000030H
|
|
00041 5b pop rbx
|
|
00042 c3 ret 0
|
|
_glfwRestoreVideoModeWin32 ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
; COMDAT _glfwGetHMONITORContentScaleWin32
|
|
_TEXT SEGMENT
|
|
xdpi$ = 32
|
|
ydpi$ = 36
|
|
__$ArrayPad$ = 40
|
|
handle$ = 80
|
|
xscale$ = 88
|
|
yscale$ = 96
|
|
_glfwGetHMONITORContentScaleWin32 PROC ; COMDAT
|
|
|
|
; 319 : {
|
|
|
|
$LN17:
|
|
00000 40 53 push rbx
|
|
00002 56 push rsi
|
|
00003 57 push rdi
|
|
00004 48 83 ec 30 sub rsp, 48 ; 00000030H
|
|
00008 48 8b 05 00 00
|
|
00 00 mov rax, QWORD PTR __security_cookie
|
|
0000f 48 33 c4 xor rax, rsp
|
|
00012 48 89 44 24 28 mov QWORD PTR __$ArrayPad$[rsp], rax
|
|
|
|
; 320 : UINT xdpi, ydpi;
|
|
; 321 :
|
|
; 322 : if (xscale)
|
|
|
|
00017 33 c0 xor eax, eax
|
|
00019 49 8b f8 mov rdi, r8
|
|
0001c 48 8b f2 mov rsi, rdx
|
|
0001f 48 8b d9 mov rbx, rcx
|
|
00022 48 85 d2 test rdx, rdx
|
|
00025 74 02 je SHORT $LN2@glfwGetHMO
|
|
|
|
; 323 : *xscale = 0.f;
|
|
|
|
00027 89 02 mov DWORD PTR [rdx], eax
|
|
$LN2@glfwGetHMO:
|
|
|
|
; 324 : if (yscale)
|
|
|
|
00029 48 85 ff test rdi, rdi
|
|
0002c 74 03 je SHORT $LN3@glfwGetHMO
|
|
|
|
; 325 : *yscale = 0.f;
|
|
|
|
0002e 41 89 00 mov DWORD PTR [r8], eax
|
|
$LN3@glfwGetHMO:
|
|
|
|
; 326 :
|
|
; 327 : if (IsWindows8Point1OrGreater())
|
|
|
|
00031 ba 03 00 00 00 mov edx, 3
|
|
00036 e8 00 00 00 00 call _glfwIsWindowsVersionOrGreaterWin32
|
|
0003b 85 c0 test eax, eax
|
|
0003d 74 2c je SHORT $LN4@glfwGetHMO
|
|
|
|
; 328 : {
|
|
; 329 : if (GetDpiForMonitor(handle, MDT_EFFECTIVE_DPI, &xdpi, &ydpi) != S_OK)
|
|
|
|
0003f 4c 8d 4c 24 24 lea r9, QWORD PTR ydpi$[rsp]
|
|
00044 33 d2 xor edx, edx
|
|
00046 4c 8d 44 24 20 lea r8, QWORD PTR xdpi$[rsp]
|
|
0004b 48 8b cb mov rcx, rbx
|
|
0004e ff 15 10 2a 00
|
|
00 call QWORD PTR _glfw+10768
|
|
00054 85 c0 test eax, eax
|
|
00056 74 4d je SHORT $LN5@glfwGetHMO
|
|
|
|
; 330 : {
|
|
; 331 : _glfwInputError(GLFW_PLATFORM_ERROR, "Win32: Failed to query monitor DPI");
|
|
|
|
00058 48 8d 15 00 00
|
|
00 00 lea rdx, OFFSET FLAT:??_C@_0CD@IGHBCNOG@Win32?3?5Failed?5to?5query?5monitor?5@
|
|
0005f b9 08 00 01 00 mov ecx, 65544 ; 00010008H
|
|
00064 e8 00 00 00 00 call _glfwInputError
|
|
|
|
; 332 : return;
|
|
|
|
00069 eb 74 jmp SHORT $LN8@glfwGetHMO
|
|
$LN4@glfwGetHMO:
|
|
|
|
; 333 : }
|
|
; 334 : }
|
|
; 335 : else
|
|
; 336 : {
|
|
; 337 : const HDC dc = GetDC(NULL);
|
|
|
|
0006b 33 c9 xor ecx, ecx
|
|
0006d ff 15 00 00 00
|
|
00 call QWORD PTR __imp_GetDC
|
|
|
|
; 338 : xdpi = GetDeviceCaps(dc, LOGPIXELSX);
|
|
|
|
00073 48 8b c8 mov rcx, rax
|
|
00076 ba 58 00 00 00 mov edx, 88 ; 00000058H
|
|
0007b 48 8b d8 mov rbx, rax
|
|
0007e ff 15 00 00 00
|
|
00 call QWORD PTR __imp_GetDeviceCaps
|
|
|
|
; 339 : ydpi = GetDeviceCaps(dc, LOGPIXELSY);
|
|
|
|
00084 ba 5a 00 00 00 mov edx, 90 ; 0000005aH
|
|
00089 48 8b cb mov rcx, rbx
|
|
0008c 89 44 24 20 mov DWORD PTR xdpi$[rsp], eax
|
|
00090 ff 15 00 00 00
|
|
00 call QWORD PTR __imp_GetDeviceCaps
|
|
|
|
; 340 : ReleaseDC(NULL, dc);
|
|
|
|
00096 48 8b d3 mov rdx, rbx
|
|
00099 33 c9 xor ecx, ecx
|
|
0009b 89 44 24 24 mov DWORD PTR ydpi$[rsp], eax
|
|
0009f ff 15 00 00 00
|
|
00 call QWORD PTR __imp_ReleaseDC
|
|
$LN5@glfwGetHMO:
|
|
|
|
; 341 : }
|
|
; 342 :
|
|
; 343 : if (xscale)
|
|
|
|
000a5 f3 0f 10 0d 00
|
|
00 00 00 movss xmm1, DWORD PTR __real@42c00000
|
|
000ad 48 85 f6 test rsi, rsi
|
|
000b0 74 14 je SHORT $LN7@glfwGetHMO
|
|
|
|
; 344 : *xscale = xdpi / (float) USER_DEFAULT_SCREEN_DPI;
|
|
|
|
000b2 8b 44 24 20 mov eax, DWORD PTR xdpi$[rsp]
|
|
000b6 0f 57 c0 xorps xmm0, xmm0
|
|
000b9 f3 48 0f 2a c0 cvtsi2ss xmm0, rax
|
|
000be f3 0f 5e c1 divss xmm0, xmm1
|
|
000c2 f3 0f 11 06 movss DWORD PTR [rsi], xmm0
|
|
$LN7@glfwGetHMO:
|
|
|
|
; 345 : if (yscale)
|
|
|
|
000c6 48 85 ff test rdi, rdi
|
|
000c9 74 14 je SHORT $LN8@glfwGetHMO
|
|
|
|
; 346 : *yscale = ydpi / (float) USER_DEFAULT_SCREEN_DPI;
|
|
|
|
000cb 8b 44 24 24 mov eax, DWORD PTR ydpi$[rsp]
|
|
000cf 0f 57 c0 xorps xmm0, xmm0
|
|
000d2 f3 48 0f 2a c0 cvtsi2ss xmm0, rax
|
|
000d7 f3 0f 5e c1 divss xmm0, xmm1
|
|
000db f3 0f 11 07 movss DWORD PTR [rdi], xmm0
|
|
$LN8@glfwGetHMO:
|
|
|
|
; 347 : }
|
|
|
|
000df 48 8b 4c 24 28 mov rcx, QWORD PTR __$ArrayPad$[rsp]
|
|
000e4 48 33 cc xor rcx, rsp
|
|
000e7 e8 00 00 00 00 call __security_check_cookie
|
|
000ec 48 83 c4 30 add rsp, 48 ; 00000030H
|
|
000f0 5f pop rdi
|
|
000f1 5e pop rsi
|
|
000f2 5b pop rbx
|
|
000f3 c3 ret 0
|
|
_glfwGetHMONITORContentScaleWin32 ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
; COMDAT glfwGetWin32Adapter
|
|
_TEXT SEGMENT
|
|
handle$ = 48
|
|
glfwGetWin32Adapter PROC ; COMDAT
|
|
|
|
; 537 : {
|
|
|
|
$LN5:
|
|
00000 48 83 ec 28 sub rsp, 40 ; 00000028H
|
|
|
|
; 538 : _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
|
|
; 539 : _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
|
|
|
|
00004 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
0000b 75 13 jne SHORT $LN2@glfwGetWin
|
|
0000d 33 d2 xor edx, edx
|
|
0000f b9 01 00 01 00 mov ecx, 65537 ; 00010001H
|
|
00014 e8 00 00 00 00 call _glfwInputError
|
|
00019 33 c0 xor eax, eax
|
|
|
|
; 541 : }
|
|
|
|
0001b 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
0001f c3 ret 0
|
|
$LN2@glfwGetWin:
|
|
|
|
; 540 : return monitor->win32.publicAdapterName;
|
|
|
|
00020 48 8d 81 88 01
|
|
00 00 lea rax, QWORD PTR [rcx+392]
|
|
|
|
; 541 : }
|
|
|
|
00027 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
0002b c3 ret 0
|
|
glfwGetWin32Adapter ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_monitor.c
|
|
; COMDAT glfwGetWin32Monitor
|
|
_TEXT SEGMENT
|
|
handle$ = 48
|
|
glfwGetWin32Monitor PROC ; COMDAT
|
|
|
|
; 544 : {
|
|
|
|
$LN5:
|
|
00000 48 83 ec 28 sub rsp, 40 ; 00000028H
|
|
|
|
; 545 : _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
|
|
; 546 : _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
|
|
|
|
00004 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
0000b 75 13 jne SHORT $LN2@glfwGetWin
|
|
0000d 33 d2 xor edx, edx
|
|
0000f b9 01 00 01 00 mov ecx, 65537 ; 00010001H
|
|
00014 e8 00 00 00 00 call _glfwInputError
|
|
00019 33 c0 xor eax, eax
|
|
|
|
; 548 : }
|
|
|
|
0001b 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
0001f c3 ret 0
|
|
$LN2@glfwGetWin:
|
|
|
|
; 547 : return monitor->win32.publicDisplayName;
|
|
|
|
00020 48 8d 81 a8 01
|
|
00 00 lea rax, QWORD PTR [rcx+424]
|
|
|
|
; 548 : }
|
|
|
|
00027 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
0002b c3 ret 0
|
|
glfwGetWin32Monitor ENDP
|
|
_TEXT ENDS
|
|
END
|