Back to Home

ESO Lua File v101050

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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
function ZO_LinearEase(progress)
    return progress
end
function ZO_LinearEaseZeroToOneToZero(progress)
    return progress < 0.5 and (progress * 2) or (2 - (progress * 2))
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 < 0.5 then
        return ((progress * 2) ^ power) * 0.5
    end
    return 1 - (((1 - progress) * 2) ^ power) * 0.5
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_EaseOutInZeroToOneToZero(progress)
    if progress <= 0.5 then
        return 1 - math.sin(ZO_PI * (0.5 - progress))
    end
    return 1 - math.sin(ZO_PI * (progress - 0.5))
end
function ZO_ExponentialEaseInOut(progress, exponent)
    if progress < 0.5 then
        return ((progress * 2) ^ exponent) * 0.5
    end
    return 1 - (((1 - progress) * 2) ^ exponent) * 0.5
end
function ZO_ExponentialEaseOutIn(progress, exponent)
    if progress < 0.5 then
        return (1 - ((1 - (2 * progress)) ^ exponent)) * 0.5
    end
    return (((progress - 0.5) * 2) ^ exponent) * 0.5 + 0.5
end
    if exponent == 1 then
        -- Linear interpolator.
        return ZO_LinearEase
    end
    -- Eased interpolator.
    return function(progress)
        return ZO_ExponentialEaseInOut(progress, exponent)
    end
end
    if exponent == 1 then
        -- Linear interpolator.
        return ZO_LinearEase
    end
    -- Eased interpolator.
    return function(progress)
        return ZO_ExponentialEaseOutIn(progress, exponent)
    end
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
ZO_BounceEase = ZO_GenerateCubicBezierEase(0.31, 1.36, 0.83, 1.2)
ZO_BezierInEase = ZO_GenerateCubicBezierEase(0.5, 0.74, 0.38, 0.94)
do
    local exp = math.exp
    local P = 1.57
    local DIVISOR = 1 / (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 = #progressValues - 1
    local inBetweenModulo = 1 / inBetweenSize
    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 % inBetweenModulo) * inBetweenSize 
        return zo_lerp(previousValue, nextValue, percentBetweenValues)
    end
end