Back to Home

ESO Lua File v101038

libraries/utility/zo_easing.lua

[◄ back to folders ]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
function ZO_LinearEase(progress)
    return progress
end
local function EaseIn(progress, power)
    return progress ^ power
end
local function EaseOut(progress, power)
    return 1 - ((1 - progress) ^ power)
end
local function EaseOutIn(progress, power)
    if progress < .5 then
        return ((progress * 2) ^ power) / 2
    end
    return 1 - (((1 - progress) * 2) ^ power) / 2
end
function ZO_EaseInQuadratic(progress)
    return EaseIn(progress, 2)
end
function ZO_EaseOutQuadratic(progress)
    return EaseOut(progress, 2)
end
function ZO_EaseInOutQuadratic(progress)
    return EaseOutIn(progress, 2)
end
function ZO_EaseInCubic(progress)
    return EaseIn(progress, 3)
end
function ZO_EaseOutCubic(progress)
    return EaseOut(progress, 3)
end
function ZO_EaseInOutCubic(progress)
    return EaseOutIn(progress, 3)
end
function ZO_EaseInQuartic(progress)
    return EaseIn(progress, 4)
end
function ZO_EaseOutQuartic(progress)
    return EaseOut(progress, 4)
end
function ZO_EaseInOutQuartic(progress)
    return EaseOutIn(progress, 4)
end
function ZO_EaseInQuintic(progress)
    return EaseIn(progress, 5)
end
function ZO_EaseOutQuintic(progress)
    return EaseOut(progress, 5)
end
function ZO_EaseInOutQuintic(progress)
    return EaseOutIn(progress, 5)
end
function ZO_EaseInOutZeroToOneToZero(progress)
    return math.sin(ZO_PI * progress)
end
function ZO_GenerateCubicBezierEase(x1, y1, x2, y2)
    if x1 == y1 and x2 == y2 then
        return ZO_LinearEase
    end
    return function(progress)
        return CalculateCubicBezierEase(progress, x1, y1, x2, y2)
    end
end
do
    local exp = math.exp
    local P = 1.57
    local DIVISOR = exp(P) - 1
    function ZO_EaseNormalizedZoom(progress)
        --The actual zoom level we use to size things does not go linearly from min to max. Going linearly causes the zoom to feel like it is moving very fast to start
        --and then moving more and more slowly as we reach max zoom. To counteract this we treat the progression from min to max as a curve that increases more slowly to
        --start and then faster later. Research has shown that the curve y=e^px best matches human expectations of an even zoom speed with a p value of 6^0.25 ~= 1.57. We
        --normalized this curve so that y goes from 0 to 1 as x goes from 0 to 1 since we operate on a normalized value between min and max zoom.
        return (exp(P * progress) - 1) / DIVISOR
    end
end
-- progress values must have at least two values in it:
-- {0, 1} generates a line from 0 to 1
-- {0, 1, 0} generates a line from 0 to 1 (at progress=0.5) back to 0
function ZO_GenerateLinearPiecewiseEase(progressValues)
    if not internalassert(#progressValues >= 2, "piecewise ease needs at least two values to ease between") then
        return ZO_LinearEase
    end
    local inBetweenSize = 1 / (#progressValues - 1)
    return function(progress)
        local nextIndex = math.max(2, math.ceil(progress / inBetweenSize) + 1)
        local nextValue = progressValues[nextIndex]
        local previousValue = progressValues[nextIndex - 1]
        local percentBetweenValues = (progress % inBetweenSize) / inBetweenSize 
        return zo_lerp(previousValue, nextValue, percentBetweenValues)
    end
end