Distorted Android

///////////////////////////////////////////////////////////////////////////////////////////////////

package org.distorted.library.type

 *

interface Data1D

{

    fun get(buffer: FloatArray, offset: Int, time: Long, step: Long): Boolean

}

///////////////////////////////////////////////////////////////////////////////////////////////////

package org.distorted.library.type

 *

interface Data2D

{

    fun get(buffer: FloatArray, offset: Int, time: Long, step: Long): Boolean

}

///////////////////////////////////////////////////////////////////////////////////////////////////

package org.distorted.library.type

 *

interface Data3D

{

    fun get(buffer: FloatArray, offset: Int, time: Long, step: Long): Boolean

}

///////////////////////////////////////////////////////////////////////////////////////////////////

package org.distorted.library.type

 *

interface Data4D

{

    fun get(buffer: FloatArray, offset: Int, time: Long, step: Long): Boolean

}

///////////////////////////////////////////////////////////////////////////////////////////////////

package org.distorted.library.type

 *

interface Data5D

{

    fun get(buffer: FloatArray, offset: Int, time: Long, step: Long): Boolean

}

///////////////////////////////////////////////////////////////////////////////////////////////////

package org.distorted.library.type

import org.distorted.library.main.DistortedLibrary

import java.util.Random

import java.util.Vector

import kotlin.math.sqrt

*

*  if there is only one Point, just return it.

*  if there are two Points, linearly bounce between them

*  if there are more, interpolate a path between them. Exact way we interpolate depends on the MODE.

*

abstract class Dynamic

{

    companion object

    {

        /**

         * Keep the speed of interpolation always changing. Time to cover one segment (distance between

         * two consecutive points) always the same. Smoothly interpolate the speed between two segments.

         */

        const val SPEED_MODE_SMOOTH: Int = 0

        /**

         * Make each segment have constant speed. Time to cover each segment is still the same, thus the

         * speed will jump when passing through a point and then keep constant.

         */

        const val SPEED_MODE_SEGMENT_CONSTANT: Int = 1

        /**

         * Have the speed be always, globally the same across all segments. Time to cover one segment will

         * thus generally no longer be the same.

         */

        const val SPEED_MODE_GLOBALLY_CONSTANT: Int = 2 // TODO: not supported yet

        /**

         * One revolution takes us from the first point to the last and back to first through the shortest path.

         */

        const val MODE_LOOP: Int = 0

        /**

         * One revolution takes us from the first point to the last and back to first through the same path.

         */

        const val MODE_PATH: Int = 1

        /**

         * One revolution takes us from the first point to the last and jumps straight back to the first point.

         */

        const val MODE_JUMP: Int = 2

        /**

         * The default mode of access. When in this mode, we are able to call interpolate() with points in time

         * in any random order. This means one single Dynamic can be used in many effects simultaneously.

         * On the other hand, when in this mode, it is not possible to smoothly interpolate when mDuration suddenly

         * changes.

         */

        const val ACCESS_TYPE_RANDOM: Int = 0

        /**

         * Set the mode to ACCESS_SEQUENTIAL if you need to change mDuration and you would rather have the Dynamic

         * keep on smoothly interpolating.

         * On the other hand, in this mode, a Dynamic can only be accessed in sequential manner, which means one

         * Dynamic can only be used in one effect at a time.

         */

        const val ACCESS_TYPE_SEQUENTIAL: Int = 1

        private const val NUM_RATIO = 10 // we attempt to 'smooth out' the speed in each segment -

        // remember this many 'points' inside the Cache for each segment.

        protected val mTmpRatio: FloatArray = FloatArray(NUM_RATIO)

        private val mRnd = Random()

        private const val NUM_NOISE = 5 // used iff mNoise>0.0. Number of intermediary points between each pair of adjacent vectors

        private var mPausedTime: Long = 0

        @JvmStatic fun onPause() { mPausedTime = System.currentTimeMillis() }

    }

    var dimension: Int = 0

        protected set

    @get:Synchronized

    var numPoints: Int = 0

        protected set

    protected var mSegment: Int       = 0 // between which pair of points are we currently? (in case of PATH this is a bit complicated!)

    protected var cacheDirty: Boolean = false // VectorCache not up to date

    protected var mMode: Int          = 0 // LOOP, PATH or JUMP

    var duration: Long                = 0 // number of milliseconds it takes to do a full loop/path from first vector to the last and back to the first

