ebiten

package module
v2.3.0-alpha.6 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 2, 2022 License: Apache-2.0 Imports: 17 Imported by: 3,906

README

Ebiten (v2)

Go Reference Build Status

A dead simple 2D game library for Go

Ebiten is an open source game library for the Go programming language. Ebiten's simple API allows you to quickly and easily develop 2D games that can be deployed across multiple platforms.

Overview

Platforms

Note: External (bluetooth) keyboards are not available on iOS yet.

For installation on desktops, see the installation instruction.

Features

  • 2D Graphics (Geometry and color transformation by matrices, Various composition modes, Offscreen rendering, Text rendering, Automatic batches, Automatic texture atlas, Custom shaders)
  • Input (Mouse, Keyboard, Gamepads, Touches)
  • Audio (Ogg/Vorbis, MP3, WAV, PCM)

Packages

Community

License

Ebiten is licensed under Apache license version 2.0. See LICENSE file.

The Ebiten logo by Hajime Hoshi is licensed under the Creative Commons Attribution-NoDerivatives 4.0.

Documentation

Overview

Package ebiten provides graphics and input API to develop a 2D game.

You can start the game by calling the function RunGame. 

// Game implements ebiten.Game interface.
type Game struct{}

// Update proceeds the game state.
// Update is called every tick (1/60 [s] by default).
func (g *Game) Update() error {
    // Write your game's logical update.
    return nil
}

// Draw draws the game screen.
// Draw is called every frame (typically 1/60[s] for 60Hz display).
func (g *Game) Draw(screen *ebiten.Image) {
    // Write your game's rendering.
}

// Layout takes the outside size (e.g., the window size) and returns the (logical) screen size.
// If you don't have to adjust the screen size with the outside size, just return a fixed size.
func (g *Game) Layout(outsideWidth, outsideHeight int) (screenWidth, screenHeight int) {
    return 320, 240
}

func main() {
    game := &Game{}
    // Specify the window size as you like. Here, a doubled size is specified.
    ebiten.SetWindowSize(640, 480)
    ebiten.SetWindowTitle("Your game's title")
    // Call ebiten.RunGame to start your game loop.
    if err := ebiten.RunGame(game); err != nil {
        log.Fatal(err)
    }
}

In the API document, 'the main thread' means the goroutine in init(), main() and their callees without 'go' statement. It is assured that 'the main thread' runs on the OS main thread. There are some Ebiten functions (e.g., DeviceScaleFactor) that must be called on the main thread under some conditions (typically, before ebiten.RunGame is called).

Environment variables

`EBITEN_SCREENSHOT_KEY` environment variable specifies the key to take a screenshot. For example, if you run your game with `EBITEN_SCREENSHOT_KEY=q`, you can take a game screen's screenshot by pressing Q key. This works only on desktops.

`EBITEN_INTERNAL_IMAGES_KEY` environment variable specifies the key to dump all the internal images. This is valid only when the build tag 'ebitendebug' is specified. This works only on desktops.

`EBITEN_GRAPHICS_LIBRARY` environment variable specifies the graphics library. If the specified graphics library is not available, RunGame returns an error. This can take one of the following value: 

"auto":    Ebiten chooses the graphics library automatically. This is the default value.
"opengl":  OpenGL, OpenGL ES, or WebGL.
"directx": DirectX. This works only on Windows.
"metal":   Metal. This works only on macOS or iOS.

`EBITEN_DIRECTX` environment variable specifies various parameters for DirectX. You can specify multiple values separated by a comma. The default value is empty (i.e. no parameters). 

"warp":  Use WARP (i.e. software rendering).
"debug": Use a debug layer.

Build tags

`ebitendebug` outputs a log of graphics commands. This is useful to know what happens in Ebiten. In general, the number of graphics commands affects the performance of your game.

`ebitenwebgl1` forces to use WebGL 1 on browsers.

`ebitensinglethread` disables Ebiten's thread safety to unlock maximum performance. If you use this you will have to manage threads yourself. Functions like IsKeyPressed will no longer be concurrent-safe with this build tag. They must be called from the main thread or the same goroutine as the given game's callback functions like Update to RunGame.

`ebitenexternaldll` stops embedding DLL file in a Windows executable. `ebitenexternaldll` works only for Windows. The executable will require a DLL file at the working directory. Copy them from Ebiten repository's `internal/glfw`:

  • `glfw_windows_386.dll` for Windows 386
  • `glfw_windows_amd64.dll` for Windows amd64

The directory path can be obtained by Go commands. For example, on PowerShell: 

$dir = go list -f '{{.Dir}}' github.com/hajimehoshi/ebiten/v2/internal/glfw
echo $dir\glfw_windows_amd64.dll

and on shell: 

echo $(go list -f '{{.Dir}}' github.com/hajimehoshi/ebiten/v2/internal/glfw)/glfw_windows_amd64.dll

Embedding a DLL and extracting it on the fly might be problematic on Windows since the application might be unexpectedly recognized as a virus by some virus checkers. `ebitenexternaldll` is useful for such cases. See #1832 for the discussion.

Index

Constants

View Source 
const ColorMDim = affine.ColorMDim

ColorMDim is a dimension of a ColorM.

View Source 
const DefaultTPS = ui.DefaultTPS

DefaultTPS represents a default ticks per second, that represents how many times game updating happens in a second.

View Source 
const GeoMDim = 3

GeoMDim is a dimension of a GeoM.

View Source 
const MaxIndicesNum = graphics.IndicesNum

MaxIndicesNum is the maximum number of indices for DrawTriangles.

View Source 
const SyncWithFPS = clock.SyncWithFPS

SyncWithFPS is a special TPS value that means TPS syncs with FPS.

View Source 
const UncappedTPS = SyncWithFPS

UncappedTPS is a special TPS value that means TPS syncs with FPS.

Deprecated: as of v2.2. Use SyncWithFPS instead.

Variables

This section is empty.

Functions

func AppendInputChars added in v2.2.0 

func AppendInputChars(runes []rune) []rune

AppendInputChars appends "printable" runes, read from the keyboard at the time update is called, to runes, and returns the extended buffer. Giving a slice that already has enough capacity works efficiently.

AppendInputChars represents the environment's locale-dependent translation of keyboard input to Unicode characters. On the other hand, Key represents a physical key of US keyboard layout

"Control" and modifier keys should be handled with IsKeyPressed.

AppendInputChars is concurrent-safe.

On Android (ebitenmobile), EbitenView must be focusable to enable to handle keyboard keys.

Keyboards don't work on iOS yet (#1090).

func CurrentFPS 

func CurrentFPS() float64

CurrentFPS returns the current number of FPS (frames per second), that represents how many swapping buffer happens per second.

On some environments, CurrentFPS doesn't return a reliable value since vsync doesn't work well there. If you want to measure the application's speed, Use CurrentTPS.

This value is for measurement and/or debug, and your game logic should not rely on this value.

CurrentFPS is concurrent-safe.

func CurrentTPS 

func CurrentTPS() float64

CurrentTPS returns the current TPS (ticks per second), that represents how many update function is called in a second.

This value is for measurement and/or debug, and your game logic should not rely on this value.

CurrentTPS is concurrent-safe.

func CursorPosition 

func CursorPosition() (x, y int)

CursorPosition returns a position of a mouse cursor relative to the game screen (window). The cursor position is 'logical' position and this considers the scale of the screen.

CursorPosition returns (0, 0) before the main loop on desktops and browsers.

CursorPosition always returns (0, 0) on mobiles.

CursorPosition is concurrent-safe.

func DeviceScaleFactor 

func DeviceScaleFactor() float64

DeviceScaleFactor returns a device scale factor value of the current monitor which the window belongs to.

DeviceScaleFactor returns a meaningful value on high-DPI display environment, otherwise DeviceScaleFactor returns 1.

DeviceScaleFactor might panic on init function on some devices like Android. Then, it is not recommended to call DeviceScaleFactor from init functions.

DeviceScaleFactor must be called on the main thread before the main loop, and is concurrent-safe after the main loop.

DeviceScaleFactor is concurrent-safe.

