ebiten

package module
v2.1.0-alpha.7 Latest Latest
Warning

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

 Go to latest Published: Jan 1, 2021 License: Apache-2.0 Imports: 26 Imported by: 3,909

README

Ebiten (v2)

PkgGoDev Build Status Build Status Go Report Card

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: Gamepad and keyboard are not available on Android/iOS.

For installation on desktops, see the installation instruction.

Features

  • 2D Graphics (Geometry/Color matrix transformation, Various composition modes, Offscreen rendering, Fullscreen, Text rendering, Automatic batches, Automatic texture atlas)
  • Input (Mouse, Keyboard, Gamepads, Touches)
  • Audio (Ogg/Vorbis, MP3, WAV, PCM)

Packages

Community

Slack

#ebiten channel in Gophers Slack

License

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

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.

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.

`ebitengl` forces to use OpenGL in any environments.

`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.

Index

Constants

View Source 
const ColorMDim = affine.ColorMDim

ColorMDim is a dimension of a ColorM.

View Source 
const DefaultTPS = 60

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 UncappedTPS = clock.UncappedTPS

UncappedTPS is a special TPS value that means the game doesn't have limitation on TPS.

Variables

This section is empty.

Functions

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.

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.

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 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.

func GamepadAxis 

func GamepadAxis(id GamepadID, axis int) float64

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

GamepadAxis is concurrent-safe.

GamepadAxis always returns 0 on mobiles.

func GamepadAxisNum 

func GamepadAxisNum(id GamepadID) int

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

GamepadAxisNum is concurrent-safe.

GamepadAxisNum always returns 0 on mobiles.

func GamepadButtonNum 

func GamepadButtonNum(id GamepadID) int

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

GamepadButtonNum is concurrent-safe.

GamepadButtonNum always returns 0 on mobiles.

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 always returns an empty string on mobiles.

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 

func InputChars() []rune

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

InputChars represents the environment's locale-dependent translation of keyboard input to Unicode characters.

IsKeyPressed is based on a mapping of device (US keyboard) codes to input device keys. "Control" and modifier keys should be handled with IsKeyPressed.

InputChars 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 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 browsers or mobiles.

IsFullscreen is concurrent-safe.

func IsGamepadButtonPressed 

func IsGamepadButtonPressed(id GamepadID, button GamepadButton) bool

IsGamepadButtonPressed returns the boolean indicating 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.

IsGamepadButtonPressed always returns false on mobiles.

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

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 IsScreenTransparent 

func IsScreenTransparent() bool

IsScreenTransparent reports whether the window is transparent.

IsScreenTransparent is concurrent-safe.

func IsVsyncEnabled 

func IsVsyncEnabled() bool

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

IsVsyncEnabled 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.

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 

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.

IsWindowResizable is concurrent-safe.

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.

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, if it exists, 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 must implement Game interface. Game's Draw function is optional, but it is recommended to implement Draw to seperate updating the logic and rendering.

RunGame is a more flexibile form of Run due to game's Layout function. You can make a resizable window if you use RunGame, while you cannot if you use Run. RunGame is more sophisticated way than Run and hides the notion of 'scale'.

While Run specifies the window size, RunGame does not. You need to call SetWindowSize before RunGame if you want. Otherwise, a default window size is adopted.

Some functions (ScreenScale, SetScreenScale, SetScreenSize) are not available with RunGame.

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) OpenGL error happens, 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 RunGameWithoutMainLoop 

func RunGameWithoutMainLoop(game Game)

RunGameWithoutMainLoop runs the game, but don't call the loop on the main (UI) thread. Different from Run, RunGameWithoutMainLoop returns immediately.

Ebiten users should NOT call RunGameWithoutMainLoop. Instead, functions in github.com/hajimehoshi/ebiten/v2/mobile package calls this.

TODO: Remove this. In order to remove this, the uiContext should be in another package.

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. For more details, see SetFullscreen API comment.

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.

On browsers, only CursorModeVisible and CursorModeHidden are supported.

SetCursorMode does nothing on mobiles.

SetCursorMode is concurrent-safe.

func SetFullscreen 

func SetFullscreen(fullscreen bool)

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

On 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.

SetFullscreen does nothing on browsers or mobiles.

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 SetRunnableInBackground.

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 UncappedTPS, TPS is uncapped and the game is updated per frame. If tps is negative but not UncappedTPS, 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 false and the screen is cleared each frame by default.

SetScreenClearedEveryFrame is concurrent-safe.

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 

func SetVsyncEnabled(enabled bool)

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

If the given value is true, the game tries to sync the display's refresh rate. If false, the game ignores the display's refresh rate. The initial value is true. By disabling vsync, the game works more efficiently but consumes more CPU.

Note that the state doesn't affect TPS (ticks per second, i.e. how many the run function is updated per second).

SetVsyncEnabled does nothing on mobiles so far.

SetVsyncEnabled 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 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 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 on fullscreen mode.

SetWindowPosition does nothing on browsers and mobiles.

SetWindowPosition is concurrent-safe.

func SetWindowResizable 

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.

The window is not resizable by default.

If SetWindowResizable is called with true and Run is used, SetWindowResizable panics. Use RunGame instead.

SetWindowResizable is concurrent-safe.

func SetWindowSize 

func SetWindowSize(width, height int)

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

On fullscreen mode, SetWindowSize sets the original window size.

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

SetWindowSize 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 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 Wheel 

func Wheel() (xoff, yoff float64)

Wheel returns the x and y offset 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 on 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.

On fullscreen mode, WindowSize returns the original window size.

WindowSize 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(driver.AddressUnsafe)

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

	// AddressRepeat means that texture coordinates wrap to the other side of the texture.
	AddressRepeat Address = Address(driver.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) 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(driver.CompositeModeSourceOver)

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

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

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

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

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

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

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

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

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

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

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

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

	// The product of source and destination (a.k.a 'multiply blend mode')
	// c_out = c_src * c_dst
	CompositeModeMultiply CompositeMode = CompositeMode(driver.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 int

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

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

func CursorMode 

func CursorMode() CursorModeType

CursorMode returns the current cursor mode.

On browsers, only CursorModeVisible and CursorModeHidden are supported.

CursorMode returns CursorModeHidden on mobiles.

CursorMode 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
}

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
}

DrawTrianglesShaderOptions represents options for DrawTrianglesShader.

This API is experimental.

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(driver.FilterNearest)

	// FilterLinear represents linear filter
	FilterLinear Filter = Filter(driver.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 int

A GamepadButton represents a gamepad button. 

const (
	GamepadButton0   GamepadButton = GamepadButton(driver.GamepadButton0)
	GamepadButton1   GamepadButton = GamepadButton(driver.GamepadButton1)
	GamepadButton2   GamepadButton = GamepadButton(driver.GamepadButton2)
	GamepadButton3   GamepadButton = GamepadButton(driver.GamepadButton3)
	GamepadButton4   GamepadButton = GamepadButton(driver.GamepadButton4)
	GamepadButton5   GamepadButton = GamepadButton(driver.GamepadButton5)
	GamepadButton6   GamepadButton = GamepadButton(driver.GamepadButton6)
	GamepadButton7   GamepadButton = GamepadButton(driver.GamepadButton7)
	GamepadButton8   GamepadButton = GamepadButton(driver.GamepadButton8)
	GamepadButton9   GamepadButton = GamepadButton(driver.GamepadButton9)
	GamepadButton10  GamepadButton = GamepadButton(driver.GamepadButton10)
	GamepadButton11  GamepadButton = GamepadButton(driver.GamepadButton11)
	GamepadButton12  GamepadButton = GamepadButton(driver.GamepadButton12)
	GamepadButton13  GamepadButton = GamepadButton(driver.GamepadButton13)
	GamepadButton14  GamepadButton = GamepadButton(driver.GamepadButton14)
	GamepadButton15  GamepadButton = GamepadButton(driver.GamepadButton15)
	GamepadButton16  GamepadButton = GamepadButton(driver.GamepadButton16)
	GamepadButton17  GamepadButton = GamepadButton(driver.GamepadButton17)
	GamepadButton18  GamepadButton = GamepadButton(driver.GamepadButton18)
	GamepadButton19  GamepadButton = GamepadButton(driver.GamepadButton19)
	GamepadButton20  GamepadButton = GamepadButton(driver.GamepadButton20)
	GamepadButton21  GamepadButton = GamepadButton(driver.GamepadButton21)
	GamepadButton22  GamepadButton = GamepadButton(driver.GamepadButton22)
	GamepadButton23  GamepadButton = GamepadButton(driver.GamepadButton23)
	GamepadButton24  GamepadButton = GamepadButton(driver.GamepadButton24)
	GamepadButton25  GamepadButton = GamepadButton(driver.GamepadButton25)
	GamepadButton26  GamepadButton = GamepadButton(driver.GamepadButton26)
	GamepadButton27  GamepadButton = GamepadButton(driver.GamepadButton27)
	GamepadButton28  GamepadButton = GamepadButton(driver.GamepadButton28)
	GamepadButton29  GamepadButton = GamepadButton(driver.GamepadButton29)
	GamepadButton30  GamepadButton = GamepadButton(driver.GamepadButton30)
	GamepadButton31  GamepadButton = GamepadButton(driver.GamepadButton31)
	GamepadButtonMax GamepadButton = GamepadButton31
)

GamepadButtons

type GamepadID 

type GamepadID = driver.GamepadID

GamepadID represents a gamepad's identifier.

func GamepadIDs 

func GamepadIDs() []GamepadID

GamepadIDs returns a slice indicating available gamepad IDs.

GamepadIDs is concurrent-safe.

GamepadIDs always returns an empty slice on mobiles.

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 muptiplying 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.

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.

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. The texture atlas size is 4096x4096 so far. 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.

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.

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) 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.

In the current Ebiten implementation, SubImage is available only as a rendering source.

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 (
	Key0            Key = Key(driver.Key0)
	Key1            Key = Key(driver.Key1)
	Key2            Key = Key(driver.Key2)
	Key3            Key = Key(driver.Key3)
	Key4            Key = Key(driver.Key4)
	Key5            Key = Key(driver.Key5)
	Key6            Key = Key(driver.Key6)
	Key7            Key = Key(driver.Key7)
	Key8            Key = Key(driver.Key8)
	Key9            Key = Key(driver.Key9)
	KeyA            Key = Key(driver.KeyA)
	KeyB            Key = Key(driver.KeyB)
	KeyC            Key = Key(driver.KeyC)
	KeyD            Key = Key(driver.KeyD)
	KeyE            Key = Key(driver.KeyE)
	KeyF            Key = Key(driver.KeyF)
	KeyG            Key = Key(driver.KeyG)
	KeyH            Key = Key(driver.KeyH)
	KeyI            Key = Key(driver.KeyI)
	KeyJ            Key = Key(driver.KeyJ)
	KeyK            Key = Key(driver.KeyK)
	KeyL            Key = Key(driver.KeyL)
	KeyM            Key = Key(driver.KeyM)
	KeyN            Key = Key(driver.KeyN)
	KeyO            Key = Key(driver.KeyO)
	KeyP            Key = Key(driver.KeyP)
	KeyQ            Key = Key(driver.KeyQ)
	KeyR            Key = Key(driver.KeyR)
	KeyS            Key = Key(driver.KeyS)
	KeyT            Key = Key(driver.KeyT)
	KeyU            Key = Key(driver.KeyU)
	KeyV            Key = Key(driver.KeyV)
	KeyW            Key = Key(driver.KeyW)
	KeyX            Key = Key(driver.KeyX)
	KeyY            Key = Key(driver.KeyY)
	KeyZ            Key = Key(driver.KeyZ)
	KeyApostrophe   Key = Key(driver.KeyApostrophe)
	KeyBackslash    Key = Key(driver.KeyBackslash)
	KeyBackspace    Key = Key(driver.KeyBackspace)
	KeyCapsLock     Key = Key(driver.KeyCapsLock)
	KeyComma        Key = Key(driver.KeyComma)
	KeyDelete       Key = Key(driver.KeyDelete)
	KeyDown         Key = Key(driver.KeyDown)
	KeyEnd          Key = Key(driver.KeyEnd)
	KeyEnter        Key = Key(driver.KeyEnter)
	KeyEqual        Key = Key(driver.KeyEqual)
	KeyEscape       Key = Key(driver.KeyEscape)
	KeyF1           Key = Key(driver.KeyF1)
	KeyF2           Key = Key(driver.KeyF2)
	KeyF3           Key = Key(driver.KeyF3)
	KeyF4           Key = Key(driver.KeyF4)
	KeyF5           Key = Key(driver.KeyF5)
	KeyF6           Key = Key(driver.KeyF6)
	KeyF7           Key = Key(driver.KeyF7)
	KeyF8           Key = Key(driver.KeyF8)
	KeyF9           Key = Key(driver.KeyF9)
	KeyF10          Key = Key(driver.KeyF10)
	KeyF11          Key = Key(driver.KeyF11)
	KeyF12          Key = Key(driver.KeyF12)
	KeyGraveAccent  Key = Key(driver.KeyGraveAccent)
	KeyHome         Key = Key(driver.KeyHome)
	KeyInsert       Key = Key(driver.KeyInsert)
	KeyKP0          Key = Key(driver.KeyKP0)
	KeyKP1          Key = Key(driver.KeyKP1)
	KeyKP2          Key = Key(driver.KeyKP2)
	KeyKP3          Key = Key(driver.KeyKP3)
	KeyKP4          Key = Key(driver.KeyKP4)
	KeyKP5          Key = Key(driver.KeyKP5)
	KeyKP6          Key = Key(driver.KeyKP6)
	KeyKP7          Key = Key(driver.KeyKP7)
	KeyKP8          Key = Key(driver.KeyKP8)
	KeyKP9          Key = Key(driver.KeyKP9)
	KeyKPAdd        Key = Key(driver.KeyKPAdd)
	KeyKPDecimal    Key = Key(driver.KeyKPDecimal)
	KeyKPDivide     Key = Key(driver.KeyKPDivide)
	KeyKPEnter      Key = Key(driver.KeyKPEnter)
	KeyKPEqual      Key = Key(driver.KeyKPEqual)
	KeyKPMultiply   Key = Key(driver.KeyKPMultiply)
	KeyKPSubtract   Key = Key(driver.KeyKPSubtract)
	KeyLeft         Key = Key(driver.KeyLeft)
	KeyLeftBracket  Key = Key(driver.KeyLeftBracket)
	KeyMenu         Key = Key(driver.KeyMenu)
	KeyMinus        Key = Key(driver.KeyMinus)
	KeyNumLock      Key = Key(driver.KeyNumLock)
	KeyPageDown     Key = Key(driver.KeyPageDown)
	KeyPageUp       Key = Key(driver.KeyPageUp)
	KeyPause        Key = Key(driver.KeyPause)
	KeyPeriod       Key = Key(driver.KeyPeriod)
	KeyPrintScreen  Key = Key(driver.KeyPrintScreen)
	KeyRight        Key = Key(driver.KeyRight)
	KeyRightBracket Key = Key(driver.KeyRightBracket)
	KeyScrollLock   Key = Key(driver.KeyScrollLock)
	KeySemicolon    Key = Key(driver.KeySemicolon)
	KeySlash        Key = Key(driver.KeySlash)
	KeySpace        Key = Key(driver.KeySpace)
	KeyTab          Key = Key(driver.KeyTab)
	KeyUp           Key = Key(driver.KeyUp)
	KeyAlt          Key = Key(driver.KeyReserved0)
	KeyControl      Key = Key(driver.KeyReserved1)
	KeyShift        Key = Key(driver.KeyReserved2)
	KeySuper        Key = Key(driver.KeyReserved3)
	KeyMax          Key = KeySuper
)

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 int

A MouseButton represents a mouse button. 

const (
	MouseButtonLeft   MouseButton = MouseButton(driver.MouseButtonLeft)
	MouseButtonRight  MouseButton = MouseButton(driver.MouseButtonRight)
	MouseButtonMiddle MouseButton = MouseButton(driver.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.

If the compilation fails, NewShader returns an error.

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 TouchID 

type TouchID = driver.TouchID

TouchID represents a touch's identifier.

func TouchIDs 

func TouchIDs() []TouchID

TouchIDs returns the current touch states.

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

TouchIDs returns nil when there are no touches. TouchIDs always returns nil on desktops.

TouchIDs is concurrent-safe.

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.
	// 1 means the original source image color is used.
	// 0 means a transparent color is used.
	ColorR float32
	ColorG float32
	ColorB float32
	ColorA float32
}

Vertex represents a vertex passed to DrawTriangles.

Source Files

View all Source files

Directories

Path Synopsis
Package audio provides audio players.
 Package audio provides audio players.
internal/convert
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/blocks
resources/images/flappy
resources/images/keyboard
resources/images/mascot
resources/images/platformer
resources/images/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
buffered
clock
Package clock manages game timers.
 Package clock manages game timers.
colormcache
debug
devicescale
driver
glfw
graphics
graphicscommand
Package graphicscommand represents a low layer for graphics using OpenGL.
 Package graphicscommand represents a low layer for graphics using OpenGL.
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/metal
shareable
testflock
Package testflock provides a lock for testing.
 Package testflock provides a lock for testing.
testing
thread
uidriver/glfw
uidriver/js
uidriver/mobile
web
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.
internal/triangulate

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.