rotor-framework 0.3.2

package/src/source/libs/animate/Animate.bs

@@ -0,0 +1,753 @@
+' Public API
+namespace animate
+    function create(params as object) as object
+        animation = _animate.create(params)
+        return _animate.utils.createNodeFromAA(animation)
+    end function
+
+    ' Returns a random integer between min and max, inclusive
+    function random(min as integer, max as integer) as integer
+        return rnd(max - min) + min
+    end function
+
+    function timeline(params as object) as object
+        return new _animate.Timeline(params)
+    end function
+
+    ' All of these have been generated with GPT4,
+    ' hopefully the math is ok :)
+    namespace penner
+        ' The *Sine functions create animations that accelerate
+        ' or decelerate according to a sinusoidal curve.
+        function easeInSine(t as float) as float
+            return -1 * cos(t * _animate.utils.constants.radiansFactor) + 1
+        end function
+
+        function easeOutSine(t as float) as float
+            return sin(t * _animate.utils.constants.radiansFactor)
+        end function
+
+        function easeInOutSine(t as float) as float
+            return -0.5 * (cos(_animate.utils.constants.pi * t) - 1)
+        end function
+
+        function easeOutInSine(t as float) as float
+            if (t < 0.5)
+                return animate.penner.easeOutSine(t * 2) / 2
+            else
+                return animate.penner.easeInSine((t - 0.5) * 2) / 2 + 0.5
+            end if
+        end function
+
+        ' The *Circ functions create an animation that
+        ' accelerates and decelerates respectively in a manner that resembles
+        ' a quarter of a circle.
+
+        function easeInCirc(t as float) as float
+            return -1 * (sqr(1 - t * t) - 1)
+        end function
+
+        function easeOutCirc(t as float) as float
+            t = t - 1
+            return sqr(1 - t * t)
+        end function
+
+        function easeInOutCirc(t as float) as float
+            if (t < 0.5)
+                return -0.5 * (sqr(1 - 4 * t * t) - 1)
+            else
+                t = t - 1
+                return 0.5 * (sqr(1 - 4 * t * t) + 1)
+            end if
+        end function
+
+        function easeOutInCirc(t as float) as float
+            if (t < 0.5)
+                return animate.penner.easeOutCirc(t * 2) / 2
+            else
+                return animate.penner.easeInCirc((t - 0.5) * 2) / 2 + 0.5
+            end if
+        end function
+
+        ' The *Elastic functions create animations that overshoot
+        ' the final state and then oscillate around it before settling,
+        ' creating an elastic effect.
+        ' `p` is the period of the oscillation
+        ' `s` is the phase shift of the oscillation
+        ' These values have been chosen empirically.
+
+        function easeInElastic(t as Float) as Float
+            if (t = 0)
+                return 0
+            end if
+            if (t = 1)
+                return 1
+            end if
+            p = 0.3
+            s = p / 4
+            t = t - 1
+            return -(2 ^ (10 * t) * sin((t - s) * (2 * _animate.utils.constants.pi) / p))
+        end function
+
+        function easeOutElastic(t as Float) as Float
+            if (t = 0)
+                return 0
+            end if
+            if (t = 1)
+                return 1
+            end if
+            p = 0.3
+            s = p / 4
+            return 2 ^ (-10 * t) * sin((t - s) * (2 * _animate.utils.constants.pi) / p) + 1
+        end function
+
+        function easeInOutElastic(t as Float) as Float
+            if (t = 0)
+                return 0
+            end if
+            if (t = 1)
+                return 1
+            end if
+            p = 0.45
+            s = p / 4
+            if (t < 0.5)
+                t = t - 1
+                return -0.5 * (2 ^ (10 * t) * sin((t - s) * (2 * _animate.utils.constants.pi) / p))
+            else
+                t = t - 1
+                return 0.5 * (2 ^ (-10 * t) * sin((t - s) * (2 * _animate.utils.constants.pi) / p)) + 1
+            end if
+        end function
+
+        function easeOutInElastic(t as Float) as Float
+            if (t < 0.5)
+                return animate.penner.easeOutElastic(t * 2) / 2
+            else
+                return animate.penner.easeInElastic((t - 0.5) * 2) / 2 + 0.5
+            end if
+        end function
+
+        ' The *Back functions create an animation
+        ' that overshoots the final state and then comes back.
+        ' This creates a "pullback" or "draw back" effect at the beginning
+        ' or end of the animation, respectively.
+        ' `s` is a constant that determines the amount of overshoot.
+        ' The value 1.70158 results in about a 10% overshoot.
+
+        function easeInBack(t as float) as float
+            s = 1.70158
+            return t * t * ((s + 1) * t - s)
+        end function
+
+        function easeOutBack(t as float) as float
+            s = 1.70158
+            t = t - 1
+            return (t * t * ((s + 1) * t + s) + 1)
+        end function
+
+        function easeInOutBack(t as float) as float
+            ' Adjust the overshoot to achieve a visually
+            ' pleasing result for the combined "in" and "out" animation.
+            s = 1.70158 * 1.525
+            if (t < 0.5)
+                return (t * t * ((s + 1) * t - s)) / 2
+            else
+                t = t - 2
+                return (t * t * ((s + 1) * t + s) + 2) / 2
+            end if
+        end function
+
+        function easeOutInBack(t as float) as float
+            if (t < 0.5)
+                return animate.penner.easeOutBack(t * 2) / 2
+            else
+                return animate.penner.easeInBack((t - 0.5) * 2) / 2 + 0.5
+            end if
+        end function
+
+        ' The *Bounce functions create animations that mimic a bouncing effect.
+        ' The constants in the function (7.5625, 2.75, etc.)
+        ' are chosen empirically to make the bounce effect look good.
+
+        function easeInBounce(t as float) as float
+            return 1 - animate.penner.easeOutBounce(1 - t)
+        end function
+
+        function easeOutBounce(t as float) as float
+            if (t < (1 / 2.75))
+                return (7.5625 * t * t)
+            else if (t < (2 / 2.75))
+                t = t - (1.5 / 2.75)
+                return (7.5625 * t * t + 0.75)
+            else if (t < (2.5 / 2.75))
+                t = t - (2.25 / 2.75)
+                return (7.5625 * t * t + 0.9375)
+            else
+                t = t - (2.625 / 2.75)
+                return (7.5625 * t * t + 0.984375)
+            end if
+        end function
+
+        function easeInOutBounce(t as float) as float
+            if (t < 0.5)
+                return animate.penner.easeInBounce(t * 2) / 2
+            else
+                return animate.penner.easeOutBounce(t * 2 - 1) / 2 + 0.5
+            end if
+        end function
+
+        function easeOutInBounce(t as float) as float
+            if (t < 0.5)
+                return animate.penner.easeOutBounce(t * 2) / 2
+            else
+                return animate.penner.easeInBounce((t - 0.5) * 2) / 2 + 0.5
+            end if
+        end function
+    end namespace
+end namespace
+
+' Private methods
+namespace _animate
+    function create(params as object, recursive = true as boolean) as object
+        animations = []
+        animationParams = _animate.utils.extractAnimationParams(params)
+        if (animationParams.duration = invalid)
+            animationParams.duration = 1
+        end if
+
+        for each animationKey in animationParams.keys()
+            params.delete(animationKey)
+        end for
+
+        interpolatorParams = _animate.utils.extractInterpolatorParams(params)
+        for each interpolatorKey in interpolatorParams.keys()
+            params.delete(interpolatorKey)
+        end for
+
+        targets = []
+        if (params.target <> invalid)
+            targets = params.target
+            params.delete("target")
+        end if
+
+        if (params.targets <> invalid)
+            targets = params.targets
+            params.delete("targets")
+        end if
+
+        autoplay = params.autoplay
+        if (autoplay = invalid)
+            autoplay = false
+        end if
+        params.delete("autoplay")
+
+        nodeTargets = getNodeTargets(targets)
+
+        subAnimations = []
+
+        if (recursive)
+            subKeys = []
+
+            for each item in params.items()
+                if (_animate.is._aa(item.value))
+                    subParams = {}
+                    subParams.append(animationParams)
+                    subParams.append(interpolatorParams)
+                    subParams.targets = nodeTargets
+                    subParams[item.key] = item.value.value
+                    item.value.delete("value")
+                    subParams.append(item.value)
+                    subAnimation = _animate.create(subParams, false)
+                    subAnimations.push(_animate.utils.shallowCopy(subAnimation))
+                    subKeys.push(item.key)
+                end if
+            end for
+
+            for each subKey in subKeys
+                params.delete(subKey)
+            end for
+        end if
+
+        customEaseFunction = invalid
+        if (_animate.is.func(animationParams.easeFunction))
+            customEaseFunction = animationParams.easeFunction
+            animationParams.easeFunction = "linear"
+        end if
+
+        targetsLength = nodeTargets.count()
+        for i = 0 to targetsLength - 1
+            nodeTarget = nodeTargets[i]
+            if (nodeTarget.id = invalid or nodeTarget.id = "")
+                nodeTarget.id = `__animate_${rnd(42069)}` ' nice
+            end if
+
+            targetInfo = {
+                nodeTarget: nodeTarget,
+                index: i,
+                targetsLength: targetsLength
+            }
+
+            finalAnimationParams = _animate.utils.getFunctionValueParams(animationParams, targetInfo)
+            finalInterpolatorParams = _animate.utils.getFunctionValueParams(interpolatorParams, targetInfo)
+            finalParams = _animate.utils.getFunctionValueParams(params, targetInfo)
+
+            alternate = (finalParams.direction = "alternate")
+            if (alternate)
+                finalParams.direction = "normal"
+            end if
+
+            animation = {
+                subtype: _animate.utils.nodes.Animation,
+                children: _animate.getTargetInterpolators(nodeTarget, finalParams, _animate.utils.shallowCopy(finalInterpolatorParams), finalAnimationParams.duration, customEaseFunction)
+            }
+
+            if (animation.children.count() > 0)
+                if (alternate)
+                    alternatedParams = _animate.utils.shallowCopy(finalParams)
+                    alternatedParams.direction = "reverse"
+                    alternated = {
+                        subtype: _animate.utils.nodes.Animation,
+                        children: _animate.getTargetInterpolators(nodeTarget, alternatedParams, _animate.utils.shallowCopy(finalInterpolatorParams), finalAnimationParams.duration, customEaseFunction)
+                    }
+
+                    animation.append(finalAnimationParams)
+                    animation.repeat = false
+
+                    alternated.append(finalAnimationParams)
+                    alternated.repeat = false
+
+                    seqAnim = {
+                        subtype: _animate.utils.nodes.SequentialAnimation,
+                        children: [_animate.utils.shallowCopy(animation), alternated]
+                    }
+                    seqAnim.repeat = finalAnimationParams.repeat
+                    animations.push(seqAnim)
+                else
+                    animation.append(finalAnimationParams)
+                    animations.push(_animate.utils.shallowCopy(animation))
+                end if
+            end if
+        end for
+
+        if (recursive and subAnimations.count() > 0)
+            animations.append(subAnimations)
+        end if
+
+        if (animations.count() > 1)
+            multipleAnimations = {
+                subtype: _animate.utils.nodes.ParallelAnimation,
+                children: animations
+            }
+            if (recursive)
+                multipleAnimations.control = autoplay ? "start" : "none"
+            end if
+            return multipleAnimations
+        else if (animations.count() = 1)
+            if (recursive)
+                animations[0].control = autoplay ? "start" : "none"
+            end if
+            return animations[0]
+        end if
+
+        return animations
+    end function
+
+    function getTargetInterpolators(nodeTarget as object, params as object, globalInterpolatorParams as object, duration as float, customEaseFunction as dynamic) as object
+        interpolators = []
+        direction = params.direction
+        if (direction = invalid)
+            direction = "normal"
+        end if
+        params.delete("direction")
+
+        for each item in params.items()
+            ' Thanks Roku for not letting us split if statements
+            ' in multiple lines. This is very readable! :)
+            if (_animate.is.valid(item.value) and (_animate.is.special.prop(item.key) or nodeTarget.hasField(item.key)))
+                interpolator = _animate.getPropertyInterpolator(nodeTarget, item.key, item.value, duration, customEaseFunction)
+                if (interpolator <> invalid)
+                    finalInterpolator = globalInterpolatorParams
+                    finalInterpolator.append(interpolator)
+
+                    if (direction = "reverse")
+                        finalInterpolator.keyValue.reverse()
+                    end if
+
+                    interpolators.push(_animate.utils.shallowCopy(finalInterpolator))
+                end if
+            end if
+        end for
+        return interpolators
+    end function
+
+    function getPropertyInterpolator(nodeTarget as object, property as string, value as dynamic, duration, customEaseFunction as dynamic) as dynamic
+        if (property = "translation" and _animate.is.arr2d(value))
+            value = [
+                nodeTarget.translation[0] + cdbl(value[0]),
+                nodeTarget.translation[1] + cdbl(value[1])
+            ]
+        else if (_animate.is.special.translation(property) and _animate.utils.compareFieldStrings(property, "translationTo") and _animate.is.arr2d(value))
+            value = [
+                cdbl(value[0]),
+                cdbl(value[1])
+            ]
+            property = "translation"
+        else if (_animate.is.special.translation(property))
+            value = cdbl(value)
+            if (_animate.utils.compareFieldStrings(property, "x"))
+                value = [value, nodeTarget.translation[1]]
+            else if (_animate.utils.compareFieldStrings(property, "y"))
+                value = [nodeTarget.translation[0], value]
+            else if (_animate.utils.compareFieldStrings(property, "translateX"))
+                currentX = nodeTarget.translation[0]
+                value = [currentX + value, nodeTarget.translation[1]]
+            else if (_animate.utils.compareFieldStrings(property, "translateY"))
+                currentY = nodeTarget.translation[1]
+                value = [nodeTarget.translation[0], currentY + value]
+            end if
+            property = "translation"
+        end if
+
+        ops = GetInterface(value, "ifStringOps")
+
+        if (property = "rotation" and _animate.is.str(value) and ops <> invalid and ops.endsWith("deg"))
+            degrees = value.tokenize("deg")[0].toFloat()
+            value = degrees * _animate.utils.constants.radiansFactor
+        end if
+
+        if (property = "scale" and _animate.is.number(value))
+            if (_animate.is.integer(value))
+                value = cdbl(value)
+            end if
+            value = [value, value]
+        end if
+
+        currentValue = nodeTarget[property]
+
+        interpolator = {}
+        if (_animate.is.colorField(property))
+            interpolator.subtype = _animate.utils.nodes.ColorFieldInterpolator
+        else if (_animate.is.arr2d(value))
+            interpolator.subtype = _animate.utils.nodes.Vector2DFieldInterpolator
+        else if (_animate.is.number(value))
+            interpolator.subtype = _animate.utils.nodes.FloatFieldInterpolator
+        else
+            return invalid
+        end if
+
+        keyValue = [currentValue, value]
+
+        if (not _animate.is.colorField(property) and customEaseFunction <> invalid)
+            keyValue = _animate.utils.generateKeyValues(currentValue, value, 60 * duration, customEaseFunction)
+        end if
+
+        keyValueCount = keyValue.count()
+        key = []
+        _step = 1 / (keyValueCount - 1)
+        for i = 0 to keyValueCount - 1
+            key.push(i * _step)
+        end for
+
+        interpolator.append({
+            fieldToInterp: `${nodeTarget.id}.${property}`,
+            keyValue: keyValue,
+            key: key
+        })
+
+        return interpolator
+    end function
+
+    function getNodeTargets(targets as dynamic) as object
+        nodeTargets = []
+
+        if (_animate.is.str(targets))
+            ' For a string `targets`, we split by spaces
+            ' and try to find the nodes in the current `m.top` scope.
+            ids = targets.tokenize(" ")
+            for each id in ids
+                nodeTarget = m.top.findNode(id)
+                if (_animate.is.valid(nodeTarget))
+                    nodeTargets.push(nodeTarget)
+                end if
+            end for
+        else if (_animate.is.arr(targets))
+            ' For array targets, we recursively find targets inside
+            ' each element.
+            for each target in targets
+                nodeTargets.append(getNodeTargets(target))
+            end for
+        else if (_animate.is._node(targets))
+            ' For nodes we consider them directly
+            nodeTargets.push(targets)
+        end if
+
+        return nodeTargets
+    end function
+
+    class Timeline
+        private nodeObject as object = {}
+        private inheritableParams as object = {}
+
+        sub new(params as object)
+            sequential = false
+            if (params.sequential <> invalid and _animate.is.bool(params.sequential))
+                sequential = params.sequential
+                params.delete("sequential")
+            end if
+
+            animationAndInterpolatorParams = _animate.utils.extractAnimationParams(params)
+            animationAndInterpolatorParams.append(_animate.utils.extractInterpolatorParams(params))
+
+            m.inheritableParams = _animate.utils.extractParams(params, [
+                "targets",
+                "target",
+                "easeFunction",
+                "duration",
+                "delay"
+            ])
+
+            nodeName = _animate.utils.nodes.ParallelAnimation
+            if (sequential)
+                nodeName = _animate.utils.nodes.SequentialAnimation
+            end if
+
+            m.nodeObject = {
+                subtype: nodeName,
+                children: []
+            }
+            m.nodeObject.append(animationAndInterpolatorParams)
+        end sub
+
+        function add(params as object) as object
+            if (params.target <> invalid)
+                params.targets = params.target
+                params.delete("target")
+            end if
+
+            finalParams = _animate.utils.shallowCopy(m.inheritableParams)
+            finalParams.append(params)
+            m.nodeObject.children.push(_animate.create(finalParams))
+            return m
+        end function
+
+        function getAnimation() as object
+            return _animate.utils.createNodeFromAA(m.nodeObject)
+        end function
+    end class
+
+    namespace is
+        function valid(x as dynamic) as boolean
+            return x <> invalid
+        end function
+
+        function bool(x as dynamic) as boolean
+            return _animate.is.valid(x) and getInterface(x, "ifBoolean") <> invalid
+        end function
+
+        function str(x as dynamic) as boolean
+            return _animate.is.valid(x) and getInterface(x, "ifString") <> invalid
+        end function
+
+        function arr(x as dynamic) as boolean
+            return _animate.is.valid(x) and getInterface(x, "ifArray") <> invalid
+        end function
+
+        function integer(x as dynamic) as boolean
+            return _animate.is.valid(x) and getInterface(x, "ifInt") <> invalid and (type(x) = "roInt" or type(x) = "roInteger" or type(x) = "Integer")
+        end function
+
+        function float(x as dynamic) as boolean
+            return _animate.is.valid(x) and (getInterface(x, "ifFloat") <> invalid or (type(x) = "roFloat" or type(x) = "Float"))
+        end function
+
+        function number(x as dynamic) as boolean
+            return _animate.is.float(x) or _animate.is.integer(x)
+        end function
+
+        function _node(x as dynamic) as boolean
+            return _animate.is.valid(x) and getInterface(x, "ifSGNodeField") <> invalid
+        end function
+
+        function arr2d(x as dynamic) as boolean
+            return _animate.is.valid(x) and _animate.is.arr(x) and x.count() = 2 and _animate.is.number(x[0]) and _animate.is.number(x[1])
+        end function
+
+        function _aa(x as dynamic) as boolean
+            return _animate.is.valid(x) and getInterface(x, "ifAssociativeArray") <> invalid
+        end function
+
+        function func(x as dynamic) as boolean
+            return _animate.is.valid(x) and getInterface(x, "ifFunction") <> invalid
+        end function
+
+        function colorField(x as dynamic) as boolean
+            colorFields = ["color", "blendColor"]
+            if (not _animate.is.str(x))
+                return false
+            end if
+            for each cf in colorFields
+                if (_animate.utils.compareFieldStrings(cf, x))
+                    return true
+                end if
+            end for
+            return false
+        end function
+
+        namespace special
+            function prop(x as dynamic) as boolean
+                return _animate.is.special.translation(x)
+            end function
+
+            function translation(x as dynamic) as boolean
+                if (not _animate.is.str(x))
+                    return false
+                end if
+
+                specialProperties = ["x", "y", "translateX", "translateY", "translationTo"]
+                for each specialProperty in specialProperties
+                    if (_animate.utils.compareFieldStrings(specialProperty, x))
+                        return true
+                    end if
+                end for
+
+                return false
+            end function
+        end namespace
+    end namespace
+
+    namespace utils
+
+        function createNodeFromAA(aa as object) as object
+            ' Make sure we have an associative array to process
+            if Type(aa) <> "roAssociativeArray"
+                return invalid
+            end if
+
+            ' Fetch subtype if it exists, otherwise provide a default
+            nodeSubtype = "Group" ' Example default node type
+            if aa.Lookup("subtype") <> invalid
+                nodeSubtype = aa.subtype
+            end if
+
+            ' Create a new node with the given (or default) subtype
+            node = CreateObject("roSGNode", nodeSubtype)
+
+            ' If we have a "children" key and it's an array, recurse
+            if aa.Lookup("children") <> invalid and Type(aa.children) = "roArray"
+                for each childAA in aa.children
+                    ' Recursively create child nodes
+                    childNode = _animate.utils.createNodeFromAA(childAA)
+                    if childNode <> invalid
+                        node.appendChild(childNode)
+                    end if
+                end for
+            end if
+            ' Clean up the keys we no longer need in this AA
+            aa.delete("subtype")
+            aa.delete("children")
+
+            ' Set all remaining fields on the node from the AA
+            node.update(aa, true)
+
+            return node
+        end function
+
+        function compareFieldStrings(x as string, y as string) as boolean
+            return lcase(x) = lcase(y)
+        end function
+
+        function getAnimationParams() as object
+            return [
+                "repeat",
+                "delay",
+                "duration",
+                "easeFunction",
+                "easeInPercent",
+                "easeOutPercent",
+                "optional"
+            ]
+        end function
+
+        function getInterpolatorParams() as object
+            return [
+                "fraction",
+                "reverse"
+            ]
+        end function
+
+        function extractParams(source as object, wantedParams as object) as object
+            result = {}
+            for each wantedParam in wantedParams
+                if (source[wantedParam] <> invalid)
+                    result[wantedParam] = source[wantedParam]
+                end if
+            end for
+            return result
+        end function
+
+        function extractAnimationParams(params as object) as object
+            return _animate.utils.extractParams(params, _animate.utils.getAnimationParams())
+        end function
+
+        function extractInterpolatorParams(params as object) as object
+            return _animate.utils.extractParams(params, _animate.utils.getInterpolatorParams())
+        end function
+
+        function shallowCopy(x as object) as object
+            y = {}
+            if (_animate.is.arr(x))
+                y = []
+            end if
+            y.append(x)
+            return y
+        end function
+
+        function getFunctionValueParams(params as object, targetInfo as object) as object
+            copy = _animate.utils.shallowCopy(params)
+            for each item in copy.items()
+                if (_animate.is.func(item.value))
+                    copy[item.key] = item.value(targetInfo.nodeTarget, targetInfo.index, targetInfo.targetsLength)
+                end if
+            end for
+            return copy
+        end function
+
+        function generateKeyValues(_start as dynamic, _end as dynamic, frames as float, easeFunc as function)
+            keyFrames = []
+            for frame = 0 to cint(frames) - 1
+                ' Normalize the current frame number to the range [0, 1]
+                normalizedFrame = frame / (frames - 1)
+                ' Apply the easing function
+                easedFrame = easeFunc(normalizedFrame)
+
+                if (_animate.is.arr2d(_start) and _animate.is.arr2d(_end))
+                    ' Map the result to the range [start, end] for each component
+                    d1 = _start[0] + (_end[0] - _start[0]) * easedFrame
+                    d2 = _start[1] + (_end[1] - _start[1]) * easedFrame
+                    value = [d1, d2]
+                else
+                    ' Map the result to the range [start, end]
+                    value = _start + (_end - _start) * easedFrame
+                end if
+
+                ' Add the calculated value to the list of keyframes
+                keyFrames.push(value)
+            end for
+            return keyFrames
+        end function
+
+        enum nodes
+            Animation = "Animation"
+            ParallelAnimation = "ParallelAnimation"
+            SequentialAnimation = "SequentialAnimation"
+            ColorFieldInterpolator = "ColorFieldInterpolator"
+            Vector2DFieldInterpolator = "Vector2DFieldInterpolator"
+            FloatFieldInterpolator = "FloatFieldInterpolator"
+        end enum
+
+        enum constants
+            pi = 3.14159265
+            radiansFactor = 0.01745329
+        end enum
+    end namespace
+end namespace