def ease(self, eo="eei", ei="eei", negative=False):
if negative and self.position > 0:
return -ease(ei, self.value)[0]
elif self.position > 0:
return ease(ei, self.value)[0]
else:
return ease(eo, self.value)[0]
def ease(self, easefn):
easer = easefn
if not isinstance(easer, str):
try:
iter(easefn) # is-iterable
if len(easefn) > self.loop:
easer = easefn[self.loop]
elif len(easefn) == 2:
easer = easefn[self.loop % 2]
elif len(easefn) == 1:
easer = easefn[0]
else:
easer = easefn[0]
except TypeError:
print("failed")
pass
v, tangent = ease(easer, self.loop_t)
return min(1, max(0, v)), tangent
def fadeIn(self, fi, easefn="seio", fade_length=None, start=0):
if ClipFlags.FadeIn in self.flags or fade_length:
if fade_length:
fade = fade_length
else:
fade = self.flags[ClipFlags.FadeIn]
if start == 0:
start_frame = self.start
elif start == -1:
start_frame = self.start - fade
if fi < start_frame:
return -1
elif fi > start_frame + fade:
return 1
else:
fv = (fi - start_frame) / fade
a, _ = ease(easefn, fv)
return a
return -1
def io(self, fi, length, ei="eei", eo="eei", negative=False):
"""
Somewhat like ``progress()``, but can be used to fade in/out (hence the name (i)n/(o)ut)
* ``length`` refers to the lenght of the ease, in frames
* ``ei=`` takes the ease-in mnemonic
* ``eo=`` takes the ease-out mnemonic
"""
try:
length_i, length_o = length
except:
length_i = length
length_o = length
if fi < self.start:
return 1
if fi > self.end:
return 0
to_end = self.end - fi
to_start = fi - self.start
easefn = None
in_end = False
if to_end < length_o and eo:
in_end = True
v = 1 - to_end / length_o
easefn = eo
elif to_start <= length_i and ei:
v = 1 - to_start / length_i
easefn = ei
else:
v = 0
if v == 0 or not easefn:
return 0
else:
a, _ = ease(easefn, v)
if negative and in_end:
return -a
else:
return a
def ease(self, eo="eei", ei="eei"):
return ease(eo, self.value)[0]
def rotate(i, p):
ee = ease("eeo", min(1, max(0, (e - rnds1[i]) * 5)))
p.rotate(ee[0] * (360 if i % 2 == 0 else -360))
return p
def now(self, rs, easefn="linear"):
ee = (time() - self.start) * self.factor
if ee < 1:
rs.callback = 0.1 # factor?
return ease(easefn, min(1, max(0, ee)))[0]