2014-12-24 03:04:10 +01:00
|
|
|
// Copyright 2014 Hajime Hoshi
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
// you may not use this file except in compliance with the License.
|
|
|
|
// You may obtain a copy of the License at
|
|
|
|
//
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
//
|
|
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
// See the License for the specific language governing permissions and
|
|
|
|
// limitations under the License.
|
2014-12-09 15:16:04 +01:00
|
|
|
|
2014-12-14 08:53:32 +01:00
|
|
|
package ebiten
|
2014-12-06 17:09:59 +01:00
|
|
|
|
2014-12-27 20:01:23 +01:00
|
|
|
import (
|
2016-07-03 09:18:29 +02:00
|
|
|
"sync/atomic"
|
|
|
|
|
2020-10-03 19:35:13 +02:00
|
|
|
"github.com/hajimehoshi/ebiten/v2/internal/clock"
|
|
|
|
"github.com/hajimehoshi/ebiten/v2/internal/driver"
|
2014-12-27 20:01:23 +01:00
|
|
|
)
|
|
|
|
|
2019-11-24 16:12:06 +01:00
|
|
|
// Game defines necessary functions for a game.
|
|
|
|
type Game interface {
|
2020-04-01 07:31:46 +02:00
|
|
|
// Update updates a game by one tick. The given argument represents a screen image.
|
2020-03-24 04:01:37 +01:00
|
|
|
//
|
2020-10-04 10:09:17 +02:00
|
|
|
// Update updates only the game logic and Draw draws the screen.
|
2020-10-04 10:42:54 +02:00
|
|
|
//
|
2020-05-14 21:04:29 +02:00
|
|
|
// In the first frame, it is ensured that Update is called at least once before Draw. You can use Update
|
2020-10-04 10:42:54 +02:00
|
|
|
// to initialize the game state.
|
|
|
|
//
|
|
|
|
// After the first frame, Update might not be called or might be called once
|
2020-05-14 21:06:32 +02:00
|
|
|
// or more for one frame. The frequency is determined by the current TPS (tick-per-second).
|
2020-10-04 10:42:54 +02:00
|
|
|
Update() error
|
2019-11-24 16:12:06 +01:00
|
|
|
|
2020-03-24 04:01:37 +01:00
|
|
|
// Draw draws the game screen by one frame.
|
|
|
|
//
|
2020-03-30 18:56:22 +02:00
|
|
|
// The give argument represents a screen image. The updated content is adopted as the game screen.
|
2020-10-04 10:09:17 +02:00
|
|
|
Draw(screen *Image)
|
2020-03-24 04:01:37 +01:00
|
|
|
|
2019-12-16 02:52:53 +01:00
|
|
|
// Layout accepts a native outside size in device-independent pixels and returns the game's logical screen
|
|
|
|
// size.
|
2019-11-24 16:12:06 +01:00
|
|
|
//
|
2019-12-21 19:50:30 +01:00
|
|
|
// On desktops, the outside is a window or a monitor (fullscreen mode). On browsers, the outside is a body
|
2020-04-01 07:31:46 +02:00
|
|
|
// element. On mobiles, the outside is the view's size.
|
2019-12-21 19:50:30 +01:00
|
|
|
//
|
2020-04-01 07:31:46 +02:00
|
|
|
// Even though the outside size and the screen size differ, the rendering scale is automatically adjusted to
|
|
|
|
// fit with the outside.
|
2019-11-24 16:12:06 +01:00
|
|
|
//
|
2019-12-22 20:43:04 +01:00
|
|
|
// Layout is called almost every frame.
|
|
|
|
//
|
|
|
|
// If Layout returns non-positive numbers, the caller can panic.
|
2019-11-24 16:12:06 +01:00
|
|
|
//
|
|
|
|
// 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)
|
|
|
|
}
|
|
|
|
|
2020-10-17 18:29:35 +02:00
|
|
|
// DefaultTPS represents a default ticks per second, that represents how many times game updating happens in a second.
|
2018-07-16 19:07:03 +02:00
|
|
|
const DefaultTPS = 60
|
2018-07-16 17:52:50 +02:00
|
|
|
|
2018-07-17 19:17:06 +02:00
|
|
|
// CurrentFPS returns the current number of FPS (frames per second), that represents
|
|
|
|
// how many swapping buffer happens per second.
|
2017-09-30 18:59:34 +02:00
|
|
|
//
|
2018-09-30 07:43:53 +02:00
|
|
|
// 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.
|
|
|
|
//
|
2018-07-14 18:04:46 +02:00
|
|
|
// CurrentFPS is concurrent-safe.
|
2016-03-26 09:50:00 +01:00
|
|
|
func CurrentFPS() float64 {
|
2017-08-05 19:17:26 +02:00
|
|
|
return clock.CurrentFPS()
|
2016-03-26 09:50:00 +01:00
|
|
|
}
|
|
|
|
|
2016-07-03 09:18:29 +02:00
|
|
|
var (
|
2020-08-20 10:12:22 +02:00
|
|
|
isScreenClearedEveryFrame = int32(1)
|
|
|
|
currentMaxTPS = int32(DefaultTPS)
|
2016-07-03 09:18:29 +02:00
|
|
|
)
|
|
|
|
|
2020-08-20 10:12:22 +02:00
|
|
|
// SetScreenClearedEveryFrame enables or disables the clearing of the screen at the beginning of each frame.
|
2020-08-13 11:19:56 +02:00
|
|
|
// The default value is false and the screen is cleared each frame by default.
|
|
|
|
//
|
2020-08-20 10:12:22 +02:00
|
|
|
// SetScreenClearedEveryFrame is concurrent-safe.
|
|
|
|
func SetScreenClearedEveryFrame(cleared bool) {
|
2020-08-13 11:19:56 +02:00
|
|
|
v := int32(0)
|
2020-08-20 10:12:22 +02:00
|
|
|
if cleared {
|
2020-08-13 11:19:56 +02:00
|
|
|
v = 1
|
|
|
|
}
|
2020-08-20 10:12:22 +02:00
|
|
|
atomic.StoreInt32(&isScreenClearedEveryFrame, v)
|
|
|
|
theUIContext.setScreenClearedEveryFrame(cleared)
|
2020-08-13 11:19:56 +02:00
|
|
|
}
|
|
|
|
|
2020-08-20 10:12:22 +02:00
|
|
|
// IsScreenClearedEveryFrame returns true if the frame isn't cleared at the beginning.
|
2020-08-13 11:19:56 +02:00
|
|
|
//
|
2020-08-20 10:12:22 +02:00
|
|
|
// IsScreenClearedEveryFrame is concurrent-safe.
|
|
|
|
func IsScreenClearedEveryFrame() bool {
|
|
|
|
return atomic.LoadInt32(&isScreenClearedEveryFrame) != 0
|
2020-08-13 11:19:56 +02:00
|
|
|
}
|
|
|
|
|
2020-10-17 11:11:50 +02:00
|
|
|
type imageDumperGame struct {
|
2020-02-05 19:32:01 +01:00
|
|
|
game Game
|
|
|
|
d *imageDumper
|
2020-10-04 10:42:54 +02:00
|
|
|
err error
|
2020-02-05 19:32:01 +01:00
|
|
|
}
|
|
|
|
|
2020-10-17 11:11:50 +02:00
|
|
|
func (i *imageDumperGame) Update() error {
|
2020-03-24 04:01:37 +01:00
|
|
|
if i.err != nil {
|
|
|
|
return i.err
|
|
|
|
}
|
2020-10-04 10:42:54 +02:00
|
|
|
if i.d == nil {
|
|
|
|
i.d = &imageDumper{g: i.game}
|
|
|
|
}
|
|
|
|
return i.d.update()
|
2020-03-24 04:01:37 +01:00
|
|
|
}
|
|
|
|
|
2020-10-17 11:11:50 +02:00
|
|
|
func (i *imageDumperGame) Draw(screen *Image) {
|
2020-03-24 04:01:37 +01:00
|
|
|
if i.err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2020-10-04 10:09:17 +02:00
|
|
|
i.game.Draw(screen)
|
2020-03-24 04:01:37 +01:00
|
|
|
i.err = i.d.dump(screen)
|
|
|
|
}
|
|
|
|
|
2020-10-17 11:11:50 +02:00
|
|
|
func (i *imageDumperGame) Layout(outsideWidth, outsideHeight int) (screenWidth, screenHeight int) {
|
2020-10-04 10:42:54 +02:00
|
|
|
return i.game.Layout(outsideWidth, outsideHeight)
|
|
|
|
}
|
|
|
|
|
2019-12-16 02:52:53 +01:00
|
|
|
// RunGame starts the main loop and runs the game.
|
2020-06-19 14:12:02 +02:00
|
|
|
// game's Update function is called every tick to update the game logic.
|
2020-03-24 04:01:37 +01:00
|
|
|
// game's Draw function is, if it exists, called every frame to draw the screen.
|
2019-12-22 05:21:15 +01:00
|
|
|
// game's Layout function is called when necessary, and you can specify the logical screen size by the function.
|
2019-12-16 02:52:53 +01:00
|
|
|
//
|
2020-03-24 04:01:37 +01:00
|
|
|
// 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.
|
|
|
|
//
|
2020-04-01 07:38:53 +02:00
|
|
|
// RunGame is a more flexibile form of Run due to game's Layout function.
|
2019-12-22 05:21:15 +01:00
|
|
|
// You can make a resizable window if you use RunGame, while you cannot if you use Run.
|
2019-12-16 02:52:53 +01:00
|
|
|
// RunGame is more sophisticated way than Run and hides the notion of 'scale'.
|
|
|
|
//
|
2019-12-22 04:46:57 +01:00
|
|
|
// 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.
|
2019-12-16 02:52:53 +01:00
|
|
|
//
|
2020-04-01 07:38:53 +02:00
|
|
|
// On browsers, it is strongly recommended to use iframe if you embed an Ebiten application in your website.
|
2019-12-16 02:52:53 +01:00
|
|
|
//
|
|
|
|
// 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).
|
|
|
|
//
|
2020-10-06 18:03:19 +02:00
|
|
|
// RunGame returns error when 1) OpenGL error happens, 2) audio error happens or
|
2019-12-16 02:52:53 +01:00
|
|
|
// 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 RunGame(game Game) error {
|
2019-12-24 16:05:56 +01:00
|
|
|
fixWindowPosition(WindowSize())
|
2020-10-17 11:11:50 +02:00
|
|
|
theUIContext.set(&imageDumperGame{
|
2020-10-04 10:42:54 +02:00
|
|
|
game: game,
|
2020-10-14 19:27:42 +02:00
|
|
|
})
|
2020-01-03 09:32:46 +01:00
|
|
|
if err := uiDriver().Run(theUIContext); err != nil {
|
2019-12-16 02:52:53 +01:00
|
|
|
if err == driver.RegularTermination {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-02-11 09:53:50 +01:00
|
|
|
// RunGameWithoutMainLoop runs the game, but don't call the loop on the main (UI) thread.
|
|
|
|
// Different from Run, RunGameWithoutMainLoop returns immediately.
|
2016-05-18 18:49:57 +02:00
|
|
|
//
|
2020-02-11 09:53:50 +01:00
|
|
|
// Ebiten users should NOT call RunGameWithoutMainLoop.
|
2020-10-03 19:35:13 +02:00
|
|
|
// Instead, functions in github.com/hajimehoshi/ebiten/v2/mobile package calls this.
|
2020-10-17 11:11:50 +02:00
|
|
|
//
|
|
|
|
// TODO: Remove this. In order to remove this, the uiContext should be in another package.
|
2020-02-11 15:19:43 +01:00
|
|
|
func RunGameWithoutMainLoop(game Game) {
|
2020-02-11 09:53:50 +01:00
|
|
|
fixWindowPosition(WindowSize())
|
2020-10-17 11:11:50 +02:00
|
|
|
theUIContext.set(&imageDumperGame{
|
2020-10-04 10:42:54 +02:00
|
|
|
game: game,
|
2020-10-14 19:27:42 +02:00
|
|
|
})
|
2020-02-11 15:19:43 +01:00
|
|
|
uiDriver().RunWithoutMainLoop(theUIContext)
|
2016-05-18 18:49:57 +02:00
|
|
|
}
|
|
|
|
|
2020-03-22 07:32:11 +01:00
|
|
|
// 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.
|
2018-10-09 16:27:29 +02:00
|
|
|
func ScreenSizeInFullscreen() (int, int) {
|
2019-09-02 18:42:53 +02:00
|
|
|
return uiDriver().ScreenSizeInFullscreen()
|
2018-05-04 09:09:55 +02:00
|
|
|
}
|
|
|
|
|
2019-12-14 04:30:03 +01:00
|
|
|
// CursorMode returns the current cursor mode.
|
2017-08-12 08:39:41 +02:00
|
|
|
//
|
2019-12-14 04:30:03 +01:00
|
|
|
// On browsers, only CursorModeVisible and CursorModeHidden are supported.
|
2017-08-12 08:39:41 +02:00
|
|
|
//
|
2019-12-14 04:30:03 +01:00
|
|
|
// CursorMode returns CursorModeHidden on mobiles.
|
|
|
|
//
|
|
|
|
// CursorMode is concurrent-safe.
|
|
|
|
func CursorMode() CursorModeType {
|
|
|
|
return CursorModeType(uiDriver().CursorMode())
|
2017-08-12 08:39:41 +02:00
|
|
|
}
|
|
|
|
|
2019-12-14 04:30:03 +01:00
|
|
|
// 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.
|
2016-09-03 10:17:54 +02:00
|
|
|
//
|
2019-12-14 04:30:03 +01:00
|
|
|
// SetCursorMode does nothing on mobiles.
|
2017-08-12 08:39:41 +02:00
|
|
|
//
|
2019-12-14 04:30:03 +01:00
|
|
|
// SetCursorMode is concurrent-safe.
|
|
|
|
func SetCursorMode(mode CursorModeType) {
|
|
|
|
uiDriver().SetCursorMode(driver.CursorMode(mode))
|
|
|
|
}
|
|
|
|
|
2019-10-21 21:07:14 +02:00
|
|
|
// IsFullscreen reports whether the current mode is fullscreen or not.
|
2017-07-01 06:07:44 +02:00
|
|
|
//
|
2020-10-04 19:00:50 +02:00
|
|
|
// IsFullscreen always returns false on browsers or mobiles.
|
2017-09-30 18:59:34 +02:00
|
|
|
//
|
2018-07-14 18:04:46 +02:00
|
|
|
// IsFullscreen is concurrent-safe.
|
2017-06-29 17:35:34 +02:00
|
|
|
func IsFullscreen() bool {
|
2019-09-02 18:42:53 +02:00
|
|
|
return uiDriver().IsFullscreen()
|
2017-06-29 17:35:34 +02:00
|
|
|
}
|
|
|
|
|
2019-10-14 16:32:38 +02:00
|
|
|
// SetFullscreen changes the current mode to fullscreen or not on desktops.
|
2017-07-01 06:07:44 +02:00
|
|
|
//
|
|
|
|
// On fullscreen mode, the game screen is automatically enlarged
|
|
|
|
// to fit with the monitor. The current scale value is ignored.
|
|
|
|
//
|
2017-07-21 19:15:09 +02:00
|
|
|
// On desktops, Ebiten uses 'windowed' fullscreen mode, which doesn't change
|
2017-07-01 06:07:44 +02:00
|
|
|
// your monitor's resolution.
|
|
|
|
//
|
2020-10-04 19:00:50 +02:00
|
|
|
// SetFullscreen does nothing on browsers or mobiles.
|
2017-07-21 19:15:09 +02:00
|
|
|
//
|
2018-07-14 18:04:46 +02:00
|
|
|
// SetFullscreen is concurrent-safe.
|
2017-06-29 17:35:34 +02:00
|
|
|
func SetFullscreen(fullscreen bool) {
|
2019-09-02 18:42:53 +02:00
|
|
|
uiDriver().SetFullscreen(fullscreen)
|
2017-06-29 17:35:34 +02:00
|
|
|
}
|
2017-08-02 16:37:50 +02:00
|
|
|
|
2020-03-20 16:08:40 +01:00
|
|
|
// IsFocused returns a boolean value indicating whether
|
2020-01-16 02:47:23 +01:00
|
|
|
// the game is in focus or in the foreground.
|
|
|
|
//
|
2020-03-20 16:34:12 +01:00
|
|
|
// IsFocused will only return true if IsRunnableOnUnfocused is false.
|
2020-01-16 02:47:23 +01:00
|
|
|
//
|
2020-03-20 16:08:40 +01:00
|
|
|
// IsFocused is concurrent-safe.
|
|
|
|
func IsFocused() bool {
|
|
|
|
return uiDriver().IsFocused()
|
2020-01-16 02:47:23 +01:00
|
|
|
}
|
|
|
|
|
2020-03-20 16:34:12 +01:00
|
|
|
// IsRunnableOnUnfocused returns a boolean value indicating whether
|
2017-09-13 20:37:38 +02:00
|
|
|
// the game runs even in background.
|
2017-08-02 16:37:50 +02:00
|
|
|
//
|
2020-03-20 16:34:12 +01:00
|
|
|
// IsRunnableOnUnfocused is concurrent-safe.
|
|
|
|
func IsRunnableOnUnfocused() bool {
|
|
|
|
return uiDriver().IsRunnableOnUnfocused()
|
|
|
|
}
|
|
|
|
|
|
|
|
// SetRunnableOnUnfocused sets the state if the game runs even in background.
|
2017-08-02 16:37:50 +02:00
|
|
|
//
|
2020-10-06 17:30:46 +02:00
|
|
|
// If the given value is true, the game runs even in background e.g. when losing focus.
|
|
|
|
// The initial state is true.
|
2017-08-02 16:37:50 +02:00
|
|
|
//
|
|
|
|
// 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.
|
|
|
|
//
|
2020-03-20 16:34:12 +01:00
|
|
|
// SetRunnableOnUnfocused does nothing on mobiles so far.
|
2017-08-02 16:37:50 +02:00
|
|
|
//
|
2020-03-20 16:34:12 +01:00
|
|
|
// SetRunnableOnUnfocused is concurrent-safe.
|
|
|
|
func SetRunnableOnUnfocused(runnableOnUnfocused bool) {
|
|
|
|
uiDriver().SetRunnableOnUnfocused(runnableOnUnfocused)
|
|
|
|
}
|
|
|
|
|
2018-10-09 16:27:29 +02:00
|
|
|
// DeviceScaleFactor returns a device scale factor value of the current monitor which the window belongs to.
|
2018-01-03 08:52:41 +01:00
|
|
|
//
|
2018-01-03 11:23:29 +01:00
|
|
|
// DeviceScaleFactor returns a meaningful value on high-DPI display environment,
|
|
|
|
// otherwise DeviceScaleFactor returns 1.
|
2018-01-03 08:52:41 +01:00
|
|
|
//
|
2018-05-04 20:15:17 +02:00
|
|
|
// DeviceScaleFactor might panic on init function on some devices like Android.
|
2018-05-04 08:26:47 +02:00
|
|
|
// Then, it is not recommended to call DeviceScaleFactor from init functions.
|
|
|
|
//
|
2019-12-16 02:52:53 +01:00
|
|
|
// DeviceScaleFactor must be called on the main thread before the main loop, and is concurrent-safe after the main loop.
|
2018-01-03 11:23:29 +01:00
|
|
|
func DeviceScaleFactor() float64 {
|
2019-09-02 18:42:53 +02:00
|
|
|
return uiDriver().DeviceScaleFactor()
|
2018-01-02 21:25:22 +01:00
|
|
|
}
|
2018-07-14 13:50:09 +02:00
|
|
|
|
|
|
|
// IsVsyncEnabled returns a boolean value indicating whether
|
|
|
|
// the game uses the display's vsync.
|
|
|
|
//
|
|
|
|
// IsVsyncEnabled is concurrent-safe.
|
|
|
|
func IsVsyncEnabled() bool {
|
2019-09-02 18:42:53 +02:00
|
|
|
return uiDriver().IsVsyncEnabled()
|
2018-07-14 13:50:09 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// 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.
|
|
|
|
//
|
2018-12-03 18:23:25 +01:00
|
|
|
// Note that the state doesn't affect TPS (ticks per second, i.e. how many the run function is
|
2018-07-15 21:57:15 +02:00
|
|
|
// updated per second).
|
2018-07-14 13:50:09 +02:00
|
|
|
//
|
2018-07-15 21:57:15 +02:00
|
|
|
// SetVsyncEnabled does nothing on mobiles so far.
|
2018-07-14 13:50:09 +02:00
|
|
|
//
|
|
|
|
// SetVsyncEnabled is concurrent-safe.
|
|
|
|
func SetVsyncEnabled(enabled bool) {
|
2019-09-02 18:42:53 +02:00
|
|
|
uiDriver().SetVsyncEnabled(enabled)
|
2018-07-14 13:50:09 +02:00
|
|
|
}
|
2018-07-16 18:42:19 +02:00
|
|
|
|
2018-07-17 15:41:27 +02:00
|
|
|
// MaxTPS returns the current maximum TPS.
|
2018-07-16 18:42:19 +02:00
|
|
|
//
|
2018-07-17 15:41:27 +02:00
|
|
|
// MaxTPS is concurrent-safe.
|
|
|
|
func MaxTPS() int {
|
|
|
|
return int(atomic.LoadInt32(¤tMaxTPS))
|
2018-07-16 18:42:19 +02:00
|
|
|
}
|
|
|
|
|
2018-07-17 19:11:00 +02:00
|
|
|
// CurrentTPS returns the current TPS (ticks per second),
|
|
|
|
// that represents how many update function is called in a second.
|
2018-07-17 19:17:06 +02:00
|
|
|
//
|
2018-10-10 16:23:28 +02:00
|
|
|
// CurrentTPS is concurrent-safe.
|
2018-07-17 19:11:00 +02:00
|
|
|
func CurrentTPS() float64 {
|
|
|
|
return clock.CurrentTPS()
|
|
|
|
}
|
|
|
|
|
2018-07-17 15:33:53 +02:00
|
|
|
// UncappedTPS is a special TPS value that means the game doesn't have limitation on TPS.
|
2018-07-17 19:11:00 +02:00
|
|
|
const UncappedTPS = clock.UncappedTPS
|
2018-07-17 15:33:53 +02:00
|
|
|
|
|
|
|
// SetMaxTPS sets the maximum TPS (ticks per second),
|
|
|
|
// that represents how many updating function is called per second.
|
2018-07-16 18:42:19 +02:00
|
|
|
// The initial value is 60.
|
|
|
|
//
|
2018-07-17 15:33:53 +02:00
|
|
|
// If tps is UncappedTPS, TPS is uncapped and the game is updated per frame.
|
|
|
|
// If tps is negative but not UncappedTPS, SetMaxTPS panics.
|
2018-07-16 18:42:19 +02:00
|
|
|
//
|
2018-07-17 15:33:53 +02:00
|
|
|
// SetMaxTPS is concurrent-safe.
|
|
|
|
func SetMaxTPS(tps int) {
|
|
|
|
if tps < 0 && tps != UncappedTPS {
|
|
|
|
panic("ebiten: tps must be >= 0 or UncappedTPS")
|
|
|
|
}
|
2018-07-17 15:41:27 +02:00
|
|
|
atomic.StoreInt32(¤tMaxTPS, int32(tps))
|
2018-07-16 18:42:19 +02:00
|
|
|
}
|
2019-11-30 16:07:41 +01:00
|
|
|
|
|
|
|
// IsScreenTransparent reports whether the window is transparent.
|
2020-02-09 13:56:48 +01:00
|
|
|
//
|
|
|
|
// IsScreenTransparent is concurrent-safe.
|
2019-11-30 16:07:41 +01:00
|
|
|
func IsScreenTransparent() bool {
|
|
|
|
return uiDriver().IsScreenTransparent()
|
|
|
|
}
|
|
|
|
|
|
|
|
// SetScreenTransparent sets the state if the window is transparent.
|
|
|
|
//
|
2019-12-16 02:52:53 +01:00
|
|
|
// SetScreenTransparent panics if SetScreenTransparent is called after the main loop.
|
2019-11-30 16:07:41 +01:00
|
|
|
//
|
|
|
|
// SetScreenTransparent does nothing on mobiles.
|
2020-02-09 13:56:48 +01:00
|
|
|
//
|
|
|
|
// SetScreenTransparent is concurrent-safe.
|
2019-11-30 16:07:41 +01:00
|
|
|
func SetScreenTransparent(transparent bool) {
|
|
|
|
uiDriver().SetScreenTransparent(transparent)
|
|
|
|
}
|
2020-02-09 15:03:03 +01:00
|
|
|
|
|
|
|
// 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 SetInitFocused(focused bool) {
|
|
|
|
uiDriver().SetInitFocused(focused)
|
|
|
|
}
|