    var count: Float                  = 0f // number of loops/paths we will do; mCount = 1.5 means we go from the first vector to the last, back to first, and to the last again.

    protected var mLastPos: Double    = 0.0

    protected var mAccessType: Int    = 0

    protected var mSpeedMode: Int     = 0

    protected var mTmpTime: Float     = 0f

    protected var mTmpVec: Int        = 0

    protected var mTmpSeg: Int        = 0

    var convexity: Float

        get() = mConvexity

        set(convexity)

        {

            if (mConvexity!=convexity)

            {

                mConvexity = convexity

                cacheDirty = true

            }

        }

    val speedMode: Float

        get() = mSpeedMode.toFloat()

    protected inner class VectorNoise

    internal constructor()

    {

        var n: Array<FloatArray> = Array(dimension) { FloatArray(NUM_NOISE) }

        fun computeNoise()

            n[0][0] = mRnd.nextFloat()

            for (i in 1..<NUM_NOISE) n[0][i] = n[0][i-1] + mRnd.nextFloat()

            val sum = n[0][NUM_NOISE-1] + mRnd.nextFloat()

            for (i in 0..<NUM_NOISE)

            {

                n[0][i] /= sum

                for (j in 1..<dimension) n[j][i] = mRnd.nextFloat()-0.5f

            }

    protected var vn: Vector<VectorNoise>? = null

    protected lateinit var mFactor: FloatArray

    protected lateinit var mNoise: FloatArray

    protected lateinit var baseV: Array<FloatArray>

    ///////////////////////////////////////////////////////////////////////////////////////////////

    // the coefficients of the X(t), Y(t) and Z(t) polynomials: X(t) = a[0]*T^3 + b[0]*T^2 + c[0]*t + d[0]  etc.

    // (velocity) is the velocity vector.

    // (cached) is the original vector from vv (copied here so when interpolating we can see if it is

    // still valid and if not - rebuild the Cache

    protected inner class VectorCache

    internal constructor()

        var a: FloatArray = FloatArray(dimension)

        var b: FloatArray = FloatArray(dimension)

        var c: FloatArray = FloatArray(dimension)

        var d: FloatArray = FloatArray(dimension)

        var velocity: FloatArray = FloatArray(dimension)

        var cached: FloatArray = FloatArray(dimension)

        var path_ratio: FloatArray = FloatArray(NUM_RATIO)

    protected var vc: Vector<VectorCache>? = null

    protected var mConvexity: Float = 0f

    private lateinit var buf: FloatArray

    private lateinit var old: FloatArray

    // where we randomize noise factors to make the way between the two vectors not so smooth.

    private var mStartTime: Long = 0

    private var mCorrectedTime: Long = 0

    protected constructor()

    ///////////////////////////////////////////////////////////////////////////////////////////////

    protected constructor(duration: Int, count: Float, dimension: Int)

        vc = Vector()

        vn = null

        numPoints = 0

        cacheDirty = false

        mMode = MODE_LOOP

        this.duration = duration.toLong()

        this.count = count

        this.dimension = dimension

        mSegment = -1

        mLastPos = -1.0

        mAccessType = ACCESS_TYPE_RANDOM

        mSpeedMode = SPEED_MODE_SMOOTH

        mConvexity = 1.0f

        mStartTime = -1

        mCorrectedTime = 0

        baseV = Array(this.dimension) { FloatArray(this.dimension) }

        buf = FloatArray(this.dimension)

        old = FloatArray(this.dimension)

    ///////////////////////////////////////////////////////////////////////////////////////////////

    fun initDynamic()

        mStartTime = -1

        mCorrectedTime = 0

    ///////////////////////////////////////////////////////////////////////////////////////////////

    protected fun computeSegmentAndTime(time: Float)

        when (mMode)

        {

            MODE_LOOP ->

                {

                    mTmpTime= time*numPoints

                    mTmpSeg = mTmpTime.toInt()

                    mTmpVec = mTmpSeg

                }

            MODE_PATH ->

                {

                    mTmpSeg = (2*time*(numPoints-1)).toInt()

                    if (time <= 0.5f)  // this has to be <= (otherwise when effect ends at t=0.5, then time=1.0

                    {                  // and end position is slightly not equal to the end point => might not get autodeleted!

                        mTmpTime = 2*time*(numPoints-1)

                        mTmpVec = mTmpSeg

                    }

                    else

                    {

                        mTmpTime = 2 * (1 - time) * (numPoints - 1)

                        mTmpVec = 2 * numPoints - 3 - mTmpSeg

                    }

                }

            MODE_JUMP ->

                {

                    mTmpTime = time*(numPoints-1)

                    mTmpSeg = mTmpTime.toInt()

                    mTmpVec = mTmpSeg

                }

            else ->

                {

                    mTmpVec = 0

                    mTmpSeg = 0

                }

        }

    ///////////////////////////////////////////////////////////////////////////////////////////////

    private fun valueAtPoint(t: Float, cache: VectorCache): Float

        var tmp: Float

        var sum = 0.0f

        for (d in 0..<dimension)

        {

            tmp = (3*cache.a[d]*t + 2*cache.b[d])*t + cache.c[d]

            sum += tmp*tmp

        }

        return sqrt(sum.toDouble()).toFloat()

    ///////////////////////////////////////////////////////////////////////////////////////////////

    protected fun smoothSpeed(time: Float, cache: VectorCache): Float

        val fndex = time*NUM_RATIO

        val index = fndex.toInt()

        val prev  = if (index==0) 0.0f else cache.path_ratio[index-1]

        val next  = cache.path_ratio[index]

        return prev + (next-prev) * (fndex-index)

    ///////////////////////////////////////////////////////////////////////////////////////////////

    // First, compute the approx length of the segment from time=0 to time=(i+1)/NUM_TIME and store this

    // in cache.path_ratio[i]. Then the last path_ratio is the length from 0 to 1, i.e. the total length

    // of the segment.

    // We do this by computing the integral from 0 to 1 of sqrt( (dx/dt)^2 + (dy/dt)^2 ) (i.e. the length

    // of the segment) using the approx 'trapezoids' integration method.

    //

    // Then, for every i, divide path_ratio[i] by the total length to get the percentage of total path

    // length covered at time i. At this time, path_ratio[3] = 0.45 means 'at time 3/NUM_RATIO, we cover

    // 0.45 = 45% of the total length of the segment.

    //

    // Finally, invert this function (for quicker lookups in smoothSpeed) so that after this step,

    // path_ratio[3] = 0.45 means 'at 45% of the time, we cover 3/NUM_RATIO distance'.

    protected fun smoothOutSegment(cache: VectorCache)

        var vPrev: Float

        var sum = 0.0f

        var vNext = valueAtPoint(0.0f,cache)

        for (i in 0..<NUM_RATIO)

        {

            vPrev = vNext

            vNext = valueAtPoint( (i+1).toFloat()/NUM_RATIO, cache )

            sum += (vPrev+vNext)

            cache.path_ratio[i] = sum

        }

        val total = cache.path_ratio[NUM_RATIO-1]

        for (i in 0..<NUM_RATIO) cache.path_ratio[i] /= total

        var writeIndex = 0

        var prev = 0.0f

        var next: Float

        var ratio = 1.0f/NUM_RATIO

        for (readIndex in 0..<NUM_RATIO)

            next = cache.path_ratio[readIndex]

            while (prev<ratio && ratio<=next)

            {

                val a = (next-ratio) / (next-prev)

                mTmpRatio[writeIndex] = (readIndex+1-a) / NUM_RATIO

                writeIndex++

                ratio = (writeIndex+1.0f) / NUM_RATIO

            }

            prev = next

        }

