particle

package
Version: v2.0.0+incompatible Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Feb 7, 2018 License: Apache-2.0 Imports: 16 Imported by: 8

Documentation

Overview

Package particle provides options for generating renderable particle sources.

Index

Constants

View Source
const (
	//IgnoreEnd refers to the life value given to particles that want to skip their source's end function.
	IgnoreEnd = -2000 / 2
)

Variables

View Source
var (
	// Inf represents Infinite duration
	Inf = intrange.NewInfinite()
)

Functions

func Allocate

func Allocate(id event.CID) int

Allocate requests a new block in the particle space for the given cid

func And

func And(as ...func(Generator)) func(Generator)

And chains together particle options into a single option for prebaking option sets

func Angle

func Angle(a floatrange.Range) func(Generator)

Angle sets the initial angle of a particle in degrees

func Color

func Color(start, startRand, end, endRand color.Color) func(Generator)

Color sets colors on a Colorable

func Color2

func Color2(start, startRand, end, endRand color.Color) func(Generator)

Color2 sets more colors on a Colorable2

func Deallocate

func Deallocate(block int)

Deallocate requests that the given block be removed from the particle space

func Duration

func Duration(i intrange.Range) func(Generator)

Duration sets how long a generator should produce particles for

func End

func End(ef func(Particle)) func(Generator)

End sets what function should happen when a particle dies

func EndSize

func EndSize(i intrange.Range) func(Generator)

EndSize sets the end size of a Sizeable

func Fragile

func Fragile(f bool) func(*CollisionGenerator)

Fragile sets whether the particles from this collisionGenerator are destroyed on contact

func Gravity

func Gravity(x, y float64) func(Generator)

Gravity sets how a particle should be shifted over time in either dimension

func HitMap

func HitMap(hm map[collision.Label]collision.OnHit) func(*CollisionGenerator)

HitMap sets functions to be called when particles from this generator collide with other spaces

func Layer

func Layer(l func(physics.Vector) int) func(Generator)

Layer sets a function to determine what draw layer a particle should exist on

func LifeSpan

func LifeSpan(ls floatrange.Range) func(Generator)

LifeSpan sets how long a particle should last before dying

func NewPerFrame

func NewPerFrame(npf floatrange.Range) func(Generator)

NewPerFrame sets how many particles should be produced per frame

func Pos

func Pos(x, y float64) func(Generator)

Pos sets the initial position of spawned particles

func Progress

func Progress(pf func(x, y, w, h int) float64) func(Generator)

Progress sets a Progresses' Progress Function

func Rotation

func Rotation(a floatrange.Range) func(Generator)

Rotation rotates particles by a variable amount per frame

func Shape

func Shape(sf shape.Shape) func(Generator)

Shape is an option to set a generator's shape

func Size

func Size(i intrange.Range) func(Generator)

Size is an option to set a Sizeable size

func Speed

func Speed(s floatrange.Range) func(Generator)

Speed sets the initial speed of a particle

func SpeedDecay

func SpeedDecay(x, y float64) func(Generator)

SpeedDecay sets how the speed of a particle should decay

func Spread

func Spread(x, y float64) func(Generator)

Spread sets how far from a generator's position a particle can spawn

func Sprite

func Sprite(s *render.Sprite) func(Generator)

Sprite sets a Sprited's sprite

func SpriteRotation

func SpriteRotation(f floatrange.Range) func(Generator)

SpriteRotation sets a Sprited's rotation

Types

type BaseGenerator

type BaseGenerator struct {
	physics.Vector
	// This float is currently forced to an integer
	// at new particle rotation. This should be changed
	// to something along the lines of 'new per 30 frames',
	// or allow low fractional values to be meaningful,
	// so that more fine-tuned particle generation speeds are possible.
	NewPerFrame floatrange.Range
	// The number of frames each particle should persist
	// before being removed.
	LifeSpan floatrange.Range
	// 0 - between quadrant 1 and 4
	// 90 - between quadrant 2 and 1
	Angle  floatrange.Range
	Speed  floatrange.Range
	Spread physics.Vector
	// Duration in milliseconds for the particle source.
	// After this many milliseconds have passed, it will
	// stop sending out new particles. Old particles will
	// not be removed until their individual lifespans run
	// out.
	// A duration of -1 represents never stopping.
	Duration intrange.Range
	// Rotational acceleration, to change angle over time
	Rotation floatrange.Range
	// Gravity X() and Gravity Y() represent particle acceleration per frame.
	Gravity    physics.Vector
	SpeedDecay physics.Vector
	EndFunc    func(Particle)
	LayerFunc  func(physics.Vector) int
}

