animation

type Animator ¶

type Animator interface {
	// Animate renders the frames into dst and calls
	// fn on each rendered frame.
	Animate(ctx context.Context, dst draw.Image, fn func(image.Image) error) error
	image.Image
}

Animator is an image that can animate frames.

type Cache ¶

type Cache struct {
	// contains filtered or unexported fields
}

Cache is an ardilla.RawFrame cache.

func NewCache(deck RawImager) *Cache

type GIF ¶

type GIF struct {
	*gif.GIF

	// Cache caches GIF frames in the internal format
	// of the device. Cache must not be changed while
	// an animation is running.
	Cache *Cache
	// contains filtered or unexported fields
}

GIF is an animated GIF.

The GIF image.Image implementation is conditional on whether an animation The image is either from the first or last frame; if an terminates the last frame is used, if it does not terminate the first is used. GIF animations that terminate should ensure that the final frame is a complete renderable image.

GIF pointer values must not be shared between goroutines. It is safe to share the backing gif.GIF and Cache values, so if a GIF is to be used concurrently, each goroutine should have a pointer to a copy of a parent concrete GIF value.

func (img *GIF) Animate(ctx context.Context, dst draw.Image, fn func(image.Image) error) error

func (img *GIF) At(x, y int) color.Color

func (img *GIF) Bounds() image.Rectangle

func (img *GIF) ColorModel() color.Model

type GIFs ¶

type GIFs []*GIF

GIFs is an animator that runs through a set of GIF animations in order. Each of the GIFs must have the same bounds and only the last GIF in the sequence may be non-terminating. As with the GIF type, if the final GIF in the sequence has completed, it's final frame is used as the complete image.Image, otherwise the first frame of the first GIF in the sequence is used.

func (img GIFs) Animate(ctx context.Context, dst draw.Image, fn func(image.Image) error) error

func (img GIFs) At(x, y int) color.Color

func (img GIFs) Bounds() image.Rectangle

func (img GIFs) ColorModel() color.Model

type Images ¶

type Images struct {
	// The successive images.
	Image []image.Image

	// Delay is the delay between images.
	Delay time.Duration

	// LoopCount controls the number of times an animation will be
	// restarted during display.
	// A LoopCount of 0 means to loop forever.
	// A LoopCount of -1 means to show each frame only once.
	// Otherwise, the animation is looped LoopCount+1 times.
	LoopCount int

	// Cache caches frames in the internal format
	// of the device. Cache must not be changed while
	// an animation is running.
	Cache *Cache
	// contains filtered or unexported fields
}

Images is an animator that animates through a set of images in order similar to the GIFs type. If an image in the set is an Animator, it is animated. No checks are made for non-terminating animations with the set.

func (img *Images) Animate(ctx context.Context, dst draw.Image, fn func(image.Image) error) error

func (img *Images) At(x, y int) color.Color

func (img *Images) Bounds() image.Rectangle

func (img *Images) ColorModel() color.Model

type RawImager ¶

type RawImager interface {
	RawImage(img image.Image) (*ardilla.RawImage, error)
}

RawImager wraps the RawImage method.

type ReadPeeker ¶

type ReadPeeker interface {
	io.Reader
	Peek(n int) ([]byte, error)
}

ReadPeeker is an io.Reader that can also peek n bytes ahead.

func AsReadPeeker(r io.Reader) ReadPeeker

type Text ¶

type Text string

Text is a scrolling text animator.

func (t Text) GIF(bound image.Rectangle, pal color.Palette, fg, bg byte) (*GIF, error)