BUG: DeviceScaleFactor value is not affected by SetWindowPosition before RunGame (#1575).

func GamepadAxis deprecated 

func GamepadAxis(id GamepadID, axis int) float64

GamepadAxis returns a float value [-1.0 - 1.0] of the given gamepad (id)'s axis (axis).

Deprecated: as of v2.2. Use GamepadAxisValue instead.

func GamepadAxisNum 

func GamepadAxisNum(id GamepadID) int

GamepadAxisNum returns the number of axes of the gamepad (id).

GamepadAxisNum is concurrent-safe.

func GamepadAxisValue added in v2.2.0 

func GamepadAxisValue(id GamepadID, axis int) float64

GamepadAxisValue returns a float value [-1.0 - 1.0] of the given gamepad (id)'s axis (axis).

GamepadAxisValue is concurrent-safe.

func GamepadButtonNum 

func GamepadButtonNum(id GamepadID) int

GamepadButtonNum returns the number of the buttons of the given gamepad (id).

GamepadButtonNum is concurrent-safe.

func GamepadName 

func GamepadName(id GamepadID) string

GamepadName returns a string with the name. This function may vary in how it returns descriptions for the same device across platforms. for example the following drivers/platforms see a Xbox One controller as the following:

  • Windows: "Xbox Controller"
  • Chrome: "Xbox 360 Controller (XInput STANDARD GAMEPAD)"
  • Firefox: "xinput"

GamepadName is concurrent-safe.

func GamepadSDLID 

func GamepadSDLID(id GamepadID) string

GamepadSDLID returns a string with the GUID generated in the same way as SDL. To detect devices, see also the community project of gamepad devices database: https://github.com/gabomdq/SDL_GameControllerDB

GamepadSDLID always returns an empty string on browsers and mobiles.

GamepadSDLID is concurrent-safe.

func InputChars deprecated 

func InputChars() []rune

InputChars return "printable" runes read from the keyboard at the time update is called.

Deprecated: as of v2.2. Use AppendInputChars instead.

func IsFocused 

func IsFocused() bool

IsFocused returns a boolean value indicating whether the game is in focus or in the foreground.

IsFocused will only return true if IsRunnableOnUnfocused is false.

IsFocused is concurrent-safe.

func IsFullscreen 

func IsFullscreen() bool

IsFullscreen reports whether the current mode is fullscreen or not.

IsFullscreen always returns false on mobiles.

IsFullscreen is concurrent-safe.

func IsGamepadButtonPressed 

func IsGamepadButtonPressed(id GamepadID, button GamepadButton) bool

IsGamepadButtonPressed reports whether the given button of the gamepad (id) is pressed or not.

If you want to know whether the given button of gamepad (id) started being pressed in the current frame, use inpututil.IsGamepadButtonJustPressed

IsGamepadButtonPressed is concurrent-safe.

The relationships between physical buttons and buttion IDs depend on environments. There can be differences even between Chrome and Firefox.

func IsKeyPressed 

func IsKeyPressed(key Key) bool

IsKeyPressed returns a boolean indicating whether key is pressed.

If you want to know whether the key started being pressed in the current frame, use inpututil.IsKeyJustPressed

Note that a Key represents a pysical key of US keyboard layout. For example, KeyQ represents Q key on US keyboards and ' (quote) key on Dvorak keyboards.

Known issue: On Edge browser, some keys don't work well:

  • KeyKPEnter and KeyKPEqual are recognized as KeyEnter and KeyEqual.
  • KeyPrintScreen is only treated at keyup event.

IsKeyPressed is concurrent-safe.

On Android (ebitenmobile), EbitenView must be focusable to enable to handle keyboard keys.

Keyboards don't work on iOS yet (#1090).

func IsMouseButtonPressed 

func IsMouseButtonPressed(mouseButton MouseButton) bool

IsMouseButtonPressed returns a boolean indicating whether mouseButton is pressed.

If you want to know whether the mouseButton started being pressed in the current frame, use inpututil.IsMouseButtonJustPressed

IsMouseButtonPressed is concurrent-safe.

func IsRunnableOnUnfocused 

func IsRunnableOnUnfocused() bool

IsRunnableOnUnfocused returns a boolean value indicating whether the game runs even in background.

IsRunnableOnUnfocused is concurrent-safe.

func IsScreenClearedEveryFrame 

func IsScreenClearedEveryFrame() bool

IsScreenClearedEveryFrame returns true if the frame isn't cleared at the beginning.

IsScreenClearedEveryFrame is concurrent-safe.

func IsScreenFilterEnabled added in v2.3.0 

func IsScreenFilterEnabled() bool

IsScreenFilterEnabled returns true if Ebiten's "screen" filter is enabled.

IsScreenFilterEnabled is concurrent-safe.

func IsScreenTransparent 

func IsScreenTransparent() bool

IsScreenTransparent reports whether the window is transparent.

IsScreenTransparent is concurrent-safe.

func IsStandardGamepadButtonPressed added in v2.2.0 

func IsStandardGamepadButtonPressed(id GamepadID, button StandardGamepadButton) bool

IsStandardGamepadButtonPressed reports whether the given gamepad (id)'s standard gamepad button (button) is pressed.

IsStandardGamepadButtonPressed returns false when the gamepad doesn't have a standard gamepad layout mapping.

IsStandardGamepadButtonPressed is concurrent safe.

func IsStandardGamepadLayoutAvailable added in v2.2.0 

func IsStandardGamepadLayoutAvailable(id GamepadID) bool

IsStandardGamepadLayoutAvailable reports whether the gamepad (id) has a standard gamepad layout mapping.

IsStandardGamepadLayoutAvailable is concurrent-safe.

func IsVsyncEnabled deprecated 

func IsVsyncEnabled() bool

IsVsyncEnabled returns a boolean value indicating whether the game uses the display's vsync.

Deprecated: as of v2.2. Use FPSMode instead.

func IsWindowBeingClosed added in v2.2.0 

func IsWindowBeingClosed() bool

IsWindowBeingClosed returns true when the user is trying to close the window on desktops. As the window is closed immediately by default, you might want to call SetWindowClosingHandled(true) to prevent the window is automatically closed.

IsWindowBeingClosed always returns false on other platforms.

IsWindowBeingClosed is concurrent-safe.

func IsWindowClosingHandled added in v2.2.0 

func IsWindowClosingHandled() bool

IsWindowClosingHandled reports whether the window closing is handled or not on desktops by SetWindowClosingHandled.

IsWindowClosingHandled always returns false on other platforms.

IsWindowClosingHandled is concurrent-safe.

func IsWindowDecorated 

func IsWindowDecorated() bool

IsWindowDecorated reports whether the window is decorated.

IsWindowDecorated is concurrent-safe.

func IsWindowFloating 

func IsWindowFloating() bool

IsWindowFloating reports whether the window is always shown above all the other windows.

IsWindowFloating returns false on browsers and mobiles.

IsWindowFloating is concurrent-safe.

func IsWindowMaximized 

func IsWindowMaximized() bool

IsWindowMaximized reports whether the window is maximized or not.

IsWindowMaximized returns false when the window is not resizable (WindowResizingModeEnabled).

IsWindowMaximized always returns false on browsers and mobiles.

IsWindowMaximized is concurrent-safe.

func IsWindowMinimized 

func IsWindowMinimized() bool

IsWindowMinimized reports whether the window is minimized or not.

IsWindowMinimized always returns false on browsers and mobiles.

IsWindowMinimized is concurrent-safe.

func IsWindowResizable deprecated 

func IsWindowResizable() bool

IsWindowResizable reports whether the window is resizable by the user's dragging on desktops. On the other environments, IsWindowResizable always returns false.

Deprecated: as of v2.3. Use WindowResizingMode instead.

func MaxTPS 

func MaxTPS() int

MaxTPS returns the current maximum TPS.

MaxTPS is concurrent-safe.

func MaximizeWindow 

func MaximizeWindow()

MaximizeWindow maximizes the window.

MaximizeWindow panics when the window is not resizable (WindowResizingModeEnabled).

MaximizeWindow does nothing on browsers or mobiles.

MaximizeWindow is concurrent-safe.

func MinimizeWindow 

func MinimizeWindow()

MinimizeWindow minimizes the window.

If the main loop does not start yet, MinimizeWindow does nothing.

MinimizeWindow does nothing on browsers or mobiles.

MinimizeWindow is concurrent-safe.

func RestoreWindow 

func RestoreWindow()

RestoreWindow restores the window from its maximized or minimized state.

RestoreWindow panics when the window is not maximized nor minimized.

RestoreWindow is concurrent-safe.

func RunGame 

func RunGame(game Game) error

RunGame starts the main loop and runs the game. game's Update function is called every tick to update the game logic. game's Draw function is called every frame to draw the screen. game's Layout function is called when necessary, and you can specify the logical screen size by the function.

game's functions are called on the same goroutine.

On browsers, it is strongly recommended to use iframe if you embed an Ebiten application in your website.

RunGame must be called on the main thread. Note that Ebiten bounds the main goroutine to the main OS thread by runtime.LockOSThread.

Ebiten tries to call game's Update function 60 times a second by default. In other words, TPS (ticks per second) is 60 by default. This is not related to framerate (display's refresh rate).

RunGame returns error when 1) error happens in the underlying graphics driver, 2) audio error happens or 3) f returns error. In the case of 3), RunGame returns the same error.

The size unit is device-independent pixel.

Don't call RunGame twice or more in one process.

func ScheduleFrame added in v2.2.0 

func ScheduleFrame()

ScheduleFrame schedules a next frame when the current FPS mode is FPSModeVsyncOffMinimum.

ScheduleFrame is concurrent-safe.

func ScreenSizeInFullscreen 

func ScreenSizeInFullscreen() (int, int)

ScreenSizeInFullscreen returns the size in device-independent pixels when the game is fullscreen. The adopted monitor is the 'current' monitor which the window belongs to. The returned value can be given to Run or SetSize function if the perfectly fit fullscreen is needed.

On browsers, ScreenSizeInFullscreen returns the 'window' (global object) size, not 'screen' size since an Ebiten game should not know the outside of the window object.

On mobiles, ScreenSizeInFullscreen returns (0, 0) so far.

ScreenSizeInFullscreen's use cases are limited. If you are making a fullscreen application, you can use RunGame and the Game interface's Layout function instead. If you are making a not-fullscreen application but the application's behavior depends on the monitor size, ScreenSizeInFullscreen is useful.

ScreenSizeInFullscreen must be called on the main thread before ebiten.Run, and is concurrent-safe after ebiten.Run.

func SetCursorMode 

func SetCursorMode(mode CursorModeType)

SetCursorMode sets the render and capture mode of the mouse cursor. CursorModeVisible sets the cursor to always be visible. CursorModeHidden hides the system cursor when over the window. CursorModeCaptured hides the system cursor and locks it to the window.

CursorModeCaptured also works on browsers. When the user exits the captured mode not by SetCursorMode but by the UI (e.g., pressing ESC), the previous cursor mode is set automatically.

SetCursorMode does nothing on mobiles.

SetCursorMode is concurrent-safe.

func SetCursorShape added in v2.1.0 

func SetCursorShape(shape CursorShapeType)

SetCursorShape sets the cursor shape.

SetCursorShape is concurrent-safe.

func SetFPSMode added in v2.2.0 

func SetFPSMode(mode FPSModeType)

SetFPSMode sets the FPS mode. The default FPS mode is FPSModeVsyncOn.

SetFPSMode is concurrent-safe.

func SetFullscreen 

func SetFullscreen(fullscreen bool)

SetFullscreen changes the current mode to fullscreen or not on desktops and browsers.

In fullscreen mode, the game screen is automatically enlarged to fit with the monitor. The current scale value is ignored.

On desktops, Ebiten uses 'windowed' fullscreen mode, which doesn't change your monitor's resolution.

