doodle/pkg/level/giant_screenshot/giant_screenshot.go

package giant_screenshot

import (
	"errors"
	"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/shmem"
	"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.
*/

var locked bool

// GiantScreenshot returns a rendered RGBA image of the entire level.
//
// Only one thread should be doing this at a time. A sync.Mutex will cause
// an error to return if another goroutine is already in the process of
// generating a screenshot, and you'll have to wait and try later.
func GiantScreenshot(lvl *level.Level) (image.Image, error) {
	// Lock this to one user at a time.
	if locked {
		return nil, errors.New("a giant screenshot is still being processed; try later...")
	}
	locked = true
	defer func() {
		locked = false
	}()

	shmem.Flash("Saving a giant screenshot (this takes a moment)...")

	// 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.
		drawAt := render.NewPoint(actor.Point.X, actor.Point.Y)
		if worldSize.X < 0 {
			var offset = render.AbsInt(worldSize.X) * chunkSize
			drawAt.X += offset
		}
		if worldSize.Y < 0 {
			var offset = render.AbsInt(worldSize.Y) * chunkSize
			drawAt.Y += offset
		}

		// 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(drawAt.X, drawAt.Y))
		}

	}

	return img, nil
}

// 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, err := GiantScreenshot(level)
	if err != nil {
		return "", err
	}

	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
}