A BaseGenerator fulfills all basic requirements to generate particles Modeled after Parcycle

func (*BaseGenerator) GetBaseGenerator

func (bg *BaseGenerator) GetBaseGenerator() *BaseGenerator

GetBaseGenerator returns this

func (*BaseGenerator) SetPos

func (bg *BaseGenerator) SetPos(x, y float64)

SetPos sets the position of a base generator

func (*BaseGenerator) ShiftX

func (bg *BaseGenerator) ShiftX(x float64)

ShiftX moves a base generator by an x value

func (*BaseGenerator) ShiftY

func (bg *BaseGenerator) ShiftY(y float64)

ShiftY moves a base generator by a y value

type CollisionGenerator

type CollisionGenerator struct {
	Generator
	Fragile bool
	HitMap  map[collision.Label]collision.OnHit
}

A CollisionGenerator generates collision particles

func (*CollisionGenerator) Generate

func (cg *CollisionGenerator) Generate(layer int) *Source

Generate creates a source using this generator

func (*CollisionGenerator) GenerateParticle

func (cg *CollisionGenerator) GenerateParticle(bp *baseParticle) Particle

GenerateParticle creates a particle from a generator

func (*CollisionGenerator) GetParticleSize

func (cg *CollisionGenerator) GetParticleSize() (float64, float64, bool)

GetParticleSize on a CollisionGenerator tells the caller that the particle size is per-particle specific

type CollisionParticle

type CollisionParticle struct {
	Particle
	// contains filtered or unexported fields
}

A CollisionParticle is a wrapper around other particles that also has a collision space and can functionally react with the environment on collision

func (*CollisionParticle) Cycle

func (cp *CollisionParticle) Cycle(generator Generator)

Cycle updates the collisiion particles variables once per rotation

func (*CollisionParticle) Draw

func (cp *CollisionParticle) Draw(buff draw.Image)

Draw redirects to DrawOffset

func (*CollisionParticle) DrawOffset

func (cp *CollisionParticle) DrawOffset(buff draw.Image, xOff, yOff float64)

DrawOffset redirects to DrawOffsetGen

func (*CollisionParticle) DrawOffsetGen

func (cp *CollisionParticle) DrawOffsetGen(generator Generator, buff draw.Image, xOff, yOff float64)

DrawOffsetGen draws a particle with it's generator's variables

func (*CollisionParticle) GetDims

func (cp *CollisionParticle) GetDims() (int, int)

GetDims returns the dimensions of the space of the particle

type ColorGenerator

type ColorGenerator struct {
	BaseGenerator
	StartColor, StartColorRand color.Color
	EndColor, EndColorRand     color.Color
	// The size, in pixel radius, of spawned particles
	Size    intrange.Range
	EndSize intrange.Range
	//
	// Some sort of particle type, for rendering triangles or squares or circles...
	Shape shape.Shape
}

A ColorGenerator generates ColorParticles

func (*ColorGenerator) Generate

func (cg *ColorGenerator) Generate(layer int) *Source

Generate creates a source using this generator

func (*ColorGenerator) GenerateParticle

func (cg *ColorGenerator) GenerateParticle(bp *baseParticle) Particle

GenerateParticle creates a particle from a generator

func (*ColorGenerator) GetParticleSize

func (cg *ColorGenerator) GetParticleSize() (float64, float64, bool)

GetParticleSize on a color generator returns that the particles are per-particle specificially sized

func (*ColorGenerator) SetEndColor

func (cg *ColorGenerator) SetEndColor(ec, ecr color.Color)

SetEndColor lets cg have its end color be set

func (*ColorGenerator) SetEndSize

func (cg *ColorGenerator) SetEndSize(i intrange.Range)

SetEndSize stasfies Sizeable

func (*ColorGenerator) SetShape

func (cg *ColorGenerator) SetShape(sf shape.Shape)

SetShape satisfies Shapeable

func (*ColorGenerator) SetSize

func (cg *ColorGenerator) SetSize(i intrange.Range)

SetSize satisfies Sizeable

func (*ColorGenerator) SetStartColor

func (cg *ColorGenerator) SetStartColor(sc, scr color.Color)

SetStartColor lets cg have its color be set

type ColorParticle

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

A ColorParticle is a particle with a defined color and size

func (ColorParticle) Cycle

func (bp ColorParticle) Cycle(gen Generator)

func (*ColorParticle) Draw

func (cp *ColorParticle) Draw(buff draw.Image)

Draw redirects to DrawOffset

func (*ColorParticle) DrawOffset

func (cp *ColorParticle) DrawOffset(buff draw.Image, xOff, yOff float64)