On browsers, triggering fullscreen requires a user gesture otherwise SetFullscreen does nothing but leave an error message in console. This behaviour varies across browser implementations, your mileage may vary.

SetFullscreen does nothing on mobiles.

SetFullscreen does nothing on macOS when the window is fullscreened natively by the macOS desktop instead of SetFullscreen(true).

SetFullscreen is concurrent-safe.

func SetInitFocused 

func SetInitFocused(focused bool)

SetInitFocused sets whether the application is focused on show. The default value is true, i.e., the application is focused. Note that the application does not proceed if this is not focused by default. This behavior can be changed by SetRunnableOnUnfocused.

SetInitFocused does nothing on mobile.

SetInitFocused panics if this is called after the main loop.

SetInitFocused is cuncurrent-safe.

func SetMaxTPS 

func SetMaxTPS(tps int)

SetMaxTPS sets the maximum TPS (ticks per second), that represents how many updating function is called per second. The initial value is 60.

If tps is SyncWithFPS, TPS is uncapped and the game is updated per frame. If tps is negative but not SyncWithFPS, SetMaxTPS panics.

SetMaxTPS is concurrent-safe.

func SetRunnableOnUnfocused 

func SetRunnableOnUnfocused(runnableOnUnfocused bool)

SetRunnableOnUnfocused sets the state if the game runs even in background.

If the given value is true, the game runs even in background e.g. when losing focus. The initial state is true.

Known issue: On browsers, even if the state is on, the game doesn't run in background tabs. This is because browsers throttles background tabs not to often update.

SetRunnableOnUnfocused does nothing on mobiles so far.

SetRunnableOnUnfocused is concurrent-safe.

func SetScreenClearedEveryFrame 

func SetScreenClearedEveryFrame(cleared bool)

SetScreenClearedEveryFrame enables or disables the clearing of the screen at the beginning of each frame. The default value is true and the screen is cleared each frame by default.

SetScreenClearedEveryFrame is concurrent-safe.

func SetScreenFilterEnabled added in v2.3.0 

func SetScreenFilterEnabled(enabled bool)

SetScreenFilterEnabled enables/disables the use of the "screen" filter Ebiten uses.

The "screen" filter is a box filter from game to display resolution.

If disabled, nearest-neighbor filtering will be used for scaling instead.

The default state is true.

SetScreenFilterEnabled is concurrent-safe, but takes effect only at the next Draw call.

func SetScreenTransparent 

func SetScreenTransparent(transparent bool)

SetScreenTransparent sets the state if the window is transparent.

SetScreenTransparent panics if SetScreenTransparent is called after the main loop.

SetScreenTransparent does nothing on mobiles.

SetScreenTransparent is concurrent-safe.

func SetVsyncEnabled deprecated 

func SetVsyncEnabled(enabled bool)

SetVsyncEnabled sets a boolean value indicating whether the game uses the display's vsync.

Deprecated: as of v2.2. Use SetFPSMode instead.

func SetWindowClosingHandled added in v2.2.0 

func SetWindowClosingHandled(handled bool)

SetWindowClosingHandled sets whether the window closing is handled or not on desktops. The default state is false.

If the window closing is handled, the window is not closed immediately and the game can know whether the window is begin closed or not by IsWindowBeingClosed. In this case, the window is not closed automatically. To end the game, you have to return an error value at the Game's Update function.

SetWindowClosingHandled works only on desktops. SetWindowClosingHandled does nothing on other platforms.

SetWindowClosingHandled is concurrent-safe.

func SetWindowDecorated 

func SetWindowDecorated(decorated bool)

SetWindowDecorated sets the state if the window is decorated.

The window is decorated by default.

SetWindowDecorated works only on desktops. SetWindowDecorated does nothing on other platforms.

SetWindowDecorated does nothing on macOS when the window is fullscreened.

SetWindowDecorated is concurrent-safe.

func SetWindowFloating 

func SetWindowFloating(float bool)

SetWindowFloating sets the state whether the window is always shown above all the other windows.

SetWindowFloating does nothing on browsers or mobiles.

SetWindowFloating does nothing on macOS when the window is fullscreened.

SetWindowFloating is concurrent-safe.

func SetWindowIcon 

func SetWindowIcon(iconImages []image.Image)

SetWindowIcon sets the icon of the game window.

If len(iconImages) is 0, SetWindowIcon reverts the icon to the default one.

For desktops, see the document of glfwSetWindowIcon of GLFW 3.2: 

This function sets the icon of the specified window.
If passed an array of candidate images, those of or closest to the sizes
desired by the system are selected.
If no images are specified, the window reverts to its default icon.

The desired image sizes varies depending on platform and system settings.
The selected images will be rescaled as needed.
Good sizes include 16x16, 32x32 and 48x48.

As macOS windows don't have icons, SetWindowIcon doesn't work on macOS.

SetWindowIcon doesn't work on browsers or mobiles.

SetWindowIcon is concurrent-safe.

func SetWindowPosition 

func SetWindowPosition(x, y int)

SetWindowPosition sets the window position. The origin position is the left-upper corner of the current monitor. The unit is device-independent pixels.

SetWindowPosition does nothing in fullscreen mode.

SetWindowPosition does nothing on browsers and mobiles.

SetWindowPosition is concurrent-safe.

func SetWindowResizable deprecated 

func SetWindowResizable(resizable bool)

SetWindowResizable sets whether the window is resizable by the user's dragging on desktops. On the other environments, SetWindowResizable does nothing.

Deprecated: as of v2.3, Use SetWindowResizingMode instead.

func SetWindowResizingMode added in v2.3.0 

func SetWindowResizingMode(mode WindowResizingModeType)

SetWindowResizingMode sets the mode in which a user resizes the window.

SetWindowResizingMode does nothing on macOS when the window is fullscreened.

SetWindowResizingMode is concurrent-safe.

func SetWindowSize 

func SetWindowSize(width, height int)

SetWindowSize sets the window size on desktops. SetWindowSize does nothing on other environments.

In fullscreen mode, SetWindowSize sets the original window size.

SetWindowSize panics if width or height is not a positive number.

SetWindowSize is concurrent-safe.

func SetWindowSizeLimits added in v2.1.0 

func SetWindowSizeLimits(minw, minh, maxw, maxh int)

SetWindowSizeLimits sets the limitation of the window size on desktops. A negative value indicates the size is not limited.

SetWindowSizeLimits is concurrent-safe.

func SetWindowTitle 

func SetWindowTitle(title string)

SetWindowTitle sets the title of the window.

SetWindowTitle does nothing on browsers or mobiles.

SetWindowTitle is concurrent-safe.

func StandardGamepadAxisValue added in v2.2.0 

func StandardGamepadAxisValue(id GamepadID, axis StandardGamepadAxis) float64

StandardGamepadAxisValue returns a float value [-1.0 - 1.0] of the given gamepad (id)'s standard axis (axis).

StandardGamepadAxisValue returns 0 when the gamepad doesn't have a standard gamepad layout mapping.

StandardGamepadAxisValue is concurrent safe.

func StandardGamepadButtonValue added in v2.2.0 

func StandardGamepadButtonValue(id GamepadID, button StandardGamepadButton) float64

StandardGamepadButtonValue returns a float value [0.0 - 1.0] of the given gamepad (id)'s standard button (button).

StandardGamepadButtonValue returns 0 when the gamepad doesn't have a standard gamepad layout mapping.

StandardGamepadButtonValue is concurrent safe.

func TouchPosition 

func TouchPosition(id TouchID) (int, int)

TouchPosition returns the position for the touch of the specified ID.

If the touch of the specified ID is not present, TouchPosition returns (0, 0).

TouchPosition is cuncurrent-safe.

func UpdateStandardGamepadLayoutMappings added in v2.2.0 

func UpdateStandardGamepadLayoutMappings(mappings string) (bool, error)

UpdateStandardGamepadLayoutMappings parses the specified string mappings in SDL_GameControllerDB format and updates the gamepad layout definitions.

UpdateStandardGamepadLayoutMappings reports whether the mappings were applied, and returns an error in case any occurred while parsing the mappings.

One or more input definitions can be provided separated by newlines. In particular, it is valid to pass an entire gamecontrollerdb.txt file. Note though that Ebiten already includes its own copy of this file, so this call should only be necessary to add mappings for hardware not supported yet; ideally games using the StandardGamepad* functions should allow the user to provide mappings and then call this function if provided. When using this facility to support new hardware, please also send a pull request to https://github.com/gabomdq/SDL_GameControllerDB to make your mapping available to everyone else.

A platform field in a line corresponds with a GOOS like the following: 

"Windows":  GOOS=windows
"Mac OS X": GOOS=darwin (not ios)
"Linux":    GOOS=linux (not android)
"Android":  GOOS=android
"iOS":      GOOS=ios
"":         Any GOOS

On platforms where gamepad mappings are not managed by Ebiten, this always returns false and nil.

UpdateStandardGamepadLayoutMappings is concurrent-safe.

UpdateStandardGamepadLayoutMappings mappings take effect immediately even for already connected gamepads.

UpdateStandardGamepadLayoutMappings works atomically. If an error happens, nothing is updated.

func Vibrate added in v2.3.0 

func Vibrate(options *VibrateOptions)

Vibrate vibrates the device with the specified options.

Vibrate works on mobiles and browsers.

On browsers, Magnitude in the options is ignored.

On Android, this line is required in the manifest setting to use Vibrate: 

<uses-permission android:name="android.permission.VIBRATE"/>

On Android, Magnitude in the options is recognized only when the API Level is 26 or newer. Otherwise, Magnitude is ignored.

On iOS, CoreHaptics.framework is required to use Vibrate.

On iOS, Vibrate works only when iOS version is 13.0 or newer. Otherwise, Vibrate does nothing.

Vibrate is concurrent-safe.

func VibrateGamepad added in v2.3.0 

func VibrateGamepad(gamepadID GamepadID, options *VibrateGamepadOptions)

VibrateGamepad vibrates the specified gamepad with the specified options.

