render package - github.com/oakmound/oak/v4/render

render package - github.com/oakmound/oak/v4/render - Go Packages

Package render provides structures for organizing graphics to draw to a window and essential graphical primitives.

Draw

var (
	
	HorizontalProgress = func(x, y, w, h int) float64 {
		return float64(x) / float64(w)
	}
	
	VerticalProgress = func(x, y, w, h int) float64 {
		return float64(y) / float64(h)
	}
	
	CircularProgress = func(x, y, w, h int) float64 {
		xRadius := float64(w) / 2
		yRadius := float64(h) / 2
		dX := math.Abs(float64(x) - xRadius)
		dY := math.Abs(float64(y) - yRadius)
		progress := math.Pow(dX/xRadius, 2) + math.Pow(dY/yRadius, 2)
		if progress > 1 {
			progress = 1
		}
		return progress
	}
)

Progress functions

DefaultCache is the receiver for package level sprites, sheets, and font loading operations.

BatchLoad loads subdirectories from the given base folder and imports all files, using alias rules to automatically determine the size of sprites and sheets in subfolders.

BlankBatchLoad acts like BatchLoad, but will not load and instead return a blank image of the appropriate dimensions for anything above maxFileSize.

DrawCircle draws a circle on the input rgba, of color c.

DrawCurve draws a curve inward on the input rgba, of color c.

DrawGradientLine acts like DrawThickLine but also applies a gradient to the line

DrawImage performs a draw operation at -x, -y, because shiny/screen represents quadrant 4 as negative in both axes. draw.Over will merge two pixels at a given position based on their alpha channel.

DrawLine draws a line onto an image rgba from one point to another

func DrawLineColored(rgba *image.RGBA, x1, y1, x2, y2, thickness int, colorer Colorer)

DrawLineColored acts like DrawThickLine, but takes in a custom colorer function for how it draws its line.

DrawThickLine acts like DrawlineOnto, but takes in thickness of the given line

FontColor returns an image.Image color matching the SVG 1.1 spec. If the string does not align to a color in the spec, it will error.

GetFont calls GetFont on the Default Cache.

GradientColorAt returns a new color via a gradient between two colors and the progress between them

LoadFont calls LoadFont on the Default Cache.

OverwriteImage is equivalent to ShinyDraw, but uses draw.Src draw.Src will overwrite pixels beneath the given image regardless of the new image's alpha.

RegisterCfgDecoder acts like RegisterDecoder for CfgDecoders

RegisterDecoder adds a decoder to the set of image decoders for file loading. If the extension string is already set, the existing decoder will not be overwritten.

func SetDrawStack(stackLayers ...Stackable)

SetDrawStack takes in a set of Stackables which act as the Drawstack available and resets how calls to Draw will act. If this is called mid scene, all elements on the existing draw stack will be lost.

Tween takes two images and returns a set of images tweening between the two over some number of frames

Cache is a simple image data cache

NewCache returns an empty Cache

Clear will remove elements matching the given key from the Cache.

func (c *Cache) ClearAll()

ClearAll will remove all elements from a Cache

GetFont returns a cached font, or an error if the font is not cached.

GetSheet tries to find the given file in the set of loaded sheets. If SheetIsLoaded(filename) is not true, this returns an error. Otherwise it will return the sheet as a 2d array of sprites

GetSprite tries to find the given file in a private set of loaded sprites. If that file isn't cached, it will return an error.

LoadFont loads the given font file, parses it, and caches it under its full path and its final path element.

LoadSheet loads a file in some directory with sheets of (w,h) sized sprites. This will blow away any cached sheet with the same fileName.

LoadSprite will load the given file as an image by combining directory and fileName. The resulting image, if found, will be cached under its last path element for later access through GetSprite.

type CanPause interface {
	Pause()
	Unpause()
}

CanPause types have pause functions to start and stop animation

CfgDecoder is an equivalent to Decoder that just exports the color model and dimensions of the image.

