core/math/ease

ease

Types

Ease :: enum int {
	Linear             = 0,
	Quadratic_In       = 1,
	Quadratic_Out      = 2,
	Quadratic_In_Out   = 3,
	Cubic_In           = 4,
	Cubic_Out          = 5,
	Cubic_In_Out       = 6,
	Quartic_In         = 7,
	Quartic_Out        = 8,
	Quartic_In_Out     = 9,
	Quintic_In         = 10,
	Quintic_Out        = 11,
	Quintic_In_Out     = 12,
	Sine_In            = 13,
	Sine_Out           = 14,
	Sine_In_Out        = 15,
	Circular_In        = 16,
	Circular_Out       = 17,
	Circular_In_Out    = 18,
	Exponential_In     = 19,
	Exponential_Out    = 20,
	Exponential_In_Out = 21,
	Elastic_In         = 22,
	Elastic_Out        = 23,
	Elastic_In_Out     = 24,
	Back_In            = 25,
	Back_Out           = 26,
	Back_In_Out        = 27,
	Bounce_In          = 28,
	Bounce_Out         = 29,
	Bounce_In_Out      = 30,
}

Source

additional enum variant

Flux_Map :: struct {}Source

Flux_Tween :: struct {}Source

Procedures

back_in :: proc(p: T) -> (T)Source

Modeled after the overshooting cubic y = x^3-xsin(xpi)

back_in_out :: proc(p: T) -> (T)Source

Modeled after the piecewise overshooting cubic function: y = (1/2)((2x)^3-(2x)sin(2xpi)) ; [0, 0.5) y = (1/2)(1-((1-x)^3-(1-x)sin((1-x)*pi))+1) ; [0.5, 1]

back_out :: proc(p: T) -> (T)Source

Modeled after overshooting cubic y = 1-((1-x)^3-(1-x)sin((1-x)pi))

bounce_in :: proc(p: T) -> (T)Source

bounce_in_out :: proc(p: T) -> (T)Source

bounce_out :: proc(p: T) -> (T)Source

circular_in :: proc(p: T) -> (T)Source

Modeled after shifted quadrant IV of unit circle

circular_in_inverse :: proc(p: T) -> (T)Source

Inverse of circular_in x = sqrt(2y - y²)

circular_in_out :: proc(p: T) -> (T)Source

Modeled after the piecewise circular function y = (1/2)(1 - sqrt(1 - 4x^2)) ; [0, 0.5) y = (1/2)(sqrt(-(2x - 3)*(2x - 1)) + 1) ; [0.5, 1]

circular_in_out_inverse :: proc(p: T) -> (T)Source

Inverse of circular_in_out x = sqrt(1 - (1-2y)²) / 2 ; [0, 0.5) x = 1 - sqrt(1 - (2y-1)²) / 2 ; [0.5, 1]

circular_out :: proc(p: T) -> (T)Source

Modeled after shifted quadrant II of unit circle

circular_out_inverse :: proc(p: T) -> (T)Source

Inverse of circular_out x = 1 - sqrt(1 - y²)

cubic_in :: proc(p: T) -> (T)Source

Modeled after the cubic y = x^3

cubic_in_inverse :: proc(p: T) -> (T)Source

Inverse of cubic_in x = y^(1/3)

cubic_in_out :: proc(p: T) -> (T)Source

Modeled after the piecewise cubic y = (1/2)((2x)^3) ; [0, 0.5) y = (1/2)((2x-2)^3 + 2) ; [0.5, 1]

cubic_in_out_inverse :: proc(p: T) -> (T)Source

Inverse of cubic_in_out x = (y/4)^(1/3) ; [0, 0.5) x = ((y-1)*2)^(1/3)/2 + 1 ; [0.5, 1]

cubic_out :: proc(p: T) -> (T)Source

Modeled after the cubic y = (x - 1)^3 + 1

cubic_out_inverse :: proc(p: T) -> (T)Source

Inverse of cubic_out x = (y - 1)^(1/3) + 1

ease :: proc(type: Ease, p: T) -> (T)Source

ease_inverse :: proc(type: Ease, p: T) -> (T)Source

Additional enum variant

elastic_in :: proc(p: T) -> (T)Source

Modeled after the damped sine wave y = sin(13pi/2x)pow(2, 10 * (x - 1))

elastic_in_out :: proc(p: T) -> (T)Source

Modeled after the piecewise exponentially-damped sine wave: y = (1/2)sin(13pi/2(2x))pow(2, 10 ((2x) - 1)) ; [0,0.5) y = (1/2)(sin(-13pi/2((2x-1)+1))pow(2,-10(2x-1)) + 2) ; [0.5, 1]

elastic_out :: proc(p: T) -> (T)Source

Modeled after the damped sine wave y = sin(-13pi/2(x + 1))pow(2, -10x) + 1

exponential_in :: proc(p: T) -> (T)Source

Modeled after the exponential function y = 2^(10(x - 1))

exponential_in_inverse :: proc(p: T) -> (T)Source

Inverse of exponential_in x = log₂(y) / 10 + 1

exponential_in_out :: proc(p: T) -> (T)Source

Modeled after the piecewise exponential y = (1/2)2^(10(2x - 1)) ; [0,0.5) y = -(1/2)*2^(-10(2x - 1))) + 1 ; [0.5,1]

exponential_in_out_inverse :: proc(p: T) -> (T)Source

