doodle/pkg/level/giant_screenshot/giant_screenshot.go
Noah Petherbridge 4469847c72 Giant Screenshot Feature
In the Level Editor, the "Level->Giant Screenshot" menu will take a full
scale PNG screenshot of the entire level, with its wallpaper and
doodads, and save it in ~/.config/doodle/screenshots.

It is currently CPU intensive and slow. With future work it should be
made asynchronous. The function is abstracted away nicely so that the
doodad CLI tool may support this as well.
2021-10-03 17:21:17 -07:00

181 lines
4.9 KiB
Go

package giant_screenshot
import (
"image"
"image/draw"
"image/png"
"os"
"path/filepath"
"time"
"git.kirsle.net/apps/doodle/pkg/doodads"
"git.kirsle.net/apps/doodle/pkg/level"
"git.kirsle.net/apps/doodle/pkg/log"
"git.kirsle.net/apps/doodle/pkg/userdir"
"git.kirsle.net/apps/doodle/pkg/wallpaper"
"git.kirsle.net/go/render"
)
/*
Giant Screenshot functionality for the Level Editor.
*/
// GiantScreenshot returns a rendered RGBA image of the entire level.
func GiantScreenshot(lvl *level.Level) image.Image {
// How big will our image be?
var (
size = lvl.Chunker.WorldSizePositive()
chunkSize = lvl.Chunker.Size
chunkLow, chunkHigh = lvl.Chunker.Bounds()
worldSize = render.Rect{
X: chunkLow.X,
Y: chunkLow.Y,
W: chunkHigh.X,
H: chunkHigh.Y,
}
x int
y int
)
// Bounded levels: set the image output size precisely.
if lvl.PageType == level.Bounded || lvl.PageType == level.Bordered {
size = render.NewRect(int(lvl.MaxWidth), int(lvl.MaxHeight))
}
// Levels without negative space: set the lower chunk coord to 0,0
if lvl.PageType > level.Unbounded {
worldSize.X = 0
worldSize.Y = 0
}
// Create the image.
img := image.NewRGBA(image.Rect(0, 0, size.W, size.H))
// Render the wallpaper onto it.
log.Debug("GiantScreenshot: Render wallpaper to image (%s)...", size)
img = WallpaperToImage(lvl, img, size.W, size.H)
// Render the chunks.
log.Debug("GiantScreenshot: Render level chunks...")
for chunkX := worldSize.X; chunkX <= worldSize.W; chunkX++ {
y = 0
for chunkY := worldSize.Y; chunkY <= worldSize.H; chunkY++ {
if chunk, ok := lvl.Chunker.GetChunk(render.NewPoint(chunkX, chunkY)); ok {
// TODO: we always use RGBA but is risky:
rgba, ok := chunk.CachedBitmap(render.Invisible).(*image.RGBA)
if !ok {
log.Error("GiantScreenshot: couldn't turn chunk to RGBA")
}
img = blotImage(img, rgba, image.Pt(x, y))
}
y += chunkSize
}
x += chunkSize
}
// Render the doodads.
log.Debug("GiantScreenshot: Render actors...")
for _, actor := range lvl.Actors {
doodad, err := doodads.LoadFromEmbeddable(actor.Filename, lvl)
if err != nil {
log.Error("GiantScreenshot: Load doodad: %s", err)
continue
}
// Offset the doodad position if the image is displaying
// negative coordinates.
if worldSize.X < 0 {
actor.Point.X += render.AbsInt(worldSize.X) * chunkSize
}
if worldSize.Y < 0 {
actor.Point.Y += render.AbsInt(worldSize.Y) * chunkSize
}
// TODO: usually doodad sprites start at 0,0 and the chunkSize
// is the same as their sprite size.
if len(doodad.Layers) > 0 && doodad.Layers[0].Chunker != nil {
var chunker = doodad.Layers[0].Chunker
chunk, ok := chunker.GetChunk(render.Origin)
if !ok {
continue
}
// TODO: we always use RGBA but is risky:
rgba, ok := chunk.CachedBitmap(render.Invisible).(*image.RGBA)
if !ok {
log.Error("GiantScreenshot: couldn't turn chunk to RGBA")
}
img = blotImage(img, rgba, image.Pt(actor.Point.X, actor.Point.Y))
}
}
return img
}
// SaveGiantScreenshot will take a screenshot and write it to a file on disk,
// returning the filename relative to ~/.config/doodle/screenshots
func SaveGiantScreenshot(level *level.Level) (string, error) {
var filename = time.Now().Format("2006-01-02_15-04-05.png")
img := GiantScreenshot(level)
fh, err := os.Create(filepath.Join(userdir.ScreenshotDirectory, filename))
if err != nil {
return "", err
}
png.Encode(fh, img)
return filename, nil
}
// WallpaperToImage accurately draws the wallpaper into an Image.
//
// The image is assumed to have a rect of (0,0,width,height) and that
// width and height are positive. Used for the Giant Screenshot feature.
func WallpaperToImage(lvl *level.Level, target *image.RGBA, width, height int) *image.RGBA {
wp, err := wallpaper.FromFile("assets/wallpapers/"+lvl.Wallpaper, lvl)
if err != nil {
log.Error("GiantScreenshot: wallpaper load: %s", err)
}
var size = wp.QuarterRect()
var resultImage = target
// Tile the repeat texture.
for x := 0; x < width; x += size.W {
for y := 0; y < height; y += size.H {
offset := image.Pt(x, y)
resultImage = blotImage(resultImage, wp.Repeat(), offset)
}
}
// Tile the left edge for bounded lvls.
if lvl.PageType > level.Unbounded {
// The left edge.
for y := 0; y < height; y += size.H {
offset := image.Pt(0, y)
resultImage = blotImage(resultImage, wp.Left(), offset)
}
// The top edge.
for x := 0; x < width; x += size.W {
offset := image.Pt(x, 0)
resultImage = blotImage(resultImage, wp.Top(), offset)
}
// The top left corner.
resultImage = blotImage(resultImage, wp.Corner(), image.Point{})
}
return resultImage
}
func blotImage(target, source *image.RGBA, offset image.Point) *image.RGBA {
b := target.Bounds()
newImg := image.NewRGBA(b)
draw.Draw(newImg, b, target, image.Point{}, draw.Src)
draw.Draw(newImg, source.Bounds().Add(offset), source, image.Point{}, draw.Over)
return newImg
}