VibrateGamepad is concurrent-safe.

func Wheel 

func Wheel() (xoff, yoff float64)

Wheel returns x and y offsets of the mouse wheel or touchpad scroll. It returns 0 if the wheel isn't being rolled.

Wheel is concurrent-safe.

func WindowPosition 

func WindowPosition() (x, y int)

WindowPosition returns the window position. The origin position is the left-upper corner of the current monitor. The unit is device-independent pixels.

WindowPosition panics if the main loop does not start yet.

WindowPosition returns the last window position in fullscreen mode.

WindowPosition returns (0, 0) on browsers and mobiles.

WindowPosition is concurrent-safe.

func WindowSize 

func WindowSize() (int, int)

WindowSize returns the window size on desktops. WindowSize returns (0, 0) on other environments.

In fullscreen mode, WindowSize returns the original window size.

WindowSize is concurrent-safe.

func WindowSizeLimits added in v2.1.0 

func WindowSizeLimits() (minw, minh, maxw, maxh int)

WindowSizeLimits returns the limitation of the window size on desktops. A negative value indicates the size is not limited.

WindowSizeLimits is concurrent-safe.

Types

type Address 

type Address int

Address represents a sampler address mode. 

const (
	// AddressUnsafe means there is no guarantee when the texture coodinates are out of range.
	AddressUnsafe Address = Address(graphicsdriver.AddressUnsafe)

	// AddressClampToZero means that out-of-range texture coordinates return 0 (transparent).
	AddressClampToZero Address = Address(graphicsdriver.AddressClampToZero)

	// AddressRepeat means that texture coordinates wrap to the other side of the texture.
	AddressRepeat Address = Address(graphicsdriver.AddressRepeat)
)

type ColorM 

type ColorM struct {
	// contains filtered or unexported fields
}

A ColorM represents a matrix to transform coloring when rendering an image.

A ColorM is applied to the straight alpha color while an Image's pixels' format is alpha premultiplied. Before applying a matrix, a color is un-multiplied, and after applying the matrix, the color is multiplied again.

The initial value is identity.

func (*ColorM) Apply 

func (c *ColorM) Apply(clr color.Color) color.Color

Apply pre-multiplies a vector (r, g, b, a, 1) by the matrix where r, g, b, and a are clr's values in straight-alpha format. In other words, Apply calculates ColorM * (r, g, b, a, 1)^T.

func (*ColorM) ChangeHSV 

func (c *ColorM) ChangeHSV(hueTheta float64, saturationScale float64, valueScale float64)

ChangeHSV changes HSV (Hue-Saturation-Value) values. hueTheta is a radian value to rotate hue. saturationScale is a value to scale saturation. valueScale is a value to scale value (a.k.a. brightness).

This conversion uses RGB to/from YCrCb conversion.

func (*ColorM) Concat 

func (c *ColorM) Concat(other ColorM)

Concat multiplies a color matrix with the other color matrix. This is same as muptiplying the matrix other and the matrix c in this order.

func (*ColorM) Element 

func (c *ColorM) Element(i, j int) float64

Element returns a value of a matrix at (i, j).

func (*ColorM) Invert 

func (c *ColorM) Invert()

Invert inverts the matrix. If c is not invertible, Invert panics.

func (*ColorM) IsInvertible 

func (c *ColorM) IsInvertible() bool

IsInvertible returns a boolean value indicating whether the matrix c is invertible or not.

func (*ColorM) Reset 

func (c *ColorM) Reset()

Reset resets the ColorM as identity.

func (*ColorM) RotateHue 

func (c *ColorM) RotateHue(theta float64)

RotateHue rotates the hue. theta represents rotating angle in radian.

func (*ColorM) Scale 

func (c *ColorM) Scale(r, g, b, a float64)

Scale scales the matrix by (r, g, b, a).

func (*ColorM) ScaleWithColor added in v2.3.0 

func (c *ColorM) ScaleWithColor(clr color.Color)

ScaleWithColor scales the matrix by clr.

func (*ColorM) SetElement 

func (c *ColorM) SetElement(i, j int, element float64)

SetElement sets an element at (i, j).

func (*ColorM) String 

func (c *ColorM) String() string

String returns a string representation of ColorM.

func (*ColorM) Translate 

func (c *ColorM) Translate(r, g, b, a float64)

Translate translates the matrix by (r, g, b, a).

type CompositeMode 

type CompositeMode int

CompositeMode represents Porter-Duff composition mode. 

const (
	// Regular alpha blending
	// c_out = c_src + c_dst × (1 - α_src)
	CompositeModeSourceOver CompositeMode = CompositeMode(graphicsdriver.CompositeModeSourceOver)

	// c_out = 0
	CompositeModeClear CompositeMode = CompositeMode(graphicsdriver.CompositeModeClear)

	// c_out = c_src
	CompositeModeCopy CompositeMode = CompositeMode(graphicsdriver.CompositeModeCopy)

	// c_out = c_dst
	CompositeModeDestination CompositeMode = CompositeMode(graphicsdriver.CompositeModeDestination)

	// c_out = c_src × (1 - α_dst) + c_dst
	CompositeModeDestinationOver CompositeMode = CompositeMode(graphicsdriver.CompositeModeDestinationOver)

	// c_out = c_src × α_dst
	CompositeModeSourceIn CompositeMode = CompositeMode(graphicsdriver.CompositeModeSourceIn)

	// c_out = c_dst × α_src
	CompositeModeDestinationIn CompositeMode = CompositeMode(graphicsdriver.CompositeModeDestinationIn)

	// c_out = c_src × (1 - α_dst)
	CompositeModeSourceOut CompositeMode = CompositeMode(graphicsdriver.CompositeModeSourceOut)

	// c_out = c_dst × (1 - α_src)
	CompositeModeDestinationOut CompositeMode = CompositeMode(graphicsdriver.CompositeModeDestinationOut)

	// c_out = c_src × α_dst + c_dst × (1 - α_src)
	CompositeModeSourceAtop CompositeMode = CompositeMode(graphicsdriver.CompositeModeSourceAtop)

	// c_out = c_src × (1 - α_dst) + c_dst × α_src
	CompositeModeDestinationAtop CompositeMode = CompositeMode(graphicsdriver.CompositeModeDestinationAtop)

	// c_out = c_src × (1 - α_dst) + c_dst × (1 - α_src)
	CompositeModeXor CompositeMode = CompositeMode(graphicsdriver.CompositeModeXor)

	// Sum of source and destination (a.k.a. 'plus' or 'additive')
	// c_out = c_src + c_dst
	CompositeModeLighter CompositeMode = CompositeMode(graphicsdriver.CompositeModeLighter)

	// The product of source and destination (a.k.a 'multiply blend mode')
	// c_out = c_src * c_dst
	CompositeModeMultiply CompositeMode = CompositeMode(graphicsdriver.CompositeModeMultiply)
)

This name convention follows CSS compositing: https://drafts.fxtf.org/compositing-2/.

In the comments, c_src, c_dst and c_out represent alpha-premultiplied RGB values of source, destination and output respectively. α_src and α_dst represent alpha values of source and destination respectively.

type CursorModeType 

type CursorModeType = ui.CursorMode

CursorModeType represents a render and coordinate mode of a mouse cursor. 

const (
	CursorModeVisible  CursorModeType = CursorModeType(ui.CursorModeVisible)
	CursorModeHidden   CursorModeType = CursorModeType(ui.CursorModeHidden)
	CursorModeCaptured CursorModeType = CursorModeType(ui.CursorModeCaptured)
)

CursorModeTypes

func CursorMode 

func CursorMode() CursorModeType

CursorMode returns the current cursor mode.

CursorMode returns CursorModeHidden on mobiles.

CursorMode is concurrent-safe.

type CursorShapeType added in v2.1.0 

type CursorShapeType = ui.CursorShape

CursorShapeType represents a shape of a mouse cursor. 

const (
	CursorShapeDefault   CursorShapeType = CursorShapeType(ui.CursorShapeDefault)
	CursorShapeText      CursorShapeType = CursorShapeType(ui.CursorShapeText)
	CursorShapeCrosshair CursorShapeType = CursorShapeType(ui.CursorShapeCrosshair)
	CursorShapePointer   CursorShapeType = CursorShapeType(ui.CursorShapePointer)
	CursorShapeEWResize  CursorShapeType = CursorShapeType(ui.CursorShapeEWResize)
	CursorShapeNSResize  CursorShapeType = CursorShapeType(ui.CursorShapeNSResize)
)

CursorShapeTypes

func CursorShape added in v2.1.0 

func CursorShape() CursorShapeType

CursorShape returns the current cursor shape.

CursorShape returns CursorShapeDefault on mobiles.

CursorShape is concurrent-safe.

type DrawImageOptions 

type DrawImageOptions struct {
	// GeoM is a geometry matrix to draw.
	// The default (zero) value is identity, which draws the image at (0, 0).
	GeoM GeoM

	// ColorM is a color matrix to draw.
	// The default (zero) value is identity, which doesn't change any color.
	ColorM ColorM

	// CompositeMode is a composite mode to draw.
	// The default (zero) value is regular alpha blending.
	CompositeMode CompositeMode

	// Filter is a type of texture filter.
	// The default (zero) value is FilterNearest.
	Filter Filter
}

DrawImageOptions represents options for DrawImage.

type DrawRectShaderOptions 

type DrawRectShaderOptions struct {
	// GeoM is a geometry matrix to draw.
	// The default (zero) value is identity, which draws the rectangle at (0, 0).
	GeoM GeoM

	// CompositeMode is a composite mode to draw.
	// The default (zero) value is regular alpha blending.
	CompositeMode CompositeMode

	// Uniforms is a set of uniform variables for the shader.
	// The keys are the names of the uniform variables.
	// The values must be float or []float.
	// If the uniform variable type is an array, a vector or a matrix,
	// you have to specify linearly flattened values as a slice.
	// For example, if the uniform variable type is [4]vec4, the number of the slice values will be 16.
	Uniforms map[string]interface{}

	// Images is a set of the source images.
	// All the image must be the same size with the rectangle.
	Images [4]*Image
}