        System.arraycopy(mTmpRatio, 0, cache.path_ratio, 0, NUM_RATIO)

    ///////////////////////////////////////////////////////////////////////////////////////////////

    protected fun noise(time: Float, vecNum: Int): Float

        val lower: Float

        val upper: Float

        var len: Float

        val d = time*(NUM_NOISE+1)

        var index = d.toInt()

        if (index >= NUM_NOISE+1) index = NUM_NOISE

        val tmpN = vn!!.elementAt(vecNum)

        var t = d-index

        t = t*t*(3-2*t)

        when (index)

            0 ->

                {

                    var i = 0

                    while (i < dimension-1)

                    {

                        mFactor[i] = mNoise[i+1] * tmpN.n[i+1][0] * t

                        i++

                    }

                    return time + mNoise[0] * (d*tmpN.n[0][0]-time)

                }

            NUM_NOISE ->

                {

                    var i = 0

                    while (i < dimension - 1)

                    {

                        mFactor[i] = mNoise[i+1] * tmpN.n[i+1][NUM_NOISE-1] * (1-t)

                        i++

                    }

                    len = (NUM_NOISE.toFloat()) / (NUM_NOISE+1)

                    lower = len + mNoise[0] * (tmpN.n[0][NUM_NOISE-1] - len)

                    return (1.0f-lower) * (d-NUM_NOISE) + lower

                }

