5060 lines
140 KiB
Plaintext
5060 lines
140 KiB
Plaintext
; Listing generated by Microsoft (R) Optimizing Compiler Version 19.37.32824.0
|
|
|
|
include listing.inc
|
|
|
|
INCLUDELIB OLDNAMES
|
|
|
|
PUBLIC ??_C@_0BK@KJGCMOHN@Invalid?5window?5size?5?$CFix?$CFi@ ; `string'
|
|
PUBLIC ??_C@_0BL@IDFNAMEG@Invalid?5window?5hint?50x?$CF08X@ ; `string'
|
|
PUBLIC ??_C@_0CC@NBPCCDGB@Invalid?5window?5hint?5string?50x?$CF0@ ; `string'
|
|
PUBLIC ??_C@_0CE@MPCJCEEO@Invalid?5image?5count?5for?5window?5@ ; `string'
|
|
PUBLIC ??_C@_0CJ@FFMMFAIL@Invalid?5image?5dimensions?5for?5wi@ ; `string'
|
|
PUBLIC ??_C@_0CC@HJEJGDAP@Invalid?5window?5minimum?5size?5?$CFix@ ; `string'
|
|
PUBLIC ??_C@_0CC@NOHNODHG@Invalid?5window?5maximum?5size?5?$CFix@ ; `string'
|
|
PUBLIC ??_C@_0CC@BPDGBBAB@Invalid?5window?5aspect?5ratio?5?$CFi?3@ ; `string'
|
|
PUBLIC ??_C@_0BK@MBEPKAIA@Invalid?5window?5opacity?5?$CFf@ ; `string'
|
|
PUBLIC ??_C@_0CA@KCGCFCEG@Invalid?5window?5attribute?50x?$CF08X@ ; `string'
|
|
PUBLIC ??_C@_0BI@BFOJALMM@Invalid?5refresh?5rate?5?$CFi@ ; `string'
|
|
; COMDAT ??_C@_0BI@BFOJALMM@Invalid?5refresh?5rate?5?$CFi@
|
|
CONST SEGMENT
|
|
??_C@_0BI@BFOJALMM@Invalid?5refresh?5rate?5?$CFi@ DB 'Invalid refresh rat'
|
|
DB 'e %i', 00H ; `string'
|
|
CONST ENDS
|
|
; COMDAT ??_C@_0CA@KCGCFCEG@Invalid?5window?5attribute?50x?$CF08X@
|
|
CONST SEGMENT
|
|
??_C@_0CA@KCGCFCEG@Invalid?5window?5attribute?50x?$CF08X@ DB 'Invalid win'
|
|
DB 'dow attribute 0x%08X', 00H ; `string'
|
|
CONST ENDS
|
|
; COMDAT ??_C@_0BK@MBEPKAIA@Invalid?5window?5opacity?5?$CFf@
|
|
CONST SEGMENT
|
|
??_C@_0BK@MBEPKAIA@Invalid?5window?5opacity?5?$CFf@ DB 'Invalid window op'
|
|
DB 'acity %f', 00H ; `string'
|
|
CONST ENDS
|
|
; COMDAT ??_C@_0CC@BPDGBBAB@Invalid?5window?5aspect?5ratio?5?$CFi?3@
|
|
CONST SEGMENT
|
|
??_C@_0CC@BPDGBBAB@Invalid?5window?5aspect?5ratio?5?$CFi?3@ DB 'Invalid w'
|
|
DB 'indow aspect ratio %i:%i', 00H ; `string'
|
|
CONST ENDS
|
|
; COMDAT ??_C@_0CC@NOHNODHG@Invalid?5window?5maximum?5size?5?$CFix@
|
|
CONST SEGMENT
|
|
??_C@_0CC@NOHNODHG@Invalid?5window?5maximum?5size?5?$CFix@ DB 'Invalid wi'
|
|
DB 'ndow maximum size %ix%i', 00H ; `string'
|
|
CONST ENDS
|
|
; COMDAT ??_C@_0CC@HJEJGDAP@Invalid?5window?5minimum?5size?5?$CFix@
|
|
CONST SEGMENT
|
|
??_C@_0CC@HJEJGDAP@Invalid?5window?5minimum?5size?5?$CFix@ DB 'Invalid wi'
|
|
DB 'ndow minimum size %ix%i', 00H ; `string'
|
|
CONST ENDS
|
|
; COMDAT ??_C@_0CJ@FFMMFAIL@Invalid?5image?5dimensions?5for?5wi@
|
|
CONST SEGMENT
|
|
??_C@_0CJ@FFMMFAIL@Invalid?5image?5dimensions?5for?5wi@ DB 'Invalid image'
|
|
DB ' dimensions for window icon', 00H ; `string'
|
|
CONST ENDS
|
|
; COMDAT ??_C@_0CE@MPCJCEEO@Invalid?5image?5count?5for?5window?5@
|
|
CONST SEGMENT
|
|
??_C@_0CE@MPCJCEEO@Invalid?5image?5count?5for?5window?5@ DB 'Invalid imag'
|
|
DB 'e count for window icon', 00H ; `string'
|
|
CONST ENDS
|
|
; COMDAT ??_C@_0CC@NBPCCDGB@Invalid?5window?5hint?5string?50x?$CF0@
|
|
CONST SEGMENT
|
|
??_C@_0CC@NBPCCDGB@Invalid?5window?5hint?5string?50x?$CF0@ DB 'Invalid wi'
|
|
DB 'ndow hint string 0x%08X', 00H ; `string'
|
|
CONST ENDS
|
|
; COMDAT ??_C@_0BL@IDFNAMEG@Invalid?5window?5hint?50x?$CF08X@
|
|
CONST SEGMENT
|
|
??_C@_0BL@IDFNAMEG@Invalid?5window?5hint?50x?$CF08X@ DB 'Invalid window h'
|
|
DB 'int 0x%08X', 00H ; `string'
|
|
CONST ENDS
|
|
; COMDAT ??_C@_0BK@KJGCMOHN@Invalid?5window?5size?5?$CFix?$CFi@
|
|
CONST SEGMENT
|
|
??_C@_0BK@KJGCMOHN@Invalid?5window?5size?5?$CFix?$CFi@ DB 'Invalid window'
|
|
DB ' size %ix%i', 00H ; `string'
|
|
PUBLIC glfwPostEmptyEvent
|
|
PUBLIC glfwWaitEventsTimeout
|
|
PUBLIC glfwWaitEvents
|
|
PUBLIC glfwPollEvents
|
|
PUBLIC glfwSetWindowContentScaleCallback
|
|
PUBLIC glfwSetFramebufferSizeCallback
|
|
PUBLIC glfwSetWindowMaximizeCallback
|
|
PUBLIC glfwSetWindowIconifyCallback
|
|
PUBLIC glfwSetWindowFocusCallback
|
|
PUBLIC glfwSetWindowRefreshCallback
|
|
PUBLIC glfwSetWindowCloseCallback
|
|
PUBLIC glfwSetWindowSizeCallback
|
|
PUBLIC glfwSetWindowPosCallback
|
|
PUBLIC glfwGetWindowUserPointer
|
|
PUBLIC glfwSetWindowUserPointer
|
|
PUBLIC glfwSetWindowMonitor
|
|
PUBLIC glfwGetWindowMonitor
|
|
PUBLIC glfwSetWindowAttrib
|
|
PUBLIC glfwGetWindowAttrib
|
|
PUBLIC glfwFocusWindow
|
|
PUBLIC glfwHideWindow
|
|
PUBLIC glfwRequestWindowAttention
|
|
PUBLIC glfwShowWindow
|
|
PUBLIC glfwMaximizeWindow
|
|
PUBLIC glfwRestoreWindow
|
|
PUBLIC glfwIconifyWindow
|
|
PUBLIC glfwSetWindowOpacity
|
|
PUBLIC glfwGetWindowOpacity
|
|
PUBLIC glfwGetWindowContentScale
|
|
PUBLIC glfwGetWindowFrameSize
|
|
PUBLIC glfwGetFramebufferSize
|
|
PUBLIC glfwSetWindowAspectRatio
|
|
PUBLIC glfwSetWindowSizeLimits
|
|
PUBLIC glfwSetWindowSize
|
|
PUBLIC glfwGetWindowSize
|
|
PUBLIC glfwSetWindowPos
|
|
PUBLIC glfwGetWindowPos
|
|
PUBLIC glfwSetWindowIcon
|
|
PUBLIC glfwSetWindowTitle
|
|
PUBLIC glfwSetWindowShouldClose
|
|
PUBLIC glfwWindowShouldClose
|
|
PUBLIC glfwWindowHintString
|
|
PUBLIC glfwWindowHint
|
|
PUBLIC glfwCreateWindow
|
|
PUBLIC _glfwInputWindowCloseRequest
|
|
PUBLIC _glfwInputWindowDamage
|
|
PUBLIC _glfwInputWindowContentScale
|
|
PUBLIC _glfwInputWindowIconify
|
|
PUBLIC _glfwInputWindowFocus
|
|
PUBLIC _glfwInputWindowSize
|
|
PUBLIC _glfwInputWindowMonitor
|
|
PUBLIC _glfwInputFramebufferSize
|
|
PUBLIC _glfwInputWindowMaximize
|
|
PUBLIC _glfwInputWindowPos
|
|
PUBLIC glfwDefaultWindowHints
|
|
PUBLIC glfwDestroyWindow
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$glfwSetWindowContentScaleCallback DD imagerel $LN5
|
|
DD imagerel $LN5+51
|
|
DD imagerel $unwind$glfwSetWindowContentScaleCallback
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$glfwSetFramebufferSizeCallback DD imagerel $LN5
|
|
DD imagerel $LN5+51
|
|
DD imagerel $unwind$glfwSetFramebufferSizeCallback
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$glfwSetWindowMaximizeCallback DD imagerel $LN5
|
|
DD imagerel $LN5+51
|
|
DD imagerel $unwind$glfwSetWindowMaximizeCallback
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$glfwSetWindowIconifyCallback DD imagerel $LN5
|
|
DD imagerel $LN5+51
|
|
DD imagerel $unwind$glfwSetWindowIconifyCallback
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$glfwSetWindowFocusCallback DD imagerel $LN5
|
|
DD imagerel $LN5+51
|
|
DD imagerel $unwind$glfwSetWindowFocusCallback
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$glfwSetWindowRefreshCallback DD imagerel $LN5
|
|
DD imagerel $LN5+51
|
|
DD imagerel $unwind$glfwSetWindowRefreshCallback
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$glfwSetWindowCloseCallback DD imagerel $LN5
|
|
DD imagerel $LN5+51
|
|
DD imagerel $unwind$glfwSetWindowCloseCallback
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$glfwSetWindowSizeCallback DD imagerel $LN5
|
|
DD imagerel $LN5+51
|
|
DD imagerel $unwind$glfwSetWindowSizeCallback
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$glfwSetWindowPosCallback DD imagerel $LN5
|
|
DD imagerel $LN5+51
|
|
DD imagerel $unwind$glfwSetWindowPosCallback
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$glfwGetWindowUserPointer DD imagerel $LN5
|
|
DD imagerel $LN5+41
|
|
DD imagerel $unwind$glfwGetWindowUserPointer
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$glfwGetWindowMonitor DD imagerel $LN5
|
|
DD imagerel $LN5+41
|
|
DD imagerel $unwind$glfwGetWindowMonitor
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$glfwGetWindowAttrib DD imagerel $LN35
|
|
DD imagerel $LN35+492
|
|
DD imagerel $unwind$glfwGetWindowAttrib
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$glfwShowWindow DD imagerel $LN10
|
|
DD imagerel $LN10+75
|
|
DD imagerel $unwind$glfwShowWindow
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$glfwGetWindowOpacity DD imagerel $LN5
|
|
DD imagerel $LN5+49
|
|
DD imagerel $unwind$glfwGetWindowOpacity
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$glfwWindowShouldClose DD imagerel $LN5
|
|
DD imagerel $LN5+40
|
|
DD imagerel $unwind$glfwWindowShouldClose
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$glfwCreateWindow DD imagerel $LN26
|
|
DD imagerel $LN26+409
|
|
DD imagerel $unwind$glfwCreateWindow
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$0$glfwCreateWindow DD imagerel $LN26+409
|
|
DD imagerel $LN26+654
|
|
DD imagerel $chain$0$glfwCreateWindow
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$1$glfwCreateWindow DD imagerel $LN26+654
|
|
DD imagerel $LN26+682
|
|
DD imagerel $chain$1$glfwCreateWindow
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$2$glfwCreateWindow DD imagerel $LN26+682
|
|
DD imagerel $LN26+687
|
|
DD imagerel $chain$2$glfwCreateWindow
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$3$glfwCreateWindow DD imagerel $LN26+687
|
|
DD imagerel $LN26+714
|
|
DD imagerel $chain$3$glfwCreateWindow
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$_glfwInputWindowFocus DD imagerel $LN100
|
|
DD imagerel $LN100+37
|
|
DD imagerel $unwind$_glfwInputWindowFocus
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$1$_glfwInputWindowFocus DD imagerel $LN100+37
|
|
DD imagerel $LN100+164
|
|
DD imagerel $chain$1$_glfwInputWindowFocus
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$2$_glfwInputWindowFocus DD imagerel $LN100+164
|
|
DD imagerel $LN100+580
|
|
DD imagerel $chain$2$_glfwInputWindowFocus
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$glfwDefaultWindowHints DD imagerel $LN5
|
|
DD imagerel $LN5+283
|
|
DD imagerel $unwind$glfwDefaultWindowHints
|
|
pdata ENDS
|
|
; COMDAT pdata
|
|
pdata SEGMENT
|
|
$pdata$glfwDestroyWindow DD imagerel $LN34
|
|
DD imagerel $LN34+256
|
|
DD imagerel $unwind$glfwDestroyWindow
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$glfwDestroyWindow DD 020601H
|
|
DD 030023206H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$glfwDefaultWindowHints DD 010401H
|
|
DD 04204H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$2$_glfwInputWindowFocus DD 021H
|
|
DD imagerel $LN100
|
|
DD imagerel $LN100+37
|
|
DD imagerel $unwind$_glfwInputWindowFocus
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$1$_glfwInputWindowFocus DD 040c21H
|
|
DD 09640cH
|
|
DD 085405H
|
|
DD imagerel $LN100
|
|
DD imagerel $LN100+37
|
|
DD imagerel $unwind$_glfwInputWindowFocus
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$_glfwInputWindowFocus DD 040a01H
|
|
DD 0a340aH
|
|
DD 07006520aH
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$3$glfwCreateWindow DD 021H
|
|
DD imagerel $LN26
|
|
DD imagerel $LN26+409
|
|
DD imagerel $unwind$glfwCreateWindow
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$2$glfwCreateWindow DD 020021H
|
|
DD 0a23400H
|
|
DD imagerel $LN26
|
|
DD imagerel $LN26+409
|
|
DD imagerel $unwind$glfwCreateWindow
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$1$glfwCreateWindow DD 021H
|
|
DD imagerel $LN26
|
|
DD imagerel $LN26+409
|
|
DD imagerel $unwind$glfwCreateWindow
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$chain$0$glfwCreateWindow DD 020821H
|
|
DD 0a23408H
|
|
DD imagerel $LN26
|
|
DD imagerel $LN26+409
|
|
DD imagerel $unwind$glfwCreateWindow
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$glfwCreateWindow DD 062619H
|
|
DD 0a30115H
|
|
DD 07004e006H
|
|
DD 050026003H
|
|
DD imagerel __GSHandlerCheck
|
|
DD 0500H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$glfwWindowShouldClose DD 010401H
|
|
DD 04204H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$glfwGetWindowOpacity DD 010401H
|
|
DD 04204H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$glfwShowWindow DD 020601H
|
|
DD 030023206H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$glfwGetWindowAttrib DD 010401H
|
|
DD 04204H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$glfwGetWindowMonitor DD 010401H
|
|
DD 04204H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$glfwGetWindowUserPointer DD 010401H
|
|
DD 04204H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$glfwSetWindowPosCallback DD 010401H
|
|
DD 04204H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$glfwSetWindowSizeCallback DD 010401H
|
|
DD 04204H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$glfwSetWindowCloseCallback DD 010401H
|
|
DD 04204H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$glfwSetWindowRefreshCallback DD 010401H
|
|
DD 04204H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$glfwSetWindowFocusCallback DD 010401H
|
|
DD 04204H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$glfwSetWindowIconifyCallback DD 010401H
|
|
DD 04204H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$glfwSetWindowMaximizeCallback DD 010401H
|
|
DD 04204H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$glfwSetFramebufferSizeCallback DD 010401H
|
|
DD 04204H
|
|
xdata ENDS
|
|
; COMDAT xdata
|
|
xdata SEGMENT
|
|
$unwind$glfwSetWindowContentScaleCallback DD 010401H
|
|
DD 04204H
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_thread.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\context.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_thread.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\context.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwDestroyWindow
|
|
_TEXT SEGMENT
|
|
handle$ = 48
|
|
glfwDestroyWindow PROC ; COMDAT
|
|
|
|
; 468 : {
|
|
|
|
$LN34:
|
|
00000 40 53 push rbx
|
|
00002 48 83 ec 20 sub rsp, 32 ; 00000020H
|
|
|
|
; 469 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 470 :
|
|
; 471 : _GLFW_REQUIRE_INIT();
|
|
|
|
00006 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
0000d 48 8b d9 mov rbx, rcx
|
|
00010 75 11 jne SHORT $LN4@glfwDestro
|
|
00012 33 d2 xor edx, edx
|
|
00014 b9 01 00 01 00 mov ecx, 65537 ; 00010001H
|
|
|
|
; 498 : }
|
|
|
|
00019 48 83 c4 20 add rsp, 32 ; 00000020H
|
|
0001d 5b pop rbx
|
|
|
|
; 469 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 470 :
|
|
; 471 : _GLFW_REQUIRE_INIT();
|
|
|
|
0001e e9 00 00 00 00 jmp _glfwInputError
|
|
$LN4@glfwDestro:
|
|
|
|
; 472 :
|
|
; 473 : // Allow closing of NULL (to match the behavior of free)
|
|
; 474 : if (window == NULL)
|
|
|
|
00023 48 85 db test rbx, rbx
|
|
00026 0f 84 ce 00 00
|
|
00 je $LN21@glfwDestro
|
|
|
|
; 475 : return;
|
|
; 476 :
|
|
; 477 : // Clear all callbacks to avoid exposing a half torn-down window object
|
|
; 478 : memset(&window->callbacks, 0, sizeof(window->callbacks));
|
|
|
|
0002c 0f 57 c0 xorps xmm0, xmm0
|
|
0002f 33 c0 xor eax, eax
|
|
00031 0f 11 81 d0 02
|
|
00 00 movups XMMWORD PTR [rcx+720], xmm0
|
|
00038 0f 11 81 e0 02
|
|
00 00 movups XMMWORD PTR [rcx+736], xmm0
|
|
0003f 0f 11 81 f0 02
|
|
00 00 movups XMMWORD PTR [rcx+752], xmm0
|
|
00046 0f 11 81 00 03
|
|
00 00 movups XMMWORD PTR [rcx+768], xmm0
|
|
0004d 0f 11 81 10 03
|
|
00 00 movups XMMWORD PTR [rcx+784], xmm0
|
|
00054 0f 11 81 20 03
|
|
00 00 movups XMMWORD PTR [rcx+800], xmm0
|
|
0005b 0f 11 81 30 03
|
|
00 00 movups XMMWORD PTR [rcx+816], xmm0
|
|
00062 0f 11 81 40 03
|
|
00 00 movups XMMWORD PTR [rcx+832], xmm0
|
|
00069 48 89 81 50 03
|
|
00 00 mov QWORD PTR [rcx+848], rax
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_thread.c
|
|
|
|
; 66 : return TlsGetValue(tls->win32.index);
|
|
|
|
00070 8b 0d a8 19 00
|
|
00 mov ecx, DWORD PTR _glfw+6568
|
|
00076 ff 15 00 00 00
|
|
00 call QWORD PTR __imp_TlsGetValue
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
|
|
; 482 : if (window == _glfwPlatformGetTls(&_glfw.contextSlot))
|
|
|
|
0007c 48 3b d8 cmp rbx, rax
|
|
0007f 75 30 jne SHORT $LN16@glfwDestro
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\context.c
|
|
|
|
; 621 : _GLFW_REQUIRE_INIT();
|
|
|
|
00081 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
00088 75 0e jne SHORT $LN11@glfwDestro
|
|
0008a 33 d2 xor edx, edx
|
|
0008c b9 01 00 01 00 mov ecx, 65537 ; 00010001H
|
|
00091 e8 00 00 00 00 call _glfwInputError
|
|
00096 eb 19 jmp SHORT $LN16@glfwDestro
|
|
$LN11@glfwDestro:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\win32_thread.c
|
|
|
|
; 66 : return TlsGetValue(tls->win32.index);
|
|
|
|
00098 8b 0d a8 19 00
|
|
00 mov ecx, DWORD PTR _glfw+6568
|
|
0009e ff 15 00 00 00
|
|
00 call QWORD PTR __imp_TlsGetValue
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\context.c
|
|
|
|
; 632 : if (previous)
|
|
|
|
000a4 48 85 c0 test rax, rax
|
|
000a7 74 08 je SHORT $LN16@glfwDestro
|
|
|
|
; 633 : {
|
|
; 634 : if (!window || window->context.source != previous->context.source)
|
|
; 635 : previous->context.makeCurrent(NULL);
|
|
|
|
000a9 33 c9 xor ecx, ecx
|
|
000ab ff 90 50 02 00
|
|
00 call QWORD PTR [rax+592]
|
|
$LN16@glfwDestro:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
|
|
; 485 : _glfw.platform.destroyWindow(window);
|
|
|
|
000b1 48 8b cb mov rcx, rbx
|
|
000b4 ff 15 18 01 00
|
|
00 call QWORD PTR _glfw+280
|
|
|
|
; 486 :
|
|
; 487 : // Unlink window from global linked list
|
|
; 488 : {
|
|
; 489 : _GLFWwindow** prev = &_glfw.windowListHead;
|
|
; 490 :
|
|
; 491 : while (*prev != window)
|
|
|
|
000ba 48 8b 0d 78 07
|
|
00 00 mov rcx, QWORD PTR _glfw+1912
|
|
000c1 48 8d 15 78 07
|
|
00 00 lea rdx, OFFSET FLAT:_glfw+1912
|
|
000c8 48 3b cb cmp rcx, rbx
|
|
000cb 74 11 je SHORT $LN3@glfwDestro
|
|
000cd 0f 1f 00 npad 3
|
|
$LL2@glfwDestro:
|
|
000d0 48 8b 01 mov rax, QWORD PTR [rcx]
|
|
|
|
; 492 : prev = &((*prev)->next);
|
|
|
|
000d3 48 8b d1 mov rdx, rcx
|
|
000d6 48 8b c8 mov rcx, rax
|
|
000d9 48 3b c3 cmp rax, rbx
|
|
000dc 75 f2 jne SHORT $LL2@glfwDestro
|
|
$LN3@glfwDestro:
|
|
|
|
; 494 : *prev = window->next;
|
|
|
|
000de 48 8b 03 mov rax, QWORD PTR [rbx]
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 321 : _glfw.allocator.deallocate(block, _glfw.allocator.user);
|
|
|
|
000e1 48 8b cb mov rcx, rbx
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
|
|
; 494 : *prev = window->next;
|
|
|
|
000e4 48 89 02 mov QWORD PTR [rdx], rax
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 321 : _glfw.allocator.deallocate(block, _glfw.allocator.user);
|
|
|
|
000e7 48 8b 15 20 00
|
|
00 00 mov rdx, QWORD PTR _glfw+32
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
|
|
; 498 : }
|
|
|
|
000ee 48 83 c4 20 add rsp, 32 ; 00000020H
|
|
000f2 5b pop rbx
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 321 : _glfw.allocator.deallocate(block, _glfw.allocator.user);
|
|
|
|
000f3 48 ff 25 18 00
|
|
00 00 rex_jmp QWORD PTR _glfw+24
|
|
$LN21@glfwDestro:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
|
|
; 498 : }
|
|
|
|
000fa 48 83 c4 20 add rsp, 32 ; 00000020H
|
|
000fe 5b pop rbx
|
|
000ff c3 ret 0
|
|
glfwDestroyWindow ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwDefaultWindowHints
|
|
_TEXT SEGMENT
|
|
glfwDefaultWindowHints PROC ; COMDAT
|
|
|
|
; 258 : {
|
|
|
|
$LN5:
|
|
00000 48 83 ec 28 sub rsp, 40 ; 00000028H
|
|
|
|
; 259 : _GLFW_REQUIRE_INIT();
|
|
|
|
00004 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
0000b 75 10 jne SHORT $LN2@glfwDefaul
|
|
0000d 33 d2 xor edx, edx
|
|
0000f b9 01 00 01 00 mov ecx, 65537 ; 00010001H
|
|
|
|
; 296 : }
|
|
|
|
00014 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
|
|
; 259 : _GLFW_REQUIRE_INIT();
|
|
|
|
00018 e9 00 00 00 00 jmp _glfwInputError
|
|
$LN2@glfwDefaul:
|
|
0001d 0f 57 c0 xorps xmm0, xmm0
|
|
|
|
; 260 :
|
|
; 261 : // The default is OpenGL with minimum version 1.0
|
|
; 262 : memset(&_glfw.hints.context, 0, sizeof(_glfw.hints.context));
|
|
; 263 : _glfw.hints.context.client = GLFW_OPENGL_API;
|
|
; 264 : _glfw.hints.context.source = GLFW_NATIVE_CONTEXT_API;
|
|
; 265 : _glfw.hints.context.major = 1;
|
|
; 266 : _glfw.hints.context.minor = 0;
|
|
; 267 :
|
|
; 268 : // The default is a focused, visible, resizable window with decorations
|
|
; 269 : memset(&_glfw.hints.window, 0, sizeof(_glfw.hints.window));
|
|
|
|
00020 48 8d 0d d8 02
|
|
00 00 lea rcx, OFFSET FLAT:_glfw+728
|
|
00027 0f 11 05 28 07
|
|
00 00 movups XMMWORD PTR _glfw+1832, xmm0
|
|
0002e 33 c0 xor eax, eax
|
|
00030 c7 05 28 07 00
|
|
00 01 00 03 00 mov DWORD PTR _glfw+1832, 196609 ; 00030001H
|
|
0003a 33 d2 xor edx, edx
|
|
0003c c7 05 2c 07 00
|
|
00 01 60 03 00 mov DWORD PTR _glfw+1836, 221185 ; 00036001H
|
|
00046 41 b8 50 04 00
|
|
00 mov r8d, 1104 ; 00000450H
|
|
0004c 48 c7 05 30 07
|
|
00 00 01 00 00
|
|
00 mov QWORD PTR _glfw+1840, 1
|
|
00057 0f 11 05 38 07
|
|
00 00 movups XMMWORD PTR _glfw+1848, xmm0
|
|
0005e 48 89 05 58 07
|
|
00 00 mov QWORD PTR _glfw+1880, rax
|
|
00065 0f 11 05 48 07
|
|
00 00 movups XMMWORD PTR _glfw+1864, xmm0
|
|
0006c e8 00 00 00 00 call memset
|
|
|
|
; 270 : _glfw.hints.window.resizable = GLFW_TRUE;
|
|
|
|
00071 66 0f 6f 05 00
|
|
00 00 00 movdqa xmm0, XMMWORD PTR __xmm@00000001000000010000000100000001
|
|
|
|
; 271 : _glfw.hints.window.visible = GLFW_TRUE;
|
|
; 272 : _glfw.hints.window.decorated = GLFW_TRUE;
|
|
; 273 : _glfw.hints.window.focused = GLFW_TRUE;
|
|
; 274 : _glfw.hints.window.autoIconify = GLFW_TRUE;
|
|
; 275 : _glfw.hints.window.centerCursor = GLFW_TRUE;
|
|
; 276 : _glfw.hints.window.focusOnShow = GLFW_TRUE;
|
|
; 277 : _glfw.hints.window.xpos = GLFW_ANY_POSITION;
|
|
; 278 : _glfw.hints.window.ypos = GLFW_ANY_POSITION;
|
|
; 279 :
|
|
; 280 : // The default is 24 bits of color, 24 bits of depth and 8 bits of stencil,
|
|
; 281 : // double buffered
|
|
; 282 : memset(&_glfw.hints.framebuffer, 0, sizeof(_glfw.hints.framebuffer));
|
|
|
|
00079 33 c0 xor eax, eax
|
|
0007b 66 0f 7f 05 f0
|
|
02 00 00 movdqa XMMWORD PTR _glfw+752, xmm0
|
|
00083 0f 57 c0 xorps xmm0, xmm0
|
|
00086 0f 11 05 a0 02
|
|
00 00 movups XMMWORD PTR _glfw+672, xmm0
|
|
0008d c7 05 00 03 00
|
|
00 01 00 00 00 mov DWORD PTR _glfw+768, 1
|
|
00097 0f 11 05 c0 02
|
|
00 00 movups XMMWORD PTR _glfw+704, xmm0
|
|
0009e c7 05 0c 03 00
|
|
00 01 00 00 00 mov DWORD PTR _glfw+780, 1
|
|
000a8 0f 11 05 b0 02
|
|
00 00 movups XMMWORD PTR _glfw+688, xmm0
|
|
000af c7 05 10 03 00
|
|
00 01 00 00 00 mov DWORD PTR _glfw+784, 1
|
|
|
|
; 283 : _glfw.hints.framebuffer.redBits = 8;
|
|
|
|
000b9 66 0f 6f 05 00
|
|
00 00 00 movdqa xmm0, XMMWORD PTR __xmm@00000008000000080000000800000008
|
|
000c1 66 0f 7f 05 90
|
|
02 00 00 movdqa XMMWORD PTR _glfw+656, xmm0
|
|
000c9 c7 05 d8 02 00
|
|
00 00 00 00 80 mov DWORD PTR _glfw+728, -2147483648 ; ffffffff80000000H
|
|
000d3 c7 05 dc 02 00
|
|
00 00 00 00 80 mov DWORD PTR _glfw+732, -2147483648 ; ffffffff80000000H
|
|
000dd 48 89 05 d0 02
|
|
00 00 mov QWORD PTR _glfw+720, rax
|
|
|
|
; 284 : _glfw.hints.framebuffer.greenBits = 8;
|
|
; 285 : _glfw.hints.framebuffer.blueBits = 8;
|
|
; 286 : _glfw.hints.framebuffer.alphaBits = 8;
|
|
; 287 : _glfw.hints.framebuffer.depthBits = 24;
|
|
|
|
000e4 c7 05 a0 02 00
|
|
00 18 00 00 00 mov DWORD PTR _glfw+672, 24
|
|
|
|
; 288 : _glfw.hints.framebuffer.stencilBits = 8;
|
|
|
|
000ee c7 05 a4 02 00
|
|
00 08 00 00 00 mov DWORD PTR _glfw+676, 8
|
|
|
|
; 289 : _glfw.hints.framebuffer.doublebuffer = GLFW_TRUE;
|
|
|
|
000f8 c7 05 c8 02 00
|
|
00 01 00 00 00 mov DWORD PTR _glfw+712, 1
|
|
|
|
; 290 :
|
|
; 291 : // The default is to select the highest available refresh rate
|
|
; 292 : _glfw.hints.refreshRate = GLFW_DONT_CARE;
|
|
|
|
00102 c7 05 60 07 00
|
|
00 ff ff ff ff mov DWORD PTR _glfw+1888, -1
|
|
|
|
; 293 :
|
|
; 294 : // The default is to use full Retina resolution framebuffers
|
|
; 295 : _glfw.hints.window.ns.retina = GLFW_TRUE;
|
|
|
|
0010c c7 05 1c 03 00
|
|
00 01 00 00 00 mov DWORD PTR _glfw+796, 1
|
|
|
|
; 296 : }
|
|
|
|
00116 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
0011a c3 ret 0
|
|
glfwDefaultWindowHints ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT _glfwInputWindowPos
|
|
_TEXT SEGMENT
|
|
window$ = 8
|
|
x$ = 16
|
|
y$ = 24
|
|
_glfwInputWindowPos PROC ; COMDAT
|
|
|
|
; 79 : assert(window != NULL);
|
|
; 80 :
|
|
; 81 : if (window->callbacks.pos)
|
|
|
|
00000 48 8b 81 d0 02
|
|
00 00 mov rax, QWORD PTR [rcx+720]
|
|
00007 48 85 c0 test rax, rax
|
|
0000a 74 03 je SHORT $LN2@glfwInputW
|
|
|
|
; 82 : window->callbacks.pos((GLFWwindow*) window, x, y);
|
|
|
|
0000c 48 ff e0 rex_jmp rax
|
|
$LN2@glfwInputW:
|
|
|
|
; 83 : }
|
|
|
|
0000f c3 ret 0
|
|
_glfwInputWindowPos ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT _glfwInputWindowMaximize
|
|
_TEXT SEGMENT
|
|
window$ = 8
|
|
maximized$ = 16
|
|
_glfwInputWindowMaximize PROC ; COMDAT
|
|
|
|
; 113 : assert(window != NULL);
|
|
; 114 : assert(maximized == GLFW_TRUE || maximized == GLFW_FALSE);
|
|
; 115 :
|
|
; 116 : if (window->callbacks.maximize)
|
|
|
|
00000 48 8b 81 00 03
|
|
00 00 mov rax, QWORD PTR [rcx+768]
|
|
00007 48 85 c0 test rax, rax
|
|
0000a 74 03 je SHORT $LN2@glfwInputW
|
|
|
|
; 117 : window->callbacks.maximize((GLFWwindow*) window, maximized);
|
|
|
|
0000c 48 ff e0 rex_jmp rax
|
|
$LN2@glfwInputW:
|
|
|
|
; 118 : }
|
|
|
|
0000f c3 ret 0
|
|
_glfwInputWindowMaximize ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT _glfwInputFramebufferSize
|
|
_TEXT SEGMENT
|
|
window$ = 8
|
|
width$ = 16
|
|
height$ = 24
|
|
_glfwInputFramebufferSize PROC ; COMDAT
|
|
|
|
; 125 : assert(window != NULL);
|
|
; 126 : assert(width >= 0);
|
|
; 127 : assert(height >= 0);
|
|
; 128 :
|
|
; 129 : if (window->callbacks.fbsize)
|
|
|
|
00000 48 8b 81 08 03
|
|
00 00 mov rax, QWORD PTR [rcx+776]
|
|
00007 48 85 c0 test rax, rax
|
|
0000a 74 03 je SHORT $LN2@glfwInputF
|
|
|
|
; 130 : window->callbacks.fbsize((GLFWwindow*) window, width, height);
|
|
|
|
0000c 48 ff e0 rex_jmp rax
|
|
$LN2@glfwInputF:
|
|
|
|
; 131 : }
|
|
|
|
0000f c3 ret 0
|
|
_glfwInputFramebufferSize ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT _glfwInputWindowMonitor
|
|
_TEXT SEGMENT
|
|
window$ = 8
|
|
monitor$ = 16
|
|
_glfwInputWindowMonitor PROC ; COMDAT
|
|
|
|
; 174 : assert(window != NULL);
|
|
; 175 : window->monitor = monitor;
|
|
|
|
00000 48 89 51 50 mov QWORD PTR [rcx+80], rdx
|
|
|
|
; 176 : }
|
|
|
|
00004 c3 ret 0
|
|
_glfwInputWindowMonitor ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT _glfwInputWindowSize
|
|
_TEXT SEGMENT
|
|
window$ = 8
|
|
width$ = 16
|
|
height$ = 24
|
|
_glfwInputWindowSize PROC ; COMDAT
|
|
|
|
; 90 : assert(window != NULL);
|
|
; 91 : assert(width >= 0);
|
|
; 92 : assert(height >= 0);
|
|
; 93 :
|
|
; 94 : if (window->callbacks.size)
|
|
|
|
00000 48 8b 81 d8 02
|
|
00 00 mov rax, QWORD PTR [rcx+728]
|
|
00007 48 85 c0 test rax, rax
|
|
0000a 74 03 je SHORT $LN2@glfwInputW
|
|
|
|
; 95 : window->callbacks.size((GLFWwindow*) window, width, height);
|
|
|
|
0000c 48 ff e0 rex_jmp rax
|
|
$LN2@glfwInputW:
|
|
|
|
; 96 : }
|
|
|
|
0000f c3 ret 0
|
|
_glfwInputWindowSize ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\input.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\input.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\input.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\input.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\input.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\input.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\input.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\input.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\input.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT _glfwInputWindowFocus
|
|
_TEXT SEGMENT
|
|
window$ = 64
|
|
focused$ = 72
|
|
_glfwInputWindowFocus PROC ; COMDAT
|
|
|
|
; 46 : {
|
|
|
|
$LN100:
|
|
00000 48 89 5c 24 18 mov QWORD PTR [rsp+24], rbx
|
|
00005 57 push rdi
|
|
00006 48 83 ec 30 sub rsp, 48 ; 00000030H
|
|
|
|
; 47 : assert(window != NULL);
|
|
; 48 : assert(focused == GLFW_TRUE || focused == GLFW_FALSE);
|
|
; 49 :
|
|
; 50 : if (window->callbacks.focus)
|
|
|
|
0000a 48 8b 81 f0 02
|
|
00 00 mov rax, QWORD PTR [rcx+752]
|
|
00011 8b fa mov edi, edx
|
|
00013 48 8b d9 mov rbx, rcx
|
|
00016 48 85 c0 test rax, rax
|
|
00019 74 02 je SHORT $LN8@glfwInputW
|
|
|
|
; 51 : window->callbacks.focus((GLFWwindow*) window, focused);
|
|
|
|
0001b ff d0 call rax
|
|
$LN8@glfwInputW:
|
|
|
|
; 52 :
|
|
; 53 : if (!focused)
|
|
|
|
0001d 85 ff test edi, edi
|
|
0001f 0f 85 14 02 00
|
|
00 jne $LN69@glfwInputW
|
|
00025 48 89 6c 24 40 mov QWORD PTR [rsp+64], rbp
|
|
|
|
; 57 : for (key = 0; key <= GLFW_KEY_LAST; key++)
|
|
|
|
0002a 33 ed xor ebp, ebp
|
|
0002c 48 89 74 24 48 mov QWORD PTR [rsp+72], rsi
|
|
00031 8b fd mov edi, ebp
|
|
00033 48 8d b3 90 00
|
|
00 00 lea rsi, QWORD PTR [rbx+144]
|
|
0003a 66 0f 1f 44 00
|
|
00 npad 6
|
|
$LL4@glfwInputW:
|
|
|
|
; 58 : {
|
|
; 59 : if (window->keys[key] == GLFW_PRESS)
|
|
|
|
00040 80 3e 01 cmp BYTE PTR [rsi], 1
|
|
00043 75 3f jne SHORT $LN2@glfwInputW
|
|
|
|
; 60 : {
|
|
; 61 : const int scancode = _glfw.platform.getKeyScancode(key);
|
|
|
|
00045 8b cf mov ecx, edi
|
|
00047 ff 15 90 00 00
|
|
00 call QWORD PTR _glfw+144
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\input.c
|
|
|
|
; 282 : if (key >= 0 && key <= GLFW_KEY_LAST)
|
|
|
|
0004d 81 ff 5c 01 00
|
|
00 cmp edi, 348 ; 0000015cH
|
|
00053 77 11 ja SHORT $LN75@glfwInputW
|
|
|
|
; 283 : {
|
|
; 284 : GLFWbool repeated = GLFW_FALSE;
|
|
; 285 :
|
|
; 286 : if (action == GLFW_RELEASE && window->keys[key] == GLFW_RELEASE)
|
|
|
|
00055 40 38 2e cmp BYTE PTR [rsi], bpl
|
|
00058 74 2a je SHORT $LN2@glfwInputW
|
|
|
|
; 287 : return;
|
|
; 288 :
|
|
; 289 : if (action == GLFW_PRESS && window->keys[key] == GLFW_PRESS)
|
|
; 290 : repeated = GLFW_TRUE;
|
|
; 291 :
|
|
; 292 : if (action == GLFW_RELEASE && window->stickyKeys)
|
|
; 293 : window->keys[key] = _GLFW_STICK;
|
|
; 294 : else
|
|
; 295 : window->keys[key] = (char)action;
|
|
; 296 :
|
|
; 297 : if (repeated)
|
|
|
|
0005a 8b 4b 78 mov ecx, DWORD PTR [rbx+120]
|
|
0005d f7 d9 neg ecx
|
|
0005f 1a d2 sbb dl, dl
|
|
00061 80 e2 03 and dl, 3
|
|
00064 88 16 mov BYTE PTR [rsi], dl
|
|
$LN75@glfwInputW:
|
|
|
|
; 298 : action = GLFW_REPEAT;
|
|
; 299 : }
|
|
; 300 :
|
|
; 301 : if (!window->lockKeyMods)
|
|
; 302 : mods &= ~(GLFW_MOD_CAPS_LOCK | GLFW_MOD_NUM_LOCK);
|
|
; 303 :
|
|
; 304 : if (window->callbacks.key)
|
|
|
|
00066 4c 8b 93 38 03
|
|
00 00 mov r10, QWORD PTR [rbx+824]
|
|
0006d 4d 85 d2 test r10, r10
|
|
00070 74 12 je SHORT $LN2@glfwInputW
|
|
|
|
; 305 : window->callbacks.key((GLFWwindow*)window, key, scancode, action, mods);
|
|
|
|
00072 45 33 c9 xor r9d, r9d
|
|
00075 89 6c 24 20 mov DWORD PTR [rsp+32], ebp
|
|
00079 44 8b c0 mov r8d, eax
|
|
0007c 8b d7 mov edx, edi
|
|
0007e 48 8b cb mov rcx, rbx
|
|
00081 41 ff d2 call r10
|
|
$LN2@glfwInputW:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
|
|
; 57 : for (key = 0; key <= GLFW_KEY_LAST; key++)
|
|
|
|
00084 ff c7 inc edi
|
|
00086 48 ff c6 inc rsi
|
|
00089 81 ff 5c 01 00
|
|
00 cmp edi, 348 ; 0000015cH
|
|
0008f 7e af jle SHORT $LL4@glfwInputW
|
|
|
|
; 68 : if (window->mouseButtons[button] == GLFW_PRESS)
|
|
|
|
00091 80 bb 88 00 00
|
|
00 01 cmp BYTE PTR [rbx+136], 1
|
|
00098 48 8b 74 24 48 mov rsi, QWORD PTR [rsp+72]
|
|
0009d 48 8b 6c 24 40 mov rbp, QWORD PTR [rsp+64]
|
|
000a2 75 29 jne SHORT $LN5@glfwInputW
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\input.c
|
|
|
|
; 368 : if (window->callbacks.mouseButton)
|
|
|
|
000a4 8b 43 7c mov eax, DWORD PTR [rbx+124]
|
|
000a7 f7 d8 neg eax
|
|
000a9 1a c9 sbb cl, cl
|
|
000ab 80 e1 03 and cl, 3
|
|
000ae 88 8b 88 00 00
|
|
00 mov BYTE PTR [rbx+136], cl
|
|
000b4 48 8b 83 18 03
|
|
00 00 mov rax, QWORD PTR [rbx+792]
|
|
000bb 48 85 c0 test rax, rax
|
|
000be 74 0d je SHORT $LN5@glfwInputW
|
|
|
|
; 369 : window->callbacks.mouseButton((GLFWwindow*)window, button, action, mods);
|
|
|
|
000c0 45 33 c9 xor r9d, r9d
|
|
000c3 45 33 c0 xor r8d, r8d
|
|
000c6 33 d2 xor edx, edx
|
|
000c8 48 8b cb mov rcx, rbx
|
|
000cb ff d0 call rax
|
|
$LN5@glfwInputW:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
|
|
; 68 : if (window->mouseButtons[button] == GLFW_PRESS)
|
|
|
|
000cd 80 bb 89 00 00
|
|
00 01 cmp BYTE PTR [rbx+137], 1
|
|
000d4 75 2b jne SHORT $LN39@glfwInputW
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\input.c
|
|
|
|
; 368 : if (window->callbacks.mouseButton)
|
|
|
|
000d6 8b 43 7c mov eax, DWORD PTR [rbx+124]
|
|
000d9 f7 d8 neg eax
|
|
000db 1a c9 sbb cl, cl
|
|
000dd 80 e1 03 and cl, 3
|
|
000e0 88 8b 89 00 00
|
|
00 mov BYTE PTR [rbx+137], cl
|
|
000e6 48 8b 83 18 03
|
|
00 00 mov rax, QWORD PTR [rbx+792]
|
|
000ed 48 85 c0 test rax, rax
|
|
000f0 74 0f je SHORT $LN39@glfwInputW
|
|
|
|
; 369 : window->callbacks.mouseButton((GLFWwindow*)window, button, action, mods);
|
|
|
|
000f2 45 33 c9 xor r9d, r9d
|
|
000f5 45 33 c0 xor r8d, r8d
|
|
000f8 48 8b cb mov rcx, rbx
|
|
000fb 41 8d 51 01 lea edx, QWORD PTR [r9+1]
|
|
000ff ff d0 call rax
|
|
$LN39@glfwInputW:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
|
|
; 68 : if (window->mouseButtons[button] == GLFW_PRESS)
|
|
|
|
00101 80 bb 8a 00 00
|
|
00 01 cmp BYTE PTR [rbx+138], 1
|
|
00108 75 2b jne SHORT $LN44@glfwInputW
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\input.c
|
|
|
|
; 368 : if (window->callbacks.mouseButton)
|
|
|
|
0010a 8b 43 7c mov eax, DWORD PTR [rbx+124]
|
|
0010d f7 d8 neg eax
|
|
0010f 1a c9 sbb cl, cl
|
|
00111 80 e1 03 and cl, 3
|
|
00114 88 8b 8a 00 00
|
|
00 mov BYTE PTR [rbx+138], cl
|
|
0011a 48 8b 83 18 03
|
|
00 00 mov rax, QWORD PTR [rbx+792]
|
|
00121 48 85 c0 test rax, rax
|
|
00124 74 0f je SHORT $LN44@glfwInputW
|
|
|
|
; 369 : window->callbacks.mouseButton((GLFWwindow*)window, button, action, mods);
|
|
|
|
00126 45 33 c9 xor r9d, r9d
|
|
00129 45 33 c0 xor r8d, r8d
|
|
0012c 48 8b cb mov rcx, rbx
|
|
0012f 41 8d 51 02 lea edx, QWORD PTR [r9+2]
|
|
00133 ff d0 call rax
|
|
$LN44@glfwInputW:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
|
|
; 68 : if (window->mouseButtons[button] == GLFW_PRESS)
|
|
|
|
00135 80 bb 8b 00 00
|
|
00 01 cmp BYTE PTR [rbx+139], 1
|
|
0013c 75 2b jne SHORT $LN49@glfwInputW
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\input.c
|
|
|
|
; 368 : if (window->callbacks.mouseButton)
|
|
|
|
0013e 8b 43 7c mov eax, DWORD PTR [rbx+124]
|
|
00141 f7 d8 neg eax
|
|
00143 1a c9 sbb cl, cl
|
|
00145 80 e1 03 and cl, 3
|
|
00148 88 8b 8b 00 00
|
|
00 mov BYTE PTR [rbx+139], cl
|
|
0014e 48 8b 83 18 03
|
|
00 00 mov rax, QWORD PTR [rbx+792]
|
|
00155 48 85 c0 test rax, rax
|
|
00158 74 0f je SHORT $LN49@glfwInputW
|
|
|
|
; 369 : window->callbacks.mouseButton((GLFWwindow*)window, button, action, mods);
|
|
|
|
0015a 45 33 c9 xor r9d, r9d
|
|
0015d 45 33 c0 xor r8d, r8d
|
|
00160 48 8b cb mov rcx, rbx
|
|
00163 41 8d 51 03 lea edx, QWORD PTR [r9+3]
|
|
00167 ff d0 call rax
|
|
$LN49@glfwInputW:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
|
|
; 68 : if (window->mouseButtons[button] == GLFW_PRESS)
|
|
|
|
00169 80 bb 8c 00 00
|
|
00 01 cmp BYTE PTR [rbx+140], 1
|
|
00170 75 2b jne SHORT $LN54@glfwInputW
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\input.c
|
|
|
|
; 368 : if (window->callbacks.mouseButton)
|
|
|
|
00172 8b 43 7c mov eax, DWORD PTR [rbx+124]
|
|
00175 f7 d8 neg eax
|
|
00177 1a c9 sbb cl, cl
|
|
00179 80 e1 03 and cl, 3
|
|
0017c 88 8b 8c 00 00
|
|
00 mov BYTE PTR [rbx+140], cl
|
|
00182 48 8b 83 18 03
|
|
00 00 mov rax, QWORD PTR [rbx+792]
|
|
00189 48 85 c0 test rax, rax
|
|
0018c 74 0f je SHORT $LN54@glfwInputW
|
|
|
|
; 369 : window->callbacks.mouseButton((GLFWwindow*)window, button, action, mods);
|
|
|
|
0018e 45 33 c9 xor r9d, r9d
|
|
00191 45 33 c0 xor r8d, r8d
|
|
00194 48 8b cb mov rcx, rbx
|
|
00197 41 8d 51 04 lea edx, QWORD PTR [r9+4]
|
|
0019b ff d0 call rax
|
|
$LN54@glfwInputW:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
|
|
; 68 : if (window->mouseButtons[button] == GLFW_PRESS)
|
|
|
|
0019d 80 bb 8d 00 00
|
|
00 01 cmp BYTE PTR [rbx+141], 1
|
|
001a4 75 2b jne SHORT $LN59@glfwInputW
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\input.c
|
|
|
|
; 368 : if (window->callbacks.mouseButton)
|
|
|
|
001a6 8b 43 7c mov eax, DWORD PTR [rbx+124]
|
|
001a9 f7 d8 neg eax
|
|
001ab 1a c9 sbb cl, cl
|
|
001ad 80 e1 03 and cl, 3
|
|
001b0 88 8b 8d 00 00
|
|
00 mov BYTE PTR [rbx+141], cl
|
|
001b6 48 8b 83 18 03
|
|
00 00 mov rax, QWORD PTR [rbx+792]
|
|
001bd 48 85 c0 test rax, rax
|
|
001c0 74 0f je SHORT $LN59@glfwInputW
|
|
|
|
; 369 : window->callbacks.mouseButton((GLFWwindow*)window, button, action, mods);
|
|
|
|
001c2 45 33 c9 xor r9d, r9d
|
|
001c5 45 33 c0 xor r8d, r8d
|
|
001c8 48 8b cb mov rcx, rbx
|
|
001cb 41 8d 51 05 lea edx, QWORD PTR [r9+5]
|
|
001cf ff d0 call rax
|
|
$LN59@glfwInputW:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
|
|
; 68 : if (window->mouseButtons[button] == GLFW_PRESS)
|
|
|
|
001d1 80 bb 8e 00 00
|
|
00 01 cmp BYTE PTR [rbx+142], 1
|
|
001d8 75 2b jne SHORT $LN64@glfwInputW
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\input.c
|
|
|
|
; 368 : if (window->callbacks.mouseButton)
|
|
|
|
001da 8b 43 7c mov eax, DWORD PTR [rbx+124]
|
|
001dd f7 d8 neg eax
|
|
001df 1a c9 sbb cl, cl
|
|
001e1 80 e1 03 and cl, 3
|
|
001e4 88 8b 8e 00 00
|
|
00 mov BYTE PTR [rbx+142], cl
|
|
001ea 48 8b 83 18 03
|
|
00 00 mov rax, QWORD PTR [rbx+792]
|
|
001f1 48 85 c0 test rax, rax
|
|
001f4 74 0f je SHORT $LN64@glfwInputW
|
|
|
|
; 369 : window->callbacks.mouseButton((GLFWwindow*)window, button, action, mods);
|
|
|
|
001f6 45 33 c9 xor r9d, r9d
|
|
001f9 45 33 c0 xor r8d, r8d
|
|
001fc 48 8b cb mov rcx, rbx
|
|
001ff 41 8d 51 06 lea edx, QWORD PTR [r9+6]
|
|
00203 ff d0 call rax
|
|
$LN64@glfwInputW:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
|
|
; 68 : if (window->mouseButtons[button] == GLFW_PRESS)
|
|
|
|
00205 80 bb 8f 00 00
|
|
00 01 cmp BYTE PTR [rbx+143], 1
|
|
0020c 75 2b jne SHORT $LN69@glfwInputW
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\input.c
|
|
|
|
; 368 : if (window->callbacks.mouseButton)
|
|
|
|
0020e 8b 43 7c mov eax, DWORD PTR [rbx+124]
|
|
00211 f7 d8 neg eax
|
|
00213 1a c9 sbb cl, cl
|
|
00215 80 e1 03 and cl, 3
|
|
00218 88 8b 8f 00 00
|
|
00 mov BYTE PTR [rbx+143], cl
|
|
0021e 48 8b 83 18 03
|
|
00 00 mov rax, QWORD PTR [rbx+792]
|
|
00225 48 85 c0 test rax, rax
|
|
00228 74 0f je SHORT $LN69@glfwInputW
|
|
|
|
; 369 : window->callbacks.mouseButton((GLFWwindow*)window, button, action, mods);
|
|
|
|
0022a 45 33 c9 xor r9d, r9d
|
|
0022d 45 33 c0 xor r8d, r8d
|
|
00230 48 8b cb mov rcx, rbx
|
|
00233 41 8d 51 07 lea edx, QWORD PTR [r9+7]
|
|
00237 ff d0 call rax
|
|
$LN69@glfwInputW:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
|
|
; 72 : }
|
|
|
|
00239 48 8b 5c 24 50 mov rbx, QWORD PTR [rsp+80]
|
|
0023e 48 83 c4 30 add rsp, 48 ; 00000030H
|
|
00242 5f pop rdi
|
|
00243 c3 ret 0
|
|
_glfwInputWindowFocus ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT _glfwInputWindowIconify
|
|
_TEXT SEGMENT
|
|
window$ = 8
|
|
iconified$ = 16
|
|
_glfwInputWindowIconify PROC ; COMDAT
|
|
|
|
; 102 : assert(window != NULL);
|
|
; 103 : assert(iconified == GLFW_TRUE || iconified == GLFW_FALSE);
|
|
; 104 :
|
|
; 105 : if (window->callbacks.iconify)
|
|
|
|
00000 48 8b 81 f8 02
|
|
00 00 mov rax, QWORD PTR [rcx+760]
|
|
00007 48 85 c0 test rax, rax
|
|
0000a 74 03 je SHORT $LN2@glfwInputW
|
|
|
|
; 106 : window->callbacks.iconify((GLFWwindow*) window, iconified);
|
|
|
|
0000c 48 ff e0 rex_jmp rax
|
|
$LN2@glfwInputW:
|
|
|
|
; 107 : }
|
|
|
|
0000f c3 ret 0
|
|
_glfwInputWindowIconify ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT _glfwInputWindowContentScale
|
|
_TEXT SEGMENT
|
|
window$ = 8
|
|
xscale$ = 16
|
|
yscale$ = 24
|
|
_glfwInputWindowContentScale PROC ; COMDAT
|
|
|
|
; 138 : assert(window != NULL);
|
|
; 139 : assert(xscale > 0.f);
|
|
; 140 : assert(xscale < FLT_MAX);
|
|
; 141 : assert(yscale > 0.f);
|
|
; 142 : assert(yscale < FLT_MAX);
|
|
; 143 :
|
|
; 144 : if (window->callbacks.scale)
|
|
|
|
00000 48 8b 81 10 03
|
|
00 00 mov rax, QWORD PTR [rcx+784]
|
|
00007 48 85 c0 test rax, rax
|
|
0000a 74 03 je SHORT $LN2@glfwInputW
|
|
|
|
; 145 : window->callbacks.scale((GLFWwindow*) window, xscale, yscale);
|
|
|
|
0000c 48 ff e0 rex_jmp rax
|
|
$LN2@glfwInputW:
|
|
|
|
; 146 : }
|
|
|
|
0000f c3 ret 0
|
|
_glfwInputWindowContentScale ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT _glfwInputWindowDamage
|
|
_TEXT SEGMENT
|
|
window$ = 8
|
|
_glfwInputWindowDamage PROC ; COMDAT
|
|
|
|
; 152 : assert(window != NULL);
|
|
; 153 :
|
|
; 154 : if (window->callbacks.refresh)
|
|
|
|
00000 48 8b 81 e8 02
|
|
00 00 mov rax, QWORD PTR [rcx+744]
|
|
00007 48 85 c0 test rax, rax
|
|
0000a 74 03 je SHORT $LN2@glfwInputW
|
|
|
|
; 155 : window->callbacks.refresh((GLFWwindow*) window);
|
|
|
|
0000c 48 ff e0 rex_jmp rax
|
|
$LN2@glfwInputW:
|
|
|
|
; 156 : }
|
|
|
|
0000f c3 ret 0
|
|
_glfwInputWindowDamage ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT _glfwInputWindowCloseRequest
|
|
_TEXT SEGMENT
|
|
window$ = 8
|
|
_glfwInputWindowCloseRequest PROC ; COMDAT
|
|
|
|
; 162 : assert(window != NULL);
|
|
; 163 :
|
|
; 164 : window->shouldClose = GLFW_TRUE;
|
|
; 165 :
|
|
; 166 : if (window->callbacks.close)
|
|
|
|
00000 48 8b 81 e0 02
|
|
00 00 mov rax, QWORD PTR [rcx+736]
|
|
00007 c7 41 20 01 00
|
|
00 00 mov DWORD PTR [rcx+32], 1
|
|
0000e 48 85 c0 test rax, rax
|
|
00011 74 03 je SHORT $LN2@glfwInputW
|
|
|
|
; 167 : window->callbacks.close((GLFWwindow*) window);
|
|
|
|
00013 48 ff e0 rex_jmp rax
|
|
$LN2@glfwInputW:
|
|
|
|
; 168 : }
|
|
|
|
00016 c3 ret 0
|
|
_glfwInputWindowCloseRequest ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwCreateWindow
|
|
_TEXT SEGMENT
|
|
ctxconfig$ = 32
|
|
wndconfig$ = 96
|
|
fbconfig$ = 1200
|
|
__$ArrayPad$ = 1280
|
|
width$ = 1344
|
|
height$ = 1352
|
|
title$ = 1360
|
|
monitor$ = 1368
|
|
share$ = 1376
|
|
glfwCreateWindow PROC ; COMDAT
|
|
|
|
; 186 : {
|
|
|
|
$LN26:
|
|
00000 40 55 push rbp
|
|
00002 56 push rsi
|
|
00003 57 push rdi
|
|
00004 41 56 push r14
|
|
00006 48 8d ac 24 e8
|
|
fb ff ff lea rbp, QWORD PTR [rsp-1048]
|
|
0000e 48 81 ec 18 05
|
|
00 00 sub rsp, 1304 ; 00000518H
|
|
00015 48 8b 05 00 00
|
|
00 00 mov rax, QWORD PTR __security_cookie
|
|
0001c 48 33 c4 xor rax, rsp
|
|
0001f 48 89 85 00 04
|
|
00 00 mov QWORD PTR __$ArrayPad$[rbp-256], rax
|
|
|
|
; 187 : _GLFWfbconfig fbconfig;
|
|
; 188 : _GLFWctxconfig ctxconfig;
|
|
; 189 : _GLFWwndconfig wndconfig;
|
|
; 190 : _GLFWwindow* window;
|
|
; 191 :
|
|
; 192 : assert(title != NULL);
|
|
; 193 : assert(width >= 0);
|
|
; 194 : assert(height >= 0);
|
|
; 195 :
|
|
; 196 : _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
|
|
|
|
00026 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
0002d 4d 8b f1 mov r14, r9
|
|
00030 4c 8b 95 60 04
|
|
00 00 mov r10, QWORD PTR share$[rbp-256]
|
|
00037 8b f2 mov esi, edx
|
|
00039 8b f9 mov edi, ecx
|
|
0003b 75 13 jne SHORT $LN2@glfwCreate
|
|
0003d 33 d2 xor edx, edx
|
|
0003f b9 01 00 01 00 mov ecx, 65537 ; 00010001H
|
|
00044 e8 00 00 00 00 call _glfwInputError
|
|
$LN24@glfwCreate:
|
|
|
|
; 255 : }
|
|
|
|
00049 33 c0 xor eax, eax
|
|
0004b e9 3e 02 00 00 jmp $LN1@glfwCreate
|
|
$LN2@glfwCreate:
|
|
|
|
; 197 :
|
|
; 198 : if (width <= 0 || height <= 0)
|
|
|
|
00050 85 ff test edi, edi
|
|
00052 0f 8e 57 02 00
|
|
00 jle $LN4@glfwCreate
|
|
00058 85 f6 test esi, esi
|
|
0005a 0f 8e 4f 02 00
|
|
00 jle $LN4@glfwCreate
|
|
|
|
; 205 : }
|
|
; 206 :
|
|
; 207 : fbconfig = _glfw.hints.framebuffer;
|
|
|
|
00060 0f 28 05 90 02
|
|
00 00 movaps xmm0, XMMWORD PTR _glfw+656
|
|
|
|
; 208 : ctxconfig = _glfw.hints.context;
|
|
; 209 : wndconfig = _glfw.hints.window;
|
|
|
|
00067 48 8d 4c 24 60 lea rcx, QWORD PTR wndconfig$[rsp]
|
|
0006c 0f 28 0d a0 02
|
|
00 00 movaps xmm1, XMMWORD PTR _glfw+672
|
|
00073 48 8d 05 d8 02
|
|
00 00 lea rax, OFFSET FLAT:_glfw+728
|
|
0007a 0f 29 85 b0 03
|
|
00 00 movaps XMMWORD PTR fbconfig$[rbp-256], xmm0
|
|
00081 ba 08 00 00 00 mov edx, 8
|
|
00086 0f 28 05 b0 02
|
|
00 00 movaps xmm0, XMMWORD PTR _glfw+688
|
|
0008d 0f 29 8d c0 03
|
|
00 00 movaps XMMWORD PTR fbconfig$[rbp-240], xmm1
|
|
00094 0f 28 0d c0 02
|
|
00 00 movaps xmm1, XMMWORD PTR _glfw+704
|
|
0009b 0f 29 85 d0 03
|
|
00 00 movaps XMMWORD PTR fbconfig$[rbp-224], xmm0
|
|
000a2 f2 0f 10 05 d0
|
|
02 00 00 movsd xmm0, QWORD PTR _glfw+720
|
|
000aa 0f 29 8d e0 03
|
|
00 00 movaps XMMWORD PTR fbconfig$[rbp-208], xmm1
|
|
000b1 0f 10 0d 28 07
|
|
00 00 movups xmm1, XMMWORD PTR _glfw+1832
|
|
000b8 f2 0f 11 85 f0
|
|
03 00 00 movsd QWORD PTR fbconfig$[rbp-192], xmm0
|
|
000c0 0f 10 05 38 07
|
|
00 00 movups xmm0, XMMWORD PTR _glfw+1848
|
|
000c7 0f 11 4c 24 20 movups XMMWORD PTR ctxconfig$[rsp], xmm1
|
|
000cc 0f 10 0d 48 07
|
|
00 00 movups xmm1, XMMWORD PTR _glfw+1864
|
|
000d3 0f 11 44 24 30 movups XMMWORD PTR ctxconfig$[rsp+16], xmm0
|
|
000d8 f2 0f 10 05 58
|
|
07 00 00 movsd xmm0, QWORD PTR _glfw+1880
|
|
000e0 f2 0f 11 44 24
|
|
50 movsd QWORD PTR ctxconfig$[rsp+48], xmm0
|
|
000e6 0f 11 4c 24 40 movups XMMWORD PTR ctxconfig$[rsp+32], xmm1
|
|
000eb 0f 1f 44 00 00 npad 5
|
|
$LL15@glfwCreate:
|
|
000f0 48 8d 89 80 00
|
|
00 00 lea rcx, QWORD PTR [rcx+128]
|
|
000f7 0f 10 00 movups xmm0, XMMWORD PTR [rax]
|
|
000fa 0f 10 48 10 movups xmm1, XMMWORD PTR [rax+16]
|
|
000fe 48 8d 80 80 00
|
|
00 00 lea rax, QWORD PTR [rax+128]
|
|
00105 0f 11 41 80 movups XMMWORD PTR [rcx-128], xmm0
|
|
00109 0f 10 40 a0 movups xmm0, XMMWORD PTR [rax-96]
|
|
0010d 0f 11 49 90 movups XMMWORD PTR [rcx-112], xmm1
|
|
00111 0f 10 48 b0 movups xmm1, XMMWORD PTR [rax-80]
|
|
00115 0f 11 41 a0 movups XMMWORD PTR [rcx-96], xmm0
|
|
00119 0f 10 40 c0 movups xmm0, XMMWORD PTR [rax-64]
|
|
0011d 0f 11 49 b0 movups XMMWORD PTR [rcx-80], xmm1
|
|
00121 0f 10 48 d0 movups xmm1, XMMWORD PTR [rax-48]
|
|
00125 0f 11 41 c0 movups XMMWORD PTR [rcx-64], xmm0
|
|
00129 0f 10 40 e0 movups xmm0, XMMWORD PTR [rax-32]
|
|
0012d 0f 11 49 d0 movups XMMWORD PTR [rcx-48], xmm1
|
|
00131 0f 10 48 f0 movups xmm1, XMMWORD PTR [rax-16]
|
|
00135 0f 11 41 e0 movups XMMWORD PTR [rcx-32], xmm0
|
|
00139 0f 11 49 f0 movups XMMWORD PTR [rcx-16], xmm1
|
|
0013d 48 83 ea 01 sub rdx, 1
|
|
00141 75 ad jne SHORT $LL15@glfwCreate
|
|
00143 0f 10 00 movups xmm0, XMMWORD PTR [rax]
|
|
|
|
; 210 :
|
|
; 211 : wndconfig.width = width;
|
|
; 212 : wndconfig.height = height;
|
|
; 213 : wndconfig.title = title;
|
|
; 214 : ctxconfig.share = (_GLFWwindow*) share;
|
|
|
|
00146 4c 89 54 24 48 mov QWORD PTR ctxconfig$[rsp+40], r10
|
|
0014b 0f 10 48 10 movups xmm1, XMMWORD PTR [rax+16]
|
|
0014f 0f 11 01 movups XMMWORD PTR [rcx], xmm0
|
|
00152 0f 10 40 20 movups xmm0, XMMWORD PTR [rax+32]
|
|
00156 0f 11 49 10 movups XMMWORD PTR [rcx+16], xmm1
|
|
0015a 0f 10 48 30 movups xmm1, XMMWORD PTR [rax+48]
|
|
0015e 0f 11 41 20 movups XMMWORD PTR [rcx+32], xmm0
|
|
00162 0f 10 40 40 movups xmm0, XMMWORD PTR [rax+64]
|
|
00166 0f 11 49 30 movups XMMWORD PTR [rcx+48], xmm1
|
|
0016a 0f 11 41 40 movups XMMWORD PTR [rcx+64], xmm0
|
|
|
|
; 215 :
|
|
; 216 : if (!_glfwIsValidContextConfig(&ctxconfig))
|
|
|
|
0016e 48 8d 4c 24 20 lea rcx, QWORD PTR ctxconfig$[rsp]
|
|
00173 89 7c 24 68 mov DWORD PTR wndconfig$[rsp+8], edi
|
|
00177 89 74 24 6c mov DWORD PTR wndconfig$[rsp+12], esi
|
|
0017b 4c 89 44 24 70 mov QWORD PTR wndconfig$[rsp+16], r8
|
|
00180 e8 00 00 00 00 call _glfwIsValidContextConfig
|
|
00185 85 c0 test eax, eax
|
|
00187 0f 84 bc fe ff
|
|
ff je $LN24@glfwCreate
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\init.c
|
|
|
|
; 283 : block = _glfw.allocator.allocate(count * size, _glfw.allocator.user);
|
|
|
|
0018d 48 8b 15 20 00
|
|
00 00 mov rdx, QWORD PTR _glfw+32
|
|
00194 b9 d8 03 00 00 mov ecx, 984 ; 000003d8H
|
|
00199 48 89 9c 24 10
|
|
05 00 00 mov QWORD PTR [rsp+1296], rbx
|
|
001a1 ff 15 08 00 00
|
|
00 call QWORD PTR _glfw+8
|
|
|
|
; 284 : if (block)
|
|
|
|
001a7 48 85 c0 test rax, rax
|
|
001aa 74 15 je SHORT $LN12@glfwCreate
|
|
|
|
; 285 : return memset(block, 0, count * size);
|
|
|
|
001ac 33 d2 xor edx, edx
|
|
001ae 41 b8 d8 03 00
|
|
00 mov r8d, 984 ; 000003d8H
|
|
001b4 48 8b c8 mov rcx, rax
|
|
001b7 e8 00 00 00 00 call memset
|
|
001bc 48 8b d8 mov rbx, rax
|
|
001bf eb 0e jmp SHORT $LN10@glfwCreate
|
|
$LN12@glfwCreate:
|
|
|
|
; 286 : else
|
|
; 287 : {
|
|
; 288 : _glfwInputError(GLFW_OUT_OF_MEMORY, NULL);
|
|
|
|
001c1 33 d2 xor edx, edx
|
|
001c3 b9 05 00 01 00 mov ecx, 65541 ; 00010005H
|
|
001c8 e8 00 00 00 00 call _glfwInputError
|
|
|
|
; 289 : return NULL;
|
|
|
|
001cd 33 db xor ebx, ebx
|
|
$LN10@glfwCreate:
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
|
|
; 220 : window->next = _glfw.windowListHead;
|
|
|
|
001cf 48 8b 05 78 07
|
|
00 00 mov rax, QWORD PTR _glfw+1912
|
|
|
|
; 221 : _glfw.windowListHead = window;
|
|
; 222 :
|
|
; 223 : window->videoMode.width = width;
|
|
; 224 : window->videoMode.height = height;
|
|
; 225 : window->videoMode.redBits = fbconfig.redBits;
|
|
; 226 : window->videoMode.greenBits = fbconfig.greenBits;
|
|
; 227 : window->videoMode.blueBits = fbconfig.blueBits;
|
|
; 228 : window->videoMode.refreshRate = _glfw.hints.refreshRate;
|
|
; 229 :
|
|
; 230 : window->monitor = (_GLFWmonitor*) monitor;
|
|
; 231 : window->resizable = wndconfig.resizable;
|
|
; 232 : window->decorated = wndconfig.decorated;
|
|
; 233 : window->autoIconify = wndconfig.autoIconify;
|
|
; 234 : window->floating = wndconfig.floating;
|
|
; 235 : window->focusOnShow = wndconfig.focusOnShow;
|
|
; 236 : window->mousePassthrough = wndconfig.mousePassthrough;
|
|
; 237 : window->cursorMode = GLFW_CURSOR_NORMAL;
|
|
; 238 :
|
|
; 239 : window->doublebuffer = fbconfig.doublebuffer;
|
|
; 240 :
|
|
; 241 : window->minwidth = GLFW_DONT_CARE;
|
|
; 242 : window->minheight = GLFW_DONT_CARE;
|
|
; 243 : window->maxwidth = GLFW_DONT_CARE;
|
|
; 244 : window->maxheight = GLFW_DONT_CARE;
|
|
; 245 : window->numer = GLFW_DONT_CARE;
|
|
; 246 : window->denom = GLFW_DONT_CARE;
|
|
; 247 :
|
|
; 248 : if (!_glfw.platform.createWindow(window, &wndconfig, &ctxconfig, &fbconfig))
|
|
|
|
001d6 4c 8d 8d b0 03
|
|
00 00 lea r9, QWORD PTR fbconfig$[rbp-256]
|
|
001dd 48 89 03 mov QWORD PTR [rbx], rax
|
|
001e0 4c 8d 44 24 20 lea r8, QWORD PTR ctxconfig$[rsp]
|
|
001e5 48 89 1d 78 07
|
|
00 00 mov QWORD PTR _glfw+1912, rbx
|
|
001ec 48 8d 54 24 60 lea rdx, QWORD PTR wndconfig$[rsp]
|
|
001f1 89 7b 34 mov DWORD PTR [rbx+52], edi
|
|
001f4 48 8b cb mov rcx, rbx
|
|
001f7 89 73 38 mov DWORD PTR [rbx+56], esi
|
|
001fa 8b 85 b0 03 00
|
|
00 mov eax, DWORD PTR fbconfig$[rbp-256]
|
|
00200 89 43 3c mov DWORD PTR [rbx+60], eax
|
|
00203 8b 85 b4 03 00
|
|
00 mov eax, DWORD PTR fbconfig$[rbp-252]
|
|
00209 89 43 40 mov DWORD PTR [rbx+64], eax
|
|
0020c 8b 85 b8 03 00
|
|
00 mov eax, DWORD PTR fbconfig$[rbp-248]
|
|
00212 89 43 44 mov DWORD PTR [rbx+68], eax
|
|
00215 8b 05 60 07 00
|
|
00 mov eax, DWORD PTR _glfw+1888
|
|
0021b 89 43 48 mov DWORD PTR [rbx+72], eax
|
|
0021e 4c 89 73 50 mov QWORD PTR [rbx+80], r14
|
|
00222 8b 44 24 78 mov eax, DWORD PTR wndconfig$[rsp+24]
|
|
00226 89 43 08 mov DWORD PTR [rbx+8], eax
|
|
00229 8b 45 80 mov eax, DWORD PTR wndconfig$[rbp-224]
|
|
0022c 89 43 0c mov DWORD PTR [rbx+12], eax
|
|
0022f 8b 45 88 mov eax, DWORD PTR wndconfig$[rbp-216]
|
|
00232 89 43 10 mov DWORD PTR [rbx+16], eax
|
|
00235 8b 45 8c mov eax, DWORD PTR wndconfig$[rbp-212]
|
|
00238 89 43 14 mov DWORD PTR [rbx+20], eax
|
|
0023b 8b 45 98 mov eax, DWORD PTR wndconfig$[rbp-200]
|
|
0023e 89 43 18 mov DWORD PTR [rbx+24], eax
|
|
00241 8b 45 9c mov eax, DWORD PTR wndconfig$[rbp-196]
|
|
00244 89 43 1c mov DWORD PTR [rbx+28], eax
|
|
00247 c7 83 84 00 00
|
|
00 01 40 03 00 mov DWORD PTR [rbx+132], 212993 ; 00034001H
|
|
00251 8b 85 e8 03 00
|
|
00 mov eax, DWORD PTR fbconfig$[rbp-200]
|
|
00257 89 43 30 mov DWORD PTR [rbx+48], eax
|
|
0025a 48 c7 43 60 ff
|
|
ff ff ff mov QWORD PTR [rbx+96], -1
|
|
00262 48 c7 43 68 ff
|
|
ff ff ff mov QWORD PTR [rbx+104], -1
|
|
0026a 48 c7 43 70 ff
|
|
ff ff ff mov QWORD PTR [rbx+112], -1
|
|
00272 ff 15 10 01 00
|
|
00 call QWORD PTR _glfw+272
|
|
00278 85 c0 test eax, eax
|
|
0027a 75 2e jne SHORT $LN6@glfwCreate
|
|
|
|
; 249 : {
|
|
; 250 : glfwDestroyWindow((GLFWwindow*) window);
|
|
|
|
0027c 48 8b cb mov rcx, rbx
|
|
0027f e8 00 00 00 00 call glfwDestroyWindow
|
|
|
|
; 251 : return NULL;
|
|
|
|
00284 33 c0 xor eax, eax
|
|
$LN23@glfwCreate:
|
|
00286 48 8b 9c 24 10
|
|
05 00 00 mov rbx, QWORD PTR [rsp+1296]
|
|
$LN1@glfwCreate:
|
|
|
|
; 255 : }
|
|
|
|
0028e 48 8b 8d 00 04
|
|
00 00 mov rcx, QWORD PTR __$ArrayPad$[rbp-256]
|
|
00295 48 33 cc xor rcx, rsp
|
|
00298 e8 00 00 00 00 call __security_check_cookie
|
|
0029d 48 81 c4 18 05
|
|
00 00 add rsp, 1304 ; 00000518H
|
|
002a4 41 5e pop r14
|
|
002a6 5f pop rdi
|
|
002a7 5e pop rsi
|
|
002a8 5d pop rbp
|
|
002a9 c3 ret 0
|
|
$LN6@glfwCreate:
|
|
|
|
; 252 : }
|
|
; 253 :
|
|
; 254 : return (GLFWwindow*) window;
|
|
|
|
002aa 48 8b c3 mov rax, rbx
|
|
002ad eb d7 jmp SHORT $LN23@glfwCreate
|
|
$LN4@glfwCreate:
|
|
|
|
; 199 : {
|
|
; 200 : _glfwInputError(GLFW_INVALID_VALUE,
|
|
|
|
002af 44 8b ce mov r9d, esi
|
|
002b2 48 8d 15 00 00
|
|
00 00 lea rdx, OFFSET FLAT:??_C@_0BK@KJGCMOHN@Invalid?5window?5size?5?$CFix?$CFi@
|
|
002b9 44 8b c7 mov r8d, edi
|
|
002bc b9 04 00 01 00 mov ecx, 65540 ; 00010004H
|
|
002c1 e8 00 00 00 00 call _glfwInputError
|
|
|
|
; 201 : "Invalid window size %ix%i",
|
|
; 202 : width, height);
|
|
; 203 :
|
|
; 204 : return NULL;
|
|
|
|
002c6 33 c0 xor eax, eax
|
|
002c8 eb c4 jmp SHORT $LN1@glfwCreate
|
|
glfwCreateWindow ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwWindowHint
|
|
_TEXT SEGMENT
|
|
hint$ = 8
|
|
value$ = 16
|
|
glfwWindowHint PROC ; COMDAT
|
|
|
|
; 300 : _GLFW_REQUIRE_INIT();
|
|
|
|
00000 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
00007 75 0c jne SHORT $LN4@glfwWindow
|
|
00009 33 d2 xor edx, edx
|
|
0000b b9 01 00 01 00 mov ecx, 65537 ; 00010001H
|
|
00010 e9 00 00 00 00 jmp _glfwInputError
|
|
$LN4@glfwWindow:
|
|
|
|
; 301 :
|
|
; 302 : switch (hint)
|
|
|
|
00015 81 f9 01 10 02
|
|
00 cmp ecx, 135169 ; 00021001H
|
|
0001b 0f 8f da 00 00
|
|
00 jg $LN49@glfwWindow
|
|
00021 0f 84 cd 00 00
|
|
00 je $LN5@glfwWindow
|
|
00027 8d 81 ff ff fd
|
|
ff lea eax, DWORD PTR [rcx-131073]
|
|
0002d 83 f8 0e cmp eax, 14
|
|
00030 0f 87 38 02 00
|
|
00 ja $LN2@glfwWindow
|
|
00036 48 98 cdqe
|
|
00038 4c 8d 05 00 00
|
|
00 00 lea r8, OFFSET FLAT:__ImageBase
|
|
0003f 41 8b 84 80 00
|
|
00 00 00 mov eax, DWORD PTR $LN54@glfwWindow[r8+rax*4]
|
|
00047 49 03 c0 add rax, r8
|
|
0004a ff e0 jmp rax
|
|
$LN18@glfwWindow:
|
|
|
|
; 342 : return;
|
|
; 343 : case GLFW_TRANSPARENT_FRAMEBUFFER:
|
|
; 344 : _glfw.hints.framebuffer.transparent = value ? GLFW_TRUE : GLFW_FALSE;
|
|
|
|
0004c 33 c0 xor eax, eax
|
|
0004e 85 d2 test edx, edx
|
|
00050 0f 95 c0 setne al
|
|
00053 89 05 cc 02 00
|
|
00 mov DWORD PTR _glfw+716, eax
|
|
|
|
; 436 : }
|
|
|
|
00059 c3 ret 0
|
|
$LN21@glfwWindow:
|
|
|
|
; 351 : return;
|
|
; 352 : case GLFW_RESIZABLE:
|
|
; 353 : _glfw.hints.window.resizable = value ? GLFW_TRUE : GLFW_FALSE;
|
|
|
|
0005a 33 c0 xor eax, eax
|
|
0005c 85 d2 test edx, edx
|
|
0005e 0f 95 c0 setne al
|
|
00061 89 05 f0 02 00
|
|
00 mov DWORD PTR _glfw+752, eax
|
|
|
|
; 436 : }
|
|
|
|
00067 c3 ret 0
|
|
$LN22@glfwWindow:
|
|
|
|
; 354 : return;
|
|
; 355 : case GLFW_DECORATED:
|
|
; 356 : _glfw.hints.window.decorated = value ? GLFW_TRUE : GLFW_FALSE;
|
|
|
|
00068 33 c0 xor eax, eax
|
|
0006a 85 d2 test edx, edx
|
|
0006c 0f 95 c0 setne al
|
|
0006f 89 05 f8 02 00
|
|
00 mov DWORD PTR _glfw+760, eax
|
|
|
|
; 436 : }
|
|
|
|
00075 c3 ret 0
|
|
$LN23@glfwWindow:
|
|
|
|
; 357 : return;
|
|
; 358 : case GLFW_FOCUSED:
|
|
; 359 : _glfw.hints.window.focused = value ? GLFW_TRUE : GLFW_FALSE;
|
|
|
|
00076 33 c0 xor eax, eax
|
|
00078 85 d2 test edx, edx
|
|
0007a 0f 95 c0 setne al
|
|
0007d 89 05 fc 02 00
|
|
00 mov DWORD PTR _glfw+764, eax
|
|
|
|
; 436 : }
|
|
|
|
00083 c3 ret 0
|
|
$LN24@glfwWindow:
|
|
|
|
; 360 : return;
|
|
; 361 : case GLFW_AUTO_ICONIFY:
|
|
; 362 : _glfw.hints.window.autoIconify = value ? GLFW_TRUE : GLFW_FALSE;
|
|
|
|
00084 33 c0 xor eax, eax
|
|
00086 85 d2 test edx, edx
|
|
00088 0f 95 c0 setne al
|
|
0008b 89 05 00 03 00
|
|
00 mov DWORD PTR _glfw+768, eax
|
|
|
|
; 436 : }
|
|
|
|
00091 c3 ret 0
|
|
$LN25@glfwWindow:
|
|
|
|
; 363 : return;
|
|
; 364 : case GLFW_FLOATING:
|
|
; 365 : _glfw.hints.window.floating = value ? GLFW_TRUE : GLFW_FALSE;
|
|
|
|
00092 33 c0 xor eax, eax
|
|
00094 85 d2 test edx, edx
|
|
00096 0f 95 c0 setne al
|
|
00099 89 05 04 03 00
|
|
00 mov DWORD PTR _glfw+772, eax
|
|
|
|
; 436 : }
|
|
|
|
0009f c3 ret 0
|
|
$LN26@glfwWindow:
|
|
|
|
; 366 : return;
|
|
; 367 : case GLFW_MAXIMIZED:
|
|
; 368 : _glfw.hints.window.maximized = value ? GLFW_TRUE : GLFW_FALSE;
|
|
|
|
000a0 33 c0 xor eax, eax
|
|
000a2 85 d2 test edx, edx
|
|
000a4 0f 95 c0 setne al
|
|
000a7 89 05 08 03 00
|
|
00 mov DWORD PTR _glfw+776, eax
|
|
|
|
; 436 : }
|
|
|
|
000ad c3 ret 0
|
|
$LN27@glfwWindow:
|
|
|
|
; 369 : return;
|
|
; 370 : case GLFW_VISIBLE:
|
|
; 371 : _glfw.hints.window.visible = value ? GLFW_TRUE : GLFW_FALSE;
|
|
|
|
000ae 33 c0 xor eax, eax
|
|
000b0 85 d2 test edx, edx
|
|
000b2 0f 95 c0 setne al
|
|
000b5 89 05 f4 02 00
|
|
00 mov DWORD PTR _glfw+756, eax
|
|
|
|
; 436 : }
|
|
|
|
000bb c3 ret 0
|
|
$LN28@glfwWindow:
|
|
|
|
; 372 : return;
|
|
; 373 : case GLFW_POSITION_X:
|
|
; 374 : _glfw.hints.window.xpos = value;
|
|
|
|
000bc 89 15 d8 02 00
|
|
00 mov DWORD PTR _glfw+728, edx
|
|
|
|
; 436 : }
|
|
|
|
000c2 c3 ret 0
|
|
$LN29@glfwWindow:
|
|
|
|
; 375 : return;
|
|
; 376 : case GLFW_POSITION_Y:
|
|
; 377 : _glfw.hints.window.ypos = value;
|
|
|
|
000c3 89 15 dc 02 00
|
|
00 mov DWORD PTR _glfw+732, edx
|
|
|
|
; 436 : }
|
|
|
|
000c9 c3 ret 0
|
|
$LN34@glfwWindow:
|
|
|
|
; 390 : return;
|
|
; 391 : case GLFW_CENTER_CURSOR:
|
|
; 392 : _glfw.hints.window.centerCursor = value ? GLFW_TRUE : GLFW_FALSE;
|
|
|
|
000ca 33 c0 xor eax, eax
|
|
000cc 85 d2 test edx, edx
|
|
000ce 0f 95 c0 setne al
|
|
000d1 89 05 0c 03 00
|
|
00 mov DWORD PTR _glfw+780, eax
|
|
|
|
; 436 : }
|
|
|
|
000d7 c3 ret 0
|
|
$LN35@glfwWindow:
|
|
|
|
; 393 : return;
|
|
; 394 : case GLFW_FOCUS_ON_SHOW:
|
|
; 395 : _glfw.hints.window.focusOnShow = value ? GLFW_TRUE : GLFW_FALSE;
|
|
|
|
000d8 33 c0 xor eax, eax
|
|
000da 85 d2 test edx, edx
|
|
000dc 0f 95 c0 setne al
|
|
000df 89 05 10 03 00
|
|
00 mov DWORD PTR _glfw+784, eax
|
|
|
|
; 436 : }
|
|
|
|
000e5 c3 ret 0
|
|
$LN36@glfwWindow:
|
|
|
|
; 396 : return;
|
|
; 397 : case GLFW_MOUSE_PASSTHROUGH:
|
|
; 398 : _glfw.hints.window.mousePassthrough = value ? GLFW_TRUE : GLFW_FALSE;
|
|
|
|
000e6 33 c0 xor eax, eax
|
|
000e8 85 d2 test edx, edx
|
|
000ea 0f 95 c0 setne al
|
|
000ed 89 05 14 03 00
|
|
00 mov DWORD PTR _glfw+788, eax
|
|
|
|
; 436 : }
|
|
|
|
000f3 c3 ret 0
|
|
$LN5@glfwWindow:
|
|
|
|
; 303 : {
|
|
; 304 : case GLFW_RED_BITS:
|
|
; 305 : _glfw.hints.framebuffer.redBits = value;
|
|
|
|
000f4 89 15 90 02 00
|
|
00 mov DWORD PTR _glfw+656, edx
|
|
|
|
; 436 : }
|
|
|
|
000fa c3 ret 0
|
|
$LN49@glfwWindow:
|
|
|
|
; 301 :
|
|
; 302 : switch (hint)
|
|
|
|
000fb 81 f9 01 20 02
|
|
00 cmp ecx, 139265 ; 00022001H
|
|
00101 0f 8f b0 00 00
|
|
00 jg $LN50@glfwWindow
|
|
00107 0f 84 a3 00 00
|
|
00 je $LN37@glfwWindow
|
|
0010d 8d 81 fe ef fd
|
|
ff lea eax, DWORD PTR [rcx-135170]
|
|
00113 83 f8 0e cmp eax, 14
|
|
00116 0f 87 52 01 00
|
|
00 ja $LN2@glfwWindow
|
|
0011c 48 98 cdqe
|
|
0011e 4c 8d 05 00 00
|
|
00 00 lea r8, OFFSET FLAT:__ImageBase
|
|
00125 41 8b 84 80 00
|
|
00 00 00 mov eax, DWORD PTR $LN53@glfwWindow[r8+rax*4]
|
|
0012d 49 03 c0 add rax, r8
|
|
00130 ff e0 jmp rax
|
|
$LN6@glfwWindow:
|
|
|
|
; 306 : return;
|
|
; 307 : case GLFW_GREEN_BITS:
|
|
; 308 : _glfw.hints.framebuffer.greenBits = value;
|
|
|
|
00132 89 15 94 02 00
|
|
00 mov DWORD PTR _glfw+660, edx
|
|
|
|
; 436 : }
|
|
|
|
00138 c3 ret 0
|
|
$LN7@glfwWindow:
|
|
|
|
; 309 : return;
|
|
; 310 : case GLFW_BLUE_BITS:
|
|
; 311 : _glfw.hints.framebuffer.blueBits = value;
|
|
|
|
00139 89 15 98 02 00
|
|
00 mov DWORD PTR _glfw+664, edx
|
|
|
|
; 436 : }
|
|
|
|
0013f c3 ret 0
|
|
$LN8@glfwWindow:
|
|
|
|
; 312 : return;
|
|
; 313 : case GLFW_ALPHA_BITS:
|
|
; 314 : _glfw.hints.framebuffer.alphaBits = value;
|
|
|
|
00140 89 15 9c 02 00
|
|
00 mov DWORD PTR _glfw+668, edx
|
|
|
|
; 436 : }
|
|
|
|
00146 c3 ret 0
|
|
$LN9@glfwWindow:
|
|
|
|
; 315 : return;
|
|
; 316 : case GLFW_DEPTH_BITS:
|
|
; 317 : _glfw.hints.framebuffer.depthBits = value;
|
|
|
|
00147 89 15 a0 02 00
|
|
00 mov DWORD PTR _glfw+672, edx
|
|
|
|
; 436 : }
|
|
|
|
0014d c3 ret 0
|
|
$LN10@glfwWindow:
|
|
|
|
; 318 : return;
|
|
; 319 : case GLFW_STENCIL_BITS:
|
|
; 320 : _glfw.hints.framebuffer.stencilBits = value;
|
|
|
|
0014e 89 15 a4 02 00
|
|
00 mov DWORD PTR _glfw+676, edx
|
|
|
|
; 436 : }
|
|
|
|
00154 c3 ret 0
|
|
$LN11@glfwWindow:
|
|
|
|
; 321 : return;
|
|
; 322 : case GLFW_ACCUM_RED_BITS:
|
|
; 323 : _glfw.hints.framebuffer.accumRedBits = value;
|
|
|
|
00155 89 15 a8 02 00
|
|
00 mov DWORD PTR _glfw+680, edx
|
|
|
|
; 436 : }
|
|
|
|
0015b c3 ret 0
|
|
$LN12@glfwWindow:
|
|
|
|
; 324 : return;
|
|
; 325 : case GLFW_ACCUM_GREEN_BITS:
|
|
; 326 : _glfw.hints.framebuffer.accumGreenBits = value;
|
|
|
|
0015c 89 15 ac 02 00
|
|
00 mov DWORD PTR _glfw+684, edx
|
|
|
|
; 436 : }
|
|
|
|
00162 c3 ret 0
|
|
$LN13@glfwWindow:
|
|
|
|
; 327 : return;
|
|
; 328 : case GLFW_ACCUM_BLUE_BITS:
|
|
; 329 : _glfw.hints.framebuffer.accumBlueBits = value;
|
|
|
|
00163 89 15 b0 02 00
|
|
00 mov DWORD PTR _glfw+688, edx
|
|
|
|
; 436 : }
|
|
|
|
00169 c3 ret 0
|
|
$LN14@glfwWindow:
|
|
|
|
; 330 : return;
|
|
; 331 : case GLFW_ACCUM_ALPHA_BITS:
|
|
; 332 : _glfw.hints.framebuffer.accumAlphaBits = value;
|
|
|
|
0016a 89 15 b4 02 00
|
|
00 mov DWORD PTR _glfw+692, edx
|
|
|
|
; 436 : }
|
|
|
|
00170 c3 ret 0
|
|
$LN15@glfwWindow:
|
|
|
|
; 333 : return;
|
|
; 334 : case GLFW_AUX_BUFFERS:
|
|
; 335 : _glfw.hints.framebuffer.auxBuffers = value;
|
|
|
|
00171 89 15 b8 02 00
|
|
00 mov DWORD PTR _glfw+696, edx
|
|
|
|
; 436 : }
|
|
|
|
00177 c3 ret 0
|
|
$LN16@glfwWindow:
|
|
|
|
; 336 : return;
|
|
; 337 : case GLFW_STEREO:
|
|
; 338 : _glfw.hints.framebuffer.stereo = value ? GLFW_TRUE : GLFW_FALSE;
|
|
|
|
00178 33 c0 xor eax, eax
|
|
0017a 85 d2 test edx, edx
|
|
0017c 0f 95 c0 setne al
|
|
0017f 89 05 bc 02 00
|
|
00 mov DWORD PTR _glfw+700, eax
|
|
|
|
; 436 : }
|
|
|
|
00185 c3 ret 0
|
|
$LN17@glfwWindow:
|
|
|
|
; 339 : return;
|
|
; 340 : case GLFW_DOUBLEBUFFER:
|
|
; 341 : _glfw.hints.framebuffer.doublebuffer = value ? GLFW_TRUE : GLFW_FALSE;
|
|
|
|
00186 33 c0 xor eax, eax
|
|
00188 85 d2 test edx, edx
|
|
0018a 0f 95 c0 setne al
|
|
0018d 89 05 c8 02 00
|
|
00 mov DWORD PTR _glfw+712, eax
|
|
|
|
; 436 : }
|
|
|
|
00193 c3 ret 0
|
|
$LN19@glfwWindow:
|
|
|
|
; 345 : return;
|
|
; 346 : case GLFW_SAMPLES:
|
|
; 347 : _glfw.hints.framebuffer.samples = value;
|
|
|
|
00194 89 15 c0 02 00
|
|
00 mov DWORD PTR _glfw+704, edx
|
|
|
|
; 436 : }
|
|
|
|
0019a c3 ret 0
|
|
$LN20@glfwWindow:
|
|
|
|
; 348 : return;
|
|
; 349 : case GLFW_SRGB_CAPABLE:
|
|
; 350 : _glfw.hints.framebuffer.sRGB = value ? GLFW_TRUE : GLFW_FALSE;
|
|
|
|
0019b 33 c0 xor eax, eax
|
|
0019d 85 d2 test edx, edx
|
|
0019f 0f 95 c0 setne al
|
|
001a2 89 05 c4 02 00
|
|
00 mov DWORD PTR _glfw+708, eax
|
|
|
|
; 436 : }
|
|
|
|
001a8 c3 ret 0
|
|
$LN47@glfwWindow:
|
|
|
|
; 429 : return;
|
|
; 430 : case GLFW_REFRESH_RATE:
|
|
; 431 : _glfw.hints.refreshRate = value;
|
|
|
|
001a9 89 15 60 07 00
|
|
00 mov DWORD PTR _glfw+1888, edx
|
|
|
|
; 436 : }
|
|
|
|
001af c3 ret 0
|
|
$LN37@glfwWindow:
|
|
|
|
; 399 : return;
|
|
; 400 : case GLFW_CLIENT_API:
|
|
; 401 : _glfw.hints.context.client = value;
|
|
|
|
001b0 89 15 28 07 00
|
|
00 mov DWORD PTR _glfw+1832, edx
|
|
|
|
; 436 : }
|
|
|
|
001b6 c3 ret 0
|
|
$LN50@glfwWindow:
|
|
|
|
; 301 :
|
|
; 302 : switch (hint)
|
|
|
|
001b7 81 f9 01 30 02
|
|
00 cmp ecx, 143361 ; 00023001H
|
|
001bd 0f 8f 9b 00 00
|
|
00 jg $LN51@glfwWindow
|
|
001c3 0f 84 87 00 00
|
|
00 je $LN30@glfwWindow
|
|
001c9 8d 81 fe df fd
|
|
ff lea eax, DWORD PTR [rcx-139266]
|
|
001cf 83 f8 0a cmp eax, 10
|
|
001d2 0f 87 96 00 00
|
|
00 ja $LN2@glfwWindow
|
|
001d8 48 98 cdqe
|
|
001da 4c 8d 05 00 00
|
|
00 00 lea r8, OFFSET FLAT:__ImageBase
|
|
001e1 41 8b 84 80 00
|
|
00 00 00 mov eax, DWORD PTR $LN52@glfwWindow[r8+rax*4]
|
|
001e9 49 03 c0 add rax, r8
|
|
001ec ff e0 jmp rax
|
|
$LN33@glfwWindow:
|
|
|
|
; 387 : return;
|
|
; 388 : case GLFW_SCALE_TO_MONITOR:
|
|
; 389 : _glfw.hints.window.scaleToMonitor = value ? GLFW_TRUE : GLFW_FALSE;
|
|
|
|
001ee 33 c0 xor eax, eax
|
|
001f0 85 d2 test edx, edx
|
|
001f2 0f 95 c0 setne al
|
|
001f5 89 05 18 03 00
|
|
00 mov DWORD PTR _glfw+792, eax
|
|
|
|
; 436 : }
|
|
|
|
001fb c3 ret 0
|
|
$LN38@glfwWindow:
|
|
|
|
; 402 : return;
|
|
; 403 : case GLFW_CONTEXT_CREATION_API:
|
|
; 404 : _glfw.hints.context.source = value;
|
|
|
|
001fc 89 15 2c 07 00
|
|
00 mov DWORD PTR _glfw+1836, edx
|
|
|
|
; 436 : }
|
|
|
|
00202 c3 ret 0
|
|
$LN39@glfwWindow:
|
|
|
|
; 405 : return;
|
|
; 406 : case GLFW_CONTEXT_VERSION_MAJOR:
|
|
; 407 : _glfw.hints.context.major = value;
|
|
|
|
00203 89 15 30 07 00
|
|
00 mov DWORD PTR _glfw+1840, edx
|
|
|
|
; 436 : }
|
|
|
|
00209 c3 ret 0
|
|
$LN40@glfwWindow:
|
|
|
|
; 408 : return;
|
|
; 409 : case GLFW_CONTEXT_VERSION_MINOR:
|
|
; 410 : _glfw.hints.context.minor = value;
|
|
|
|
0020a 89 15 34 07 00
|
|
00 mov DWORD PTR _glfw+1844, edx
|
|
|
|
; 436 : }
|
|
|
|
00210 c3 ret 0
|
|
$LN41@glfwWindow:
|
|
|
|
; 411 : return;
|
|
; 412 : case GLFW_CONTEXT_ROBUSTNESS:
|
|
; 413 : _glfw.hints.context.robustness = value;
|
|
|
|
00211 89 15 48 07 00
|
|
00 mov DWORD PTR _glfw+1864, edx
|
|
|
|
; 436 : }
|
|
|
|
00217 c3 ret 0
|
|
$LN42@glfwWindow:
|
|
|
|
; 414 : return;
|
|
; 415 : case GLFW_OPENGL_FORWARD_COMPAT:
|
|
; 416 : _glfw.hints.context.forward = value ? GLFW_TRUE : GLFW_FALSE;
|
|
|
|
00218 33 c0 xor eax, eax
|
|
0021a 85 d2 test edx, edx
|
|
0021c 0f 95 c0 setne al
|
|
0021f 89 05 38 07 00
|
|
00 mov DWORD PTR _glfw+1848, eax
|
|
|
|
; 436 : }
|
|
|
|
00225 c3 ret 0
|
|
$LN43@glfwWindow:
|
|
|
|
; 417 : return;
|
|
; 418 : case GLFW_CONTEXT_DEBUG:
|
|
; 419 : _glfw.hints.context.debug = value ? GLFW_TRUE : GLFW_FALSE;
|
|
|
|
00226 33 c0 xor eax, eax
|
|
00228 85 d2 test edx, edx
|
|
0022a 0f 95 c0 setne al
|
|
0022d 89 05 3c 07 00
|
|
00 mov DWORD PTR _glfw+1852, eax
|
|
|
|
; 436 : }
|
|
|
|
00233 c3 ret 0
|
|
$LN44@glfwWindow:
|
|
|
|
; 420 : return;
|
|
; 421 : case GLFW_CONTEXT_NO_ERROR:
|
|
; 422 : _glfw.hints.context.noerror = value ? GLFW_TRUE : GLFW_FALSE;
|
|
|
|
00234 33 c0 xor eax, eax
|
|
00236 85 d2 test edx, edx
|
|
00238 0f 95 c0 setne al
|
|
0023b 89 05 40 07 00
|
|
00 mov DWORD PTR _glfw+1856, eax
|
|
|
|
; 436 : }
|
|
|
|
00241 c3 ret 0
|
|
$LN45@glfwWindow:
|
|
|
|
; 423 : return;
|
|
; 424 : case GLFW_OPENGL_PROFILE:
|
|
; 425 : _glfw.hints.context.profile = value;
|
|
|
|
00242 89 15 44 07 00
|
|
00 mov DWORD PTR _glfw+1860, edx
|
|
|
|
; 436 : }
|
|
|
|
00248 c3 ret 0
|
|
$LN46@glfwWindow:
|
|
|
|
; 426 : return;
|
|
; 427 : case GLFW_CONTEXT_RELEASE_BEHAVIOR:
|
|
; 428 : _glfw.hints.context.release = value;
|
|
|
|
00249 89 15 4c 07 00
|
|
00 mov DWORD PTR _glfw+1868, edx
|
|
|
|
; 436 : }
|
|
|
|
0024f c3 ret 0
|
|
$LN30@glfwWindow:
|
|
|
|
; 378 : return;
|
|
; 379 : case GLFW_COCOA_RETINA_FRAMEBUFFER:
|
|
; 380 : _glfw.hints.window.ns.retina = value ? GLFW_TRUE : GLFW_FALSE;
|
|
|
|
00250 33 c0 xor eax, eax
|
|
00252 85 d2 test edx, edx
|
|
00254 0f 95 c0 setne al
|
|
00257 89 05 1c 03 00
|
|
00 mov DWORD PTR _glfw+796, eax
|
|
|
|
; 436 : }
|
|
|
|
0025d c3 ret 0
|
|
$LN51@glfwWindow:
|
|
|
|
; 301 :
|
|
; 302 : switch (hint)
|
|
|
|
0025e 81 f9 03 30 02
|
|
00 cmp ecx, 143363 ; 00023003H
|
|
00264 74 2a je SHORT $LN32@glfwWindow
|
|
00266 81 f9 01 50 02
|
|
00 cmp ecx, 151553 ; 00025001H
|
|
0026c 74 14 je SHORT $LN31@glfwWindow
|
|
$LN2@glfwWindow:
|
|
|
|
; 432 : return;
|
|
; 433 : }
|
|
; 434 :
|
|
; 435 : _glfwInputError(GLFW_INVALID_ENUM, "Invalid window hint 0x%08X", hint);
|
|
|
|
0026e 44 8b c1 mov r8d, ecx
|
|
00271 48 8d 15 00 00
|
|
00 00 lea rdx, OFFSET FLAT:??_C@_0BL@IDFNAMEG@Invalid?5window?5hint?50x?$CF08X@
|
|
00278 b9 03 00 01 00 mov ecx, 65539 ; 00010003H
|
|
0027d e9 00 00 00 00 jmp _glfwInputError
|
|
$LN31@glfwWindow:
|
|
|
|
; 381 : return;
|
|
; 382 : case GLFW_WIN32_KEYBOARD_MENU:
|
|
; 383 : _glfw.hints.window.win32.keymenu = value ? GLFW_TRUE : GLFW_FALSE;
|
|
|
|
00282 33 c0 xor eax, eax
|
|
00284 85 d2 test edx, edx
|
|
00286 0f 95 c0 setne al
|
|
00289 89 05 20 06 00
|
|
00 mov DWORD PTR _glfw+1568, eax
|
|
|
|
; 436 : }
|
|
|
|
0028f c3 ret 0
|
|
$LN32@glfwWindow:
|
|
|
|
; 384 : return;
|
|
; 385 : case GLFW_COCOA_GRAPHICS_SWITCHING:
|
|
; 386 : _glfw.hints.context.nsgl.offline = value ? GLFW_TRUE : GLFW_FALSE;
|
|
|
|
00290 33 c0 xor eax, eax
|
|
00292 85 d2 test edx, edx
|
|
00294 0f 95 c0 setne al
|
|
00297 89 05 58 07 00
|
|
00 mov DWORD PTR _glfw+1880, eax
|
|
|
|
; 436 : }
|
|
|
|
0029d c3 ret 0
|
|
0029e 66 90 npad 2
|
|
$LN54@glfwWindow:
|
|
002a0 00 00 00 00 DD $LN23@glfwWindow
|
|
002a4 00 00 00 00 DD $LN2@glfwWindow
|
|
002a8 00 00 00 00 DD $LN21@glfwWindow
|
|
002ac 00 00 00 00 DD $LN27@glfwWindow
|
|
002b0 00 00 00 00 DD $LN22@glfwWindow
|
|
002b4 00 00 00 00 DD $LN24@glfwWindow
|
|
002b8 00 00 00 00 DD $LN25@glfwWindow
|
|
002bc 00 00 00 00 DD $LN26@glfwWindow
|
|
002c0 00 00 00 00 DD $LN34@glfwWindow
|
|
002c4 00 00 00 00 DD $LN18@glfwWindow
|
|
002c8 00 00 00 00 DD $LN2@glfwWindow
|
|
002cc 00 00 00 00 DD $LN35@glfwWindow
|
|
002d0 00 00 00 00 DD $LN36@glfwWindow
|
|
002d4 00 00 00 00 DD $LN28@glfwWindow
|
|
002d8 00 00 00 00 DD $LN29@glfwWindow
|
|
$LN53@glfwWindow:
|
|
002dc 00 00 00 00 DD $LN6@glfwWindow
|
|
002e0 00 00 00 00 DD $LN7@glfwWindow
|
|
002e4 00 00 00 00 DD $LN8@glfwWindow
|
|
002e8 00 00 00 00 DD $LN9@glfwWindow
|
|
002ec 00 00 00 00 DD $LN10@glfwWindow
|
|
002f0 00 00 00 00 DD $LN11@glfwWindow
|
|
002f4 00 00 00 00 DD $LN12@glfwWindow
|
|
002f8 00 00 00 00 DD $LN13@glfwWindow
|
|
002fc 00 00 00 00 DD $LN14@glfwWindow
|
|
00300 00 00 00 00 DD $LN15@glfwWindow
|
|
00304 00 00 00 00 DD $LN16@glfwWindow
|
|
00308 00 00 00 00 DD $LN19@glfwWindow
|
|
0030c 00 00 00 00 DD $LN20@glfwWindow
|
|
00310 00 00 00 00 DD $LN47@glfwWindow
|
|
00314 00 00 00 00 DD $LN17@glfwWindow
|
|
$LN52@glfwWindow:
|
|
00318 00 00 00 00 DD $LN39@glfwWindow
|
|
0031c 00 00 00 00 DD $LN40@glfwWindow
|
|
00320 00 00 00 00 DD $LN2@glfwWindow
|
|
00324 00 00 00 00 DD $LN41@glfwWindow
|
|
00328 00 00 00 00 DD $LN42@glfwWindow
|
|
0032c 00 00 00 00 DD $LN43@glfwWindow
|
|
00330 00 00 00 00 DD $LN45@glfwWindow
|
|
00334 00 00 00 00 DD $LN46@glfwWindow
|
|
00338 00 00 00 00 DD $LN44@glfwWindow
|
|
0033c 00 00 00 00 DD $LN38@glfwWindow
|
|
00340 00 00 00 00 DD $LN33@glfwWindow
|
|
glfwWindowHint ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwWindowHintString
|
|
_TEXT SEGMENT
|
|
hint$ = 8
|
|
value$ = 16
|
|
glfwWindowHintString PROC ; COMDAT
|
|
|
|
; 440 : assert(value != NULL);
|
|
; 441 :
|
|
; 442 : _GLFW_REQUIRE_INIT();
|
|
|
|
00000 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
00007 44 8b c1 mov r8d, ecx
|
|
0000a 75 0c jne SHORT $LN4@glfwWindow
|
|
0000c 33 d2 xor edx, edx
|
|
0000e b9 01 00 01 00 mov ecx, 65537 ; 00010001H
|
|
00013 e9 00 00 00 00 jmp _glfwInputError
|
|
$LN4@glfwWindow:
|
|
|
|
; 443 :
|
|
; 444 : switch (hint)
|
|
|
|
00018 81 e9 02 30 02
|
|
00 sub ecx, 143362 ; 00023002H
|
|
0001e 74 41 je SHORT $LN5@glfwWindow
|
|
00020 81 e9 ff 0f 00
|
|
00 sub ecx, 4095 ; 00000fffH
|
|
00026 74 30 je SHORT $LN6@glfwWindow
|
|
00028 83 e9 01 sub ecx, 1
|
|
0002b 74 22 je SHORT $LN7@glfwWindow
|
|
0002d 81 f9 ff 1f 00
|
|
00 cmp ecx, 8191 ; 00001fffH
|
|
00033 74 11 je SHORT $LN8@glfwWindow
|
|
|
|
; 462 : }
|
|
; 463 :
|
|
; 464 : _glfwInputError(GLFW_INVALID_ENUM, "Invalid window hint string 0x%08X", hint);
|
|
|
|
00035 48 8d 15 00 00
|
|
00 00 lea rdx, OFFSET FLAT:??_C@_0CC@NBPCCDGB@Invalid?5window?5hint?5string?50x?$CF0@
|
|
0003c b9 03 00 01 00 mov ecx, 65539 ; 00010003H
|
|
00041 e9 00 00 00 00 jmp _glfwInputError
|
|
$LN8@glfwWindow:
|
|
|
|
; 458 : case GLFW_WAYLAND_APP_ID:
|
|
; 459 : strncpy(_glfw.hints.window.wl.appId, value,
|
|
|
|
00046 48 8d 0d 24 06
|
|
00 00 lea rcx, OFFSET FLAT:_glfw+1572
|
|
|
|
; 460 : sizeof(_glfw.hints.window.wl.appId) - 1);
|
|
; 461 : return;
|
|
|
|
0004d eb 19 jmp SHORT $LN10@glfwWindow
|
|
$LN7@glfwWindow:
|
|
|
|
; 454 : case GLFW_X11_INSTANCE_NAME:
|
|
; 455 : strncpy(_glfw.hints.window.x11.instanceName, value,
|
|
|
|
0004f 48 8d 0d 20 05
|
|
00 00 lea rcx, OFFSET FLAT:_glfw+1312
|
|
|
|
; 456 : sizeof(_glfw.hints.window.x11.instanceName) - 1);
|
|
; 457 : return;
|
|
|
|
00056 eb 10 jmp SHORT $LN10@glfwWindow
|
|
$LN6@glfwWindow:
|
|
|
|
; 448 : sizeof(_glfw.hints.window.ns.frameName) - 1);
|
|
; 449 : return;
|
|
; 450 : case GLFW_X11_CLASS_NAME:
|
|
; 451 : strncpy(_glfw.hints.window.x11.className, value,
|
|
|
|
00058 48 8d 0d 20 04
|
|
00 00 lea rcx, OFFSET FLAT:_glfw+1056
|
|
|
|
; 452 : sizeof(_glfw.hints.window.x11.className) - 1);
|
|
; 453 : return;
|
|
|
|
0005f eb 07 jmp SHORT $LN10@glfwWindow
|
|
$LN5@glfwWindow:
|
|
|
|
; 445 : {
|
|
; 446 : case GLFW_COCOA_FRAME_NAME:
|
|
; 447 : strncpy(_glfw.hints.window.ns.frameName, value,
|
|
|
|
00061 48 8d 0d 20 03
|
|
00 00 lea rcx, OFFSET FLAT:_glfw+800
|
|
$LN10@glfwWindow:
|
|
|
|
; 465 : }
|
|
|
|
00068 41 b8 ff 00 00
|
|
00 mov r8d, 255 ; 000000ffH
|
|
0006e 48 ff 25 00 00
|
|
00 00 rex_jmp QWORD PTR __imp_strncpy
|
|
glfwWindowHintString ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwWindowShouldClose
|
|
_TEXT SEGMENT
|
|
handle$ = 48
|
|
glfwWindowShouldClose PROC ; COMDAT
|
|
|
|
; 501 : {
|
|
|
|
$LN5:
|
|
00000 48 83 ec 28 sub rsp, 40 ; 00000028H
|
|
|
|
; 502 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 503 : assert(window != NULL);
|
|
; 504 :
|
|
; 505 : _GLFW_REQUIRE_INIT_OR_RETURN(0);
|
|
|
|
00004 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
0000b 75 13 jne SHORT $LN2@glfwWindow
|
|
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
|
|
|
|
; 507 : }
|
|
|
|
0001b 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
0001f c3 ret 0
|
|
$LN2@glfwWindow:
|
|
|
|
; 506 : return window->shouldClose;
|
|
|
|
00020 8b 41 20 mov eax, DWORD PTR [rcx+32]
|
|
|
|
; 507 : }
|
|
|
|
00023 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
00027 c3 ret 0
|
|
glfwWindowShouldClose ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwSetWindowShouldClose
|
|
_TEXT SEGMENT
|
|
handle$ = 8
|
|
value$ = 16
|
|
glfwSetWindowShouldClose PROC ; COMDAT
|
|
|
|
; 511 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 512 : assert(window != NULL);
|
|
; 513 :
|
|
; 514 : _GLFW_REQUIRE_INIT();
|
|
|
|
00000 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
00007 75 0c jne SHORT $LN2@glfwSetWin
|
|
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@glfwSetWin:
|
|
|
|
; 515 : window->shouldClose = value;
|
|
|
|
00015 89 51 20 mov DWORD PTR [rcx+32], edx
|
|
|
|
; 516 : }
|
|
|
|
00018 c3 ret 0
|
|
glfwSetWindowShouldClose ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwSetWindowTitle
|
|
_TEXT SEGMENT
|
|
handle$ = 8
|
|
title$ = 16
|
|
glfwSetWindowTitle PROC ; COMDAT
|
|
|
|
; 520 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 521 : assert(window != NULL);
|
|
; 522 : assert(title != NULL);
|
|
; 523 :
|
|
; 524 : _GLFW_REQUIRE_INIT();
|
|
|
|
00000 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
00007 75 0c jne SHORT $LN2@glfwSetWin
|
|
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@glfwSetWin:
|
|
|
|
; 525 : _glfw.platform.setWindowTitle(window, title);
|
|
|
|
00015 48 ff 25 20 01
|
|
00 00 rex_jmp QWORD PTR _glfw+288
|
|
glfwSetWindowTitle ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwSetWindowIcon
|
|
_TEXT SEGMENT
|
|
handle$ = 8
|
|
count$ = 16
|
|
images$ = 24
|
|
glfwSetWindowIcon PROC ; COMDAT
|
|
|
|
; 531 : int i;
|
|
; 532 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 533 :
|
|
; 534 : assert(window != NULL);
|
|
; 535 : assert(count >= 0);
|
|
; 536 : assert(count == 0 || images != NULL);
|
|
; 537 :
|
|
; 538 : _GLFW_REQUIRE_INIT();
|
|
|
|
00000 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
00007 4c 8b d1 mov r10, rcx
|
|
0000a 4c 63 ca movsxd r9, edx
|
|
0000d 75 0c jne SHORT $LN5@glfwSetWin
|
|
0000f 33 d2 xor edx, edx
|
|
00011 b9 01 00 01 00 mov ecx, 65537 ; 00010001H
|
|
00016 e9 00 00 00 00 jmp _glfwInputError
|
|
$LN5@glfwSetWin:
|
|
|
|
; 539 :
|
|
; 540 : if (count < 0)
|
|
|
|
0001b 85 d2 test edx, edx
|
|
0001d 79 11 jns SHORT $LN15@glfwSetWin
|
|
|
|
; 541 : {
|
|
; 542 : _glfwInputError(GLFW_INVALID_VALUE, "Invalid image count for window icon");
|
|
|
|
0001f 48 8d 15 00 00
|
|
00 00 lea rdx, OFFSET FLAT:??_C@_0CE@MPCJCEEO@Invalid?5image?5count?5for?5window?5@
|
|
00026 b9 04 00 01 00 mov ecx, 65540 ; 00010004H
|
|
0002b e9 00 00 00 00 jmp _glfwInputError
|
|
$LN15@glfwSetWin:
|
|
|
|
; 543 : return;
|
|
; 544 : }
|
|
; 545 :
|
|
; 546 : for (i = 0; i < count; i++)
|
|
|
|
00030 74 1c je SHORT $LN3@glfwSetWin
|
|
00032 33 c9 xor ecx, ecx
|
|
00034 49 8b c0 mov rax, r8
|
|
$LL4@glfwSetWin:
|
|
|
|
; 547 : {
|
|
; 548 : assert(images[i].pixels != NULL);
|
|
; 549 :
|
|
; 550 : if (images[i].width <= 0 || images[i].height <= 0)
|
|
|
|
00037 83 38 00 cmp DWORD PTR [rax], 0
|
|
0003a 7e 1f jle SHORT $LN11@glfwSetWin
|
|
0003c 83 78 04 00 cmp DWORD PTR [rax+4], 0
|
|
00040 7e 19 jle SHORT $LN11@glfwSetWin
|
|
|
|
; 543 : return;
|
|
; 544 : }
|
|
; 545 :
|
|
; 546 : for (i = 0; i < count; i++)
|
|
|
|
00042 48 ff c1 inc rcx
|
|
00045 48 83 c0 10 add rax, 16
|
|
00049 49 3b c9 cmp rcx, r9
|
|
0004c 7c e9 jl SHORT $LL4@glfwSetWin
|
|
$LN3@glfwSetWin:
|
|
|
|
; 553 : "Invalid image dimensions for window icon");
|
|
; 554 : return;
|
|
; 555 : }
|
|
; 556 : }
|
|
; 557 :
|
|
; 558 : _glfw.platform.setWindowIcon(window, count, images);
|
|
|
|
0004e 41 8b d1 mov edx, r9d
|
|
00051 49 8b ca mov rcx, r10
|
|
00054 48 ff 25 28 01
|
|
00 00 rex_jmp QWORD PTR _glfw+296
|
|
$LN11@glfwSetWin:
|
|
|
|
; 551 : {
|
|
; 552 : _glfwInputError(GLFW_INVALID_VALUE,
|
|
|
|
0005b 48 8d 15 00 00
|
|
00 00 lea rdx, OFFSET FLAT:??_C@_0CJ@FFMMFAIL@Invalid?5image?5dimensions?5for?5wi@
|
|
00062 b9 04 00 01 00 mov ecx, 65540 ; 00010004H
|
|
00067 e9 00 00 00 00 jmp _glfwInputError
|
|
glfwSetWindowIcon ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwGetWindowPos
|
|
_TEXT SEGMENT
|
|
handle$ = 8
|
|
xpos$ = 16
|
|
ypos$ = 24
|
|
glfwGetWindowPos PROC ; COMDAT
|
|
|
|
; 563 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 564 : assert(window != NULL);
|
|
; 565 :
|
|
; 566 : if (xpos)
|
|
|
|
00000 33 c0 xor eax, eax
|
|
00002 48 85 d2 test rdx, rdx
|
|
00005 74 02 je SHORT $LN2@glfwGetWin
|
|
|
|
; 567 : *xpos = 0;
|
|
|
|
00007 89 02 mov DWORD PTR [rdx], eax
|
|
$LN2@glfwGetWin:
|
|
|
|
; 568 : if (ypos)
|
|
|
|
00009 4d 85 c0 test r8, r8
|
|
0000c 74 03 je SHORT $LN3@glfwGetWin
|
|
|
|
; 569 : *ypos = 0;
|
|
|
|
0000e 41 89 00 mov DWORD PTR [r8], eax
|
|
$LN3@glfwGetWin:
|
|
|
|
; 570 :
|
|
; 571 : _GLFW_REQUIRE_INIT();
|
|
|
|
00011 39 05 00 00 00
|
|
00 cmp DWORD PTR _glfw, eax
|
|
00017 75 0c jne SHORT $LN4@glfwGetWin
|
|
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@glfwGetWin:
|
|
|
|
; 572 : _glfw.platform.getWindowPos(window, xpos, ypos);
|
|
|
|
00025 48 ff 25 30 01
|
|
00 00 rex_jmp QWORD PTR _glfw+304
|
|
glfwGetWindowPos ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwSetWindowPos
|
|
_TEXT SEGMENT
|
|
handle$ = 8
|
|
xpos$ = 16
|
|
ypos$ = 24
|
|
glfwSetWindowPos PROC ; COMDAT
|
|
|
|
; 577 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 578 : assert(window != NULL);
|
|
; 579 :
|
|
; 580 : _GLFW_REQUIRE_INIT();
|
|
|
|
00000 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
00007 75 0c jne SHORT $LN2@glfwSetWin
|
|
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@glfwSetWin:
|
|
|
|
; 581 :
|
|
; 582 : if (window->monitor)
|
|
|
|
00015 48 83 79 50 00 cmp QWORD PTR [rcx+80], 0
|
|
0001a 75 07 jne SHORT $LN1@glfwSetWin
|
|
|
|
; 583 : return;
|
|
; 584 :
|
|
; 585 : _glfw.platform.setWindowPos(window, xpos, ypos);
|
|
|
|
0001c 48 ff 25 38 01
|
|
00 00 rex_jmp QWORD PTR _glfw+312
|
|
$LN1@glfwSetWin:
|
|
|
|
; 586 : }
|
|
|
|
00023 c3 ret 0
|
|
glfwSetWindowPos ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwGetWindowSize
|
|
_TEXT SEGMENT
|
|
handle$ = 8
|
|
width$ = 16
|
|
height$ = 24
|
|
glfwGetWindowSize PROC ; COMDAT
|
|
|
|
; 590 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 591 : assert(window != NULL);
|
|
; 592 :
|
|
; 593 : if (width)
|
|
|
|
00000 33 c0 xor eax, eax
|
|
00002 48 85 d2 test rdx, rdx
|
|
00005 74 02 je SHORT $LN2@glfwGetWin
|
|
|
|
; 594 : *width = 0;
|
|
|
|
00007 89 02 mov DWORD PTR [rdx], eax
|
|
$LN2@glfwGetWin:
|
|
|
|
; 595 : if (height)
|
|
|
|
00009 4d 85 c0 test r8, r8
|
|
0000c 74 03 je SHORT $LN3@glfwGetWin
|
|
|
|
; 596 : *height = 0;
|
|
|
|
0000e 41 89 00 mov DWORD PTR [r8], eax
|
|
$LN3@glfwGetWin:
|
|
|
|
; 597 :
|
|
; 598 : _GLFW_REQUIRE_INIT();
|
|
|
|
00011 39 05 00 00 00
|
|
00 cmp DWORD PTR _glfw, eax
|
|
00017 75 0c jne SHORT $LN4@glfwGetWin
|
|
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@glfwGetWin:
|
|
|
|
; 599 : _glfw.platform.getWindowSize(window, width, height);
|
|
|
|
00025 48 ff 25 40 01
|
|
00 00 rex_jmp QWORD PTR _glfw+320
|
|
glfwGetWindowSize ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwSetWindowSize
|
|
_TEXT SEGMENT
|
|
handle$ = 8
|
|
width$ = 16
|
|
height$ = 24
|
|
glfwSetWindowSize PROC ; COMDAT
|
|
|
|
; 604 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 605 : assert(window != NULL);
|
|
; 606 : assert(width >= 0);
|
|
; 607 : assert(height >= 0);
|
|
; 608 :
|
|
; 609 : _GLFW_REQUIRE_INIT();
|
|
|
|
00000 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
00007 75 0c jne SHORT $LN2@glfwSetWin
|
|
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@glfwSetWin:
|
|
|
|
; 610 :
|
|
; 611 : window->videoMode.width = width;
|
|
|
|
00015 89 51 34 mov DWORD PTR [rcx+52], edx
|
|
|
|
; 612 : window->videoMode.height = height;
|
|
|
|
00018 44 89 41 38 mov DWORD PTR [rcx+56], r8d
|
|
|
|
; 613 :
|
|
; 614 : _glfw.platform.setWindowSize(window, width, height);
|
|
|
|
0001c 48 ff 25 48 01
|
|
00 00 rex_jmp QWORD PTR _glfw+328
|
|
glfwSetWindowSize ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwSetWindowSizeLimits
|
|
_TEXT SEGMENT
|
|
handle$ = 8
|
|
minwidth$ = 16
|
|
minheight$ = 24
|
|
maxwidth$ = 32
|
|
maxheight$ = 40
|
|
glfwSetWindowSizeLimits PROC ; COMDAT
|
|
|
|
; 621 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 622 : assert(window != NULL);
|
|
; 623 :
|
|
; 624 : _GLFW_REQUIRE_INIT();
|
|
|
|
00000 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
00007 45 8b d1 mov r10d, r9d
|
|
0000a 75 0c jne SHORT $LN2@glfwSetWin
|
|
0000c 33 d2 xor edx, edx
|
|
0000e b9 01 00 01 00 mov ecx, 65537 ; 00010001H
|
|
00013 e9 00 00 00 00 jmp _glfwInputError
|
|
$LN2@glfwSetWin:
|
|
|
|
; 625 :
|
|
; 626 : if (minwidth != GLFW_DONT_CARE && minheight != GLFW_DONT_CARE)
|
|
|
|
00018 83 fa ff cmp edx, -1
|
|
0001b 74 26 je SHORT $LN4@glfwSetWin
|
|
0001d 41 83 f8 ff cmp r8d, -1
|
|
00021 74 20 je SHORT $LN4@glfwSetWin
|
|
|
|
; 627 : {
|
|
; 628 : if (minwidth < 0 || minheight < 0)
|
|
|
|
00023 85 d2 test edx, edx
|
|
00025 78 05 js SHORT $LN5@glfwSetWin
|
|
00027 45 85 c0 test r8d, r8d
|
|
0002a 79 17 jns SHORT $LN4@glfwSetWin
|
|
$LN5@glfwSetWin:
|
|
|
|
; 629 : {
|
|
; 630 : _glfwInputError(GLFW_INVALID_VALUE,
|
|
|
|
0002c 45 8b c8 mov r9d, r8d
|
|
0002f b9 04 00 01 00 mov ecx, 65540 ; 00010004H
|
|
00034 44 8b c2 mov r8d, edx
|
|
00037 48 8d 15 00 00
|
|
00 00 lea rdx, OFFSET FLAT:??_C@_0CC@HJEJGDAP@Invalid?5window?5minimum?5size?5?$CFix@
|
|
0003e e9 00 00 00 00 jmp _glfwInputError
|
|
$LN4@glfwSetWin:
|
|
|
|
; 631 : "Invalid window minimum size %ix%i",
|
|
; 632 : minwidth, minheight);
|
|
; 633 : return;
|
|
; 634 : }
|
|
; 635 : }
|
|
; 636 :
|
|
; 637 : if (maxwidth != GLFW_DONT_CARE && maxheight != GLFW_DONT_CARE)
|
|
|
|
00043 8b 44 24 28 mov eax, DWORD PTR maxheight$[rsp]
|
|
00047 41 83 fa ff cmp r10d, -1
|
|
0004b 74 2f je SHORT $LN7@glfwSetWin
|
|
0004d 83 f8 ff cmp eax, -1
|
|
00050 74 2a je SHORT $LN7@glfwSetWin
|
|
|
|
; 638 : {
|
|
; 639 : if (maxwidth < 0 || maxheight < 0 ||
|
|
; 640 : maxwidth < minwidth || maxheight < minheight)
|
|
|
|
00052 45 85 d2 test r10d, r10d
|
|
00055 78 0e js SHORT $LN8@glfwSetWin
|
|
00057 85 c0 test eax, eax
|
|
00059 78 0a js SHORT $LN8@glfwSetWin
|
|
0005b 44 3b d2 cmp r10d, edx
|
|
0005e 7c 05 jl SHORT $LN8@glfwSetWin
|
|
00060 41 3b c0 cmp eax, r8d
|
|
00063 7d 17 jge SHORT $LN7@glfwSetWin
|
|
$LN8@glfwSetWin:
|
|
|
|
; 641 : {
|
|
; 642 : _glfwInputError(GLFW_INVALID_VALUE,
|
|
|
|
00065 44 8b c8 mov r9d, eax
|
|
00068 48 8d 15 00 00
|
|
00 00 lea rdx, OFFSET FLAT:??_C@_0CC@NOHNODHG@Invalid?5window?5maximum?5size?5?$CFix@
|
|
0006f 45 8b c2 mov r8d, r10d
|
|
00072 b9 04 00 01 00 mov ecx, 65540 ; 00010004H
|
|
00077 e9 00 00 00 00 jmp _glfwInputError
|
|
$LN7@glfwSetWin:
|
|
|
|
; 643 : "Invalid window maximum size %ix%i",
|
|
; 644 : maxwidth, maxheight);
|
|
; 645 : return;
|
|
; 646 : }
|
|
; 647 : }
|
|
; 648 :
|
|
; 649 : window->minwidth = minwidth;
|
|
; 650 : window->minheight = minheight;
|
|
; 651 : window->maxwidth = maxwidth;
|
|
; 652 : window->maxheight = maxheight;
|
|
; 653 :
|
|
; 654 : if (window->monitor || !window->resizable)
|
|
|
|
0007c 48 83 79 50 00 cmp QWORD PTR [rcx+80], 0
|
|
00081 89 51 60 mov DWORD PTR [rcx+96], edx
|
|
00084 44 89 41 64 mov DWORD PTR [rcx+100], r8d
|
|
00088 44 89 51 68 mov DWORD PTR [rcx+104], r10d
|
|
0008c 89 41 6c mov DWORD PTR [rcx+108], eax
|
|
0008f 75 11 jne SHORT $LN10@glfwSetWin
|
|
00091 83 79 08 00 cmp DWORD PTR [rcx+8], 0
|
|
00095 74 0b je SHORT $LN10@glfwSetWin
|
|
|
|
; 655 : return;
|
|
; 656 :
|
|
; 657 : _glfw.platform.setWindowSizeLimits(window,
|
|
|
|
00097 89 44 24 28 mov DWORD PTR maxheight$[rsp], eax
|
|
0009b 48 ff 25 50 01
|
|
00 00 rex_jmp QWORD PTR _glfw+336
|
|
$LN10@glfwSetWin:
|
|
|
|
; 658 : minwidth, minheight,
|
|
; 659 : maxwidth, maxheight);
|
|
; 660 : }
|
|
|
|
000a2 c3 ret 0
|
|
glfwSetWindowSizeLimits ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwSetWindowAspectRatio
|
|
_TEXT SEGMENT
|
|
handle$ = 8
|
|
numer$ = 16
|
|
denom$ = 24
|
|
glfwSetWindowAspectRatio PROC ; COMDAT
|
|
|
|
; 664 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 665 : assert(window != NULL);
|
|
; 666 : assert(numer != 0);
|
|
; 667 : assert(denom != 0);
|
|
; 668 :
|
|
; 669 : _GLFW_REQUIRE_INIT();
|
|
|
|
00000 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
00007 75 0c jne SHORT $LN2@glfwSetWin
|
|
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@glfwSetWin:
|
|
|
|
; 670 :
|
|
; 671 : if (numer != GLFW_DONT_CARE && denom != GLFW_DONT_CARE)
|
|
|
|
00015 83 fa ff cmp edx, -1
|
|
00018 74 26 je SHORT $LN4@glfwSetWin
|
|
0001a 41 83 f8 ff cmp r8d, -1
|
|
0001e 74 20 je SHORT $LN4@glfwSetWin
|
|
|
|
; 672 : {
|
|
; 673 : if (numer <= 0 || denom <= 0)
|
|
|
|
00020 85 d2 test edx, edx
|
|
00022 7e 05 jle SHORT $LN5@glfwSetWin
|
|
00024 45 85 c0 test r8d, r8d
|
|
00027 7f 17 jg SHORT $LN4@glfwSetWin
|
|
$LN5@glfwSetWin:
|
|
|
|
; 674 : {
|
|
; 675 : _glfwInputError(GLFW_INVALID_VALUE,
|
|
|
|
00029 45 8b c8 mov r9d, r8d
|
|
0002c b9 04 00 01 00 mov ecx, 65540 ; 00010004H
|
|
00031 44 8b c2 mov r8d, edx
|
|
00034 48 8d 15 00 00
|
|
00 00 lea rdx, OFFSET FLAT:??_C@_0CC@BPDGBBAB@Invalid?5window?5aspect?5ratio?5?$CFi?3@
|
|
0003b e9 00 00 00 00 jmp _glfwInputError
|
|
$LN4@glfwSetWin:
|
|
|
|
; 676 : "Invalid window aspect ratio %i:%i",
|
|
; 677 : numer, denom);
|
|
; 678 : return;
|
|
; 679 : }
|
|
; 680 : }
|
|
; 681 :
|
|
; 682 : window->numer = numer;
|
|
; 683 : window->denom = denom;
|
|
; 684 :
|
|
; 685 : if (window->monitor || !window->resizable)
|
|
|
|
00040 48 83 79 50 00 cmp QWORD PTR [rcx+80], 0
|
|
00045 89 51 70 mov DWORD PTR [rcx+112], edx
|
|
00048 44 89 41 74 mov DWORD PTR [rcx+116], r8d
|
|
0004c 75 0d jne SHORT $LN7@glfwSetWin
|
|
0004e 83 79 08 00 cmp DWORD PTR [rcx+8], 0
|
|
00052 74 07 je SHORT $LN7@glfwSetWin
|
|
|
|
; 686 : return;
|
|
; 687 :
|
|
; 688 : _glfw.platform.setWindowAspectRatio(window, numer, denom);
|
|
|
|
00054 48 ff 25 58 01
|
|
00 00 rex_jmp QWORD PTR _glfw+344
|
|
$LN7@glfwSetWin:
|
|
|
|
; 689 : }
|
|
|
|
0005b c3 ret 0
|
|
glfwSetWindowAspectRatio ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwGetFramebufferSize
|
|
_TEXT SEGMENT
|
|
handle$ = 8
|
|
width$ = 16
|
|
height$ = 24
|
|
glfwGetFramebufferSize PROC ; COMDAT
|
|
|
|
; 693 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 694 : assert(window != NULL);
|
|
; 695 :
|
|
; 696 : if (width)
|
|
|
|
00000 33 c0 xor eax, eax
|
|
00002 48 85 d2 test rdx, rdx
|
|
00005 74 02 je SHORT $LN2@glfwGetFra
|
|
|
|
; 697 : *width = 0;
|
|
|
|
00007 89 02 mov DWORD PTR [rdx], eax
|
|
$LN2@glfwGetFra:
|
|
|
|
; 698 : if (height)
|
|
|
|
00009 4d 85 c0 test r8, r8
|
|
0000c 74 03 je SHORT $LN3@glfwGetFra
|
|
|
|
; 699 : *height = 0;
|
|
|
|
0000e 41 89 00 mov DWORD PTR [r8], eax
|
|
$LN3@glfwGetFra:
|
|
|
|
; 700 :
|
|
; 701 : _GLFW_REQUIRE_INIT();
|
|
|
|
00011 39 05 00 00 00
|
|
00 cmp DWORD PTR _glfw, eax
|
|
00017 75 0c jne SHORT $LN4@glfwGetFra
|
|
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@glfwGetFra:
|
|
|
|
; 702 : _glfw.platform.getFramebufferSize(window, width, height);
|
|
|
|
00025 48 ff 25 60 01
|
|
00 00 rex_jmp QWORD PTR _glfw+352
|
|
glfwGetFramebufferSize ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwGetWindowFrameSize
|
|
_TEXT SEGMENT
|
|
handle$ = 8
|
|
left$ = 16
|
|
top$ = 24
|
|
right$ = 32
|
|
bottom$ = 40
|
|
glfwGetWindowFrameSize PROC ; COMDAT
|
|
|
|
; 709 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 710 : assert(window != NULL);
|
|
; 711 :
|
|
; 712 : if (left)
|
|
|
|
00000 45 33 d2 xor r10d, r10d
|
|
00003 48 85 d2 test rdx, rdx
|
|
00006 74 03 je SHORT $LN2@glfwGetWin
|
|
|
|
; 713 : *left = 0;
|
|
|
|
00008 44 89 12 mov DWORD PTR [rdx], r10d
|
|
$LN2@glfwGetWin:
|
|
|
|
; 714 : if (top)
|
|
|
|
0000b 4d 85 c0 test r8, r8
|
|
0000e 74 03 je SHORT $LN3@glfwGetWin
|
|
|
|
; 715 : *top = 0;
|
|
|
|
00010 45 89 10 mov DWORD PTR [r8], r10d
|
|
$LN3@glfwGetWin:
|
|
|
|
; 716 : if (right)
|
|
|
|
00013 4d 85 c9 test r9, r9
|
|
00016 74 03 je SHORT $LN4@glfwGetWin
|
|
|
|
; 717 : *right = 0;
|
|
|
|
00018 45 89 11 mov DWORD PTR [r9], r10d
|
|
$LN4@glfwGetWin:
|
|
|
|
; 718 : if (bottom)
|
|
|
|
0001b 48 8b 44 24 28 mov rax, QWORD PTR bottom$[rsp]
|
|
00020 48 85 c0 test rax, rax
|
|
00023 74 03 je SHORT $LN5@glfwGetWin
|
|
|
|
; 719 : *bottom = 0;
|
|
|
|
00025 44 89 10 mov DWORD PTR [rax], r10d
|
|
$LN5@glfwGetWin:
|
|
|
|
; 720 :
|
|
; 721 : _GLFW_REQUIRE_INIT();
|
|
|
|
00028 44 39 15 00 00
|
|
00 00 cmp DWORD PTR _glfw, r10d
|
|
0002f 75 0c jne SHORT $LN6@glfwGetWin
|
|
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@glfwGetWin:
|
|
|
|
; 722 : _glfw.platform.getWindowFrameSize(window, left, top, right, bottom);
|
|
|
|
0003d 48 89 44 24 28 mov QWORD PTR bottom$[rsp], rax
|
|
00042 48 ff 25 68 01
|
|
00 00 rex_jmp QWORD PTR _glfw+360
|
|
glfwGetWindowFrameSize ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwGetWindowContentScale
|
|
_TEXT SEGMENT
|
|
handle$ = 8
|
|
xscale$ = 16
|
|
yscale$ = 24
|
|
glfwGetWindowContentScale PROC ; COMDAT
|
|
|
|
; 728 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 729 : assert(window != NULL);
|
|
; 730 :
|
|
; 731 : if (xscale)
|
|
|
|
00000 33 c0 xor eax, eax
|
|
00002 48 85 d2 test rdx, rdx
|
|
00005 74 02 je SHORT $LN2@glfwGetWin
|
|
|
|
; 732 : *xscale = 0.f;
|
|
|
|
00007 89 02 mov DWORD PTR [rdx], eax
|
|
$LN2@glfwGetWin:
|
|
|
|
; 733 : if (yscale)
|
|
|
|
00009 4d 85 c0 test r8, r8
|
|
0000c 74 03 je SHORT $LN3@glfwGetWin
|
|
|
|
; 734 : *yscale = 0.f;
|
|
|
|
0000e 41 89 00 mov DWORD PTR [r8], eax
|
|
$LN3@glfwGetWin:
|
|
|
|
; 735 :
|
|
; 736 : _GLFW_REQUIRE_INIT();
|
|
|
|
00011 39 05 00 00 00
|
|
00 cmp DWORD PTR _glfw, eax
|
|
00017 75 0c jne SHORT $LN4@glfwGetWin
|
|
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@glfwGetWin:
|
|
|
|
; 737 : _glfw.platform.getWindowContentScale(window, xscale, yscale);
|
|
|
|
00025 48 ff 25 70 01
|
|
00 00 rex_jmp QWORD PTR _glfw+368
|
|
glfwGetWindowContentScale ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwGetWindowOpacity
|
|
_TEXT SEGMENT
|
|
handle$ = 48
|
|
glfwGetWindowOpacity PROC ; COMDAT
|
|
|
|
; 741 : {
|
|
|
|
$LN5:
|
|
00000 48 83 ec 28 sub rsp, 40 ; 00000028H
|
|
|
|
; 742 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 743 : assert(window != NULL);
|
|
; 744 :
|
|
; 745 : _GLFW_REQUIRE_INIT_OR_RETURN(1.f);
|
|
|
|
00004 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
0000b 75 19 jne SHORT $LN2@glfwGetWin
|
|
0000d 33 d2 xor edx, edx
|
|
0000f b9 01 00 01 00 mov ecx, 65537 ; 00010001H
|
|
00014 e8 00 00 00 00 call _glfwInputError
|
|
00019 f3 0f 10 05 00
|
|
00 00 00 movss xmm0, DWORD PTR __real@3f800000
|
|
|
|
; 747 : }
|
|
|
|
00021 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
00025 c3 ret 0
|
|
$LN2@glfwGetWin:
|
|
00026 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
|
|
; 746 : return _glfw.platform.getWindowOpacity(window);
|
|
|
|
0002a 48 ff 25 e8 01
|
|
00 00 rex_jmp QWORD PTR _glfw+488
|
|
glfwGetWindowOpacity ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwSetWindowOpacity
|
|
_TEXT SEGMENT
|
|
handle$ = 8
|
|
opacity$ = 16
|
|
glfwSetWindowOpacity PROC ; COMDAT
|
|
|
|
; 751 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 752 : assert(window != NULL);
|
|
; 753 : assert(opacity == opacity);
|
|
; 754 : assert(opacity >= 0.f);
|
|
; 755 : assert(opacity <= 1.f);
|
|
; 756 :
|
|
; 757 : _GLFW_REQUIRE_INIT();
|
|
|
|
00000 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
00007 75 0c jne SHORT $LN2@glfwSetWin
|
|
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@glfwSetWin:
|
|
|
|
; 758 :
|
|
; 759 : if (opacity != opacity || opacity < 0.f || opacity > 1.f)
|
|
|
|
00015 0f 2e c9 ucomiss xmm1, xmm1
|
|
00018 7a 18 jp SHORT $LN4@glfwSetWin
|
|
0001a 0f 57 c0 xorps xmm0, xmm0
|
|
0001d 0f 2f c1 comiss xmm0, xmm1
|
|
00020 77 10 ja SHORT $LN4@glfwSetWin
|
|
00022 0f 2f 0d 00 00
|
|
00 00 comiss xmm1, DWORD PTR __real@3f800000
|
|
00029 77 07 ja SHORT $LN4@glfwSetWin
|
|
|
|
; 762 : return;
|
|
; 763 : }
|
|
; 764 :
|
|
; 765 : _glfw.platform.setWindowOpacity(window, opacity);
|
|
|
|
0002b 48 ff 25 08 02
|
|
00 00 rex_jmp QWORD PTR _glfw+520
|
|
$LN4@glfwSetWin:
|
|
|
|
; 760 : {
|
|
; 761 : _glfwInputError(GLFW_INVALID_VALUE, "Invalid window opacity %f", opacity);
|
|
|
|
00032 0f 57 d2 xorps xmm2, xmm2
|
|
00035 48 8d 15 00 00
|
|
00 00 lea rdx, OFFSET FLAT:??_C@_0BK@MBEPKAIA@Invalid?5window?5opacity?5?$CFf@
|
|
0003c f3 0f 5a d1 cvtss2sd xmm2, xmm1
|
|
00040 b9 04 00 01 00 mov ecx, 65540 ; 00010004H
|
|
00045 66 49 0f 7e d0 movq r8, xmm2
|
|
0004a e9 00 00 00 00 jmp _glfwInputError
|
|
glfwSetWindowOpacity ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwIconifyWindow
|
|
_TEXT SEGMENT
|
|
handle$ = 8
|
|
glfwIconifyWindow PROC ; COMDAT
|
|
|
|
; 770 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 771 : assert(window != NULL);
|
|
; 772 :
|
|
; 773 : _GLFW_REQUIRE_INIT();
|
|
|
|
00000 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
00007 75 0c jne SHORT $LN2@glfwIconif
|
|
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@glfwIconif:
|
|
|
|
; 774 : _glfw.platform.iconifyWindow(window);
|
|
|
|
00015 48 ff 25 78 01
|
|
00 00 rex_jmp QWORD PTR _glfw+376
|
|
glfwIconifyWindow ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwRestoreWindow
|
|
_TEXT SEGMENT
|
|
handle$ = 8
|
|
glfwRestoreWindow PROC ; COMDAT
|
|
|
|
; 779 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 780 : assert(window != NULL);
|
|
; 781 :
|
|
; 782 : _GLFW_REQUIRE_INIT();
|
|
|
|
00000 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
00007 75 0c jne SHORT $LN2@glfwRestor
|
|
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@glfwRestor:
|
|
|
|
; 783 : _glfw.platform.restoreWindow(window);
|
|
|
|
00015 48 ff 25 80 01
|
|
00 00 rex_jmp QWORD PTR _glfw+384
|
|
glfwRestoreWindow ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwMaximizeWindow
|
|
_TEXT SEGMENT
|
|
handle$ = 8
|
|
glfwMaximizeWindow PROC ; COMDAT
|
|
|
|
; 788 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 789 : assert(window != NULL);
|
|
; 790 :
|
|
; 791 : _GLFW_REQUIRE_INIT();
|
|
|
|
00000 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
00007 75 0c jne SHORT $LN2@glfwMaximi
|
|
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@glfwMaximi:
|
|
|
|
; 792 :
|
|
; 793 : if (window->monitor)
|
|
|
|
00015 48 83 79 50 00 cmp QWORD PTR [rcx+80], 0
|
|
0001a 75 07 jne SHORT $LN1@glfwMaximi
|
|
|
|
; 794 : return;
|
|
; 795 :
|
|
; 796 : _glfw.platform.maximizeWindow(window);
|
|
|
|
0001c 48 ff 25 88 01
|
|
00 00 rex_jmp QWORD PTR _glfw+392
|
|
$LN1@glfwMaximi:
|
|
|
|
; 797 : }
|
|
|
|
00023 c3 ret 0
|
|
glfwMaximizeWindow ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwShowWindow
|
|
_TEXT SEGMENT
|
|
handle$ = 48
|
|
glfwShowWindow PROC ; COMDAT
|
|
|
|
; 800 : {
|
|
|
|
$LN10:
|
|
00000 40 53 push rbx
|
|
00002 48 83 ec 20 sub rsp, 32 ; 00000020H
|
|
|
|
; 801 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 802 : assert(window != NULL);
|
|
; 803 :
|
|
; 804 : _GLFW_REQUIRE_INIT();
|
|
|
|
00006 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
0000d 48 8b d9 mov rbx, rcx
|
|
00010 75 11 jne SHORT $LN2@glfwShowWi
|
|
00012 33 d2 xor edx, edx
|
|
00014 b9 01 00 01 00 mov ecx, 65537 ; 00010001H
|
|
|
|
; 813 : }
|
|
|
|
00019 48 83 c4 20 add rsp, 32 ; 00000020H
|
|
0001d 5b pop rbx
|
|
|
|
; 801 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 802 : assert(window != NULL);
|
|
; 803 :
|
|
; 804 : _GLFW_REQUIRE_INIT();
|
|
|
|
0001e e9 00 00 00 00 jmp _glfwInputError
|
|
$LN2@glfwShowWi:
|
|
|
|
; 805 :
|
|
; 806 : if (window->monitor)
|
|
|
|
00023 48 83 79 50 00 cmp QWORD PTR [rcx+80], 0
|
|
00028 75 1b jne SHORT $LN4@glfwShowWi
|
|
|
|
; 807 : return;
|
|
; 808 :
|
|
; 809 : _glfw.platform.showWindow(window);
|
|
|
|
0002a ff 15 90 01 00
|
|
00 call QWORD PTR _glfw+400
|
|
|
|
; 810 :
|
|
; 811 : if (window->focusOnShow)
|
|
|
|
00030 83 7b 18 00 cmp DWORD PTR [rbx+24], 0
|
|
00034 74 0f je SHORT $LN4@glfwShowWi
|
|
|
|
; 812 : _glfw.platform.focusWindow(window);
|
|
|
|
00036 48 8b cb mov rcx, rbx
|
|
|
|
; 813 : }
|
|
|
|
00039 48 83 c4 20 add rsp, 32 ; 00000020H
|
|
0003d 5b pop rbx
|
|
|
|
; 812 : _glfw.platform.focusWindow(window);
|
|
|
|
0003e 48 ff 25 a8 01
|
|
00 00 rex_jmp QWORD PTR _glfw+424
|
|
$LN4@glfwShowWi:
|
|
|
|
; 813 : }
|
|
|
|
00045 48 83 c4 20 add rsp, 32 ; 00000020H
|
|
00049 5b pop rbx
|
|
0004a c3 ret 0
|
|
glfwShowWindow ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwRequestWindowAttention
|
|
_TEXT SEGMENT
|
|
handle$ = 8
|
|
glfwRequestWindowAttention PROC ; COMDAT
|
|
|
|
; 817 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 818 : assert(window != NULL);
|
|
; 819 :
|
|
; 820 : _GLFW_REQUIRE_INIT();
|
|
|
|
00000 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
00007 75 0c jne SHORT $LN2@glfwReques
|
|
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@glfwReques:
|
|
|
|
; 821 :
|
|
; 822 : _glfw.platform.requestWindowAttention(window);
|
|
|
|
00015 48 ff 25 a0 01
|
|
00 00 rex_jmp QWORD PTR _glfw+416
|
|
glfwRequestWindowAttention ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwHideWindow
|
|
_TEXT SEGMENT
|
|
handle$ = 8
|
|
glfwHideWindow PROC ; COMDAT
|
|
|
|
; 827 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 828 : assert(window != NULL);
|
|
; 829 :
|
|
; 830 : _GLFW_REQUIRE_INIT();
|
|
|
|
00000 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
00007 75 0c jne SHORT $LN2@glfwHideWi
|
|
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@glfwHideWi:
|
|
|
|
; 831 :
|
|
; 832 : if (window->monitor)
|
|
|
|
00015 48 83 79 50 00 cmp QWORD PTR [rcx+80], 0
|
|
0001a 75 07 jne SHORT $LN1@glfwHideWi
|
|
|
|
; 833 : return;
|
|
; 834 :
|
|
; 835 : _glfw.platform.hideWindow(window);
|
|
|
|
0001c 48 ff 25 98 01
|
|
00 00 rex_jmp QWORD PTR _glfw+408
|
|
$LN1@glfwHideWi:
|
|
|
|
; 836 : }
|
|
|
|
00023 c3 ret 0
|
|
glfwHideWindow ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwFocusWindow
|
|
_TEXT SEGMENT
|
|
handle$ = 8
|
|
glfwFocusWindow PROC ; COMDAT
|
|
|
|
; 840 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 841 : assert(window != NULL);
|
|
; 842 :
|
|
; 843 : _GLFW_REQUIRE_INIT();
|
|
|
|
00000 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
00007 75 0c jne SHORT $LN2@glfwFocusW
|
|
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@glfwFocusW:
|
|
|
|
; 844 :
|
|
; 845 : _glfw.platform.focusWindow(window);
|
|
|
|
00015 48 ff 25 a8 01
|
|
00 00 rex_jmp QWORD PTR _glfw+424
|
|
glfwFocusWindow ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwGetWindowAttrib
|
|
_TEXT SEGMENT
|
|
handle$ = 48
|
|
attrib$ = 56
|
|
glfwGetWindowAttrib PROC ; COMDAT
|
|
|
|
; 849 : {
|
|
|
|
$LN35:
|
|
00000 48 83 ec 28 sub rsp, 40 ; 00000028H
|
|
|
|
; 850 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 851 : assert(window != NULL);
|
|
; 852 :
|
|
; 853 : _GLFW_REQUIRE_INIT_OR_RETURN(0);
|
|
|
|
00004 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
0000b 75 13 jne SHORT $LN4@glfwGetWin
|
|
0000d 33 d2 xor edx, edx
|
|
0000f b9 01 00 01 00 mov ecx, 65537 ; 00010001H
|
|
00014 e8 00 00 00 00 call _glfwInputError
|
|
|
|
; 908 : return 0;
|
|
; 909 : }
|
|
|
|
00019 33 c0 xor eax, eax
|
|
0001b 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
0001f c3 ret 0
|
|
$LN4@glfwGetWin:
|
|
|
|
; 854 :
|
|
; 855 : switch (attrib)
|
|
|
|
00020 81 fa 10 10 02
|
|
00 cmp edx, 135184 ; 00021010H
|
|
00026 0f 8f a5 00 00
|
|
00 jg $LN30@glfwGetWin
|
|
0002c 0f 84 97 00 00
|
|
00 je $LN17@glfwGetWin
|
|
00032 8d 82 ff ff fd
|
|
ff lea eax, DWORD PTR [rdx-131073]
|
|
00038 83 f8 0c cmp eax, 12
|
|
0003b 0f 87 2e 01 00
|
|
00 ja $LN2@glfwGetWin
|
|
00041 48 98 cdqe
|
|
00043 4c 8d 05 00 00
|
|
00 00 lea r8, OFFSET FLAT:__ImageBase
|
|
0004a 41 8b 84 80 00
|
|
00 00 00 mov eax, DWORD PTR $LN32@glfwGetWin[r8+rax*4]
|
|
00052 49 03 c0 add rax, r8
|
|
00055 ff e0 jmp rax
|
|
$LN5@glfwGetWin:
|
|
|
|
; 908 : return 0;
|
|
; 909 : }
|
|
|
|
00057 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
|
|
; 856 : {
|
|
; 857 : case GLFW_FOCUSED:
|
|
; 858 : return _glfw.platform.windowFocused(window);
|
|
|
|
0005b 48 ff 25 b8 01
|
|
00 00 rex_jmp QWORD PTR _glfw+440
|
|
$LN6@glfwGetWin:
|
|
|
|
; 908 : return 0;
|
|
; 909 : }
|
|
|
|
00062 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
|
|
; 859 : case GLFW_ICONIFIED:
|
|
; 860 : return _glfw.platform.windowIconified(window);
|
|
|
|
00066 48 ff 25 c0 01
|
|
00 00 rex_jmp QWORD PTR _glfw+448
|
|
$LN7@glfwGetWin:
|
|
|
|
; 908 : return 0;
|
|
; 909 : }
|
|
|
|
0006d 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
|
|
; 861 : case GLFW_VISIBLE:
|
|
; 862 : return _glfw.platform.windowVisible(window);
|
|
|
|
00071 48 ff 25 c8 01
|
|
00 00 rex_jmp QWORD PTR _glfw+456
|
|
$LN8@glfwGetWin:
|
|
|
|
; 908 : return 0;
|
|
; 909 : }
|
|
|
|
00078 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
|
|
; 863 : case GLFW_MAXIMIZED:
|
|
; 864 : return _glfw.platform.windowMaximized(window);
|
|
|
|
0007c 48 ff 25 d0 01
|
|
00 00 rex_jmp QWORD PTR _glfw+464
|
|
$LN9@glfwGetWin:
|
|
|
|
; 908 : return 0;
|
|
; 909 : }
|
|
|
|
00083 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
|
|
; 865 : case GLFW_HOVERED:
|
|
; 866 : return _glfw.platform.windowHovered(window);
|
|
|
|
00087 48 ff 25 d8 01
|
|
00 00 rex_jmp QWORD PTR _glfw+472
|
|
$LN10@glfwGetWin:
|
|
|
|
; 867 : case GLFW_FOCUS_ON_SHOW:
|
|
; 868 : return window->focusOnShow;
|
|
|
|
0008e 8b 41 18 mov eax, DWORD PTR [rcx+24]
|
|
|
|
; 908 : return 0;
|
|
; 909 : }
|
|
|
|
00091 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
00095 c3 ret 0
|
|
$LN11@glfwGetWin:
|
|
|
|
; 869 : case GLFW_MOUSE_PASSTHROUGH:
|
|
; 870 : return window->mousePassthrough;
|
|
|
|
00096 8b 41 1c mov eax, DWORD PTR [rcx+28]
|
|
|
|
; 908 : return 0;
|
|
; 909 : }
|
|
|
|
00099 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
0009d c3 ret 0
|
|
$LN12@glfwGetWin:
|
|
0009e 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
|
|
; 871 : case GLFW_TRANSPARENT_FRAMEBUFFER:
|
|
; 872 : return _glfw.platform.framebufferTransparent(window);
|
|
|
|
000a2 48 ff 25 e0 01
|
|
00 00 rex_jmp QWORD PTR _glfw+480
|
|
$LN13@glfwGetWin:
|
|
|
|
; 873 : case GLFW_RESIZABLE:
|
|
; 874 : return window->resizable;
|
|
|
|
000a9 8b 41 08 mov eax, DWORD PTR [rcx+8]
|
|
|
|
; 908 : return 0;
|
|
; 909 : }
|
|
|
|
000ac 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
000b0 c3 ret 0
|
|
$LN14@glfwGetWin:
|
|
|
|
; 875 : case GLFW_DECORATED:
|
|
; 876 : return window->decorated;
|
|
|
|
000b1 8b 41 0c mov eax, DWORD PTR [rcx+12]
|
|
|
|
; 908 : return 0;
|
|
; 909 : }
|
|
|
|
000b4 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
000b8 c3 ret 0
|
|
$LN15@glfwGetWin:
|
|
|
|
; 877 : case GLFW_FLOATING:
|
|
; 878 : return window->floating;
|
|
|
|
000b9 8b 41 14 mov eax, DWORD PTR [rcx+20]
|
|
|
|
; 908 : return 0;
|
|
; 909 : }
|
|
|
|
000bc 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
000c0 c3 ret 0
|
|
$LN16@glfwGetWin:
|
|
|
|
; 879 : case GLFW_AUTO_ICONIFY:
|
|
; 880 : return window->autoIconify;
|
|
|
|
000c1 8b 41 10 mov eax, DWORD PTR [rcx+16]
|
|
|
|
; 908 : return 0;
|
|
; 909 : }
|
|
|
|
000c4 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
000c8 c3 ret 0
|
|
$LN17@glfwGetWin:
|
|
|
|
; 881 : case GLFW_DOUBLEBUFFER:
|
|
; 882 : return window->doublebuffer;
|
|
|
|
000c9 8b 41 30 mov eax, DWORD PTR [rcx+48]
|
|
|
|
; 908 : return 0;
|
|
; 909 : }
|
|
|
|
000cc 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
000d0 c3 ret 0
|
|
$LN30@glfwGetWin:
|
|
|
|
; 854 :
|
|
; 855 : switch (attrib)
|
|
|
|
000d1 8d 82 ff df fd
|
|
ff lea eax, DWORD PTR [rdx-139265]
|
|
000d7 83 f8 0a cmp eax, 10
|
|
000da 0f 87 8f 00 00
|
|
00 ja $LN2@glfwGetWin
|
|
000e0 48 98 cdqe
|
|
000e2 4c 8d 05 00 00
|
|
00 00 lea r8, OFFSET FLAT:__ImageBase
|
|
000e9 41 8b 84 80 00
|
|
00 00 00 mov eax, DWORD PTR $LN31@glfwGetWin[r8+rax*4]
|
|
000f1 49 03 c0 add rax, r8
|
|
000f4 ff e0 jmp rax
|
|
$LN18@glfwGetWin:
|
|
|
|
; 883 : case GLFW_CLIENT_API:
|
|
; 884 : return window->context.client;
|
|
|
|
000f6 8b 81 08 02 00
|
|
00 mov eax, DWORD PTR [rcx+520]
|
|
|
|
; 908 : return 0;
|
|
; 909 : }
|
|
|
|
000fc 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
00100 c3 ret 0
|
|
$LN19@glfwGetWin:
|
|
|
|
; 885 : case GLFW_CONTEXT_CREATION_API:
|
|
; 886 : return window->context.source;
|
|
|
|
00101 8b 81 0c 02 00
|
|
00 mov eax, DWORD PTR [rcx+524]
|
|
|
|
; 908 : return 0;
|
|
; 909 : }
|
|
|
|
00107 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
0010b c3 ret 0
|
|
$LN20@glfwGetWin:
|
|
|
|
; 887 : case GLFW_CONTEXT_VERSION_MAJOR:
|
|
; 888 : return window->context.major;
|
|
|
|
0010c 8b 81 10 02 00
|
|
00 mov eax, DWORD PTR [rcx+528]
|
|
|
|
; 908 : return 0;
|
|
; 909 : }
|
|
|
|
00112 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
00116 c3 ret 0
|
|
$LN21@glfwGetWin:
|
|
|
|
; 889 : case GLFW_CONTEXT_VERSION_MINOR:
|
|
; 890 : return window->context.minor;
|
|
|
|
00117 8b 81 14 02 00
|
|
00 mov eax, DWORD PTR [rcx+532]
|
|
|
|
; 908 : return 0;
|
|
; 909 : }
|
|
|
|
0011d 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
00121 c3 ret 0
|
|
$LN22@glfwGetWin:
|
|
|
|
; 891 : case GLFW_CONTEXT_REVISION:
|
|
; 892 : return window->context.revision;
|
|
|
|
00122 8b 81 18 02 00
|
|
00 mov eax, DWORD PTR [rcx+536]
|
|
|
|
; 908 : return 0;
|
|
; 909 : }
|
|
|
|
00128 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
0012c c3 ret 0
|
|
$LN23@glfwGetWin:
|
|
|
|
; 893 : case GLFW_CONTEXT_ROBUSTNESS:
|
|
; 894 : return window->context.robustness;
|
|
|
|
0012d 8b 81 2c 02 00
|
|
00 mov eax, DWORD PTR [rcx+556]
|
|
|
|
; 908 : return 0;
|
|
; 909 : }
|
|
|
|
00133 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
00137 c3 ret 0
|
|
$LN24@glfwGetWin:
|
|
|
|
; 895 : case GLFW_OPENGL_FORWARD_COMPAT:
|
|
; 896 : return window->context.forward;
|
|
|
|
00138 8b 81 1c 02 00
|
|
00 mov eax, DWORD PTR [rcx+540]
|
|
|
|
; 908 : return 0;
|
|
; 909 : }
|
|
|
|
0013e 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
00142 c3 ret 0
|
|
$LN25@glfwGetWin:
|
|
|
|
; 897 : case GLFW_CONTEXT_DEBUG:
|
|
; 898 : return window->context.debug;
|
|
|
|
00143 8b 81 20 02 00
|
|
00 mov eax, DWORD PTR [rcx+544]
|
|
|
|
; 908 : return 0;
|
|
; 909 : }
|
|
|
|
00149 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
0014d c3 ret 0
|
|
$LN26@glfwGetWin:
|
|
|
|
; 899 : case GLFW_OPENGL_PROFILE:
|
|
; 900 : return window->context.profile;
|
|
|
|
0014e 8b 81 28 02 00
|
|
00 mov eax, DWORD PTR [rcx+552]
|
|
|
|
; 908 : return 0;
|
|
; 909 : }
|
|
|
|
00154 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
00158 c3 ret 0
|
|
$LN27@glfwGetWin:
|
|
|
|
; 901 : case GLFW_CONTEXT_RELEASE_BEHAVIOR:
|
|
; 902 : return window->context.release;
|
|
|
|
00159 8b 81 30 02 00
|
|
00 mov eax, DWORD PTR [rcx+560]
|
|
|
|
; 908 : return 0;
|
|
; 909 : }
|
|
|
|
0015f 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
00163 c3 ret 0
|
|
$LN28@glfwGetWin:
|
|
|
|
; 903 : case GLFW_CONTEXT_NO_ERROR:
|
|
; 904 : return window->context.noerror;
|
|
|
|
00164 8b 81 24 02 00
|
|
00 mov eax, DWORD PTR [rcx+548]
|
|
|
|
; 908 : return 0;
|
|
; 909 : }
|
|
|
|
0016a 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
0016e c3 ret 0
|
|
$LN2@glfwGetWin:
|
|
|
|
; 905 : }
|
|
; 906 :
|
|
; 907 : _glfwInputError(GLFW_INVALID_ENUM, "Invalid window attribute 0x%08X", attrib);
|
|
|
|
0016f 44 8b c2 mov r8d, edx
|
|
00172 b9 03 00 01 00 mov ecx, 65539 ; 00010003H
|
|
00177 48 8d 15 00 00
|
|
00 00 lea rdx, OFFSET FLAT:??_C@_0CA@KCGCFCEG@Invalid?5window?5attribute?50x?$CF08X@
|
|
0017e e8 00 00 00 00 call _glfwInputError
|
|
|
|
; 908 : return 0;
|
|
; 909 : }
|
|
|
|
00183 33 c0 xor eax, eax
|
|
00185 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
00189 c3 ret 0
|
|
0018a 66 90 npad 2
|
|
$LN32@glfwGetWin:
|
|
0018c 00 00 00 00 DD $LN5@glfwGetWin
|
|
00190 00 00 00 00 DD $LN6@glfwGetWin
|
|
00194 00 00 00 00 DD $LN13@glfwGetWin
|
|
00198 00 00 00 00 DD $LN7@glfwGetWin
|
|
0019c 00 00 00 00 DD $LN14@glfwGetWin
|
|
001a0 00 00 00 00 DD $LN16@glfwGetWin
|
|
001a4 00 00 00 00 DD $LN15@glfwGetWin
|
|
001a8 00 00 00 00 DD $LN8@glfwGetWin
|
|
001ac 00 00 00 00 DD $LN2@glfwGetWin
|
|
001b0 00 00 00 00 DD $LN12@glfwGetWin
|
|
001b4 00 00 00 00 DD $LN9@glfwGetWin
|
|
001b8 00 00 00 00 DD $LN10@glfwGetWin
|
|
001bc 00 00 00 00 DD $LN11@glfwGetWin
|
|
$LN31@glfwGetWin:
|
|
001c0 00 00 00 00 DD $LN18@glfwGetWin
|
|
001c4 00 00 00 00 DD $LN20@glfwGetWin
|
|
001c8 00 00 00 00 DD $LN21@glfwGetWin
|
|
001cc 00 00 00 00 DD $LN22@glfwGetWin
|
|
001d0 00 00 00 00 DD $LN23@glfwGetWin
|
|
001d4 00 00 00 00 DD $LN24@glfwGetWin
|
|
001d8 00 00 00 00 DD $LN25@glfwGetWin
|
|
001dc 00 00 00 00 DD $LN26@glfwGetWin
|
|
001e0 00 00 00 00 DD $LN27@glfwGetWin
|
|
001e4 00 00 00 00 DD $LN28@glfwGetWin
|
|
001e8 00 00 00 00 DD $LN19@glfwGetWin
|
|
glfwGetWindowAttrib ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwSetWindowAttrib
|
|
_TEXT SEGMENT
|
|
handle$ = 8
|
|
attrib$ = 16
|
|
value$ = 24
|
|
glfwSetWindowAttrib PROC ; COMDAT
|
|
|
|
; 913 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 914 : assert(window != NULL);
|
|
; 915 :
|
|
; 916 : _GLFW_REQUIRE_INIT();
|
|
|
|
00000 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
00007 41 8b c0 mov eax, r8d
|
|
0000a 44 8b c2 mov r8d, edx
|
|
0000d 4c 8b c9 mov r9, rcx
|
|
00010 75 0c jne SHORT $LN4@glfwSetWin
|
|
00012 33 d2 xor edx, edx
|
|
00014 b9 01 00 01 00 mov ecx, 65537 ; 00010001H
|
|
00019 e9 00 00 00 00 jmp _glfwInputError
|
|
$LN4@glfwSetWin:
|
|
|
|
; 917 :
|
|
; 918 : value = value ? GLFW_TRUE : GLFW_FALSE;
|
|
|
|
0001e 33 d2 xor edx, edx
|
|
00020 85 c0 test eax, eax
|
|
|
|
; 919 :
|
|
; 920 : switch (attrib)
|
|
|
|
00022 41 8d 80 fd ff
|
|
fd ff lea eax, DWORD PTR [r8-131075]
|
|
00029 0f 95 c2 setne dl
|
|
0002c 83 f8 0a cmp eax, 10
|
|
0002f 77 6d ja SHORT $LN2@glfwSetWin
|
|
00031 4c 8d 15 00 00
|
|
00 00 lea r10, OFFSET FLAT:__ImageBase
|
|
00038 48 98 cdqe
|
|
0003a 41 8b 8c 82 00
|
|
00 00 00 mov ecx, DWORD PTR $LN15@glfwSetWin[r10+rax*4]
|
|
00042 49 03 ca add rcx, r10
|
|
00045 ff e1 jmp rcx
|
|
$LN5@glfwSetWin:
|
|
|
|
; 921 : {
|
|
; 922 : case GLFW_AUTO_ICONIFY:
|
|
; 923 : window->autoIconify = value;
|
|
|
|
00047 41 89 51 10 mov DWORD PTR [r9+16], edx
|
|
|
|
; 955 : }
|
|
|
|
0004b c3 ret 0
|
|
$LN6@glfwSetWin:
|
|
|
|
; 924 : return;
|
|
; 925 :
|
|
; 926 : case GLFW_RESIZABLE:
|
|
; 927 : window->resizable = value;
|
|
; 928 : if (!window->monitor)
|
|
|
|
0004c 49 83 79 50 00 cmp QWORD PTR [r9+80], 0
|
|
00051 41 89 51 08 mov DWORD PTR [r9+8], edx
|
|
00055 75 58 jne SHORT $LN1@glfwSetWin
|
|
|
|
; 929 : _glfw.platform.setWindowResizable(window, value);
|
|
|
|
00057 49 8b c9 mov rcx, r9
|
|
0005a 48 ff 25 f0 01
|
|
00 00 rex_jmp QWORD PTR _glfw+496
|
|
$LN8@glfwSetWin:
|
|
|
|
; 930 : return;
|
|
; 931 :
|
|
; 932 : case GLFW_DECORATED:
|
|
; 933 : window->decorated = value;
|
|
; 934 : if (!window->monitor)
|
|
|
|
00061 49 83 79 50 00 cmp QWORD PTR [r9+80], 0
|
|
00066 41 89 51 0c mov DWORD PTR [r9+12], edx
|
|
0006a 75 43 jne SHORT $LN1@glfwSetWin
|
|
|
|
; 935 : _glfw.platform.setWindowDecorated(window, value);
|
|
|
|
0006c 49 8b c9 mov rcx, r9
|
|
0006f 48 ff 25 f8 01
|
|
00 00 rex_jmp QWORD PTR _glfw+504
|
|
$LN10@glfwSetWin:
|
|
|
|
; 936 : return;
|
|
; 937 :
|
|
; 938 : case GLFW_FLOATING:
|
|
; 939 : window->floating = value;
|
|
; 940 : if (!window->monitor)
|
|
|
|
00076 49 83 79 50 00 cmp QWORD PTR [r9+80], 0
|
|
0007b 41 89 51 14 mov DWORD PTR [r9+20], edx
|
|
0007f 75 2e jne SHORT $LN1@glfwSetWin
|
|
|
|
; 941 : _glfw.platform.setWindowFloating(window, value);
|
|
|
|
00081 49 8b c9 mov rcx, r9
|
|
00084 48 ff 25 00 02
|
|
00 00 rex_jmp QWORD PTR _glfw+512
|
|
$LN12@glfwSetWin:
|
|
|
|
; 942 : return;
|
|
; 943 :
|
|
; 944 : case GLFW_FOCUS_ON_SHOW:
|
|
; 945 : window->focusOnShow = value;
|
|
|
|
0008b 41 89 51 18 mov DWORD PTR [r9+24], edx
|
|
|
|
; 955 : }
|
|
|
|
0008f c3 ret 0
|
|
$LN13@glfwSetWin:
|
|
|
|
; 946 : return;
|
|
; 947 :
|
|
; 948 : case GLFW_MOUSE_PASSTHROUGH:
|
|
; 949 : window->mousePassthrough = value;
|
|
; 950 : _glfw.platform.setWindowMousePassthrough(window, value);
|
|
|
|
00090 49 8b c9 mov rcx, r9
|
|
00093 41 89 51 1c mov DWORD PTR [r9+28], edx
|
|
00097 48 ff 25 10 02
|
|
00 00 rex_jmp QWORD PTR _glfw+528
|
|
$LN2@glfwSetWin:
|
|
|
|
; 951 : return;
|
|
; 952 : }
|
|
; 953 :
|
|
; 954 : _glfwInputError(GLFW_INVALID_ENUM, "Invalid window attribute 0x%08X", attrib);
|
|
|
|
0009e 48 8d 15 00 00
|
|
00 00 lea rdx, OFFSET FLAT:??_C@_0CA@KCGCFCEG@Invalid?5window?5attribute?50x?$CF08X@
|
|
000a5 b9 03 00 01 00 mov ecx, 65539 ; 00010003H
|
|
000aa e9 00 00 00 00 jmp _glfwInputError
|
|
$LN1@glfwSetWin:
|
|
|
|
; 955 : }
|
|
|
|
000af c3 ret 0
|
|
$LN15@glfwSetWin:
|
|
000b0 00 00 00 00 DD $LN6@glfwSetWin
|
|
000b4 00 00 00 00 DD $LN2@glfwSetWin
|
|
000b8 00 00 00 00 DD $LN8@glfwSetWin
|
|
000bc 00 00 00 00 DD $LN5@glfwSetWin
|
|
000c0 00 00 00 00 DD $LN10@glfwSetWin
|
|
000c4 00 00 00 00 DD $LN2@glfwSetWin
|
|
000c8 00 00 00 00 DD $LN2@glfwSetWin
|
|
000cc 00 00 00 00 DD $LN2@glfwSetWin
|
|
000d0 00 00 00 00 DD $LN2@glfwSetWin
|
|
000d4 00 00 00 00 DD $LN12@glfwSetWin
|
|
000d8 00 00 00 00 DD $LN13@glfwSetWin
|
|
glfwSetWindowAttrib ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwGetWindowMonitor
|
|
_TEXT SEGMENT
|
|
handle$ = 48
|
|
glfwGetWindowMonitor PROC ; COMDAT
|
|
|
|
; 958 : {
|
|
|
|
$LN5:
|
|
00000 48 83 ec 28 sub rsp, 40 ; 00000028H
|
|
|
|
; 959 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 960 : assert(window != NULL);
|
|
; 961 :
|
|
; 962 : _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
|
|
|
|
00004 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
0000b 75 13 jne SHORT $LN2@glfwGetWin
|
|
0000d 33 d2 xor edx, edx
|
|
0000f b9 01 00 01 00 mov ecx, 65537 ; 00010001H
|
|
00014 e8 00 00 00 00 call _glfwInputError
|
|
00019 33 c0 xor eax, eax
|
|
|
|
; 964 : }
|
|
|
|
0001b 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
0001f c3 ret 0
|
|
$LN2@glfwGetWin:
|
|
|
|
; 963 : return (GLFWmonitor*) window->monitor;
|
|
|
|
00020 48 8b 41 50 mov rax, QWORD PTR [rcx+80]
|
|
|
|
; 964 : }
|
|
|
|
00024 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
00028 c3 ret 0
|
|
glfwGetWindowMonitor ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwSetWindowMonitor
|
|
_TEXT SEGMENT
|
|
wh$ = 8
|
|
mh$ = 16
|
|
xpos$ = 24
|
|
ypos$ = 32
|
|
width$ = 40
|
|
height$ = 48
|
|
refreshRate$ = 56
|
|
glfwSetWindowMonitor PROC ; COMDAT
|
|
|
|
; 972 : _GLFWwindow* window = (_GLFWwindow*) wh;
|
|
; 973 : _GLFWmonitor* monitor = (_GLFWmonitor*) mh;
|
|
; 974 : assert(window != NULL);
|
|
; 975 : assert(width >= 0);
|
|
; 976 : assert(height >= 0);
|
|
; 977 :
|
|
; 978 : _GLFW_REQUIRE_INIT();
|
|
|
|
00000 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
00007 45 8b d1 mov r10d, r9d
|
|
0000a 45 8b d8 mov r11d, r8d
|
|
0000d 75 0c jne SHORT $LN2@glfwSetWin
|
|
0000f 33 d2 xor edx, edx
|
|
00011 b9 01 00 01 00 mov ecx, 65537 ; 00010001H
|
|
00016 e9 00 00 00 00 jmp _glfwInputError
|
|
$LN2@glfwSetWin:
|
|
|
|
; 979 :
|
|
; 980 : if (width <= 0 || height <= 0)
|
|
|
|
0001b 44 8b 44 24 28 mov r8d, DWORD PTR width$[rsp]
|
|
00020 44 8b 4c 24 30 mov r9d, DWORD PTR height$[rsp]
|
|
00025 45 85 c0 test r8d, r8d
|
|
00028 7e 48 jle SHORT $LN4@glfwSetWin
|
|
0002a 45 85 c9 test r9d, r9d
|
|
0002d 7e 43 jle SHORT $LN4@glfwSetWin
|
|
|
|
; 983 : "Invalid window size %ix%i",
|
|
; 984 : width, height);
|
|
; 985 : return;
|
|
; 986 : }
|
|
; 987 :
|
|
; 988 : if (refreshRate < 0 && refreshRate != GLFW_DONT_CARE)
|
|
|
|
0002f 8b 44 24 38 mov eax, DWORD PTR refreshRate$[rsp]
|
|
00033 83 f8 fe cmp eax, -2
|
|
00036 7f 14 jg SHORT $LN5@glfwSetWin
|
|
|
|
; 989 : {
|
|
; 990 : _glfwInputError(GLFW_INVALID_VALUE,
|
|
|
|
00038 44 8b c0 mov r8d, eax
|
|
0003b 48 8d 15 00 00
|
|
00 00 lea rdx, OFFSET FLAT:??_C@_0BI@BFOJALMM@Invalid?5refresh?5rate?5?$CFi@
|
|
00042 b9 04 00 01 00 mov ecx, 65540 ; 00010004H
|
|
00047 e9 00 00 00 00 jmp _glfwInputError
|
|
$LN5@glfwSetWin:
|
|
|
|
; 991 : "Invalid refresh rate %i",
|
|
; 992 : refreshRate);
|
|
; 993 : return;
|
|
; 994 : }
|
|
; 995 :
|
|
; 996 : window->videoMode.width = width;
|
|
; 997 : window->videoMode.height = height;
|
|
; 998 : window->videoMode.refreshRate = refreshRate;
|
|
; 999 :
|
|
; 1000 : _glfw.platform.setWindowMonitor(window, monitor,
|
|
|
|
0004c 89 44 24 38 mov DWORD PTR refreshRate$[rsp], eax
|
|
00050 44 89 4c 24 30 mov DWORD PTR height$[rsp], r9d
|
|
00055 44 89 44 24 28 mov DWORD PTR width$[rsp], r8d
|
|
0005a 44 89 41 34 mov DWORD PTR [rcx+52], r8d
|
|
0005e 45 8b c3 mov r8d, r11d
|
|
00061 44 89 49 38 mov DWORD PTR [rcx+56], r9d
|
|
00065 45 8b ca mov r9d, r10d
|
|
00068 89 41 48 mov DWORD PTR [rcx+72], eax
|
|
0006b 48 ff 25 b0 01
|
|
00 00 rex_jmp QWORD PTR _glfw+432
|
|
$LN4@glfwSetWin:
|
|
|
|
; 981 : {
|
|
; 982 : _glfwInputError(GLFW_INVALID_VALUE,
|
|
|
|
00072 48 8d 15 00 00
|
|
00 00 lea rdx, OFFSET FLAT:??_C@_0BK@KJGCMOHN@Invalid?5window?5size?5?$CFix?$CFi@
|
|
00079 b9 04 00 01 00 mov ecx, 65540 ; 00010004H
|
|
0007e e9 00 00 00 00 jmp _glfwInputError
|
|
glfwSetWindowMonitor ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwSetWindowUserPointer
|
|
_TEXT SEGMENT
|
|
handle$ = 8
|
|
pointer$ = 16
|
|
glfwSetWindowUserPointer PROC ; COMDAT
|
|
|
|
; 1007 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 1008 : assert(window != NULL);
|
|
; 1009 :
|
|
; 1010 : _GLFW_REQUIRE_INIT();
|
|
|
|
00000 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
00007 75 0c jne SHORT $LN2@glfwSetWin
|
|
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@glfwSetWin:
|
|
|
|
; 1011 : window->userPointer = pointer;
|
|
|
|
00015 48 89 51 28 mov QWORD PTR [rcx+40], rdx
|
|
|
|
; 1012 : }
|
|
|
|
00019 c3 ret 0
|
|
glfwSetWindowUserPointer ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwGetWindowUserPointer
|
|
_TEXT SEGMENT
|
|
handle$ = 48
|
|
glfwGetWindowUserPointer PROC ; COMDAT
|
|
|
|
; 1015 : {
|
|
|
|
$LN5:
|
|
00000 48 83 ec 28 sub rsp, 40 ; 00000028H
|
|
|
|
; 1016 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 1017 : assert(window != NULL);
|
|
; 1018 :
|
|
; 1019 : _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
|
|
|
|
00004 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
0000b 75 13 jne SHORT $LN2@glfwGetWin
|
|
0000d 33 d2 xor edx, edx
|
|
0000f b9 01 00 01 00 mov ecx, 65537 ; 00010001H
|
|
00014 e8 00 00 00 00 call _glfwInputError
|
|
00019 33 c0 xor eax, eax
|
|
|
|
; 1021 : }
|
|
|
|
0001b 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
0001f c3 ret 0
|
|
$LN2@glfwGetWin:
|
|
|
|
; 1020 : return window->userPointer;
|
|
|
|
00020 48 8b 41 28 mov rax, QWORD PTR [rcx+40]
|
|
|
|
; 1021 : }
|
|
|
|
00024 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
00028 c3 ret 0
|
|
glfwGetWindowUserPointer ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwSetWindowPosCallback
|
|
_TEXT SEGMENT
|
|
handle$ = 48
|
|
cbfun$ = 56
|
|
glfwSetWindowPosCallback PROC ; COMDAT
|
|
|
|
; 1025 : {
|
|
|
|
$LN5:
|
|
00000 48 83 ec 28 sub rsp, 40 ; 00000028H
|
|
|
|
; 1026 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 1027 : assert(window != NULL);
|
|
; 1028 :
|
|
; 1029 : _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@glfwSetWin
|
|
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
|
|
|
|
; 1031 : return cbfun;
|
|
; 1032 : }
|
|
|
|
0001b 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
0001f c3 ret 0
|
|
$LN2@glfwSetWin:
|
|
|
|
; 1030 : _GLFW_SWAP(GLFWwindowposfun, window->callbacks.pos, cbfun);
|
|
|
|
00020 48 8b 81 d0 02
|
|
00 00 mov rax, QWORD PTR [rcx+720]
|
|
00027 48 89 91 d0 02
|
|
00 00 mov QWORD PTR [rcx+720], rdx
|
|
|
|
; 1031 : return cbfun;
|
|
; 1032 : }
|
|
|
|
0002e 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
00032 c3 ret 0
|
|
glfwSetWindowPosCallback ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwSetWindowSizeCallback
|
|
_TEXT SEGMENT
|
|
handle$ = 48
|
|
cbfun$ = 56
|
|
glfwSetWindowSizeCallback PROC ; COMDAT
|
|
|
|
; 1036 : {
|
|
|
|
$LN5:
|
|
00000 48 83 ec 28 sub rsp, 40 ; 00000028H
|
|
|
|
; 1037 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 1038 : assert(window != NULL);
|
|
; 1039 :
|
|
; 1040 : _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@glfwSetWin
|
|
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
|
|
|
|
; 1042 : return cbfun;
|
|
; 1043 : }
|
|
|
|
0001b 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
0001f c3 ret 0
|
|
$LN2@glfwSetWin:
|
|
|
|
; 1041 : _GLFW_SWAP(GLFWwindowsizefun, window->callbacks.size, cbfun);
|
|
|
|
00020 48 8b 81 d8 02
|
|
00 00 mov rax, QWORD PTR [rcx+728]
|
|
00027 48 89 91 d8 02
|
|
00 00 mov QWORD PTR [rcx+728], rdx
|
|
|
|
; 1042 : return cbfun;
|
|
; 1043 : }
|
|
|
|
0002e 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
00032 c3 ret 0
|
|
glfwSetWindowSizeCallback ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwSetWindowCloseCallback
|
|
_TEXT SEGMENT
|
|
handle$ = 48
|
|
cbfun$ = 56
|
|
glfwSetWindowCloseCallback PROC ; COMDAT
|
|
|
|
; 1047 : {
|
|
|
|
$LN5:
|
|
00000 48 83 ec 28 sub rsp, 40 ; 00000028H
|
|
|
|
; 1048 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 1049 : assert(window != NULL);
|
|
; 1050 :
|
|
; 1051 : _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@glfwSetWin
|
|
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
|
|
|
|
; 1053 : return cbfun;
|
|
; 1054 : }
|
|
|
|
0001b 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
0001f c3 ret 0
|
|
$LN2@glfwSetWin:
|
|
|
|
; 1052 : _GLFW_SWAP(GLFWwindowclosefun, window->callbacks.close, cbfun);
|
|
|
|
00020 48 8b 81 e0 02
|
|
00 00 mov rax, QWORD PTR [rcx+736]
|
|
00027 48 89 91 e0 02
|
|
00 00 mov QWORD PTR [rcx+736], rdx
|
|
|
|
; 1053 : return cbfun;
|
|
; 1054 : }
|
|
|
|
0002e 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
00032 c3 ret 0
|
|
glfwSetWindowCloseCallback ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwSetWindowRefreshCallback
|
|
_TEXT SEGMENT
|
|
handle$ = 48
|
|
cbfun$ = 56
|
|
glfwSetWindowRefreshCallback PROC ; COMDAT
|
|
|
|
; 1058 : {
|
|
|
|
$LN5:
|
|
00000 48 83 ec 28 sub rsp, 40 ; 00000028H
|
|
|
|
; 1059 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 1060 : assert(window != NULL);
|
|
; 1061 :
|
|
; 1062 : _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@glfwSetWin
|
|
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
|
|
|
|
; 1064 : return cbfun;
|
|
; 1065 : }
|
|
|
|
0001b 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
0001f c3 ret 0
|
|
$LN2@glfwSetWin:
|
|
|
|
; 1063 : _GLFW_SWAP(GLFWwindowrefreshfun, window->callbacks.refresh, cbfun);
|
|
|
|
00020 48 8b 81 e8 02
|
|
00 00 mov rax, QWORD PTR [rcx+744]
|
|
00027 48 89 91 e8 02
|
|
00 00 mov QWORD PTR [rcx+744], rdx
|
|
|
|
; 1064 : return cbfun;
|
|
; 1065 : }
|
|
|
|
0002e 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
00032 c3 ret 0
|
|
glfwSetWindowRefreshCallback ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwSetWindowFocusCallback
|
|
_TEXT SEGMENT
|
|
handle$ = 48
|
|
cbfun$ = 56
|
|
glfwSetWindowFocusCallback PROC ; COMDAT
|
|
|
|
; 1069 : {
|
|
|
|
$LN5:
|
|
00000 48 83 ec 28 sub rsp, 40 ; 00000028H
|
|
|
|
; 1070 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 1071 : assert(window != NULL);
|
|
; 1072 :
|
|
; 1073 : _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@glfwSetWin
|
|
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
|
|
|
|
; 1075 : return cbfun;
|
|
; 1076 : }
|
|
|
|
0001b 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
0001f c3 ret 0
|
|
$LN2@glfwSetWin:
|
|
|
|
; 1074 : _GLFW_SWAP(GLFWwindowfocusfun, window->callbacks.focus, cbfun);
|
|
|
|
00020 48 8b 81 f0 02
|
|
00 00 mov rax, QWORD PTR [rcx+752]
|
|
00027 48 89 91 f0 02
|
|
00 00 mov QWORD PTR [rcx+752], rdx
|
|
|
|
; 1075 : return cbfun;
|
|
; 1076 : }
|
|
|
|
0002e 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
00032 c3 ret 0
|
|
glfwSetWindowFocusCallback ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwSetWindowIconifyCallback
|
|
_TEXT SEGMENT
|
|
handle$ = 48
|
|
cbfun$ = 56
|
|
glfwSetWindowIconifyCallback PROC ; COMDAT
|
|
|
|
; 1080 : {
|
|
|
|
$LN5:
|
|
00000 48 83 ec 28 sub rsp, 40 ; 00000028H
|
|
|
|
; 1081 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 1082 : assert(window != NULL);
|
|
; 1083 :
|
|
; 1084 : _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@glfwSetWin
|
|
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
|
|
|
|
; 1086 : return cbfun;
|
|
; 1087 : }
|
|
|
|
0001b 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
0001f c3 ret 0
|
|
$LN2@glfwSetWin:
|
|
|
|
; 1085 : _GLFW_SWAP(GLFWwindowiconifyfun, window->callbacks.iconify, cbfun);
|
|
|
|
00020 48 8b 81 f8 02
|
|
00 00 mov rax, QWORD PTR [rcx+760]
|
|
00027 48 89 91 f8 02
|
|
00 00 mov QWORD PTR [rcx+760], rdx
|
|
|
|
; 1086 : return cbfun;
|
|
; 1087 : }
|
|
|
|
0002e 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
00032 c3 ret 0
|
|
glfwSetWindowIconifyCallback ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwSetWindowMaximizeCallback
|
|
_TEXT SEGMENT
|
|
handle$ = 48
|
|
cbfun$ = 56
|
|
glfwSetWindowMaximizeCallback PROC ; COMDAT
|
|
|
|
; 1091 : {
|
|
|
|
$LN5:
|
|
00000 48 83 ec 28 sub rsp, 40 ; 00000028H
|
|
|
|
; 1092 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 1093 : assert(window != NULL);
|
|
; 1094 :
|
|
; 1095 : _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@glfwSetWin
|
|
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
|
|
|
|
; 1097 : return cbfun;
|
|
; 1098 : }
|
|
|
|
0001b 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
0001f c3 ret 0
|
|
$LN2@glfwSetWin:
|
|
|
|
; 1096 : _GLFW_SWAP(GLFWwindowmaximizefun, window->callbacks.maximize, cbfun);
|
|
|
|
00020 48 8b 81 00 03
|
|
00 00 mov rax, QWORD PTR [rcx+768]
|
|
00027 48 89 91 00 03
|
|
00 00 mov QWORD PTR [rcx+768], rdx
|
|
|
|
; 1097 : return cbfun;
|
|
; 1098 : }
|
|
|
|
0002e 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
00032 c3 ret 0
|
|
glfwSetWindowMaximizeCallback ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwSetFramebufferSizeCallback
|
|
_TEXT SEGMENT
|
|
handle$ = 48
|
|
cbfun$ = 56
|
|
glfwSetFramebufferSizeCallback PROC ; COMDAT
|
|
|
|
; 1102 : {
|
|
|
|
$LN5:
|
|
00000 48 83 ec 28 sub rsp, 40 ; 00000028H
|
|
|
|
; 1103 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 1104 : assert(window != NULL);
|
|
; 1105 :
|
|
; 1106 : _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@glfwSetFra
|
|
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
|
|
|
|
; 1108 : return cbfun;
|
|
; 1109 : }
|
|
|
|
0001b 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
0001f c3 ret 0
|
|
$LN2@glfwSetFra:
|
|
|
|
; 1107 : _GLFW_SWAP(GLFWframebuffersizefun, window->callbacks.fbsize, cbfun);
|
|
|
|
00020 48 8b 81 08 03
|
|
00 00 mov rax, QWORD PTR [rcx+776]
|
|
00027 48 89 91 08 03
|
|
00 00 mov QWORD PTR [rcx+776], rdx
|
|
|
|
; 1108 : return cbfun;
|
|
; 1109 : }
|
|
|
|
0002e 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
00032 c3 ret 0
|
|
glfwSetFramebufferSizeCallback ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwSetWindowContentScaleCallback
|
|
_TEXT SEGMENT
|
|
handle$ = 48
|
|
cbfun$ = 56
|
|
glfwSetWindowContentScaleCallback PROC ; COMDAT
|
|
|
|
; 1113 : {
|
|
|
|
$LN5:
|
|
00000 48 83 ec 28 sub rsp, 40 ; 00000028H
|
|
|
|
; 1114 : _GLFWwindow* window = (_GLFWwindow*) handle;
|
|
; 1115 : assert(window != NULL);
|
|
; 1116 :
|
|
; 1117 : _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@glfwSetWin
|
|
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
|
|
|
|
; 1119 : return cbfun;
|
|
; 1120 : }
|
|
|
|
0001b 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
0001f c3 ret 0
|
|
$LN2@glfwSetWin:
|
|
|
|
; 1118 : _GLFW_SWAP(GLFWwindowcontentscalefun, window->callbacks.scale, cbfun);
|
|
|
|
00020 48 8b 81 10 03
|
|
00 00 mov rax, QWORD PTR [rcx+784]
|
|
00027 48 89 91 10 03
|
|
00 00 mov QWORD PTR [rcx+784], rdx
|
|
|
|
; 1119 : return cbfun;
|
|
; 1120 : }
|
|
|
|
0002e 48 83 c4 28 add rsp, 40 ; 00000028H
|
|
00032 c3 ret 0
|
|
glfwSetWindowContentScaleCallback ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwPollEvents
|
|
_TEXT SEGMENT
|
|
glfwPollEvents PROC ; COMDAT
|
|
|
|
; 1124 : _GLFW_REQUIRE_INIT();
|
|
|
|
00000 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
00007 75 0c jne SHORT $LN2@glfwPollEv
|
|
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@glfwPollEv:
|
|
|
|
; 1125 : _glfw.platform.pollEvents();
|
|
|
|
00015 48 ff 25 18 02
|
|
00 00 rex_jmp QWORD PTR _glfw+536
|
|
glfwPollEvents ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwWaitEvents
|
|
_TEXT SEGMENT
|
|
glfwWaitEvents PROC ; COMDAT
|
|
|
|
; 1130 : _GLFW_REQUIRE_INIT();
|
|
|
|
00000 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
00007 75 0c jne SHORT $LN2@glfwWaitEv
|
|
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@glfwWaitEv:
|
|
|
|
; 1131 : _glfw.platform.waitEvents();
|
|
|
|
00015 48 ff 25 20 02
|
|
00 00 rex_jmp QWORD PTR _glfw+544
|
|
glfwWaitEvents ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwWaitEventsTimeout
|
|
_TEXT SEGMENT
|
|
timeout$ = 8
|
|
glfwWaitEventsTimeout PROC ; COMDAT
|
|
|
|
; 1136 : _GLFW_REQUIRE_INIT();
|
|
|
|
00000 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
00007 0f 28 d0 movaps xmm2, xmm0
|
|
0000a 75 0c jne SHORT $LN2@glfwWaitEv
|
|
0000c 33 d2 xor edx, edx
|
|
0000e b9 01 00 01 00 mov ecx, 65537 ; 00010001H
|
|
00013 e9 00 00 00 00 jmp _glfwInputError
|
|
$LN2@glfwWaitEv:
|
|
|
|
; 1137 : assert(timeout == timeout);
|
|
; 1138 : assert(timeout >= 0.0);
|
|
; 1139 : assert(timeout <= DBL_MAX);
|
|
; 1140 :
|
|
; 1141 : if (timeout != timeout || timeout < 0.0 || timeout > DBL_MAX)
|
|
|
|
00018 66 0f 2e d2 ucomisd xmm2, xmm2
|
|
0001c 7a 1d jp SHORT $LN4@glfwWaitEv
|
|
0001e 0f 57 c0 xorps xmm0, xmm0
|
|
00021 66 0f 2f c2 comisd xmm0, xmm2
|
|
00025 77 14 ja SHORT $LN4@glfwWaitEv
|
|
00027 66 0f 2f 15 00
|
|
00 00 00 comisd xmm2, QWORD PTR __real@7fefffffffffffff
|
|
0002f 77 0a ja SHORT $LN4@glfwWaitEv
|
|
|
|
; 1144 : return;
|
|
; 1145 : }
|
|
; 1146 :
|
|
; 1147 : _glfw.platform.waitEventsTimeout(timeout);
|
|
|
|
00031 0f 28 c2 movaps xmm0, xmm2
|
|
00034 48 ff 25 28 02
|
|
00 00 rex_jmp QWORD PTR _glfw+552
|
|
$LN4@glfwWaitEv:
|
|
|
|
; 1142 : {
|
|
; 1143 : _glfwInputError(GLFW_INVALID_VALUE, "Invalid time %f", timeout);
|
|
|
|
0003b 66 49 0f 7e d0 movq r8, xmm2
|
|
00040 48 8d 15 00 00
|
|
00 00 lea rdx, OFFSET FLAT:??_C@_0BA@KMGHNAFM@Invalid?5time?5?$CFf@
|
|
00047 b9 04 00 01 00 mov ecx, 65540 ; 00010004H
|
|
0004c e9 00 00 00 00 jmp _glfwInputError
|
|
glfwWaitEventsTimeout ENDP
|
|
_TEXT ENDS
|
|
; Function compile flags: /Ogtpy
|
|
; File D:\NitloadIndustry\Ñо¿ÏîÄ¿\1-Flagship\TH2020\ProjectFile\Ô´´úÂë\StgSharpGraphic\code\glfw\window.c
|
|
; COMDAT glfwPostEmptyEvent
|
|
_TEXT SEGMENT
|
|
glfwPostEmptyEvent PROC ; COMDAT
|
|
|
|
; 1152 : _GLFW_REQUIRE_INIT();
|
|
|
|
00000 83 3d 00 00 00
|
|
00 00 cmp DWORD PTR _glfw, 0
|
|
00007 75 0c jne SHORT $LN2@glfwPostEm
|
|
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@glfwPostEm:
|
|
|
|
; 1153 : _glfw.platform.postEmptyEvent();
|
|
|
|
00015 48 ff 25 30 02
|
|
00 00 rex_jmp QWORD PTR _glfw+560
|
|
glfwPostEmptyEvent ENDP
|
|
_TEXT ENDS
|
|
END
|