How does window size downscale drawings?

[drum445]

Does drawing sprites to the screen at 2x the desired size then calling SetWindowSize with windowSize/2 produce the exact same image as simply drawing to the screen at the desired tile size?

I have used this approach to prevent blurry text when maximising the window, so I draw everything to my screen at 2x the size, then half the window width and height in SetWindowSize. So if the user does maximise the window, nothing will actually be stretched

Is that the recommended approach for ebiten to avoid blurry images/text when maximising the window or when running on high-dpi screens?

[hajimehoshi]

Have you looked at examples/highdpi? Probably this is what you want to know. This example implements Layout for hi-DPI environments not to blur renderings.

[drum445]

I've put this example together

package main

import (
	"fmt"
	"image/color"
	"log"

	"github.com/hajimehoshi/ebiten/examples/resources/fonts"
	"github.com/hajimehoshi/ebiten/v2"
	"github.com/hajimehoshi/ebiten/v2/text"
	"golang.org/x/image/font"
	"golang.org/x/image/font/opentype"
)

const (
	windowWidth  = 1920
	windowHeight = 1080
)

var (
	mplusSmallerFont font.Face
)

type Game struct{}

func (g *Game) Update() error {
	return nil
}

func (g *Game) Draw(screen *ebiten.Image) {
	screen.Fill(color.White)
	text.Draw(screen, "SOME EXAMPLE TEXT", mplusSmallerFont, 100, 100, color.Black)
}

func (g *Game) Layout(outsideWidth, outsideHeight int) (int, int) {
	return windowWidth, windowHeight
}

func main() {

	tt, _ := opentype.Parse(fonts.MPlus1pRegular_ttf)
	mplusSmallerFont, _ = opentype.NewFace(tt, &opentype.FaceOptions{
		Size:    80,
		DPI:     72,
		Hinting: font.HintingVertical,
	})

	ebiten.SetWindowSize(windowWidth/2, windowHeight/2)
	ebiten.SetWindowTitle("Example")
	ebiten.SetWindowResizingMode(ebiten.WindowResizingModeEnabled)
	ebiten.SetTPS(60)

	fmt.Println(windowWidth/2, windowHeight/2)
	if err := ebiten.RunGame(&Game{}); err != nil {
		log.Fatal(err)
	}
}

If you run that you'll see that the font is rendered nicely with no blurring even when increasing the resolution
This is because the font is actually being drawn at 80px, but as I half the window size it is scaled down to 40px which means it can go above 40 without stretching occurring. To see this more clearly change the following lines and you'll see what I mean:

windowWidth = 960
windowHeight = 540
Size: 40,
ebiten.SetWindowSize(windowWidth, windowHeight)

[hajimehoshi]

Isn't this the same as

const (
	windowWidth  = 960
	windowHeight = 540
)

func (g *Game) Layout(outsideWidth, outsideHeight int) (int, int) {
	return windowWidth*2, windowHeight*2
}

func main() {
	// ...
	ebiten.SetWindowSize(windowWidth, windowHeight)
	// ...
}

So this is exactly the same as what the highdpi example does, but your idea always uses x2 scaling. This might be overkill when a display is not hi-dpi (where ebiten.DeviceScaleFactor() < 2).

[drum445]

In theory yes, but I'd still have to draw the font twice as big right? Or more accurately *ebiten.DeviceScaleFactor()

[hajimehoshi]

but I'd still have to draw the font twice as big right? Or more accurately *ebiten.DeviceScaleFactor()

Yes.

[drum445]

Thanks for your replies, I'll give that a go and compare the differences between the two approaches.
It' a little more complex than my example, as I have many different entities drawing to the screen, so just trying to find the simplest option