Inverse of exponential_in_out x = (log₂(2y) + 10) / 20 ; [0, 0.5) x = (10 - log₂(2(1-y))) / 20 ; [0.5, 1]

exponential_out :: proc(p: T) -> (T)Source

Modeled after the exponential function y = -2^(-10x) + 1

exponential_out_inverse :: proc(p: T) -> (T)Source

Inverse of exponential_out x = -log₂(1 - y) / 10

flux_clear :: proc(flux: ^Flux_Map($T))Source

clear map content, stops all animations

flux_destroy :: proc(flux: Flux_Map($T), allocator: mem.Allocator = context.allocator, loc = #caller_location)Source

delete map content

flux_init :: proc(T: typeid, value_capacity: untyped integer = 8, allocator: mem.Allocator = context.allocator, loc = #caller_location) -> (Flux_Map($T=typeid))

Source

init flux map to a float type and a wanted cap

flux_stop :: proc(flux: ^Flux_Map($T), key: ^T) -> (bool)Source

stop a specific key inside the map returns true when it successfully removed the key

flux_to :: proc(
	flux:     ^Flux_Map($T),
	value:    ^T,
	goal:     T,
	type:     Ease,
	duration: time.Duration,
	delay:    f64,
) -> (tween: ^Flux_Tween(T))

Source

append / overwrite existing tween value to parameters rest is initialized in flux_tween_init, inside update return value can be used to set callbacks

flux_tween_init :: proc(tween: ^Flux_Tween($T), duration: time.Duration)Source

init internal properties

flux_tween_time_left :: proc(flux: Flux_Map($T), key: ^T) -> (f64)Source

returns the amount of time left for the tween animation, if the key exists in the map returns 0 if the tween doesn't exist on the map

flux_update :: proc(flux: ^Flux_Map($T), dt: f64)Source

update all tweens, wait for their delay if one exists calls callbacks in all stages, when they're filled deletes tween from the map after completion

quadratic_in :: proc(p: T) -> (T)Source

converted to odin from https://github.com/warrenm/AHEasing with additional enum based call Modeled after the parabola y = x^2

quadratic_in_inverse :: proc(p: T) -> (T)Source

Inverse of quadratic_in x = sqrt(y)

quadratic_in_out :: proc(p: T) -> (T)Source

Modeled after the piecewise quadratic y = (1/2)((2x)^2) ; [0, 0.5) y = -(1/2)((2x-1)*(2x-3) - 1) ; [0.5, 1]

quadratic_in_out_inverse :: proc(p: T) -> (T)Source

Inverse of quadratic_in_out x = sqrt(y/2) ; [0, 0.5) x = 1 - sqrt((1-y)/2) ; [0.5, 1]

quadratic_out :: proc(p: T) -> (T)Source

Modeled after the parabola y = -x^2 + 2x

quadratic_out_inverse :: proc(p: T) -> (T)Source

Inverse of quadratic_out x = 1 - sqrt(1 - y)

quartic_in :: proc(p: T) -> (T)Source

Modeled after the quartic x^4

quartic_in_inverse :: proc(p: T) -> (T)Source

Inverse of quartic_in x = y^(1/4)

quartic_in_out :: proc(p: T) -> (T)Source

Modeled after the piecewise quartic y = (1/2)((2x)^4) ; [0, 0.5) y = -(1/2)((2x-2)^4 - 2) ; [0.5, 1]

quartic_in_out_inverse :: proc(p: T) -> (T)Source

Inverse of quartic_in_out x = (y/8)^(1/4) ; [0, 0.5) x = 1 - ((1-y)/8)^(1/4) ; [0.5, 1]

quartic_out :: proc(p: T) -> (T)Source

Modeled after the quartic y = 1 - (x - 1)^4

quartic_out_inverse :: proc(p: T) -> (T)Source

Inverse of quartic_out x = 1 - (1 - y)^(1/4)

quintic_in :: proc(p: T) -> (T)Source

Modeled after the quintic y = x^5

quintic_in_inverse :: proc(p: T) -> (T)Source

Inverse of quintic_in x = y^(1/5)

quintic_in_out :: proc(p: T) -> (T)Source

Modeled after the piecewise quintic y = (1/2)((2x)^5) ; [0, 0.5) y = (1/2)((2x-2)^5 + 2) ; [0.5, 1]

quintic_in_out_inverse :: proc(p: T) -> (T)Source

Inverse of quintic_in_out x = (y/16)^(1/5) ; [0, 0.5) x = ((y-1)*2)^(1/5)/2 + 1 ; [0.5, 1]

quintic_out :: proc(p: T) -> (T)Source

Modeled after the quintic y = (x - 1)^5 + 1

quintic_out_inverse :: proc(p: T) -> (T)Source

Inverse of quintic_out x = (y - 1)^(1/5) + 1

sine_in :: proc(p: T) -> (T)Source

Modeled after quarter-cycle of sine wave

sine_in_inverse :: proc(p: T) -> (T)Source

Inverse of sine_in x = asin(y - 1) * 2/π + 1

sine_in_out :: proc(p: T) -> (T)Source

Modeled after half sine wave

sine_in_out_inverse :: proc(p: T) -> (T)Source

Inverse of sine_in_out x = acos(1 - 2y) / π

sine_out :: proc(p: T) -> (T)Source

Modeled after quarter-cycle of sine wave (different phase)

sine_out_inverse :: proc(p: T) -> (T)Source

Inverse of sine_out x = asin(y) * 2/π

ease

Types

Procedures

Find anything

Settings