ColorBoxR is a renderable color box. It is a smaller structure and should render faster than a ColorBoxM.

NewColorBoxR creates a color box. Colorboxes made without using this constructor may not function.

Draw renders this colorbox to screen.

GetDims returns the dimensiosn of this colorbox

A Colorer takes some notion of linear progress and returns a color

IdentityColorer returns the same color it was given at initialization, regardless of progress.

type CompositeM struct {
	LayeredPoint
	
}

CompositeM Types display all of their parts at the same time, and respect the positions of their parts as relative to the position of the composite itself

func NewCompositeM(sl ...Modifiable) *CompositeM

NewCompositeM creates a CompositeM

AddOffset offsets all renderables in the CompositeM by a vector

func (cs *CompositeM) Append(r Modifiable)

Append adds a renderable as is to the CompositeM

AppendOffset adds a new offset modifiable to the CompositeM

func (cs *CompositeM) Copy() Modifiable

Copy makes a new CompositeM with the same renderables

Draw draws the CompositeM with some offset from its logical position (and therefore sub renderables logical positions).

Filter filters each component part of this CompositeM by all of the inputs.

Get returns a renderable at the given index within the CompositeM

GetRGBA always returns nil from Composites

func (cs *CompositeM) Len() int

Len returns the number of renderables in this CompositeM.

Modify applies mods to the CompositeM

func (cs *CompositeM) Prepend(r Modifiable)

Prepend adds a new renderable to the front of the CompositeMR.

func (cs *CompositeM) SetIndex(i int, r Modifiable)

SetIndex places a renderable at a certain point in the CompositeMs renderable slice

SetOffsets applies the initial offsets to the entire CompositeM

func (cs *CompositeM) Slice(start, end int) *CompositeM

Slice creates a new CompositeM as a subslice of the existing CompositeM. No Modifiables will be copied, and the original will not be modified.

func (cs *CompositeM) ToSprite() *Sprite

ToSprite converts the composite into a sprite by drawing each layer in order and overwriting lower layered pixels

func (cs *CompositeM) Undraw()

Undraw stops the CompositeM from being drawn

type CompositeR struct {
	LayeredPoint
	
}

A CompositeR is equivalent to a CompositeM for Renderables instead of Modifiables. CompositeRs also implements Stackable.

func NewCompositeR(sl ...Renderable) *CompositeR

NewCompositeR creates a new CompositeR from a slice of renderables

func (cs *CompositeR) Add(r Renderable, _ ...int) Renderable

Add stages a renderable to be added to the Composite at the next PreDraw

AddOffset adds an offset to a given renderable of the slice

func (cs *CompositeR) Append(r Renderable)

Append adds a new renderable to the end of the CompositeR.

AppendOffset adds a new renderable to CompositeR with an offset

func (cs *CompositeR) Clear()

Clear resets a composite to be empty.

func (cs *CompositeR) Copy() Stackable

Copy returns a new composite with the same length slice of renderables but no actual renderables... CompositeRs cannot have their internal elements copied, as renderables cannot be copied.

Draw Draws the CompositeR with an offset from its logical location.

DrawToScreen draws the elements in this composite to the given screen image.

Get returns renderable from a given index in CompositeR

GetRGBA always returns nil from Composites

func (cs *CompositeR) Len() int

Len returns the number of renderables in this composite.

func (cs *CompositeR) PreDraw()

PreDraw updates the CompositeR with the new renderables to add. This helps keep consistency and mitigates the threat of unsafe operations.

func (cs *CompositeR) Prepend(r Renderable)

Prepend adds a new renderable to the front of the CompositeR.

func (cs *CompositeR) Replace(old, new Renderable, i int)

Replace updates a renderable in the CompositeR to the new Renderable

func (cs *CompositeR) SetIndex(i int, r Renderable)

SetIndex places a renderable at a certain point in the composites renderable slice

SetOffsets sets all renderables in CompositeR to the passed in Vector positions positions

