mirror of
https://github.com/hajimehoshi/ebiten.git
synced 2024-11-10 13:07:26 +01:00
1935 lines
71 KiB
Go
1935 lines
71 KiB
Go
// Copyright 2022 The Ebiten Authors
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package glfwwin
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"runtime"
|
|
"syscall"
|
|
"unsafe"
|
|
|
|
"golang.org/x/sys/windows"
|
|
)
|
|
|
|
// math.MaxUint was added at Go 1.17. See https://github.com/golang/go/issues/28538
|
|
const (
|
|
intSize = 32 << (^uint(0) >> 63)
|
|
)
|
|
|
|
// For the definitions, see https://github.com/wine-mirror/wine
|
|
const (
|
|
_BI_BITFIELDS = 3
|
|
_CCHDEVICENAME = 32
|
|
_CCHFORMNAME = 32
|
|
_CDS_TEST = 0x00000002
|
|
_CDS_FULLSCREEN = 0x00000004
|
|
_CS_HREDRAW = 0x00000002
|
|
_CS_OWNDC = 0x00000020
|
|
_CS_VREDRAW = 0x00000001
|
|
_CW_USEDEFAULT = int32(^0x7fffffff)
|
|
_DBT_DEVTYP_DEVICEINTERFACE = 0x00000005
|
|
_DEVICE_NOTIFY_WINDOW_HANDLE = 0x00000000
|
|
_DIB_RGB_COLORS = 0
|
|
_DISP_CHANGE_SUCCESSFUL = 0
|
|
_DISP_CHANGE_RESTART = 1
|
|
_DISP_CHANGE_FAILED = -1
|
|
_DISP_CHANGE_BADMODE = -2
|
|
_DISP_CHANGE_NOTUPDATED = -3
|
|
_DISP_CHANGE_BADFLAGS = -4
|
|
_DISP_CHANGE_BADPARAM = -5
|
|
_DISP_CHANGE_BADDUALVIEW = -6
|
|
_DISPLAY_DEVICE_ACTIVE = 0x00000001
|
|
_DISPLAY_DEVICE_MODESPRUNED = 0x08000000
|
|
_DISPLAY_DEVICE_PRIMARY_DEVICE = 0x00000004
|
|
_DM_BITSPERPEL = 0x00040000
|
|
_DM_PELSWIDTH = 0x00080000
|
|
_DM_PELSHEIGHT = 0x00100000
|
|
_DM_DISPLAYFREQUENCY = 0x00400000
|
|
_DWM_BB_BLURREGION = 0x00000002
|
|
_DWM_BB_ENABLE = 0x00000001
|
|
_EDS_ROTATEDMODE = 0x00000004
|
|
_ENUM_CURRENT_SETTINGS uint32 = 0xffffffff
|
|
_GCLP_HICON = -14
|
|
_GCLP_HICONSM = -34
|
|
_GWL_EXSTYLE = -20
|
|
_GWL_STYLE = -16
|
|
_HTCLIENT = 1
|
|
_HORZSIZE = 4
|
|
_HWND_NOTOPMOST windows.HWND = (1 << intSize) - 2
|
|
_HWND_TOP windows.HWND = 0
|
|
_HWND_TOPMOST windows.HWND = (1 << intSize) - 1
|
|
_ICON_BIG = 1
|
|
_ICON_SMALL = 0
|
|
_IDC_ARROW = 32512
|
|
_IDI_APPLICATION = 32512
|
|
_IMAGE_CURSOR = 2
|
|
_IMAGE_ICON = 1
|
|
_KF_ALTDOWN = 0x2000
|
|
_KF_DLGMODE = 0x0800
|
|
_KF_EXTENDED = 0x0100
|
|
_KF_MENUMODE = 0x1000
|
|
_KF_REPEAT = 0x4000
|
|
_KF_UP = 0x8000
|
|
_LOGPIXELSX = 88
|
|
_LOGPIXELSY = 90
|
|
_LR_DEFAULTSIZE = 0x0040
|
|
_LR_SHARED = 0x8000
|
|
_LWA_ALPHA = 0x00000002
|
|
_MAPVK_VK_TO_VSC = 0
|
|
_MAPVK_VSC_TO_VK = 1
|
|
_MONITOR_DEFAULTTONEAREST = 0x00000002
|
|
_MOUSE_MOVE_ABSOLUTE = 0x01
|
|
_MSGFLT_ALLOW = 1
|
|
_OCR_CROSS = 32515
|
|
_OCR_HAND = 32649
|
|
_OCR_IBEAM = 32513
|
|
_OCR_NORMAL = 32512
|
|
_OCR_SIZENS = 32645
|
|
_OCR_SIZEWE = 32644
|
|
_PM_NOREMOVE = 0x0000
|
|
_PM_REMOVE = 0x0001
|
|
_PFD_DRAW_TO_WINDOW = 0x00000004
|
|
_PFD_DOUBLEBUFFER = 0x00000001
|
|
_PFD_GENERIC_ACCELERATED = 0x00001000
|
|
_PFD_GENERIC_FORMAT = 0x00000040
|
|
_PFD_STEREO = 0x00000002
|
|
_PFD_SUPPORT_OPENGL = 0x00000020
|
|
_PFD_TYPE_RGBA = 0
|
|
_QS_ALLEVENTS = _QS_INPUT | _QS_POSTMESSAGE | _QS_TIMER | _QS_PAINT | _QS_HOTKEY
|
|
_QS_HOTKEY = 0x0080
|
|
_QS_INPUT = _QS_MOUSE | _QS_KEY | _QS_RAWINPUT
|
|
_QS_KEY = 0x0001
|
|
_QS_MOUSE = _QS_MOUSEMOVE | _QS_MOUSEBUTTON
|
|
_QS_MOUSEBUTTON = 0x0004
|
|
_QS_MOUSEMOVE = 0x0002
|
|
_QS_PAINT = 0x0020
|
|
_QS_POSTMESSAGE = 0x0008
|
|
_QS_RAWINPUT = 0x0400
|
|
_QS_TIMER = 0x0010
|
|
_RID_INPUT = 0x10000003
|
|
_RIDEV_REMOVE = 0x00000001
|
|
_SC_KEYMENU = 0xf100
|
|
_SC_MONITORPOWER = 0xf170
|
|
_SC_SCREENSAVE = 0xf140
|
|
_SIZE_MAXIMIZED = 2
|
|
_SIZE_MINIMIZED = 1
|
|
_SIZE_RESTORED = 0
|
|
_SM_CXICON = 11
|
|
_SM_CXSMICON = 49
|
|
_SM_CYCAPTION = 4
|
|
_SM_CYICON = 12
|
|
_SM_CYSMICON = 50
|
|
_SPI_GETFOREGROUNDLOCKTIMEOUT = 0x2000
|
|
_SPI_GETMOUSETRAILS = 94
|
|
_SPI_SETFOREGROUNDLOCKTIMEOUT = 0x2001
|
|
_SPI_SETMOUSETRAILS = 93
|
|
_SPIF_SENDCHANGE = _SPIF_SENDWININICHANGE
|
|
_SPIF_SENDWININICHANGE = 2
|
|
_SW_HIDE = 0
|
|
_SW_MAXIMIZE = _SW_SHOWMAXIMIZED
|
|
_SW_MINIMIZE = 6
|
|
_SW_RESTORE = 9
|
|
_SW_SHOWNA = 8
|
|
_SW_SHOWMAXIMIZED = 3
|
|
_SWP_FRAMECHANGED = 0x0020
|
|
_SWP_NOACTIVATE = 0x0010
|
|
_SWP_NOCOPYBITS = 0x0100
|
|
_SWP_NOMOVE = 0x0002
|
|
_SWP_NOOWNERZORDER = 0x0200
|
|
_SWP_NOSIZE = 0x0001
|
|
_SWP_NOZORDER = 0x0004
|
|
_SWP_SHOWWINDOW = 0x0040
|
|
_TLS_OUT_OF_INDEXES uint32 = 0xffffffff
|
|
_TME_LEAVE = 0x00000002
|
|
_UNICODE_NOCHAR = 0xffff
|
|
_USER_DEFAULT_SCREEN_DPI = 96
|
|
_VER_BUILDNUMBER = 0x00000004
|
|
_VER_GREATER_EQUAL = 3
|
|
_VER_MAJORVERSION = 0x00000002
|
|
_VER_MINORVERSION = 0x00000001
|
|
_VER_SERVICEPACKMAJOR = 0x00000020
|
|
_VERTSIZE = 6
|
|
_VK_ADD = 0x6B
|
|
_VK_CAPITAL = 0x14
|
|
_VK_CONTROL = 0x11
|
|
_VK_DECIMAL = 0x6E
|
|
_VK_DIVIDE = 0x6F
|
|
_VK_LSHIFT = 0xA0
|
|
_VK_LWIN = 0x5B
|
|
_VK_MENU = 0x12
|
|
_VK_MULTIPLY = 0x6A
|
|
_VK_NUMLOCK = 0x90
|
|
_VK_NUMPAD0 = 0x60
|
|
_VK_NUMPAD1 = 0x61
|
|
_VK_NUMPAD2 = 0x62
|
|
_VK_NUMPAD3 = 0x63
|
|
_VK_NUMPAD4 = 0x64
|
|
_VK_NUMPAD5 = 0x65
|
|
_VK_NUMPAD6 = 0x66
|
|
_VK_NUMPAD7 = 0x67
|
|
_VK_NUMPAD8 = 0x68
|
|
_VK_NUMPAD9 = 0x69
|
|
_VK_PROCESSKEY = 0xE5
|
|
_VK_RSHIFT = 0xA1
|
|
_VK_RWIN = 0x5C
|
|
_VK_SHIFT = 0x10
|
|
_VK_SNAPSHOT = 0x2C
|
|
_VK_SUBTRACT = 0x6D
|
|
_WAIT_FAILED = 0xffffffff
|
|
_WHEEL_DELTA = 120
|
|
_WGL_ACCUM_BITS_ARB = 0x201D
|
|
_WGL_ACCELERATION_ARB = 0x2003
|
|
_WGL_ACCUM_ALPHA_BITS_ARB = 0x2021
|
|
_WGL_ACCUM_BLUE_BITS_ARB = 0x2020
|
|
_WGL_ACCUM_GREEN_BITS_ARB = 0x201F
|
|
_WGL_ACCUM_RED_BITS_ARB = 0x201E
|
|
_WGL_AUX_BUFFERS_ARB = 0x2024
|
|
_WGL_ALPHA_BITS_ARB = 0x201B
|
|
_WGL_ALPHA_SHIFT_ARB = 0x201C
|
|
_WGL_BLUE_BITS_ARB = 0x2019
|
|
_WGL_BLUE_SHIFT_ARB = 0x201A
|
|
_WGL_COLOR_BITS_ARB = 0x2014
|
|
_WGL_COLORSPACE_EXT = 0x309D
|
|
_WGL_COLORSPACE_SRGB_EXT = 0x3089
|
|
_WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB = 0x00000002
|
|
_WGL_CONTEXT_CORE_PROFILE_BIT_ARB = 0x00000001
|
|
_WGL_CONTEXT_DEBUG_BIT_ARB = 0x0001
|
|
_WGL_CONTEXT_ES2_PROFILE_BIT_EXT = 0x00000004
|
|
_WGL_CONTEXT_FLAGS_ARB = 0x2094
|
|
_WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB = 0x0002
|
|
_WGL_CONTEXT_MAJOR_VERSION_ARB = 0x2091
|
|
_WGL_CONTEXT_MINOR_VERSION_ARB = 0x2092
|
|
_WGL_CONTEXT_OPENGL_NO_ERROR_ARB = 0x31B3
|
|
_WGL_CONTEXT_PROFILE_MASK_ARB = 0x9126
|
|
_WGL_CONTEXT_RELEASE_BEHAVIOR_ARB = 0x2097
|
|
_WGL_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB = 0x0000
|
|
_WGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB = 0x2098
|
|
_WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB = 0x8256
|
|
_WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB = 0x00000004
|
|
_WGL_DEPTH_BITS_ARB = 0x2022
|
|
_WGL_DRAW_TO_BITMAP_ARB = 0x2002
|
|
_WGL_DRAW_TO_WINDOW_ARB = 0x2001
|
|
_WGL_DOUBLE_BUFFER_ARB = 0x2011
|
|
_WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB = 0x20A9
|
|
_WGL_GREEN_BITS_ARB = 0x2017
|
|
_WGL_GREEN_SHIFT_ARB = 0x2018
|
|
_WGL_LOSE_CONTEXT_ON_RESET_ARB = 0x8252
|
|
_WGL_NEED_PALETTE_ARB = 0x2004
|
|
_WGL_NEED_SYSTEM_PALETTE_ARB = 0x2005
|
|
_WGL_NO_ACCELERATION_ARB = 0x2025
|
|
_WGL_NO_RESET_NOTIFICATION_ARB = 0x8261
|
|
_WGL_NUMBER_OVERLAYS_ARB = 0x2008
|
|
_WGL_NUMBER_PIXEL_FORMATS_ARB = 0x2000
|
|
_WGL_NUMBER_UNDERLAYS_ARB = 0x2009
|
|
_WGL_PIXEL_TYPE_ARB = 0x2013
|
|
_WGL_RED_BITS_ARB = 0x2015
|
|
_WGL_RED_SHIFT_ARB = 0x2016
|
|
_WGL_SAMPLES_ARB = 0x2042
|
|
_WGL_SHARE_ACCUM_ARB = 0x200E
|
|
_WGL_SHARE_DEPTH_ARB = 0x200C
|
|
_WGL_SHARE_STENCIL_ARB = 0x200D
|
|
_WGL_STENCIL_BITS_ARB = 0x2023
|
|
_WGL_STEREO_ARB = 0x2012
|
|
_WGL_SUPPORT_GDI_ARB = 0x200F
|
|
_WGL_SUPPORT_OPENGL_ARB = 0x2010
|
|
_WGL_SWAP_LAYER_BUFFERS_ARB = 0x2006
|
|
_WGL_SWAP_METHOD_ARB = 0x2007
|
|
_WGL_TRANSPARENT_ARB = 0x200A
|
|
_WGL_TRANSPARENT_ALPHA_VALUE_ARB = 0x203A
|
|
_WGL_TRANSPARENT_BLUE_VALUE_ARB = 0x2039
|
|
_WGL_TRANSPARENT_GREEN_VALUE_ARB = 0x2038
|
|
_WGL_TRANSPARENT_INDEX_VALUE_ARB = 0x203B
|
|
_WGL_TRANSPARENT_RED_VALUE_ARB = 0x2037
|
|
_WGL_TYPE_RGBA_ARB = 0x202B
|
|
_WIN32_WINNT_VISTA = 0x0600
|
|
_WIN32_WINNT_WIN7 = 0x0601
|
|
_WIN32_WINNT_WIN8 = 0x0602
|
|
_WIN32_WINNT_WINBLUE = 0x0603
|
|
_WIN32_WINNT_WINXP = 0x0501
|
|
_WM_CAPTURECHANGED = 0x0215
|
|
_WM_CHAR = 0x0102
|
|
_WM_CLOSE = 0x0010
|
|
_WM_COPYDATA = 0x004a
|
|
_WM_COPYGLOBALDATA = 0x0049
|
|
_WM_DISPLAYCHANGE = 0x007e
|
|
_WM_DPICHANGED = 0x02e0
|
|
_WM_DROPFILES = 0x0233
|
|
_WM_DWMCOMPOSITIONCHANGED = 0x031E
|
|
_WM_DWMCOLORIZATIONCOLORCHANGED = 0x0320
|
|
_WM_ENTERMENULOOP = 0x0211
|
|
_WM_ENTERSIZEMOVE = 0x0231
|
|
_WM_ERASEBKGND = 0x0014
|
|
_WM_EXITMENULOOP = 0x0212
|
|
_WM_EXITSIZEMOVE = 0x0232
|
|
_WM_GETDPISCALEDSIZE = 0x02e4
|
|
_WM_GETMINMAXINFO = 0x0024
|
|
_WM_INPUT = 0x00ff
|
|
_WM_INPUTLANGCHANGE = 0x0051
|
|
_WM_KEYDOWN = _WM_KEYFIRST
|
|
_WM_KEYFIRST = 0x0100
|
|
_WM_KEYUP = 0x0101
|
|
_WM_KILLFOCUS = 0x0008
|
|
_WM_LBUTTONDOWN = 0x0201
|
|
_WM_LBUTTONUP = 0x0202
|
|
_WM_MBUTTONDOWN = 0x0207
|
|
_WM_MBUTTONUP = 0x0208
|
|
_WM_NCACTIVATE = 0x0086
|
|
_WM_NCPAINT = 0x0085
|
|
_WM_NULL = 0x0000
|
|
_WM_MOUSEACTIVATE = 0x0021
|
|
_WM_MOUSEFIRST = 0x0200
|
|
_WM_MOUSEHWHEEL = 0x020E
|
|
_WM_MOUSELEAVE = 0x02A3
|
|
_WM_MOUSEMOVE = _WM_MOUSEFIRST
|
|
_WM_MOUSEWHEEL = 0x020A
|
|
_WM_MOVE = 0x0003
|
|
_WM_NCCREATE = 0x0081
|
|
_WM_PAINT = 0x000f
|
|
_WM_QUIT = 0x0012
|
|
_WM_RBUTTONDOWN = 0x0204
|
|
_WM_RBUTTONUP = 0x0205
|
|
_WM_SETCURSOR = 0x0020
|
|
_WM_SETFOCUS = 0x0007
|
|
_WM_SETICON = 0x0080
|
|
_WM_SIZE = 0x0005
|
|
_WM_SIZING = 0x0214
|
|
_WM_SYSCHAR = 0x0106
|
|
_WM_SYSCOMMAND = 0x0112
|
|
_WM_SYSKEYDOWN = 0x0104
|
|
_WM_SYSKEYUP = 0x0105
|
|
_WM_UNICHAR = 0x0109
|
|
_WM_XBUTTONDOWN = 0x020B
|
|
_WM_XBUTTONUP = 0x020C
|
|
_WMSZ_BOTTOM = 6
|
|
_WMSZ_BOTTOMLEFT = 7
|
|
_WMSZ_BOTTOMRIGHT = 8
|
|
_WMSZ_LEFT = 1
|
|
_WMSZ_RIGHT = 2
|
|
_WMSZ_TOP = 3
|
|
_WMSZ_TOPLEFT = 4
|
|
_WMSZ_TOPRIGHT = 5
|
|
_WS_BORDER = 0x00800000
|
|
_WS_CAPTION = _WS_BORDER | _WS_DLGFRAME
|
|
_WS_CLIPSIBLINGS = 0x04000000
|
|
_WS_CLIPCHILDREN = 0x02000000
|
|
_WS_DLGFRAME = 0x00400000
|
|
_WS_EX_APPWINDOW = 0x00040000
|
|
_WS_EX_CLIENTEDGE = 0x00000200
|
|
_WS_EX_LAYERED = 0x00080000
|
|
_WS_EX_OVERLAPPEDWINDOW = _WS_EX_WINDOWEDGE | _WS_EX_CLIENTEDGE
|
|
_WS_EX_TOPMOST = 0x00000008
|
|
_WS_EX_WINDOWEDGE = 0x00000100
|
|
_WS_MAXIMIZE = 0x01000000
|
|
_WS_MAXIMIZEBOX = 0x00010000
|
|
_WS_MINIMIZEBOX = 0x00020000
|
|
_WS_OVERLAPPED = 0x00000000
|
|
_WS_OVERLAPPEDWINDOW = _WS_OVERLAPPED | _WS_CAPTION | _WS_SYSMENU | _WS_THICKFRAME | _WS_MINIMIZEBOX | _WS_MAXIMIZEBOX
|
|
_WS_POPUP = 0x80000000
|
|
_WS_SYSMENU = 0x00080000
|
|
_WS_THICKFRAME = 0x00040000
|
|
_XBUTTON1 = 0x0001
|
|
)
|
|
|
|
type (
|
|
_ATOM uint16
|
|
_BOOL int32
|
|
_COLORREF uint32
|
|
_HBITMAP windows.Handle
|
|
_HBRUSH windows.Handle
|
|
_HCURSOR windows.Handle
|
|
_HDC windows.Handle
|
|
_HDEVNOTIFY windows.Handle
|
|
_HDROP windows.Handle
|
|
_HGDIOBJ windows.Handle
|
|
_HGLRC windows.Handle
|
|
_HICON windows.Handle
|
|
_HINSTANCE windows.Handle
|
|
_HMENU windows.Handle
|
|
_HMODULE windows.Handle
|
|
_HMONITOR windows.Handle
|
|
_HRAWINPUT windows.Handle
|
|
_HRGN windows.Handle
|
|
_LPARAM uintptr
|
|
_LRESULT uintptr
|
|
_WNDPROC uintptr
|
|
_WPARAM uintptr
|
|
)
|
|
|
|
func _GET_X_LPARAM(lp _LPARAM) int {
|
|
return int(_LOWORD(uint32(lp)))
|
|
}
|
|
|
|
func _GET_XBUTTON_WPARAM(wParam _WPARAM) uint16 {
|
|
return _HIWORD(uint32(wParam))
|
|
}
|
|
|
|
func _GET_Y_LPARAM(lp _LPARAM) int {
|
|
return int(_HIWORD(uint32(lp)))
|
|
}
|
|
func _HIBYTE(wValue uint16) byte {
|
|
return byte(wValue >> 8)
|
|
}
|
|
|
|
func _HIWORD(dwValue uint32) uint16 {
|
|
return uint16(dwValue >> 16)
|
|
}
|
|
|
|
func _LOBYTE(wValue uint16) byte {
|
|
return byte(wValue)
|
|
}
|
|
|
|
func _LOWORD(dwValue uint32) uint16 {
|
|
return uint16(dwValue)
|
|
}
|
|
|
|
type _DPI_AWARENESS_CONTEXT windows.Handle
|
|
|
|
const (
|
|
_DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2 _DPI_AWARENESS_CONTEXT = (1 << intSize) - 4
|
|
)
|
|
|
|
type _EXECUTION_STATE uint32
|
|
|
|
const (
|
|
_ES_CONTINUOUS _EXECUTION_STATE = 0x80000000
|
|
_ES_DISPLAY_REQUIRED _EXECUTION_STATE = 0x00000002
|
|
)
|
|
|
|
type _MONITOR_DPI_TYPE int32
|
|
|
|
const (
|
|
_MDT_EFFECTIVE_DPI _MONITOR_DPI_TYPE = 0
|
|
_MDT_ANGULAR_DPI _MONITOR_DPI_TYPE = 1
|
|
_MDT_RAW_DPI _MONITOR_DPI_TYPE = 2
|
|
_MDT_DEFAULT _MONITOR_DPI_TYPE = _MDT_EFFECTIVE_DPI
|
|
)
|
|
|
|
type _PROCESS_DPI_AWARENESS int32
|
|
|
|
const (
|
|
_PROCESS_DPI_UNAWARE _PROCESS_DPI_AWARENESS = 0
|
|
_PROCESS_SYSTEM_DPI_AWARE _PROCESS_DPI_AWARENESS = 1
|
|
_PROCESS_PER_MONITOR_DPI_AWARE _PROCESS_DPI_AWARENESS = 2
|
|
)
|
|
|
|
type _BITMAPV5HEADER struct {
|
|
bV5Size uint32
|
|
bV5Width int32
|
|
bV5Height int32
|
|
bV5Planes uint16
|
|
bV5BitCount uint16
|
|
bV5Compression uint32
|
|
bV5SizeImage uint32
|
|
bV5XPelsPerMeter int32
|
|
bV5YPelsPerMeter int32
|
|
bV5ClrUsed uint32
|
|
bV5ClrImportant uint32
|
|
bV5RedMask uint32
|
|
bV5GreenMask uint32
|
|
bV5BlueMask uint32
|
|
bV5AlphaMask uint32
|
|
bV5CSType uint32
|
|
bV5Endpoints _CIEXYZTRIPLE
|
|
bV5GammaRed uint32
|
|
bV5GammaGreen uint32
|
|
bV5GammaBlue uint32
|
|
bV5Intent uint32
|
|
bV5ProfileData uint32
|
|
bV5ProfileSize uint32
|
|
bV5Reserved uint32
|
|
}
|
|
|
|
type _CHANGEFILTERSTRUCT struct {
|
|
cbSize uint32
|
|
ExtStatus uint32
|
|
}
|
|
|
|
type _CIEXYZ struct {
|
|
ciexyzX _FXPT2DOT30
|
|
ciexyzY _FXPT2DOT30
|
|
ciexyzZ _FXPT2DOT30
|
|
}
|
|
|
|
type _CIEXYZTRIPLE struct {
|
|
ciexyzRed _CIEXYZ
|
|
ciexyzGreen _CIEXYZ
|
|
ciexyzBlue _CIEXYZ
|
|
}
|
|
|
|
type _CREATESTRUCTW struct {
|
|
lpCreateParams unsafe.Pointer
|
|
hInstance _HINSTANCE
|
|
hMenu _HMENU
|
|
hwndParent windows.HWND
|
|
cy int32
|
|
cx int32
|
|
y int32
|
|
x int32
|
|
style int32
|
|
lpszName *uint16
|
|
lpszClass *uint16
|
|
dwExStyle uint32
|
|
}
|
|
|
|
type _DEV_BROADCAST_DEVICEINTERFACE_W struct {
|
|
dbcc_size uint32
|
|
dbcc_devicetype uint32
|
|
dbcc_reserved uint32
|
|
dbcc_classguid windows.GUID
|
|
dbcc_name [1]uint16
|
|
}
|
|
|
|
type _DEVMODEW struct {
|
|
dmDeviceName [_CCHDEVICENAME]uint16
|
|
dmSpecVersion uint16
|
|
dmDriverVersion uint16
|
|
dmSize uint16
|
|
dmDriverExtra uint16
|
|
dmFields uint32
|
|
dmPosition _POINTL
|
|
_ [8]byte // the rest of union
|
|
dmColor int16
|
|
dmDuplex int16
|
|
dmYResolution int16
|
|
dmTTOption int16
|
|
dmCollate int16
|
|
dmFormName [_CCHFORMNAME]uint16
|
|
dmLogPixels uint16
|
|
dmBitsPerPel uint32
|
|
dmPelsWidth uint32
|
|
dmPelsHeight uint32
|
|
dmDisplayFlags uint32 // union with DWORD dmNup
|
|
dmDisplayFrequency uint32
|
|
dmICMMethod uint32
|
|
dmICMIntent uint32
|
|
dmMediaType uint32
|
|
dmDitherType uint32
|
|
dmReserved1 uint32
|
|
dmReserved2 uint32
|
|
dmPanningWidth uint32
|
|
dmPanningHeight uint32
|
|
}
|
|
|
|
type _DISPLAY_DEVICEW struct {
|
|
cb uint32
|
|
DeviceName [32]uint16
|
|
DeviceString [128]uint16
|
|
StateFlags uint32
|
|
DeviceID [128]uint16
|
|
DeviceKey [128]uint16
|
|
}
|
|
|
|
type _DWM_BLURBEHIND struct {
|
|
dwFlags uint32
|
|
fEnable int32
|
|
hRgnBlur _HRGN
|
|
fTransitionOnMaximized int32
|
|
}
|
|
|
|
type _FXPT2DOT30 int32
|
|
|
|
type _ICONINFO struct {
|
|
fIcon int32
|
|
xHotspot uint32
|
|
yHotspot uint32
|
|
hbmMask _HBITMAP
|
|
hbmColor _HBITMAP
|
|
}
|
|
|
|
type _MINMAXINFO struct {
|
|
ptReserved _POINT
|
|
ptMaxSize _POINT
|
|
ptMaxPosition _POINT
|
|
ptMinTrackSize _POINT
|
|
ptMaxTrackSize _POINT
|
|
}
|
|
|
|
type _MONITORINFO struct {
|
|
cbSize uint32
|
|
rcMonitor _RECT
|
|
rcWork _RECT
|
|
dwFlags uint32
|
|
}
|
|
|
|
type _MONITORINFOEXW struct {
|
|
cbSize uint32
|
|
rcMonitor _RECT
|
|
rcWork _RECT
|
|
dwFlags uint32
|
|
szDevice [_CCHDEVICENAME]uint16
|
|
}
|
|
|
|
type _MSG struct {
|
|
hwnd windows.HWND
|
|
message uint32
|
|
wParam _WPARAM
|
|
lParam _LPARAM
|
|
time uint32
|
|
pt _POINT
|
|
lPrivate uint32
|
|
}
|
|
|
|
type _OSVERSIONINFOEXW struct {
|
|
dwOSVersionInfoSize uint32
|
|
dwMajorVersion uint32
|
|
dwMinorVersion uint32
|
|
dwBuildNumber uint32
|
|
dwPlatformId uint32
|
|
szCSDVersion [128]uint16
|
|
wServicePackMajor uint16
|
|
wServicePackMinor uint16
|
|
wSuiteMask uint16
|
|
wProductType byte
|
|
wReserved byte
|
|
}
|
|
|
|
type _PIXELFORMATDESCRIPTOR struct {
|
|
nSize uint16
|
|
nVersion uint16
|
|
dwFlags uint32
|
|
iPixelType byte
|
|
cColorBits byte
|
|
cRedBits byte
|
|
cRedShift byte
|
|
cGreenBits byte
|
|
cGreenShift byte
|
|
cBlueBits byte
|
|
cBlueShift byte
|
|
cAlphaBits byte
|
|
cAlphaShift byte
|
|
cAccumBits byte
|
|
cAccumRedBits byte
|
|
cAccumGreenBits byte
|
|
cAccumBlueBits byte
|
|
cAccumAlphaBits byte
|
|
cDepthBits byte
|
|
cStencilBits byte
|
|
cAuxBuffers byte
|
|
iLayerType byte
|
|
bReserved byte
|
|
dwLayerMask uint32
|
|
dwVisibleMask uint32
|
|
dwDamageMask uint32
|
|
}
|
|
|
|
type _POINT struct {
|
|
x int32
|
|
y int32
|
|
}
|
|
|
|
type _POINTL struct {
|
|
x int32
|
|
y int32
|
|
}
|
|
|
|
type _RAWINPUT struct {
|
|
header _RAWINPUTHEADER
|
|
mouse _RAWMOUSE
|
|
|
|
// RAWMOUSE is the biggest among RAWHID, RAWKEYBOARD, and RAWMOUSE.
|
|
// Then, padding is not needed here.
|
|
}
|
|
|
|
type _RAWINPUTDEVICE struct {
|
|
usUsagePage uint16
|
|
usUsage uint16
|
|
dwFlags uint32
|
|
hwndTarget windows.HWND
|
|
}
|
|
|
|
type _RAWINPUTHEADER struct {
|
|
dwType uint32
|
|
dwSize uint32
|
|
hDevice windows.Handle
|
|
wParam uintptr
|
|
}
|
|
|
|
type _RAWMOUSE struct {
|
|
usFlags uint16
|
|
ulButtons uint32 // TODO: Check alignments
|
|
ulRawButtons uint32
|
|
lLastX int32
|
|
lLastY int32
|
|
ulExtraInformation uint32
|
|
}
|
|
|
|
type _RECT struct {
|
|
left int32
|
|
top int32
|
|
right int32
|
|
bottom int32
|
|
}
|
|
|
|
type _SIZE struct {
|
|
cx int32
|
|
cy int32
|
|
}
|
|
|
|
type _TRACKMOUSEEVENT struct {
|
|
cbSize uint32
|
|
dwFlags uint32
|
|
hwndTrack windows.HWND
|
|
dwHoverTime uint32
|
|
}
|
|
|
|
type _WINDOWPLACEMENT struct {
|
|
length uint32
|
|
flags uint32
|
|
showCmd uint32
|
|
ptMinPosition _POINT
|
|
ptMaxPosition _POINT
|
|
rcNormalPosition _RECT
|
|
rcDevice _RECT
|
|
}
|
|
|
|
type _WNDCLASSEXW struct {
|
|
cbSize uint32
|
|
style uint32
|
|
lpfnWndProc _WNDPROC
|
|
cbClsExtra int32
|
|
cbWndExtra int32
|
|
hInstance _HINSTANCE
|
|
hIcon _HICON
|
|
hCursor _HCURSOR
|
|
hbrBackground _HBRUSH
|
|
lpszMenuName *uint16
|
|
lpszClassName *uint16
|
|
hIconSm _HICON
|
|
}
|
|
|
|
var (
|
|
dwmapi = windows.NewLazySystemDLL("dwmapi.dll")
|
|
gdi32 = windows.NewLazySystemDLL("gdi32.dll")
|
|
kernel32 = windows.NewLazySystemDLL("kernel32.dll")
|
|
ntdll = windows.NewLazySystemDLL("ntdll.dll")
|
|
opengl32 = windows.NewLazySystemDLL("opengl32.dll")
|
|
shcore = windows.NewLazySystemDLL("shcore.dll")
|
|
shell32 = windows.NewLazySystemDLL("shell32.dll")
|
|
user32 = windows.NewLazySystemDLL("user32.dll")
|
|
|
|
procDwmEnableBlurBehindWindow = dwmapi.NewProc("DwmEnableBlurBehindWindow")
|
|
procDwmGetColorizationColor = dwmapi.NewProc("DwmGetColorizationColor")
|
|
procDwmFlush = dwmapi.NewProc("DwmFlush")
|
|
procDwmIsCompositionEnabled = dwmapi.NewProc("DwmIsCompositionEnabled")
|
|
|
|
procChoosePixelFormat = gdi32.NewProc("ChoosePixelFormat")
|
|
procCreateBitmap = gdi32.NewProc("CreateBitmap")
|
|
procCreateDCW = gdi32.NewProc("CreateDCW")
|
|
procCreateDIBSection = gdi32.NewProc("CreateDIBSection")
|
|
procCreateRectRgn = gdi32.NewProc("CreateRectRgn")
|
|
procDeleteDC = gdi32.NewProc("DeleteDC")
|
|
procDeleteObject = gdi32.NewProc("DeleteObject")
|
|
procDescribePixelFormat = gdi32.NewProc("DescribePixelFormat")
|
|
procGetDeviceCaps = gdi32.NewProc("GetDeviceCaps")
|
|
procSetPixelFormat = gdi32.NewProc("SetPixelFormat")
|
|
procSwapBuffers = gdi32.NewProc("SwapBuffers")
|
|
|
|
procGetModuleHandleW = kernel32.NewProc("GetModuleHandleW")
|
|
procSetThreadExecutionState = kernel32.NewProc("SetThreadExecutionState")
|
|
procTlsAlloc = kernel32.NewProc("TlsAlloc")
|
|
procTlsFree = kernel32.NewProc("TlsFree")
|
|
procTlsGetValue = kernel32.NewProc("TlsGetValue")
|
|
procTlsSetValue = kernel32.NewProc("TlsSetValue")
|
|
procVerSetConditionMask = kernel32.NewProc("VerSetConditionMask")
|
|
|
|
procRtlVerifyVersionInfo = ntdll.NewProc("RtlVerifyVersionInfo")
|
|
|
|
procWGLCreateContext = opengl32.NewProc("wglCreateContext")
|
|
procWGLDeleteContext = opengl32.NewProc("wglDeleteContext")
|
|
procWGLGetCurrentContext = opengl32.NewProc("wglGetCurrentContext")
|
|
procWGLGetCurrentDC = opengl32.NewProc("wglGetCurrentDC")
|
|
procWGLGetProcAddress = opengl32.NewProc("wglGetProcAddress")
|
|
procWGLMakeCurrent = opengl32.NewProc("wglMakeCurrent")
|
|
procWGLShareLists = opengl32.NewProc("wglShareLists")
|
|
|
|
// Extension functions should be obtained from wglGetProcAddress instead of opengl32.dll (#2101).
|
|
procWGLCreateContextAttribsARB uintptr
|
|
procWGLGetExtensionsStringARB uintptr
|
|
procWGLGetExtensionsStringEXT uintptr
|
|
procWGLGetPixelFormatAttribivARB uintptr
|
|
procWGLSwapIntervalEXT uintptr
|
|
|
|
procGetDpiForMonitor = shcore.NewProc("GetDpiForMonitor")
|
|
procSetProcessDpiAwareness = shcore.NewProc("SetProcessDpiAwareness")
|
|
|
|
procDragAcceptFiles = shell32.NewProc("DragAcceptFiles")
|
|
procDragFinish = shell32.NewProc("DragFinish")
|
|
procDragQueryFileW = shell32.NewProc("DragQueryFileW")
|
|
procDragQueryPoint = shell32.NewProc("DragQueryPoint")
|
|
|
|
procAdjustWindowRectEx = user32.NewProc("AdjustWindowRectEx")
|
|
procAdjustWindowRectExForDpi = user32.NewProc("AdjustWindowRectExForDpi")
|
|
procBringWindowToTop = user32.NewProc("BringWindowToTop")
|
|
procChangeDisplaySettingsExW = user32.NewProc("ChangeDisplaySettingsExW")
|
|
procChangeWindowMessageFilterEx = user32.NewProc("ChangeWindowMessageFilterEx")
|
|
procClientToScreen = user32.NewProc("ClientToScreen")
|
|
procClipCursor = user32.NewProc("ClipCursor")
|
|
procCreateIconIndirect = user32.NewProc("CreateIconIndirect")
|
|
procCreateWindowExW = user32.NewProc("CreateWindowExW")
|
|
procDefWindowProcW = user32.NewProc("DefWindowProcW")
|
|
procDestroyIcon = user32.NewProc("DestroyIcon")
|
|
procDestroyWindow = user32.NewProc("DestroyWindow")
|
|
procDispatchMessageW = user32.NewProc("DispatchMessageW")
|
|
procEnableNonClientDpiScaling = user32.NewProc("EnableNonClientDpiScaling")
|
|
procEnumDisplayDevicesW = user32.NewProc("EnumDisplayDevicesW")
|
|
procEnumDisplayMonitors = user32.NewProc("EnumDisplayMonitors")
|
|
procEnumDisplaySettingsW = user32.NewProc("EnumDisplaySettingsW")
|
|
procEnumDisplaySettingsExW = user32.NewProc("EnumDisplaySettingsExW")
|
|
procFlashWindow = user32.NewProc("FlashWindow")
|
|
procGetActiveWindow = user32.NewProc("GetActiveWindow")
|
|
procGetClassLongPtrW = user32.NewProc("GetClassLongPtrW")
|
|
procGetClientRect = user32.NewProc("GetClientRect")
|
|
procGetCursorPos = user32.NewProc("GetCursorPos")
|
|
procGetDC = user32.NewProc("GetDC")
|
|
procGetDpiForWindow = user32.NewProc("GetDpiForWindow")
|
|
procGetKeyState = user32.NewProc("GetKeyState")
|
|
procGetLayeredWindowAttributes = user32.NewProc("GetLayeredWindowAttributes")
|
|
procGetMessageTime = user32.NewProc("GetMessageTime")
|
|
procGetMonitorInfoW = user32.NewProc("GetMonitorInfoW")
|
|
procGetRawInputData = user32.NewProc("GetRawInputData")
|
|
procGetSystemMetrics = user32.NewProc("GetSystemMetrics")
|
|
procGetSystemMetricsForDpi = user32.NewProc("GetSystemMetricsForDpi")
|
|
procGetWindowLongW = user32.NewProc("GetWindowLongW")
|
|
procGetWindowPlacement = user32.NewProc("GetWindowPlacement")
|
|
procGetWindowRect = user32.NewProc("GetWindowRect")
|
|
procIsIconic = user32.NewProc("IsIconic")
|
|
procIsWindowVisible = user32.NewProc("IsWindowVisible")
|
|
procIsZoomed = user32.NewProc("IsZoomed")
|
|
procLoadCursorW = user32.NewProc("LoadCursorW")
|
|
procLoadImageW = user32.NewProc("LoadImageW")
|
|
procMapVirtualKeyW = user32.NewProc("MapVirtualKeyW")
|
|
procMonitorFromWindow = user32.NewProc("MonitorFromWindow")
|
|
procMoveWindow = user32.NewProc("MoveWindow")
|
|
procMsgWaitForMultipleObjects = user32.NewProc("MsgWaitForMultipleObjects")
|
|
procOffsetRect = user32.NewProc("OffsetRect")
|
|
procPeekMessageW = user32.NewProc("PeekMessageW")
|
|
procPostMessageW = user32.NewProc("PostMessageW")
|
|
procPtInRect = user32.NewProc("PtInRect")
|
|
procRegisterClassExW = user32.NewProc("RegisterClassExW")
|
|
procRegisterDeviceNotificationW = user32.NewProc("RegisterDeviceNotificationW")
|
|
procRegisterRawInputDevices = user32.NewProc("RegisterRawInputDevices")
|
|
procReleaseCapture = user32.NewProc("ReleaseCapture")
|
|
procReleaseDC = user32.NewProc("ReleaseDC")
|
|
procRemovePropW = user32.NewProc("RemovePropW")
|
|
procScreenToClient = user32.NewProc("ScreenToClient")
|
|
procSendMessageW = user32.NewProc("SendMessageW")
|
|
procSetCapture = user32.NewProc("SetCapture")
|
|
procSetCursor = user32.NewProc("SetCursor")
|
|
procSetCursorPos = user32.NewProc("SetCursorPos")
|
|
procSetFocus = user32.NewProc("SetFocus")
|
|
procSetForegroundWindow = user32.NewProc("SetForegroundWindow")
|
|
procSetLayeredWindowAttributes = user32.NewProc("procSetLayeredWindowAttributes")
|
|
procSetProcessDPIAware = user32.NewProc("SetProcessDPIAware")
|
|
procSetProcessDpiAwarenessContext = user32.NewProc("SetProcessDpiAwarenessContext")
|
|
procSetWindowLongW = user32.NewProc("SetWindowLongW")
|
|
procSetWindowPlacement = user32.NewProc("SetWindowPlacement")
|
|
procSetWindowPos = user32.NewProc("SetWindowPos")
|
|
procSetWindowTextW = user32.NewProc("SetWindowTextW")
|
|
procShowWindow = user32.NewProc("ShowWindow")
|
|
procSystemParametersInfoW = user32.NewProc("SystemParametersInfoW")
|
|
procTranslateMessage = user32.NewProc("TranslateMessage")
|
|
procTrackMouseEvent = user32.NewProc("TrackMouseEvent")
|
|
procUnregisterClassW = user32.NewProc("UnregisterClassW")
|
|
procUnregisterDeviceNotification = user32.NewProc("UnregisterDeviceNotification")
|
|
procWaitMessage = user32.NewProc("WaitMessage")
|
|
procWindowFromPoint = user32.NewProc("WindowFromPoint")
|
|
)
|
|
|
|
func initWGLExtensionFunctions() {
|
|
procWGLCreateContextAttribsARB = wglGetProcAddress("wglCreateContextAttribsARB")
|
|
procWGLGetExtensionsStringARB = wglGetProcAddress("wglGetExtensionsStringARB")
|
|
procWGLGetExtensionsStringEXT = wglGetProcAddress("wglGetExtensionsStringEXT")
|
|
procWGLGetPixelFormatAttribivARB = wglGetProcAddress("wglGetPixelFormatAttribivARB")
|
|
procWGLSwapIntervalEXT = wglGetProcAddress("wglSwapIntervalEXT")
|
|
}
|
|
|
|
func _AdjustWindowRectEx(lpRect *_RECT, dwStyle uint32, menu bool, dwExStyle uint32) error {
|
|
var bMenu uintptr
|
|
if menu {
|
|
bMenu = 1
|
|
}
|
|
r, _, e := procAdjustWindowRectEx.Call(uintptr(unsafe.Pointer(lpRect)), uintptr(dwStyle), bMenu, uintptr(dwExStyle))
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: AdjustWindowRectEx failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _AdjustWindowRectExForDpi(lpRect *_RECT, dwStyle uint32, menu bool, dwExStyle uint32, dpi uint32) error {
|
|
var bMenu uintptr
|
|
if menu {
|
|
bMenu = 1
|
|
}
|
|
r, _, e := procAdjustWindowRectExForDpi.Call(uintptr(unsafe.Pointer(lpRect)), uintptr(dwStyle), bMenu, uintptr(dwExStyle), uintptr(dpi))
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: AdjustWindowRectExForDpi failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _BringWindowToTop(hWnd windows.HWND) error {
|
|
r, _, e := procBringWindowToTop.Call(uintptr(hWnd))
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: BringWindowToTop failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _ChangeDisplaySettingsExW(deviceName string, lpDevMode *_DEVMODEW, hwnd windows.HWND, dwflags uint32, lParam unsafe.Pointer) int32 {
|
|
var lpszDeviceName *uint16
|
|
if deviceName != "" {
|
|
var err error
|
|
lpszDeviceName, err = windows.UTF16PtrFromString(deviceName)
|
|
if err != nil {
|
|
panic("glfwwin: device name must not include a NUL character")
|
|
}
|
|
}
|
|
|
|
r, _, _ := procChangeDisplaySettingsExW.Call(uintptr(unsafe.Pointer(lpszDeviceName)), uintptr(unsafe.Pointer(lpDevMode)), uintptr(hwnd), uintptr(dwflags), uintptr(lParam))
|
|
runtime.KeepAlive(lpszDeviceName)
|
|
runtime.KeepAlive(lpDevMode)
|
|
|
|
return int32(r)
|
|
}
|
|
|
|
func _ChangeWindowMessageFilterEx(hwnd windows.HWND, message uint32, action uint32, pChangeFilterStruct *_CHANGEFILTERSTRUCT) error {
|
|
r, _, e := procChangeWindowMessageFilterEx.Call(uintptr(hwnd), uintptr(message), uintptr(action), uintptr(unsafe.Pointer(pChangeFilterStruct)))
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: ChangeWindowMessageFilterEx failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _ChoosePixelFormat(hdc _HDC, ppfd *_PIXELFORMATDESCRIPTOR) (int32, error) {
|
|
r, _, e := procChoosePixelFormat.Call(uintptr(hdc), uintptr(unsafe.Pointer(ppfd)))
|
|
if int32(r) == 0 {
|
|
return 0, fmt.Errorf("glfwwin: ChoosePixelFormat failed: %w", e)
|
|
}
|
|
return int32(r), nil
|
|
}
|
|
|
|
func _ClientToScreen(hWnd windows.HWND, lpPoint *_POINT) error {
|
|
r, _, e := procClientToScreen.Call(uintptr(hWnd), uintptr(unsafe.Pointer(lpPoint)))
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: ClientToScreen failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _ClipCursor(lpRect *_RECT) error {
|
|
r, _, e := procClipCursor.Call(uintptr(unsafe.Pointer(lpRect)))
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: ClipCursor failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _CreateBitmap(nWidth int32, nHeight int32, nPlanes uint32, nBitCount uint32, lpBits unsafe.Pointer) (_HBITMAP, error) {
|
|
r, _, e := procCreateBitmap.Call(uintptr(nWidth), uintptr(nHeight), uintptr(nPlanes), uintptr(nBitCount), uintptr(lpBits))
|
|
if _HBITMAP(r) == 0 {
|
|
return 0, fmt.Errorf("glfwwin: CreateBitmap failed: %w", e)
|
|
}
|
|
return _HBITMAP(r), nil
|
|
}
|
|
|
|
func _CreateDCW(driver string, device string, port string, pdm *_DEVMODEW) (_HDC, error) {
|
|
var lpszDriver *uint16
|
|
if driver != "" {
|
|
var err error
|
|
lpszDriver, err = windows.UTF16PtrFromString(driver)
|
|
if err != nil {
|
|
panic("glfwwin: driver must not include a NUL character")
|
|
}
|
|
}
|
|
|
|
var lpszDevice *uint16
|
|
if device != "" {
|
|
var err error
|
|
lpszDevice, err = windows.UTF16PtrFromString(device)
|
|
if err != nil {
|
|
panic("glfwwin: device must not include a NUL character")
|
|
}
|
|
}
|
|
|
|
var lpszPort *uint16
|
|
if port != "" {
|
|
var err error
|
|
lpszPort, err = windows.UTF16PtrFromString(port)
|
|
if err != nil {
|
|
panic("glfwwin: port must not include a NUL character")
|
|
}
|
|
}
|
|
|
|
r, _, e := procCreateDCW.Call(uintptr(unsafe.Pointer(lpszDriver)), uintptr(unsafe.Pointer(lpszDevice)), uintptr(unsafe.Pointer(lpszPort)), uintptr(unsafe.Pointer(pdm)))
|
|
runtime.KeepAlive(lpszDriver)
|
|
runtime.KeepAlive(lpszDevice)
|
|
runtime.KeepAlive(lpszPort)
|
|
if _HDC(r) == 0 {
|
|
return 0, fmt.Errorf("glfwwin: CreateDCW failed: %w", e)
|
|
}
|
|
return _HDC(r), nil
|
|
}
|
|
|
|
func _CreateDIBSection(hdc _HDC, pbmi *_BITMAPV5HEADER, usage uint32, hSection windows.Handle, offset uint32) (_HBITMAP, *byte, error) {
|
|
// pbmi is originally *BITMAPINFO.
|
|
var bits *byte
|
|
r, _, e := procCreateDIBSection.Call(uintptr(hdc), uintptr(unsafe.Pointer(pbmi)), uintptr(usage), uintptr(unsafe.Pointer(&bits)), uintptr(hSection), uintptr(offset))
|
|
if _HBITMAP(r) == 0 {
|
|
return 0, nil, fmt.Errorf("glfwwin: CreateDIBSection failed: %w", e)
|
|
}
|
|
return _HBITMAP(r), bits, nil
|
|
}
|
|
|
|
func _CreateRectRgn(x1, y1, x2, y2 int32) (_HRGN, error) {
|
|
r, _, e := procCreateRectRgn.Call(uintptr(x1), uintptr(y1), uintptr(x2), uintptr(y2))
|
|
if _HRGN(r) == 0 {
|
|
return 0, fmt.Errorf("glfwwin: CreateRectRgn failed: %w", e)
|
|
}
|
|
return _HRGN(r), nil
|
|
}
|
|
|
|
func _CreateIconIndirect(piconinfo *_ICONINFO) (_HICON, error) {
|
|
r, _, e := procCreateIconIndirect.Call(uintptr(unsafe.Pointer(piconinfo)))
|
|
if _HICON(r) == 0 {
|
|
return 0, fmt.Errorf("glfwwin: CreateIconIndirect failed: %w", e)
|
|
}
|
|
return _HICON(r), nil
|
|
}
|
|
|
|
func _CreateWindowExW(dwExStyle uint32, className string, windowName string, dwStyle uint32, x, y, nWidth, nHeight int32, hWndParent windows.HWND, hMenu _HMENU, hInstance _HINSTANCE, lpParam unsafe.Pointer) (windows.HWND, error) {
|
|
var lpClassName *uint16
|
|
if className != "" {
|
|
var err error
|
|
lpClassName, err = windows.UTF16PtrFromString(className)
|
|
if err != nil {
|
|
panic("glfwwin: class name msut not include a NUL character")
|
|
}
|
|
}
|
|
|
|
var lpWindowName *uint16
|
|
if windowName != "" {
|
|
var err error
|
|
lpWindowName, err = windows.UTF16PtrFromString(windowName)
|
|
if err != nil {
|
|
panic("glfwwin: window name msut not include a NUL character")
|
|
}
|
|
}
|
|
|
|
r, _, e := procCreateWindowExW.Call(
|
|
uintptr(dwExStyle), uintptr(unsafe.Pointer(lpClassName)), uintptr(unsafe.Pointer(lpWindowName)), uintptr(dwStyle),
|
|
uintptr(x), uintptr(y), uintptr(nWidth), uintptr(nHeight),
|
|
uintptr(hWndParent), uintptr(hMenu), uintptr(hInstance), uintptr(lpParam))
|
|
runtime.KeepAlive(lpClassName)
|
|
runtime.KeepAlive(lpWindowName)
|
|
|
|
if windows.HWND(r) == 0 {
|
|
return 0, fmt.Errorf("glfwwin: CreateWindowExW failed: %w", e)
|
|
}
|
|
return windows.HWND(r), nil
|
|
}
|
|
|
|
func _DefWindowProcW(hWnd windows.HWND, uMsg uint32, wParam _WPARAM, lParam _LPARAM) _LRESULT {
|
|
r, _, _ := procDefWindowProcW.Call(uintptr(hWnd), uintptr(uMsg), uintptr(wParam), uintptr(lParam))
|
|
return _LRESULT(r)
|
|
}
|
|
|
|
func _DestroyIcon(hIcon _HICON) error {
|
|
r, _, e := procDestroyIcon.Call(uintptr(hIcon))
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: DestroyIcon failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _DestroyWindow(hWnd windows.HWND) error {
|
|
r, _, e := procDestroyWindow.Call(uintptr(hWnd))
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: DestroyWindow failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _DeleteDC(hdc _HDC) error {
|
|
r, _, e := procDeleteDC.Call(uintptr(hdc))
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: DeleteDC failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _DeleteObject(ho _HGDIOBJ) error {
|
|
r, _, e := procDeleteObject.Call(uintptr(ho))
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: DeleteObject failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _DescribePixelFormat(hdc _HDC, iPixelFormat int32, nBytes uint32, ppfd *_PIXELFORMATDESCRIPTOR) (int32, error) {
|
|
r, _, e := procDescribePixelFormat.Call(uintptr(hdc), uintptr(iPixelFormat), uintptr(nBytes), uintptr(unsafe.Pointer(ppfd)))
|
|
if int32(r) == 0 {
|
|
return 0, fmt.Errorf("glfwwin: DescribePixelFormat failed: %w", e)
|
|
}
|
|
return int32(r), nil
|
|
}
|
|
|
|
func _DispatchMessageW(lpMsg *_MSG) _LRESULT {
|
|
r, _, _ := procDispatchMessageW.Call(uintptr(unsafe.Pointer(lpMsg)))
|
|
return _LRESULT(r)
|
|
}
|
|
|
|
func _DragAcceptFiles(hWnd windows.HWND, accept bool) {
|
|
var fAccept uintptr
|
|
if accept {
|
|
fAccept = 1
|
|
}
|
|
procDragAcceptFiles.Call(uintptr(hWnd), fAccept)
|
|
}
|
|
|
|
func _DragFinish(hDrop _HDROP) {
|
|
procDragFinish.Call(uintptr(hDrop))
|
|
}
|
|
|
|
func _DragQueryFileW(hDrop _HDROP, iFile uint32, file []uint16) uint32 {
|
|
r, _, _ := procDragQueryFileW.Call(uintptr(hDrop), uintptr(iFile), uintptr(unsafe.Pointer(&file[0])), uintptr(len(file)))
|
|
return uint32(r)
|
|
}
|
|
|
|
func _DragQueryPoint(hDrop _HDROP) (_POINT, bool) {
|
|
var pt _POINT
|
|
r, _, _ := procDragQueryPoint.Call(uintptr(hDrop), uintptr(unsafe.Pointer(&pt)))
|
|
if int32(r) == 0 {
|
|
return _POINT{}, false
|
|
}
|
|
return pt, true
|
|
}
|
|
|
|
func _DwmEnableBlurBehindWindow(hWnd windows.HWND, pBlurBehind *_DWM_BLURBEHIND) error {
|
|
r, _, e := procDwmEnableBlurBehindWindow.Call(uintptr(hWnd), uintptr(unsafe.Pointer(pBlurBehind)))
|
|
if windows.Handle(r) != windows.S_OK {
|
|
return fmt.Errorf("glfwwin: DwmEnableBlurBehindWindow failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _DwmGetColorizationColor() (uint32, bool, error) {
|
|
var colorization uint32
|
|
var opaqueBlend int32
|
|
r, _, e := procDwmGetColorizationColor.Call(uintptr(unsafe.Pointer(&colorization)), uintptr(unsafe.Pointer(&opaqueBlend)))
|
|
if windows.Handle(r) != windows.S_OK {
|
|
return 0, false, fmt.Errorf("glfwwin: DwmGetColorizationColor failed: %w", e)
|
|
}
|
|
return colorization, opaqueBlend != 0, nil
|
|
}
|
|
|
|
func _DwmFlush() error {
|
|
r, _, e := procDwmFlush.Call()
|
|
if windows.Handle(r) != windows.S_OK {
|
|
return fmt.Errorf("glfwwin: DwmFlush failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _DwmIsCompositionEnabled() (bool, error) {
|
|
var enabled int32
|
|
r, _, e := procDwmIsCompositionEnabled.Call(uintptr(unsafe.Pointer(&enabled)))
|
|
if windows.Handle(r) != windows.S_OK {
|
|
return false, fmt.Errorf("glfwwin: DwmIsCompositionEnabled failed: %w", e)
|
|
}
|
|
return enabled != 0, nil
|
|
}
|
|
|
|
func _EnableNonClientDpiScaling(hwnd windows.HWND) error {
|
|
r, _, e := procEnableNonClientDpiScaling.Call(uintptr(hwnd))
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: EnableNonClientDpiScaling failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _EnumDisplayDevicesW(device string, iDevNum uint32, dwFlags uint32) (_DISPLAY_DEVICEW, bool) {
|
|
var lpDevice *uint16
|
|
if device != "" {
|
|
var err error
|
|
lpDevice, err = windows.UTF16PtrFromString(device)
|
|
if err != nil {
|
|
panic("glfwwin: device name must not include a NUL character")
|
|
}
|
|
}
|
|
|
|
var displayDevice _DISPLAY_DEVICEW
|
|
displayDevice.cb = uint32(unsafe.Sizeof(displayDevice))
|
|
r, _, _ := procEnumDisplayDevicesW.Call(uintptr(unsafe.Pointer(lpDevice)), uintptr(iDevNum), uintptr(unsafe.Pointer(&displayDevice)), uintptr(dwFlags))
|
|
runtime.KeepAlive(lpDevice)
|
|
|
|
if int32(r) == 0 {
|
|
return _DISPLAY_DEVICEW{}, false
|
|
}
|
|
return displayDevice, true
|
|
}
|
|
|
|
func _EnumDisplayMonitors(hdc _HDC, lprcClip *_RECT, lpfnEnum uintptr, dwData _LPARAM) error {
|
|
r, _, e := procEnumDisplayMonitors.Call(uintptr(hdc), uintptr(unsafe.Pointer(lprcClip)), uintptr(lpfnEnum), uintptr(dwData))
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: EnumDisplayMonitors failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _EnumDisplaySettingsExW(deviceName string, iModeNum uint32, dwFlags uint32) (_DEVMODEW, bool) {
|
|
var lpszDeviceName *uint16
|
|
if deviceName != "" {
|
|
var err error
|
|
lpszDeviceName, err = windows.UTF16PtrFromString(deviceName)
|
|
if err != nil {
|
|
panic("glfwwin: device name must not include a NUL character")
|
|
}
|
|
}
|
|
|
|
var dm _DEVMODEW
|
|
dm.dmSize = uint16(unsafe.Sizeof(dm))
|
|
|
|
r, _, _ := procEnumDisplaySettingsExW.Call(uintptr(unsafe.Pointer(lpszDeviceName)), uintptr(iModeNum), uintptr(unsafe.Pointer(&dm)), uintptr(dwFlags))
|
|
runtime.KeepAlive(lpszDeviceName)
|
|
|
|
if int32(r) == 0 {
|
|
return _DEVMODEW{}, false
|
|
}
|
|
return dm, true
|
|
}
|
|
|
|
func _EnumDisplaySettingsW(deviceName string, iModeNum uint32) (_DEVMODEW, bool) {
|
|
var lpszDeviceName *uint16
|
|
if deviceName != "" {
|
|
var err error
|
|
lpszDeviceName, err = windows.UTF16PtrFromString(deviceName)
|
|
if err != nil {
|
|
panic("glfwwin: device name must not include a NUL character")
|
|
}
|
|
}
|
|
|
|
var dm _DEVMODEW
|
|
dm.dmSize = uint16(unsafe.Sizeof(dm))
|
|
|
|
r, _, _ := procEnumDisplaySettingsW.Call(uintptr(unsafe.Pointer(lpszDeviceName)), uintptr(iModeNum), uintptr(unsafe.Pointer(&dm)))
|
|
runtime.KeepAlive(lpszDeviceName)
|
|
|
|
if int32(r) == 0 {
|
|
return _DEVMODEW{}, false
|
|
}
|
|
return dm, true
|
|
}
|
|
|
|
func _FlashWindow(hWnd windows.HWND, invert bool) bool {
|
|
var bInvert uintptr
|
|
if invert {
|
|
bInvert = 1
|
|
}
|
|
r, _, _ := procFlashWindow.Call(uintptr(hWnd), bInvert)
|
|
return int32(r) != 0
|
|
}
|
|
|
|
func _GetActiveWindow() windows.HWND {
|
|
r, _, _ := procGetActiveWindow.Call()
|
|
return windows.HWND(r)
|
|
}
|
|
|
|
func _GetClassLongPtrW(hWnd windows.HWND, nIndex int32) (uintptr, error) {
|
|
r, _, e := procGetClassLongPtrW.Call(uintptr(hWnd), uintptr(nIndex))
|
|
if r == 0 {
|
|
return 0, fmt.Errorf("glfwwin: GetClassLongPtrW failed: %w", e)
|
|
}
|
|
return r, nil
|
|
}
|
|
|
|
func _GetClientRect(hWnd windows.HWND) (_RECT, error) {
|
|
var rect _RECT
|
|
r, _, e := procGetClientRect.Call(uintptr(hWnd), uintptr(unsafe.Pointer(&rect)))
|
|
if int32(r) == 0 {
|
|
return _RECT{}, fmt.Errorf("glfwwin: GetClientRect failed: %w", e)
|
|
}
|
|
return rect, nil
|
|
}
|
|
|
|
func _GetCursorPos() (_POINT, error) {
|
|
var point _POINT
|
|
r, _, e := procGetCursorPos.Call(uintptr(unsafe.Pointer(&point)))
|
|
if int32(r) == 0 {
|
|
return _POINT{}, fmt.Errorf("glfwwin: GetCursorPos failed: %w", e)
|
|
}
|
|
return point, nil
|
|
}
|
|
|
|
func _GetDC(hWnd windows.HWND) (_HDC, error) {
|
|
r, _, e := procGetDC.Call(uintptr(hWnd))
|
|
if _HDC(r) == 0 {
|
|
return 0, fmt.Errorf("glfwwin: GetDC failed: %w", e)
|
|
}
|
|
return _HDC(r), nil
|
|
}
|
|
|
|
func _GetDeviceCaps(hdc _HDC, index int32) int32 {
|
|
r, _, _ := procGetDeviceCaps.Call(uintptr(hdc), uintptr(index))
|
|
return int32(r)
|
|
}
|
|
|
|
func _GetDpiForWindow(hwnd windows.HWND) uint32 {
|
|
r, _, _ := procGetDpiForWindow.Call(uintptr(hwnd))
|
|
return uint32(r)
|
|
}
|
|
|
|
func _GetKeyState(nVirtKey int32) int16 {
|
|
r, _, _ := procGetKeyState.Call(uintptr(nVirtKey))
|
|
return int16(r)
|
|
}
|
|
|
|
func _GetLayeredWindowAttributes(hWnd windows.HWND) (key _COLORREF, alpha byte, flags uint32, err error) {
|
|
r, _, e := procGetLayeredWindowAttributes.Call(uintptr(hWnd), uintptr(unsafe.Pointer(&key)), uintptr(unsafe.Pointer(&alpha)), uintptr(unsafe.Pointer(&flags)))
|
|
if int32(r) == 0 {
|
|
return 0, 0, 0, fmt.Errorf("glfwwin: GetLayeredWindowAttributes failed: %w", e)
|
|
}
|
|
return
|
|
}
|
|
|
|
func _GetMessageTime() int32 {
|
|
r, _, _ := procGetMessageTime.Call()
|
|
return int32(r)
|
|
}
|
|
|
|
func _GetModuleHandleW(moduleName string) (_HMODULE, error) {
|
|
var lpModuleName *uint16
|
|
if moduleName != "" {
|
|
var err error
|
|
lpModuleName, err = windows.UTF16PtrFromString(moduleName)
|
|
if err != nil {
|
|
panic("glfwwin: module name must not include a NUL character")
|
|
}
|
|
}
|
|
|
|
r, _, e := procGetModuleHandleW.Call(uintptr(unsafe.Pointer(lpModuleName)))
|
|
runtime.KeepAlive(lpModuleName)
|
|
|
|
if _HMODULE(r) == 0 {
|
|
return 0, fmt.Errorf("glfwwin: GetModuleHandleW failed: %w", e)
|
|
}
|
|
return _HMODULE(r), nil
|
|
}
|
|
|
|
func _GetMonitorInfoW(hMonitor _HMONITOR) (_MONITORINFO, bool) {
|
|
var mi _MONITORINFO
|
|
mi.cbSize = uint32(unsafe.Sizeof(mi))
|
|
r, _, _ := procGetMonitorInfoW.Call(uintptr(hMonitor), uintptr(unsafe.Pointer(&mi)))
|
|
if int32(r) == 0 {
|
|
return _MONITORINFO{}, false
|
|
}
|
|
return mi, true
|
|
}
|
|
|
|
func _GetMonitorInfoW_Ex(hMonitor _HMONITOR) (_MONITORINFOEXW, bool) {
|
|
var mi _MONITORINFOEXW
|
|
mi.cbSize = uint32(unsafe.Sizeof(mi))
|
|
r, _, _ := procGetMonitorInfoW.Call(uintptr(hMonitor), uintptr(unsafe.Pointer(&mi)))
|
|
if int32(r) == 0 {
|
|
return _MONITORINFOEXW{}, false
|
|
}
|
|
return mi, true
|
|
}
|
|
|
|
func _GetDpiForMonitor(hmonitor _HMONITOR, dpiType _MONITOR_DPI_TYPE) (dpiX, dpiY uint32, err error) {
|
|
r, _, e := procGetDpiForMonitor.Call(uintptr(hmonitor), uintptr(dpiType), uintptr(unsafe.Pointer(&dpiX)), uintptr(unsafe.Pointer(&dpiY)))
|
|
if windows.Handle(r) != windows.S_OK {
|
|
return 0, 0, fmt.Errorf("glfwwin: GetDpiForMonitor failed: %w", e)
|
|
}
|
|
return dpiX, dpiY, nil
|
|
}
|
|
|
|
func _GetRawInputData(hRawInput _HRAWINPUT, uiCommand uint32, pData unsafe.Pointer, pcbSize *uint32) (uint32, error) {
|
|
r, _, e := procGetRawInputData.Call(uintptr(hRawInput), uintptr(uiCommand), uintptr(pData), uintptr(unsafe.Pointer(pcbSize)), unsafe.Sizeof(_RAWINPUTHEADER{}))
|
|
if uint32(r) == (1<<32)-1 {
|
|
return 0, fmt.Errorf("glfwwin: GetRawInputData failed: %w", e)
|
|
}
|
|
return uint32(r), nil
|
|
}
|
|
|
|
func _GetSystemMetrics(nIndex int32) (int32, error) {
|
|
r, _, e := procGetSystemMetrics.Call(uintptr(nIndex))
|
|
if int32(r) == 0 && !errors.Is(e, windows.ERROR_SUCCESS) {
|
|
return 0, fmt.Errorf("glfwwin: GetSystemMetrics failed: %w", e)
|
|
}
|
|
return int32(r), nil
|
|
}
|
|
|
|
func _GetSystemMetricsForDpi(nIndex int32, dpi uint32) (int32, error) {
|
|
r, _, e := procGetSystemMetricsForDpi.Call(uintptr(nIndex), uintptr(dpi))
|
|
if int32(r) == 0 && !errors.Is(e, windows.ERROR_SUCCESS) {
|
|
return 0, fmt.Errorf("glfwwin: GetSystemMetrics failed: %w", e)
|
|
}
|
|
return int32(r), nil
|
|
}
|
|
|
|
func _GetWindowLongW(hWnd windows.HWND, nIndex int32) (int32, error) {
|
|
r, _, e := procGetWindowLongW.Call(uintptr(hWnd), uintptr(nIndex))
|
|
if int32(r) == 0 && !errors.Is(e, windows.ERROR_SUCCESS) {
|
|
return 0, fmt.Errorf("glfwwin: GetWindowLongW failed: %w", e)
|
|
}
|
|
return int32(r), nil
|
|
}
|
|
|
|
func _GetWindowPlacement(hWnd windows.HWND) (_WINDOWPLACEMENT, error) {
|
|
var wp _WINDOWPLACEMENT
|
|
wp.length = uint32(unsafe.Sizeof(wp))
|
|
|
|
r, _, e := procGetWindowPlacement.Call(uintptr(hWnd), uintptr(unsafe.Pointer(&wp)))
|
|
if int32(r) == 0 {
|
|
return _WINDOWPLACEMENT{}, fmt.Errorf("glfwwin: GetWindowPlacement failed: %w", e)
|
|
}
|
|
return wp, nil
|
|
}
|
|
|
|
func _GetWindowRect(hWnd windows.HWND) (_RECT, error) {
|
|
var rect _RECT
|
|
r, _, e := procGetWindowRect.Call(uintptr(hWnd), uintptr(unsafe.Pointer(&rect)))
|
|
if int(r) == 0 {
|
|
return _RECT{}, fmt.Errorf("glfwwin: GetWindowRect failed: %w", e)
|
|
}
|
|
return rect, nil
|
|
}
|
|
|
|
func _IsIconic(hWnd windows.HWND) bool {
|
|
r, _, _ := procIsIconic.Call(uintptr(hWnd))
|
|
return int32(r) != 0
|
|
}
|
|
|
|
func _IsWindowVisible(hWnd windows.HWND) bool {
|
|
r, _, _ := procIsWindowVisible.Call(uintptr(hWnd))
|
|
return int32(r) != 0
|
|
}
|
|
|
|
func _IsZoomed(hWnd windows.HWND) bool {
|
|
r, _, _ := procIsZoomed.Call(uintptr(hWnd))
|
|
return int32(r) != 0
|
|
}
|
|
|
|
func _LoadCursorW(hInstance _HINSTANCE, lpCursorName uintptr) (_HCURSOR, error) {
|
|
r, _, e := procLoadCursorW.Call(uintptr(hInstance), lpCursorName)
|
|
if _HCURSOR(r) == 0 {
|
|
return 0, fmt.Errorf("glfwwin: LoadCursorW: %w", e)
|
|
}
|
|
return _HCURSOR(r), nil
|
|
}
|
|
|
|
func _LoadImageW(hInst _HINSTANCE, name uintptr, typ uint32, cx int32, cy int32, fuLoad uint32) (windows.Handle, error) {
|
|
r, _, e := procLoadImageW.Call(uintptr(hInst), name, uintptr(typ), uintptr(cx), uintptr(cy), uintptr(fuLoad))
|
|
if windows.Handle(r) == 0 {
|
|
return 0, fmt.Errorf("glfwwin: LoadImageW: %w", e)
|
|
}
|
|
return windows.Handle(r), nil
|
|
}
|
|
|
|
func _LoadImageW_Available() bool {
|
|
return procLoadImageW.Find() == nil
|
|
}
|
|
|
|
func _MapVirtualKeyW(uCode uint32, uMapType uint32) uint32 {
|
|
r, _, _ := procMapVirtualKeyW.Call(uintptr(uCode), uintptr(uMapType))
|
|
return uint32(r)
|
|
}
|
|
|
|
func _MapVirtualKeyW_Available() bool {
|
|
return procMapVirtualKeyW.Find() == nil
|
|
}
|
|
|
|
func _MonitorFromWindow(hwnd windows.HWND, dwFlags uint32) _HMONITOR {
|
|
r, _, _ := procMonitorFromWindow.Call(uintptr(hwnd), uintptr(dwFlags))
|
|
return _HMONITOR(r)
|
|
}
|
|
|
|
func _MoveWindow(hWnd windows.HWND, x, y, nWidth, nHeight int32, repaint bool) error {
|
|
var bRepaint uintptr
|
|
if repaint {
|
|
bRepaint = 1
|
|
}
|
|
r, _, e := procMoveWindow.Call(uintptr(hWnd), uintptr(x), uintptr(y), uintptr(nWidth), uintptr(nHeight), bRepaint)
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: MoveWindow: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _MsgWaitForMultipleObjects(nCount uint32, pHandles *windows.Handle, waitAll bool, dwMilliseconds uint32, dwWakeMask uint32) (uint32, error) {
|
|
var fWaitAll uintptr
|
|
if waitAll {
|
|
fWaitAll = 1
|
|
}
|
|
r, _, e := procMsgWaitForMultipleObjects.Call(uintptr(nCount), uintptr(unsafe.Pointer(pHandles)), fWaitAll, uintptr(dwMilliseconds), uintptr(dwWakeMask))
|
|
if uint32(r) == _WAIT_FAILED {
|
|
return 0, fmt.Errorf("glfwwin: MsgWaitForMultipleObjects failed: %w", e)
|
|
}
|
|
return uint32(r), nil
|
|
}
|
|
|
|
func _OffsetRect(lprect *_RECT, dx int32, dy int32) bool {
|
|
r, _, _ := procOffsetRect.Call(uintptr(unsafe.Pointer(lprect)), uintptr(dx), uintptr(dy))
|
|
return int32(r) != 0
|
|
}
|
|
|
|
func _PeekMessageW(lpMsg *_MSG, hWnd windows.HWND, wMsgFilterMin uint32, wMsgFilterMax uint32, wRemoveMsg uint32) bool {
|
|
r, _, _ := procPeekMessageW.Call(uintptr(unsafe.Pointer(lpMsg)), uintptr(hWnd), uintptr(wMsgFilterMin), uintptr(wMsgFilterMax), uintptr(wRemoveMsg))
|
|
return int32(r) != 0
|
|
}
|
|
|
|
func _PostMessageW(hWnd windows.HWND, msg uint32, wParam _WPARAM, lParam _LPARAM) error {
|
|
r, _, e := procPostMessageW.Call(uintptr(hWnd), uintptr(msg), uintptr(wParam), uintptr(lParam))
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: PostMessageW failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _PtInRect(lprc *_RECT, pt _POINT) bool {
|
|
var r uintptr
|
|
if unsafe.Sizeof(uintptr(0)) == unsafe.Sizeof(uint64(0)) {
|
|
r, _, _ = procPtInRect.Call(uintptr(unsafe.Pointer(lprc)), uintptr(pt.x)|uintptr(pt.y)<<32)
|
|
} else {
|
|
switch runtime.GOARCH {
|
|
case "386":
|
|
r, _, _ = procPtInRect.Call(uintptr(unsafe.Pointer(lprc)), uintptr(pt.x), uintptr(pt.y))
|
|
case "arm":
|
|
// Adjust the alignment for ARM.
|
|
r, _, _ = procPtInRect.Call(uintptr(unsafe.Pointer(lprc)), 0, uintptr(pt.x), uintptr(pt.y))
|
|
default:
|
|
panic(fmt.Sprintf("glfwwin: GOARCH=%s is not supported", runtime.GOARCH))
|
|
}
|
|
}
|
|
return int32(r) != 0
|
|
}
|
|
|
|
func _RegisterClassExW(unnamedParam1 *_WNDCLASSEXW) (_ATOM, error) {
|
|
r, _, e := procRegisterClassExW.Call(uintptr(unsafe.Pointer(unnamedParam1)))
|
|
if _ATOM(r) == 0 {
|
|
return 0, fmt.Errorf("glfwwin: RegisterClassExW failed: %w", e)
|
|
}
|
|
return _ATOM(r), nil
|
|
}
|
|
|
|
func _RegisterDeviceNotificationW(hRecipient windows.Handle, notificationFilter unsafe.Pointer, flags uint32) (_HDEVNOTIFY, error) {
|
|
r, _, e := procRegisterDeviceNotificationW.Call(uintptr(hRecipient), uintptr(notificationFilter), uintptr(flags))
|
|
if _HDEVNOTIFY(r) == 0 {
|
|
return 0, fmt.Errorf("glfwwin: RegisterDeviceNotificationW failed: %w", e)
|
|
}
|
|
return _HDEVNOTIFY(r), nil
|
|
}
|
|
|
|
func _RegisterRawInputDevices(pRawInputDevices []_RAWINPUTDEVICE) error {
|
|
r, _, e := procRegisterRawInputDevices.Call(uintptr(unsafe.Pointer(&pRawInputDevices[0])), uintptr(len(pRawInputDevices)), unsafe.Sizeof(pRawInputDevices[0]))
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: RegisterRawInputDevices failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _ReleaseCapture() error {
|
|
r, _, e := procReleaseCapture.Call()
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: ReleaseCapture failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _ReleaseDC(hWnd windows.HWND, hDC _HDC) int32 {
|
|
r, _, _ := procReleaseDC.Call(uintptr(hWnd), uintptr(hDC))
|
|
return int32(r)
|
|
}
|
|
|
|
func _RemovePropW(hWnd windows.HWND, str string) windows.Handle {
|
|
var lpString *uint16
|
|
if str != "" {
|
|
var err error
|
|
lpString, err = windows.UTF16PtrFromString(str)
|
|
if err != nil {
|
|
panic("glfwwin: str must not include a NUL character")
|
|
}
|
|
}
|
|
|
|
r, _, _ := procRemovePropW.Call(uintptr(hWnd), uintptr(unsafe.Pointer(lpString)))
|
|
runtime.KeepAlive(lpString)
|
|
|
|
return windows.Handle(r)
|
|
}
|
|
|
|
func _RtlVerifyVersionInfo(versionInfo *_OSVERSIONINFOEXW, typeMask uint32, conditionMask uint64) int32 {
|
|
var r uintptr
|
|
if unsafe.Sizeof(uintptr(0)) == unsafe.Sizeof(uint64(0)) {
|
|
r, _, _ = procRtlVerifyVersionInfo.Call(uintptr(unsafe.Pointer(versionInfo)), uintptr(typeMask), uintptr(conditionMask))
|
|
} else {
|
|
switch runtime.GOARCH {
|
|
case "386":
|
|
r, _, _ = procRtlVerifyVersionInfo.Call(uintptr(unsafe.Pointer(versionInfo)), uintptr(typeMask), uintptr(conditionMask), uintptr(conditionMask>>32))
|
|
case "arm":
|
|
// Adjust the alignment for ARM.
|
|
r, _, _ = procRtlVerifyVersionInfo.Call(uintptr(unsafe.Pointer(versionInfo)), uintptr(typeMask), 0, uintptr(conditionMask), uintptr(conditionMask>>32))
|
|
default:
|
|
panic(fmt.Sprintf("glfwwin: GOARCH=%s is not supported", runtime.GOARCH))
|
|
}
|
|
}
|
|
return int32(r)
|
|
}
|
|
|
|
func _ScreenToClient(hWnd windows.HWND, lpPoint *_POINT) error {
|
|
r, _, e := procScreenToClient.Call(uintptr(hWnd), uintptr(unsafe.Pointer(lpPoint)))
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: ScreenToClient failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _SendMessageW(hWnd windows.HWND, msg uint32, wParam _WPARAM, lParam _LPARAM) _LRESULT {
|
|
r, _, _ := procSendMessageW.Call(uintptr(hWnd), uintptr(msg), uintptr(wParam), uintptr(lParam))
|
|
return _LRESULT(r)
|
|
}
|
|
|
|
func _SetCapture(hWnd windows.HWND) windows.HWND {
|
|
r, _, _ := procSetCapture.Call(uintptr(hWnd))
|
|
return windows.HWND(r)
|
|
}
|
|
|
|
func _SetCursor(hCursor _HCURSOR) _HCURSOR {
|
|
r, _, _ := procSetCursor.Call(uintptr(hCursor))
|
|
return _HCURSOR(r)
|
|
}
|
|
|
|
func _SetCursorPos(x, y int32) error {
|
|
r, _, e := procSetCursorPos.Call(uintptr(x), uintptr(y))
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: SetCursorPos failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _SetFocus(hWnd windows.HWND) (windows.HWND, error) {
|
|
r, _, e := procSetFocus.Call(uintptr(hWnd))
|
|
if windows.HWND(r) == 0 {
|
|
return 0, fmt.Errorf("glfwwin: SetFocus failed: %w", e)
|
|
}
|
|
return windows.HWND(r), nil
|
|
}
|
|
|
|
func _SetForegroundWindow(hWnd windows.HWND) bool {
|
|
r, _, _ := procSetForegroundWindow.Call(uintptr(hWnd))
|
|
return int32(r) != 0
|
|
}
|
|
|
|
func _SetLayeredWindowAttributes(hwnd windows.HWND, crKey _COLORREF, bAlpha byte, dwFlags uint32) error {
|
|
r, _, e := procSetLayeredWindowAttributes.Call(uintptr(hwnd), uintptr(crKey), uintptr(bAlpha), uintptr(dwFlags))
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: SetLayeredWindowAttributes failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _SetPixelFormat(hdc _HDC, format int32, ppfd *_PIXELFORMATDESCRIPTOR) error {
|
|
r, _, e := procSetPixelFormat.Call(uintptr(hdc), uintptr(format), uintptr(unsafe.Pointer(ppfd)))
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: SetPixelFormat failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _SetProcessDPIAware() bool {
|
|
r, _, _ := procSetProcessDPIAware.Call()
|
|
return int32(r) != 0
|
|
}
|
|
|
|
func _SetProcessDpiAwareness(value _PROCESS_DPI_AWARENESS) error {
|
|
r, _, e := procSetProcessDpiAwareness.Call(uintptr(value))
|
|
if windows.Handle(r) != windows.S_OK {
|
|
return fmt.Errorf("glfwwin: SetProcessDpiAwareness failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _SetProcessDpiAwarenessContext(value _DPI_AWARENESS_CONTEXT) error {
|
|
r, _, e := procSetProcessDpiAwarenessContext.Call(uintptr(value))
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: SetProcessDpiAwarenessContext failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _SetProcessDpiAwarenessContext_Available() bool {
|
|
return procSetProcessDpiAwarenessContext.Find() == nil
|
|
}
|
|
|
|
func _SetThreadExecutionState(esFlags _EXECUTION_STATE) _EXECUTION_STATE {
|
|
r, _, _ := procSetThreadExecutionState.Call(uintptr(esFlags))
|
|
return _EXECUTION_STATE(r)
|
|
}
|
|
|
|
func _SetWindowLongW(hWnd windows.HWND, nIndex int32, dwNewLong int32) (int32, error) {
|
|
r, _, e := procSetWindowLongW.Call(uintptr(hWnd), uintptr(nIndex), uintptr(dwNewLong))
|
|
if int32(r) == 0 && !errors.Is(e, windows.ERROR_SUCCESS) {
|
|
return 0, fmt.Errorf("glfwwin: SetWindowLongW failed: %w", e)
|
|
}
|
|
return int32(r), nil
|
|
}
|
|
|
|
func _SetWindowPlacement(hWnd windows.HWND, lpwndpl *_WINDOWPLACEMENT) error {
|
|
r, _, e := procSetWindowPlacement.Call(uintptr(hWnd), uintptr(unsafe.Pointer(lpwndpl)))
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: SetWindowPlacement failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _SetWindowPos(hWnd windows.HWND, hWndInsertAfter windows.HWND, x, y, cx, cy int32, uFlags uint32) error {
|
|
r, _, e := procSetWindowPos.Call(uintptr(hWnd), uintptr(hWndInsertAfter), uintptr(x), uintptr(y), uintptr(cx), uintptr(cy), uintptr(uFlags))
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: SetWindowPos failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _SetWindowTextW(hWnd windows.HWND, str string) error {
|
|
// An empty string is also a valid value. Always create a uint16 pointer.
|
|
lpString, err := windows.UTF16PtrFromString(str)
|
|
if err != nil {
|
|
panic("glfwwin: str must not include a NUL character")
|
|
}
|
|
|
|
r, _, e := procSetWindowTextW.Call(uintptr(hWnd), uintptr(unsafe.Pointer(lpString)))
|
|
runtime.KeepAlive(lpString)
|
|
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: SetWindowTextW failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _ShowWindow(hWnd windows.HWND, nCmdShow int32) bool {
|
|
r, _, _ := procShowWindow.Call(uintptr(hWnd), uintptr(nCmdShow))
|
|
return int32(r) != 0
|
|
}
|
|
|
|
func _SwapBuffers(unnamedParam1 _HDC) error {
|
|
r, _, e := procSwapBuffers.Call(uintptr(unnamedParam1))
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: SwapBuffers failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _SystemParametersInfoW(uiAction uint32, uiParam uint32, pvParam uintptr, fWinIni uint32) error {
|
|
r, _, e := procSystemParametersInfoW.Call(uintptr(uiAction), uintptr(uiParam), pvParam, uintptr(fWinIni))
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: SystemParametersInfoW failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _TlsAlloc() (uint32, error) {
|
|
r, _, e := procTlsAlloc.Call()
|
|
if uint32(r) == _TLS_OUT_OF_INDEXES {
|
|
return 0, fmt.Errorf("glfwwin: TlsAlloc failed: %w", e)
|
|
}
|
|
return uint32(r), nil
|
|
}
|
|
|
|
func _TlsFree(dwTlsIndex uint32) error {
|
|
r, _, e := procTlsFree.Call(uintptr(dwTlsIndex))
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: TlsFree failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _TlsGetValue(dwTlsIndex uint32) (uintptr, error) {
|
|
r, _, e := procTlsGetValue.Call(uintptr(dwTlsIndex))
|
|
if r == 0 && !errors.Is(e, windows.ERROR_SUCCESS) {
|
|
return 0, fmt.Errorf("glfwwin: TlsGetValue failed: %w", e)
|
|
}
|
|
return r, nil
|
|
}
|
|
|
|
func _TlsSetValue(dwTlsIndex uint32, lpTlsValue uintptr) error {
|
|
r, _, e := procTlsSetValue.Call(uintptr(dwTlsIndex), lpTlsValue)
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: TlsSetValue failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _TranslateMessage(lpMsg *_MSG) bool {
|
|
r, _, _ := procTranslateMessage.Call(uintptr(unsafe.Pointer(lpMsg)))
|
|
return int32(r) != 0
|
|
}
|
|
|
|
func _TrackMouseEvent(lpEventTrack *_TRACKMOUSEEVENT) error {
|
|
r, _, e := procTrackMouseEvent.Call(uintptr(unsafe.Pointer(lpEventTrack)))
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: TrackMouseEvent failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _UnregisterClassW(className string, hInstance _HINSTANCE) error {
|
|
var lpClassName *uint16
|
|
if className != "" {
|
|
var err error
|
|
lpClassName, err = windows.UTF16PtrFromString(className)
|
|
if err != nil {
|
|
panic("glfwwin: class name must not include a NUL character")
|
|
}
|
|
}
|
|
|
|
r, _, e := procUnregisterClassW.Call(uintptr(unsafe.Pointer(lpClassName)), uintptr(hInstance))
|
|
runtime.KeepAlive(lpClassName)
|
|
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: UnregisterClassW failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _UnregisterDeviceNotification(handle _HDEVNOTIFY) error {
|
|
r, _, e := procUnregisterDeviceNotification.Call(uintptr(handle))
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: UnregisterDeviceNotification failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _VerSetConditionMask(conditionMask uint64, typeMask uint32, condition byte) uint64 {
|
|
if unsafe.Sizeof(uintptr(0)) == unsafe.Sizeof(uint64(0)) {
|
|
r, _, _ := procVerSetConditionMask.Call(uintptr(conditionMask), uintptr(typeMask), uintptr(condition))
|
|
return uint64(r)
|
|
} else {
|
|
r1, r2, _ := procVerSetConditionMask.Call(uintptr(conditionMask), uintptr(conditionMask>>32), uintptr(typeMask), uintptr(condition))
|
|
return uint64(r1) | (uint64(r2) << 32)
|
|
}
|
|
}
|
|
|
|
func _WaitMessage() error {
|
|
r, _, e := procWaitMessage.Call()
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: WaitMessage failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func wglCreateContext(unnamedParam1 _HDC) (_HGLRC, error) {
|
|
r, _, e := procWGLCreateContext.Call(uintptr(unnamedParam1))
|
|
if _HGLRC(r) == 0 {
|
|
return 0, fmt.Errorf("glfwwin: wglCreateContext failed: %w", e)
|
|
}
|
|
return _HGLRC(r), nil
|
|
}
|
|
|
|
func wglCreateContextAttribsARB(hDC _HDC, hshareContext _HGLRC, attribList *int32) (_HGLRC, error) {
|
|
r, _, e := syscall.Syscall(procWGLCreateContextAttribsARB, 3, uintptr(hDC), uintptr(hshareContext), uintptr(unsafe.Pointer(attribList)))
|
|
if _HGLRC(r) == 0 {
|
|
// TODO: Show more detailed error? See the original implementation.
|
|
return 0, fmt.Errorf("glfwwin: wglCreateContextAttribsARB failed: %w", e)
|
|
}
|
|
return _HGLRC(r), nil
|
|
}
|
|
|
|
func wglDeleteContext(unnamedParam1 _HGLRC) error {
|
|
r, _, e := procWGLDeleteContext.Call(uintptr(unnamedParam1))
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: wglDeleteContext failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func wglGetCurrentContext() _HGLRC {
|
|
r, _, _ := procWGLGetCurrentContext.Call()
|
|
return _HGLRC(r)
|
|
}
|
|
|
|
func wglGetCurrentDC() _HDC {
|
|
r, _, _ := procWGLGetCurrentDC.Call()
|
|
return _HDC(r)
|
|
}
|
|
|
|
func wglGetExtensionsStringARB(hdc _HDC) string {
|
|
r, _, _ := syscall.Syscall(procWGLGetExtensionsStringARB, 1, uintptr(hdc), 0, 0)
|
|
return windows.BytePtrToString((*byte)(unsafe.Pointer(r)))
|
|
}
|
|
|
|
func wglGetExtensionsStringARB_Available() bool {
|
|
return procWGLGetExtensionsStringARB != 0
|
|
}
|
|
|
|
func wglGetExtensionsStringEXT() string {
|
|
r, _, _ := syscall.Syscall(procWGLGetExtensionsStringEXT, 0, 0, 0, 0)
|
|
return windows.BytePtrToString((*byte)(unsafe.Pointer(r)))
|
|
}
|
|
|
|
func wglGetExtensionsStringEXT_Available() bool {
|
|
return procWGLGetExtensionsStringEXT != 0
|
|
}
|
|
|
|
func wglGetPixelFormatAttribivARB(hdc _HDC, iPixelFormat int32, iLayerPlane int32, nAttributes uint32, piAttributes *int32, piValues *int32) error {
|
|
r, _, e := syscall.Syscall6(procWGLGetPixelFormatAttribivARB, 6, uintptr(hdc), uintptr(iPixelFormat), uintptr(iLayerPlane), uintptr(nAttributes), uintptr(unsafe.Pointer(piAttributes)), uintptr(unsafe.Pointer(piValues)))
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: wglGetPixelFormatAttribivARB failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func wglGetProcAddress(unnamedParam1 string) uintptr {
|
|
ptr, err := windows.BytePtrFromString(unnamedParam1)
|
|
if err != nil {
|
|
panic("glfwwin: unnamedParam1 must not include a NUL character")
|
|
}
|
|
r, _, _ := procWGLGetProcAddress.Call(uintptr(unsafe.Pointer(ptr)))
|
|
return r
|
|
}
|
|
|
|
func wglMakeCurrent(unnamedParam1 _HDC, unnamedParam2 _HGLRC) error {
|
|
r, _, e := procWGLMakeCurrent.Call(uintptr(unnamedParam1), uintptr(unnamedParam2))
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: wglMakeCurrent failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func wglShareLists(unnamedParam1 _HGLRC, unnamedParam2 _HGLRC) error {
|
|
r, _, e := procWGLShareLists.Call(uintptr(unnamedParam1), uintptr(unnamedParam2))
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: wglShareLists failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func wglSwapIntervalEXT(interval int32) error {
|
|
r, _, e := syscall.Syscall(procWGLSwapIntervalEXT, 1, uintptr(interval), 0, 0)
|
|
if int32(r) == 0 {
|
|
return fmt.Errorf("glfwwin: wglSwapIntervalEXT failed: %w", e)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _WindowFromPoint(point _POINT) windows.HWND {
|
|
var r uintptr
|
|
if unsafe.Sizeof(uintptr(0)) == unsafe.Sizeof(uint64(0)) {
|
|
r, _, _ = procWindowFromPoint.Call(uintptr(point.x) | uintptr(point.y)<<32)
|
|
} else {
|
|
r, _, _ = procWindowFromPoint.Call(uintptr(point.x), uintptr(point.y))
|
|
}
|
|
return windows.HWND(r)
|
|
}
|