DrawRectShaderOptions represents options for DrawRectShader.

This API is experimental.

type DrawTrianglesOptions 

type DrawTrianglesOptions struct {
	// ColorM is a color matrix to draw.
	// The default (zero) value is identity, which doesn't change any color.
	// ColorM is applied before vertex color scale is applied.
	//
	// If Shader is not nil, ColorM is ignored.
	ColorM ColorM

	// CompositeMode is a composite mode to draw.
	// The default (zero) value is regular alpha blending.
	CompositeMode CompositeMode

	// Filter is a type of texture filter.
	// The default (zero) value is FilterNearest.
	Filter Filter

	// Address is a sampler address mode.
	// The default (zero) value is AddressUnsafe.
	Address Address

	// FillRule indicates the rule how an overlapped region is rendered.
	//
	// The rule EvenOdd is useful when you want to render a complex polygon.
	// A complex polygon is a non-convex polygon like a concave polygon, a polygon with holes, or a self-intersecting polygon.
	// See examples/vector for actual usages.
	//
	// The default (zero) value is FillAll.
	FillRule FillRule
}

DrawTrianglesOptions represents options for DrawTriangles.

type DrawTrianglesShaderOptions 

type DrawTrianglesShaderOptions struct {
	// CompositeMode is a composite mode to draw.
	// The default (zero) value is regular alpha blending.
	CompositeMode CompositeMode

	// Uniforms is a set of uniform variables for the shader.
	// The keys are the names of the uniform variables.
	// The values must be float or []float.
	// If the uniform variable type is an array, a vector or a matrix,
	// you have to specify linearly flattened values as a slice.
	// For example, if the uniform variable type is [4]vec4, the number of the slice values will be 16.
	Uniforms map[string]interface{}

	// Images is a set of the source images.
	// All the image must be the same size.
	Images [4]*Image

	// FillRule indicates the rule how an overlapped region is rendered.
	//
	// The rule EvenOdd is useful when you want to render a complex polygon.
	// A complex polygon is a non-convex polygon like a concave polygon, a polygon with holes, or a self-intersecting polygon.
	// See examples/vector for actual usages.
	//
	// The default (zero) value is FillAll.
	FillRule FillRule
}

DrawTrianglesShaderOptions represents options for DrawTrianglesShader.

This API is experimental.

type FPSModeType added in v2.2.0 

type FPSModeType = ui.FPSModeType

FPSModeType is a type of FPS modes. 

const (
	// FPSModeVsyncOn indicates that the game tries to sync the display's refresh rate.
	// FPSModeVsyncOn is the default mode.
	FPSModeVsyncOn FPSModeType = ui.FPSModeVsyncOn

	// FPSModeVsyncOffMaximum indicates that the game doesn't sync with vsync, and
	// the game is updated whenever possible.
	//
	// Be careful that FPSModeVsyncOffMaximum might consume a lot of battery power.
	//
	// In FPSModeVsyncOffMaximum, the game's Draw is called almost without sleeping.
	// The game's Update is called based on the specified TPS.
	FPSModeVsyncOffMaximum FPSModeType = ui.FPSModeVsyncOffMaximum

	// FPSModeVsyncOffMinimum indicates that the game doesn't sync with vsync, and
	// the game is updated only when necessary.
	//
	// FPSModeVsyncOffMinimum is useful for relatively static applications to save battery power.
	//
	// In FPSModeVsyncOffMinimum, the game's Update and Draw are called only when
	// 1) new inputting except for gamepads is detected, or 2) ScheduleFrame is called.
	// In FPSModeVsyncOffMinimum, TPS is SyncWithFPS no matter what TPS is specified at SetMaxTPS.
	FPSModeVsyncOffMinimum FPSModeType = ui.FPSModeVsyncOffMinimum
)

func FPSMode added in v2.2.0 

func FPSMode() FPSModeType

FPSMode returns the current FPS mode.

FPSMode is concurrent-safe.

type FillRule added in v2.2.0 

type FillRule int

FillRule is the rule whether an overlapped region is rendered with DrawTriangles(Shader). 

const (
	// FillAll indicates all the triangles are rendered regardless of overlaps.
	FillAll FillRule = iota

	// EvenOdd means that triangles are rendered based on the even-odd rule.
	// If and only if the number of overlappings is odd, the region is rendered.
	EvenOdd
)

type Filter 

type Filter int

Filter represents the type of texture filter to be used when an image is maginified or minified. 

const (
	// FilterNearest represents nearest (crisp-edged) filter
	FilterNearest Filter = Filter(graphicsdriver.FilterNearest)

	// FilterLinear represents linear filter
	FilterLinear Filter = Filter(graphicsdriver.FilterLinear)
)

type Game 

type Game interface {
	// Update updates a game by one tick. The given argument represents a screen image.
	//
	// Update updates only the game logic and Draw draws the screen.
	//
	// In the first frame, it is ensured that Update is called at least once before Draw. You can use Update
	// to initialize the game state.
	//
	// After the first frame, Update might not be called or might be called once
	// or more for one frame. The frequency is determined by the current TPS (tick-per-second).
	Update() error

	// Draw draws the game screen by one frame.
	//
	// The give argument represents a screen image. The updated content is adopted as the game screen.
	Draw(screen *Image)

	// Layout accepts a native outside size in device-independent pixels and returns the game's logical screen
	// size.
	//
	// On desktops, the outside is a window or a monitor (fullscreen mode). On browsers, the outside is a body
	// element. On mobiles, the outside is the view's size.
	//
	// Even though the outside size and the screen size differ, the rendering scale is automatically adjusted to
	// fit with the outside.
	//
	// Layout is called almost every frame.
	//
	// It is ensured that Layout is invoked before Update is called in the first frame.
	//
	// If Layout returns non-positive numbers, the caller can panic.
	//
	// You can return a fixed screen size if you don't care, or you can also return a calculated screen size
	// adjusted with the given outside size.
	Layout(outsideWidth, outsideHeight int) (screenWidth, screenHeight int)
}

Game defines necessary functions for a game.

type GamepadButton 

type GamepadButton = gamepad.Button

GamepadButton represents a gamepad button. 

const (
	GamepadButton0   GamepadButton = gamepad.Button0
	GamepadButton1   GamepadButton = gamepad.Button1
	GamepadButton2   GamepadButton = gamepad.Button2
	GamepadButton3   GamepadButton = gamepad.Button3
	GamepadButton4   GamepadButton = gamepad.Button4
	GamepadButton5   GamepadButton = gamepad.Button5
	GamepadButton6   GamepadButton = gamepad.Button6
	GamepadButton7   GamepadButton = gamepad.Button7
	GamepadButton8   GamepadButton = gamepad.Button8
	GamepadButton9   GamepadButton = gamepad.Button9
	GamepadButton10  GamepadButton = gamepad.Button10
	GamepadButton11  GamepadButton = gamepad.Button11
	GamepadButton12  GamepadButton = gamepad.Button12
	GamepadButton13  GamepadButton = gamepad.Button13
	GamepadButton14  GamepadButton = gamepad.Button14
	GamepadButton15  GamepadButton = gamepad.Button15
	GamepadButton16  GamepadButton = gamepad.Button16
	GamepadButton17  GamepadButton = gamepad.Button17
	GamepadButton18  GamepadButton = gamepad.Button18
	GamepadButton19  GamepadButton = gamepad.Button19
	GamepadButton20  GamepadButton = gamepad.Button20
	GamepadButton21  GamepadButton = gamepad.Button21
	GamepadButton22  GamepadButton = gamepad.Button22
	GamepadButton23  GamepadButton = gamepad.Button23
	GamepadButton24  GamepadButton = gamepad.Button24
	GamepadButton25  GamepadButton = gamepad.Button25
	GamepadButton26  GamepadButton = gamepad.Button26
	GamepadButton27  GamepadButton = gamepad.Button27
	GamepadButton28  GamepadButton = gamepad.Button28
	GamepadButton29  GamepadButton = gamepad.Button29
	GamepadButton30  GamepadButton = gamepad.Button30
	GamepadButton31  GamepadButton = gamepad.Button31
	GamepadButtonMax GamepadButton = GamepadButton31
)

GamepadButtons

type GamepadID 

type GamepadID = gamepad.ID

GamepadID represents a gamepad's identifier.

func AppendGamepadIDs added in v2.2.0 

func AppendGamepadIDs(gamepadIDs []GamepadID) []GamepadID

AppendGamepadIDs appends available gamepad IDs to gamepadIDs, and returns the extended buffer. Giving a slice that already has enough capacity works efficiently.

AppendGamepadIDs is concurrent-safe.

func GamepadIDs deprecated 

func GamepadIDs() []GamepadID

GamepadIDs returns a slice indicating available gamepad IDs.

Deprecated: as of v2.2. Use AppendGamepadIDs instead.

type GeoM 

type GeoM struct {
	// contains filtered or unexported fields
}

A GeoM represents a matrix to transform geometry when rendering an image.

The initial value is identity.

func (*GeoM) Apply 

func (g *GeoM) Apply(x, y float64) (float64, float64)

Apply pre-multiplies a vector (x, y, 1) by the matrix. In other words, Apply calculates GeoM * (x, y, 1)^T. The return value is x and y values of the result vector.

func (*GeoM) Concat 

func (g *GeoM) Concat(other GeoM)

Concat multiplies a geometry matrix with the other geometry matrix. This is same as multiplying the matrix other and the matrix g in this order.

func (*GeoM) Element 

func (g *GeoM) Element(i, j int) float64

Element returns a value of a matrix at (i, j).

func (*GeoM) Invert 

func (g *GeoM) Invert()

Invert inverts the matrix. If g is not invertible, Invert panics.

func (*GeoM) IsInvertible 

func (g *GeoM) IsInvertible() bool