func (cs *CompositeR) ToSprite() *Sprite

ToSprite converts the composite into a sprite by drawing each layer in order and overwriting lower layered pixels

func (cs *CompositeR) Undraw()

Undraw undraws the CompositeR and its consituent renderables

Decoder functions convert arbitrary readers to images. The input of a decoder in oak's loader will generally be an image file.

type DrawFPS struct {
	*Text

	Smoothing float64
	
}

DrawFPS is a Renderable that will display how fast it is rendered. If it is a part of a dynamically ordered stackable, like a Heap, how fast it will be rendered can change in each iteration of the stackable's draw. For this reason, its recommended to isolate a DrawFPS to its own stack layer or layer within a heap.

NewDrawFPS returns a DrawFPS, which will render a counter of how fast it is being drawn. If font is not provided, DefaultFont is used. If smoothing is 0, a reasonable default will be used.

Draw renders a DrawFPS to a buffer.

type DrawStack struct {
	
}

The DrawStack is a stack with a safe adding mechanism that creates isolation between draw steps via predraw

func NewDrawStack(stack ...Stackable) *DrawStack

NewDrawStack creates a DrawStack with the given stackable items, drawn in descending index order.

func (ds *DrawStack) Clear()

Clear clears all stackables in a draw stack. This should revert the stack to contain no renderable components.

func (ds *DrawStack) Copy() *DrawStack

Copy creates a new deep copy of a Drawstack

Draw adds the given renderable to the draw stack at the appropriate position based on the input layers. See render.Draw.

DrawToScreen on a stack will render its contents to the input buffer, for a screen of w,h dimensions, from a view point of view.

func (ds *DrawStack) Pop()

Pop pops an element from the stack at the next PreDraw call.

func (ds *DrawStack) PreDraw()

PreDraw performs whatever processes need to occur before this can be drawn. In the case of the stack, it enacts previous Push and Pop calls, and signals to elements on the stack to also prepare to be drawn.

func (ds *DrawStack) Push(a Stackable)

Push appends a Stackable to the draw stack during the next PreDraw.

A Font can create text renderables. It should be constructed from FontGenerator.Generate().

DefaultFont returns a font built from DefFontGenerator.

func (f *Font) Copy() *Font

Copy returns a copy of this font

Height returns the height or size of the font

MeasureString calculates the width of a rendered text this font would draw from the given input string.

NewIntText wraps the given int pointer in a stringer interface

NewStrPtrText creates a renderable text component with a body matching and updating to match the content behind the provided string pointer

NewStringerText creates a renderable text component that will draw the string provided by the given stringer each frame.

NewText creates a renderable text component with the given string body

func (f *Font) RegenerateWith(fgFunc func(FontGenerator) FontGenerator) (*Font, error)

RegenerateWith creates a new font based on this font after changing its generation settings.

A FontGenerator stores information that can be used to create a font

Generate generates a font. File or RawFile and Color must be provided. If Cache and File are provided, the generated font will be stored in the provided cache. If Cache is not provided, it will default to DefaultCache.

func (fg FontGenerator) RegenerateWith(fgFunc func(FontGenerator) FontGenerator) (*Font, error)

RegenerateWith creates a new font off of this generator after changing its generation settings.

FontOptions are optional options used in font generation.

type InterruptBool struct {
	Interruptable bool
}

InterruptBool is a composable struct for NonInterruptable support

func (ib InterruptBool) IsInterruptable() bool

IsInterruptable returns whether this can be interrupted.

A Layer object has a draw layer

func (ld *Layer) GetLayer() int

GetLayer returns the layer of an object if it has one or else returns that the object needs to be undrawn

func (ld *Layer) SetLayer(l int)

SetLayer sets an object's layer

func (ld *Layer) Undraw()

Undraw sets that a Layer object should be undrawn

type Layered interface {
	GetLayer() int
	SetLayer(l int)
	Undraw()
}

