mirror of
https://github.com/hajimehoshi/ebiten.git
synced 2025-02-03 22:44:28 +01:00
4fe5acd711
On Windows, the window could be maximized even when the window was not resizable. This behavior is confusing. Forbid it so that the behavior will be clearer.
431 lines
11 KiB
Go
431 lines
11 KiB
Go
// Copyright 2015 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.
|
|
|
|
// +build example jsgo
|
|
|
|
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"flag"
|
|
"fmt"
|
|
"image"
|
|
"image/color"
|
|
_ "image/jpeg"
|
|
"log"
|
|
"math"
|
|
"math/rand"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/hajimehoshi/ebiten"
|
|
"github.com/hajimehoshi/ebiten/ebitenutil"
|
|
"github.com/hajimehoshi/ebiten/examples/resources/images"
|
|
"github.com/hajimehoshi/ebiten/inpututil"
|
|
)
|
|
|
|
var (
|
|
// flagLegacy represents whether the legacy APIs are used or not.
|
|
// If flagLegacy is true, these legacy APIs are used:
|
|
//
|
|
// * ebiten.Run
|
|
// * ebiten.ScreenScale
|
|
// * ebiten.SetScreenScale
|
|
// * ebiten.SetScreenSize
|
|
//
|
|
// If flagLegacy is false, these APIs are used:
|
|
//
|
|
// * ebiten.RunGame
|
|
// * ebiten.SetWindowSize
|
|
// * ebiten.WindowSize
|
|
//
|
|
// A resizable window is available only when flagLegacy is false.
|
|
flagLegacy = flag.Bool("legacy", false, "use the legacy API")
|
|
|
|
flagFullscreen = flag.Bool("fullscreen", false, "fullscreen")
|
|
flagResizable = flag.Bool("resizable", false, "make the window resizable")
|
|
flagWindowPosition = flag.String("windowposition", "", "window position (e.g., 100,200)")
|
|
flagScreenTransparent = flag.Bool("screentransparent", false, "screen transparent")
|
|
flagAutoAdjusting = flag.Bool("autoadjusting", false, "make the game screen auto-adjusting")
|
|
flagFloating = flag.Bool("floating", false, "make the window floating")
|
|
flagMaximize = flag.Bool("maximize", false, "maximize the window")
|
|
)
|
|
|
|
func init() {
|
|
flag.Parse()
|
|
rand.Seed(time.Now().UnixNano())
|
|
}
|
|
|
|
const (
|
|
initScreenWidth = 480
|
|
initScreenHeight = 360
|
|
initScreenScale = 1
|
|
)
|
|
|
|
var (
|
|
gophersImage *ebiten.Image
|
|
count = 0
|
|
)
|
|
|
|
func createRandomIconImage() image.Image {
|
|
const size = 32
|
|
|
|
r := byte(rand.Intn(0x100))
|
|
g := byte(rand.Intn(0x100))
|
|
b := byte(rand.Intn(0x100))
|
|
img := image.NewNRGBA(image.Rect(0, 0, size, size))
|
|
for j := 0; j < size; j++ {
|
|
for i := 0; i < size; i++ {
|
|
img.Pix[j*img.Stride+4*i] = r
|
|
img.Pix[j*img.Stride+4*i+1] = g
|
|
img.Pix[j*img.Stride+4*i+2] = b
|
|
img.Pix[j*img.Stride+4*i+3] = byte(float64(i+j) / float64(2*size) * 0xff)
|
|
}
|
|
}
|
|
|
|
return img
|
|
}
|
|
|
|
type game struct {
|
|
width int
|
|
height int
|
|
transparent bool
|
|
}
|
|
|
|
func (g *game) Layout(outsideWidth, outsideHeight int) (int, int) {
|
|
if *flagAutoAdjusting {
|
|
g.width, g.height = outsideWidth, outsideHeight
|
|
return outsideWidth, outsideHeight
|
|
}
|
|
// Ignore the outside size. This means that the offscreen is not adjusted with the outside world.
|
|
return g.width, g.height
|
|
}
|
|
|
|
func (g *game) Update(screen *ebiten.Image) error {
|
|
var (
|
|
screenWidth int
|
|
screenHeight int
|
|
screenScale float64
|
|
)
|
|
if *flagLegacy {
|
|
screenWidth, screenHeight = screen.Size()
|
|
screenScale = ebiten.ScreenScale()
|
|
} else {
|
|
screenWidth = g.width
|
|
screenHeight = g.height
|
|
if ww, wh := ebiten.WindowSize(); ww > 0 && wh > 0 {
|
|
screenScale = math.Min(float64(ww)/float64(g.width), float64(wh)/float64(g.height))
|
|
} else {
|
|
// ebiten.WindowSize can return (0, 0) on browsers or mobiles.
|
|
screenScale = 1
|
|
}
|
|
}
|
|
|
|
fullscreen := ebiten.IsFullscreen()
|
|
runnableOnUnfocused := ebiten.IsRunnableOnUnfocused()
|
|
cursorVisible := ebiten.IsCursorVisible()
|
|
vsyncEnabled := ebiten.IsVsyncEnabled()
|
|
tps := ebiten.MaxTPS()
|
|
decorated := ebiten.IsWindowDecorated()
|
|
positionX, positionY := ebiten.WindowPosition()
|
|
g.transparent = ebiten.IsScreenTransparent()
|
|
floating := ebiten.IsWindowFloating()
|
|
resizable := ebiten.IsWindowResizable()
|
|
|
|
const d = 16
|
|
toUpdateWindowSize := false
|
|
if ebiten.IsKeyPressed(ebiten.KeyShift) {
|
|
if inpututil.IsKeyJustPressed(ebiten.KeyUp) {
|
|
screenHeight += d
|
|
toUpdateWindowSize = true
|
|
}
|
|
if inpututil.IsKeyJustPressed(ebiten.KeyDown) {
|
|
if 16 < screenHeight && d < screenHeight {
|
|
screenHeight -= d
|
|
toUpdateWindowSize = true
|
|
}
|
|
}
|
|
if inpututil.IsKeyJustPressed(ebiten.KeyLeft) {
|
|
if 16 < screenWidth && d < screenWidth {
|
|
screenWidth -= d
|
|
toUpdateWindowSize = true
|
|
}
|
|
}
|
|
if inpututil.IsKeyJustPressed(ebiten.KeyRight) {
|
|
screenWidth += d
|
|
toUpdateWindowSize = true
|
|
}
|
|
} else {
|
|
if inpututil.IsKeyJustPressed(ebiten.KeyUp) {
|
|
positionY -= d
|
|
}
|
|
if inpututil.IsKeyJustPressed(ebiten.KeyDown) {
|
|
positionY += d
|
|
}
|
|
if inpututil.IsKeyJustPressed(ebiten.KeyLeft) {
|
|
positionX -= d
|
|
}
|
|
if inpututil.IsKeyJustPressed(ebiten.KeyRight) {
|
|
positionX += d
|
|
}
|
|
}
|
|
if inpututil.IsKeyJustPressed(ebiten.KeyS) && !*flagAutoAdjusting {
|
|
switch {
|
|
case screenScale < 1:
|
|
screenScale = 1
|
|
case screenScale < 1.5:
|
|
screenScale = 1.5
|
|
case screenScale < 2:
|
|
screenScale = 2
|
|
default:
|
|
screenScale = 0.75
|
|
}
|
|
toUpdateWindowSize = true
|
|
}
|
|
if inpututil.IsKeyJustPressed(ebiten.KeyF) {
|
|
fullscreen = !fullscreen
|
|
}
|
|
if inpututil.IsKeyJustPressed(ebiten.KeyU) {
|
|
runnableOnUnfocused = !runnableOnUnfocused
|
|
}
|
|
if inpututil.IsKeyJustPressed(ebiten.KeyC) {
|
|
cursorVisible = !cursorVisible
|
|
}
|
|
if inpututil.IsKeyJustPressed(ebiten.KeyV) {
|
|
vsyncEnabled = !vsyncEnabled
|
|
}
|
|
if inpututil.IsKeyJustPressed(ebiten.KeyT) {
|
|
switch tps {
|
|
case ebiten.UncappedTPS:
|
|
tps = 30
|
|
case 30:
|
|
tps = 60
|
|
case 60:
|
|
tps = 120
|
|
case 120:
|
|
tps = ebiten.UncappedTPS
|
|
default:
|
|
panic("not reached")
|
|
}
|
|
}
|
|
if inpututil.IsKeyJustPressed(ebiten.KeyD) {
|
|
decorated = !decorated
|
|
}
|
|
if inpututil.IsKeyJustPressed(ebiten.KeyL) {
|
|
floating = !floating
|
|
}
|
|
if inpututil.IsKeyJustPressed(ebiten.KeyR) {
|
|
resizable = !resizable
|
|
}
|
|
maximize := inpututil.IsKeyJustPressed(ebiten.KeyM)
|
|
minimize := inpututil.IsKeyJustPressed(ebiten.KeyN)
|
|
restore := inpututil.IsKeyJustPressed(ebiten.KeyE)
|
|
|
|
if toUpdateWindowSize {
|
|
if *flagLegacy {
|
|
ebiten.SetScreenSize(screenWidth, screenHeight)
|
|
ebiten.SetScreenScale(screenScale)
|
|
} else {
|
|
g.width = screenWidth
|
|
g.height = screenHeight
|
|
ebiten.SetWindowSize(int(float64(screenWidth)*screenScale), int(float64(screenHeight)*screenScale))
|
|
}
|
|
}
|
|
ebiten.SetFullscreen(fullscreen)
|
|
ebiten.SetRunnableOnUnfocused(runnableOnUnfocused)
|
|
ebiten.SetCursorVisible(cursorVisible)
|
|
ebiten.SetVsyncEnabled(vsyncEnabled)
|
|
ebiten.SetMaxTPS(tps)
|
|
ebiten.SetWindowDecorated(decorated)
|
|
ebiten.SetWindowPosition(positionX, positionY)
|
|
ebiten.SetWindowFloating(floating)
|
|
if maximize && ebiten.IsWindowResizable() {
|
|
ebiten.MaximizeWindow()
|
|
}
|
|
if minimize {
|
|
ebiten.MinimizeWindow()
|
|
}
|
|
if restore {
|
|
ebiten.RestoreWindow()
|
|
}
|
|
if !*flagLegacy {
|
|
// A resizable window is available only with RunGame.
|
|
ebiten.SetWindowResizable(resizable)
|
|
}
|
|
|
|
if inpututil.IsKeyJustPressed(ebiten.KeyI) {
|
|
ebiten.SetWindowIcon([]image.Image{createRandomIconImage()})
|
|
}
|
|
|
|
count++
|
|
return nil
|
|
}
|
|
|
|
func (g *game) Draw(screen *ebiten.Image) {
|
|
if !g.transparent {
|
|
screen.Fill(color.RGBA{0x80, 0x80, 0xc0, 0xff})
|
|
}
|
|
w, h := gophersImage.Size()
|
|
w2, h2 := screen.Size()
|
|
op := &ebiten.DrawImageOptions{}
|
|
op.GeoM.Translate(float64(-w+w2)/2, float64(-h+h2)/2)
|
|
dx := math.Cos(2*math.Pi*float64(count)/360) * 10
|
|
dy := math.Sin(2*math.Pi*float64(count)/360) * 10
|
|
op.GeoM.Translate(dx, dy)
|
|
screen.DrawImage(gophersImage, op)
|
|
|
|
wx, wy := ebiten.WindowPosition()
|
|
cx, cy := ebiten.CursorPosition()
|
|
tpsStr := "Uncapped"
|
|
if t := ebiten.MaxTPS(); t != ebiten.UncappedTPS {
|
|
tpsStr = fmt.Sprintf("%d", t)
|
|
}
|
|
|
|
var lines []string
|
|
if !ebiten.IsWindowMaximized() && ebiten.IsWindowResizable() {
|
|
lines = append(lines, "[M] Maximize the window")
|
|
}
|
|
if !ebiten.IsWindowMinimized() {
|
|
lines = append(lines, "[N] Minimize the window")
|
|
}
|
|
if ebiten.IsWindowMaximized() || ebiten.IsWindowMinimized() {
|
|
lines = append(lines, "[E] Restore the window from maximized/minimized state")
|
|
}
|
|
msgM := strings.Join(lines, "\n")
|
|
|
|
var msgS string
|
|
var msgR string
|
|
if *flagLegacy {
|
|
msgS = "[S] Change the window scale (only for desktops)\n"
|
|
} else {
|
|
msgR = "[R] Switch the window resizable state (only for desktops)\n"
|
|
}
|
|
fg := "Yes"
|
|
if !ebiten.IsFocused() {
|
|
fg = "No"
|
|
}
|
|
|
|
msg := fmt.Sprintf(`[Arrow keys] Move the window
|
|
[Shift + Arrow keys] Change the window size
|
|
%s[F] Switch the fullscreen state (only for desktops)
|
|
[U] Switch the runnable-on-unfocused state
|
|
[C] Switch the cursor visibility
|
|
[I] Change the window icon (only for desktops)
|
|
[V] Switch vsync
|
|
[T] Switch TPS (ticks per second)
|
|
[D] Switch the window decoration (only for desktops)
|
|
[L] Switch the window floating state (only for desktops)
|
|
%s
|
|
%s
|
|
IsFocused?: %s
|
|
Windows Position: (%d, %d)
|
|
Cursor: (%d, %d)
|
|
TPS: Current: %0.2f / Max: %s
|
|
FPS: %0.2f
|
|
Device Scale Factor: %0.2f`, msgS, msgM, msgR, fg, wx, wy, cx, cy, ebiten.CurrentTPS(), tpsStr, ebiten.CurrentFPS(), ebiten.DeviceScaleFactor())
|
|
ebitenutil.DebugPrint(screen, msg)
|
|
}
|
|
|
|
func parseWindowPosition() (int, int, bool) {
|
|
if *flagWindowPosition == "" {
|
|
return 0, 0, false
|
|
}
|
|
tokens := strings.Split(*flagWindowPosition, ",")
|
|
if len(tokens) != 2 {
|
|
return 0, 0, false
|
|
}
|
|
x, err := strconv.Atoi(tokens[0])
|
|
if err != nil {
|
|
return 0, 0, false
|
|
}
|
|
y, err := strconv.Atoi(tokens[1])
|
|
if err != nil {
|
|
return 0, 0, false
|
|
}
|
|
return x, y, true
|
|
}
|
|
|
|
func main() {
|
|
fmt.Printf("Device scale factor: %0.2f\n", ebiten.DeviceScaleFactor())
|
|
w, h := ebiten.ScreenSizeInFullscreen()
|
|
fmt.Printf("Screen size in fullscreen: %d, %d\n", w, h)
|
|
|
|
if !*flagLegacy {
|
|
fmt.Println("Tip: With -autoadjusting flag, you can make an adjustable game screen.")
|
|
}
|
|
|
|
// Decode image from a byte slice instead of a file so that
|
|
// this example works in any working directory.
|
|
// If you want to use a file, there are some options:
|
|
// 1) Use os.Open and pass the file to the image decoder.
|
|
// This is a very regular way, but doesn't work on browsers.
|
|
// 2) Use ebitenutil.OpenFile and pass the file to the image decoder.
|
|
// This works even on browsers.
|
|
// 3) Use ebitenutil.NewImageFromFile to create an ebiten.Image directly from a file.
|
|
// This also works on browsers.
|
|
img, _, err := image.Decode(bytes.NewReader(images.Gophers_jpg))
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
gophersImage, _ = ebiten.NewImageFromImage(img, ebiten.FilterDefault)
|
|
|
|
ebiten.SetWindowIcon([]image.Image{createRandomIconImage()})
|
|
|
|
if x, y, ok := parseWindowPosition(); ok {
|
|
ebiten.SetWindowPosition(x, y)
|
|
}
|
|
ebiten.SetScreenTransparent(*flagScreenTransparent)
|
|
|
|
g := &game{
|
|
width: initScreenWidth,
|
|
height: initScreenHeight,
|
|
}
|
|
|
|
if *flagFullscreen {
|
|
ebiten.SetFullscreen(true)
|
|
}
|
|
if *flagResizable {
|
|
ebiten.SetWindowResizable(true)
|
|
}
|
|
if *flagFloating {
|
|
ebiten.SetWindowFloating(true)
|
|
}
|
|
if *flagMaximize {
|
|
ebiten.SetWindowResizable(true)
|
|
ebiten.MaximizeWindow()
|
|
}
|
|
if *flagAutoAdjusting {
|
|
if *flagLegacy {
|
|
log.Println("-autoadjusting flag cannot work with -legacy flag")
|
|
}
|
|
ebiten.SetWindowResizable(true)
|
|
}
|
|
|
|
const title = "Window Size (Ebiten Demo)"
|
|
if *flagLegacy {
|
|
if err := ebiten.Run(g.Update, g.width, g.height, initScreenScale, title); err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
} else {
|
|
w := int(float64(g.width) * initScreenScale)
|
|
h := int(float64(g.height) * initScreenScale)
|
|
ebiten.SetWindowSize(w, h)
|
|
ebiten.SetWindowTitle(title)
|
|
if err := ebiten.RunGame(g); err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
}
|
|
}
|