ZacharyZhang-NY
8be66c09f2
Palette cycling, sky, sun and moon, clouds, starfield, rain, snow, petals, leaves, fireflies, waterfall, ocean, campfire, lava, aurora, lightning, mountains and a season scene; scanlines, vignette, screen shake, flash, dither fades, iris wipes, dissolves, mosaics, glitches, sparkles, explosions and confetti. Home opens on a live scene in the palette's season and a strip of all eight palettes. pixel adds Canvas.Cycled, Sprite.At, SpriteOf, Kit.Toward and Kit.Shot, which spends a cue under Reduce Motion so it never replays; display exports Reduce. Gallery grids and the sidebar are one Tab stop each.
97 lines
2.7 KiB
Go
97 lines
2.7 KiB
Go
package display
|
||
|
||
import (
|
||
"image"
|
||
|
||
"github.com/egoist/mygo/ui"
|
||
|
||
"git.zacharyzhang.com/ZacharyZhang-NY/8bitMyGoUI/pixel"
|
||
)
|
||
|
||
type PictureOptions struct {
|
||
// W×H is the size in dots; zero takes the image's.
|
||
W, H int
|
||
Label string
|
||
}
|
||
|
||
type pictureKey struct{}
|
||
|
||
type pictureCache struct {
|
||
sum uint64
|
||
pal *pixel.Palette
|
||
w, h int
|
||
sp *pixel.Sprite
|
||
}
|
||
|
||
// Picture reduces img to the palette with Bayer dither.
|
||
func Picture(c *ui.Context, img image.Image, o PictureOptions) *ui.Element {
|
||
k := pixel.K(c)
|
||
b := img.Bounds()
|
||
w, h := pixel.Or("Picture W", o.W, b.Dx()), pixel.Or("Picture H", o.H, b.Dy())
|
||
e := art(c, k, o.Label, w, h, nil)
|
||
pc := ui.Local(e, pictureKey{}, func() pictureCache { return pictureCache{} })
|
||
if sum := fingerprint(img); pc.sp == nil || pc.sum != sum || pc.pal != k.Palette() || pc.w != w || pc.h != h {
|
||
*pc = pictureCache{sum, k.Palette(), w, h, Reduce(img, w, h, k.Palette())}
|
||
}
|
||
sp := pc.sp
|
||
return e.Draw(func(p *ui.Painter, r ui.Rect) {
|
||
k.Canvas(p, r).Sprite(0, 0, sp, 0, pixel.Ink, 1)
|
||
})
|
||
}
|
||
|
||
// Reduce maps img onto pal as a dithered w×h sprite.
|
||
func Reduce(img image.Image, w, h int, pal *pixel.Palette) *pixel.Sprite {
|
||
b := img.Bounds()
|
||
return pixel.SpriteOf(w, h, func(x, y int) (pixel.Slot, bool) {
|
||
y0, y1 := span(b.Min.Y, b.Dy(), y, h)
|
||
x0, x1 := span(b.Min.X, b.Dx(), x, w)
|
||
var sum [4]uint32
|
||
n := uint32(0)
|
||
for sy := y0; sy < y1; sy++ {
|
||
for sx := x0; sx < x1; sx++ {
|
||
r, g, bl, a := img.At(sx, sy).RGBA()
|
||
sum[0], sum[1], sum[2], sum[3] = sum[0]+r>>8, sum[1]+g>>8, sum[2]+bl>>8, sum[3]+a>>8
|
||
n++
|
||
}
|
||
}
|
||
if sum[3]/n < 128 {
|
||
return 0, false
|
||
}
|
||
nudge := (float64(pixel.Bayer(x, y))+0.5)/16 - 0.5
|
||
return nearest(pal, [3]float64{
|
||
float64(sum[0]/n) + nudge*48, float64(sum[1]/n) + nudge*48, float64(sum[2]/n) + nudge*48,
|
||
}), true
|
||
})
|
||
}
|
||
|
||
// fingerprint mixes img's bounds and pixels, to notice edits.
|
||
func fingerprint(img image.Image) uint64 {
|
||
b := img.Bounds()
|
||
s := uint64(b.Min.X)<<48 ^ uint64(b.Min.Y)<<32 ^ uint64(b.Dx())<<16 ^ uint64(b.Dy())
|
||
for y := b.Min.Y; y < b.Max.Y; y++ {
|
||
for x := b.Min.X; x < b.Max.X; x++ {
|
||
r, g, bl, a := img.At(x, y).RGBA()
|
||
s = (s ^ uint64(r>>8)<<24 ^ uint64(g>>8)<<16 ^ uint64(bl>>8)<<8 ^ uint64(a>>8)) * 1099511628211
|
||
}
|
||
}
|
||
return s
|
||
}
|
||
|
||
// span is the source range under cell i of n.
|
||
func span(min, size, i, n int) (int, int) {
|
||
a, b := min+i*size/n, min+(i+1)*size/n
|
||
return a, max(b, a+1)
|
||
}
|
||
|
||
// nearest is the slot closest to rgb.
|
||
func nearest(pal *pixel.Palette, rgb [3]float64) pixel.Slot {
|
||
best, dist := pixel.Ink, -1.0
|
||
for s, c := range pal.Colors {
|
||
dr, dg, db := rgb[0]-float64(c.R), rgb[1]-float64(c.G), rgb[2]-float64(c.B)
|
||
if d := dr*dr + dg*dg + db*db; dist < 0 || d < dist {
|
||
best, dist = pixel.Slot(s), d
|
||
}
|
||
}
|
||
return best
|
||
}
|