Layered types know the order they should be drawn in relative to other layered types. Higher layers are drawn after lower layers, and so will appear on top of them. Drawn layers are anticipated to be all positive.

Basic Implementing struct: Layer

A LayeredPoint is an object with a position Vector and a layer

NewLayeredPoint creates a new LayeredPoint at a given location and layer

func (ldp *LayeredPoint) Copy() LayeredPoint

Copy deep copies the LayeredPoint

GetDims returns the dimensions of this object. As a single point, LayeredPoint returns (1,1).

func (ldp *LayeredPoint) GetLayer() int

GetLayer returns the layer of this point. If this is nil, it will return Undraw

SetPos sets the LayeredPoint's position to the given x, y

ShiftX moves the LayeredPoint by the given x

ShiftY moves the LayeredPoint by the given y

LogicFPS is a Stackable that will draw the logical fps onto the screen when a part of the draw stack.

NewLogicFPS returns a LogicFPS, which will render a counter of how fast it receives event.Enter events. If font is not provided, DefaultFont is used. If smoothing is 0, a reasonable default is used.

A Modifiable is a Renderable that has functions to change its underlying image.

func EmptyRenderable() Modifiable

EmptyRenderable returns a minimal, 1-width and height pseudo-nil Renderable

type NonInterruptable interface {
	IsInterruptable() bool
}

NonInterruptable types are not always interruptable. If something is not NonInterruptable, it is equivalent to having IsInterruptable always return true.

The intended use of the Interruptable datatypes is entirely external-- oak does not use them internally. The use case is for an entity that has a set of potential animations, and attempts to switch from one animation to another. The Interuptable boolean should represent whether that animation should be able to be switched out of before it ends.

Because this use case is minor, this is a candidate for removal from render and moving into an auxiliary package.

Unless otherwise noted, all NonInterruptable types are interruptable when they are initialized and need to be switched (if the type supports it) to be non interruptable.

type NonStatic interface {
	IsStatic() bool
}

NonStatic types are not always static. If something is not NonStatic, it is equivalent to having IsStatic always return true.

type NoopStackable struct{}

NoopStackable is a Stackable element where all methods are no-ops. Use for tests to disable rendering.

Add on a NoopStackable does nothing. The input Renderable is still returned.

func (ns NoopStackable) Clear()

Clear on a NoopStackable does nothing.

func (ns NoopStackable) Copy() Stackable

Copy on a NoopStackable returns itself.

DrawToScreen on a NoopStackable does nothing.

func (ns NoopStackable) PreDraw()

PreDraw on a NoopStackable does nothing.

Replace on a NoopStackable does nothing.

A Polygon is a renderable that is represented by a set of in order points on a plane.

NewPointsPolygon is a helper function for `NewPolygon(floatgeom.NewPolygon2(p1, p2, p3, pn...))`

NewPolygon constructs a renderable polygon. It will display nothing until Fill or FillInverse is called on it.

Fill fills the inside of this polygon with the input color

FillInverse colors this polygon's exterior the given color

func (pg *Polygon) GetColoredOutline(colorer Colorer, thickness int) *CompositeM

GetColoredOutline returns a set of lines of the given color along this polygon's outline

GetGradientOutline returns a set of lines of the given color along this polygon's outline, at the given thickness, ranging from c1 to c2 in color

GetOutline returns a set of lines of the given color along this polygon's outline

GetThickOutline returns a set of lines of the given color along this polygon's outline, at the given thickness

Positional types have 2D positions on a screen and can be manipulated to be in a certain position on that screen.

Basic Implementing struct: physics.Vector

A Renderable is anything which can be drawn at a given draw layer, undrawn, and set in a particular position.

Basic Implementing struct: Sprite

Draw adds the given renderable to the global draw stack.

If the draw stack has only one stackable, the item will be added to that stackable with the input layers as its argument. Otherwise, the item will be added to the layers[0]th stackable, with remaining layers supplied to the stackable as arguments.

