Documentation

Overview

    Package sprite provides a 2D scene graph for rendering and animation.

    A tree of nodes is drawn by a rendering Engine, provided by another package. The OS-independent Go version based on the image package is:

    golang.org/x/mobile/exp/sprite/portable
    

    An Engine draws a screen starting at a root Node. The tree is walked depth-first, with affine transformations applied at each level.

    Nodes are rendered relative to their parent.

    Typical main loop:

    for each frame {
    	quantize time.Now() to a clock.Time
    	process UI events
    	modify the scene's nodes and animations (Arranger values)
    	e.Render(scene, t, sz)
    }
    

    Index

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type Arranger

    type Arranger interface {
    	Arrange(e Engine, n *Node, t clock.Time)
    }

    type Engine

    type Engine interface {
    	Register(n *Node)
    	Unregister(n *Node)
    
    	LoadTexture(a image.Image) (Texture, error)
    
    	SetSubTex(n *Node, x SubTex)
    	SetTransform(n *Node, m f32.Affine) // sets transform relative to parent.
    
    	// Render renders the scene arranged at the given time, for the given
    	// window configuration (dimensions and resolution).
    	Render(scene *Node, t clock.Time, sz size.Event)
    
    	Release()
    }

    type Node

    type Node struct {
    	Parent, FirstChild, LastChild, PrevSibling, NextSibling *Node
    
    	Arranger Arranger
    
    	// EngineFields contains fields that should only be accessed by Engine
    	// implementations. It is exported because such implementations can be
    	// in other packages.
    	EngineFields struct {
    		// TODO: separate TexDirty and TransformDirty bits?
    		Dirty  bool
    		Index  int32
    		SubTex SubTex
    	}
    }

      A Node is a renderable element and forms a tree of Nodes.

      func (*Node) AppendChild

      func (n *Node) AppendChild(c *Node)

        AppendChild adds a node c as a child of n.

        It will panic if c already has a parent or siblings.

        func (*Node) RemoveChild

        func (n *Node) RemoveChild(c *Node)

          RemoveChild removes a node c that is a child of n. Afterwards, c will have no parent and no siblings.

          It will panic if c's parent is not n.

          type SubTex

          type SubTex struct {
          	T Texture
          	R image.Rectangle
          }

          type Texture

          type Texture interface {
          	Bounds() (w, h int)
          	Download(r image.Rectangle, dst draw.Image)
          	Upload(r image.Rectangle, src image.Image)
          	Release()
          }

          Source Files

          Directories

          Path Synopsis
          Package clock provides a clock and time functions for a sprite engine.
          Package clock provides a clock and time functions for a sprite engine.
          Package glsprite implements a sprite Engine using OpenGL ES 2.
          Package glsprite implements a sprite Engine using OpenGL ES 2.
          Package portable implements a sprite Engine using the image package.
          Package portable implements a sprite Engine using the image package.