IsInvertible returns a boolean value indicating whether the matrix g is invertible or not.

func (*GeoM) Reset 

func (g *GeoM) Reset()

Reset resets the GeoM as identity.

func (*GeoM) Rotate 

func (g *GeoM) Rotate(theta float64)

Rotate rotates the matrix by theta. The unit is radian.

func (*GeoM) Scale 

func (g *GeoM) Scale(x, y float64)

Scale scales the matrix by (x, y).

func (*GeoM) SetElement 

func (g *GeoM) SetElement(i, j int, element float64)

SetElement sets an element at (i, j).

func (*GeoM) Skew 

func (g *GeoM) Skew(skewX, skewY float64)

Skew skews the matrix by (skewX, skewY). The unit is radian.

func (*GeoM) String 

func (g *GeoM) String() string

String returns a string representation of GeoM.

func (*GeoM) Translate 

func (g *GeoM) Translate(tx, ty float64)

Translate translates the matrix by (tx, ty).

type Image 

type Image struct {
	// contains filtered or unexported fields
}

Image represents a rectangle set of pixels. The pixel format is alpha-premultiplied RGBA. Image implements image.Image and draw.Image.

func NewImage 

func NewImage(width, height int) *Image

NewImage returns an empty image.

If width or height is less than 1 or more than device-dependent maximum size, NewImage panics.

NewImage should be called only when necessary. For example, you should avoid to call NewImage every Update or Draw call. Reusing the same image by Clear is much more efficient than creating a new image.

NewImage panics if RunGame already finishes.

func NewImageFromImage 

func NewImageFromImage(source image.Image) *Image

NewImageFromImage creates a new image with the given image (source).

If source's width or height is less than 1 or more than device-dependent maximum size, NewImageFromImage panics.

NewImageFromImage should be called only when necessary. For example, you should avoid to call NewImageFromImage every Update or Draw call. Reusing the same image by Clear is much more efficient than creating a new image.

NewImageFromImage panics if RunGame already finishes.

The returned image's origin is always (0, 0). The source's bounds are not respected.

func (*Image) At 

func (i *Image) At(x, y int) color.Color

At returns the color of the image at (x, y).

At loads pixels from GPU to system memory if necessary, which means that At can be slow.

At always returns a transparent color if the image is disposed.

Note that an important logic should not rely on values returned by At, since the returned values can include very slight differences between some machines.

At can't be called outside the main loop (ebiten.Run's updating function) starts.

func (*Image) Bounds 

func (i *Image) Bounds() image.Rectangle

Bounds returns the bounds of the image.

func (*Image) Clear 

func (i *Image) Clear()

Clear resets the pixels of the image into 0.

When the image is disposed, Clear does nothing.

func (*Image) ColorModel 

func (i *Image) ColorModel() color.Model

ColorModel returns the color model of the image.

func (*Image) Dispose 

func (i *Image) Dispose()

Dispose disposes the image data. After disposing, most of image functions do nothing and returns meaningless values.

Calling Dispose is not mandatory. GC automatically collects internal resources that no objects refer to. However, calling Dispose explicitly is helpful if memory usage matters.

If the image is a sub-image, Dispose does nothing.

When the image is disposed, Dipose does nothing.

func (*Image) DrawImage 

func (i *Image) DrawImage(img *Image, options *DrawImageOptions)

DrawImage draws the given image on the image i.

DrawImage accepts the options. For details, see the document of DrawImageOptions.

For drawing, the pixels of the argument image at the time of this call is adopted. Even if the argument image is mutated after this call, the drawing result is never affected.

When the image i is disposed, DrawImage does nothing. When the given image img is disposed, DrawImage panics.

When the given image is as same as i, DrawImage panics.

DrawImage works more efficiently as batches when the successive calls of DrawImages satisfy the below conditions:

  • All render targets are same (A in A.DrawImage(B, op))
  • Either all ColorM element values are same or all the ColorM have only diagonal ('scale') elements
  • If only (*ColorM).Scale is applied to a ColorM, the ColorM has only diagonal elements. The other ColorM functions might modify the other elements.
  • All CompositeMode values are same
  • All Filter values are same

Even when all the above conditions are satisfied, multiple draw commands can be used in really rare cases. Ebiten images usually share an internal automatic texture atlas, but when you consume the atlas, or you create a huge image, those images cannot be on the same texture atlas. In this case, draw commands are separated. Another case is when you use an offscreen as a render source. An offscreen doesn't share the texture atlas with high probability.

For more performance tips, see https://ebiten.org/documents/performancetips.html

func (*Image) DrawRectShader 

func (i *Image) DrawRectShader(width, height int, shader *Shader, options *DrawRectShaderOptions)

DrawRectShader draws a rectangle with the specified width and height with the specified shader.

For the details about the shader, see https://ebiten.org/documents/shader.html.

When one of the specified image is non-nil and is disposed, DrawRectShader panics.

When the image i is disposed, DrawRectShader does nothing.

This API is experimental.

func (*Image) DrawTriangles 

func (i *Image) DrawTriangles(vertices []Vertex, indices []uint16, img *Image, options *DrawTrianglesOptions)

DrawTriangles draws triangles with the specified vertices and their indices.

Vertex contains color values, which are interpreted as straight-alpha colors.

If len(indices) is not multiple of 3, DrawTriangles panics.

If len(indices) is more than MaxIndicesNum, DrawTriangles panics.

The rule in which DrawTriangles works effectively is same as DrawImage's.

When the given image is disposed, DrawTriangles panics.

When the image i is disposed, DrawTriangles does nothing.

func (*Image) DrawTrianglesShader 

func (i *Image) DrawTrianglesShader(vertices []Vertex, indices []uint16, shader *Shader, options *DrawTrianglesShaderOptions)

DrawTrianglesShader draws triangles with the specified vertices and their indices with the specified shader.

Vertex contains color values, which can be interpreted for any purpose by the shader.

For the details about the shader, see https://ebiten.org/documents/shader.html.

If len(indices) is not multiple of 3, DrawTrianglesShader panics.

If len(indices) is more than MaxIndicesNum, DrawTrianglesShader panics.

When a specified image is non-nil and is disposed, DrawTrianglesShader panics.

When the image i is disposed, DrawTrianglesShader does nothing.

This API is experimental.

func (*Image) Fill 

func (i *Image) Fill(clr color.Color)

Fill fills the image with a solid color.

When the image is disposed, Fill does nothing.

func (*Image) RGBA64At added in v2.2.0 

func (i *Image) RGBA64At(x, y int) color.RGBA64

RGBA64At implements image.RGBA64Image's RGBA64At.

RGBA64At loads pixels from GPU to system memory if necessary, which means that RGBA64At can be slow.

RGBA64At always returns a transparent color if the image is disposed.

Note that an important logic should not rely on values returned by RGBA64At, since the returned values can include very slight differences between some machines.

RGBA64At can't be called outside the main loop (ebiten.Run's updating function) starts.

func (*Image) ReplacePixels 

func (i *Image) ReplacePixels(pixels []byte)

ReplacePixels replaces the pixels of the image with p.

The given p must represent RGBA pre-multiplied alpha values. len(pix) must equal to 4 * (bounds width) * (bounds height).

ReplacePixels works on a sub-image.

When len(pix) is not appropriate, ReplacePixels panics.

When the image is disposed, ReplacePixels does nothing.

func (*Image) Set 

func (i *Image) Set(x, y int, clr color.Color)

Set sets the color at (x, y).

Set loads pixels from GPU to system memory if necessary, which means that Set can be slow.

In the current implementation, successive calls of Set invokes loading pixels at most once, so this is efficient.

If the image is disposed, Set does nothing.

func (*Image) Size 

func (i *Image) Size() (width, height int)

Size returns the size of the image.

func (*Image) SubImage 

func (i *Image) SubImage(r image.Rectangle) image.Image

SubImage returns an image representing the portion of the image p visible through r. The returned value shares pixels with the original image.

The returned value is always *ebiten.Image.

If the image is disposed, SubImage returns nil.

A sub-image returned by SubImage can be used as a rendering source and a rendering destination. If a sub-image is used as a rendering source, the image is used as if it is a small image. If a sub-image is used as a rendering destination, the region being rendered is clipped.

type Key 

type Key int

A Key represents a keyboard key. These keys represent pysical keys of US keyboard. For example, KeyQ represents Q key on US keyboards and ' (quote) key on Dvorak keyboards. 