If zero layers are provided, it will add to the zeroth stack layer and give nothing to the stackable's argument.

// We haven't modified the draw stack, so it contains a single draw heap.
// Draw a Color Box
Draw(NewColorBox(10, 10, color.RGBA{255, 255, 255, 255}), 3)
// Draw a Gradient Box above that color box
Draw(NewHorizontalGradientBox(5, 5, color.RGBA{255, 0, 0, 255}, color.RGBA{0, 255, 0, 255}), 4)

DrawColor is equivalent to LoadSpriteAndDraw, but with colorboxes.

DrawPoint draws a color on the screen as a single-widthed pixel (box)

type RenderableHeap struct {
	
}

A RenderableHeap manages a set of renderables to be drawn in explicit layered order, using an internal heap to manage that order. It implements Stackable.

func NewDynamicHeap() *RenderableHeap

NewDynamicHeap creates a renderable heap for drawing renderables by layer where the position of the viewport is taken into account to produce the drawn location of the renderable.

Example: If drawing a Sprite at (100,100) with the viewport at (50,0), the sprite will appear at (50, 100).

func NewStaticHeap() *RenderableHeap

NewStaticHeap creates a renderable heap for drawing renderables by layer where the position of renderable is absolute with regards to the viewport.

Example: If drawing a Sprite at (100,100) with the viewport at (50,0), the sprite will appear at (100, 100).

func (rh *RenderableHeap) Add(r Renderable, layers ...int) Renderable

Add stages a new Renderable to add to the heap

func (rh *RenderableHeap) Clear()

Clear empties out the heap.

func (rh *RenderableHeap) Copy() Stackable

Copy on a renderableHeap does not include any of its elements, as renderables cannot be copied.

DrawToScreen draws all elements in the heap to the screen.

func (rh *RenderableHeap) PreDraw()

PreDraw parses through renderables to be pushed and adds them to the drawheap.

func (rh *RenderableHeap) Replace(old, new Renderable, layer int)

Replace adds a Renderable and removes an old one

type Reverting struct {
	Modifiable
	
}

The Reverting structure lets modifications be made to a Modifiable and then reverted, up to arbitrary history limits.

func NewReverting(m Modifiable) *Reverting

NewReverting returns a Reverting type wrapped around the given modifiable

func (rv *Reverting) Copy() Modifiable

Copy returns a copy of this Reverting

Filter alters this reverting by the given filters, appending the new modified renderable to it's list of modified versions and displaying it.

Get calls Get on the active renderable below this Reverting. If nothing has a Get method, it returns the empty string.

func (rv *Reverting) IsInterruptable() bool

IsInterruptable returns if whatever this reverting is currently dispalying is interruptable.

func (rv *Reverting) IsStatic() bool

IsStatic returns if whatever this reverting is currently displaying is static.

Modify alters this reverting by the given modifications, appending the new modified renderable to it's list of modified versions and displaying it.

func (rv *Reverting) Pause()

Pause ceases animating any renderable types that animate underneath this

func (rv *Reverting) Revert(n int)

Revert goes back n steps in this Reverting's history and displays that Modifiable

func (rv *Reverting) RevertAll()

RevertAll resets this reverting to its original Modifiable

func (*Reverting) RevertAndFilter ¶

RevertAndFilter acts as RevertAndModify, but with Filters.

func (*Reverting) RevertAndModify ¶

RevertAndModify reverts n steps and then modifies this reverting. This is a separate function from Revert followed by Modify to prevent skipped draw frames.

Set calls Set on underlying types below this Reverting that can be Set Todo: if Set becomes used by more types, this should use an interface like CanPause

SetTriggerID sets the ID AnimationEnd will trigger on for animating subtypes.

func (rv *Reverting) Unpause()

Unpause resumes animating any renderable types that animate underneath this

A Sequence is a series of modifiables drawn as an animation. It is more primitive than animation, but less efficient.