            else ->

                {

                    var ya: Float

                    var yb: Float

                    var i = 0

                    while (i < dimension-1)

                    {

                        yb = tmpN.n[i+1][index]

                        ya = tmpN.n[i+1][index-1]

                        mFactor[i] = mNoise[i+1] * ((yb-ya) * t+ya)

                        i++

                    }

                    len   = (index.toFloat()) / (NUM_NOISE+1)

                    lower = len + mNoise[0] * (tmpN.n[0][index-1] - len)

                    len   = (index.toFloat()+1) / (NUM_NOISE+1)

                    upper = len + mNoise[0] * (tmpN.n[0][index] - len)

                return (upper-lower)*(d-index) + lower

                }

    ///////////////////////////////////////////////////////////////////////////////////////////////

    // debugging only

    private fun printBase(str: String)

        var s: String

        var t: Float

        for (i in 0..<dimension)

            s = ""

            for (j in 0..<dimension)

            {

                t = ((1000*baseV[i][j]).toInt()) / (1000.0f)

                s += (" $t")

            }

            DistortedLibrary.logMessage("Dynamic: $str base $i : $s")

    ///////////////////////////////////////////////////////////////////////////////////////////////

    // debugging only

    @Suppress("unused")

    private fun checkBase()

        var tmp: Float

        var cosA: Float

        val len = FloatArray(dimension)

        var error = false

        for (i in 0..<dimension)

        {

            len[i] = 0.0f

            for (k in 0..<dimension) len[i] += baseV[i][k]*baseV[i][k]

            if (len[i]==0.0f || len[0]/len[i] < 0.95f || len[0]/len[i] > 1.05f)

            {

                DistortedLibrary.logMessage("Dynamic: length of vector $i : " + sqrt(len[i].toDouble()) )

                error = true

            }

        }

        for (i in 0..<dimension)

            for (j in i+1..<dimension)

            {

                tmp = 0.0f

                for (k in 0..<dimension) tmp += baseV[i][k]*baseV[j][k]

                cosA = (if (len[i]==0.0f || len[j]==0.0f) 0.0f else tmp / sqrt((len[i]*len[j]).toDouble()).toFloat())

                if (cosA>0.05f || cosA<-0.05f)

                {

                    DistortedLibrary.logMessage("Dynamic: cos angle between vectors $i and $j : $cosA")

                    error = true

                }

            }

        if (error) printBase("")

    ///////////////////////////////////////////////////////////////////////////////////////////////

    fun getNext(curr: Int, time: Float): Int

        return when (mMode)

        {

            MODE_LOOP -> if (curr == numPoints-1) 0        else curr+1

            MODE_PATH -> if (time < 0.5f        ) (curr+1) else (if (curr==0) 1 else curr-1)

            MODE_JUMP -> if (curr == numPoints-1) 1        else curr+1

            else      -> 0

        }

    ///////////////////////////////////////////////////////////////////////////////////////////////

    private fun checkAngle(index: Int)

        var cosA = 0.0f

        for (k in 0..<dimension) cosA += baseV[index][k]*old[k]

        if (cosA < 0.0f)

            for (j in 0..<dimension) baseV[index][j] = -baseV[index][j]

    ///////////////////////////////////////////////////////////////////////////////////////////////

    // helper function in case we are interpolating through exactly 2 points

    protected fun computeOrthonormalBase2(curr: Static, next: Static)

        when (dimension)

