mirror of
https://github.com/hajimehoshi/ebiten.git
synced 2025-10-04 23:53:10 +08:00
564 lines
16 KiB
Go
564 lines
16 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.
|
|
|
|
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"flag"
|
|
"fmt"
|
|
"image"
|
|
_ "image/jpeg"
|
|
"log"
|
|
"math"
|
|
"math/rand/v2"
|
|
"regexp"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/ebitengine/debugui"
|
|
|
|
"github.com/hajimehoshi/ebiten/v2"
|
|
"github.com/hajimehoshi/ebiten/v2/examples/resources/images"
|
|
"github.com/hajimehoshi/ebiten/v2/inpututil"
|
|
)
|
|
|
|
var (
|
|
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)")
|
|
flagTransparent = flag.Bool("transparent", false, "screen transparent")
|
|
flagFloating = flag.Bool("floating", false, "make the window floating")
|
|
flagPassthrough = flag.Bool("passthrough", false, "make the window mouse passthrough")
|
|
flagMaximize = flag.Bool("maximize", false, "maximize the window")
|
|
flagVsync = flag.Bool("vsync", true, "enable vsync")
|
|
flagInitFocused = flag.Bool("initfocused", true, "whether the window is focused on start")
|
|
flagMinWindowSize = flag.String("minwindowsize", "", "minimum window size (e.g., 100x200)")
|
|
flagMaxWindowSize = flag.String("maxwindowsize", "", "maximum window size (e.g., 1920x1080)")
|
|
flagGraphicsLibrary = flag.String("graphicslibrary", "", "graphics library (e.g. opengl)")
|
|
flagRunnableOnUnfocused = flag.Bool("runnableonunfocused", true, "whether the app is runnable even on unfocused")
|
|
flagColorSpace = flag.String("colorspace", "", "color space ('', 'srgb', or 'display-p3')")
|
|
)
|
|
|
|
func init() {
|
|
flag.Parse()
|
|
}
|
|
|
|
const (
|
|
initScreenWidth = 640
|
|
initScreenHeight = 640
|
|
initScreenScale = 1
|
|
)
|
|
|
|
var (
|
|
gophersImage *ebiten.Image
|
|
)
|
|
|
|
func createRandomIconImage() image.Image {
|
|
const size = 32
|
|
|
|
rf := float64(rand.IntN(0x100))
|
|
gf := float64(rand.IntN(0x100))
|
|
bf := float64(rand.IntN(0x100))
|
|
img := ebiten.NewImage(size, size)
|
|
pix := make([]byte, 4*size*size)
|
|
for j := 0; j < size; j++ {
|
|
for i := 0; i < size; i++ {
|
|
af := float64(i+j) / float64(2*size)
|
|
if af > 0 {
|
|
pix[4*(j*size+i)] = byte(rf * af)
|
|
pix[4*(j*size+i)+1] = byte(gf * af)
|
|
pix[4*(j*size+i)+2] = byte(bf * af)
|
|
pix[4*(j*size+i)+3] = byte(af * 0xff)
|
|
}
|
|
}
|
|
}
|
|
img.WritePixels(pix)
|
|
|
|
return img
|
|
}
|
|
|
|
type game struct {
|
|
debugUI debugui.DebugUI
|
|
|
|
count int
|
|
screenWidth float64
|
|
screenHeight float64
|
|
positionX int
|
|
positionY int
|
|
|
|
autoRestore bool
|
|
autoAdjustment bool
|
|
tps int
|
|
}
|
|
|
|
func (g *game) Layout(outsideWidth, outsideHeight int) (int, int) {
|
|
// As game implements the interface LayoutFer, Layout is never called and LayoutF is called instead.
|
|
// However, game has to implement Layout to satisfy the interface Game.
|
|
panic("windowsize: Layout must not be called")
|
|
}
|
|
|
|
func (g *game) LayoutF(outsideWidth, outsideHeight float64) (float64, float64) {
|
|
if g.autoAdjustment {
|
|
g.screenWidth, g.screenHeight = outsideWidth, outsideHeight
|
|
return outsideWidth, outsideHeight
|
|
}
|
|
// Ignore the outside size. This means that the offscreen is not adjusted with the outside world.
|
|
return g.screenWidth, g.screenHeight
|
|
}
|
|
|
|
func windowResigingModeString(m ebiten.WindowResizingModeType) string {
|
|
switch m {
|
|
case ebiten.WindowResizingModeDisabled:
|
|
return "Disabled"
|
|
case ebiten.WindowResizingModeOnlyFullscreenEnabled:
|
|
return "Fullscreen Only"
|
|
case ebiten.WindowResizingModeEnabled:
|
|
return "Enabled"
|
|
default:
|
|
panic("not reached")
|
|
}
|
|
}
|
|
|
|
func cursorModeString(m ebiten.CursorModeType) string {
|
|
switch m {
|
|
case ebiten.CursorModeVisible:
|
|
return "Visible"
|
|
case ebiten.CursorModeHidden:
|
|
return "Hidden"
|
|
case ebiten.CursorModeCaptured:
|
|
return "Captured"
|
|
default:
|
|
panic("not reached")
|
|
}
|
|
}
|
|
|
|
func (g *game) Update() error {
|
|
g.tps = ebiten.TPS()
|
|
g.positionX, g.positionY = ebiten.WindowPosition()
|
|
|
|
// ebiten.WindowSize can return (0, 0) on browsers or mobiles.
|
|
screenScale := 1.0
|
|
if ww, wh := ebiten.WindowSize(); ww > 0 && wh > 0 {
|
|
screenScale = math.Min(float64(ww)/g.screenWidth, float64(wh)/g.screenHeight)
|
|
}
|
|
|
|
// Call SetWindowSize and SetWindowPosition only when necessary.
|
|
// When a window is maximized, SetWindowSize and SetWindowPosition should not be called.
|
|
// Otherwise, the restored window size and position are not correct.
|
|
var (
|
|
toUpdateWindowSize bool
|
|
toUpdateWindowPosition bool
|
|
)
|
|
|
|
if _, err := g.debugUI.Update(func(ctx *debugui.Context) error {
|
|
ctx.Window("Window Size", image.Rect(10, 10, 330, 490), func(layout debugui.ContainerLayout) {
|
|
ctx.Header("Instructions", false, func() {
|
|
ctx.SetGridLayout([]int{-1, -1}, nil)
|
|
ctx.Text("[Arrow keys]")
|
|
ctx.Text("Move the window")
|
|
ctx.Text("[Shift + Arrow keys]")
|
|
ctx.Text("Change the window size")
|
|
ctx.Text("[E]")
|
|
ctx.Text("Restore the window (only when the window is maximized or minimized)")
|
|
})
|
|
ctx.Header("Settings (Window, Desktop Only)", true, func() {
|
|
ctx.SetGridLayout([]int{-2, -1}, nil)
|
|
|
|
ctx.Text("Resizing Mode")
|
|
resizingMode := ebiten.WindowResizingMode()
|
|
ctx.Button(windowResigingModeString(resizingMode)).On(func() {
|
|
switch resizingMode {
|
|
case ebiten.WindowResizingModeDisabled:
|
|
ebiten.SetWindowResizingMode(ebiten.WindowResizingModeOnlyFullscreenEnabled)
|
|
case ebiten.WindowResizingModeOnlyFullscreenEnabled:
|
|
ebiten.SetWindowResizingMode(ebiten.WindowResizingModeEnabled)
|
|
case ebiten.WindowResizingModeEnabled:
|
|
ebiten.SetWindowResizingMode(ebiten.WindowResizingModeDisabled)
|
|
default:
|
|
panic("not reached")
|
|
}
|
|
})
|
|
|
|
if ebiten.WindowResizingMode() == ebiten.WindowResizingModeEnabled {
|
|
ctx.Text("Maxmize")
|
|
ctx.Button("Maximize").On(func() {
|
|
ebiten.MaximizeWindow()
|
|
})
|
|
}
|
|
ctx.Text("Minimize")
|
|
ctx.Button("Minimize").On(func() {
|
|
ebiten.MinimizeWindow()
|
|
})
|
|
ctx.Text("Auto Restore")
|
|
ctx.Checkbox(&g.autoRestore, "")
|
|
if !g.autoAdjustment {
|
|
ctx.Text("Screen Scale")
|
|
ctx.Button(fmt.Sprintf("%0.2f", screenScale)).On(func() {
|
|
switch {
|
|
case screenScale < 1:
|
|
screenScale = 1
|
|
case screenScale < 1.5:
|
|
screenScale = 1.5
|
|
case screenScale < 2:
|
|
screenScale = 2
|
|
default:
|
|
screenScale = 0.75
|
|
}
|
|
toUpdateWindowSize = true
|
|
})
|
|
}
|
|
|
|
ctx.Text("Decorated")
|
|
decorated := ebiten.IsWindowDecorated()
|
|
ctx.Checkbox(&decorated, "").On(func() {
|
|
ebiten.SetWindowDecorated(decorated)
|
|
})
|
|
ctx.Text("Floating")
|
|
floating := ebiten.IsWindowFloating()
|
|
ctx.Checkbox(&floating, "").On(func() {
|
|
ebiten.SetWindowFloating(floating)
|
|
})
|
|
|
|
ctx.Text("Update Icon")
|
|
ctx.Button("Update").On(func() {
|
|
ebiten.SetWindowIcon([]image.Image{createRandomIconImage()})
|
|
})
|
|
ctx.Text("Reset Icon")
|
|
ctx.Button("Reset").On(func() {
|
|
ebiten.SetWindowIcon(nil)
|
|
})
|
|
})
|
|
ctx.Header("Settings (Rendering)", true, func() {
|
|
ctx.SetGridLayout([]int{-2, -1}, nil)
|
|
|
|
ctx.Text("Auto Size Adjustment")
|
|
ctx.Checkbox(&g.autoAdjustment, "")
|
|
ctx.Text("Fullscreen")
|
|
fullscreen := ebiten.IsFullscreen()
|
|
ctx.Checkbox(&fullscreen, "").On(func() {
|
|
ebiten.SetFullscreen(fullscreen)
|
|
})
|
|
ctx.Text("Runnable on Unfocused")
|
|
runnableOnUnfocused := ebiten.IsRunnableOnUnfocused()
|
|
ctx.Checkbox(&runnableOnUnfocused, "").On(func() {
|
|
ebiten.SetRunnableOnUnfocused(runnableOnUnfocused)
|
|
})
|
|
ctx.Text("Vsync")
|
|
vsyncEnabled := ebiten.IsVsyncEnabled()
|
|
ctx.Checkbox(&vsyncEnabled, "").On(func() {
|
|
ebiten.SetVsyncEnabled(vsyncEnabled)
|
|
})
|
|
ctx.Text("TPS Mode")
|
|
tpsStr := "Sync w/ FPS"
|
|
if t := ebiten.TPS(); t != ebiten.SyncWithFPS {
|
|
tpsStr = fmt.Sprintf("%d", t)
|
|
}
|
|
ctx.Button(tpsStr).On(func() {
|
|
switch g.tps {
|
|
case ebiten.SyncWithFPS:
|
|
g.tps = 30
|
|
case 30:
|
|
g.tps = 60
|
|
case 60:
|
|
g.tps = 120
|
|
case 120:
|
|
g.tps = ebiten.SyncWithFPS
|
|
default:
|
|
panic("not reached")
|
|
}
|
|
})
|
|
ctx.Text("Clear Screen Every Frame")
|
|
screenCleared := ebiten.IsScreenClearedEveryFrame()
|
|
ctx.Checkbox(&screenCleared, "").On(func() {
|
|
ebiten.SetScreenClearedEveryFrame(screenCleared)
|
|
})
|
|
})
|
|
ctx.Header("Settings (Mouse Cursor)", true, func() {
|
|
ctx.SetGridLayout([]int{-2, -1}, nil)
|
|
|
|
ctx.Text("Mode [C]")
|
|
cursorMode := ebiten.CursorMode()
|
|
updateCursorMode := func() {
|
|
switch cursorMode {
|
|
case ebiten.CursorModeVisible:
|
|
ebiten.SetCursorMode(ebiten.CursorModeHidden)
|
|
case ebiten.CursorModeHidden:
|
|
ebiten.SetCursorMode(ebiten.CursorModeCaptured)
|
|
case ebiten.CursorModeCaptured:
|
|
ebiten.SetCursorMode(ebiten.CursorModeVisible)
|
|
}
|
|
}
|
|
ctx.Button(cursorModeString(cursorMode)).On(updateCursorMode)
|
|
if inpututil.IsKeyJustPressed(ebiten.KeyC) {
|
|
updateCursorMode()
|
|
}
|
|
|
|
ctx.Text("Passthrough (desktop only) [P]")
|
|
mousePassthrough := ebiten.IsWindowMousePassthrough()
|
|
updateMousePassthrough := func() {
|
|
ebiten.SetWindowMousePassthrough(mousePassthrough)
|
|
}
|
|
ctx.Checkbox(&mousePassthrough, "").On(updateMousePassthrough)
|
|
if inpututil.IsKeyJustPressed(ebiten.KeyP) {
|
|
mousePassthrough = !mousePassthrough
|
|
updateMousePassthrough()
|
|
}
|
|
})
|
|
ctx.Header("Info", true, func() {
|
|
ctx.SetGridLayout([]int{-2, -1}, nil)
|
|
|
|
ctx.Text("Window Position")
|
|
wx, wy := ebiten.WindowPosition()
|
|
ctx.Text(fmt.Sprintf("(%d, %d)", wx, wy))
|
|
|
|
ctx.Text("Window Size")
|
|
ww, wh := ebiten.WindowSize()
|
|
ctx.Text(fmt.Sprintf("(%d, %d)", ww, wh))
|
|
|
|
minw, minh, maxw, maxh := ebiten.WindowSizeLimits()
|
|
ctx.Text("Minimum Window Size")
|
|
ctx.Text(fmt.Sprintf("(%d, %d)", minw, minh))
|
|
ctx.Text("Maximum Window Size")
|
|
ctx.Text(fmt.Sprintf("(%d, %d)", maxw, maxh))
|
|
|
|
ctx.Text("Cursor")
|
|
cx, cy := ebiten.CursorPosition()
|
|
ctx.Text(fmt.Sprintf("(%d, %d)", cx, cy))
|
|
|
|
ctx.Text("Device Scale Factor")
|
|
ctx.Text(fmt.Sprintf("%0.2f", ebiten.Monitor().DeviceScaleFactor()))
|
|
|
|
w, h := ebiten.Monitor().Size()
|
|
ctx.Text("Screen Size in Fullscreen")
|
|
ctx.Text(fmt.Sprintf("(%d, %d)", w, h))
|
|
|
|
ctx.Text("Focused?")
|
|
ctx.Text(fmt.Sprintf("%t", ebiten.IsFocused()))
|
|
|
|
ctx.Text("TPS")
|
|
ctx.Text(fmt.Sprintf("%0.2f", ebiten.ActualTPS()))
|
|
|
|
ctx.Text("FPS")
|
|
ctx.Text(fmt.Sprintf("%0.2f", ebiten.ActualFPS()))
|
|
})
|
|
ctx.Header("Info (Debug)", true, func() {
|
|
ctx.SetGridLayout([]int{-2, -1}, nil)
|
|
|
|
var debug ebiten.DebugInfo
|
|
ebiten.ReadDebugInfo(&debug)
|
|
|
|
ctx.Text("Graphics Lib")
|
|
ctx.Text(debug.GraphicsLibrary.String())
|
|
|
|
ctx.Text("GPU Memory Usage")
|
|
ctx.Text(fmt.Sprintf("%d", debug.TotalGPUImageMemoryUsageInBytes))
|
|
})
|
|
})
|
|
return nil
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
|
|
const d = 16
|
|
if ebiten.IsKeyPressed(ebiten.KeyShift) {
|
|
if inpututil.IsKeyJustPressed(ebiten.KeyArrowDown) {
|
|
g.screenHeight += d
|
|
toUpdateWindowSize = true
|
|
}
|
|
if inpututil.IsKeyJustPressed(ebiten.KeyArrowUp) {
|
|
if 16 < g.screenHeight && d < g.screenHeight {
|
|
g.screenHeight -= d
|
|
toUpdateWindowSize = true
|
|
}
|
|
}
|
|
if inpututil.IsKeyJustPressed(ebiten.KeyArrowLeft) {
|
|
if 16 < g.screenWidth && d < g.screenWidth {
|
|
g.screenWidth -= d
|
|
toUpdateWindowSize = true
|
|
}
|
|
}
|
|
if inpututil.IsKeyJustPressed(ebiten.KeyArrowRight) {
|
|
g.screenWidth += d
|
|
toUpdateWindowSize = true
|
|
}
|
|
} else {
|
|
if inpututil.IsKeyJustPressed(ebiten.KeyArrowUp) {
|
|
g.positionY -= d
|
|
toUpdateWindowPosition = true
|
|
}
|
|
if inpututil.IsKeyJustPressed(ebiten.KeyArrowDown) {
|
|
g.positionY += d
|
|
toUpdateWindowPosition = true
|
|
}
|
|
if inpututil.IsKeyJustPressed(ebiten.KeyArrowLeft) {
|
|
g.positionX -= d
|
|
toUpdateWindowPosition = true
|
|
}
|
|
if inpututil.IsKeyJustPressed(ebiten.KeyArrowRight) {
|
|
g.positionX += d
|
|
toUpdateWindowPosition = true
|
|
}
|
|
}
|
|
|
|
var restore bool
|
|
if ebiten.IsWindowMaximized() || ebiten.IsWindowMinimized() {
|
|
if g.autoRestore {
|
|
restore = g.count%ebiten.TPS() == 0
|
|
} else {
|
|
restore = inpututil.IsKeyJustPressed(ebiten.KeyE)
|
|
}
|
|
}
|
|
|
|
if toUpdateWindowSize {
|
|
ebiten.SetWindowSize(int(g.screenWidth*screenScale), int(g.screenHeight*screenScale))
|
|
}
|
|
|
|
ebiten.SetTPS(g.tps)
|
|
if toUpdateWindowPosition {
|
|
ebiten.SetWindowPosition(g.positionX, g.positionY)
|
|
}
|
|
if restore {
|
|
ebiten.RestoreWindow()
|
|
}
|
|
|
|
g.count++
|
|
return nil
|
|
}
|
|
|
|
func (g *game) Draw(screen *ebiten.Image) {
|
|
w, h := gophersImage.Bounds().Dx(), gophersImage.Bounds().Dy()
|
|
w2, h2 := screen.Bounds().Dx(), screen.Bounds().Dy()
|
|
op := &ebiten.DrawImageOptions{}
|
|
op.GeoM.Translate(float64(-w+w2)/2, float64(-h+h2)/2)
|
|
dx := math.Cos(2*math.Pi*float64(g.count)/360) * 20
|
|
dy := math.Sin(2*math.Pi*float64(g.count)/360) * 20
|
|
op.GeoM.Translate(dx, dy)
|
|
screen.DrawImage(gophersImage, op)
|
|
|
|
g.debugUI.Draw(screen)
|
|
}
|
|
|
|
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() {
|
|
// Decode an image from the image file's byte slice.
|
|
img, _, err := image.Decode(bytes.NewReader(images.Gophers_jpg))
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
gophersImage = ebiten.NewImageFromImage(img)
|
|
|
|
ebiten.SetWindowIcon([]image.Image{createRandomIconImage()})
|
|
|
|
if x, y, ok := parseWindowPosition(); ok {
|
|
ebiten.SetWindowPosition(x, y)
|
|
}
|
|
|
|
g := &game{
|
|
screenWidth: initScreenWidth,
|
|
screenHeight: initScreenHeight,
|
|
}
|
|
|
|
if *flagFullscreen {
|
|
ebiten.SetFullscreen(true)
|
|
}
|
|
if *flagResizable {
|
|
ebiten.SetWindowResizingMode(ebiten.WindowResizingModeEnabled)
|
|
}
|
|
if *flagFloating {
|
|
ebiten.SetWindowFloating(true)
|
|
}
|
|
if *flagPassthrough {
|
|
ebiten.SetWindowMousePassthrough(true)
|
|
}
|
|
if *flagMaximize {
|
|
ebiten.SetWindowResizingMode(ebiten.WindowResizingModeEnabled)
|
|
ebiten.MaximizeWindow()
|
|
}
|
|
if !*flagVsync {
|
|
ebiten.SetVsyncEnabled(false)
|
|
}
|
|
if !*flagRunnableOnUnfocused {
|
|
ebiten.SetRunnableOnUnfocused(false)
|
|
}
|
|
|
|
minw, minh, maxw, maxh := -1, -1, -1, -1
|
|
reSize := regexp.MustCompile(`^(\d+)x(\d+)$`)
|
|
if m := reSize.FindStringSubmatch(*flagMinWindowSize); m != nil {
|
|
minw, _ = strconv.Atoi(m[1])
|
|
minh, _ = strconv.Atoi(m[2])
|
|
}
|
|
if m := reSize.FindStringSubmatch(*flagMaxWindowSize); m != nil {
|
|
maxw, _ = strconv.Atoi(m[1])
|
|
maxh, _ = strconv.Atoi(m[2])
|
|
}
|
|
if minw >= 0 || minh >= 0 || maxw >= 0 || maxh >= 0 {
|
|
ebiten.SetWindowSizeLimits(minw, minh, maxw, maxh)
|
|
ebiten.SetWindowResizingMode(ebiten.WindowResizingModeEnabled)
|
|
}
|
|
|
|
op := &ebiten.RunGameOptions{}
|
|
switch *flagGraphicsLibrary {
|
|
case "":
|
|
op.GraphicsLibrary = ebiten.GraphicsLibraryAuto
|
|
case "opengl":
|
|
op.GraphicsLibrary = ebiten.GraphicsLibraryOpenGL
|
|
case "directx":
|
|
op.GraphicsLibrary = ebiten.GraphicsLibraryDirectX
|
|
case "metal":
|
|
op.GraphicsLibrary = ebiten.GraphicsLibraryMetal
|
|
default:
|
|
log.Fatalf("unexpected graphics library: %s", *flagGraphicsLibrary)
|
|
}
|
|
switch *flagColorSpace {
|
|
case "":
|
|
op.ColorSpace = ebiten.ColorSpaceDefault
|
|
case "srgb":
|
|
op.ColorSpace = ebiten.ColorSpaceSRGB
|
|
case "display-p3":
|
|
op.ColorSpace = ebiten.ColorSpaceDisplayP3
|
|
}
|
|
op.InitUnfocused = !*flagInitFocused
|
|
op.ScreenTransparent = *flagTransparent
|
|
op.X11ClassName = "Window-Size"
|
|
op.X11InstanceName = "window-size"
|
|
|
|
const title = "Window Size (Ebitengine Demo)"
|
|
ww := int(float64(g.screenWidth) * initScreenScale)
|
|
wh := int(float64(g.screenHeight) * initScreenScale)
|
|
ebiten.SetWindowSize(ww, wh)
|
|
ebiten.SetWindowTitle(title)
|
|
if err := ebiten.RunGameWithOptions(g, op); err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
}
|