const (
	KeyA              Key = Key(ui.KeyA)
	KeyB              Key = Key(ui.KeyB)
	KeyC              Key = Key(ui.KeyC)
	KeyD              Key = Key(ui.KeyD)
	KeyE              Key = Key(ui.KeyE)
	KeyF              Key = Key(ui.KeyF)
	KeyG              Key = Key(ui.KeyG)
	KeyH              Key = Key(ui.KeyH)
	KeyI              Key = Key(ui.KeyI)
	KeyJ              Key = Key(ui.KeyJ)
	KeyK              Key = Key(ui.KeyK)
	KeyL              Key = Key(ui.KeyL)
	KeyM              Key = Key(ui.KeyM)
	KeyN              Key = Key(ui.KeyN)
	KeyO              Key = Key(ui.KeyO)
	KeyP              Key = Key(ui.KeyP)
	KeyQ              Key = Key(ui.KeyQ)
	KeyR              Key = Key(ui.KeyR)
	KeyS              Key = Key(ui.KeyS)
	KeyT              Key = Key(ui.KeyT)
	KeyU              Key = Key(ui.KeyU)
	KeyV              Key = Key(ui.KeyV)
	KeyW              Key = Key(ui.KeyW)
	KeyX              Key = Key(ui.KeyX)
	KeyY              Key = Key(ui.KeyY)
	KeyZ              Key = Key(ui.KeyZ)
	KeyAltLeft        Key = Key(ui.KeyAltLeft)
	KeyAltRight       Key = Key(ui.KeyAltRight)
	KeyArrowDown      Key = Key(ui.KeyArrowDown)
	KeyArrowLeft      Key = Key(ui.KeyArrowLeft)
	KeyArrowRight     Key = Key(ui.KeyArrowRight)
	KeyArrowUp        Key = Key(ui.KeyArrowUp)
	KeyBackquote      Key = Key(ui.KeyBackquote)
	KeyBackslash      Key = Key(ui.KeyBackslash)
	KeyBackspace      Key = Key(ui.KeyBackspace)
	KeyBracketLeft    Key = Key(ui.KeyBracketLeft)
	KeyBracketRight   Key = Key(ui.KeyBracketRight)
	KeyCapsLock       Key = Key(ui.KeyCapsLock)
	KeyComma          Key = Key(ui.KeyComma)
	KeyContextMenu    Key = Key(ui.KeyContextMenu)
	KeyControlLeft    Key = Key(ui.KeyControlLeft)
	KeyControlRight   Key = Key(ui.KeyControlRight)
	KeyDelete         Key = Key(ui.KeyDelete)
	KeyDigit0         Key = Key(ui.KeyDigit0)
	KeyDigit1         Key = Key(ui.KeyDigit1)
	KeyDigit2         Key = Key(ui.KeyDigit2)
	KeyDigit3         Key = Key(ui.KeyDigit3)
	KeyDigit4         Key = Key(ui.KeyDigit4)
	KeyDigit5         Key = Key(ui.KeyDigit5)
	KeyDigit6         Key = Key(ui.KeyDigit6)
	KeyDigit7         Key = Key(ui.KeyDigit7)
	KeyDigit8         Key = Key(ui.KeyDigit8)
	KeyDigit9         Key = Key(ui.KeyDigit9)
	KeyEnd            Key = Key(ui.KeyEnd)
	KeyEnter          Key = Key(ui.KeyEnter)
	KeyEqual          Key = Key(ui.KeyEqual)
	KeyEscape         Key = Key(ui.KeyEscape)
	KeyF1             Key = Key(ui.KeyF1)
	KeyF2             Key = Key(ui.KeyF2)
	KeyF3             Key = Key(ui.KeyF3)
	KeyF4             Key = Key(ui.KeyF4)
	KeyF5             Key = Key(ui.KeyF5)
	KeyF6             Key = Key(ui.KeyF6)
	KeyF7             Key = Key(ui.KeyF7)
	KeyF8             Key = Key(ui.KeyF8)
	KeyF9             Key = Key(ui.KeyF9)
	KeyF10            Key = Key(ui.KeyF10)
	KeyF11            Key = Key(ui.KeyF11)
	KeyF12            Key = Key(ui.KeyF12)
	KeyHome           Key = Key(ui.KeyHome)
	KeyInsert         Key = Key(ui.KeyInsert)
	KeyMetaLeft       Key = Key(ui.KeyMetaLeft)
	KeyMetaRight      Key = Key(ui.KeyMetaRight)
	KeyMinus          Key = Key(ui.KeyMinus)
	KeyNumLock        Key = Key(ui.KeyNumLock)
	KeyNumpad0        Key = Key(ui.KeyNumpad0)
	KeyNumpad1        Key = Key(ui.KeyNumpad1)
	KeyNumpad2        Key = Key(ui.KeyNumpad2)
	KeyNumpad3        Key = Key(ui.KeyNumpad3)
	KeyNumpad4        Key = Key(ui.KeyNumpad4)
	KeyNumpad5        Key = Key(ui.KeyNumpad5)
	KeyNumpad6        Key = Key(ui.KeyNumpad6)
	KeyNumpad7        Key = Key(ui.KeyNumpad7)
	KeyNumpad8        Key = Key(ui.KeyNumpad8)
	KeyNumpad9        Key = Key(ui.KeyNumpad9)
	KeyNumpadAdd      Key = Key(ui.KeyNumpadAdd)
	KeyNumpadDecimal  Key = Key(ui.KeyNumpadDecimal)
	KeyNumpadDivide   Key = Key(ui.KeyNumpadDivide)
	KeyNumpadEnter    Key = Key(ui.KeyNumpadEnter)
	KeyNumpadEqual    Key = Key(ui.KeyNumpadEqual)
	KeyNumpadMultiply Key = Key(ui.KeyNumpadMultiply)
	KeyNumpadSubtract Key = Key(ui.KeyNumpadSubtract)
	KeyPageDown       Key = Key(ui.KeyPageDown)
	KeyPageUp         Key = Key(ui.KeyPageUp)
	KeyPause          Key = Key(ui.KeyPause)
	KeyPeriod         Key = Key(ui.KeyPeriod)
	KeyPrintScreen    Key = Key(ui.KeyPrintScreen)
	KeyQuote          Key = Key(ui.KeyQuote)
	KeyScrollLock     Key = Key(ui.KeyScrollLock)
	KeySemicolon      Key = Key(ui.KeySemicolon)
	KeyShiftLeft      Key = Key(ui.KeyShiftLeft)
	KeyShiftRight     Key = Key(ui.KeyShiftRight)
	KeySlash          Key = Key(ui.KeySlash)
	KeySpace          Key = Key(ui.KeySpace)
	KeyTab            Key = Key(ui.KeyTab)
	KeyAlt            Key = Key(ui.KeyReserved0)
	KeyControl        Key = Key(ui.KeyReserved1)
	KeyShift          Key = Key(ui.KeyReserved2)
	KeyMeta           Key = Key(ui.KeyReserved3)
	KeyMax            Key = KeyMeta

	// Keys for backward compatibility.
	// Deprecated: as of v2.1.
	Key0            Key = Key(ui.KeyDigit0)
	Key1            Key = Key(ui.KeyDigit1)
	Key2            Key = Key(ui.KeyDigit2)
	Key3            Key = Key(ui.KeyDigit3)
	Key4            Key = Key(ui.KeyDigit4)
	Key5            Key = Key(ui.KeyDigit5)
	Key6            Key = Key(ui.KeyDigit6)
	Key7            Key = Key(ui.KeyDigit7)
	Key8            Key = Key(ui.KeyDigit8)
	Key9            Key = Key(ui.KeyDigit9)
	KeyApostrophe   Key = Key(ui.KeyQuote)
	KeyDown         Key = Key(ui.KeyArrowDown)
	KeyGraveAccent  Key = Key(ui.KeyBackquote)
	KeyKP0          Key = Key(ui.KeyNumpad0)
	KeyKP1          Key = Key(ui.KeyNumpad1)
	KeyKP2          Key = Key(ui.KeyNumpad2)
	KeyKP3          Key = Key(ui.KeyNumpad3)
	KeyKP4          Key = Key(ui.KeyNumpad4)
	KeyKP5          Key = Key(ui.KeyNumpad5)
	KeyKP6          Key = Key(ui.KeyNumpad6)
	KeyKP7          Key = Key(ui.KeyNumpad7)
	KeyKP8          Key = Key(ui.KeyNumpad8)
	KeyKP9          Key = Key(ui.KeyNumpad9)
	KeyKPAdd        Key = Key(ui.KeyNumpadAdd)
	KeyKPDecimal    Key = Key(ui.KeyNumpadDecimal)
	KeyKPDivide     Key = Key(ui.KeyNumpadDivide)
	KeyKPEnter      Key = Key(ui.KeyNumpadEnter)
	KeyKPEqual      Key = Key(ui.KeyNumpadEqual)
	KeyKPMultiply   Key = Key(ui.KeyNumpadMultiply)
	KeyKPSubtract   Key = Key(ui.KeyNumpadSubtract)
	KeyLeft         Key = Key(ui.KeyArrowLeft)
	KeyLeftBracket  Key = Key(ui.KeyBracketLeft)
	KeyMenu         Key = Key(ui.KeyContextMenu)
	KeyRight        Key = Key(ui.KeyArrowRight)
	KeyRightBracket Key = Key(ui.KeyBracketRight)
	KeyUp           Key = Key(ui.KeyArrowUp)
)

Keys.

func (Key) String 

func (k Key) String() string

String returns a string representing the key.

If k is an undefined key, String returns an empty string.

type MouseButton 

type MouseButton = ui.MouseButton

A MouseButton represents a mouse button. 

const (
	MouseButtonLeft   MouseButton = ui.MouseButtonLeft
	MouseButtonRight  MouseButton = ui.MouseButtonRight
	MouseButtonMiddle MouseButton = ui.MouseButtonMiddle
)

MouseButtons

type Shader 

type Shader struct {
	// contains filtered or unexported fields
}

Shader represents a compiled shader program.

For the details about the shader, see https://ebiten.org/documents/shader.html.

func NewShader 

func NewShader(src []byte) (*Shader, error)

NewShader compiles a shader program in the shading language Kage, and retruns the result.

As of v2.3.0, the error value is always nil, and the actual complation happens lazily after the main loop starts.

For the details about the shader, see https://ebiten.org/documents/shader.html.

func (*Shader) Dispose 

func (s *Shader) Dispose()

Dispose disposes the shader program. After disposing, the shader is no longer available.

type StandardGamepadAxis added in v2.2.0 

type StandardGamepadAxis = gamepaddb.StandardAxis

StandardGamepadAxis represents a gamepad axis in the standard layout.

The layout and the button values are based on the web standard. See https://www.w3.org/TR/gamepad/#remapping. 

const (
	StandardGamepadAxisLeftStickHorizontal  StandardGamepadAxis = gamepaddb.StandardAxisLeftStickHorizontal
	StandardGamepadAxisLeftStickVertical    StandardGamepadAxis = gamepaddb.StandardAxisLeftStickVertical
	StandardGamepadAxisRightStickHorizontal StandardGamepadAxis = gamepaddb.StandardAxisRightStickHorizontal
	StandardGamepadAxisRightStickVertical   StandardGamepadAxis = gamepaddb.StandardAxisRightStickVertical
	StandardGamepadAxisMax                  StandardGamepadAxis = StandardGamepadAxisRightStickVertical
)

StandardGamepadAxes

type StandardGamepadButton added in v2.2.0 