        {

            1 ->

                {

                    val curr1 = curr as Static1D

                    val next1 = next as Static1D

                    baseV[0][0] = (next1.x - curr1.x)

                }

            2 ->

                {

                    val curr2 = curr as Static2D

                    val next2 = next as Static2D

                    baseV[0][0] = (next2.x - curr2.x)

                    baseV[0][1] = (next2.y - curr2.y)

                }

            3 ->

                {

                    val curr3 = curr as Static3D

                    val next3 = next as Static3D

                    baseV[0][0] = (next3.x - curr3.x)

                    baseV[0][1] = (next3.y - curr3.y)

                    baseV[0][2] = (next3.z - curr3.z)

                }

            4 ->

                {

                    val curr4 = curr as Static4D

                    val next4 = next as Static4D

                    baseV[0][0] = (next4.x - curr4.x)

                    baseV[0][1] = (next4.y - curr4.y)

                    baseV[0][2] = (next4.z - curr4.z)

                    baseV[0][3] = (next4.w - curr4.w)

                }

            5 ->

                {

                    val curr5 = curr as Static5D

                    val next5 = next as Static5D

                    baseV[0][0] = (next5.x - curr5.x)

                    baseV[0][1] = (next5.y - curr5.y)

                    baseV[0][2] = (next5.z - curr5.z)

                    baseV[0][3] = (next5.w - curr5.w)

                    baseV[0][4] = (next5.v - curr5.v)

                }

            else -> throw RuntimeException("Unsupported dimension")

        }

        if (baseV[0][0] == 0.0f)

        {

            baseV[1][0] = 1.0f

            baseV[1][1] = 0.0f

        }

        else

        {

            baseV[1][0] = 0.0f

            baseV[1][1] = 1.0f

        }

        for (i in 2..<dimension) baseV[1][i] = 0.0f

        computeOrthonormalBase()

    ///////////////////////////////////////////////////////////////////////////////////////////////

    // helper function in case we are interpolating through more than 2 points

    protected fun computeOrthonormalBaseMore(time: Float, vc: VectorCache)

        for (i in 0..<dimension)

        {

            baseV[0][i] = (3*vc.a[i]*time + 2*vc.b[i])*time + vc.c[i] // first derivative, i.e. velocity vector

            old[i] = baseV[1][i]

            baseV[1][i] = 6*vc.a[i]*time + 2*vc.b[i] // second derivative,i.e. acceleration vector

        }

