add blend modes example (#2563)

examples/blend/main.go

@@ -0,0 +1,217 @@
+// Copyright 2023 The Ebitengine Authors
+//
+// 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"
+	"fmt"
+	"image"
+	"image/color"
+	_ "image/png"
+	"log"
+
+	"golang.org/x/image/font/inconsolata"
+
+	"github.com/hajimehoshi/ebiten/v2"
+	"github.com/hajimehoshi/ebiten/v2/examples/resources/images/blend"
+	"github.com/hajimehoshi/ebiten/v2/text"
+)
+
+const (
+	screenWidth  = 780
+	screenHeight = 600
+)
+
+// mode is a blend mode with description.
+type mode struct {
+	blend ebiten.Blend
+	name  string
+}
+
+// Game is a canvas for drawing blend mode tiles.
+type Game struct {
+	source    *ebiten.Image
+	dest      *ebiten.Image
+	offscreen *ebiten.Image
+	tileSize  int
+	modes     []mode
+}
+
+func NewGame() (*Game, error) {
+	source, err := loadImage(blend.Source_png)
+	if err != nil {
+		return nil, fmt.Errorf("fail to load source: %w", err)
+	}
+	dest, err := loadImage(blend.Dest_png)
+	if err != nil {
+		return nil, fmt.Errorf("fail to load dest: %w", err)
+	}
+
+	// Setting up a grid for drawing.
+	g := &Game{
+		source: source,
+		dest:   dest,
+	}
+
+	// Adding all known blend modes and their names.
+	g.modes = []mode{
+		{blend: ebiten.BlendCopy, name: "BlendCopy"},
+		{blend: ebiten.BlendSourceAtop, name: "BlendSourceAtop"},
+		{blend: ebiten.BlendSourceOver, name: "BlendSourceOver"},
+		{blend: ebiten.BlendSourceIn, name: "BlendSourceIn"},
+		{blend: ebiten.BlendSourceOut, name: "BlendSourceOut"},
+		{blend: ebiten.BlendDestination, name: "BlendDestination"},
+		{blend: ebiten.BlendDestinationAtop, name: "BlendDestinationAtop"},
+		{blend: ebiten.BlendDestinationOver, name: "BlendDestinationOver"},
+		{blend: ebiten.BlendDestinationIn, name: "BlendDestinationIn"},
+		{blend: ebiten.BlendDestinationOut, name: "BlendDestinationOut"},
+		{blend: ebiten.BlendXor, name: "BlendXor"},
+		{blend: ebiten.BlendLighter, name: "BlendLighter"},
+		{blend: ebiten.BlendClear, name: "BlendClear"},
+	}
+
+	// Adjusting the tile size for the available images.
+	g.tileSize = maxSide(g.source, g.dest)
+	g.offscreen = ebiten.NewImage(int(g.tileSize), int(g.tileSize))
+
+	return g, nil
+}
+
+func (g *Game) Update() error {
+	return nil
+}
+
+func (g *Game) Draw(screen *ebiten.Image) {
+	const (
+		tileSpacing = 64
+		textSpacing = 16
+		gridW       = 4
+		gridH       = 3
+	)
+
+	// Clearing the screen.
+	screen.Fill(color.White)
+
+	// Get an offset for center alignment.
+	// Where sw, sh is the screen size in pixels.
+	// And gw, gh is the grid size in pixels.
+	totalTileSize := g.tileSize + tileSpacing
+	gw, gh := gridW*totalTileSize-tileSpacing, gridH*totalTileSize
+	sw, sh := screen.Bounds().Dx(), screen.Bounds().Dy()
+	cx, cy := float64(sw-gw)/2, float64(sh-gh)/2
+
+	// Drawing a tilemap
+	for y := 0; y < gridH; y++ {
+		for x := 0; x < gridW; x++ {
+			px, py := x*totalTileSize, y*totalTileSize
+			if y > 0 {
+				// Making a place for the text.
+				py += textSpacing * y
+			}
+
+			// Getting the right mode for the coords or skipping the rendering.
+			m, ok := getMode(g.modes, x, y, gridW, gridH)
+			if !ok {
+				continue
+			}
+
+			// Drawing the blend mode and it's name.
+			tileSize := float64(g.tileSize)
+			alignedX, alignedY := float64(px)+cx, float64(py)+cy
+			halfTileSize, spacing := tileSize/2, float64(textSpacing)
+			g.drawBlendMode(screen, alignedX, alignedY, m.blend)
+			drawCenteredText(screen, alignedX+halfTileSize, alignedY+tileSize+spacing, m.name)
+		}
+	}
+}
+
+func (g *Game) Layout(w, h int) (int, int) {
+	return w, h
+}
+
+func (g *Game) drawBlendMode(screen *ebiten.Image, x, y float64, mode ebiten.Blend) {
+	// Copy the destination image to offscreen so as not to modify it.
+	g.offscreen.Clear()
+	g.offscreen.DrawImage(g.dest, nil)
+
+	// Select and apply blending mode.
+	op := &ebiten.DrawImageOptions{}
+	op.Blend = mode
+	g.offscreen.DrawImage(g.source, op)
+
+	// Draw the result on the passed coordinates.
+	op = &ebiten.DrawImageOptions{}
+	op.GeoM.Translate(x, y)
+	screen.DrawImage(g.offscreen, op)
+}
+
+// loadImage is a util function for loading embedded images.
+func loadImage(data []byte) (*ebiten.Image, error) {
+	m, _, err := image.Decode(bytes.NewReader(data))
+	if err != nil {
+		return nil, fmt.Errorf("failed to decode image: %w", err)
+	}
+	return ebiten.NewImageFromImage(m), nil
+}
+
+// max returns the largest of x or y.
+func max(x, y int) int {
+	if x > y {
+		return x
+	}
+	return y
+}
+
+// maxSide returns the largest side of a or b images.
+func maxSide(a, b *ebiten.Image) int {
+	return max(
+		max(a.Bounds().Dx(), b.Bounds().Dx()),
+		max(a.Bounds().Dy(), b.Bounds().Dy()),
+	)
+}
+
+// getMode returns a blend mode by index and found status.
+func getMode(modes []mode, x, y, w, h int) (m mode, ok bool) {
+	idx := y*w + x
+	if idx > len(modes)-1 {
+		return mode{}, false
+	}
+	if x < 0 || x > w || y < 0 || y > h {
+		return mode{}, false
+	}
+	return modes[idx], true
+}
+
+// drawCenteredText is a util function for drawing blend mode description.
+func drawCenteredText(screen *ebiten.Image, cx, cy float64, s string) {
+	bounds := text.BoundString(inconsolata.Bold8x16, s)
+	x, y := int(cx)-bounds.Min.X-bounds.Dx()/2, int(cy)-bounds.Min.Y-bounds.Dy()/2
+	text.Draw(screen, s, inconsolata.Bold8x16, x, y, color.Black)
+}
+
+func main() {
+	ebiten.SetWindowSize(screenWidth, screenHeight)
+	ebiten.SetWindowResizingMode(ebiten.WindowResizingModeEnabled)
+	ebiten.SetWindowTitle("Blend modes (Ebitengine Demo)")
+
+	game, err := NewGame()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	if err = ebiten.RunGame(game); err != nil {
+		log.Fatal(err)
+	}
+}

examples/resources/images/blend/embed.go

@@ -0,0 +1,27 @@
+// Copyright 2023 The Ebitengine Authors
+//
+// 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 blend
+
+import (
+	_ "embed"
+)
+
+var (
+	//go:embed source.png
+	Source_png []byte
+
+	//go:embed dest.png
+	Dest_png []byte
+)

examples/resources/images/license.md

@@ -86,6 +86,22 @@ https://fonts.google.com/icons
 Apache License 2.0
 ```
 
+## blend/dest.png
+
+```
+https://fontlibrary.org/en/font/seshat-regular
+
+CC0 1.0
+```
+
+## blend/source.png
+
+```
+https://github.com/sedyh
+
+CC0 1.0
+```
+
 ## flappy/gopher.png
 
 ```