3462 lines
95 KiB
Plaintext
3462 lines
95 KiB
Plaintext
; Listing generated by Microsoft (R) Optimizing Compiler Version 19.37.32824.0
|
|
|
|
include listing.inc
|
|
|
|
INCLUDELIB OLDNAMES
|
|
|
|
PUBLIC ??_C@_0BH@BAPIEFAH@Invalid?5gamma?5value?5?$CFf@ ; `string'
|
|
PUBLIC ??_C@_0BL@OAABODH@Invalid?5gamma?5ramp?5size?5?$CFi@ ; `string'
|
|
EXTRN __imp_qsort:PROC
|
|
; COMDAT ??_C@_0BL@OAABODH@Invalid?5gamma?5ramp?5size?5?$CFi@
|
|
CONST SEGMENT
|
|
??_C@_0BL@OAABODH@Invalid?5gamma?5ramp?5size?5?$CFi@ DB 'Invalid gamma ra'
|
|
DB 'mp size %i', 00H ; `string'
|
|
CONST ENDS
|
|
; COMDAT ??_C@_0BH@BAPIEFAH@Invalid?5gamma?5value?5?$CFf@
|
|
CONST SEGMENT
|
|
??_C@_0BH@BAPIEFAH@Invalid?5gamma?5value?5?$CFf@ DB 'Invalid gamma value '
|
|
DB '%f', 00H ; `string'
|
|
PUBLIC glfwSetGammaRamp
|
|
PUBLIC glfwGetGammaRamp
|
|
PUBLIC glfwSetGamma
|
|
PUBLIC glfwGetVideoMode
|
|
PUBLIC glfwGetVideoModes
|
|
PUBLIC glfwSetMonitorCallback
|
|
PUBLIC glfwGetMonitorUserPointer
|
|
PUBLIC glfwSetMonitorUserPointer
|
|
PUBLIC glfwGetMonitorName
|
|
PUBLIC glfwGetMonitorContentScale
|
|
PUBLIC glfwGetMonitorPhysicalSize
|
|
PUBLIC glfwGetMonitorWorkarea
|
|
PUBLIC glfwGetMonitorPos
|
|
PUBLIC glfwGetPrimaryMonitor
|
|
PUBLIC glfwGetMonitors
|
|
PUBLIC _glfwSplitBPP
|
|
PUBLIC _glfwCompareVideoModes
|
|
PUBLIC _glfwChooseVideoMode
|
|
PUBLIC _glfwFreeGammaArrays
|
|
PUBLIC _glfwAllocGammaArrays
|
|
PUBLIC _glfwAllocMonitor
|
|
PUBLIC _glfwInputMonitorWindow
|
|
PUBLIC _glfwInputMonitor
|
|
PUBLIC _glfwFreeMonitor
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$glfwSetGammaRamp DD imagerel $LN11
|
|
DD imagerel $LN11+132
|
|
DD imagerel $unwind$glfwSetGammaRamp
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$glfwGetGammaRamp DD imagerel $LN21
|
|
DD imagerel $LN21+159
|
|
DD imagerel $unwind$glfwGetGammaRamp
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$glfwSetGamma DD imagerel $LN47
|
|
DD imagerel $LN47+95
|
|
DD imagerel $unwind$glfwSetGamma
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$0$glfwSetGamma DD imagerel $LN47+95
|
|
DD imagerel $LN47+128
|
|
DD imagerel $chain$0$glfwSetGamma
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$2$glfwSetGamma DD imagerel $LN47+128
|
|
DD imagerel $LN47+165
|
|
DD imagerel $chain$2$glfwSetGamma
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$4$glfwSetGamma DD imagerel $LN47+165
|
|
DD imagerel $LN47+290
|
|
DD imagerel $chain$4$glfwSetGamma
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$5$glfwSetGamma DD imagerel $LN47+290
|
|
DD imagerel $LN47+331
|
|
DD imagerel $chain$5$glfwSetGamma
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$6$glfwSetGamma DD imagerel $LN47+331
|
|
DD imagerel $LN47+441
|
|
DD imagerel $chain$6$glfwSetGamma
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$7$glfwSetGamma DD imagerel $LN47+441
|
|
DD imagerel $LN47+449
|
|
DD imagerel $chain$7$glfwSetGamma
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$8$glfwSetGamma DD imagerel $LN47+449
|
|
DD imagerel $LN47+507
|
|
DD imagerel $chain$8$glfwSetGamma
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$glfwGetVideoMode DD imagerel $LN6
|
|
DD imagerel $LN6+66
|
|
DD imagerel $unwind$glfwGetVideoMode
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$glfwGetVideoModes DD imagerel $LN9
|
|
DD imagerel $LN9+91
|
|
DD imagerel $unwind$glfwGetVideoModes
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$glfwSetMonitorCallback DD imagerel $LN5
|
|
DD imagerel $LN5+51
|
|
DD imagerel $unwind$glfwSetMonitorCallback
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$glfwGetMonitorUserPointer DD imagerel $LN5
|
|
DD imagerel $LN5+44
|
|
DD imagerel $unwind$glfwGetMonitorUserPointer
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$glfwGetMonitorName DD imagerel $LN5
|
|
DD imagerel $LN5+40
|
|
DD imagerel $unwind$glfwGetMonitorName
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$glfwGetPrimaryMonitor DD imagerel $LN7
|
|
DD imagerel $LN7+56
|
|
DD imagerel $unwind$glfwGetPrimaryMonitor
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$glfwGetMonitors DD imagerel $LN5
|
|
DD imagerel $LN5+58
|
|
DD imagerel $unwind$glfwGetMonitors
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$_glfwChooseVideoMode DD imagerel $LN52
|
|
DD imagerel $LN52+106
|
|
DD imagerel $unwind$_glfwChooseVideoMode
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$0$_glfwChooseVideoMode DD imagerel $LN52+106
|
|
DD imagerel $LN52+496
|
|
DD imagerel $chain$0$_glfwChooseVideoMode
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$1$_glfwChooseVideoMode DD imagerel $LN52+496
|
|
DD imagerel $LN52+514
|
|
DD imagerel $chain$1$_glfwChooseVideoMode
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$_glfwFreeGammaArrays DD imagerel $LN16
|
|
DD imagerel $LN16+90
|
|
DD imagerel $unwind$_glfwFreeGammaArrays
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$_glfwAllocGammaArrays DD imagerel $LN32
|
|
DD imagerel $LN32+42
|
|
DD imagerel $unwind$_glfwAllocGammaArrays
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$0$_glfwAllocGammaArrays DD imagerel $LN32+42
|
|
DD imagerel $LN32+196
|
|
DD imagerel $chain$0$_glfwAllocGammaArrays
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$1$_glfwAllocGammaArrays DD imagerel $LN32+196
|
|
DD imagerel $LN32+276
|
|
DD imagerel $chain$1$_glfwAllocGammaArrays
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$_glfwAllocMonitor DD imagerel $LN12
|
|
DD imagerel $LN12+140
|
|
DD imagerel $unwind$_glfwAllocMonitor
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$_glfwInputMonitor DD imagerel $LN63
|
|
DD imagerel $LN63+21
|
|
DD imagerel $unwind$_glfwInputMonitor
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$2$_glfwInputMonitor DD imagerel $LN63+21
|
|
DD imagerel $LN63+547
|
|
DD imagerel $chain$2$_glfwInputMonitor
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$3$_glfwInputMonitor DD imagerel $LN63+547
|
|
DD imagerel $LN63+567
|
|
DD imagerel $chain$3$_glfwInputMonitor
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$4$_glfwInputMonitor DD imagerel $LN63+567
|
|
DD imagerel $LN63+594
|
|
DD imagerel $chain$4$_glfwInputMonitor
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$refreshVideoModes DD imagerel refreshVideoModes
|
|
DD imagerel refreshVideoModes+180
|
|
DD imagerel $unwind$refreshVideoModes
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$compareVideoModes DD imagerel compareVideoModes
|
|
DD imagerel compareVideoModes+113
|
|
DD imagerel $unwind$compareVideoModes
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$_glfwFreeMonitor DD imagerel $LN42
|
|
DD imagerel $LN42+254
|
|
DD imagerel $unwind$_glfwFreeMonitor
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$_glfwFreeMonitor DD 020e01H
|
|
DD 0300a320eH
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$compareVideoModes DD 020501H
|
|
DD 013405H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$refreshVideoModes DD 044419H
|
|
DD 097444H
|
|
DD 030025206H
|
|
DD imagerel __GSHandlerCheck
|
|
DD 028H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$4$_glfwInputMonitor DD 021H
|
|
DD imagerel $LN63
|
|
DD imagerel $LN63+21
|
|
DD imagerel $unwind$_glfwInputMonitor
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$3$_glfwInputMonitor DD 020021H
|
|
DD 0d5400H
|
|
DD imagerel $LN63
|
|
DD imagerel $LN63+21
|
|
DD imagerel $unwind$_glfwInputMonitor
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$2$_glfwInputMonitor DD 061721H
|
|
DD 0c7417H
|
|
DD 0d5410H
|
|
DD 0123408H
|
|
DD imagerel $LN63
|
|
DD imagerel $LN63+21
|
|
DD imagerel $unwind$_glfwInputMonitor
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$_glfwInputMonitor DD 021519H
|
|
DD 06002d206H
|
|
DD imagerel __GSHandlerCheck
|
|
DD 050H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$_glfwAllocMonitor DD 081401H
|
|
DD 086414H
|
|
DD 075414H
|
|
DD 063414H
|
|
DD 070103214H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$1$_glfwAllocGammaArrays DD 021H
|
|
DD imagerel $LN32
|
|
DD imagerel $LN32+42
|
|
DD imagerel $unwind$_glfwAllocGammaArrays
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$0$_glfwAllocGammaArrays DD 020521H
|
|
DD 06e405H
|
|
DD imagerel $LN32
|
|
DD imagerel $LN32+42
|
|
DD imagerel $unwind$_glfwAllocGammaArrays
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$_glfwAllocGammaArrays DD 081401H
|
|
DD 096414H
|
|
DD 085414H
|
|
DD 073414H
|
|
DD 070103214H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$_glfwFreeGammaArrays DD 020601H
|
|
DD 030023206H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$1$_glfwChooseVideoMode DD 021H
|
|
DD imagerel $LN52
|
|
DD imagerel $LN52+106
|
|
DD imagerel $unwind$_glfwChooseVideoMode
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$0$_glfwChooseVideoMode DD 020521H
|
|
DD 0ec405H
|
|
DD imagerel $LN52
|
|
DD imagerel $LN52+106
|
|
DD imagerel $unwind$_glfwChooseVideoMode
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$_glfwChooseVideoMode DD 080f01H
|
|
DD 0f00b520fH
|
|
DD 0d007e009H
|
|
DD 060047005H
|
|
DD 030025003H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$glfwGetMonitors DD 010401H
|
|
DD 04204H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$glfwGetPrimaryMonitor DD 010401H
|
|
DD 04204H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$glfwGetMonitorName DD 010401H
|
|
DD 04204H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$glfwGetMonitorUserPointer DD 010401H
|
|
DD 04204H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$glfwSetMonitorCallback DD 010401H
|
|
DD 04204H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$glfwGetVideoModes DD 040a01H
|
|
DD 06340aH
|
|
DD 07006320aH
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$glfwGetVideoMode DD 032501H
|
|
DD 043425H
|
|
DD 04204H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$8$glfwSetGamma DD 021H
|
|
DD imagerel $LN47
|
|
DD imagerel $LN47+95
|
|
DD imagerel $unwind$glfwSetGamma
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$7$glfwSetGamma DD 021H
|
|
DD imagerel $LN47+95
|
|
DD imagerel $LN47+128
|
|
DD imagerel $chain$0$glfwSetGamma
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$6$glfwSetGamma DD 020021H
|
|
DD 0107400H
|
|
DD imagerel $LN47+95
|
|
DD imagerel $LN47+128
|
|
DD imagerel $chain$0$glfwSetGamma
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$5$glfwSetGamma DD 021H
|
|
DD imagerel $LN47+128
|
|
DD imagerel $LN47+165
|
|
DD imagerel $chain$2$glfwSetGamma
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$4$glfwSetGamma DD 041f21H
|
|
DD 05881fH
|
|
DD 067805H
|
|
DD imagerel $LN47+128
|
|
DD imagerel $LN47+165
|
|
DD imagerel $chain$2$glfwSetGamma
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$2$glfwSetGamma DD 041021H
|
|
DD 0107410H
|
|
DD 0163408H
|
|
DD imagerel $LN47+95
|
|
DD imagerel $LN47+128
|
|
DD imagerel $chain$0$glfwSetGamma
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$0$glfwSetGamma DD 020821H
|
|
DD 0116408H
|
|
DD imagerel $LN47
|
|
DD imagerel $LN47+95
|
|
DD imagerel $unwind$glfwSetGamma
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$glfwSetGamma DD 051d19H
|
|
DD 07680eH
|
|
DD 0120109H
|
|
DD 05002H
|
|
DD imagerel __GSHandlerCheck
|
|
DD 040H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$glfwGetGammaRamp DD 042b01H
|
|
DD 06342bH
|
|
DD 070023206H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$glfwSetGammaRamp DD 040a01H
|
|
DD 06340aH
|
|
DD 07006320aH
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; COMDAT _glfwFreeMonitor
|
|
_TEXT SEGMENT
|
|
monitor$ = 48
|
|
_glfwFreeMonitor PROC ; COMDAT
|
|
|
|
; 187 : {
|
|
|
|
$LN42:
|
|
|
|
; 188 : if (monitor == NULL)
|
|
|
|
00000 48 85 c9 test rcx, rcx
|
|
00003 0f 84 f4 00 00
|
|
00 je $LN40@glfwFreeMo
|
|
00009 53 push rbx
|
|
0000a 48 83 ec 20 sub rsp, 32 ; 00000020H
|
|
|
|
; 187 : {
|
|
|
|
0000e 48 8b d9 mov rbx, rcx
|
|
|
|
; 189 : return;
|
|
; 190 :
|
|
; 191 : _glfw.platform.freeMonitor(monitor);
|
|
|
|
00011 ff 15 d0 00 00
|
|
00 call QWORD PTR _glfw+208
|
|
|
|
; 214 : _glfw_free(ramp->red);
|
|
|
|
00017 48 8b 8b c0 00
|
|
00 00 mov rcx, QWORD PTR [rbx+192]
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 320 : if (block)
|
|
|
|
0001e 48 85 c9 test rcx, rcx
|
|
00021 74 0d je SHORT $LN7@glfwFreeMo
|
|
|
|
; 321 : _glfw.allocator.deallocate(block, _glfw.allocator.user);
|
|
|
|
00023 48 8b 15 20 00
|
|
00 00 mov rdx, QWORD PTR _glfw+32
|
|
0002a ff 15 18 00 00
|
|
00 call QWORD PTR _glfw+24
|
|
$LN7@glfwFreeMo:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
|
|
; 215 : _glfw_free(ramp->green);
|
|
|
|
00030 48 8b 8b c8 00
|
|
00 00 mov rcx, QWORD PTR [rbx+200]
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 320 : if (block)
|
|
|
|
00037 48 85 c9 test rcx, rcx
|
|
0003a 74 0d je SHORT $LN10@glfwFreeMo
|
|
|
|
; 321 : _glfw.allocator.deallocate(block, _glfw.allocator.user);
|
|
|
|
0003c 48 8b 15 20 00
|
|
00 00 mov rdx, QWORD PTR _glfw+32
|
|
00043 ff 15 18 00 00
|
|
00 call QWORD PTR _glfw+24
|
|
$LN10@glfwFreeMo:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
|
|
; 216 : _glfw_free(ramp->blue);
|
|
|
|
00049 48 8b 8b d0 00
|
|
00 00 mov rcx, QWORD PTR [rbx+208]
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 320 : if (block)
|
|
|
|
00050 48 85 c9 test rcx, rcx
|
|
00053 74 0d je SHORT $LN13@glfwFreeMo
|
|
|
|
; 321 : _glfw.allocator.deallocate(block, _glfw.allocator.user);
|
|
|
|
00055 48 8b 15 20 00
|
|
00 00 mov rdx, QWORD PTR _glfw+32
|
|
0005c ff 15 18 00 00
|
|
00 call QWORD PTR _glfw+24
|
|
$LN13@glfwFreeMo:
|
|
00062 0f 57 c0 xorps xmm0, xmm0
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
|
|
; 218 : memset(ramp, 0, sizeof(GLFWgammaramp));
|
|
|
|
00065 0f 11 83 c0 00
|
|
00 00 movups XMMWORD PTR [rbx+192], xmm0
|
|
0006c 0f 11 83 d0 00
|
|
00 00 movups XMMWORD PTR [rbx+208], xmm0
|
|
|
|
; 214 : _glfw_free(ramp->red);
|
|
|
|
00073 48 8b 8b e0 00
|
|
00 00 mov rcx, QWORD PTR [rbx+224]
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 320 : if (block)
|
|
|
|
0007a 48 85 c9 test rcx, rcx
|
|
0007d 74 0d je SHORT $LN18@glfwFreeMo
|
|
|
|
; 321 : _glfw.allocator.deallocate(block, _glfw.allocator.user);
|
|
|
|
0007f 48 8b 15 20 00
|
|
00 00 mov rdx, QWORD PTR _glfw+32
|
|
00086 ff 15 18 00 00
|
|
00 call QWORD PTR _glfw+24
|
|
$LN18@glfwFreeMo:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
|
|
; 215 : _glfw_free(ramp->green);
|
|
|
|
0008c 48 8b 8b e8 00
|
|
00 00 mov rcx, QWORD PTR [rbx+232]
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 320 : if (block)
|
|
|
|
00093 48 85 c9 test rcx, rcx
|
|
00096 74 0d je SHORT $LN21@glfwFreeMo
|
|
|
|
; 321 : _glfw.allocator.deallocate(block, _glfw.allocator.user);
|
|
|
|
00098 48 8b 15 20 00
|
|
00 00 mov rdx, QWORD PTR _glfw+32
|
|
0009f ff 15 18 00 00
|
|
00 call QWORD PTR _glfw+24
|
|
$LN21@glfwFreeMo:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
|
|
; 216 : _glfw_free(ramp->blue);
|
|
|
|
000a5 48 8b 8b f0 00
|
|
00 00 mov rcx, QWORD PTR [rbx+240]
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 320 : if (block)
|
|
|
|
000ac 48 85 c9 test rcx, rcx
|
|
000af 74 0d je SHORT $LN24@glfwFreeMo
|
|
|
|
; 321 : _glfw.allocator.deallocate(block, _glfw.allocator.user);
|
|
|
|
000b1 48 8b 15 20 00
|
|
00 00 mov rdx, QWORD PTR _glfw+32
|
|
000b8 ff 15 18 00 00
|
|
00 call QWORD PTR _glfw+24
|
|
$LN24@glfwFreeMo:
|
|
000be 0f 57 c0 xorps xmm0, xmm0
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
|
|
; 218 : memset(ramp, 0, sizeof(GLFWgammaramp));
|
|
|
|
000c1 0f 11 83 e0 00
|
|
00 00 movups XMMWORD PTR [rbx+224], xmm0
|
|
000c8 0f 11 83 f0 00
|
|
00 00 movups XMMWORD PTR [rbx+240], xmm0
|
|
|
|
; 192 :
|
|
; 193 : _glfwFreeGammaArrays(&monitor->originalRamp);
|
|
; 194 : _glfwFreeGammaArrays(&monitor->currentRamp);
|
|
; 195 :
|
|
; 196 : _glfw_free(monitor->modes);
|
|
|
|
000cf 48 8b 8b 98 00
|
|
00 00 mov rcx, QWORD PTR [rbx+152]
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 320 : if (block)
|
|
|
|
000d6 48 85 c9 test rcx, rcx
|
|
000d9 74 0d je SHORT $LN27@glfwFreeMo
|
|
|
|
; 321 : _glfw.allocator.deallocate(block, _glfw.allocator.user);
|
|
|
|
000db 48 8b 15 20 00
|
|
00 00 mov rdx, QWORD PTR _glfw+32
|
|
000e2 ff 15 18 00 00
|
|
00 call QWORD PTR _glfw+24
|
|
$LN27@glfwFreeMo:
|
|
000e8 48 8b 15 20 00
|
|
00 00 mov rdx, QWORD PTR _glfw+32
|
|
000ef 48 8b cb mov rcx, rbx
|
|
000f2 ff 15 18 00 00
|
|
00 call QWORD PTR _glfw+24
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
|
|
; 198 : }
|
|
|
|
000f8 48 83 c4 20 add rsp, 32 ; 00000020H
|
|
000fc 5b pop rbx
|
|
$LN40@glfwFreeMo:
|
|
000fd c3 ret 0
|
|
_glfwFreeMonitor ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; COMDAT compareVideoModes
|
|
_TEXT SEGMENT
|
|
fp$ = 8
|
|
sp$ = 16
|
|
compareVideoModes PROC ; COMDAT
|
|
|
|
; 43 : {
|
|
|
|
00000 48 89 5c 24 08 mov QWORD PTR [rsp+8], rbx
|
|
|
|
; 44 : const GLFWvidmode* fm = fp;
|
|
; 45 : const GLFWvidmode* sm = sp;
|
|
; 46 : const int fbpp = fm->redBits + fm->greenBits + fm->blueBits;
|
|
|
|
00005 44 8b 41 10 mov r8d, DWORD PTR [rcx+16]
|
|
00009 4c 8b da mov r11, rdx
|
|
0000c 44 03 41 0c add r8d, DWORD PTR [rcx+12]
|
|
00010 48 8b d9 mov rbx, rcx
|
|
|
|
; 47 : const int sbpp = sm->redBits + sm->greenBits + sm->blueBits;
|
|
; 48 : const int farea = fm->width * fm->height;
|
|
|
|
00013 44 8b 09 mov r9d, DWORD PTR [rcx]
|
|
00016 41 8b c1 mov eax, r9d
|
|
00019 44 03 41 08 add r8d, DWORD PTR [rcx+8]
|
|
0001d 0f af 41 04 imul eax, DWORD PTR [rcx+4]
|
|
00021 44 8b 52 10 mov r10d, DWORD PTR [rdx+16]
|
|
00025 44 03 52 0c add r10d, DWORD PTR [rdx+12]
|
|
00029 44 03 52 08 add r10d, DWORD PTR [rdx+8]
|
|
|
|
; 49 : const int sarea = sm->width * sm->height;
|
|
|
|
0002d 8b 12 mov edx, DWORD PTR [rdx]
|
|
0002f 8b ca mov ecx, edx
|
|
00031 41 0f af 4b 04 imul ecx, DWORD PTR [r11+4]
|
|
|
|
; 50 :
|
|
; 51 : // First sort on color bits per pixel
|
|
; 52 : if (fbpp != sbpp)
|
|
|
|
00036 45 3b c2 cmp r8d, r10d
|
|
00039 74 0c je SHORT $LN2@compareVid
|
|
|
|
; 53 : return fbpp - sbpp;
|
|
|
|
0003b 45 2b c2 sub r8d, r10d
|
|
0003e 41 8b c0 mov eax, r8d
|
|
|
|
; 65 : }
|
|
|
|
00041 48 8b 5c 24 08 mov rbx, QWORD PTR [rsp+8]
|
|
00046 c3 ret 0
|
|
$LN2@compareVid:
|
|
|
|
; 54 :
|
|
; 55 : // Then sort on screen area
|
|
; 56 : if (farea != sarea)
|
|
|
|
00047 3b c1 cmp eax, ecx
|
|
00049 74 08 je SHORT $LN3@compareVid
|
|
|
|
; 57 : return farea - sarea;
|
|
|
|
0004b 2b c1 sub eax, ecx
|
|
|
|
; 65 : }
|
|
|
|
0004d 48 8b 5c 24 08 mov rbx, QWORD PTR [rsp+8]
|
|
00052 c3 ret 0
|
|
$LN3@compareVid:
|
|
|
|
; 58 :
|
|
; 59 : // Then sort on width
|
|
; 60 : if (fm->width != sm->width)
|
|
|
|
00053 44 3b ca cmp r9d, edx
|
|
00056 74 0c je SHORT $LN4@compareVid
|
|
|
|
; 61 : return fm->width - sm->width;
|
|
|
|
00058 44 2b ca sub r9d, edx
|
|
0005b 41 8b c1 mov eax, r9d
|
|
|
|
; 65 : }
|
|
|
|
0005e 48 8b 5c 24 08 mov rbx, QWORD PTR [rsp+8]
|
|
00063 c3 ret 0
|
|
$LN4@compareVid:
|
|
|
|
; 62 :
|
|
; 63 : // Lastly sort on refresh rate
|
|
; 64 : return fm->refreshRate - sm->refreshRate;
|
|
|
|
00064 8b 43 14 mov eax, DWORD PTR [rbx+20]
|
|
00067 41 2b 43 14 sub eax, DWORD PTR [r11+20]
|
|
|
|
; 65 : }
|
|
|
|
0006b 48 8b 5c 24 08 mov rbx, QWORD PTR [rsp+8]
|
|
00070 c3 ret 0
|
|
compareVideoModes ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; COMDAT refreshVideoModes
|
|
_TEXT SEGMENT
|
|
modeCount$ = 32
|
|
__$ArrayPad$ = 40
|
|
monitor$ = 64
|
|
refreshVideoModes PROC ; COMDAT
|
|
|
|
; 70 : {
|
|
|
|
00000 40 53 push rbx
|
|
00002 48 83 ec 30 sub rsp, 48 ; 00000030H
|
|
00006 48 8b 05 00 00
|
|
00 00 mov rax, QWORD PTR __security_cookie
|
|
0000d 48 33 c4 xor rax, rsp
|
|
00010 48 89 44 24 28 mov QWORD PTR __$ArrayPad$[rsp], rax
|
|
|
|
; 71 : int modeCount;
|
|
; 72 : GLFWvidmode* modes;
|
|
; 73 :
|
|
; 74 : if (monitor->modes)
|
|
|
|
00015 48 83 b9 98 00
|
|
00 00 00 cmp QWORD PTR [rcx+152], 0
|
|
0001d 48 8b d9 mov rbx, rcx
|
|
00020 74 18 je SHORT $LN2@refreshVid
|
|
|
|
; 75 : return GLFW_TRUE;
|
|
|
|
00022 b8 01 00 00 00 mov eax, 1
|
|
|
|
; 88 : }
|
|
|
|
00027 48 8b 4c 24 28 mov rcx, QWORD PTR __$ArrayPad$[rsp]
|
|
0002c 48 33 cc xor rcx, rsp
|
|
0002f e8 00 00 00 00 call __security_check_cookie
|
|
00034 48 83 c4 30 add rsp, 48 ; 00000030H
|
|
00038 5b pop rbx
|
|
00039 c3 ret 0
|
|
$LN2@refreshVid:
|
|
|
|
; 76 :
|
|
; 77 : modes = _glfw.platform.getVideoModes(monitor, &modeCount);
|
|
|
|
0003a 48 8d 54 24 20 lea rdx, QWORD PTR modeCount$[rsp]
|
|
0003f 48 89 7c 24 48 mov QWORD PTR [rsp+72], rdi
|
|
00044 ff 15 f0 00 00
|
|
00 call QWORD PTR _glfw+240
|
|
0004a 48 8b f8 mov rdi, rax
|
|
|
|
; 78 : if (!modes)
|
|
|
|
0004d 48 85 c0 test rax, rax
|
|
00050 74 4a je SHORT $LN11@refreshVid
|
|
$LN3@refreshVid:
|
|
|
|
; 79 : return GLFW_FALSE;
|
|
; 80 :
|
|
; 81 : qsort(modes, modeCount, sizeof(GLFWvidmode), compareVideoModes);
|
|
|
|
00052 48 63 54 24 20 movsxd rdx, DWORD PTR modeCount$[rsp]
|
|
00057 4c 8d 0d 00 00
|
|
00 00 lea r9, OFFSET FLAT:compareVideoModes
|
|
0005e 41 b8 18 00 00
|
|
00 mov r8d, 24
|
|
00064 48 8b cf mov rcx, rdi
|
|
00067 ff 15 00 00 00
|
|
00 call QWORD PTR __imp_qsort
|
|
|
|
; 82 :
|
|
; 83 : _glfw_free(monitor->modes);
|
|
|
|
0006d 48 8b 8b 98 00
|
|
00 00 mov rcx, QWORD PTR [rbx+152]
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 320 : if (block)
|
|
|
|
00074 48 85 c9 test rcx, rcx
|
|
00077 74 0d je SHORT $LN6@refreshVid
|
|
|
|
; 321 : _glfw.allocator.deallocate(block, _glfw.allocator.user);
|
|
|
|
00079 48 8b 15 20 00
|
|
00 00 mov rdx, QWORD PTR _glfw+32
|
|
00080 ff 15 18 00 00
|
|
00 call QWORD PTR _glfw+24
|
|
$LN6@refreshVid:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
|
|
; 85 : monitor->modeCount = modeCount;
|
|
|
|
00086 8b 44 24 20 mov eax, DWORD PTR modeCount$[rsp]
|
|
0008a 89 83 a0 00 00
|
|
00 mov DWORD PTR [rbx+160], eax
|
|
|
|
; 86 :
|
|
; 87 : return GLFW_TRUE;
|
|
|
|
00090 b8 01 00 00 00 mov eax, 1
|
|
00095 48 89 bb 98 00
|
|
00 00 mov QWORD PTR [rbx+152], rdi
|
|
$LN11@refreshVid:
|
|
0009c 48 8b 7c 24 48 mov rdi, QWORD PTR [rsp+72]
|
|
|
|
; 88 : }
|
|
|
|
000a1 48 8b 4c 24 28 mov rcx, QWORD PTR __$ArrayPad$[rsp]
|
|
000a6 48 33 cc xor rcx, rsp
|
|
000a9 e8 00 00 00 00 call __security_check_cookie
|
|
000ae 48 83 c4 30 add rsp, 48 ; 00000030H
|
|
000b2 5b pop rbx
|
|
000b3 c3 ret 0
|
|
refreshVideoModes ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; COMDAT _glfwInputMonitor
|
|
_TEXT SEGMENT
|
|
height$1 = 64
|
|
width$2 = 68
|
|
yoff$3 = 72
|
|
xoff$4 = 76
|
|
__$ArrayPad$ = 80
|
|
monitor$ = 128
|
|
action$ = 136
|
|
placement$ = 144
|
|
_glfwInputMonitor PROC ; COMDAT
|
|
|
|
; 98 : {
|
|
|
|
$LN63:
|
|
00000 40 56 push rsi
|
|
00002 48 83 ec 70 sub rsp, 112 ; 00000070H
|
|
00006 48 8b 05 00 00
|
|
00 00 mov rax, QWORD PTR __security_cookie
|
|
0000d 48 33 c4 xor rax, rsp
|
|
00010 48 89 44 24 50 mov QWORD PTR __$ArrayPad$[rsp], rax
|
|
00015 48 89 9c 24 90
|
|
00 00 00 mov QWORD PTR [rsp+144], rbx
|
|
0001d 48 8b f1 mov rsi, rcx
|
|
00020 48 89 6c 24 68 mov QWORD PTR [rsp+104], rbp
|
|
00025 8b ea mov ebp, edx
|
|
00027 48 89 7c 24 60 mov QWORD PTR [rsp+96], rdi
|
|
0002c 41 8b f8 mov edi, r8d
|
|
|
|
; 99 : assert(monitor != NULL);
|
|
; 100 : assert(action == GLFW_CONNECTED || action == GLFW_DISCONNECTED);
|
|
; 101 : assert(placement == _GLFW_INSERT_FIRST || placement == _GLFW_INSERT_LAST);
|
|
; 102 :
|
|
; 103 : if (action == GLFW_CONNECTED)
|
|
|
|
0002f 81 fa 01 00 04
|
|
00 cmp edx, 262145 ; 00040001H
|
|
00035 0f 85 fb 00 00
|
|
00 jne $LN8@glfwInputM
|
|
|
|
; 104 : {
|
|
; 105 : _glfw.monitorCount++;
|
|
|
|
0003b 8b 05 88 07 00
|
|
00 mov eax, DWORD PTR _glfw+1928
|
|
|
|
; 106 : _glfw.monitors =
|
|
|
|
00041 48 8b 0d 80 07
|
|
00 00 mov rcx, QWORD PTR _glfw+1920
|
|
00048 ff c0 inc eax
|
|
0004a 48 63 d8 movsxd rbx, eax
|
|
0004d 48 c1 e3 03 shl rbx, 3
|
|
00051 89 05 88 07 00
|
|
00 mov DWORD PTR _glfw+1928, eax
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 298 : if (block && size)
|
|
|
|
00057 48 85 c9 test rcx, rcx
|
|
0005a 74 73 je SHORT $LN23@glfwInputM
|
|
0005c 48 85 db test rbx, rbx
|
|
0005f 74 5f je SHORT $LN19@glfwInputM
|
|
|
|
; 299 : {
|
|
; 300 : void* resized = _glfw.allocator.reallocate(block, size, _glfw.allocator.user);
|
|
|
|
00061 4c 8b 05 20 00
|
|
00 00 mov r8, QWORD PTR _glfw+32
|
|
00068 48 8b d3 mov rdx, rbx
|
|
0006b ff 15 10 00 00
|
|
00 call QWORD PTR _glfw+16
|
|
00071 48 8b d8 mov rbx, rax
|
|
|
|
; 301 : if (resized)
|
|
|
|
00074 48 85 c0 test rax, rax
|
|
00077 75 0e jne SHORT $LN31@glfwInputM
|
|
$LN33@glfwInputM:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
|
|
; 106 : _glfw.monitors =
|
|
|
|
00079 33 d2 xor edx, edx
|
|
0007b b9 05 00 01 00 mov ecx, 65541 ; 00010005H
|
|
$LN61@glfwInputM:
|
|
00080 e8 00 00 00 00 call _glfwInputError
|
|
$LN30@glfwInputM:
|
|
00085 33 db xor ebx, ebx
|
|
$LN31@glfwInputM:
|
|
00087 48 89 1d 80 07
|
|
00 00 mov QWORD PTR _glfw+1920, rbx
|
|
|
|
; 107 : _glfw_realloc(_glfw.monitors,
|
|
; 108 : sizeof(_GLFWmonitor*) * _glfw.monitorCount);
|
|
; 109 :
|
|
; 110 : if (placement == _GLFW_INSERT_FIRST)
|
|
|
|
0008e 85 ff test edi, edi
|
|
00090 0f 85 8c 00 00
|
|
00 jne $LN10@glfwInputM
|
|
|
|
; 111 : {
|
|
; 112 : memmove(_glfw.monitors + 1,
|
|
|
|
00096 4c 63 05 88 07
|
|
00 00 movsxd r8, DWORD PTR _glfw+1928
|
|
0009d 48 8d 4b 08 lea rcx, QWORD PTR [rbx+8]
|
|
000a1 48 8b d3 mov rdx, rbx
|
|
000a4 4e 8d 04 c5 f8
|
|
ff ff ff lea r8, QWORD PTR [r8*8-8]
|
|
000ac e8 00 00 00 00 call memmove
|
|
|
|
; 113 : _glfw.monitors,
|
|
; 114 : ((size_t) _glfw.monitorCount - 1) * sizeof(_GLFWmonitor*));
|
|
; 115 : _glfw.monitors[0] = monitor;
|
|
|
|
000b1 48 8b 05 80 07
|
|
00 00 mov rax, QWORD PTR _glfw+1920
|
|
000b8 48 89 30 mov QWORD PTR [rax], rsi
|
|
|
|
; 116 : }
|
|
|
|
000bb e9 4a 01 00 00 jmp $LN6@glfwInputM
|
|
$LN19@glfwInputM:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 321 : _glfw.allocator.deallocate(block, _glfw.allocator.user);
|
|
|
|
000c0 48 8b 15 20 00
|
|
00 00 mov rdx, QWORD PTR _glfw+32
|
|
000c7 ff 15 18 00 00
|
|
00 call QWORD PTR _glfw+24
|
|
|
|
; 312 : return NULL;
|
|
|
|
000cd eb b6 jmp SHORT $LN30@glfwInputM
|
|
$LN23@glfwInputM:
|
|
|
|
; 273 : if (count && size)
|
|
|
|
000cf 48 85 db test rbx, rbx
|
|
000d2 74 b1 je SHORT $LN30@glfwInputM
|
|
|
|
; 274 : {
|
|
; 275 : void* block;
|
|
; 276 :
|
|
; 277 : if (count > SIZE_MAX / size)
|
|
|
|
000d4 33 d2 xor edx, edx
|
|
000d6 48 c7 c0 ff ff
|
|
ff ff mov rax, -1
|
|
000dd 48 f7 f3 div rbx
|
|
000e0 48 83 f8 01 cmp rax, 1
|
|
000e4 73 0e jae SHORT $LN32@glfwInputM
|
|
|
|
; 278 : {
|
|
; 279 : _glfwInputError(GLFW_INVALID_VALUE, "Allocation size overflow");
|
|
|
|
000e6 48 8d 15 00 00
|
|
00 00 lea rdx, OFFSET FLAT:??_C@_0BJ@IHHANIOG@Allocation?5size?5overflow@
|
|
000ed b9 04 00 01 00 mov ecx, 65540 ; 00010004H
|
|
|
|
; 280 : return NULL;
|
|
|
|
000f2 eb 8c jmp SHORT $LN61@glfwInputM
|
|
$LN32@glfwInputM:
|
|
|
|
; 281 : }
|
|
; 282 :
|
|
; 283 : block = _glfw.allocator.allocate(count * size, _glfw.allocator.user);
|
|
|
|
000f4 48 8b 15 20 00
|
|
00 00 mov rdx, QWORD PTR _glfw+32
|
|
000fb 48 8b cb mov rcx, rbx
|
|
000fe ff 15 08 00 00
|
|
00 call QWORD PTR _glfw+8
|
|
|
|
; 284 : if (block)
|
|
|
|
00104 48 85 c0 test rax, rax
|
|
00107 0f 84 6c ff ff
|
|
ff je $LN33@glfwInputM
|
|
|
|
; 285 : return memset(block, 0, count * size);
|
|
|
|
0010d 4c 8b c3 mov r8, rbx
|
|
00110 33 d2 xor edx, edx
|
|
00112 48 8b c8 mov rcx, rax
|
|
00115 e8 00 00 00 00 call memset
|
|
0011a 48 8b d8 mov rbx, rax
|
|
0011d e9 65 ff ff ff jmp $LN31@glfwInputM
|
|
$LN10@glfwInputM:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
|
|
; 118 : _glfw.monitors[_glfw.monitorCount - 1] = monitor;
|
|
|
|
00122 8b 05 88 07 00
|
|
00 mov eax, DWORD PTR _glfw+1928
|
|
00128 ff c8 dec eax
|
|
0012a 48 63 c8 movsxd rcx, eax
|
|
0012d 48 89 34 cb mov QWORD PTR [rbx+rcx*8], rsi
|
|
|
|
; 119 : }
|
|
|
|
00131 e9 d4 00 00 00 jmp $LN6@glfwInputM
|
|
$LN8@glfwInputM:
|
|
|
|
; 120 : else if (action == GLFW_DISCONNECTED)
|
|
|
|
00136 81 fd 02 00 04
|
|
00 cmp ebp, 262146 ; 00040002H
|
|
0013c 0f 85 c8 00 00
|
|
00 jne $LN6@glfwInputM
|
|
|
|
; 121 : {
|
|
; 122 : int i;
|
|
; 123 : _GLFWwindow* window;
|
|
; 124 :
|
|
; 125 : for (window = _glfw.windowListHead; window; window = window->next)
|
|
|
|
00142 48 8b 3d 78 07
|
|
00 00 mov rdi, QWORD PTR _glfw+1912
|
|
00149 33 db xor ebx, ebx
|
|
0014b 48 85 ff test rdi, rdi
|
|
0014e 74 73 je SHORT $LN3@glfwInputM
|
|
$LL4@glfwInputM:
|
|
|
|
; 126 : {
|
|
; 127 : if (window->monitor == monitor)
|
|
|
|
00150 48 39 77 50 cmp QWORD PTR [rdi+80], rsi
|
|
00154 75 65 jne SHORT $LN2@glfwInputM
|
|
|
|
; 128 : {
|
|
; 129 : int width, height, xoff, yoff;
|
|
; 130 : _glfw.platform.getWindowSize(window, &width, &height);
|
|
|
|
00156 4c 8d 44 24 40 lea r8, QWORD PTR height$1[rsp]
|
|
0015b 48 8b cf mov rcx, rdi
|
|
0015e 48 8d 54 24 44 lea rdx, QWORD PTR width$2[rsp]
|
|
00163 ff 15 40 01 00
|
|
00 call QWORD PTR _glfw+320
|
|
|
|
; 131 : _glfw.platform.setWindowMonitor(window, NULL, 0, 0, width, height, 0);
|
|
|
|
00169 8b 44 24 40 mov eax, DWORD PTR height$1[rsp]
|
|
0016d 45 33 c9 xor r9d, r9d
|
|
00170 89 5c 24 30 mov DWORD PTR [rsp+48], ebx
|
|
00174 45 33 c0 xor r8d, r8d
|
|
00177 89 44 24 28 mov DWORD PTR [rsp+40], eax
|
|
0017b 33 d2 xor edx, edx
|
|
0017d 8b 44 24 44 mov eax, DWORD PTR width$2[rsp]
|
|
00181 48 8b cf mov rcx, rdi
|
|
00184 89 44 24 20 mov DWORD PTR [rsp+32], eax
|
|
00188 ff 15 b0 01 00
|
|
00 call QWORD PTR _glfw+432
|
|
|
|
; 132 : _glfw.platform.getWindowFrameSize(window, &xoff, &yoff, NULL, NULL);
|
|
|
|
0018e 45 33 c9 xor r9d, r9d
|
|
00191 48 89 5c 24 20 mov QWORD PTR [rsp+32], rbx
|
|
00196 4c 8d 44 24 48 lea r8, QWORD PTR yoff$3[rsp]
|
|
0019b 48 8b cf mov rcx, rdi
|
|
0019e 48 8d 54 24 4c lea rdx, QWORD PTR xoff$4[rsp]
|
|
001a3 ff 15 68 01 00
|
|
00 call QWORD PTR _glfw+360
|
|
|
|
; 133 : _glfw.platform.setWindowPos(window, xoff, yoff);
|
|
|
|
001a9 44 8b 44 24 48 mov r8d, DWORD PTR yoff$3[rsp]
|
|
001ae 48 8b cf mov rcx, rdi
|
|
001b1 8b 54 24 4c mov edx, DWORD PTR xoff$4[rsp]
|
|
001b5 ff 15 38 01 00
|
|
00 call QWORD PTR _glfw+312
|
|
$LN2@glfwInputM:
|
|
|
|
; 121 : {
|
|
; 122 : int i;
|
|
; 123 : _GLFWwindow* window;
|
|
; 124 :
|
|
; 125 : for (window = _glfw.windowListHead; window; window = window->next)
|
|
|
|
001bb 48 8b 3f mov rdi, QWORD PTR [rdi]
|
|
001be 48 85 ff test rdi, rdi
|
|
001c1 75 8d jne SHORT $LL4@glfwInputM
|
|
$LN3@glfwInputM:
|
|
|
|
; 134 : }
|
|
; 135 : }
|
|
; 136 :
|
|
; 137 : for (i = 0; i < _glfw.monitorCount; i++)
|
|
|
|
001c3 8b 15 88 07 00
|
|
00 mov edx, DWORD PTR _glfw+1928
|
|
001c9 85 d2 test edx, edx
|
|
001cb 7e 3d jle SHORT $LN6@glfwInputM
|
|
001cd 48 8b 0d 80 07
|
|
00 00 mov rcx, QWORD PTR _glfw+1920
|
|
001d4 48 8b c1 mov rax, rcx
|
|
$LL7@glfwInputM:
|
|
|
|
; 138 : {
|
|
; 139 : if (_glfw.monitors[i] == monitor)
|
|
|
|
001d7 48 39 30 cmp QWORD PTR [rax], rsi
|
|
001da 74 0c je SHORT $LN38@glfwInputM
|
|
|
|
; 134 : }
|
|
; 135 : }
|
|
; 136 :
|
|
; 137 : for (i = 0; i < _glfw.monitorCount; i++)
|
|
|
|
001dc ff c3 inc ebx
|
|
001de 48 83 c0 08 add rax, 8
|
|
001e2 3b da cmp ebx, edx
|
|
001e4 7c f1 jl SHORT $LL7@glfwInputM
|
|
|
|
; 138 : {
|
|
; 139 : if (_glfw.monitors[i] == monitor)
|
|
|
|
001e6 eb 22 jmp SHORT $LN6@glfwInputM
|
|
$LN38@glfwInputM:
|
|
|
|
; 140 : {
|
|
; 141 : _glfw.monitorCount--;
|
|
|
|
001e8 ff ca dec edx
|
|
|
|
; 142 : memmove(_glfw.monitors + i,
|
|
|
|
001ea 48 63 c3 movsxd rax, ebx
|
|
001ed 4c 63 c2 movsxd r8, edx
|
|
001f0 4c 2b c0 sub r8, rax
|
|
001f3 89 15 88 07 00
|
|
00 mov DWORD PTR _glfw+1928, edx
|
|
001f9 49 c1 e0 03 shl r8, 3
|
|
001fd 48 8d 0c c1 lea rcx, QWORD PTR [rcx+rax*8]
|
|
00201 48 8d 51 08 lea rdx, QWORD PTR [rcx+8]
|
|
00205 e8 00 00 00 00 call memmove
|
|
$LN6@glfwInputM:
|
|
|
|
; 143 : _glfw.monitors + i + 1,
|
|
; 144 : ((size_t) _glfw.monitorCount - i) * sizeof(_GLFWmonitor*));
|
|
; 145 : break;
|
|
; 146 : }
|
|
; 147 : }
|
|
; 148 : }
|
|
; 149 :
|
|
; 150 : if (_glfw.callbacks.monitor)
|
|
|
|
0020a 48 8b 05 68 1b
|
|
00 00 mov rax, QWORD PTR _glfw+7016
|
|
00211 48 8b 7c 24 60 mov rdi, QWORD PTR [rsp+96]
|
|
00216 48 8b 9c 24 90
|
|
00 00 00 mov rbx, QWORD PTR [rsp+144]
|
|
0021e 48 85 c0 test rax, rax
|
|
00221 74 07 je SHORT $LN15@glfwInputM
|
|
|
|
; 151 : _glfw.callbacks.monitor((GLFWmonitor*) monitor, action);
|
|
|
|
00223 8b d5 mov edx, ebp
|
|
00225 48 8b ce mov rcx, rsi
|
|
00228 ff d0 call rax
|
|
$LN15@glfwInputM:
|
|
|
|
; 152 :
|
|
; 153 : if (action == GLFW_DISCONNECTED)
|
|
|
|
0022a 81 fd 02 00 04
|
|
00 cmp ebp, 262146 ; 00040002H
|
|
00230 48 8b 6c 24 68 mov rbp, QWORD PTR [rsp+104]
|
|
00235 75 08 jne SHORT $LN16@glfwInputM
|
|
|
|
; 154 : _glfwFreeMonitor(monitor);
|
|
|
|
00237 48 8b ce mov rcx, rsi
|
|
0023a e8 00 00 00 00 call _glfwFreeMonitor
|
|
$LN16@glfwInputM:
|
|
|
|
; 155 : }
|
|
|
|
0023f 48 8b 4c 24 50 mov rcx, QWORD PTR __$ArrayPad$[rsp]
|
|
00244 48 33 cc xor rcx, rsp
|
|
00247 e8 00 00 00 00 call __security_check_cookie
|
|
0024c 48 83 c4 70 add rsp, 112 ; 00000070H
|
|
00250 5e pop rsi
|
|
00251 c3 ret 0
|
|
_glfwInputMonitor ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; COMDAT _glfwInputMonitorWindow
|
|
_TEXT SEGMENT
|
|
monitor$ = 8
|
|
window$ = 16
|
|
_glfwInputMonitorWindow PROC ; COMDAT
|
|
|
|
; 162 : assert(monitor != NULL);
|
|
; 163 : monitor->window = window;
|
|
|
|
00000 48 89 91 90 00
|
|
00 00 mov QWORD PTR [rcx+144], rdx
|
|
|
|
; 164 : }
|
|
|
|
00007 c3 ret 0
|
|
_glfwInputMonitorWindow ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; COMDAT _glfwAllocMonitor
|
|
_TEXT SEGMENT
|
|
name$ = 48
|
|
widthMM$ = 56
|
|
heightMM$ = 64
|
|
_glfwAllocMonitor PROC ; COMDAT
|
|
|
|
; 174 : {
|
|
|
|
$LN12:
|
|
00000 48 89 5c 24 08 mov QWORD PTR [rsp+8], rbx
|
|
00005 48 89 6c 24 10 mov QWORD PTR [rsp+16], rbp
|
|
0000a 48 89 74 24 18 mov QWORD PTR [rsp+24], rsi
|
|
0000f 57 push rdi
|
|
00010 48 83 ec 20 sub rsp, 32 ; 00000020H
|
|
00014 8b f2 mov esi, edx
|
|
00016 48 8b e9 mov rbp, rcx
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 283 : block = _glfw.allocator.allocate(count * size, _glfw.allocator.user);
|
|
|
|
00019 48 8b 15 20 00
|
|
00 00 mov rdx, QWORD PTR _glfw+32
|
|
00020 b9 f0 01 00 00 mov ecx, 496 ; 000001f0H
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
|
|
; 174 : {
|
|
|
|
00025 41 8b f8 mov edi, r8d
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 283 : block = _glfw.allocator.allocate(count * size, _glfw.allocator.user);
|
|
|
|
00028 ff 15 08 00 00
|
|
00 call QWORD PTR _glfw+8
|
|
|
|
; 284 : if (block)
|
|
|
|
0002e 48 85 c0 test rax, rax
|
|
00031 74 15 je SHORT $LN7@glfwAllocM
|
|
|
|
; 285 : return memset(block, 0, count * size);
|
|
|
|
00033 33 d2 xor edx, edx
|
|
00035 41 b8 f0 01 00
|
|
00 mov r8d, 496 ; 000001f0H
|
|
0003b 48 8b c8 mov rcx, rax
|
|
0003e e8 00 00 00 00 call memset
|
|
00043 48 8b d8 mov rbx, rax
|
|
00046 eb 0e jmp SHORT $LN5@glfwAllocM
|
|
$LN7@glfwAllocM:
|
|
|
|
; 286 : else
|
|
; 287 : {
|
|
; 288 : _glfwInputError(GLFW_OUT_OF_MEMORY, NULL);
|
|
|
|
00048 33 d2 xor edx, edx
|
|
0004a b9 05 00 01 00 mov ecx, 65541 ; 00010005H
|
|
0004f e8 00 00 00 00 call _glfwInputError
|
|
|
|
; 289 : return NULL;
|
|
|
|
00054 33 db xor ebx, ebx
|
|
$LN5@glfwAllocM:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
|
|
; 179 : strncpy(monitor->name, name, sizeof(monitor->name) - 1);
|
|
|
|
00056 41 b8 7f 00 00
|
|
00 mov r8d, 127 ; 0000007fH
|
|
0005c 89 b3 88 00 00
|
|
00 mov DWORD PTR [rbx+136], esi
|
|
00062 48 8b d5 mov rdx, rbp
|
|
00065 89 bb 8c 00 00
|
|
00 mov DWORD PTR [rbx+140], edi
|
|
0006b 48 8b cb mov rcx, rbx
|
|
0006e ff 15 00 00 00
|
|
00 call QWORD PTR __imp_strncpy
|
|
|
|
; 180 :
|
|
; 181 : return monitor;
|
|
; 182 : }
|
|
|
|
00074 48 8b 6c 24 38 mov rbp, QWORD PTR [rsp+56]
|
|
00079 48 8b c3 mov rax, rbx
|
|
0007c 48 8b 5c 24 30 mov rbx, QWORD PTR [rsp+48]
|
|
00081 48 8b 74 24 40 mov rsi, QWORD PTR [rsp+64]
|
|
00086 48 83 c4 20 add rsp, 32 ; 00000020H
|
|
0008a 5f pop rdi
|
|
0008b c3 ret 0
|
|
_glfwAllocMonitor ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; COMDAT _glfwAllocGammaArrays
|
|
_TEXT SEGMENT
|
|
ramp$ = 48
|
|
size$ = 56
|
|
_glfwAllocGammaArrays PROC ; COMDAT
|
|
|
|
; 203 : {
|
|
|
|
$LN32:
|
|
00000 48 89 5c 24 10 mov QWORD PTR [rsp+16], rbx
|
|
00005 48 89 6c 24 18 mov QWORD PTR [rsp+24], rbp
|
|
0000a 48 89 74 24 20 mov QWORD PTR [rsp+32], rsi
|
|
0000f 57 push rdi
|
|
00010 48 83 ec 20 sub rsp, 32 ; 00000020H
|
|
00014 8b ea mov ebp, edx
|
|
00016 48 8b d9 mov rbx, rcx
|
|
|
|
; 204 : ramp->red = _glfw_calloc(size, sizeof(unsigned short));
|
|
|
|
00019 8b f2 mov esi, edx
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 273 : if (count && size)
|
|
|
|
0001b 85 d2 test edx, edx
|
|
0001d 0f 84 cc 00 00
|
|
00 je $LN4@glfwAllocG
|
|
|
|
; 274 : {
|
|
; 275 : void* block;
|
|
; 276 :
|
|
; 277 : if (count > SIZE_MAX / size)
|
|
; 278 : {
|
|
; 279 : _glfwInputError(GLFW_INVALID_VALUE, "Allocation size overflow");
|
|
; 280 : return NULL;
|
|
; 281 : }
|
|
; 282 :
|
|
; 283 : block = _glfw.allocator.allocate(count * size, _glfw.allocator.user);
|
|
|
|
00023 48 8b 15 20 00
|
|
00 00 mov rdx, QWORD PTR _glfw+32
|
|
0002a 4c 89 74 24 30 mov QWORD PTR [rsp+48], r14
|
|
0002f 4c 8d 34 6d 00
|
|
00 00 00 lea r14, QWORD PTR [rbp*2]
|
|
00037 49 8b ce mov rcx, r14
|
|
0003a ff 15 08 00 00
|
|
00 call QWORD PTR _glfw+8
|
|
|
|
; 284 : if (block)
|
|
|
|
00040 33 ff xor edi, edi
|
|
00042 48 85 c0 test rax, rax
|
|
00045 74 12 je SHORT $LN7@glfwAllocG
|
|
|
|
; 285 : return memset(block, 0, count * size);
|
|
|
|
00047 4d 8b c6 mov r8, r14
|
|
0004a 33 d2 xor edx, edx
|
|
0004c 48 8b c8 mov rcx, rax
|
|
0004f e8 00 00 00 00 call memset
|
|
00054 48 89 03 mov QWORD PTR [rbx], rax
|
|
00057 eb 0f jmp SHORT $LN30@glfwAllocG
|
|
$LN7@glfwAllocG:
|
|
|
|
; 286 : else
|
|
; 287 : {
|
|
; 288 : _glfwInputError(GLFW_OUT_OF_MEMORY, NULL);
|
|
|
|
00059 33 d2 xor edx, edx
|
|
0005b b9 05 00 01 00 mov ecx, 65541 ; 00010005H
|
|
00060 e8 00 00 00 00 call _glfwInputError
|
|
|
|
; 289 : return NULL;
|
|
|
|
00065 48 89 3b mov QWORD PTR [rbx], rdi
|
|
$LN30@glfwAllocG:
|
|
|
|
; 283 : block = _glfw.allocator.allocate(count * size, _glfw.allocator.user);
|
|
|
|
00068 48 8b 15 20 00
|
|
00 00 mov rdx, QWORD PTR _glfw+32
|
|
0006f 48 8b c6 mov rax, rsi
|
|
00072 4c 8d 34 00 lea r14, QWORD PTR [rax+rax]
|
|
00076 49 8b ce mov rcx, r14
|
|
00079 ff 15 08 00 00
|
|
00 call QWORD PTR _glfw+8
|
|
|
|
; 284 : if (block)
|
|
|
|
0007f 48 85 c0 test rax, rax
|
|
00082 74 13 je SHORT $LN14@glfwAllocG
|
|
|
|
; 285 : return memset(block, 0, count * size);
|
|
|
|
00084 4d 8b c6 mov r8, r14
|
|
00087 33 d2 xor edx, edx
|
|
00089 48 8b c8 mov rcx, rax
|
|
0008c e8 00 00 00 00 call memset
|
|
00091 48 89 43 08 mov QWORD PTR [rbx+8], rax
|
|
00095 eb 10 jmp SHORT $LN24@glfwAllocG
|
|
$LN14@glfwAllocG:
|
|
|
|
; 286 : else
|
|
; 287 : {
|
|
; 288 : _glfwInputError(GLFW_OUT_OF_MEMORY, NULL);
|
|
|
|
00097 33 d2 xor edx, edx
|
|
00099 b9 05 00 01 00 mov ecx, 65541 ; 00010005H
|
|
0009e e8 00 00 00 00 call _glfwInputError
|
|
|
|
; 289 : return NULL;
|
|
|
|
000a3 48 89 7b 08 mov QWORD PTR [rbx+8], rdi
|
|
$LN24@glfwAllocG:
|
|
|
|
; 283 : block = _glfw.allocator.allocate(count * size, _glfw.allocator.user);
|
|
|
|
000a7 48 8b 15 20 00
|
|
00 00 mov rdx, QWORD PTR _glfw+32
|
|
000ae 48 03 f6 add rsi, rsi
|
|
000b1 48 8b ce mov rcx, rsi
|
|
000b4 ff 15 08 00 00
|
|
00 call QWORD PTR _glfw+8
|
|
000ba 4c 8b 74 24 30 mov r14, QWORD PTR [rsp+48]
|
|
|
|
; 284 : if (block)
|
|
|
|
000bf 48 85 c0 test rax, rax
|
|
000c2 74 16 je SHORT $LN21@glfwAllocG
|
|
|
|
; 285 : return memset(block, 0, count * size);
|
|
|
|
000c4 4c 8b c6 mov r8, rsi
|
|
000c7 33 d2 xor edx, edx
|
|
000c9 48 8b c8 mov rcx, rax
|
|
000cc e8 00 00 00 00 call memset
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
|
|
; 206 : ramp->blue = _glfw_calloc(size, sizeof(unsigned short));
|
|
|
|
000d1 48 89 43 10 mov QWORD PTR [rbx+16], rax
|
|
|
|
; 207 : ramp->size = size;
|
|
|
|
000d5 89 6b 18 mov DWORD PTR [rbx+24], ebp
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 285 : return memset(block, 0, count * size);
|
|
|
|
000d8 eb 25 jmp SHORT $LN19@glfwAllocG
|
|
$LN21@glfwAllocG:
|
|
|
|
; 286 : else
|
|
; 287 : {
|
|
; 288 : _glfwInputError(GLFW_OUT_OF_MEMORY, NULL);
|
|
|
|
000da 33 d2 xor edx, edx
|
|
000dc b9 05 00 01 00 mov ecx, 65541 ; 00010005H
|
|
000e1 e8 00 00 00 00 call _glfwInputError
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
|
|
; 206 : ramp->blue = _glfw_calloc(size, sizeof(unsigned short));
|
|
|
|
000e6 48 89 7b 10 mov QWORD PTR [rbx+16], rdi
|
|
|
|
; 207 : ramp->size = size;
|
|
|
|
000ea 89 6b 18 mov DWORD PTR [rbx+24], ebp
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 289 : return NULL;
|
|
|
|
000ed eb 10 jmp SHORT $LN19@glfwAllocG
|
|
$LN4@glfwAllocG:
|
|
|
|
; 293 : return NULL;
|
|
|
|
000ef 33 ff xor edi, edi
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
|
|
; 207 : ramp->size = size;
|
|
|
|
000f1 89 69 18 mov DWORD PTR [rcx+24], ebp
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 293 : return NULL;
|
|
|
|
000f4 48 89 39 mov QWORD PTR [rcx], rdi
|
|
000f7 48 89 79 08 mov QWORD PTR [rcx+8], rdi
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
|
|
; 206 : ramp->blue = _glfw_calloc(size, sizeof(unsigned short));
|
|
|
|
000fb 48 89 79 10 mov QWORD PTR [rcx+16], rdi
|
|
$LN19@glfwAllocG:
|
|
|
|
; 208 : }
|
|
|
|
000ff 48 8b 5c 24 38 mov rbx, QWORD PTR [rsp+56]
|
|
00104 48 8b 6c 24 40 mov rbp, QWORD PTR [rsp+64]
|
|
00109 48 8b 74 24 48 mov rsi, QWORD PTR [rsp+72]
|
|
0010e 48 83 c4 20 add rsp, 32 ; 00000020H
|
|
00112 5f pop rdi
|
|
00113 c3 ret 0
|
|
_glfwAllocGammaArrays ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; COMDAT _glfwFreeGammaArrays
|
|
_TEXT SEGMENT
|
|
ramp$ = 48
|
|
_glfwFreeGammaArrays PROC ; COMDAT
|
|
|
|
; 213 : {
|
|
|
|
$LN16:
|
|
00000 40 53 push rbx
|
|
00002 48 83 ec 20 sub rsp, 32 ; 00000020H
|
|
00006 48 8b d9 mov rbx, rcx
|
|
|
|
; 214 : _glfw_free(ramp->red);
|
|
|
|
00009 48 8b 09 mov rcx, QWORD PTR [rcx]
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 320 : if (block)
|
|
|
|
0000c 48 85 c9 test rcx, rcx
|
|
0000f 74 0d je SHORT $LN4@glfwFreeGa
|
|
|
|
; 321 : _glfw.allocator.deallocate(block, _glfw.allocator.user);
|
|
|
|
00011 48 8b 15 20 00
|
|
00 00 mov rdx, QWORD PTR _glfw+32
|
|
00018 ff 15 18 00 00
|
|
00 call QWORD PTR _glfw+24
|
|
$LN4@glfwFreeGa:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
|
|
; 215 : _glfw_free(ramp->green);
|
|
|
|
0001e 48 8b 4b 08 mov rcx, QWORD PTR [rbx+8]
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 320 : if (block)
|
|
|
|
00022 48 85 c9 test rcx, rcx
|
|
00025 74 0d je SHORT $LN7@glfwFreeGa
|
|
|
|
; 321 : _glfw.allocator.deallocate(block, _glfw.allocator.user);
|
|
|
|
00027 48 8b 15 20 00
|
|
00 00 mov rdx, QWORD PTR _glfw+32
|
|
0002e ff 15 18 00 00
|
|
00 call QWORD PTR _glfw+24
|
|
$LN7@glfwFreeGa:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
|
|
; 216 : _glfw_free(ramp->blue);
|
|
|
|
00034 48 8b 4b 10 mov rcx, QWORD PTR [rbx+16]
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 320 : if (block)
|
|
|
|
00038 48 85 c9 test rcx, rcx
|
|
0003b 74 0d je SHORT $LN10@glfwFreeGa
|
|
|
|
; 321 : _glfw.allocator.deallocate(block, _glfw.allocator.user);
|
|
|
|
0003d 48 8b 15 20 00
|
|
00 00 mov rdx, QWORD PTR _glfw+32
|
|
00044 ff 15 18 00 00
|
|
00 call QWORD PTR _glfw+24
|
|
$LN10@glfwFreeGa:
|
|
0004a 0f 57 c0 xorps xmm0, xmm0
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
|
|
; 218 : memset(ramp, 0, sizeof(GLFWgammaramp));
|
|
|
|
0004d 0f 11 03 movups XMMWORD PTR [rbx], xmm0
|
|
00050 0f 11 43 10 movups XMMWORD PTR [rbx+16], xmm0
|
|
|
|
; 219 : }
|
|
|
|
00054 48 83 c4 20 add rsp, 32 ; 00000020H
|
|
00058 5b pop rbx
|
|
00059 c3 ret 0
|
|
_glfwFreeGammaArrays ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; COMDAT _glfwChooseVideoMode
|
|
_TEXT SEGMENT
|
|
tv527 = 32
|
|
monitor$ = 112
|
|
desired$ = 120
|
|
$T1 = 128
|
|
$T2 = 136
|
|
_glfwChooseVideoMode PROC ; COMDAT
|
|
|
|
; 225 : {
|
|
|
|
$LN52:
|
|
00000 40 53 push rbx
|
|
00002 55 push rbp
|
|
00003 56 push rsi
|
|
00004 57 push rdi
|
|
00005 41 55 push r13
|
|
00007 41 56 push r14
|
|
00009 41 57 push r15
|
|
0000b 48 83 ec 30 sub rsp, 48 ; 00000030H
|
|
|
|
; 226 : int i;
|
|
; 227 : unsigned int sizeDiff, leastSizeDiff = UINT_MAX;
|
|
|
|
0000f bb ff ff ff ff mov ebx, -1 ; ffffffffH
|
|
|
|
; 228 : unsigned int rateDiff, leastRateDiff = UINT_MAX;
|
|
; 229 : unsigned int colorDiff, leastColorDiff = UINT_MAX;
|
|
; 230 : const GLFWvidmode* current;
|
|
; 231 : const GLFWvidmode* closest = NULL;
|
|
|
|
00014 33 f6 xor esi, esi
|
|
00016 44 8b fb mov r15d, ebx
|
|
00019 8b fb mov edi, ebx
|
|
0001b 44 8b ee mov r13d, esi
|
|
0001e 4c 8b f2 mov r14, rdx
|
|
00021 48 8b e9 mov rbp, rcx
|
|
|
|
; 232 :
|
|
; 233 : if (!refreshVideoModes(monitor))
|
|
|
|
00024 e8 00 00 00 00 call refreshVideoModes
|
|
00029 85 c0 test eax, eax
|
|
0002b 75 11 jne SHORT $LN5@glfwChoose
|
|
|
|
; 234 : return NULL;
|
|
|
|
0002d 33 c0 xor eax, eax
|
|
|
|
; 271 : }
|
|
|
|
0002f 48 83 c4 30 add rsp, 48 ; 00000030H
|
|
00033 41 5f pop r15
|
|
00035 41 5e pop r14
|
|
00037 41 5d pop r13
|
|
00039 5f pop rdi
|
|
0003a 5e pop rsi
|
|
0003b 5d pop rbp
|
|
0003c 5b pop rbx
|
|
0003d c3 ret 0
|
|
$LN5@glfwChoose:
|
|
|
|
; 235 :
|
|
; 236 : for (i = 0; i < monitor->modeCount; i++)
|
|
|
|
0003e 48 63 85 a0 00
|
|
00 00 movsxd rax, DWORD PTR [rbp+160]
|
|
00045 85 c0 test eax, eax
|
|
00047 0f 8e a3 01 00
|
|
00 jle $LN27@glfwChoose
|
|
|
|
; 248 :
|
|
; 249 : sizeDiff = abs((current->width - desired->width) *
|
|
|
|
0004d 41 8b 56 04 mov edx, DWORD PTR [r14+4]
|
|
00051 48 8b 8d 98 00
|
|
00 00 mov rcx, QWORD PTR [rbp+152]
|
|
00058 45 8b 5e 08 mov r11d, DWORD PTR [r14+8]
|
|
0005c 41 8b 6e 10 mov ebp, DWORD PTR [r14+16]
|
|
00060 89 94 24 80 00
|
|
00 00 mov DWORD PTR $T1[rsp], edx
|
|
00067 41 8b 16 mov edx, DWORD PTR [r14]
|
|
0006a 4c 89 64 24 70 mov QWORD PTR [rsp+112], r12
|
|
0006f 45 8b 66 0c mov r12d, DWORD PTR [r14+12]
|
|
|
|
; 250 : (current->width - desired->width) +
|
|
; 251 : (current->height - desired->height) *
|
|
; 252 : (current->height - desired->height));
|
|
; 253 :
|
|
; 254 : if (desired->refreshRate != GLFW_DONT_CARE)
|
|
|
|
00073 45 8b 76 14 mov r14d, DWORD PTR [r14+20]
|
|
00077 89 94 24 88 00
|
|
00 00 mov DWORD PTR $T2[rsp], edx
|
|
0007e 48 89 4c 24 20 mov QWORD PTR tv527[rsp], rcx
|
|
00083 41 83 fb ff cmp r11d, -1
|
|
00087 0f 84 af 00 00
|
|
00 je $LN17@glfwChoose
|
|
0008d 44 8b d0 mov r10d, eax
|
|
$LL4@glfwChoose:
|
|
|
|
; 241 :
|
|
; 242 : if (desired->redBits != GLFW_DONT_CARE)
|
|
; 243 : colorDiff += abs(current->redBits - desired->redBits);
|
|
|
|
00090 8b 44 0e 08 mov eax, DWORD PTR [rsi+rcx+8]
|
|
00094 4c 8d 0c 0e lea r9, QWORD PTR [rsi+rcx]
|
|
00098 41 2b c3 sub eax, r11d
|
|
0009b 99 cdq
|
|
0009c 44 8b c0 mov r8d, eax
|
|
0009f 44 33 c2 xor r8d, edx
|
|
000a2 44 2b c2 sub r8d, edx
|
|
|
|
; 244 : if (desired->greenBits != GLFW_DONT_CARE)
|
|
|
|
000a5 41 83 fc ff cmp r12d, -1
|
|
000a9 74 0f je SHORT $LN7@glfwChoose
|
|
|
|
; 245 : colorDiff += abs(current->greenBits - desired->greenBits);
|
|
|
|
000ab 41 8b 41 0c mov eax, DWORD PTR [r9+12]
|
|
000af 41 2b c4 sub eax, r12d
|
|
000b2 99 cdq
|
|
000b3 33 c2 xor eax, edx
|
|
000b5 2b c2 sub eax, edx
|
|
000b7 44 03 c0 add r8d, eax
|
|
$LN7@glfwChoose:
|
|
|
|
; 246 : if (desired->blueBits != GLFW_DONT_CARE)
|
|
|
|
000ba 83 fd ff cmp ebp, -1
|
|
000bd 74 0e je SHORT $LN8@glfwChoose
|
|
|
|
; 247 : colorDiff += abs(current->blueBits - desired->blueBits);
|
|
|
|
000bf 41 8b 41 10 mov eax, DWORD PTR [r9+16]
|
|
000c3 2b c5 sub eax, ebp
|
|
000c5 99 cdq
|
|
000c6 33 c2 xor eax, edx
|
|
000c8 2b c2 sub eax, edx
|
|
000ca 44 03 c0 add r8d, eax
|
|
$LN8@glfwChoose:
|
|
|
|
; 248 :
|
|
; 249 : sizeDiff = abs((current->width - desired->width) *
|
|
|
|
000cd 41 8b 49 04 mov ecx, DWORD PTR [r9+4]
|
|
000d1 2b 8c 24 80 00
|
|
00 00 sub ecx, DWORD PTR $T1[rsp]
|
|
000d8 41 8b 01 mov eax, DWORD PTR [r9]
|
|
000db 2b 84 24 88 00
|
|
00 00 sub eax, DWORD PTR $T2[rsp]
|
|
000e2 0f af c9 imul ecx, ecx
|
|
000e5 0f af c0 imul eax, eax
|
|
000e8 03 c1 add eax, ecx
|
|
000ea 99 cdq
|
|
000eb 8b c8 mov ecx, eax
|
|
|
|
; 250 : (current->width - desired->width) +
|
|
; 251 : (current->height - desired->height) *
|
|
; 252 : (current->height - desired->height));
|
|
; 253 :
|
|
; 254 : if (desired->refreshRate != GLFW_DONT_CARE)
|
|
|
|
000ed 41 8b 41 14 mov eax, DWORD PTR [r9+20]
|
|
000f1 33 ca xor ecx, edx
|
|
000f3 2b ca sub ecx, edx
|
|
000f5 41 83 fe ff cmp r14d, -1
|
|
000f9 74 0a je SHORT $LN9@glfwChoose
|
|
|
|
; 255 : rateDiff = abs(current->refreshRate - desired->refreshRate);
|
|
|
|
000fb 41 2b c6 sub eax, r14d
|
|
000fe 99 cdq
|
|
000ff 33 c2 xor eax, edx
|
|
00101 2b c2 sub eax, edx
|
|
00103 eb 02 jmp SHORT $LN10@glfwChoose
|
|
$LN9@glfwChoose:
|
|
|
|
; 256 : else
|
|
; 257 : rateDiff = UINT_MAX - current->refreshRate;
|
|
|
|
00105 f7 d0 not eax
|
|
$LN10@glfwChoose:
|
|
|
|
; 258 :
|
|
; 259 : if ((colorDiff < leastColorDiff) ||
|
|
; 260 : (colorDiff == leastColorDiff && sizeDiff < leastSizeDiff) ||
|
|
|
|
00107 44 3b c7 cmp r8d, edi
|
|
0010a 72 0d jb SHORT $LN12@glfwChoose
|
|
0010c 75 16 jne SHORT $LN2@glfwChoose
|
|
0010e 3b cb cmp ecx, ebx
|
|
00110 72 07 jb SHORT $LN12@glfwChoose
|
|
00112 75 10 jne SHORT $LN2@glfwChoose
|
|
00114 41 3b c7 cmp eax, r15d
|
|
00117 73 0b jae SHORT $LN2@glfwChoose
|
|
$LN12@glfwChoose:
|
|
|
|
; 261 : (colorDiff == leastColorDiff && sizeDiff == leastSizeDiff && rateDiff < leastRateDiff))
|
|
; 262 : {
|
|
; 263 : closest = current;
|
|
|
|
00119 4d 8b e9 mov r13, r9
|
|
|
|
; 264 : leastSizeDiff = sizeDiff;
|
|
|
|
0011c 8b d9 mov ebx, ecx
|
|
|
|
; 265 : leastRateDiff = rateDiff;
|
|
|
|
0011e 44 8b f8 mov r15d, eax
|
|
|
|
; 266 : leastColorDiff = colorDiff;
|
|
|
|
00121 41 8b f8 mov edi, r8d
|
|
$LN2@glfwChoose:
|
|
|
|
; 235 :
|
|
; 236 : for (i = 0; i < monitor->modeCount; i++)
|
|
|
|
00124 48 8b 4c 24 20 mov rcx, QWORD PTR tv527[rsp]
|
|
00129 48 83 c6 18 add rsi, 24
|
|
0012d 49 83 ea 01 sub r10, 1
|
|
00131 0f 85 59 ff ff
|
|
ff jne $LL4@glfwChoose
|
|
00137 e9 af 00 00 00 jmp $LN50@glfwChoose
|
|
$LN17@glfwChoose:
|
|
0013c 4c 8b d8 mov r11, rax
|
|
0013f 85 c0 test eax, eax
|
|
00141 0f 8e a4 00 00
|
|
00 jle $LN50@glfwChoose
|
|
|
|
; 244 : if (desired->greenBits != GLFW_DONT_CARE)
|
|
|
|
00147 4c 8b d6 mov r10, rsi
|
|
0014a 66 0f 1f 44 00
|
|
00 npad 6
|
|
$LL18@glfwChoose:
|
|
|
|
; 237 : {
|
|
; 238 : current = monitor->modes + i;
|
|
|
|
00150 4d 8d 0c 0a lea r9, QWORD PTR [r10+rcx]
|
|
|
|
; 239 :
|
|
; 240 : colorDiff = 0;
|
|
|
|
00154 44 8b c6 mov r8d, esi
|
|
|
|
; 244 : if (desired->greenBits != GLFW_DONT_CARE)
|
|
|
|
00157 41 83 fc ff cmp r12d, -1
|
|
0015b 74 11 je SHORT $LN19@glfwChoose
|
|
|
|
; 245 : colorDiff += abs(current->greenBits - desired->greenBits);
|
|
|
|
0015d 41 8b 41 0c mov eax, DWORD PTR [r9+12]
|
|
00161 41 2b c4 sub eax, r12d
|
|
00164 99 cdq
|
|
00165 44 8b c0 mov r8d, eax
|
|
00168 44 33 c2 xor r8d, edx
|
|
0016b 44 2b c2 sub r8d, edx
|
|
$LN19@glfwChoose:
|
|
|
|
; 246 : if (desired->blueBits != GLFW_DONT_CARE)
|
|
|
|
0016e 83 fd ff cmp ebp, -1
|
|
00171 74 0e je SHORT $LN20@glfwChoose
|
|
|
|
; 247 : colorDiff += abs(current->blueBits - desired->blueBits);
|
|
|
|
00173 41 8b 41 10 mov eax, DWORD PTR [r9+16]
|
|
00177 2b c5 sub eax, ebp
|
|
00179 99 cdq
|
|
0017a 33 c2 xor eax, edx
|
|
0017c 2b c2 sub eax, edx
|
|
0017e 44 03 c0 add r8d, eax
|
|
$LN20@glfwChoose:
|
|
|
|
; 248 :
|
|
; 249 : sizeDiff = abs((current->width - desired->width) *
|
|
|
|
00181 41 8b 49 04 mov ecx, DWORD PTR [r9+4]
|
|
00185 2b 8c 24 80 00
|
|
00 00 sub ecx, DWORD PTR $T1[rsp]
|
|
0018c 41 8b 01 mov eax, DWORD PTR [r9]
|
|
0018f 2b 84 24 88 00
|
|
00 00 sub eax, DWORD PTR $T2[rsp]
|
|
00196 0f af c9 imul ecx, ecx
|
|
00199 0f af c0 imul eax, eax
|
|
0019c 03 c1 add eax, ecx
|
|
0019e 99 cdq
|
|
0019f 8b c8 mov ecx, eax
|
|
|
|
; 250 : (current->width - desired->width) +
|
|
; 251 : (current->height - desired->height) *
|
|
; 252 : (current->height - desired->height));
|
|
; 253 :
|
|
; 254 : if (desired->refreshRate != GLFW_DONT_CARE)
|
|
|
|
001a1 41 8b 41 14 mov eax, DWORD PTR [r9+20]
|
|
001a5 33 ca xor ecx, edx
|
|
001a7 2b ca sub ecx, edx
|
|
001a9 41 83 fe ff cmp r14d, -1
|
|
001ad 74 0a je SHORT $LN21@glfwChoose
|
|
|
|
; 255 : rateDiff = abs(current->refreshRate - desired->refreshRate);
|
|
|
|
001af 41 2b c6 sub eax, r14d
|
|
001b2 99 cdq
|
|
001b3 33 c2 xor eax, edx
|
|
001b5 2b c2 sub eax, edx
|
|
001b7 eb 02 jmp SHORT $LN22@glfwChoose
|
|
$LN21@glfwChoose:
|
|
|
|
; 256 : else
|
|
; 257 : rateDiff = UINT_MAX - current->refreshRate;
|
|
|
|
001b9 f7 d0 not eax
|
|
$LN22@glfwChoose:
|
|
|
|
; 258 :
|
|
; 259 : if ((colorDiff < leastColorDiff) ||
|
|
; 260 : (colorDiff == leastColorDiff && sizeDiff < leastSizeDiff) ||
|
|
|
|
001bb 44 3b c7 cmp r8d, edi
|
|
001be 72 0d jb SHORT $LN24@glfwChoose
|
|
001c0 75 16 jne SHORT $LN25@glfwChoose
|
|
001c2 3b cb cmp ecx, ebx
|
|
001c4 72 07 jb SHORT $LN24@glfwChoose
|
|
001c6 75 10 jne SHORT $LN25@glfwChoose
|
|
001c8 41 3b c7 cmp eax, r15d
|
|
001cb 73 0b jae SHORT $LN25@glfwChoose
|
|
$LN24@glfwChoose:
|
|
|
|
; 261 : (colorDiff == leastColorDiff && sizeDiff == leastSizeDiff && rateDiff < leastRateDiff))
|
|
; 262 : {
|
|
; 263 : closest = current;
|
|
|
|
001cd 4d 8b e9 mov r13, r9
|
|
|
|
; 264 : leastSizeDiff = sizeDiff;
|
|
|
|
001d0 8b d9 mov ebx, ecx
|
|
|
|
; 265 : leastRateDiff = rateDiff;
|
|
|
|
001d2 44 8b f8 mov r15d, eax
|
|
|
|
; 266 : leastColorDiff = colorDiff;
|
|
|
|
001d5 41 8b f8 mov edi, r8d
|
|
$LN25@glfwChoose:
|
|
|
|
; 235 :
|
|
; 236 : for (i = 0; i < monitor->modeCount; i++)
|
|
|
|
001d8 48 8b 4c 24 20 mov rcx, QWORD PTR tv527[rsp]
|
|
001dd 49 83 c2 18 add r10, 24
|
|
001e1 49 83 eb 01 sub r11, 1
|
|
001e5 0f 85 65 ff ff
|
|
ff jne $LL18@glfwChoose
|
|
$LN50@glfwChoose:
|
|
001eb 4c 8b 64 24 70 mov r12, QWORD PTR [rsp+112]
|
|
$LN27@glfwChoose:
|
|
|
|
; 267 : }
|
|
; 268 : }
|
|
; 269 :
|
|
; 270 : return closest;
|
|
|
|
001f0 49 8b c5 mov rax, r13
|
|
|
|
; 271 : }
|
|
|
|
001f3 48 83 c4 30 add rsp, 48 ; 00000030H
|
|
001f7 41 5f pop r15
|
|
001f9 41 5e pop r14
|
|
001fb 41 5d pop r13
|
|
001fd 5f pop rdi
|
|
001fe 5e pop rsi
|
|
001ff 5d pop rbp
|
|
00200 5b pop rbx
|
|
00201 c3 ret 0
|
|
_glfwChooseVideoMode ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; COMDAT _glfwCompareVideoModes
|
|
_TEXT SEGMENT
|
|
fm$ = 8
|
|
sm$ = 16
|
|
_glfwCompareVideoModes PROC ; COMDAT
|
|
|
|
; 46 : const int fbpp = fm->redBits + fm->greenBits + fm->blueBits;
|
|
|
|
00000 8b 41 10 mov eax, DWORD PTR [rcx+16]
|
|
|
|
; 276 : {
|
|
|
|
00003 4c 8b c9 mov r9, rcx
|
|
|
|
; 46 : const int fbpp = fm->redBits + fm->greenBits + fm->blueBits;
|
|
|
|
00006 03 41 0c add eax, DWORD PTR [rcx+12]
|
|
00009 03 41 08 add eax, DWORD PTR [rcx+8]
|
|
|
|
; 47 : const int sbpp = sm->redBits + sm->greenBits + sm->blueBits;
|
|
|
|
0000c 8b 4a 10 mov ecx, DWORD PTR [rdx+16]
|
|
0000f 03 4a 0c add ecx, DWORD PTR [rdx+12]
|
|
00012 03 4a 08 add ecx, DWORD PTR [rdx+8]
|
|
|
|
; 48 : const int farea = fm->width * fm->height;
|
|
|
|
00015 45 8b 01 mov r8d, DWORD PTR [r9]
|
|
|
|
; 49 : const int sarea = sm->width * sm->height;
|
|
|
|
00018 44 8b 12 mov r10d, DWORD PTR [rdx]
|
|
|
|
; 50 :
|
|
; 51 : // First sort on color bits per pixel
|
|
; 52 : if (fbpp != sbpp)
|
|
|
|
0001b 3b c1 cmp eax, ecx
|
|
0001d 74 03 je SHORT $LN4@glfwCompar
|
|
$LN8@glfwCompar:
|
|
|
|
; 278 : }
|
|
|
|
0001f 2b c1 sub eax, ecx
|
|
00021 c3 ret 0
|
|
$LN4@glfwCompar:
|
|
|
|
; 49 : const int sarea = sm->width * sm->height;
|
|
|
|
00022 41 8b ca mov ecx, r10d
|
|
00025 41 8b c0 mov eax, r8d
|
|
00028 0f af 4a 04 imul ecx, DWORD PTR [rdx+4]
|
|
0002c 41 0f af 41 04 imul eax, DWORD PTR [r9+4]
|
|
|
|
; 53 : return fbpp - sbpp;
|
|
; 54 :
|
|
; 55 : // Then sort on screen area
|
|
; 56 : if (farea != sarea)
|
|
|
|
00031 3b c1 cmp eax, ecx
|
|
00033 75 ea jne SHORT $LN8@glfwCompar
|
|
|
|
; 57 : return farea - sarea;
|
|
; 58 :
|
|
; 59 : // Then sort on width
|
|
; 60 : if (fm->width != sm->width)
|
|
|
|
00035 45 3b c2 cmp r8d, r10d
|
|
00038 74 07 je SHORT $LN6@glfwCompar
|
|
|
|
; 61 : return fm->width - sm->width;
|
|
|
|
0003a 45 2b c2 sub r8d, r10d
|
|
|
|
; 277 : return compareVideoModes(fm, sm);
|
|
|
|
0003d 41 8b c0 mov eax, r8d
|
|
|
|
; 278 : }
|
|
|
|
00040 c3 ret 0
|
|
$LN6@glfwCompar:
|
|
|
|
; 64 : return fm->refreshRate - sm->refreshRate;
|
|
|
|
00041 41 8b 41 14 mov eax, DWORD PTR [r9+20]
|
|
00045 2b 42 14 sub eax, DWORD PTR [rdx+20]
|
|
|
|
; 278 : }
|
|
|
|
00048 c3 ret 0
|
|
_glfwCompareVideoModes ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; COMDAT _glfwSplitBPP
|
|
_TEXT SEGMENT
|
|
bpp$ = 8
|
|
red$ = 16
|
|
green$ = 24
|
|
blue$ = 32
|
|
_glfwSplitBPP PROC ; COMDAT
|
|
|
|
; 283 : {
|
|
|
|
00000 4c 8b d2 mov r10, rdx
|
|
|
|
; 284 : int delta;
|
|
; 285 :
|
|
; 286 : // We assume that by 32 the user really meant 24
|
|
; 287 : if (bpp == 32)
|
|
; 288 : bpp = 24;
|
|
; 289 :
|
|
; 290 : // Convert "bits per pixel" to red, green & blue sizes
|
|
; 291 :
|
|
; 292 : *red = *green = *blue = bpp / 3;
|
|
|
|
00003 83 f9 20 cmp ecx, 32 ; 00000020H
|
|
00006 41 bb 18 00 00
|
|
00 mov r11d, 24
|
|
0000c b8 56 55 55 55 mov eax, 1431655766 ; 55555556H
|
|
00011 44 0f 45 d9 cmovne r11d, ecx
|
|
00015 41 f7 eb imul r11d
|
|
00018 8b c2 mov eax, edx
|
|
0001a c1 e8 1f shr eax, 31
|
|
0001d 03 d0 add edx, eax
|
|
0001f 41 89 11 mov DWORD PTR [r9], edx
|
|
00022 41 89 10 mov DWORD PTR [r8], edx
|
|
00025 41 89 12 mov DWORD PTR [r10], edx
|
|
|
|
; 293 : delta = bpp - (*red * 3);
|
|
|
|
00028 8d 04 52 lea eax, DWORD PTR [rdx+rdx*2]
|
|
0002b 44 2b d8 sub r11d, eax
|
|
|
|
; 294 : if (delta >= 1)
|
|
|
|
0002e 41 83 fb 01 cmp r11d, 1
|
|
00032 7c 03 jl SHORT $LN3@glfwSplitB
|
|
|
|
; 295 : *green = *green + 1;
|
|
|
|
00034 41 ff 00 inc DWORD PTR [r8]
|
|
$LN3@glfwSplitB:
|
|
|
|
; 296 :
|
|
; 297 : if (delta == 2)
|
|
|
|
00037 41 83 fb 02 cmp r11d, 2
|
|
0003b 75 03 jne SHORT $LN4@glfwSplitB
|
|
|
|
; 298 : *red = *red + 1;
|
|
|
|
0003d 41 ff 02 inc DWORD PTR [r10]
|
|
$LN4@glfwSplitB:
|
|
|
|
; 299 : }
|
|
|
|
00040 c3 ret 0
|
|
_glfwSplitBPP ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; COMDAT glfwGetMonitors
|
|
_TEXT SEGMENT
|
|
count$ = 48
|
|
glfwGetMonitors PROC ; COMDAT
|
|
|
|
; 307 : {
|
|
|
|
$LN5:
|
|
00000 48 83 ec 28 sub rsp, 40 ; 00000028H
|
|
|
|
; 308 : assert(count != NULL);
|
|
; 309 :
|
|
; 310 : *count = 0;
|
|
|
|
00004 c7 01 00 00 00
|
|
00 mov DWORD PTR [rcx], 0
|
|
|
|
; 311 :
|
|
; 312 : _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
|
|
|
|
0000a 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
00011 75 13 jne SHORT $LN2@glfwGetMon
|
|
00013 33 d2 xor edx, edx
|
|
00015 b9 01 00 01 00 mov ecx, 65537 ; 00010001H
|
|
0001a e8 00 00 00 00 call _glfwInputError
|
|
0001f 33 c0 xor eax, eax
|
|
|
|
; 316 : }
|
|
|
|
00021 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
00025 c3 ret 0
|
|
$LN2@glfwGetMon:
|
|
|
|
; 313 :
|
|
; 314 : *count = _glfw.monitorCount;
|
|
|
|
00026 8b 05 88 07 00
|
|
00 mov eax, DWORD PTR _glfw+1928
|
|
0002c 89 01 mov DWORD PTR [rcx], eax
|
|
|
|
; 315 : return (GLFWmonitor**) _glfw.monitors;
|
|
|
|
0002e 48 8b 05 80 07
|
|
00 00 mov rax, QWORD PTR _glfw+1920
|
|
|
|
; 316 : }
|
|
|
|
00035 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
00039 c3 ret 0
|
|
glfwGetMonitors ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; COMDAT glfwGetPrimaryMonitor
|
|
_TEXT SEGMENT
|
|
glfwGetPrimaryMonitor PROC ; COMDAT
|
|
|
|
; 319 : {
|
|
|
|
$LN7:
|
|
00000 48 83 ec 28 sub rsp, 40 ; 00000028H
|
|
|
|
; 320 : _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@glfwGetPri
|
|
0000d 33 d2 xor edx, edx
|
|
0000f b9 01 00 01 00 mov ecx, 65537 ; 00010001H
|
|
00014 e8 00 00 00 00 call _glfwInputError
|
|
$LN5@glfwGetPri:
|
|
|
|
; 326 : }
|
|
|
|
00019 33 c0 xor eax, eax
|
|
0001b 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
0001f c3 ret 0
|
|
$LN2@glfwGetPri:
|
|
|
|
; 321 :
|
|
; 322 : if (!_glfw.monitorCount)
|
|
|
|
00020 83 3d 88 07 00
|
|
00 00 cmp DWORD PTR _glfw+1928, 0
|
|
00027 74 f0 je SHORT $LN5@glfwGetPri
|
|
|
|
; 323 : return NULL;
|
|
; 324 :
|
|
; 325 : return (GLFWmonitor*) _glfw.monitors[0];
|
|
|
|
00029 48 8b 05 80 07
|
|
00 00 mov rax, QWORD PTR _glfw+1920
|
|
00030 48 8b 00 mov rax, QWORD PTR [rax]
|
|
|
|
; 326 : }
|
|
|
|
00033 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
00037 c3 ret 0
|
|
glfwGetPrimaryMonitor ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; COMDAT glfwGetMonitorPos
|
|
_TEXT SEGMENT
|
|
handle$ = 8
|
|
xpos$ = 16
|
|
ypos$ = 24
|
|
glfwGetMonitorPos PROC ; COMDAT
|
|
|
|
; 330 : _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
|
|
; 331 : assert(monitor != NULL);
|
|
; 332 :
|
|
; 333 : if (xpos)
|
|
|
|
00000 33 c0 xor eax, eax
|
|
00002 48 85 d2 test rdx, rdx
|
|
00005 74 02 je SHORT $LN2@glfwGetMon
|
|
|
|
; 334 : *xpos = 0;
|
|
|
|
00007 89 02 mov DWORD PTR [rdx], eax
|
|
$LN2@glfwGetMon:
|
|
|
|
; 335 : if (ypos)
|
|
|
|
00009 4d 85 c0 test r8, r8
|
|
0000c 74 03 je SHORT $LN3@glfwGetMon
|
|
|
|
; 336 : *ypos = 0;
|
|
|
|
0000e 41 89 00 mov DWORD PTR [r8], eax
|
|
$LN3@glfwGetMon:
|
|
|
|
; 337 :
|
|
; 338 : _GLFW_REQUIRE_INIT();
|
|
|
|
00011 39 05 00 00 00
|
|
00 cmp DWORD PTR _glfw, eax
|
|
00017 75 0c jne SHORT $LN4@glfwGetMon
|
|
00019 33 d2 xor edx, edx
|
|
0001b b9 01 00 01 00 mov ecx, 65537 ; 00010001H
|
|
00020 e9 00 00 00 00 jmp _glfwInputError
|
|
$LN4@glfwGetMon:
|
|
|
|
; 339 :
|
|
; 340 : _glfw.platform.getMonitorPos(monitor, xpos, ypos);
|
|
|
|
00025 48 ff 25 d8 00
|
|
00 00 rex_jmp QWORD PTR _glfw+216
|
|
glfwGetMonitorPos ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; COMDAT glfwGetMonitorWorkarea
|
|
_TEXT SEGMENT
|
|
handle$ = 8
|
|
xpos$ = 16
|
|
ypos$ = 24
|
|
width$ = 32
|
|
height$ = 40
|
|
glfwGetMonitorWorkarea PROC ; COMDAT
|
|
|
|
; 347 : _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
|
|
; 348 : assert(monitor != NULL);
|
|
; 349 :
|
|
; 350 : if (xpos)
|
|
|
|
00000 45 33 d2 xor r10d, r10d
|
|
00003 48 85 d2 test rdx, rdx
|
|
00006 74 03 je SHORT $LN2@glfwGetMon
|
|
|
|
; 351 : *xpos = 0;
|
|
|
|
00008 44 89 12 mov DWORD PTR [rdx], r10d
|
|
$LN2@glfwGetMon:
|
|
|
|
; 352 : if (ypos)
|
|
|
|
0000b 4d 85 c0 test r8, r8
|
|
0000e 74 03 je SHORT $LN3@glfwGetMon
|
|
|
|
; 353 : *ypos = 0;
|
|
|
|
00010 45 89 10 mov DWORD PTR [r8], r10d
|
|
$LN3@glfwGetMon:
|
|
|
|
; 354 : if (width)
|
|
|
|
00013 4d 85 c9 test r9, r9
|
|
00016 74 03 je SHORT $LN4@glfwGetMon
|
|
|
|
; 355 : *width = 0;
|
|
|
|
00018 45 89 11 mov DWORD PTR [r9], r10d
|
|
$LN4@glfwGetMon:
|
|
|
|
; 356 : if (height)
|
|
|
|
0001b 48 8b 44 24 28 mov rax, QWORD PTR height$[rsp]
|
|
00020 48 85 c0 test rax, rax
|
|
00023 74 03 je SHORT $LN5@glfwGetMon
|
|
|
|
; 357 : *height = 0;
|
|
|
|
00025 44 89 10 mov DWORD PTR [rax], r10d
|
|
$LN5@glfwGetMon:
|
|
|
|
; 358 :
|
|
; 359 : _GLFW_REQUIRE_INIT();
|
|
|
|
00028 44 39 15 00 00
|
|
00 00 cmp DWORD PTR _glfw, r10d
|
|
0002f 75 0c jne SHORT $LN6@glfwGetMon
|
|
00031 33 d2 xor edx, edx
|
|
00033 b9 01 00 01 00 mov ecx, 65537 ; 00010001H
|
|
00038 e9 00 00 00 00 jmp _glfwInputError
|
|
$LN6@glfwGetMon:
|
|
|
|
; 360 :
|
|
; 361 : _glfw.platform.getMonitorWorkarea(monitor, xpos, ypos, width, height);
|
|
|
|
0003d 48 89 44 24 28 mov QWORD PTR height$[rsp], rax
|
|
00042 48 ff 25 e8 00
|
|
00 00 rex_jmp QWORD PTR _glfw+232
|
|
glfwGetMonitorWorkarea ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; COMDAT glfwGetMonitorPhysicalSize
|
|
_TEXT SEGMENT
|
|
handle$ = 8
|
|
widthMM$ = 16
|
|
heightMM$ = 24
|
|
glfwGetMonitorPhysicalSize PROC ; COMDAT
|
|
|
|
; 366 : _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
|
|
; 367 : assert(monitor != NULL);
|
|
; 368 :
|
|
; 369 : if (widthMM)
|
|
|
|
00000 33 c0 xor eax, eax
|
|
00002 48 85 d2 test rdx, rdx
|
|
00005 74 02 je SHORT $LN2@glfwGetMon
|
|
|
|
; 370 : *widthMM = 0;
|
|
|
|
00007 89 02 mov DWORD PTR [rdx], eax
|
|
$LN2@glfwGetMon:
|
|
|
|
; 371 : if (heightMM)
|
|
|
|
00009 4d 85 c0 test r8, r8
|
|
0000c 74 03 je SHORT $LN3@glfwGetMon
|
|
|
|
; 372 : *heightMM = 0;
|
|
|
|
0000e 41 89 00 mov DWORD PTR [r8], eax
|
|
$LN3@glfwGetMon:
|
|
|
|
; 373 :
|
|
; 374 : _GLFW_REQUIRE_INIT();
|
|
|
|
00011 39 05 00 00 00
|
|
00 cmp DWORD PTR _glfw, eax
|
|
00017 75 0c jne SHORT $LN4@glfwGetMon
|
|
00019 33 d2 xor edx, edx
|
|
0001b b9 01 00 01 00 mov ecx, 65537 ; 00010001H
|
|
00020 e9 00 00 00 00 jmp _glfwInputError
|
|
$LN4@glfwGetMon:
|
|
|
|
; 375 :
|
|
; 376 : if (widthMM)
|
|
|
|
00025 48 85 d2 test rdx, rdx
|
|
00028 74 08 je SHORT $LN5@glfwGetMon
|
|
|
|
; 377 : *widthMM = monitor->widthMM;
|
|
|
|
0002a 8b 81 88 00 00
|
|
00 mov eax, DWORD PTR [rcx+136]
|
|
00030 89 02 mov DWORD PTR [rdx], eax
|
|
$LN5@glfwGetMon:
|
|
|
|
; 378 : if (heightMM)
|
|
|
|
00032 4d 85 c0 test r8, r8
|
|
00035 74 09 je SHORT $LN6@glfwGetMon
|
|
|
|
; 379 : *heightMM = monitor->heightMM;
|
|
|
|
00037 8b 81 8c 00 00
|
|
00 mov eax, DWORD PTR [rcx+140]
|
|
0003d 41 89 00 mov DWORD PTR [r8], eax
|
|
$LN6@glfwGetMon:
|
|
|
|
; 380 : }
|
|
|
|
00040 c3 ret 0
|
|
glfwGetMonitorPhysicalSize ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; COMDAT glfwGetMonitorContentScale
|
|
_TEXT SEGMENT
|
|
handle$ = 8
|
|
xscale$ = 16
|
|
yscale$ = 24
|
|
glfwGetMonitorContentScale PROC ; COMDAT
|
|
|
|
; 385 : _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
|
|
; 386 : assert(monitor != NULL);
|
|
; 387 :
|
|
; 388 : if (xscale)
|
|
|
|
00000 33 c0 xor eax, eax
|
|
00002 48 85 d2 test rdx, rdx
|
|
00005 74 02 je SHORT $LN2@glfwGetMon
|
|
|
|
; 389 : *xscale = 0.f;
|
|
|
|
00007 89 02 mov DWORD PTR [rdx], eax
|
|
$LN2@glfwGetMon:
|
|
|
|
; 390 : if (yscale)
|
|
|
|
00009 4d 85 c0 test r8, r8
|
|
0000c 74 03 je SHORT $LN3@glfwGetMon
|
|
|
|
; 391 : *yscale = 0.f;
|
|
|
|
0000e 41 89 00 mov DWORD PTR [r8], eax
|
|
$LN3@glfwGetMon:
|
|
|
|
; 392 :
|
|
; 393 : _GLFW_REQUIRE_INIT();
|
|
|
|
00011 39 05 00 00 00
|
|
00 cmp DWORD PTR _glfw, eax
|
|
00017 75 0c jne SHORT $LN4@glfwGetMon
|
|
00019 33 d2 xor edx, edx
|
|
0001b b9 01 00 01 00 mov ecx, 65537 ; 00010001H
|
|
00020 e9 00 00 00 00 jmp _glfwInputError
|
|
$LN4@glfwGetMon:
|
|
|
|
; 394 : _glfw.platform.getMonitorContentScale(monitor, xscale, yscale);
|
|
|
|
00025 48 ff 25 e0 00
|
|
00 00 rex_jmp QWORD PTR _glfw+224
|
|
glfwGetMonitorContentScale ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; COMDAT glfwGetMonitorName
|
|
_TEXT SEGMENT
|
|
handle$ = 48
|
|
glfwGetMonitorName PROC ; COMDAT
|
|
|
|
; 398 : {
|
|
|
|
$LN5:
|
|
00000 48 83 ec 28 sub rsp, 40 ; 00000028H
|
|
|
|
; 399 : _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
|
|
; 400 : assert(monitor != NULL);
|
|
; 401 :
|
|
; 402 : _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@glfwGetMon
|
|
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
|
|
|
|
; 404 : }
|
|
|
|
0001b 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
0001f c3 ret 0
|
|
$LN2@glfwGetMon:
|
|
|
|
; 403 : return monitor->name;
|
|
|
|
00020 48 8b c1 mov rax, rcx
|
|
|
|
; 404 : }
|
|
|
|
00023 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
00027 c3 ret 0
|
|
glfwGetMonitorName ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; COMDAT glfwSetMonitorUserPointer
|
|
_TEXT SEGMENT
|
|
handle$ = 8
|
|
pointer$ = 16
|
|
glfwSetMonitorUserPointer PROC ; COMDAT
|
|
|
|
; 408 : _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
|
|
; 409 : assert(monitor != NULL);
|
|
; 410 :
|
|
; 411 : _GLFW_REQUIRE_INIT();
|
|
|
|
00000 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
00007 75 0c jne SHORT $LN2@glfwSetMon
|
|
00009 33 d2 xor edx, edx
|
|
0000b b9 01 00 01 00 mov ecx, 65537 ; 00010001H
|
|
00010 e9 00 00 00 00 jmp _glfwInputError
|
|
$LN2@glfwSetMon:
|
|
|
|
; 412 : monitor->userPointer = pointer;
|
|
|
|
00015 48 89 91 80 00
|
|
00 00 mov QWORD PTR [rcx+128], rdx
|
|
|
|
; 413 : }
|
|
|
|
0001c c3 ret 0
|
|
glfwSetMonitorUserPointer ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; COMDAT glfwGetMonitorUserPointer
|
|
_TEXT SEGMENT
|
|
handle$ = 48
|
|
glfwGetMonitorUserPointer PROC ; COMDAT
|
|
|
|
; 416 : {
|
|
|
|
$LN5:
|
|
00000 48 83 ec 28 sub rsp, 40 ; 00000028H
|
|
|
|
; 417 : _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
|
|
; 418 : assert(monitor != NULL);
|
|
; 419 :
|
|
; 420 : _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@glfwGetMon
|
|
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
|
|
|
|
; 422 : }
|
|
|
|
0001b 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
0001f c3 ret 0
|
|
$LN2@glfwGetMon:
|
|
|
|
; 421 : return monitor->userPointer;
|
|
|
|
00020 48 8b 81 80 00
|
|
00 00 mov rax, QWORD PTR [rcx+128]
|
|
|
|
; 422 : }
|
|
|
|
00027 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
0002b c3 ret 0
|
|
glfwGetMonitorUserPointer ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; COMDAT glfwSetMonitorCallback
|
|
_TEXT SEGMENT
|
|
cbfun$ = 48
|
|
glfwSetMonitorCallback PROC ; COMDAT
|
|
|
|
; 425 : {
|
|
|
|
$LN5:
|
|
00000 48 83 ec 28 sub rsp, 40 ; 00000028H
|
|
|
|
; 426 : _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@glfwSetMon
|
|
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
|
|
|
|
; 428 : return cbfun;
|
|
; 429 : }
|
|
|
|
0001b 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
0001f c3 ret 0
|
|
$LN2@glfwSetMon:
|
|
|
|
; 427 : _GLFW_SWAP(GLFWmonitorfun, _glfw.callbacks.monitor, cbfun);
|
|
|
|
00020 48 8b 05 68 1b
|
|
00 00 mov rax, QWORD PTR _glfw+7016
|
|
00027 48 89 0d 68 1b
|
|
00 00 mov QWORD PTR _glfw+7016, rcx
|
|
|
|
; 428 : return cbfun;
|
|
; 429 : }
|
|
|
|
0002e 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
00032 c3 ret 0
|
|
glfwSetMonitorCallback ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; COMDAT glfwGetVideoModes
|
|
_TEXT SEGMENT
|
|
handle$ = 48
|
|
count$ = 56
|
|
glfwGetVideoModes PROC ; COMDAT
|
|
|
|
; 432 : {
|
|
|
|
$LN9:
|
|
00000 48 89 5c 24 08 mov QWORD PTR [rsp+8], rbx
|
|
00005 57 push rdi
|
|
00006 48 83 ec 20 sub rsp, 32 ; 00000020H
|
|
|
|
; 433 : _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
|
|
; 434 : assert(monitor != NULL);
|
|
; 435 : assert(count != NULL);
|
|
; 436 :
|
|
; 437 : *count = 0;
|
|
|
|
0000a c7 02 00 00 00
|
|
00 mov DWORD PTR [rdx], 0
|
|
00010 48 8b fa mov rdi, rdx
|
|
|
|
; 438 :
|
|
; 439 : _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
|
|
|
|
00013 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
0001a 48 8b d9 mov rbx, rcx
|
|
0001d 75 19 jne SHORT $LN2@glfwGetVid
|
|
0001f 33 d2 xor edx, edx
|
|
00021 b9 01 00 01 00 mov ecx, 65537 ; 00010001H
|
|
00026 e8 00 00 00 00 call _glfwInputError
|
|
$LN7@glfwGetVid:
|
|
|
|
; 446 : }
|
|
|
|
0002b 33 c0 xor eax, eax
|
|
0002d 48 8b 5c 24 30 mov rbx, QWORD PTR [rsp+48]
|
|
00032 48 83 c4 20 add rsp, 32 ; 00000020H
|
|
00036 5f pop rdi
|
|
00037 c3 ret 0
|
|
$LN2@glfwGetVid:
|
|
|
|
; 440 :
|
|
; 441 : if (!refreshVideoModes(monitor))
|
|
|
|
00038 e8 00 00 00 00 call refreshVideoModes
|
|
0003d 85 c0 test eax, eax
|
|
0003f 74 ea je SHORT $LN7@glfwGetVid
|
|
|
|
; 442 : return NULL;
|
|
; 443 :
|
|
; 444 : *count = monitor->modeCount;
|
|
|
|
00041 8b 83 a0 00 00
|
|
00 mov eax, DWORD PTR [rbx+160]
|
|
00047 89 07 mov DWORD PTR [rdi], eax
|
|
|
|
; 445 : return monitor->modes;
|
|
|
|
00049 48 8b 83 98 00
|
|
00 00 mov rax, QWORD PTR [rbx+152]
|
|
|
|
; 446 : }
|
|
|
|
00050 48 8b 5c 24 30 mov rbx, QWORD PTR [rsp+48]
|
|
00055 48 83 c4 20 add rsp, 32 ; 00000020H
|
|
00059 5f pop rdi
|
|
0005a c3 ret 0
|
|
glfwGetVideoModes ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; COMDAT glfwGetVideoMode
|
|
_TEXT SEGMENT
|
|
handle$ = 48
|
|
glfwGetVideoMode PROC ; COMDAT
|
|
|
|
; 449 : {
|
|
|
|
$LN6:
|
|
00000 48 83 ec 28 sub rsp, 40 ; 00000028H
|
|
|
|
; 450 : _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
|
|
; 451 : assert(monitor != NULL);
|
|
; 452 :
|
|
; 453 : _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@glfwGetVid
|
|
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
|
|
|
|
; 457 : }
|
|
|
|
0001b 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
0001f c3 ret 0
|
|
$LN2@glfwGetVid:
|
|
00020 48 89 5c 24 20 mov QWORD PTR [rsp+32], rbx
|
|
|
|
; 454 :
|
|
; 455 : _glfw.platform.getVideoMode(monitor, &monitor->currentMode);
|
|
|
|
00025 48 8d 99 a4 00
|
|
00 00 lea rbx, QWORD PTR [rcx+164]
|
|
0002c 48 8b d3 mov rdx, rbx
|
|
0002f ff 15 f8 00 00
|
|
00 call QWORD PTR _glfw+248
|
|
|
|
; 456 : return &monitor->currentMode;
|
|
|
|
00035 48 8b c3 mov rax, rbx
|
|
00038 48 8b 5c 24 20 mov rbx, QWORD PTR [rsp+32]
|
|
|
|
; 457 : }
|
|
|
|
0003d 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
00041 c3 ret 0
|
|
glfwGetVideoMode ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; COMDAT glfwSetGamma
|
|
_TEXT SEGMENT
|
|
ramp$ = 32
|
|
__$ArrayPad$ = 64
|
|
handle$ = 160
|
|
gamma$ = 168
|
|
glfwSetGamma PROC ; COMDAT
|
|
|
|
; 460 : {
|
|
|
|
$LN47:
|
|
00000 40 55 push rbp
|
|
00002 48 81 ec 90 00
|
|
00 00 sub rsp, 144 ; 00000090H
|
|
00009 0f 29 74 24 70 movaps XMMWORD PTR [rsp+112], xmm6
|
|
0000e 48 8b 05 00 00
|
|
00 00 mov rax, QWORD PTR __security_cookie
|
|
00015 48 33 c4 xor rax, rsp
|
|
00018 48 89 44 24 40 mov QWORD PTR __$ArrayPad$[rsp], rax
|
|
|
|
; 461 : unsigned int i;
|
|
; 462 : unsigned short* values;
|
|
; 463 : GLFWgammaramp ramp;
|
|
; 464 : const GLFWgammaramp* original;
|
|
; 465 : assert(handle != NULL);
|
|
; 466 : assert(gamma > 0.f);
|
|
; 467 : assert(gamma <= FLT_MAX);
|
|
; 468 :
|
|
; 469 : _GLFW_REQUIRE_INIT();
|
|
|
|
0001d 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
00024 0f 28 f1 movaps xmm6, xmm1
|
|
00027 48 8b e9 mov rbp, rcx
|
|
0002a 75 11 jne SHORT $LN5@glfwSetGam
|
|
0002c 33 d2 xor edx, edx
|
|
0002e b9 01 00 01 00 mov ecx, 65537 ; 00010001H
|
|
00033 e8 00 00 00 00 call _glfwInputError
|
|
00038 e9 84 01 00 00 jmp $LN25@glfwSetGam
|
|
$LN5@glfwSetGam:
|
|
|
|
; 470 :
|
|
; 471 : if (gamma != gamma || gamma <= 0.f || gamma > FLT_MAX)
|
|
|
|
0003d 0f 2e f6 ucomiss xmm6, xmm6
|
|
00040 0f 8a 96 01 00
|
|
00 jp $LN7@glfwSetGam
|
|
00046 0f 57 c0 xorps xmm0, xmm0
|
|
00049 0f 2f c6 comiss xmm0, xmm6
|
|
0004c 0f 83 8a 01 00
|
|
00 jae $LN7@glfwSetGam
|
|
00052 0f 2f 35 00 00
|
|
00 00 comiss xmm6, DWORD PTR __real@7f7fffff
|
|
00059 0f 87 7d 01 00
|
|
00 ja $LN7@glfwSetGam
|
|
0005f 48 89 b4 24 88
|
|
00 00 00 mov QWORD PTR [rsp+136], rsi
|
|
|
|
; 474 : return;
|
|
; 475 : }
|
|
; 476 :
|
|
; 477 : original = glfwGetGammaRamp(handle);
|
|
|
|
00067 e8 00 00 00 00 call glfwGetGammaRamp
|
|
0006c 48 8b f0 mov rsi, rax
|
|
|
|
; 478 : if (!original)
|
|
|
|
0006f 48 85 c0 test rax, rax
|
|
00072 0f 84 41 01 00
|
|
00 je $LN43@glfwSetGam
|
|
|
|
; 479 : return;
|
|
; 480 :
|
|
; 481 : values = _glfw_calloc(original->size, sizeof(unsigned short));
|
|
|
|
00078 8b 48 18 mov ecx, DWORD PTR [rax+24]
|
|
0007b ba 02 00 00 00 mov edx, 2
|
|
00080 48 89 9c 24 b0
|
|
00 00 00 mov QWORD PTR [rsp+176], rbx
|
|
00088 48 89 bc 24 80
|
|
00 00 00 mov QWORD PTR [rsp+128], rdi
|
|
00090 e8 00 00 00 00 call _glfw_calloc
|
|
|
|
; 482 :
|
|
; 483 : for (i = 0; i < original->size; i++)
|
|
|
|
00095 8b 4e 18 mov ecx, DWORD PTR [rsi+24]
|
|
00098 33 db xor ebx, ebx
|
|
0009a 48 8b f8 mov rdi, rax
|
|
0009d 85 c9 test ecx, ecx
|
|
0009f 0f 84 7d 00 00
|
|
00 je $LN3@glfwSetGam
|
|
000a5 0f 29 7c 24 60 movaps XMMWORD PTR [rsp+96], xmm7
|
|
000aa f3 0f 10 3d 00
|
|
00 00 00 movss xmm7, DWORD PTR __real@3f800000
|
|
000b2 f3 0f 5e fe divss xmm7, xmm6
|
|
000b6 f3 0f 10 35 00
|
|
00 00 00 movss xmm6, DWORD PTR __real@477fff00
|
|
000be 44 0f 29 44 24
|
|
50 movaps XMMWORD PTR [rsp+80], xmm8
|
|
000c4 f3 44 0f 10 05
|
|
00 00 00 00 movss xmm8, DWORD PTR __real@3f000000
|
|
000cd 0f 1f 00 npad 3
|
|
$LL4@glfwSetGam:
|
|
|
|
; 484 : {
|
|
; 485 : float value;
|
|
; 486 :
|
|
; 487 : // Calculate intensity
|
|
; 488 : value = i / (float) (original->size - 1);
|
|
|
|
000d0 0f 57 c0 xorps xmm0, xmm0
|
|
000d3 8b c3 mov eax, ebx
|
|
000d5 0f 57 c9 xorps xmm1, xmm1
|
|
000d8 ff c9 dec ecx
|
|
000da f3 48 0f 2a c0 cvtsi2ss xmm0, rax
|
|
000df f3 48 0f 2a c9 cvtsi2ss xmm1, rcx
|
|
000e4 f3 0f 5e c1 divss xmm0, xmm1
|
|
|
|
; 489 : // Apply gamma curve
|
|
; 490 : value = powf(value, 1.f / gamma) * 65535.f + 0.5f;
|
|
|
|
000e8 0f 28 cf movaps xmm1, xmm7
|
|
000eb e8 00 00 00 00 call powf
|
|
000f0 f3 0f 59 c6 mulss xmm0, xmm6
|
|
000f4 f3 41 0f 58 c0 addss xmm0, xmm8
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 249 : if (a != a)
|
|
|
|
000f9 0f 2e c0 ucomiss xmm0, xmm0
|
|
000fc 7a 05 jp SHORT $LN45@glfwSetGam
|
|
|
|
; 250 : return b;
|
|
; 251 : else if (b != b)
|
|
; 252 : return a;
|
|
; 253 : else if (a < b)
|
|
|
|
000fe 0f 2f f0 comiss xmm6, xmm0
|
|
00101 77 03 ja SHORT $LN16@glfwSetGam
|
|
$LN45@glfwSetGam:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
|
|
; 494 : values[i] = (unsigned short) value;
|
|
|
|
00103 0f 28 c6 movaps xmm0, xmm6
|
|
$LN16@glfwSetGam:
|
|
00106 f3 0f 2c c8 cvttss2si ecx, xmm0
|
|
0010a 66 89 0c 5f mov WORD PTR [rdi+rbx*2], cx
|
|
0010e ff c3 inc ebx
|
|
00110 8b 4e 18 mov ecx, DWORD PTR [rsi+24]
|
|
00113 3b d9 cmp ebx, ecx
|
|
00115 72 b9 jb SHORT $LL4@glfwSetGam
|
|
|
|
; 482 :
|
|
; 483 : for (i = 0; i < original->size; i++)
|
|
|
|
00117 44 0f 28 44 24
|
|
50 movaps xmm8, XMMWORD PTR [rsp+80]
|
|
0011d 0f 28 7c 24 60 movaps xmm7, XMMWORD PTR [rsp+96]
|
|
$LN3@glfwSetGam:
|
|
|
|
; 530 : _GLFW_REQUIRE_INIT();
|
|
|
|
00122 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
|
|
; 495 : }
|
|
; 496 :
|
|
; 497 : ramp.red = values;
|
|
; 498 : ramp.green = values;
|
|
; 499 : ramp.blue = values;
|
|
; 500 : ramp.size = original->size;
|
|
|
|
00129 48 8b 9c 24 b0
|
|
00 00 00 mov rbx, QWORD PTR [rsp+176]
|
|
00131 48 89 7c 24 20 mov QWORD PTR ramp$[rsp], rdi
|
|
00136 48 89 7c 24 28 mov QWORD PTR ramp$[rsp+8], rdi
|
|
0013b 48 89 7c 24 30 mov QWORD PTR ramp$[rsp+16], rdi
|
|
00140 44 8b 46 18 mov r8d, DWORD PTR [rsi+24]
|
|
00144 44 89 44 24 38 mov DWORD PTR ramp$[rsp+24], r8d
|
|
|
|
; 530 : _GLFW_REQUIRE_INIT();
|
|
|
|
00149 75 0e jne SHORT $LN19@glfwSetGam
|
|
0014b 33 d2 xor edx, edx
|
|
0014d b9 01 00 01 00 mov ecx, 65537 ; 00010001H
|
|
00152 e8 00 00 00 00 call _glfwInputError
|
|
00157 eb 43 jmp SHORT $LN18@glfwSetGam
|
|
$LN19@glfwSetGam:
|
|
|
|
; 531 :
|
|
; 532 : if (ramp->size <= 0)
|
|
|
|
00159 45 85 c0 test r8d, r8d
|
|
0015c 75 13 jne SHORT $LN20@glfwSetGam
|
|
|
|
; 533 : {
|
|
; 534 : _glfwInputError(GLFW_INVALID_VALUE,
|
|
|
|
0015e 48 8d 15 00 00
|
|
00 00 lea rdx, OFFSET FLAT:??_C@_0BL@OAABODH@Invalid?5gamma?5ramp?5size?5?$CFi@
|
|
00165 b9 04 00 01 00 mov ecx, 65540 ; 00010004H
|
|
0016a e8 00 00 00 00 call _glfwInputError
|
|
|
|
; 535 : "Invalid gamma ramp size %i",
|
|
; 536 : ramp->size);
|
|
; 537 : return;
|
|
|
|
0016f eb 2b jmp SHORT $LN18@glfwSetGam
|
|
$LN20@glfwSetGam:
|
|
|
|
; 538 : }
|
|
; 539 :
|
|
; 540 : if (!monitor->originalRamp.size)
|
|
|
|
00171 83 bd d8 00 00
|
|
00 00 cmp DWORD PTR [rbp+216], 0
|
|
00178 75 14 jne SHORT $LN22@glfwSetGam
|
|
|
|
; 541 : {
|
|
; 542 : if (!_glfw.platform.getGammaRamp(monitor, &monitor->originalRamp))
|
|
|
|
0017a 48 8d 95 c0 00
|
|
00 00 lea rdx, QWORD PTR [rbp+192]
|
|
00181 48 8b cd mov rcx, rbp
|
|
00184 ff 15 00 01 00
|
|
00 call QWORD PTR _glfw+256
|
|
0018a 85 c0 test eax, eax
|
|
0018c 74 0e je SHORT $LN18@glfwSetGam
|
|
$LN22@glfwSetGam:
|
|
|
|
; 543 : return;
|
|
; 544 : }
|
|
; 545 :
|
|
; 546 : _glfw.platform.setGammaRamp(monitor, ramp);
|
|
|
|
0018e 48 8d 54 24 20 lea rdx, QWORD PTR ramp$[rsp]
|
|
00193 48 8b cd mov rcx, rbp
|
|
00196 ff 15 08 01 00
|
|
00 call QWORD PTR _glfw+264
|
|
$LN18@glfwSetGam:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 320 : if (block)
|
|
|
|
0019c 48 85 ff test rdi, rdi
|
|
0019f 74 10 je SHORT $LN44@glfwSetGam
|
|
|
|
; 321 : _glfw.allocator.deallocate(block, _glfw.allocator.user);
|
|
|
|
001a1 48 8b 15 20 00
|
|
00 00 mov rdx, QWORD PTR _glfw+32
|
|
001a8 48 8b cf mov rcx, rdi
|
|
001ab ff 15 18 00 00
|
|
00 call QWORD PTR _glfw+24
|
|
$LN44@glfwSetGam:
|
|
001b1 48 8b bc 24 80
|
|
00 00 00 mov rdi, QWORD PTR [rsp+128]
|
|
$LN43@glfwSetGam:
|
|
001b9 48 8b b4 24 88
|
|
00 00 00 mov rsi, QWORD PTR [rsp+136]
|
|
$LN25@glfwSetGam:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
|
|
; 504 : }
|
|
|
|
001c1 48 8b 4c 24 40 mov rcx, QWORD PTR __$ArrayPad$[rsp]
|
|
001c6 48 33 cc xor rcx, rsp
|
|
001c9 e8 00 00 00 00 call __security_check_cookie
|
|
001ce 0f 28 74 24 70 movaps xmm6, XMMWORD PTR [rsp+112]
|
|
001d3 48 81 c4 90 00
|
|
00 00 add rsp, 144 ; 00000090H
|
|
001da 5d pop rbp
|
|
001db c3 ret 0
|
|
$LN7@glfwSetGam:
|
|
|
|
; 472 : {
|
|
; 473 : _glfwInputError(GLFW_INVALID_VALUE, "Invalid gamma value %f", gamma);
|
|
|
|
001dc 0f 57 d2 xorps xmm2, xmm2
|
|
001df 48 8d 15 00 00
|
|
00 00 lea rdx, OFFSET FLAT:??_C@_0BH@BAPIEFAH@Invalid?5gamma?5value?5?$CFf@
|
|
001e6 f3 0f 5a d6 cvtss2sd xmm2, xmm6
|
|
001ea b9 04 00 01 00 mov ecx, 65540 ; 00010004H
|
|
001ef 66 49 0f 7e d0 movq r8, xmm2
|
|
001f4 e8 00 00 00 00 call _glfwInputError
|
|
001f9 eb c6 jmp SHORT $LN25@glfwSetGam
|
|
glfwSetGamma ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; COMDAT glfwGetGammaRamp
|
|
_TEXT SEGMENT
|
|
handle$ = 48
|
|
glfwGetGammaRamp PROC ; COMDAT
|
|
|
|
; 507 : {
|
|
|
|
$LN21:
|
|
00000 40 57 push rdi
|
|
00002 48 83 ec 20 sub rsp, 32 ; 00000020H
|
|
|
|
; 508 : _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
|
|
; 509 : assert(monitor != NULL);
|
|
; 510 :
|
|
; 511 : _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
|
|
|
|
00006 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
0000d 48 8b f9 mov rdi, rcx
|
|
00010 75 14 jne SHORT $LN2@glfwGetGam
|
|
00012 33 d2 xor edx, edx
|
|
00014 b9 01 00 01 00 mov ecx, 65537 ; 00010001H
|
|
00019 e8 00 00 00 00 call _glfwInputError
|
|
0001e 33 c0 xor eax, eax
|
|
|
|
; 515 : return NULL;
|
|
; 516 :
|
|
; 517 : return &monitor->currentRamp;
|
|
; 518 : }
|
|
|
|
00020 48 83 c4 20 add rsp, 32 ; 00000020H
|
|
00024 5f pop rdi
|
|
00025 c3 ret 0
|
|
$LN2@glfwGetGam:
|
|
00026 48 89 5c 24 30 mov QWORD PTR [rsp+48], rbx
|
|
|
|
; 512 :
|
|
; 513 : _glfwFreeGammaArrays(&monitor->currentRamp);
|
|
|
|
0002b 48 8d 99 e0 00
|
|
00 00 lea rbx, QWORD PTR [rcx+224]
|
|
|
|
; 214 : _glfw_free(ramp->red);
|
|
|
|
00032 48 8b 0b mov rcx, QWORD PTR [rbx]
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 320 : if (block)
|
|
|
|
00035 48 85 c9 test rcx, rcx
|
|
00038 74 0d je SHORT $LN8@glfwGetGam
|
|
|
|
; 321 : _glfw.allocator.deallocate(block, _glfw.allocator.user);
|
|
|
|
0003a 48 8b 15 20 00
|
|
00 00 mov rdx, QWORD PTR _glfw+32
|
|
00041 ff 15 18 00 00
|
|
00 call QWORD PTR _glfw+24
|
|
$LN8@glfwGetGam:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
|
|
; 215 : _glfw_free(ramp->green);
|
|
|
|
00047 48 8b 4b 08 mov rcx, QWORD PTR [rbx+8]
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 320 : if (block)
|
|
|
|
0004b 48 85 c9 test rcx, rcx
|
|
0004e 74 0d je SHORT $LN11@glfwGetGam
|
|
|
|
; 321 : _glfw.allocator.deallocate(block, _glfw.allocator.user);
|
|
|
|
00050 48 8b 15 20 00
|
|
00 00 mov rdx, QWORD PTR _glfw+32
|
|
00057 ff 15 18 00 00
|
|
00 call QWORD PTR _glfw+24
|
|
$LN11@glfwGetGam:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
|
|
; 216 : _glfw_free(ramp->blue);
|
|
|
|
0005d 48 8b 4b 10 mov rcx, QWORD PTR [rbx+16]
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 320 : if (block)
|
|
|
|
00061 48 85 c9 test rcx, rcx
|
|
00064 74 0d je SHORT $LN14@glfwGetGam
|
|
|
|
; 321 : _glfw.allocator.deallocate(block, _glfw.allocator.user);
|
|
|
|
00066 48 8b 15 20 00
|
|
00 00 mov rdx, QWORD PTR _glfw+32
|
|
0006d ff 15 18 00 00
|
|
00 call QWORD PTR _glfw+24
|
|
$LN14@glfwGetGam:
|
|
00073 0f 57 c0 xorps xmm0, xmm0
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
|
|
; 514 : if (!_glfw.platform.getGammaRamp(monitor, &monitor->currentRamp))
|
|
|
|
00076 48 8b d3 mov rdx, rbx
|
|
|
|
; 218 : memset(ramp, 0, sizeof(GLFWgammaramp));
|
|
|
|
00079 0f 11 03 movups XMMWORD PTR [rbx], xmm0
|
|
|
|
; 514 : if (!_glfw.platform.getGammaRamp(monitor, &monitor->currentRamp))
|
|
|
|
0007c 48 8b cf mov rcx, rdi
|
|
|
|
; 218 : memset(ramp, 0, sizeof(GLFWgammaramp));
|
|
|
|
0007f 0f 11 43 10 movups XMMWORD PTR [rbx+16], xmm0
|
|
|
|
; 514 : if (!_glfw.platform.getGammaRamp(monitor, &monitor->currentRamp))
|
|
|
|
00083 ff 15 00 01 00
|
|
00 call QWORD PTR _glfw+256
|
|
00089 33 c9 xor ecx, ecx
|
|
0008b 85 c0 test eax, eax
|
|
0008d 48 0f 44 d9 cmove rbx, rcx
|
|
00091 48 8b c3 mov rax, rbx
|
|
00094 48 8b 5c 24 30 mov rbx, QWORD PTR [rsp+48]
|
|
|
|
; 515 : return NULL;
|
|
; 516 :
|
|
; 517 : return &monitor->currentRamp;
|
|
; 518 : }
|
|
|
|
00099 48 83 c4 20 add rsp, 32 ; 00000020H
|
|
0009d 5f pop rdi
|
|
0009e c3 ret 0
|
|
glfwGetGammaRamp ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\monitor.c
|
|
; COMDAT glfwSetGammaRamp
|
|
_TEXT SEGMENT
|
|
handle$ = 48
|
|
ramp$ = 56
|
|
glfwSetGammaRamp PROC ; COMDAT
|
|
|
|
; 521 : {
|
|
|
|
$LN11:
|
|
00000 48 89 5c 24 08 mov QWORD PTR [rsp+8], rbx
|
|
00005 57 push rdi
|
|
00006 48 83 ec 20 sub rsp, 32 ; 00000020H
|
|
|
|
; 522 : _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
|
|
; 523 : assert(monitor != NULL);
|
|
; 524 : assert(ramp != NULL);
|
|
; 525 : assert(ramp->size > 0);
|
|
; 526 : assert(ramp->red != NULL);
|
|
; 527 : assert(ramp->green != NULL);
|
|
; 528 : assert(ramp->blue != NULL);
|
|
; 529 :
|
|
; 530 : _GLFW_REQUIRE_INIT();
|
|
|
|
0000a 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
00011 48 8b fa mov rdi, rdx
|
|
00014 48 8b d9 mov rbx, rcx
|
|
00017 75 16 jne SHORT $LN2@glfwSetGam
|
|
00019 33 d2 xor edx, edx
|
|
0001b b9 01 00 01 00 mov ecx, 65537 ; 00010001H
|
|
|
|
; 547 : }
|
|
|
|
00020 48 8b 5c 24 30 mov rbx, QWORD PTR [rsp+48]
|
|
00025 48 83 c4 20 add rsp, 32 ; 00000020H
|
|
00029 5f pop rdi
|
|
|
|
; 522 : _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
|
|
; 523 : assert(monitor != NULL);
|
|
; 524 : assert(ramp != NULL);
|
|
; 525 : assert(ramp->size > 0);
|
|
; 526 : assert(ramp->red != NULL);
|
|
; 527 : assert(ramp->green != NULL);
|
|
; 528 : assert(ramp->blue != NULL);
|
|
; 529 :
|
|
; 530 : _GLFW_REQUIRE_INIT();
|
|
|
|
0002a e9 00 00 00 00 jmp _glfwInputError
|
|
$LN2@glfwSetGam:
|
|
|
|
; 531 :
|
|
; 532 : if (ramp->size <= 0)
|
|
|
|
0002f 44 8b 42 18 mov r8d, DWORD PTR [rdx+24]
|
|
00033 45 85 c0 test r8d, r8d
|
|
00036 75 1b jne SHORT $LN3@glfwSetGam
|
|
|
|
; 533 : {
|
|
; 534 : _glfwInputError(GLFW_INVALID_VALUE,
|
|
|
|
00038 48 8d 15 00 00
|
|
00 00 lea rdx, OFFSET FLAT:??_C@_0BL@OAABODH@Invalid?5gamma?5ramp?5size?5?$CFi@
|
|
0003f b9 04 00 01 00 mov ecx, 65540 ; 00010004H
|
|
|
|
; 547 : }
|
|
|
|
00044 48 8b 5c 24 30 mov rbx, QWORD PTR [rsp+48]
|
|
00049 48 83 c4 20 add rsp, 32 ; 00000020H
|
|
0004d 5f pop rdi
|
|
|
|
; 533 : {
|
|
; 534 : _glfwInputError(GLFW_INVALID_VALUE,
|
|
|
|
0004e e9 00 00 00 00 jmp _glfwInputError
|
|
$LN3@glfwSetGam:
|
|
|
|
; 535 : "Invalid gamma ramp size %i",
|
|
; 536 : ramp->size);
|
|
; 537 : return;
|
|
; 538 : }
|
|
; 539 :
|
|
; 540 : if (!monitor->originalRamp.size)
|
|
|
|
00053 83 b9 d8 00 00
|
|
00 00 cmp DWORD PTR [rcx+216], 0
|
|
0005a 75 11 jne SHORT $LN5@glfwSetGam
|
|
|
|
; 541 : {
|
|
; 542 : if (!_glfw.platform.getGammaRamp(monitor, &monitor->originalRamp))
|
|
|
|
0005c 48 8d 91 c0 00
|
|
00 00 lea rdx, QWORD PTR [rcx+192]
|
|
00063 ff 15 00 01 00
|
|
00 call QWORD PTR _glfw+256
|
|
00069 85 c0 test eax, eax
|
|
0006b 74 0c je SHORT $LN1@glfwSetGam
|
|
$LN5@glfwSetGam:
|
|
|
|
; 543 : return;
|
|
; 544 : }
|
|
; 545 :
|
|
; 546 : _glfw.platform.setGammaRamp(monitor, ramp);
|
|
|
|
0006d 48 8b d7 mov rdx, rdi
|
|
00070 48 8b cb mov rcx, rbx
|
|
00073 ff 15 08 01 00
|
|
00 call QWORD PTR _glfw+264
|
|
$LN1@glfwSetGam:
|
|
|
|
; 547 : }
|
|
|
|
00079 48 8b 5c 24 30 mov rbx, QWORD PTR [rsp+48]
|
|
0007e 48 83 c4 20 add rsp, 32 ; 00000020H
|
|
00082 5f pop rdi
|
|
00083 c3 ret 0
|
|
glfwSetGammaRamp ENDP
|
|
_TEXT ENDS
|
|
END
|