DrawOffset redirects to DrawOffsetGen

func (*ColorParticle) DrawOffsetGen

func (cp *ColorParticle) DrawOffsetGen(generator Generator, buff draw.Image, xOff, yOff float64)

DrawOffsetGen draws a particle with it's generator's variables

func (ColorParticle) GetBaseParticle

func (bp ColorParticle) GetBaseParticle() *baseParticle

func (*ColorParticle) GetDims

func (cp *ColorParticle) GetDims() (int, int)

GetDims returns the color particle's size, twice

func (*ColorParticle) GetLayer

func (cp *ColorParticle) GetLayer() int

GetLayer returns baseParticle GetLayer. This is a safety check against auto-generated code which would not contain the nil check here

func (*ColorParticle) GetPos

func (cp *ColorParticle) GetPos() physics.Vector

GetPos returns the middle of a color particle

type Colorable

type Colorable interface {
	SetStartColor(color.Color, color.Color)
	SetEndColor(color.Color, color.Color)
}

A Colorable can have colors set on it.

type Colorable2

type Colorable2 interface {
	SetStartColor2(color.Color, color.Color)
	SetEndColor2(color.Color, color.Color)
}

A Colorable2 can have more colors set on it

type Generator

type Generator interface {
	GetBaseGenerator() *BaseGenerator
	GenerateParticle(*baseParticle) Particle
	Generate(int) *Source
	GetParticleSize() (float64, float64, bool)
	ShiftX(float64)
	ShiftY(float64)
	SetPos(float64, float64)
	GetPos() (float64, float64)
}

A Generator holds settings for generating particles

func NewCollisionGenerator

func NewCollisionGenerator(g Generator, options ...func(*CollisionGenerator)) Generator

NewCollisionGenerator creates a new collision generator

func NewColorGenerator

func NewColorGenerator(options ...func(Generator)) Generator

NewColorGenerator returns a new color generator with some applied options.

func NewGradientGenerator

func NewGradientGenerator(options ...func(Generator)) Generator

NewGradientGenerator returns a new GradientGenerator

func NewSpriteGenerator

func NewSpriteGenerator(options ...func(Generator)) Generator

NewSpriteGenerator creates a SpriteGenerator

type GradientGenerator

type GradientGenerator struct {
	ColorGenerator
	StartColor2, StartColor2Rand color.Color
	EndColor2, EndColor2Rand     color.Color
	ProgressFunction             func(x, y, w, h int) float64
}

A GradientGenerator is a ColorGenerator with a patterned gradient on its particles

func (*GradientGenerator) Generate

func (gg *GradientGenerator) Generate(layer int) *Source

Generate takes a generator and converts it into a source, drawing particles and binding functions for particle generation and rotation.

func (*GradientGenerator) GenerateParticle

func (gg *GradientGenerator) GenerateParticle(bp *baseParticle) Particle

GenerateParticle creates a particle from a generator

func (*GradientGenerator) SetEndColor2

func (gg *GradientGenerator) SetEndColor2(ec, ecr color.Color)

SetEndColor2 satisfies Colorable2

func (*GradientGenerator) SetProgress

func (gg *GradientGenerator) SetProgress(pf func(x, y, w, h int) float64)

SetProgress satisfies Progresses

func (*GradientGenerator) SetStartColor2

func (gg *GradientGenerator) SetStartColor2(sc, scr color.Color)

SetStartColor2 satisfies Colorable2

type GradientParticle

type GradientParticle struct {
	ColorParticle
	// contains filtered or unexported fields
}

A GradientParticle has a gradient from one color to another

func (GradientParticle) Cycle

func (bp GradientParticle) Cycle(gen Generator)

func (*GradientParticle) Draw

func (gp *GradientParticle) Draw(buff draw.Image)

Draw redirects to DrawOffset

func (*GradientParticle) DrawOffset

func (gp *GradientParticle) DrawOffset(buff draw.Image, xOff, yOff float64)

DrawOffset redirects to DrawOffsetGen

func (*GradientParticle) DrawOffsetGen

func (gp *GradientParticle) DrawOffsetGen(generator Generator, buff draw.Image, xOff, yOff float64)

DrawOffsetGen draws a particle with it's generator's variables

func (GradientParticle) GetBaseParticle

func (bp GradientParticle) GetBaseParticle() *baseParticle

type Particle

type Particle interface {
	render.Renderable
	GetBaseParticle() *baseParticle
	GetPos() physics.Vector
	DrawOffsetGen(gen Generator, buff draw.Image, xOff, yOff float64)
	Cycle(gen Generator)
	// contains filtered or unexported methods
}