NewSequence returns a new sequence from the input modifiables, playing at the given fps rate.

NewSheetSequence creates a Sequence from a sheet and a list of x,y frame coordinates. A sequence will be created by getting the sheet's [i][i+1]th elements incrementally from the input frames. If the number of input frames is uneven, an error is returned.

TweenSequence returns a sequence that is the tweening between the input images at the given frame rate over the given frame count.

func (sq *Sequence) Copy() Modifiable

Copy copies each modifiable inside this sequence in order to produce a new copied sequence

Draw draws this sequence at +xOff, +yOff

Filter filters each element in the sequence by the inputs

Get returns the Modifiable stored at this sequence's ith index. If the sequence does not have an ith index this returns nil

GetDims of a Sequence returns the dims of the current Renderable for the sequence

GetRGBA returns the RGBA of the currently showing frame of this sequence

func (sq *Sequence) IsStatic() bool

IsStatic returns false for sequences

Modify alters each renderable in this sequence by the given modifications

func (p *Sequence) Pause()

SetFPS sets the number of frames that should advance per second to be the input fps

SetTriggerID sets the ID that AnimationEnd will be triggered on when this sequence loops over from its last frame to its first

func (p *Sequence) Unpause()

Sheet is a 2D array of image rgbas

GetSheet calls GetSheet on the Default Cache.

LoadSheet calls LoadSheet on the Default Cache.

MakeSheet converts an image into a sheet with cellSize sized sprites

func (sh *Sheet) SubSprite(x, y int) *Sprite

SubSprite gets a sprite from a sheet at the given location

func (sh *Sheet) ToSprites() [][]*Sprite

ToSprites returns this sheet as a 2D array of Sprites

type Sprite struct {
	LayeredPoint
	
}

A Sprite is a basic wrapper around image data and a point. The most basic Renderable.

BezierLine converts a bezier into a line sprite.

BezierThickLine draws a BezierLine wrapping each colored pixel in a square of width and height = thickness

GetSprite calls GetSprite on the Default Cache.

LoadSprite calls LoadSprite on the Default Cache.

NewCircle creates a sprite and draws a circle onto it

func NewCircularGradientBox(w, h int, startColor, endColor color.Color) *Sprite

NewCircularGradientBox returns a gradient box where the center will be startColor and the gradient will radiate as a circle out from the center.

NewColorBox returns a Sprite full of a given color with the given dimensions Deprecated: Use NewColorboxM (for a Modifiable) or NewColorBoxR.

NewColorBoxM returns a modifiable Color Box (as a Sprite)

func NewColoredLine(x1, y1, x2, y2 float64, colorer Colorer, thickness int) *Sprite

NewColoredLine returns a line with a custom function for how each pixel in that line should be colored.

NewEmptySprite returns a sprite of the given dimensions with a blank RGBA

func NewGradientBox(w, h int, startColor, endColor color.Color, pFunction progressFunction) *Sprite

NewGradientBox returns a gradient box defined on the two input colors and the given progress function

NewGradientLine returns a Line that has some value of thickness along with a start and end color

func NewHorizontalGradientBox(w, h int, startColor, endColor color.Color) *Sprite

NewHorizontalGradientBox returns a gradient box with a horizontal gradient from the start to end color, left to right.

NewLine returns a line from x1,y1 to x2,y2 with the given color

NewSprite creates a new sprite

NewThickLine returns a Line that has some value of thickness

func NewVerticalGradientBox(w, h int, startColor, endColor color.Color) *Sprite

NewVerticalGradientBox returns a gradient box with a vertical gradient from the start to end color, top to bottom.

func OverlaySprites(sps []*Sprite) *Sprite

OverlaySprites combines sprites together through masking to form a single sprite

At returns the color of a given pixel location

Bounds is an alternative to GetDims that alows a sprite to satisfy draw.Image.

ColorModel allows sprites to satisfy draw.Image. Returns color.RGBAModel.

