mirror of
https://github.com/hajimehoshi/ebiten.git
synced 2024-09-20 13:22:19 +02:00
90 lines
2.8 KiB
Go
90 lines
2.8 KiB
Go
// 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.
|
|
|
|
package ebiten
|
|
|
|
import (
|
|
"github.com/hajimehoshi/ebiten/internal/loop"
|
|
)
|
|
|
|
// FPS represents how many times game updating happens in a second.
|
|
const FPS = loop.FPS
|
|
|
|
// CurrentFPS returns the current number of frames per second of rendering.
|
|
//
|
|
// This function is concurrent-safe.
|
|
//
|
|
// This value represents how many times rendering happens in 1/60 second and
|
|
// NOT how many times logical game updating (a passed function to Run) happens.
|
|
// Note that logical game updating is assured to happen 60 times in a second
|
|
// as long as the screen is active.
|
|
func CurrentFPS() float64 {
|
|
return loop.CurrentFPS()
|
|
}
|
|
|
|
// IsRunningSlowly returns true if the game is running too slowly to keep 60 FPS of rendering.
|
|
// The game screen is not updated when IsRunningSlowly is true.
|
|
// It is recommended to skip heavy processing, especially drawing, when IsRunningSlowly is true.
|
|
//
|
|
// This function is concurrent-safe.
|
|
func IsRunningSlowly() bool {
|
|
return loop.IsRunningSlowly()
|
|
}
|
|
|
|
// Run runs the game.
|
|
// f is a function which is called at every frame.
|
|
// The argument (*Image) is the render target that represents the screen.
|
|
//
|
|
// This function must be called from the main thread.
|
|
// Note that ebiten bounds the main goroutine to the main OS thread by runtime.LockOSThread.
|
|
//
|
|
// The given function f is guaranteed to be called 60 times a second
|
|
// even if a rendering frame is skipped.
|
|
// f is not called when the screen is not shown.
|
|
func Run(f func(*Image) error, width, height, scale int, title string) error {
|
|
ch := make(chan error)
|
|
go func() {
|
|
g := newGraphicsContext(f)
|
|
ch <- loop.Run(g, width, height, scale, title)
|
|
}()
|
|
loop.Main()
|
|
return <-ch
|
|
}
|
|
|
|
// SetScreenSize changes the (logical) size of the screen.
|
|
// This doesn't affect the current scale of the screen.
|
|
//
|
|
// This function is concurrent-safe.
|
|
func SetScreenSize(width, height int) {
|
|
if err := loop.SetScreenSize(width, height); err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
|
|
// SetScreenScale changes the scale of the screen.
|
|
//
|
|
// This function is concurrent-safe.
|
|
func SetScreenScale(scale int) {
|
|
if err := loop.SetScreenScale(scale); err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
|
|
// ScreenScale returns the current screen scale.
|
|
//
|
|
// This function is concurrent-safe.
|
|
func ScreenScale() int {
|
|
return loop.ScreenScale()
|
|
}
|