1117 lines
42 KiB
Go
1117 lines
42 KiB
Go
package sdl
|
|
|
|
/*
|
|
#include "sdl_wrapper.h"
|
|
static inline Sint32 ShowMessageBox(SDL_MessageBoxData data)
|
|
{
|
|
Sint32 buttonid;
|
|
SDL_ShowMessageBox(&data, &buttonid);
|
|
return buttonid;
|
|
}
|
|
|
|
#if !(SDL_VERSION_ATLEAST(2,0,1))
|
|
static void SDL_GL_GetDrawableSize(SDL_Window *window, int *w, int *h)
|
|
{
|
|
*w = 0;
|
|
*h = 0;
|
|
}
|
|
|
|
|
|
#if defined(WARN_OUTDATED)
|
|
#pragma message("SDL_WINDOW_ALLOW_HIGHDPI is not supported before SDL 2.0.1")
|
|
#endif
|
|
|
|
#define SDL_WINDOW_ALLOW_HIGHDPI (0)
|
|
|
|
|
|
#if defined(WARN_OUTDATED)
|
|
#pragma message("SDL_GL_FRAMEBUFFER_SRGB_CAPABLE is not supported before SDL 2.0.1")
|
|
#endif
|
|
|
|
#define SDL_GL_FRAMEBUFFER_SRGB_CAPABLE (0)
|
|
#endif
|
|
|
|
#if !(SDL_VERSION_ATLEAST(2,0,4))
|
|
|
|
#if defined(WARN_OUTDATED)
|
|
#pragma message("SDL_WINDOW_MOUSE_CAPTURE is not supported before SDL 2.0.4")
|
|
#endif
|
|
|
|
#define SDL_WINDOW_MOUSE_CAPTURE (0)
|
|
|
|
|
|
#if defined(WARN_OUTDATED)
|
|
#pragma message("SDL_GL_CONTEXT_RELEASE_BEHAVIOR is not supported before SDL 2.0.4")
|
|
#endif
|
|
|
|
#define SDL_GL_CONTEXT_RELEASE_BEHAVIOR (0)
|
|
|
|
|
|
#if defined(WARN_OUTDATED)
|
|
#pragma message("SDL_GetDisplayDPI is not supported before SDL 2.0.4")
|
|
#endif
|
|
|
|
static int SDL_GetDisplayDPI(int displayIndex, float* ddpi, float* hdpi, float* vdpi)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
#endif
|
|
|
|
#if !(SDL_VERSION_ATLEAST(2,0,5))
|
|
|
|
#if defined(WARN_OUTDATED)
|
|
#pragma message("SDL_SetWindowResizable is not supported before SDL 2.0.5")
|
|
#endif
|
|
|
|
static void SDL_SetWindowResizable(SDL_Window *window, SDL_bool resizable)
|
|
{
|
|
}
|
|
|
|
|
|
#if defined(WARN_OUTDATED)
|
|
#pragma message("SDL_SetWindowOpacity is not supported before SDL 2.0.5")
|
|
#endif
|
|
|
|
static int SDL_SetWindowOpacity(SDL_Window *window, float opacity)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
|
|
#if defined(WARN_OUTDATED)
|
|
#pragma message("SDL_GetWindowOpacity is not supported before SDL 2.0.5")
|
|
#endif
|
|
|
|
static int SDL_GetWindowOpacity(SDL_Window *window, float *opacity)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
|
|
#if defined(WARN_OUTDATED)
|
|
#pragma message("SDL_GetDisplayUsableBounds is not supported before SDL 2.0.5")
|
|
#endif
|
|
|
|
static int SDL_GetDisplayUsableBounds(int displayIndex, SDL_Rect* rect)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
|
|
#if defined(WARN_OUTDATED)
|
|
#pragma message("SDL_WINDOW_ALWAYS_ON_TOP is not supported before SDL 2.0.5")
|
|
#endif
|
|
|
|
#define SDL_WINDOW_ALWAYS_ON_TOP (0)
|
|
|
|
|
|
#if defined(WARN_OUTDATED)
|
|
#pragma message("SDL_WINDOW_SKIP_TASKBAR is not supported before SDL 2.0.5")
|
|
#endif
|
|
|
|
#define SDL_WINDOW_SKIP_TASKBAR (0)
|
|
|
|
|
|
#if defined(WARN_OUTDATED)
|
|
#pragma message("SDL_WINDOW_UTILITY is not supported before SDL 2.0.5")
|
|
#endif
|
|
|
|
#define SDL_WINDOW_UTILITY (0)
|
|
|
|
|
|
#if defined(WARN_OUTDATED)
|
|
#pragma message("SDL_WINDOW_TOOLTIP is not supported before SDL 2.0.5")
|
|
#endif
|
|
|
|
#define SDL_WINDOW_TOOLTIP (0)
|
|
|
|
|
|
#if defined(WARN_OUTDATED)
|
|
#pragma message("SDL_WINDOW_POPUP_MENU is not supported before SDL 2.0.5")
|
|
#endif
|
|
|
|
#define SDL_WINDOW_POPUP_MENU (0)
|
|
|
|
|
|
#if defined(WARN_OUTDATED)
|
|
#pragma message("SDL_WINDOWEVENT_TAKE_FOCUS is not supported before SDL 2.0.5")
|
|
#endif
|
|
|
|
#define SDL_WINDOWEVENT_TAKE_FOCUS (0)
|
|
|
|
|
|
#if defined(WARN_OUTDATED)
|
|
#pragma message("SDL_WINDOWEVENT_HIT_TEST is not supported before SDL 2.0.5")
|
|
#endif
|
|
|
|
#define SDL_WINDOWEVENT_HIT_TEST (0)
|
|
#endif
|
|
|
|
#if !(SDL_VERSION_ATLEAST(2,0,6))
|
|
|
|
#if defined(WARN_OUTDATED)
|
|
#pragma message("SDL_WINDOW_VULKAN is not supported before SDL 2.0.6")
|
|
#endif
|
|
|
|
#define SDL_WINDOW_VULKAN (0)
|
|
|
|
|
|
#if defined(WARN_OUTDATED)
|
|
#pragma message("SDL_GL_CONTEXT_RESET_NOTIFICATION is not supported before SDL 2.0.6")
|
|
#endif
|
|
|
|
#define SDL_GL_CONTEXT_RESET_NOTIFICATION (0)
|
|
|
|
|
|
#if defined(WARN_OUTDATED)
|
|
#pragma message("SDL_GL_CONTEXT_NO_ERROR is not supported before SDL 2.0.6")
|
|
#endif
|
|
|
|
#define SDL_GL_CONTEXT_NO_ERROR (0)
|
|
#endif
|
|
|
|
|
|
#if !(SDL_VERSION_ATLEAST(2,0,16))
|
|
|
|
#if defined(WARN_OUTDATED)
|
|
#pragma message("SDL_FlashWindow is not supported before SDL 2.0.16")
|
|
#pragma message("SDL_SetWindowAlwaysOnTop is not supported before SDL 2.0.16")
|
|
#pragma message("SDL_SetWindowKeyboardGrab is not supported before SDL 2.0.16")
|
|
#endif
|
|
|
|
typedef enum
|
|
{
|
|
SDL_FLASH_CANCEL, // Cancel any window flash state
|
|
SDL_FLASH_BRIEFLY, // Flash the window briefly to get attention
|
|
SDL_FLASH_UNTIL_FOCUSED, // Flash the window until it gets focus
|
|
} SDL_FlashOperation;
|
|
|
|
static int SDL_FlashWindow(SDL_Window * window, SDL_FlashOperation operation)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
static void SDL_SetWindowAlwaysOnTop(SDL_Window * window, SDL_bool on_top)
|
|
{
|
|
return;
|
|
}
|
|
|
|
static void SDL_SetWindowKeyboardGrab(SDL_Window * window, SDL_bool grabbed)
|
|
{
|
|
return;
|
|
}
|
|
|
|
#endif
|
|
|
|
#if !(SDL_VERSION_ATLEAST(2,0,18))
|
|
|
|
#if defined(WARN_OUTDATED)
|
|
#pragma message("SDL_GetWindowICCProfile is not supported before SDL 2.0.18")
|
|
#pragma message("SDL_SetWindowMouseRect is not supported before SDL 2.0.18")
|
|
#pragma message("SDL_GetWindowMouseRect is not supported before SDL 2.0.18")
|
|
#endif
|
|
|
|
#define SDL_WINDOWEVENT_ICCPROF_CHANGED (17) // The ICC profile of the window's display has changed.
|
|
#define SDL_WINDOWEVENT_DISPLAY_CHANGED (18) // Window has been moved to display data1.
|
|
|
|
static void* SDLCALL SDL_GetWindowICCProfile(SDL_Window * window, size_t* size)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static int SDL_SetWindowMouseRect(SDL_Window * window, const SDL_Rect * rect)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
static const SDL_Rect * SDLCALL SDL_GetWindowMouseRect(SDL_Window * window)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
#endif
|
|
*/
|
|
import "C"
|
|
import "unsafe"
|
|
|
|
// An enumeration of window states.
|
|
// (https://wiki.libsdl.org/SDL_WindowFlags)
|
|
const (
|
|
WINDOW_FULLSCREEN = C.SDL_WINDOW_FULLSCREEN // fullscreen window
|
|
WINDOW_OPENGL = C.SDL_WINDOW_OPENGL // window usable with OpenGL context
|
|
WINDOW_SHOWN = C.SDL_WINDOW_SHOWN // window is visible
|
|
WINDOW_HIDDEN = C.SDL_WINDOW_HIDDEN // window is not visible
|
|
WINDOW_BORDERLESS = C.SDL_WINDOW_BORDERLESS // no window decoration
|
|
WINDOW_RESIZABLE = C.SDL_WINDOW_RESIZABLE // window can be resized
|
|
WINDOW_MINIMIZED = C.SDL_WINDOW_MINIMIZED // window is minimized
|
|
WINDOW_MAXIMIZED = C.SDL_WINDOW_MAXIMIZED // window is maximized
|
|
WINDOW_INPUT_GRABBED = C.SDL_WINDOW_INPUT_GRABBED // window has grabbed input focus
|
|
WINDOW_INPUT_FOCUS = C.SDL_WINDOW_INPUT_FOCUS // window has input focus
|
|
WINDOW_MOUSE_FOCUS = C.SDL_WINDOW_MOUSE_FOCUS // window has mouse focus
|
|
WINDOW_FULLSCREEN_DESKTOP = C.SDL_WINDOW_FULLSCREEN_DESKTOP // fullscreen window at the current desktop resolution
|
|
WINDOW_FOREIGN = C.SDL_WINDOW_FOREIGN // window not created by SDL
|
|
WINDOW_ALLOW_HIGHDPI = C.SDL_WINDOW_ALLOW_HIGHDPI // window should be created in high-DPI mode if supported (>= SDL 2.0.1)
|
|
WINDOW_MOUSE_CAPTURE = C.SDL_WINDOW_MOUSE_CAPTURE // window has mouse captured (unrelated to INPUT_GRABBED, >= SDL 2.0.4)
|
|
WINDOW_ALWAYS_ON_TOP = C.SDL_WINDOW_ALWAYS_ON_TOP // window should always be above others (X11 only, >= SDL 2.0.5)
|
|
WINDOW_SKIP_TASKBAR = C.SDL_WINDOW_SKIP_TASKBAR // window should not be added to the taskbar (X11 only, >= SDL 2.0.5)
|
|
WINDOW_UTILITY = C.SDL_WINDOW_UTILITY // window should be treated as a utility window (X11 only, >= SDL 2.0.5)
|
|
WINDOW_TOOLTIP = C.SDL_WINDOW_TOOLTIP // window should be treated as a tooltip (X11 only, >= SDL 2.0.5)
|
|
WINDOW_POPUP_MENU = C.SDL_WINDOW_POPUP_MENU // window should be treated as a popup menu (X11 only, >= SDL 2.0.5)
|
|
WINDOW_VULKAN = C.SDL_WINDOW_VULKAN // window usable for Vulkan surface (>= SDL 2.0.6)
|
|
)
|
|
|
|
// An enumeration of window events.
|
|
// (https://wiki.libsdl.org/SDL_WindowEventID)
|
|
const (
|
|
WINDOWEVENT_NONE = C.SDL_WINDOWEVENT_NONE // (never used)
|
|
WINDOWEVENT_SHOWN = C.SDL_WINDOWEVENT_SHOWN // window has been shown
|
|
WINDOWEVENT_HIDDEN = C.SDL_WINDOWEVENT_HIDDEN // window has been hidden
|
|
WINDOWEVENT_EXPOSED = C.SDL_WINDOWEVENT_EXPOSED // window has been exposed and should be redrawn
|
|
WINDOWEVENT_MOVED = C.SDL_WINDOWEVENT_MOVED // window has been moved to data1, data2
|
|
WINDOWEVENT_RESIZED = C.SDL_WINDOWEVENT_RESIZED // window has been resized to data1xdata2; this event is always preceded by WINDOWEVENT_SIZE_CHANGED
|
|
WINDOWEVENT_SIZE_CHANGED = C.SDL_WINDOWEVENT_SIZE_CHANGED // window size has changed, either as a result of an API call or through the system or user changing the window size; this event is followed by WINDOWEVENT_RESIZED if the size was changed by an external event, i.e. the user or the window manager
|
|
WINDOWEVENT_MINIMIZED = C.SDL_WINDOWEVENT_MINIMIZED // window has been minimized
|
|
WINDOWEVENT_MAXIMIZED = C.SDL_WINDOWEVENT_MAXIMIZED // window has been maximized
|
|
WINDOWEVENT_RESTORED = C.SDL_WINDOWEVENT_RESTORED // window has been restored to normal size and position
|
|
WINDOWEVENT_ENTER = C.SDL_WINDOWEVENT_ENTER // window has gained mouse focus
|
|
WINDOWEVENT_LEAVE = C.SDL_WINDOWEVENT_LEAVE // window has lost mouse focus
|
|
WINDOWEVENT_FOCUS_GAINED = C.SDL_WINDOWEVENT_FOCUS_GAINED // window has gained keyboard focus
|
|
WINDOWEVENT_FOCUS_LOST = C.SDL_WINDOWEVENT_FOCUS_LOST // window has lost keyboard focus
|
|
WINDOWEVENT_CLOSE = C.SDL_WINDOWEVENT_CLOSE // the window manager requests that the window be closed
|
|
WINDOWEVENT_TAKE_FOCUS = C.SDL_WINDOWEVENT_TAKE_FOCUS // window is being offered a focus (should SDL_SetWindowInputFocus() on itself or a subwindow, or ignore) (>= SDL 2.0.5)
|
|
WINDOWEVENT_HIT_TEST = C.SDL_WINDOWEVENT_HIT_TEST // window had a hit test that wasn't SDL_HITTEST_NORMAL (>= SDL 2.0.5)
|
|
WINDOWEVENT_ICCPROF_CHANGED = C.SDL_WINDOWEVENT_ICCPROF_CHANGED // the ICC profile of the window's display has changed
|
|
WINDOWEVENT_DISPLAY_CHANGED = C.SDL_WINDOWEVENT_DISPLAY_CHANGED // window has been moved to display data1
|
|
)
|
|
|
|
// Window position flags.
|
|
// (https://wiki.libsdl.org/SDL_CreateWindow)
|
|
const (
|
|
WINDOWPOS_UNDEFINED_MASK = C.SDL_WINDOWPOS_UNDEFINED_MASK // used to indicate that you don't care what the window position is
|
|
WINDOWPOS_UNDEFINED = C.SDL_WINDOWPOS_UNDEFINED // used to indicate that you don't care what the window position is
|
|
WINDOWPOS_CENTERED_MASK = C.SDL_WINDOWPOS_CENTERED_MASK // used to indicate that the window position should be centered
|
|
WINDOWPOS_CENTERED = C.SDL_WINDOWPOS_CENTERED // used to indicate that the window position should be centered
|
|
)
|
|
|
|
// An enumeration of message box flags (e.g. if supported message box will display warning icon).
|
|
// (https://wiki.libsdl.org/SDL_MessageBoxFlags)
|
|
const (
|
|
MESSAGEBOX_ERROR = C.SDL_MESSAGEBOX_ERROR // error dialog
|
|
MESSAGEBOX_WARNING = C.SDL_MESSAGEBOX_WARNING // warning dialog
|
|
MESSAGEBOX_INFORMATION = C.SDL_MESSAGEBOX_INFORMATION // informational dialog
|
|
)
|
|
|
|
// Flags for MessageBoxButtonData.
|
|
const (
|
|
MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT = C.SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT // marks the default button when return is hit
|
|
MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT = C.SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT // marks the default button when escape is hit
|
|
)
|
|
|
|
// OpenGL configuration attributes.
|
|
// (https://wiki.libsdl.org/SDL_GL_SetAttribute)
|
|
const (
|
|
GL_RED_SIZE = C.SDL_GL_RED_SIZE // the minimum number of bits for the red channel of the color buffer; defaults to 3
|
|
GL_GREEN_SIZE = C.SDL_GL_GREEN_SIZE // the minimum number of bits for the green channel of the color buffer; defaults to 3
|
|
GL_BLUE_SIZE = C.SDL_GL_BLUE_SIZE // the minimum number of bits for the blue channel of the color buffer; defaults to 2
|
|
GL_ALPHA_SIZE = C.SDL_GL_ALPHA_SIZE // the minimum number of bits for the alpha channel of the color buffer; defaults to 0
|
|
GL_BUFFER_SIZE = C.SDL_GL_BUFFER_SIZE // the minimum number of bits for frame buffer size; defaults to 0
|
|
GL_DOUBLEBUFFER = C.SDL_GL_DOUBLEBUFFER // whether the output is single or double buffered; defaults to double buffering on
|
|
GL_DEPTH_SIZE = C.SDL_GL_DEPTH_SIZE // the minimum number of bits in the depth buffer; defaults to 16
|
|
GL_STENCIL_SIZE = C.SDL_GL_STENCIL_SIZE // the minimum number of bits in the stencil buffer; defaults to 0
|
|
GL_ACCUM_RED_SIZE = C.SDL_GL_ACCUM_RED_SIZE // the minimum number of bits for the red channel of the accumulation buffer; defaults to 0
|
|
GL_ACCUM_GREEN_SIZE = C.SDL_GL_ACCUM_GREEN_SIZE // the minimum number of bits for the green channel of the accumulation buffer; defaults to 0
|
|
GL_ACCUM_BLUE_SIZE = C.SDL_GL_ACCUM_BLUE_SIZE // the minimum number of bits for the blue channel of the accumulation buffer; defaults to 0
|
|
GL_ACCUM_ALPHA_SIZE = C.SDL_GL_ALPHA_SIZE // the minimum number of bits for the alpha channel of the accumulation buffer; defaults to 0
|
|
GL_STEREO = C.SDL_GL_STEREO // whether the output is stereo 3D; defaults to off
|
|
GL_MULTISAMPLEBUFFERS = C.SDL_GL_MULTISAMPLEBUFFERS // the number of buffers used for multisample anti-aliasing; defaults to 0; see Remarks for details
|
|
GL_MULTISAMPLESAMPLES = C.SDL_GL_MULTISAMPLESAMPLES // the number of samples used around the current pixel used for multisample anti-aliasing; defaults to 0; see Remarks for details
|
|
GL_ACCELERATED_VISUAL = C.SDL_GL_ACCELERATED_VISUAL // set to 1 to require hardware acceleration, set to 0 to force software rendering; defaults to allow either
|
|
GL_RETAINED_BACKING = C.SDL_GL_RETAINED_BACKING // not used (deprecated)
|
|
GL_CONTEXT_MAJOR_VERSION = C.SDL_GL_CONTEXT_MAJOR_VERSION // OpenGL context major version
|
|
GL_CONTEXT_MINOR_VERSION = C.SDL_GL_CONTEXT_MINOR_VERSION // OpenGL context minor version
|
|
GL_CONTEXT_EGL = C.SDL_GL_CONTEXT_EGL // not used (deprecated)
|
|
GL_CONTEXT_FLAGS = C.SDL_GL_CONTEXT_FLAGS // some combination of 0 or more of elements of the GLcontextFlag enumeration; defaults to 0 (https://wiki.libsdl.org/SDL_GLcontextFlag)
|
|
GL_CONTEXT_PROFILE_MASK = C.SDL_GL_CONTEXT_PROFILE_MASK // type of GL context (Core, Compatibility, ES); default value depends on platform (https://wiki.libsdl.org/SDL_GLprofile)
|
|
GL_SHARE_WITH_CURRENT_CONTEXT = C.SDL_GL_SHARE_WITH_CURRENT_CONTEXT // OpenGL context sharing; defaults to 0
|
|
GL_FRAMEBUFFER_SRGB_CAPABLE = C.SDL_GL_FRAMEBUFFER_SRGB_CAPABLE // requests sRGB capable visual; defaults to 0 (>= SDL 2.0.1)
|
|
GL_CONTEXT_RELEASE_BEHAVIOR = C.SDL_GL_CONTEXT_RELEASE_BEHAVIOR // sets context the release behavior; defaults to 1 (>= SDL 2.0.4)
|
|
GL_CONTEXT_RESET_NOTIFICATION = C.SDL_GL_CONTEXT_RESET_NOTIFICATION // (>= SDL 2.0.6)
|
|
GL_CONTEXT_NO_ERROR = C.SDL_GL_CONTEXT_NO_ERROR // (>= SDL 2.0.6)
|
|
)
|
|
|
|
// An enumeration of OpenGL profiles.
|
|
// (https://wiki.libsdl.org/SDL_GLprofile)
|
|
const (
|
|
GL_CONTEXT_PROFILE_CORE = C.SDL_GL_CONTEXT_PROFILE_CORE // OpenGL core profile - deprecated functions are disabled
|
|
GL_CONTEXT_PROFILE_COMPATIBILITY = C.SDL_GL_CONTEXT_PROFILE_COMPATIBILITY // OpenGL compatibility profile - deprecated functions are allowed
|
|
GL_CONTEXT_PROFILE_ES = C.SDL_GL_CONTEXT_PROFILE_ES // OpenGL ES profile - only a subset of the base OpenGL functionality is available
|
|
)
|
|
|
|
// An enumeration of OpenGL context configuration flags.
|
|
// (https://wiki.libsdl.org/SDL_GLcontextFlag)
|
|
const (
|
|
GL_CONTEXT_DEBUG_FLAG = C.SDL_GL_CONTEXT_DEBUG_FLAG // intended to put the GL into a "debug" mode which might offer better developer insights, possibly at a loss of performance
|
|
GL_CONTEXT_FORWARD_COMPATIBLE_FLAG = C.SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG // intended to put the GL into a "forward compatible" mode, which means that no deprecated functionality will be supported, possibly at a gain in performance, and only applies to GL 3.0 and later contexts
|
|
GL_CONTEXT_ROBUST_ACCESS_FLAG = C.SDL_GL_CONTEXT_ROBUST_ACCESS_FLAG // intended to require a GL context that supports the GL_ARB_robustness extension--a mode that offers a few APIs that are safer than the usual defaults (think snprintf() vs sprintf())
|
|
GL_CONTEXT_RESET_ISOLATION_FLAG = C.SDL_GL_CONTEXT_RESET_ISOLATION_FLAG // intended to require the GL to make promises about what to do in the face of driver or hardware failure
|
|
)
|
|
|
|
//
|
|
// Window flash operation
|
|
//
|
|
const (
|
|
FLASH_CANCEL FlashOperation = C.SDL_FLASH_CANCEL // Cancel any window flash state
|
|
FLASH_BRIEFLY = C.SDL_FLASH_BRIEFLY // Flash the window briefly to get attention
|
|
FLASH_UNTIL_FOCUSED = C.SDL_FLASH_UNTIL_FOCUSED // Flash the window until it gets focus
|
|
)
|
|
|
|
type FlashOperation C.SDL_FlashOperation
|
|
|
|
// DisplayMode contains the description of a display mode.
|
|
// (https://wiki.libsdl.org/SDL_DisplayMode)
|
|
type DisplayMode struct {
|
|
Format uint32 // one of the PixelFormatEnum values (https://wiki.libsdl.org/SDL_PixelFormatEnum)
|
|
W int32 // width, in screen coordinates
|
|
H int32 // height, in screen coordinates
|
|
RefreshRate int32 // refresh rate (in Hz), or 0 for unspecified
|
|
DriverData unsafe.Pointer // driver-specific data, initialize to 0
|
|
}
|
|
type cDisplayMode C.SDL_DisplayMode
|
|
|
|
// Window is a type used to identify a window.
|
|
type Window C.SDL_Window
|
|
|
|
// GLContext is an opaque handle to an OpenGL context.
|
|
type GLContext C.SDL_GLContext
|
|
|
|
// GLattr is an OpenGL configuration attribute.
|
|
//(https://wiki.libsdl.org/SDL_GLattr)
|
|
type GLattr C.SDL_GLattr
|
|
|
|
// MessageBoxColor contains RGB value used in an MessageBoxColorScheme.
|
|
// (https://wiki.libsdl.org/SDL_MessageBoxColor)
|
|
type MessageBoxColor struct {
|
|
R uint8 // the red component in the range 0-255
|
|
G uint8 // the green component in the range 0-255
|
|
B uint8 // the blue component in the range 0-255
|
|
}
|
|
type cMessageBoxColor C.SDL_MessageBoxColor
|
|
|
|
// MessageBoxColorScheme contains a set of colors to use for message box dialogs.
|
|
// (https://wiki.libsdl.org/SDL_MessageBoxColorScheme)
|
|
type MessageBoxColorScheme struct {
|
|
Colors [5]MessageBoxColor // background, text, button border, button background, button selected
|
|
}
|
|
type cMessageBoxColorScheme C.SDL_MessageBoxColorScheme
|
|
|
|
// MessageBoxButtonData contains individual button data for a message box.
|
|
// (https://wiki.libsdl.org/SDL_MessageBoxButtonData)
|
|
type MessageBoxButtonData struct {
|
|
Flags uint32 // MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT, MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT
|
|
ButtonID int32 // user defined button id (value returned via ShowMessageBox())
|
|
Text string // the UTF-8 button text
|
|
}
|
|
|
|
// MessageBoxData contains title, text, window and other data for a message box.
|
|
// (https://wiki.libsdl.org/SDL_MessageBoxData)
|
|
type MessageBoxData struct {
|
|
Flags uint32 // MESSAGEBOX_ERROR, MESSAGEBOX_WARNING, MESSAGEBOX_INFORMATION
|
|
Window *Window // parent window or nil
|
|
Title string
|
|
Message string
|
|
Buttons []MessageBoxButtonData
|
|
ColorScheme *MessageBoxColorScheme // nil to use system settings
|
|
}
|
|
|
|
func (window *Window) cptr() *C.SDL_Window {
|
|
return (*C.SDL_Window)(unsafe.Pointer(window))
|
|
}
|
|
|
|
func (dm *DisplayMode) cptr() *C.SDL_DisplayMode {
|
|
return (*C.SDL_DisplayMode)(unsafe.Pointer(dm))
|
|
}
|
|
|
|
func (mc *MessageBoxColor) cptr() *C.SDL_MessageBoxColor {
|
|
return (*C.SDL_MessageBoxColor)(unsafe.Pointer(mc))
|
|
}
|
|
|
|
func (mcs *MessageBoxColorScheme) cptr() *C.SDL_MessageBoxColorScheme {
|
|
return (*C.SDL_MessageBoxColorScheme)(unsafe.Pointer(mcs))
|
|
}
|
|
|
|
func (mbd *MessageBoxButtonData) cptr() *C.SDL_MessageBoxButtonData {
|
|
return (*C.SDL_MessageBoxButtonData)(unsafe.Pointer(mbd))
|
|
}
|
|
|
|
func (md *MessageBoxData) cptr() *C.SDL_MessageBoxData {
|
|
return (*C.SDL_MessageBoxData)(unsafe.Pointer(md))
|
|
}
|
|
|
|
func (attr GLattr) c() C.SDL_GLattr {
|
|
return C.SDL_GLattr(attr)
|
|
}
|
|
|
|
// GetDisplayName returns the name of a display in UTF-8 encoding.
|
|
// (https://wiki.libsdl.org/SDL_GetDisplayName)
|
|
func GetDisplayName(displayIndex int) (string, error) {
|
|
name := C.SDL_GetDisplayName(C.int(displayIndex))
|
|
if name == nil {
|
|
return "", GetError()
|
|
}
|
|
return C.GoString(name), nil
|
|
}
|
|
|
|
// GetNumVideoDisplays returns the number of available video displays.
|
|
// (https://wiki.libsdl.org/SDL_GetNumVideoDisplays)
|
|
func GetNumVideoDisplays() (int, error) {
|
|
n := int(C.SDL_GetNumVideoDisplays())
|
|
return n, errorFromInt(n)
|
|
}
|
|
|
|
// GetNumVideoDrivers returns the number of video drivers compiled into SDL.
|
|
// (https://wiki.libsdl.org/SDL_GetNumVideoDrivers)
|
|
func GetNumVideoDrivers() (int, error) {
|
|
n := int(C.SDL_GetNumVideoDrivers())
|
|
return n, errorFromInt(n)
|
|
}
|
|
|
|
// GetVideoDriver returns the name of a built in video driver.
|
|
// (https://wiki.libsdl.org/SDL_GetVideoDriver)
|
|
func GetVideoDriver(index int) string {
|
|
return string(C.GoString(C.SDL_GetVideoDriver(C.int(index))))
|
|
}
|
|
|
|
// VideoInit initializes the video subsystem, optionally specifying a video driver.
|
|
// (https://wiki.libsdl.org/SDL_VideoInit)
|
|
func VideoInit(driverName string) error {
|
|
return errorFromInt(int(
|
|
C.SDL_VideoInit(C.CString(driverName))))
|
|
}
|
|
|
|
// VideoQuit shuts down the video subsystem, if initialized with VideoInit().
|
|
// (https://wiki.libsdl.org/SDL_VideoQuit)
|
|
func VideoQuit() {
|
|
C.SDL_VideoQuit()
|
|
}
|
|
|
|
// GetCurrentVideoDriver returns the name of the currently initialized video driver.
|
|
// (https://wiki.libsdl.org/SDL_GetCurrentVideoDriver)
|
|
func GetCurrentVideoDriver() (string, error) {
|
|
name := C.SDL_GetCurrentVideoDriver()
|
|
if name == nil {
|
|
return "", GetError()
|
|
}
|
|
return C.GoString(name), nil
|
|
}
|
|
|
|
// GetNumDisplayModes returns the number of available display modes.
|
|
// (https://wiki.libsdl.org/SDL_GetNumDisplayModes)
|
|
func GetNumDisplayModes(displayIndex int) (int, error) {
|
|
n := int(C.SDL_GetNumDisplayModes(C.int(displayIndex)))
|
|
return n, errorFromInt(n)
|
|
}
|
|
|
|
// GetDisplayBounds returns the desktop area represented by a display, with the primary display located at 0,0.
|
|
// (https://wiki.libsdl.org/SDL_GetDisplayBounds)
|
|
func GetDisplayBounds(displayIndex int) (rect Rect, err error) {
|
|
err = errorFromInt(int(
|
|
C.SDL_GetDisplayBounds(C.int(displayIndex), (&rect).cptr())))
|
|
return
|
|
}
|
|
|
|
// GetDisplayUsableBounds returns the usable desktop area represented by a display, with the primary display located at 0,0.
|
|
// (https://wiki.libsdl.org/SDL_GetDisplayUsableBounds)
|
|
func GetDisplayUsableBounds(displayIndex int) (rect Rect, err error) {
|
|
err = errorFromInt(int(
|
|
C.SDL_GetDisplayUsableBounds(C.int(displayIndex), rect.cptr())))
|
|
return
|
|
}
|
|
|
|
// GetDisplayMode returns information about a specific display mode.
|
|
// (https://wiki.libsdl.org/SDL_GetDisplayMode)
|
|
func GetDisplayMode(displayIndex int, modeIndex int) (mode DisplayMode, err error) {
|
|
err = errorFromInt(int(
|
|
C.SDL_GetDisplayMode(C.int(displayIndex), C.int(modeIndex), (&mode).cptr())))
|
|
return
|
|
}
|
|
|
|
// GetDesktopDisplayMode returns information about the desktop display mode.
|
|
// (https://wiki.libsdl.org/SDL_GetDesktopDisplayMode)
|
|
func GetDesktopDisplayMode(displayIndex int) (mode DisplayMode, err error) {
|
|
err = errorFromInt(int(
|
|
C.SDL_GetDesktopDisplayMode(C.int(displayIndex), (&mode).cptr())))
|
|
return
|
|
}
|
|
|
|
// GetCurrentDisplayMode returns information about the current display mode.
|
|
// (https://wiki.libsdl.org/SDL_GetCurrentDisplayMode)
|
|
func GetCurrentDisplayMode(displayIndex int) (mode DisplayMode, err error) {
|
|
err = errorFromInt(int(
|
|
C.SDL_GetCurrentDisplayMode(C.int(displayIndex), (&mode).cptr())))
|
|
return
|
|
}
|
|
|
|
// GetClosestDisplayMode returns the closest match to the requested display mode.
|
|
// (https://wiki.libsdl.org/SDL_GetClosestDisplayMode)
|
|
func GetClosestDisplayMode(displayIndex int, mode *DisplayMode, closest *DisplayMode) (*DisplayMode, error) {
|
|
m := (*DisplayMode)(unsafe.Pointer((C.SDL_GetClosestDisplayMode(C.int(displayIndex), mode.cptr(), closest.cptr()))))
|
|
if m == nil {
|
|
return nil, GetError()
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
// GetDisplayDPI returns the dots/pixels-per-inch for a display.
|
|
// (https://wiki.libsdl.org/SDL_GetDisplayDPI)
|
|
func GetDisplayDPI(displayIndex int) (ddpi, hdpi, vdpi float32, err error) {
|
|
err = errorFromInt(int(
|
|
C.SDL_GetDisplayDPI(C.int(displayIndex), (*C.float)(unsafe.Pointer(&ddpi)), (*C.float)(unsafe.Pointer(&hdpi)), (*C.float)(unsafe.Pointer(&vdpi)))))
|
|
return
|
|
}
|
|
|
|
// GetDisplayIndex returns the index of the display associated with the window.
|
|
// (https://wiki.libsdl.org/SDL_GetWindowDisplayIndex)
|
|
func (window *Window) GetDisplayIndex() (int, error) {
|
|
i := int(C.SDL_GetWindowDisplayIndex(window.cptr()))
|
|
return i, errorFromInt(i)
|
|
}
|
|
|
|
// SetDisplayMode sets the display mode to use when the window is visible at fullscreen.
|
|
// (https://wiki.libsdl.org/SDL_SetWindowDisplayMode)
|
|
func (window *Window) SetDisplayMode(mode *DisplayMode) error {
|
|
return errorFromInt(int(
|
|
C.SDL_SetWindowDisplayMode(window.cptr(), mode.cptr())))
|
|
}
|
|
|
|
// GetDisplayMode fills in information about the display mode to use when the window is visible at fullscreen.
|
|
// (https://wiki.libsdl.org/SDL_GetWindowDisplayMode)
|
|
func (window *Window) GetDisplayMode() (mode DisplayMode, err error) {
|
|
err = errorFromInt(int(
|
|
C.SDL_GetWindowDisplayMode(window.cptr(), (&mode).cptr())))
|
|
return
|
|
}
|
|
|
|
// GetPixelFormat returns the pixel format associated with the window.
|
|
// (https://wiki.libsdl.org/SDL_GetWindowPixelFormat)
|
|
func (window *Window) GetPixelFormat() (uint32, error) {
|
|
f := (uint32)(C.SDL_GetWindowPixelFormat(window.cptr()))
|
|
if f == PIXELFORMAT_UNKNOWN {
|
|
return f, GetError()
|
|
}
|
|
return f, nil
|
|
}
|
|
|
|
// CreateWindow creates a window with the specified position, dimensions, and flags.
|
|
// (https://wiki.libsdl.org/SDL_CreateWindow)
|
|
func CreateWindow(title string, x, y, w, h int32, flags uint32) (*Window, error) {
|
|
var _window = C.SDL_CreateWindow(C.CString(title), C.int(x), C.int(y), C.int(w), C.int(h), C.Uint32(flags))
|
|
if _window == nil {
|
|
return nil, GetError()
|
|
}
|
|
return (*Window)(unsafe.Pointer(_window)), nil
|
|
}
|
|
|
|
// CreateWindowFrom creates an SDL window from an existing native window.
|
|
// (https://wiki.libsdl.org/SDL_CreateWindowFrom)
|
|
func CreateWindowFrom(data unsafe.Pointer) (*Window, error) {
|
|
_window := C.SDL_CreateWindowFrom(data)
|
|
if _window == nil {
|
|
return nil, GetError()
|
|
}
|
|
return (*Window)(unsafe.Pointer(_window)), nil
|
|
}
|
|
|
|
// Destroy destroys the window.
|
|
// (https://wiki.libsdl.org/SDL_DestroyWindow)
|
|
func (window *Window) Destroy() error {
|
|
lastErr := GetError()
|
|
ClearError()
|
|
C.SDL_DestroyWindow(window.cptr())
|
|
err := GetError()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
SetError(lastErr)
|
|
return nil
|
|
}
|
|
|
|
// GetID returns the numeric ID of the window, for logging purposes.
|
|
// (https://wiki.libsdl.org/SDL_GetWindowID)
|
|
func (window *Window) GetID() (uint32, error) {
|
|
id := uint32(C.SDL_GetWindowID(window.cptr()))
|
|
if id == 0 {
|
|
return 0, GetError()
|
|
}
|
|
return id, nil
|
|
}
|
|
|
|
// GetWindowFromID returns a window from a stored ID.
|
|
// (https://wiki.libsdl.org/SDL_GetWindowFromID)
|
|
func GetWindowFromID(id uint32) (*Window, error) {
|
|
_window := C.SDL_GetWindowFromID(C.Uint32(id))
|
|
if _window == nil {
|
|
return nil, GetError()
|
|
}
|
|
return (*Window)(unsafe.Pointer((_window))), nil
|
|
}
|
|
|
|
// GetFlags returns the window flags.
|
|
// (https://wiki.libsdl.org/SDL_GetWindowFlags)
|
|
func (window *Window) GetFlags() uint32 {
|
|
return (uint32)(C.SDL_GetWindowFlags(window.cptr()))
|
|
}
|
|
|
|
// SetTitle sets the title of the window.
|
|
// (https://wiki.libsdl.org/SDL_SetWindowTitle)
|
|
func (window *Window) SetTitle(title string) {
|
|
C.SDL_SetWindowTitle(window.cptr(), C.CString(title))
|
|
}
|
|
|
|
// GetTitle returns the title of the window.
|
|
// (https://wiki.libsdl.org/SDL_GetWindowTitle)
|
|
func (window *Window) GetTitle() string {
|
|
return C.GoString(C.SDL_GetWindowTitle(window.cptr()))
|
|
}
|
|
|
|
// SetIcon sets the icon for the window.
|
|
// (https://wiki.libsdl.org/SDL_SetWindowIcon)
|
|
func (window *Window) SetIcon(icon *Surface) {
|
|
C.SDL_SetWindowIcon(window.cptr(), icon.cptr())
|
|
}
|
|
|
|
// SetData associates an arbitrary named pointer with the window.
|
|
// (https://wiki.libsdl.org/SDL_SetWindowData)
|
|
func (window *Window) SetData(name string, userdata unsafe.Pointer) unsafe.Pointer {
|
|
return unsafe.Pointer(C.SDL_SetWindowData(window.cptr(), C.CString(name), userdata))
|
|
}
|
|
|
|
// GetData returns the data pointer associated with the window.
|
|
// (https://wiki.libsdl.org/SDL_GetWindowData)
|
|
func (window *Window) GetData(name string) unsafe.Pointer {
|
|
return unsafe.Pointer(C.SDL_GetWindowData(window.cptr(), C.CString(name)))
|
|
}
|
|
|
|
// SetPosition sets the position of the window.
|
|
// (https://wiki.libsdl.org/SDL_SetWindowPosition)
|
|
func (window *Window) SetPosition(x, y int32) {
|
|
C.SDL_SetWindowPosition(window.cptr(), C.int(x), C.int(y))
|
|
}
|
|
|
|
// GetPosition returns the position of the window.
|
|
// (https://wiki.libsdl.org/SDL_GetWindowPosition)
|
|
func (window *Window) GetPosition() (x, y int32) {
|
|
var _x, _y C.int
|
|
C.SDL_GetWindowPosition(window.cptr(), &_x, &_y)
|
|
return int32(_x), int32(_y)
|
|
}
|
|
|
|
// SetResizable sets the user-resizable state of the window.
|
|
// (https://wiki.libsdl.org/SDL_SetWindowResizable)
|
|
func (window *Window) SetResizable(resizable bool) {
|
|
C.SDL_SetWindowResizable(window.cptr(), C.SDL_bool(Btoi(resizable)))
|
|
}
|
|
|
|
// SetSize sets the size of the window's client area.
|
|
// (https://wiki.libsdl.org/SDL_SetWindowSize)
|
|
func (window *Window) SetSize(w, h int32) {
|
|
C.SDL_SetWindowSize(window.cptr(), C.int(w), C.int(h))
|
|
}
|
|
|
|
// GetSize returns the size of the window's client area.
|
|
// (https://wiki.libsdl.org/SDL_GetWindowSize)
|
|
func (window *Window) GetSize() (w, h int32) {
|
|
var _w, _h C.int
|
|
C.SDL_GetWindowSize(window.cptr(), &_w, &_h)
|
|
return int32(_w), int32(_h)
|
|
}
|
|
|
|
// SetMinimumSize sets the minimum size of the window's client area.
|
|
// (https://wiki.libsdl.org/SDL_SetWindowMinimumSize)
|
|
func (window *Window) SetMinimumSize(minW, minH int32) {
|
|
C.SDL_SetWindowMinimumSize(window.cptr(), C.int(minW), C.int(minH))
|
|
}
|
|
|
|
// GetMinimumSize returns the minimum size of the window's client area.
|
|
// (https://wiki.libsdl.org/SDL_GetWindowMinimumSize)
|
|
func (window *Window) GetMinimumSize() (w, h int32) {
|
|
var _w, _h C.int
|
|
C.SDL_GetWindowMinimumSize(window.cptr(), &_w, &_h)
|
|
return int32(_w), int32(_h)
|
|
}
|
|
|
|
// SetMaximumSize sets the maximum size of the window's client area.
|
|
// (https://wiki.libsdl.org/SDL_SetWindowMaximumSize)
|
|
func (window *Window) SetMaximumSize(maxW, maxH int32) {
|
|
C.SDL_SetWindowMaximumSize(window.cptr(), C.int(maxW), C.int(maxH))
|
|
}
|
|
|
|
// GetMaximumSize returns the maximum size of the window's client area.
|
|
// (https://wiki.libsdl.org/SDL_GetWindowMaximumSize)
|
|
func (window *Window) GetMaximumSize() (w, h int32) {
|
|
var _w, _h C.int
|
|
C.SDL_GetWindowMaximumSize(window.cptr(), &_w, &_h)
|
|
return int32(_w), int32(_h)
|
|
}
|
|
|
|
// SetBordered sets the border state of the window.
|
|
// (https://wiki.libsdl.org/SDL_SetWindowBordered)
|
|
func (window *Window) SetBordered(bordered bool) {
|
|
C.SDL_SetWindowBordered(window.cptr(), C.SDL_bool(Btoi(bordered)))
|
|
}
|
|
|
|
// Show shows the window.
|
|
// (https://wiki.libsdl.org/SDL_ShowWindow)
|
|
func (window *Window) Show() {
|
|
C.SDL_ShowWindow(window.cptr())
|
|
}
|
|
|
|
// Hide hides the window.
|
|
// (https://wiki.libsdl.org/SDL_HideWindow)
|
|
func (window *Window) Hide() {
|
|
C.SDL_HideWindow(window.cptr())
|
|
}
|
|
|
|
// Raise raises the window above other windows and set the input focus.
|
|
// (https://wiki.libsdl.org/SDL_RaiseWindow)
|
|
func (window *Window) Raise() {
|
|
C.SDL_RaiseWindow(window.cptr())
|
|
}
|
|
|
|
// Maximize makes the window as large as possible.
|
|
// (https://wiki.libsdl.org/SDL_MaximizeWindow)
|
|
func (window *Window) Maximize() {
|
|
C.SDL_MaximizeWindow(window.cptr())
|
|
}
|
|
|
|
// Minimize minimizes the window to an iconic representation.
|
|
// (https://wiki.libsdl.org/SDL_MinimizeWindow)
|
|
func (window *Window) Minimize() {
|
|
C.SDL_MinimizeWindow(window.cptr())
|
|
}
|
|
|
|
// Restore restores the size and position of a minimized or maximized window.
|
|
// (https://wiki.libsdl.org/SDL_RestoreWindow)
|
|
func (window *Window) Restore() {
|
|
C.SDL_RestoreWindow(window.cptr())
|
|
}
|
|
|
|
// SetFullscreen sets the window's fullscreen state.
|
|
// (https://wiki.libsdl.org/SDL_SetWindowFullscreen)
|
|
func (window *Window) SetFullscreen(flags uint32) error {
|
|
return errorFromInt(int(
|
|
C.SDL_SetWindowFullscreen(window.cptr(), C.Uint32(flags))))
|
|
}
|
|
|
|
// GetSurface returns the SDL surface associated with the window.
|
|
// (https://wiki.libsdl.org/SDL_GetWindowSurface)
|
|
func (window *Window) GetSurface() (*Surface, error) {
|
|
surface := (*Surface)(unsafe.Pointer(C.SDL_GetWindowSurface(window.cptr())))
|
|
if surface == nil {
|
|
return nil, GetError()
|
|
}
|
|
return surface, nil
|
|
}
|
|
|
|
// UpdateSurface copies the window surface to the screen.
|
|
// (https://wiki.libsdl.org/SDL_UpdateWindowSurface)
|
|
func (window *Window) UpdateSurface() error {
|
|
return errorFromInt(int(
|
|
C.SDL_UpdateWindowSurface(window.cptr())))
|
|
}
|
|
|
|
// UpdateSurfaceRects copies areas of the window surface to the screen.
|
|
// (https://wiki.libsdl.org/SDL_UpdateWindowSurfaceRects)
|
|
func (window *Window) UpdateSurfaceRects(rects []Rect) error {
|
|
return errorFromInt(int(
|
|
C.SDL_UpdateWindowSurfaceRects(window.cptr(), rects[0].cptr(), C.int(len(rects)))))
|
|
}
|
|
|
|
// SetGrab sets the window's input grab mode.
|
|
// (https://wiki.libsdl.org/SDL_SetWindowGrab)
|
|
func (window *Window) SetGrab(grabbed bool) {
|
|
C.SDL_SetWindowGrab(window.cptr(), C.SDL_bool((Btoi(grabbed))))
|
|
}
|
|
|
|
// GetGrab returns the window's input grab mode.
|
|
// (https://wiki.libsdl.org/SDL_GetWindowGrab)
|
|
func (window *Window) GetGrab() bool {
|
|
return C.SDL_GetWindowGrab(window.cptr()) != 0
|
|
}
|
|
|
|
// SetBrightness sets the brightness (gamma multiplier) for the display that owns the given window.
|
|
// (https://wiki.libsdl.org/SDL_SetWindowBrightness)
|
|
func (window *Window) SetBrightness(brightness float32) error {
|
|
return errorFromInt(int(
|
|
C.SDL_SetWindowBrightness(window.cptr(), C.float(brightness))))
|
|
}
|
|
|
|
// GetBrightness returns the brightness (gamma multiplier) for the display that owns the given window.
|
|
// (https://wiki.libsdl.org/SDL_GetWindowBrightness)
|
|
func (window *Window) GetBrightness() float32 {
|
|
return float32(C.SDL_GetWindowBrightness(window.cptr()))
|
|
}
|
|
|
|
// SetGammaRamp sets the gamma ramp for the display that owns the given window.
|
|
// (https://wiki.libsdl.org/SDL_SetWindowGammaRamp)
|
|
func (window *Window) SetGammaRamp(red, green, blue *[256]uint16) error {
|
|
return errorFromInt(int(
|
|
C.SDL_SetWindowGammaRamp(
|
|
window.cptr(),
|
|
(*C.Uint16)(unsafe.Pointer(red)),
|
|
(*C.Uint16)(unsafe.Pointer(green)),
|
|
(*C.Uint16)(unsafe.Pointer(blue)))))
|
|
}
|
|
|
|
// GetGammaRamp returns the gamma ramp for the display that owns a given window.
|
|
// (https://wiki.libsdl.org/SDL_GetWindowGammaRamp)
|
|
func (window *Window) GetGammaRamp() (red, green, blue *[256]uint16, err error) {
|
|
code := int(C.SDL_GetWindowGammaRamp(
|
|
window.cptr(),
|
|
(*C.Uint16)(unsafe.Pointer(red)),
|
|
(*C.Uint16)(unsafe.Pointer(green)),
|
|
(*C.Uint16)(unsafe.Pointer(blue))))
|
|
return red, green, blue, errorFromInt(code)
|
|
}
|
|
|
|
// SetWindowOpacity sets the opacity of the window.
|
|
// (https://wiki.libsdl.org/SDL_SetWindowOpacity)
|
|
func (window *Window) SetWindowOpacity(opacity float32) error {
|
|
return errorFromInt(int(
|
|
C.SDL_SetWindowOpacity(window.cptr(), C.float(opacity))))
|
|
}
|
|
|
|
// GetWindowOpacity returns the opacity of the window.
|
|
// (https://wiki.libsdl.org/SDL_GetWindowOpacity)
|
|
func (window *Window) GetWindowOpacity() (opacity float32, err error) {
|
|
return opacity, errorFromInt(int(
|
|
C.SDL_GetWindowOpacity(window.cptr(), (*C.float)(unsafe.Pointer(&opacity)))))
|
|
}
|
|
|
|
// ShowSimpleMessageBox displays a simple modal message box.
|
|
// (https://wiki.libsdl.org/SDL_ShowSimpleMessageBox)
|
|
func ShowSimpleMessageBox(flags uint32, title, message string, window *Window) error {
|
|
_title := C.CString(title)
|
|
defer C.free(unsafe.Pointer(_title))
|
|
_message := C.CString(message)
|
|
defer C.free(unsafe.Pointer(_message))
|
|
return errorFromInt(int(
|
|
C.SDL_ShowSimpleMessageBox(C.Uint32(flags), _title, _message, window.cptr())))
|
|
}
|
|
|
|
// ShowMessageBox creates a modal message box.
|
|
// (https://wiki.libsdl.org/SDL_ShowMessageBox)
|
|
func ShowMessageBox(data *MessageBoxData) (buttonid int32, err error) {
|
|
_title := C.CString(data.Title)
|
|
defer C.free(unsafe.Pointer(_title))
|
|
_message := C.CString(data.Message)
|
|
defer C.free(unsafe.Pointer(_message))
|
|
|
|
var cbuttons []C.SDL_MessageBoxButtonData
|
|
var cbtntexts []*C.char
|
|
defer func(texts []*C.char) {
|
|
for _, t := range texts {
|
|
C.free(unsafe.Pointer(t))
|
|
}
|
|
}(cbtntexts)
|
|
|
|
for _, btn := range data.Buttons {
|
|
ctext := C.CString(btn.Text)
|
|
cbtn := C.SDL_MessageBoxButtonData{
|
|
flags: C.Uint32(btn.Flags),
|
|
buttonid: C.int(btn.ButtonID),
|
|
text: ctext,
|
|
}
|
|
|
|
cbuttons = append(cbuttons, cbtn)
|
|
cbtntexts = append(cbtntexts, ctext)
|
|
}
|
|
|
|
var buttonPtr *C.SDL_MessageBoxButtonData
|
|
if len(cbuttons) > 0 {
|
|
buttonPtr = &cbuttons[0]
|
|
}
|
|
cdata := C.SDL_MessageBoxData{
|
|
flags: C.Uint32(data.Flags),
|
|
window: data.Window.cptr(),
|
|
title: _title,
|
|
message: _message,
|
|
numbuttons: C.int(len(data.Buttons)),
|
|
buttons: buttonPtr,
|
|
colorScheme: data.ColorScheme.cptr(),
|
|
}
|
|
|
|
buttonid = int32(C.ShowMessageBox(cdata))
|
|
return buttonid, errorFromInt(int(buttonid))
|
|
}
|
|
|
|
// IsScreenSaverEnabled reports whether the screensaver is currently enabled.
|
|
// (https://wiki.libsdl.org/SDL_IsScreenSaverEnabled)
|
|
func IsScreenSaverEnabled() bool {
|
|
return C.SDL_IsScreenSaverEnabled() != 0
|
|
}
|
|
|
|
// EnableScreenSaver allows the screen to be blanked by a screen saver.
|
|
// (https://wiki.libsdl.org/SDL_EnableScreenSaver)
|
|
func EnableScreenSaver() {
|
|
C.SDL_EnableScreenSaver()
|
|
}
|
|
|
|
// DisableScreenSaver prevents the screen from being blanked by a screen saver.
|
|
// (https://wiki.libsdl.org/SDL_DisableScreenSaver)
|
|
func DisableScreenSaver() {
|
|
C.SDL_DisableScreenSaver()
|
|
}
|
|
|
|
// GLLoadLibrary dynamically loads an OpenGL library.
|
|
// (https://wiki.libsdl.org/SDL_GL_LoadLibrary)
|
|
func GLLoadLibrary(path string) error {
|
|
return errorFromInt(int(
|
|
C.SDL_GL_LoadLibrary(C.CString(path))))
|
|
}
|
|
|
|
// GLGetProcAddress returns an OpenGL function by name.
|
|
// (https://wiki.libsdl.org/SDL_GL_GetProcAddress)
|
|
func GLGetProcAddress(proc string) unsafe.Pointer {
|
|
return unsafe.Pointer(C.SDL_GL_GetProcAddress(C.CString(proc)))
|
|
}
|
|
|
|
// GLUnloadLibrary unloads the OpenGL library previously loaded by GLLoadLibrary().
|
|
// (https://wiki.libsdl.org/SDL_GL_UnloadLibrary)
|
|
func GLUnloadLibrary() {
|
|
C.SDL_GL_UnloadLibrary()
|
|
}
|
|
|
|
// GLExtensionSupported reports whether an OpenGL extension is supported for the current context.
|
|
// (https://wiki.libsdl.org/SDL_GL_ExtensionSupported)
|
|
func GLExtensionSupported(extension string) bool {
|
|
return C.SDL_GL_ExtensionSupported(C.CString(extension)) != 0
|
|
}
|
|
|
|
// GLSetAttribute sets an OpenGL window attribute before window creation.
|
|
// (https://wiki.libsdl.org/SDL_GL_SetAttribute)
|
|
func GLSetAttribute(attr GLattr, value int) error {
|
|
return errorFromInt(int(
|
|
C.SDL_GL_SetAttribute(attr.c(), C.int(value))))
|
|
}
|
|
|
|
// GLGetAttribute returns the actual value for an attribute from the current context.
|
|
// (https://wiki.libsdl.org/SDL_GL_GetAttribute)
|
|
func GLGetAttribute(attr GLattr) (int, error) {
|
|
var _value C.int
|
|
if C.SDL_GL_GetAttribute(attr.c(), &_value) != 0 {
|
|
return int(_value), GetError()
|
|
}
|
|
return int(_value), nil
|
|
}
|
|
|
|
// GLCreateContext creates an OpenGL context for use with an OpenGL window, and make it current.
|
|
// (https://wiki.libsdl.org/SDL_GL_CreateContext)
|
|
func (window *Window) GLCreateContext() (GLContext, error) {
|
|
c := GLContext(C.SDL_GL_CreateContext(window.cptr()))
|
|
if c == nil {
|
|
return nil, GetError()
|
|
}
|
|
return c, nil
|
|
}
|
|
|
|
// GLMakeCurrent sets up an OpenGL context for rendering into an OpenGL window.
|
|
// (https://wiki.libsdl.org/SDL_GL_MakeCurrent)
|
|
func (window *Window) GLMakeCurrent(glcontext GLContext) error {
|
|
return errorFromInt(int(
|
|
C.SDL_GL_MakeCurrent(window.cptr(), C.SDL_GLContext(glcontext))))
|
|
}
|
|
|
|
// GLSetSwapInterval sets the swap interval for the current OpenGL context.
|
|
// (https://wiki.libsdl.org/SDL_GL_SetSwapInterval)
|
|
func GLSetSwapInterval(interval int) error {
|
|
return errorFromInt(int(
|
|
C.SDL_GL_SetSwapInterval(C.int(interval))))
|
|
}
|
|
|
|
// GLGetSwapInterval returns the swap interval for the current OpenGL context.
|
|
// (https://wiki.libsdl.org/SDL_GL_GetSwapInterval)
|
|
func GLGetSwapInterval() (int, error) {
|
|
i := int(C.SDL_GL_GetSwapInterval())
|
|
// -1 means adaptive vsync, not an error
|
|
// 0 means vsync off
|
|
// 1 means vsync on
|
|
if i == -1 || i == 0 || i == 1 {
|
|
return i, nil
|
|
}
|
|
// any other value should be an error
|
|
return i, errorFromInt(i)
|
|
}
|
|
|
|
// GLGetDrawableSize returns the size of a window's underlying drawable in pixels (for use with glViewport).
|
|
// (https://wiki.libsdl.org/SDL_GL_GetDrawableSize)
|
|
func (window *Window) GLGetDrawableSize() (w, h int32) {
|
|
var _w, _h C.int
|
|
C.SDL_GL_GetDrawableSize(window.cptr(), &_w, &_h)
|
|
return int32(_w), int32(_h)
|
|
}
|
|
|
|
// GLSwap updates a window with OpenGL rendering.
|
|
// (https://wiki.libsdl.org/SDL_GL_SwapWindow)
|
|
func (window *Window) GLSwap() {
|
|
C.SDL_GL_SwapWindow(window.cptr())
|
|
}
|
|
|
|
// GLDeleteContext deletes an OpenGL context.
|
|
// (https://wiki.libsdl.org/SDL_GL_DeleteContext)
|
|
func GLDeleteContext(context GLContext) {
|
|
C.SDL_GL_DeleteContext(C.SDL_GLContext(context))
|
|
}
|
|
|
|
// Flash requests the window to demand attention from the user.
|
|
// (https://wiki.libsdl.org/SDL_FlashWindow)
|
|
func (window *Window) Flash(operation FlashOperation) (err error) {
|
|
return errorFromInt(int(C.SDL_FlashWindow(window.cptr(), C.SDL_FlashOperation(operation))))
|
|
}
|
|
|
|
// SetAlwaysOnTop sets the window to always be above the others.
|
|
// (https://wiki.libsdl.org/SDL_SetWindowAlwaysOnTop)
|
|
func (window *Window) SetAlwaysOnTop(onTop bool) {
|
|
C.SDL_SetWindowAlwaysOnTop(window.cptr(), C.SDL_bool(Btoi(onTop)))
|
|
}
|
|
|
|
// SetKeyboardGrab sets a window's keyboard grab mode.
|
|
// (https://wiki.libsdl.org/SDL_GetWindowKeyboardGrab)
|
|
func (window *Window) SetKeyboardGrab(grabbed bool) {
|
|
C.SDL_SetWindowKeyboardGrab(window.cptr(), C.SDL_bool(Btoi(grabbed)))
|
|
}
|
|
|
|
// GetICCProfile gets the raw ICC profile data for the screen the window is currently on.
|
|
//
|
|
// Data returned should be freed with SDL_free.
|
|
//
|
|
// (https://wiki.libsdl.org/SDL_GetWindowICCProfile)
|
|
func (window *Window) GetICCProfile() (iccProfile unsafe.Pointer, size uintptr, err error) {
|
|
_size := (*C.size_t)(unsafe.Pointer(&size))
|
|
iccProfile = C.SDL_GetWindowICCProfile(window.cptr(), _size)
|
|
if iccProfile == nil {
|
|
err = GetError()
|
|
}
|
|
return
|
|
}
|
|
|
|
// SetMouseRect confines the cursor to the specified area of a window.
|
|
//
|
|
// Note that this does NOT grab the cursor, it only defines the area a cursor
|
|
// is restricted to when the window has mouse focus.
|
|
//
|
|
// (https://wiki.libsdl.org/SDL_SetWindowMouseRect)
|
|
func (window *Window) SetMouseRect(rect Rect) (err error) {
|
|
_rect := (*C.SDL_Rect)(unsafe.Pointer(&rect))
|
|
err = errorFromInt(int(C.SDL_SetWindowMouseRect(window.cptr(), _rect)))
|
|
return
|
|
}
|
|
|
|
// GetMouseRect gets the mouse confinement rectangle of a window.
|
|
// (https://wiki.libsdl.org/SDL_GetWindowMouseRect)
|
|
func (window *Window) GetMouseRect() (rect Rect) {
|
|
_rect := C.SDL_GetWindowMouseRect(window.cptr())
|
|
rect = *((*Rect)(unsafe.Pointer(_rect)))
|
|
return
|
|
}
|