ebiten/examples/masking/main.go

172 lines
4.3 KiB
Go
Raw Normal View History

2016-02-29 18:09:54 +01:00
// Copyright 2016 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.
2021-06-24 14:49:37 +02:00
//go:build example
2020-10-06 17:45:54 +02:00
// +build example
2016-02-29 18:09:54 +01:00
package main
import (
"bytes"
2016-02-29 18:09:54 +01:00
"image"
"image/color"
_ "image/jpeg"
"log"
"math"
2020-10-03 19:35:13 +02:00
"github.com/hajimehoshi/ebiten/v2"
"github.com/hajimehoshi/ebiten/v2/examples/resources/images"
2016-02-29 18:09:54 +01:00
)
const (
screenWidth = 320
screenHeight = 240
)
var (
2018-01-28 17:59:46 +01:00
bgImage *ebiten.Image
fgImage *ebiten.Image
maskedFgImage = ebiten.NewImage(screenWidth, screenHeight)
2016-02-29 18:09:54 +01:00
spotLightImage *ebiten.Image
)
2018-01-28 17:59:46 +01:00
func init() {
// Decode an image from the image file's byte slice.
img, _, err := image.Decode(bytes.NewReader(images.Gophers_jpg))
2018-01-28 17:59:46 +01:00
if err != nil {
log.Fatal(err)
}
bgImage = ebiten.NewImageFromImage(img)
2018-01-28 17:59:46 +01:00
img, _, err = image.Decode(bytes.NewReader(images.FiveYears_jpg))
2018-01-28 17:59:46 +01:00
if err != nil {
log.Fatal(err)
}
fgImage = ebiten.NewImageFromImage(img)
2018-01-28 17:59:46 +01:00
// Initialize the spot light image.
const r = 64
alphas := image.Point{r * 2, r * 2}
a := image.NewAlpha(image.Rectangle{image.ZP, alphas})
for j := 0; j < alphas.Y; j++ {
for i := 0; i < alphas.X; i++ {
// d is the distance between (i, j) and the (circle) center.
d := math.Sqrt(float64((i-r)*(i-r) + (j-r)*(j-r)))
// Alphas around the center are 0 and values outside of the circle are 0xff.
b := uint8(max(0, min(0xff, int(3*d*0xff/r)-2*0xff)))
2018-01-28 17:59:46 +01:00
a.SetAlpha(i, j, color.Alpha{b})
}
}
spotLightImage = ebiten.NewImageFromImage(a)
2018-01-28 17:59:46 +01:00
}
2020-05-11 19:11:09 +02:00
type Game struct {
spotLightX int
spotLightY int
spotLightVX int
spotLightVY int
}
func NewGame() *Game {
return &Game{
spotLightX: 0,
spotLightY: 0,
spotLightVX: 1,
spotLightVY: 1,
}
}
func (g *Game) Update() error {
2020-05-11 19:11:09 +02:00
if g.spotLightVX == 0 {
g.spotLightVX = 1
}
if g.spotLightVY == 0 {
g.spotLightVY = 1
}
g.spotLightX += g.spotLightVX
g.spotLightY += g.spotLightVY
if g.spotLightX < 0 {
g.spotLightX = -g.spotLightX
g.spotLightVX = -g.spotLightVX
2016-02-29 18:09:54 +01:00
}
2020-05-11 19:11:09 +02:00
if g.spotLightY < 0 {
g.spotLightY = -g.spotLightY
g.spotLightVY = -g.spotLightVY
2016-02-29 18:09:54 +01:00
}
w, h := spotLightImage.Size()
maxX, maxY := screenWidth-w, screenHeight-h
2020-05-11 19:11:09 +02:00
if maxX < g.spotLightX {
g.spotLightX = -g.spotLightX + 2*maxX
g.spotLightVX = -g.spotLightVX
2016-02-29 18:09:54 +01:00
}
2020-05-11 19:11:09 +02:00
if maxY < g.spotLightY {
g.spotLightY = -g.spotLightY + 2*maxY
g.spotLightVY = -g.spotLightVY
2017-05-16 03:35:58 +02:00
}
2020-05-11 19:11:09 +02:00
return nil
}
2018-01-28 17:59:46 +01:00
2020-05-11 19:11:09 +02:00
func (g *Game) Draw(screen *ebiten.Image) {
// Reset the maskedFgImage.
maskedFgImage.Fill(color.White)
2016-02-29 18:09:54 +01:00
op := &ebiten.DrawImageOptions{}
op.Blend = ebiten.BlendCopy
2020-05-11 19:11:09 +02:00
op.GeoM.Translate(float64(g.spotLightX), float64(g.spotLightY))
2018-01-28 18:47:38 +01:00
maskedFgImage.DrawImage(spotLightImage, op)
2016-02-29 18:09:54 +01:00
// Use 'source-in' blend mode so that the source image (fgImage) is used but the alpha
// is determined by the destination image (maskedFgImage).
2018-01-28 17:59:46 +01:00
//
// The result image is the source image with the destination alpha. In maskedFgImage, alpha
// values in the hole is 0 and alpha values in other places are 0xff. As a result, the
// maskedFgImage draws the source image with a hole that shape is spotLightImage. Note that
// RGB values in the destination image are ignored.
2018-01-28 17:59:46 +01:00
//
// See also https://www.w3.org/TR/compositing-1/#porterduffcompositingoperators_srcin.
2016-02-29 18:09:54 +01:00
op = &ebiten.DrawImageOptions{}
op.Blend = ebiten.BlendSourceIn
2018-01-28 18:47:38 +01:00
maskedFgImage.DrawImage(fgImage, op)
2016-02-29 18:09:54 +01:00
screen.Fill(color.RGBA{0x00, 0x00, 0x80, 0xff})
2018-01-28 17:59:46 +01:00
screen.DrawImage(bgImage, &ebiten.DrawImageOptions{})
2018-01-28 18:47:38 +01:00
screen.DrawImage(maskedFgImage, &ebiten.DrawImageOptions{})
2020-05-11 19:11:09 +02:00
}
2016-02-29 18:09:54 +01:00
2020-05-11 19:11:09 +02:00
func (g *Game) Layout(outsideWidth, outsideHeight int) (int, int) {
return screenWidth, screenHeight
2016-02-29 18:09:54 +01:00
}
func max(a, b int) int {
if a < b {
return b
}
return a
}
func min(a, b int) int {
if a < b {
return a
}
return b
}
func main() {
2020-05-11 19:11:09 +02:00
ebiten.SetWindowSize(screenWidth*2, screenHeight*2)
ebiten.SetWindowTitle("Masking (Ebitengine Demo)")
2020-05-11 19:11:09 +02:00
if err := ebiten.RunGame(&Game{}); err != nil {
2016-02-29 18:09:54 +01:00
log.Fatal(err)
}
}