A Particle is a renderable that is spawned by a generator, usually very fast, usually very small, for visual effects

func Lookup

func Lookup(id int) Particle

Lookup requests a specific particle in the particle space

type Progresses

type Progresses interface {
	SetProgress(func(x, y, w, h int) float64)
}

A Progresses has a SetProgress function where a progress function returns how far between two colors a given coordinate in a space is

type Shapeable

type Shapeable interface {
	SetShape(shape.Shape)
}

Shapeable generators can have the Shape option called on them

type Sizeable

type Sizeable interface {
	SetSize(i intrange.Range)
	SetEndSize(i intrange.Range)
}

A Sizeable is a generator that can have some size set to it

type Source

type Source struct {
	render.Layered
	Generator Generator

	CID event.CID

	EndFunc func()
	// contains filtered or unexported fields
}

A Source is used to store and control a set of particles.

func LookupSource

func LookupSource(id int) *Source

LookupSource requests the source that generated a pid

func NewSource

func NewSource(g Generator, stackLevel int) *Source

NewSource creates a new source

func (*Source) Init

func (ps *Source) Init() event.CID

Init allows a source to be considered as an entity, and initializes it

func (*Source) Layer

func (ps *Source) Layer(v physics.Vector) int

Layer is shorthand for getting the base generator behind a source's layer

func (*Source) Pause

func (ps *Source) Pause()

Pause on a Source just stops the repetition of its rotation function, which moves, destroys, ages and generates particles. Existing particles will stay in place.

func (*Source) SetPos

func (ps *Source) SetPos(x, y float64)

SetPos sets a source's underlying generator

func (*Source) ShiftX

func (ps *Source) ShiftX(x float64)

ShiftX shift's a source's underlying generator

func (*Source) ShiftY

func (ps *Source) ShiftY(y float64)

ShiftY shift's a source's underlying generator (todo: consider if this shoud be composed)

func (*Source) Stop

func (ps *Source) Stop()

Stop manually stops a Source, if its duration is infinite or if it should be stopped before expriring naturally.

func (*Source) UnPause

func (ps *Source) UnPause()

UnPause on a source a Source rebinds it's rotate function.

type SpriteGenerator

type SpriteGenerator struct {
	BaseGenerator
	SpriteRotation floatrange.Range
	Base           *render.Sprite
}

A SpriteGenerator generate SpriteParticles

func (*SpriteGenerator) Generate

func (sg *SpriteGenerator) Generate(layer int) *Source

Generate creates a source using this generator

func (*SpriteGenerator) GenerateParticle

func (sg *SpriteGenerator) GenerateParticle(bp *baseParticle) Particle

GenerateParticle creates a particle from a generator

func (*SpriteGenerator) GetParticleSize

func (sg *SpriteGenerator) GetParticleSize() (float64, float64, bool)

GetParticleSize returns the size of the sprite that the generator generates

func (*SpriteGenerator) SetSprite

func (sg *SpriteGenerator) SetSprite(s *render.Sprite)

SetSprite is the function on a sprite generator that satisfies Sprited

func (*SpriteGenerator) SetSpriteRotation

func (sg *SpriteGenerator) SetSpriteRotation(f floatrange.Range)

SetSpriteRotation satisfied Sprited for SpriteGenerators

type SpriteParticle

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

A SpriteParticle is a particle that has an amount of sprite rotation

func (SpriteParticle) Cycle

func (bp SpriteParticle) Cycle(gen Generator)

func (*SpriteParticle) Draw

func (sp *SpriteParticle) Draw(buff draw.Image)

Draw redirects to DrawOffset

func (*SpriteParticle) DrawOffset

func (sp *SpriteParticle) DrawOffset(buff draw.Image, xOff, yOff float64)

DrawOffset redirects to DrawOffsetGen

func (*SpriteParticle) DrawOffsetGen

func (sp *SpriteParticle) DrawOffsetGen(generator Generator, buff draw.Image, xOff, yOff float64)

DrawOffsetGen draws a particle with it's generator's variables

func (SpriteParticle) GetBaseParticle

func (bp SpriteParticle) GetBaseParticle() *baseParticle

func (SpriteParticle) GetDims

func (bp SpriteParticle) GetDims() (int, int)

func (SpriteParticle) GetLayer

func (bp SpriteParticle) GetLayer() int

func (SpriteParticle) GetPos

func (bp SpriteParticle) GetPos() physics.Vector

type Sprited

type Sprited interface {
	SetSprite(*render.Sprite)
	SetSpriteRotation(f floatrange.Range)
}

A Sprited can have a sprite set to it

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL