factoryTween

Documentation

Index

• func NewEaseInCircular(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInCircularOutCubic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInCircularOutExponential(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInCircularOutLinear(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInCircularOutQuadratic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInCircularOutQuartic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInCircularOutQuintic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInCircularOutSine(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInCubic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInCubicOutCircular(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInCubicOutExponential(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInCubicOutLinear(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInCubicOutQuadratic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInCubicOutQuartic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInCubicOutQuintic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInCubicOutSine(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInExponential(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInExponentialOutCircular(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInExponentialOutCubic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInExponentialOutLinear(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInExponentialOutQuadratic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInExponentialOutQuartic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInExponentialOutQuintic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInExponentialOutSine(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInLinearOutCircular(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInLinearOutCubic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInLinearOutExponential(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInLinearOutQuadratic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInLinearOutQuartic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInLinearOutQuintic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInOutCircular(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInOutCubic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInOutExponential(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInOutQuadratic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInOutQuartic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInOutQuintic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInOutSine(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInQuadratic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInQuadraticOutCircular(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInQuadraticOutCubic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInQuadraticOutExponential(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInQuadraticOutLinear(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInQuadraticOutQuartic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInQuadraticOutQuintic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInQuadraticOutSine(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInQuartic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInQuarticOutCircular(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInQuarticOutCubic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInQuarticOutExponential(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInQuarticOutLinear(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInQuarticOutQuadratic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInQuarticOutQuintic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInQuarticOutSine(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInQuintic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInQuinticOutCircular(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInQuinticOutCubic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInQuinticOutExponential(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInQuinticOutLinear(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInQuinticOutQuadratic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInQuinticOutQuartic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInQuinticOutSine(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInSine(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInSineOutCircular(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInSineOutCubic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInSineOutExponential(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInSineOutQuadratic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInSineOutQuartic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseInSineOutQuintic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseOutCircular(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseOutCubic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseOutExponential(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseOutQuadratic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseOutQuartic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseOutQuintic(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewEaseOutSine(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewLinear(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween
• func NewSelectRandom(duration time.Duration, startValue, endValue float64, doNotReverseMotion bool, ...) *tween.Tween

Functions

func NewEaseInCircular

func NewEaseInCircular(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInCircular

English: Ease tween in circular

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in circular

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInCircularOutCubic

func NewEaseInCircularOutCubic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInCircularOutCubic

English: Ease tween in circular out cubic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in circular out cubic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInCircularOutExponential

func NewEaseInCircularOutExponential(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInCircularOutExponential

English: Ease tween in circular out exponential

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in circular out exponential

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInCircularOutLinear

func NewEaseInCircularOutLinear(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInCircularOutLinear

English: Ease tween in circular out linear

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in circular out linear

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInCircularOutQuadratic

func NewEaseInCircularOutQuadratic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInCircularOutQuadratic

English: Ease tween in circular out quadratic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in circular out quadratic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInCircularOutQuartic

func NewEaseInCircularOutQuartic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInCircularOutQuartic

English: Ease tween in circular out quartic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in circular out quartic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInCircularOutQuintic

func NewEaseInCircularOutQuintic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInCircularOutQuintic

English: Ease tween in circular out quintic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in circular out quintic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInCircularOutSine

func NewEaseInCircularOutSine(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInCircularOutSine

English: Ease tween in circular out sine

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in circular out sine

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInCubic

func NewEaseInCubic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInCubic

English: Ease tween in cubic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in cubic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInCubicOutCircular

func NewEaseInCubicOutCircular(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInCubicOutCircular

English: Ease tween in cubic out circular

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in cubic out circular

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInCubicOutExponential

func NewEaseInCubicOutExponential(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInCubicOutExponential

English: Ease tween in cubic out exponential

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in cubic out exponential

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInCubicOutLinear

func NewEaseInCubicOutLinear(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInCubicOutLinear

English: Ease tween in cubic out linear

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in cubic out linear

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInCubicOutQuadratic

func NewEaseInCubicOutQuadratic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInCubicOutQuadratic

English: Ease tween in cubic out quadratic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in cubic out quadratic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInCubicOutQuartic

func NewEaseInCubicOutQuartic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInCubicOutQuartic

English: Ease tween in cubic out quartic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in cubic out quartic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInCubicOutQuintic

func NewEaseInCubicOutQuintic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInCubicOutQuintic

English: Ease tween in cubic out quintic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in cubic out quintic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInCubicOutSine

func NewEaseInCubicOutSine(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInCubicOutSine

English: Ease tween in cubic out sine

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in cubic out sine

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInExponential

func NewEaseInExponential(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInExponential

English: Ease tween in exponential

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in exponential

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInExponentialOutCircular

func NewEaseInExponentialOutCircular(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInExponentialOutCircular

English: Ease tween in exponential out circular

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in exponential out circular

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInExponentialOutCubic

func NewEaseInExponentialOutCubic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInExponentialOutCubic

English: Ease tween in exponential out cubic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in exponential out cubic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInExponentialOutLinear

func NewEaseInExponentialOutLinear(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInExponentialOutLinear

English: Ease tween in exponential out linear

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in exponential out linear

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInExponentialOutQuadratic

func NewEaseInExponentialOutQuadratic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInExponentialOutQuadratic

English: Ease tween in exponential out quadratic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in exponential out quadratic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInExponentialOutQuartic

func NewEaseInExponentialOutQuartic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInExponentialOutQuartic

English: Ease tween in exponential out quartic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in exponential out quartic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInExponentialOutQuintic

func NewEaseInExponentialOutQuintic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInExponentialOutQuintic

English: Ease tween in exponential out quintic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in exponential out quintic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInExponentialOutSine

func NewEaseInExponentialOutSine(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInExponentialOutSine

English: Ease tween in exponential out sine

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in exponential out sine

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInLinearOutCircular

func NewEaseInLinearOutCircular(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInLinearOutCircular

English: Ease tween in linear out circular

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in linear out circular

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInLinearOutCubic

func NewEaseInLinearOutCubic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInLinearOutCubic

English: Ease tween in linear out cubic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in linear out cubic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInLinearOutExponential

func NewEaseInLinearOutExponential(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInLinearOutExponential

English: Ease tween in linear out exponential

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in linear out exponential

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInLinearOutQuadratic

func NewEaseInLinearOutQuadratic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInLinearOutQuadratic

English: Ease tween in linear out quadratic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in linear out quadratic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInLinearOutQuartic

func NewEaseInLinearOutQuartic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInLinearOutQuartic

English: Ease tween in linear out quartic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in linear out quartic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInLinearOutQuintic

func NewEaseInLinearOutQuintic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInLinearOutQuintic

English: Ease tween in linear out quintic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in linear out quintic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInOutCircular

func NewEaseInOutCircular(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInOutCircular

English: Ease tween in out circular

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in out circular

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInOutCubic

func NewEaseInOutCubic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInOutCubic

English: Ease tween in out cubic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in out cubic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInOutExponential

func NewEaseInOutExponential(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInOutExponential

English: Ease tween in out exponential

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in out exponential

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInOutQuadratic

func NewEaseInOutQuadratic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInOutQuadratic

English: Ease tween in out quadratic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in out quadratic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInOutQuartic

func NewEaseInOutQuartic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInOutQuartic

English: Ease tween in out quartic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in out quartic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInOutQuintic

func NewEaseInOutQuintic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInOutQuintic

English: Ease tween in out quintic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in out quintic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInOutSine

func NewEaseInOutSine(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInOutSine

English: Ease tween in out sine

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in out sine

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInQuadratic

func NewEaseInQuadratic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInQuadratic

English: Ease tween in quadratic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in quadratic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInQuadraticOutCircular

func NewEaseInQuadraticOutCircular(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInQuadraticOutCircular

English: Ease tween in quadratic out circular

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in quadratic out circular

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInQuadraticOutCubic

func NewEaseInQuadraticOutCubic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInQuadraticOutCubic

English: Ease tween in quadratic out cubic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in quadratic out cubic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInQuadraticOutExponential

func NewEaseInQuadraticOutExponential(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInQuadraticOutExponential

English: Ease tween in quadratic out exponential

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in quadratic out exponential

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInQuadraticOutLinear

func NewEaseInQuadraticOutLinear(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInQuadraticOutLinear

English: Ease tween in quadratic out linear

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in quadratic out linear

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInQuadraticOutQuartic

func NewEaseInQuadraticOutQuartic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInQuadraticOutQuartic

English: Ease tween in quadratic out quartic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in quadratic out quartic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInQuadraticOutQuintic

func NewEaseInQuadraticOutQuintic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInQuadraticOutQuintic

English: Ease tween in quadratic out quintic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in quadratic out quintic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInQuadraticOutSine

func NewEaseInQuadraticOutSine(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInQuadraticOutSine

English: Ease tween in quadratic out sine

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in quadratic out sine

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInQuartic

func NewEaseInQuartic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInQuartic

English: Ease tween in quartic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in quartic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInQuarticOutCircular

func NewEaseInQuarticOutCircular(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInQuarticOutCircular

English: Ease tween in quartic out circular

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in quartic out circular

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInQuarticOutCubic

func NewEaseInQuarticOutCubic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInQuarticOutCubic

English: Ease tween in quartic out cubic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in quartic out cubic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInQuarticOutExponential

func NewEaseInQuarticOutExponential(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInQuarticOutExponential

English: Ease tween in quartic out exponential

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in quartic out exponential

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInQuarticOutLinear

func NewEaseInQuarticOutLinear(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInQuarticOutLinear

English: Ease tween in quartic out linear

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in quartic out linear

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInQuarticOutQuadratic

func NewEaseInQuarticOutQuadratic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInQuarticOutQuadratic

English: Ease tween in quartic out quadratic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in quartic out quadratic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInQuarticOutQuintic

func NewEaseInQuarticOutQuintic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInQuarticOutQuintic

English: Ease tween in quartic out quintic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in quartic out quintic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInQuarticOutSine

func NewEaseInQuarticOutSine(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInQuarticOutSine

English: Ease tween in quartic out sine

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in quartic out sine

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInQuintic

func NewEaseInQuintic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInQuintic

English: Ease tween in quintic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in quintic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInQuinticOutCircular

func NewEaseInQuinticOutCircular(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInQuinticOutCircular

English: Ease tween in quintic out circular

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in quintic out circular

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInQuinticOutCubic

func NewEaseInQuinticOutCubic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInQuinticOutCubic

English: Ease tween in quintic out cubic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in quintic out cubic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInQuinticOutExponential

func NewEaseInQuinticOutExponential(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInQuinticOutExponential

English: Ease tween in quintic out exponential

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in quintic out exponential

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInQuinticOutLinear

func NewEaseInQuinticOutLinear(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInQuinticOutLinear

English: Ease tween in quintic out linear

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in quintic out linear

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInQuinticOutQuadratic

func NewEaseInQuinticOutQuadratic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInQuinticOutQuadratic

English: Ease tween in quintic out quadratic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in quintic out quadratic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInQuinticOutQuartic

func NewEaseInQuinticOutQuartic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInQuinticOutQuartic

English: Ease tween in quintic out quartic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in quintic out quartic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInQuinticOutSine

func NewEaseInQuinticOutSine(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInQuinticOutSine

English: Ease tween in quintic out sine

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in quintic out sine

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInSine

func NewEaseInSine(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInSine

English: Ease tween in sine

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in sine

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInSineOutCircular

func NewEaseInSineOutCircular(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInSineOutCircular

English: Ease tween in sine out circular

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in sine out circular

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInSineOutCubic

func NewEaseInSineOutCubic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInSineOutCubic

English: Ease tween in sine out cubic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in sine out cubic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInSineOutExponential

func NewEaseInSineOutExponential(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInSineOutExponential

English: Ease tween in sine out exponential

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in sine out exponential

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInSineOutQuadratic

func NewEaseInSineOutQuadratic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInSineOutQuadratic

English: Ease tween in sine out quadratic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in sine out quadratic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInSineOutQuartic

func NewEaseInSineOutQuartic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInSineOutQuartic

English: Ease tween in sine out quartic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in sine out quartic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseInSineOutQuintic

func NewEaseInSineOutQuintic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseInSineOutQuintic

English: Ease tween in sine out quintic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação in sine out quintic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseOutCircular

func NewEaseOutCircular(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseOutCircular

English: Ease tween out circular

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação out circular

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseOutCubic

func NewEaseOutCubic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseOutCubic

English: Ease tween out cubic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação out cubic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseOutExponential

func NewEaseOutExponential(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseOutExponential

English: Ease tween out exponential

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação out exponential

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseOutQuadratic

func NewEaseOutQuadratic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseOutQuadratic

English: Ease tween out quadratic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação out quadratic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseOutQuartic

func NewEaseOutQuartic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseOutQuartic

English: Ease tween out quartic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação out quartic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseOutQuintic

func NewEaseOutQuintic(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseOutQuintic

English: Ease tween ease out quintic

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação ease out quintic

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewEaseOutSine

func NewEaseOutSine(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewEaseOutSine

English: Ease tween ease out sine

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação ease out sine

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewLinear

func NewLinear(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewLinear

English: Ease tween linear

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação linear

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}

func NewSelectRandom

func NewSelectRandom(
	duration time.Duration,
	startValue,
	endValue float64,
	doNotReverseMotion bool,
	onStartFunc,
	onEndFunc,
	onCycleStartFunc,
	onCycleEndFunc,
	onInvertFunc func(value float64, arguments ...interface{}),
	onStepFunc func(value, percentToComplete float64, arguments ...interface{}),
	loop int,
	arguments ...interface{},
) *tween.Tween

NewSelectRandom

English: Ease tween random

duration: animation duration
startValue: initial value
endValue: final value
doNotReverseMotion: don't reverse motion into loop
onStartFunc: on start function
onEndFunc: on end function
onCycleStartFunc: on tween cycle start function
onCycleEndFunc: on tween cycle end function
onInvertFunc: on invert function. Only for loop != 0
onStepFunc: on step function
loop: number of loops or -1 for infinite loops
arguments: array of arguments passed for functions onStart, onEnd, onInvert and onStep.
           Example: ..., [arguments] x, y) will be onStartFunc(value, args...) { args[0]: x; args[1]: y}

Português: Facilitador de interpolação random

duration: duração da animação
startValue: valor inicial
endValue: valor final
doNotReverseMotion: não inverter o movimento quando no loops
onStartFunc: função do evento início
onEndFunc: função do evento fim
onCycleStartFunc: função para o início do ciclo de interpolação
onCycleEndFunc: função para o fim do ciclo de interpolação
onInvertFunc: função para o evento inversão. Apenas se loop != 0
onStepFunc: função para o evento passo
loop: número de interações ou -1 para um número infinito de interações
arguments: array de argumentos passados para as funções onStart, onEnd, onInvert e onStep.
           Exemplo: ..., [argumentos] x, y) será onStartFunc(value, args...) { args[0]: x; args[1]: y}