func (s *Sprite) Copy() Modifiable

Copy returns a copy of this Sprite

Draw draws this sprite at +xOff, +yOff

Filter filters this sprite's rgba on all the input filters

GetDims returns the dimensions of this sprite, or if this sprite has no defined RGBA returns default values.

GetRGBA returns the rgba behind this sprite

Modify takes in modifications (modify.go) and alters this sprite accordingly

Set sets a color of a given pixel location

SetRGBA will replace the rgba behind this sprite

A Stackable can be put onto a draw stack. It usually manages how a subset of renderables are drawn.

type Switch struct {
	LayeredPoint
	
}

The Switch type is intended for use to easily swap between multiple renderables that are drawn at the same position on the same layer. A common use case for this would be a character entitiy who switches their animation based on how they are moving or what they are doing, or a button that has changes state when selected or hovered over.

NewSwitch creates a new Switch from a map of names to modifiables

Add makes a new entry in the Switch's map. If the key already existed, it will be overwritten and an error will be returned.

func (c *Switch) Copy() Modifiable

Copy creates a copy of the Switch

Draw draws the Switch at an offset from its logical location

Filter filters all elements of the Switch with fs

Get returns the Switch's current key

GetDims gets the current Renderables dimensions

GetRGBA returns the current renderables rgba

GetSub returns a keyed Modifiable from this Switch's map

func (c *Switch) IsInterruptable() bool

IsInterruptable returns whether the current renderable is interruptable

func (c *Switch) IsStatic() bool

IsStatic returns whether the current renderable is static

Modify performs the input modifications on all elements of the Switch

Pause stops the current Renderable if possible

func (c *Switch) Revert(mod int)

Revert will revert all parts of this Switch that can be reverted

func (c *Switch) RevertAll()

RevertAll will revert all parts of this Switch that can be reverted, back to their original state.

Set sets the current renderable to the one specified

SetOffsets sets the logical offset for the specified key

SetTriggerID sets the ID AnimationEnd will trigger on for animating subtypes. Todo: standardize this with the other interface Set functions so that it also only acts on the current subRenderable, or the other way around, or somehow offer both options

ShiftPos shifts the Switch's logical position

func (c *Switch) Unpause()

Unpause tries to unpause the current Renderable if possible

type Text struct {
	LayeredPoint
	
}

A Text is a renderable that represents some text to print on screen

NewIntText wraps the given int pointer in a stringer interface and creates a text renderable that will diplay the underlying int value.

NewStrPtrText is a helper to take in a string pointer for NewText

NewStringerText creates a text element using the default font and a stringer.

NewText is a helper to create a text element with the default font and a string.

Center will shift the text so that the existing leftmost point where the text sits becomes the center of the new text.

Draw for a text draws the text at its layeredPoint position

GetDims reports the width and height of a text renderable

func (t *Text) SetFont(f *Font)

SetFont sets the drawer which renders the text each frame

func (t *Text) SetInt(i int)

SetInt takes and converts the input integer to a string to write

func (t *Text) SetIntPtr(i *int)

SetIntPtr takes in an integer pointer that will draw the integer behind the pointer, in base 10, each frame

func (t *Text) SetString(str string)

SetString accepts a string itself as the stringer to be written

func (t *Text) SetStringPtr(str *string)

SetStringPtr accepts a string pointer as the stringer to be written

SetStringer accepts an fmt.Stringer to write

func (t *Text) StringLiteral() string

StringLiteral returns what text is currently rendering.

func (t *Text) ToSprite() *Sprite

ToSprite converts this text into a sprite, so that it is no longer modifiable in terms of its text content, but is modifiable in terms of mod.Transform or mod.Filter.

Wrap returns the input text split into a list of texts spread vertically, splitting after each charLimit is reached. the input vertInc is how much each text in the slice will differ by in y value

Triggerable types can have an ID set so when their animations finish, they trigger AnimationEnd on that ID.