type StandardGamepadButton = gamepaddb.StandardButton

StandardGamepadButton represents a gamepad button in the standard layout.

The layout and the button values are based on the web standard. See https://www.w3.org/TR/gamepad/#remapping. 

const (
	StandardGamepadButtonRightBottom      StandardGamepadButton = gamepaddb.StandardButtonRightBottom
	StandardGamepadButtonRightRight       StandardGamepadButton = gamepaddb.StandardButtonRightRight
	StandardGamepadButtonRightLeft        StandardGamepadButton = gamepaddb.StandardButtonRightLeft
	StandardGamepadButtonRightTop         StandardGamepadButton = gamepaddb.StandardButtonRightTop
	StandardGamepadButtonFrontTopLeft     StandardGamepadButton = gamepaddb.StandardButtonFrontTopLeft
	StandardGamepadButtonFrontTopRight    StandardGamepadButton = gamepaddb.StandardButtonFrontTopRight
	StandardGamepadButtonFrontBottomLeft  StandardGamepadButton = gamepaddb.StandardButtonFrontBottomLeft
	StandardGamepadButtonFrontBottomRight StandardGamepadButton = gamepaddb.StandardButtonFrontBottomRight
	StandardGamepadButtonCenterLeft       StandardGamepadButton = gamepaddb.StandardButtonCenterLeft
	StandardGamepadButtonCenterRight      StandardGamepadButton = gamepaddb.StandardButtonCenterRight
	StandardGamepadButtonLeftStick        StandardGamepadButton = gamepaddb.StandardButtonLeftStick
	StandardGamepadButtonRightStick       StandardGamepadButton = gamepaddb.StandardButtonRightStick
	StandardGamepadButtonLeftTop          StandardGamepadButton = gamepaddb.StandardButtonLeftTop
	StandardGamepadButtonLeftBottom       StandardGamepadButton = gamepaddb.StandardButtonLeftBottom
	StandardGamepadButtonLeftLeft         StandardGamepadButton = gamepaddb.StandardButtonLeftLeft
	StandardGamepadButtonLeftRight        StandardGamepadButton = gamepaddb.StandardButtonLeftRight
	StandardGamepadButtonCenterCenter     StandardGamepadButton = gamepaddb.StandardButtonCenterCenter
	StandardGamepadButtonMax              StandardGamepadButton = StandardGamepadButtonCenterCenter
)

StandardGamepadButtons

type TouchID 

type TouchID = ui.TouchID

TouchID represents a touch's identifier.

func AppendTouchIDs added in v2.2.0 

func AppendTouchIDs(touches []TouchID) []TouchID

AppendTouchIDs appends the current touch states to touches, and returns the extended buffer. Giving a slice that already has enough capacity works efficiently.

If you want to know whether a touch started being pressed in the current frame, use inpututil.JustPressedTouchIDs

AppendTouchIDs doesn't append anything when there are no touches. AppendTouchIDs always does nothing on desktops.

AppendTouchIDs is concurrent-safe.

func TouchIDs 

func TouchIDs() []TouchID

TouchIDs returns the current touch states.

Deperecated: as of v2.2. Use AppendTouchIDs instead.

type Vertex 

type Vertex struct {
	// DstX and DstY represents a point on a destination image.
	DstX float32
	DstY float32

	// SrcX and SrcY represents a point on a source image.
	// Be careful that SrcX/SrcY coordinates are on the image's bounds.
	// This means that a left-upper point of a sub-image might not be (0, 0).
	SrcX float32
	SrcY float32

	// ColorR/ColorG/ColorB/ColorA represents color scaling values.
	// Their interpretation depends on the concrete draw call used:
	// - DrawTriangles: straight-alpha encoded color multiplier.
	//   If ColorA is 0, the vertex is fully transparent and color is ignored.
	//   If ColorA is 1, the vertex has the color (ColorR, ColorG, ColorB).
	//   Vertex colors are interpolated linearly respecting alpha.
	// - DrawTrianglesShader: arbitrary floating point values sent to the shader.
	//   These are interpolated linearly and independently from each other.
	ColorR float32
	ColorG float32
	ColorB float32
	ColorA float32
}

Vertex represents a vertex passed to DrawTriangles.

type VibrateGamepadOptions added in v2.3.0 

type VibrateGamepadOptions struct {
	// Duration is the time duration of the effect.
	Duration time.Duration

	// StrongMagnitude is the rumble intensity of a low-frequency rumble motor.
	// The value is in between 0 and 1.
	StrongMagnitude float64

	// StrongMagnitude is the rumble intensity of a high-frequency rumble motor.
	// The value is in between 0 and 1.
	WeakMagnitude float64
}

VibrateGamepadOptions represents the options for gamepad vibration.

type VibrateOptions added in v2.3.0 

type VibrateOptions struct {
	// Duration is the time duration of the effect.
	Duration time.Duration

	// Magnitude is the strength of the device vibration.
	// The value is in between 0 and 1.
	Magnitude float64
}

VibrateOptions represents the options for device vibration.

type WindowResizingModeType added in v2.3.0 

type WindowResizingModeType = ui.WindowResizingMode

WindowResizingModeType represents a mode in which a user resizes the window.

Regardless of the resizing mode, an Ebiten application can still change the window size or make the window fullscreen by calling Ebiten functions. 

const (
	// WindowResizingModeDisabled indicates the mode to disallow resizing the window by a user.
	WindowResizingModeDisabled WindowResizingModeType = WindowResizingModeType(ui.WindowResizingModeDisabled)

	// WindowResizingModeDisabled indicates the mode to disallow resizing the window,
	// but allow to make the window fullscreen by a user.
	// This works only on macOS so far.
	// On the other platforms, this is the same as WindowResizingModeDisabled.
	WindowResizingModeOnlyFullscreenEnabled WindowResizingModeType = WindowResizingModeType(ui.WindowResizingModeOnlyFullscreenEnabled)

	// WindowResizingModeEnabled indicates the mode to allow resizing the window by a user.
	WindowResizingModeEnabled WindowResizingModeType = WindowResizingModeType(ui.WindowResizingModeEnabled)
)

WindowResizingModeTypes

func WindowResizingMode added in v2.3.0 

func WindowResizingMode() WindowResizingModeType

WindowResizingMode returns the current mode in which a user resizes the window.

The default mode is WindowResizingModeDisabled.

WindowResizingMode is concurrent-safe.

Source Files

View all Source files

Directories

Path Synopsis
Package audio provides audio players.
 Package audio provides audio players.
internal/convert
internal/go2cpp
mp3
Package mp3 provides MP3 decoder.
 Package mp3 provides MP3 decoder.
vorbis
Package vorbis provides Ogg/Vorbis decoder.
 Package vorbis provides Ogg/Vorbis decoder.
wav
Package wav provides WAV (RIFF) decoder.
 Package wav provides WAV (RIFF) decoder.
cmd
ebitenmobile
ebitenmobile is a wrapper of gomobile for Ebiten.
 ebitenmobile is a wrapper of gomobile for Ebiten.
Package ebitenutil provides utility functions for Ebiten.
 Package ebitenutil provides utility functions for Ebiten.
internal/assets
examples
2048/2048
blocks/blocks
keyboard/keyboard
resources
resources/audio
resources/fonts
resources/images
resources/images/audio
resources/images/blocks
resources/images/flappy
resources/images/keyboard
resources/images/mascot
resources/images/platformer
resources/images/shader
shader
Package inpututil provides utility functions of input like keyboard or mouse.
 Package inpututil provides utility functions of input like keyboard or mouse.
internal
affine
atlas
buffered
clock
Package clock manages game timers.
 Package clock manages game timers.
debug
devicescale
gamepad
gamepaddb
glfw
graphics
graphicscommand
Package graphicscommand represents a low layer for graphics using OpenGL.
 Package graphicscommand represents a low layer for graphics using OpenGL.
graphicsdriver
graphicsdriver/directx
graphicsdriver/metal
graphicsdriver/metal/ca
Package ca provides access to Apple's Core Animation API (https://developer.apple.com/documentation/quartzcore).
 Package ca provides access to Apple's Core Animation API (https://developer.apple.com/documentation/quartzcore).
graphicsdriver/metal/mtl
Package mtl provides access to Apple's Metal API (https://developer.apple.com/documentation/metal).
 Package mtl provides access to Apple's Metal API (https://developer.apple.com/documentation/metal).
graphicsdriver/metal/ns
Package ns provides access to Apple's AppKit API (https://developer.apple.com/documentation/appkit).
 Package ns provides access to Apple's AppKit API (https://developer.apple.com/documentation/appkit).
graphicsdriver/opengl
graphicsdriver/opengl/gl
Package gl implements Go bindings to OpenGL.
 Package gl implements Go bindings to OpenGL.
graphicsdriver/opengl/gles
Package gles implements Go bindings to OpenGL ES.
 Package gles implements Go bindings to OpenGL ES.
hooks
jsutil
Package jsutil offers utility functions for Wasm.
 Package jsutil offers utility functions for Wasm.
mipmap
packing
Package packing offers a packing algorithm in 2D space.
 Package packing offers a packing algorithm in 2D space.
png
Package png implements a PNG image decoder and encoder.
 Package png implements a PNG image decoder and encoder.
restorable
Package restorable offers an Image struct that stores image commands and restores its pixel data from the commands when context lost happens.
 Package restorable offers an Image struct that stores image commands and restores its pixel data from the commands when context lost happens.
shader
shaderir
Package shaderir offers intermediate representation for shader programs.
 Package shaderir offers intermediate representation for shader programs.
shaderir/glsl
shaderir/hlsl
shaderir/msl
testing
thread
ui
vibrate
Package mobile provides functions for mobile platforms (Android and iOS).
 Package mobile provides functions for mobile platforms (Android and iOS).
Package text offers functions to draw texts on an Ebiten's image.
 Package text offers functions to draw texts on an Ebiten's image.
Package vector provides functions for vector graphics rendering.
 Package vector provides functions for vector graphics rendering.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.