        computeOrthonormalBase()

    }

    ///////////////////////////////////////////////////////////////////////////////////////////////

    // When this function gets called, baseV[0] and baseV[1] should have been filled with two mDimension-al

    // vectors. This function then fills the rest of the baseV array with a mDimension-al Orthonormal base.

    // (mDimension-2 vectors, pairwise orthogonal to each other and to the original 2). The function always

    // leaves base[0] alone but generally speaking must adjust base[1] to make it orthogonal to base[0]!

    // The whole baseV is then used to compute Noise.

    //

    // When computing noise of a point travelling along a N-dimensional path, there are three cases:

    // a) we may be interpolating through 1 point, i.e. standing in place - nothing to do in this case

    // b) we may be interpolating through 2 points, i.e. travelling along a straight line between them -

    //    then pass the velocity vector in baseV[0] and anything linearly independent in base[1].

    //    The output will then be discontinuous in dimensions>2 (sad corollary from the Hairy Ball Theorem)

    //    but we don't care - we are travelling along a straight line, so velocity (aka baseV[0]!) does

    //    not change.

    // c) we may be interpolating through more than 2 points. Then interpolation formulas ensure the path

    //    will never be a straight line, even locally -> we can pass in baseV[0] and baseV[1] the velocity

    //    and the acceleration (first and second derivatives of the path) which are then guaranteed to be

    //    linearly independent. Then we can ensure this is continuous in dimensions <=4. This leaves

    //    dimension 5 (ATM WAVE is 5-dimensional) discontinuous -> WAVE will suffer from chaotic noise.

    //

    // Bear in mind here the 'normal' in 'orthonormal' means 'length equal to the length of the original

    // velocity vector' (rather than the standard 1)

    protected fun computeOrthonormalBase()

    {

        var lastnonzero = -1

        var tmp: Float

        for (i in 0..<dimension)

            if (baseV[0][i] != 0.0f) lastnonzero = i

        if (lastnonzero == -1)

        {                                   //  velocity is the 0 vector -> two

            for (i in 0..<dimension-1)    //  consecutive points we are interpolating

                for (j in 0..<dimension)  //  through are identical -> no noise,

                    baseV[i+1][j] = 0.0f    //  set the base to 0 vectors.

        }

        else

        {

            for (i in 1..<dimension)                                                             // One iteration computes baseV[i][*]

            {                                                                                      //  (aka b[i]), the i-th orthonormal vector.

                buf[i-1] = 0.0f                                                                    //

                                                                                                   //  We can use (modified!) Gram-Schmidt.

                for (k in 0..<dimension)                                                         //

                {                                                                                  //

                    if (i>=2)                                                                      //  b[0] = b[0]

                    {                                                                              //  b[1] = b[1] - (<b[1],b[0]>/<b[0],b[0]>)*b[0]

                        old[k] = baseV[i][k]                                                       //  b[2] = b[2] - (<b[2],b[0]>/<b[0],b[0]>)*b[0] - (<b[2],b[1]>/<b[1],b[1]>)*b[1]

                        baseV[i][k] = if (k== i - (if (lastnonzero >= i) 1 else 0)) 1.0f else 0.0f //  b[3] = b[3] - (<b[3],b[0]>/<b[0],b[0]>)*b[0] - (<b[3],b[1]>/<b[1],b[1]>)*b[1] - (<b[3],b[2]>/<b[2],b[2]>)*b[2]

                    }                                                                              //  (...)

                                                                                                   //  then b[i] = b[i] / |b[i]|  ( Here really b[i] = b[i] / (|b[0]|/|b[i]|)

                    tmp = baseV[i-1][k]                                                            //

                    buf[i-1] += tmp*tmp                                                            //

                }                                                                                  //

                                                                                                   //

                for (j in 0..<i)                                                                 //

                {                                                                                  //

                    tmp = 0.0f                                                                     //

                    for (k in 0..<dimension) tmp += baseV[i][k]*baseV[j][k]                      //

                    tmp /= buf[j]                                                                  //

                    for (k in 0..<dimension) baseV[i][k] -= tmp*baseV[j][k]                      //

                }                                                                                  //

                                                                                                   //

                checkAngle(i)                                                                      //

            }                                                                                      //

                                                                                                   // end compute baseV[i][*]

            buf[dimension-1] = 0.0f

                                                                                                   // Normalize

            for (k in 0..<dimension)                                                             //

            {                                                                                      //

                tmp = baseV[dimension-1][k]                                                        //

                buf[dimension-1] += tmp*tmp                                                        //

            }                                                                                      //

                                                                                                   //

            for (i in 1..<dimension)                                                             //

            {                                                                                      //

                tmp = sqrt((buf[0] / buf[i]).toDouble()).toFloat()                                 //

                for (k in 0..<dimension) baseV[i][k] *= tmp                                      //

            }                                                                                      // End Normalize

        }

    ///////////////////////////////////////////////////////////////////////////////////////////////

    abstract fun interpolate(buffer: FloatArray, offset: Int, tm: Float)

    ///////////////////////////////////////////////////////////////////////////////////////////////

    // PUBLIC API

    ///////////////////////////////////////////////////////////////////////////////////////////////

    /** Sets the mode of the interpolation to Loop, Path or Jump.

    *

    *  Loop is when we go from the first point all the way to the last, and the back to the first through the shortest way.

    *  Path is when we come back from the last point back to the first the same way we got there.

    *  Jump is when we go from first to last and then jump straight back to the first.

    *

    * @param mode [Dynamic.MODE_LOOP], [Dynamic.MODE_PATH] or [Dynamic.MODE_JUMP].

    */

    fun setMode(mode: Int) { mMode = mode }

    ///////////////////////////////////////////////////////////////////////////////////////////////

    /** Start running from the beginning again.

    *

    * If a Dynamic has been used already, and we want to use it again and start interpolating from the

    * first Point, first we need to reset it using this method.

    */

    fun resetToBeginning() { mStartTime = -1 }

    ///////////////////////////////////////////////////////////////////////////////////////////////

    /** Sets the access type this Dynamic will be working in.

    *

    * @param type [Dynamic.ACCESS_TYPE_RANDOM] or [Dynamic.ACCESS_TYPE_SEQUENTIAL].

    */

    fun setAccessType(type: Int)

    {

        mAccessType = type

        mLastPos = -1.0

    }

    ///////////////////////////////////////////////////////////////////////////////////////////////

    /** Sets the way we compute the interpolation speed.

    *

    * @param mode [Dynamic.SPEED_MODE_SMOOTH] or [Dynamic.SPEED_MODE_SEGMENT_CONSTANT] or

    * [Dynamic.SPEED_MODE_GLOBALLY_CONSTANT]

    */

    fun setSpeedMode(mode: Int)

    {

        if (mSpeedMode!=mode)

        {

            if (mSpeedMode==SPEED_MODE_SMOOTH)

                for (i in 0..<numPoints) smoothOutSegment(vc!!.elementAt(i))

            mSpeedMode = mode

        }