/*

* Copyright (c) 2003 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: KeyframeSequence implementation

*

*/

/*!

 * \internal

 * \file

 * \brief KeyframeSequence implementation

 */

#ifndef M3G_CORE_INCLUDE

#   error included by m3g_core.c; do not compile separately.

#endif

#include "m3g_keyframesequence.h"

#include "m3g_memory.h"

/*----------------------------------------------------------------------

 * Internal functions

 *--------------------------------------------------------------------*/

/*!

 * \internal

 * \brief Destroys this KeyframeSequence object.

 *

 * \param obj KeyframeSequence object

 */

static void m3gDestroyKeyframeSequence(Object *obj)

{

    KeyframeSequence *sequence = (KeyframeSequence *) obj;

    M3G_VALIDATE_OBJECT(sequence);

    {

        Interface *m3g = M3G_INTERFACE(sequence);

        m3gFree(m3g, sequence->keyframes);

        m3gFree(m3g, sequence->keyframeTimes);

        m3gFree(m3g, sequence->inTangents);

        m3gFree(m3g, sequence->outTangents);

        m3gFree(m3g, sequence->a);

        m3gFree(m3g, sequence->b);

    }

    m3gDestroyObject(&sequence->object);

}

/*!

 * \internal

 * \brief Overloaded Object3D method.

 *

 * \param originalObj original KeyframeSequence object

 * \param cloneObj pointer to cloned KeyframeSequence object

 * \param pairs array for all object-duplicate pairs

 * \param numPairs number of pairs

 */

static M3Gbool m3gKeyframeSequenceDuplicate(const Object *originalObj,

                                            Object **cloneObj,

                                            Object **pairs,

                                            M3Gint *numPairs)

{

    KeyframeSequence *original = (KeyframeSequence *)originalObj;

    KeyframeSequence *clone =

        (KeyframeSequence *)m3gCreateKeyframeSequence(originalObj->interface,

                                                      original->numKeyframes,

                                                      original->numComponents,

                                                      original->interpolation);

    *cloneObj = (Object *)clone;

    if (*cloneObj == NULL) {

        return M3G_FALSE;

    }

    if(m3gObjectDuplicate(originalObj, cloneObj, pairs, numPairs)) {

        M3Gsizei n = original->numKeyframes * original->numComponents;

        m3gCopy(clone->keyframes, original->keyframes, n * sizeof(M3Gfloat));

        m3gCopy(clone->keyframeTimes, original->keyframeTimes, original->numKeyframes * sizeof(M3Gint));

        if (original->dirty == M3G_FALSE) {

            if (original->inTangents) {

                m3gCopy(clone->inTangents, original->inTangents, n * sizeof(M3Gfloat));

                m3gCopy(clone->outTangents, original->outTangents, n * sizeof(M3Gfloat));

            }

            if (original->a) {

                m3gCopy(clone->a, original->a, original->numKeyframes * sizeof(Quat));

                m3gCopy(clone->b, original->b, original->numKeyframes * sizeof(Quat));

            }

        }

        else {

            clone->dirty = M3G_TRUE;

        }

        clone->duration = original->duration;

        clone->closed = original->closed;

        clone->firstValid = original->firstValid;

        clone->lastValid = original->lastValid;

        return M3G_TRUE;

    }

    else {

        return M3G_FALSE;

    }

}

/*!

 * \internal

 * \brief Initializes a KeyframeSequence object. See specification

 * for default values.

 *

 * \param m3g                   M3G interface

 * \param sequence              KeyframeSequence object

 * \param numKeyframes          number of keyframes

 * \param numComponents         number of components

 * \param interpolation         interpolation type

 * \retval                      KeyframeSequence initialized KeyframeSequence object

 * \retval                      NULL initialization failed

 */

static KeyframeSequence *m3gInitKeyframeSequence(Interface *m3g,

                                                 KeyframeSequence *sequence,

                                                 M3Gint numKeyframes,

                                                 M3Gint numComponents,

                                                 M3Gint interpolation)

{

    m3gInitObject(&sequence->object, m3g, M3G_CLASS_KEYFRAME_SEQUENCE);

    /* Set keyframe parameters */

    sequence->numKeyframes = numKeyframes;

    sequence->numComponents = numComponents;

    sequence->interpolation = interpolation;

    sequence->lastValid = numKeyframes - 1; /* firstValid defaults to 0 */

    /* Allocate keyframe and tangent data */

    {    

        M3Gsizei n = numKeyframes * numComponents;

        sequence->keyframes = (M3Gfloat *)m3gAllocZ(m3g, n * sizeof(M3Gfloat));

        if (sequence->keyframes == NULL) {

            goto AllocFailed;

        }

        sequence->keyframeTimes = (M3Gint *)m3gAllocZ(m3g, numKeyframes * sizeof(M3Gint));

        if (sequence->keyframeTimes == NULL) {

            goto AllocFailed;

        }

        if (interpolation == M3G_SPLINE) {

            sequence->inTangents  = (M3Gfloat *)m3gAllocZ(m3g, n * sizeof(M3Gfloat));

            sequence->outTangents = (M3Gfloat *)m3gAllocZ(m3g, n * sizeof(M3Gfloat));

            if (sequence->inTangents == NULL || sequence->outTangents == NULL) {

                goto AllocFailed;

            }

        }

        else if (interpolation == M3G_SQUAD) {

            sequence->a = (Quat *)m3gAlloc(m3g, numKeyframes * sizeof(Quat));

            sequence->b = (Quat *)m3gAlloc(m3g, numKeyframes * sizeof(Quat));

            if (sequence->a == NULL || sequence->b == NULL) {

                goto AllocFailed;

            }

        }

        /* Success; just make a note that the data is not valid yet */

        sequence->dirty = M3G_TRUE;

        return sequence;

AllocFailed:

        /* The destructor contains exactly the code we need for this,

         * so just call that */

        m3gDestroyKeyframeSequence((Object*) sequence);

        return NULL;

    }

}

/*!

 * \internal

 * \brief Checks the validity of keyframe timings

 *

 * \param sequence   KeyframeSequence object

 * \retval M3G_TRUE  sequence valid

 * \retval M3G_FALSE sequence invalid

 */

static M3Gbool m3gValidSequence(const KeyframeSequence *sequence)

{    

    const M3Gint last = sequence->lastValid;

    M3Gint current = sequence->firstValid;

    while (current != last) {

        M3Gint next = (current < sequence->numKeyframes-1) ? current + 1 : 0;

        if (sequence->keyframeTimes[next] < sequence->keyframeTimes[current]) {

            return M3G_FALSE;

        }

        current = next;

    }

    return (sequence->keyframeTimes[last] <= sequence->duration);

}

/*!

 * \internal

 * \brief Get number of components

 *

 * \param sequence   KeyframeSequence object

 * \return number of components

 */

static M3Gint m3gGetNumComponents(const KeyframeSequence *sequence)

{

    return sequence->numComponents;

}

/*!

 * \internal

 * \brief Get next keyframe index

 *

 * \param sequence  KeyframeSequence object

 * \param ind       current index

 * \return next index

 */

static M3Gint m3gNextKeyframeIndex(const KeyframeSequence *sequence, M3Gint ind)

{

    if (ind == sequence->lastValid) {

        return sequence->firstValid;

    }

    else if (ind == sequence->numKeyframes - 1) {

        return 0;

    }

    else {

        return (ind + 1);

    }

}

/*!

 * \internal

 * \brief Get previous keyframe index

 *

 * \param sequence  KeyframeSequence object

 * \param ind       current index

 * \return previous index

 */

static M3Gint m3gPreviousKeyframeIndex(const KeyframeSequence *sequence, M3Gint ind)

{

    if (ind == sequence->firstValid) {

        return sequence->lastValid;

    }

    else if (ind == 0) {

        return (sequence->numKeyframes - 1);

    }

    else {

        return (ind - 1);

    }

}

/*!

 * \internal

 * \brief Get keyframe at index

 *

 * \param seq       KeyframeSequence object

 * \param idx       keyframe index

 * \return keyframe value

 */

static M3G_INLINE const M3Gfloat *m3gKeyframeAt(const KeyframeSequence *seq, M3Gint idx)

{

    return seq->keyframes + idx * seq->numComponents;

}

/*!

 * \internal

 * \brief Get keyframe at index -1

 *

 * \param seq       KeyframeSequence object

 * \param idx       keyframe index

 * \return keyframe value

 */

static M3G_INLINE const M3Gfloat *m3gKeyframeBefore(const KeyframeSequence *seq, M3Gint idx)

{

    return m3gKeyframeAt(seq, m3gPreviousKeyframeIndex(seq, idx));

}

/*!

 * \internal

 * \brief Get keyframe at index + 1

 *

 * \param seq       KeyframeSequence object

 * \param idx       keyframe index

 * \return keyframe value

 */

static M3G_INLINE const M3Gfloat *m3gKeyframeAfter(const KeyframeSequence *seq, M3Gint idx)

{

    return m3gKeyframeAt(seq, m3gNextKeyframeIndex(seq, idx));

}

/*!

 * \internal

 * \brief Get tangent to index

 *

 * \param seq       KeyframeSequence object

 * \param idx       keyframe index

 * \return tangent value

 */

static M3G_INLINE const M3Gfloat *m3gTangentTo(const KeyframeSequence *seq, M3Gint idx)

{

    M3G_ASSERT(seq->inTangents != NULL);

    return seq->inTangents + idx * seq->numComponents;

}

/*!

 * \internal

 * \brief Get tangent from index

 *

 * \param seq       KeyframeSequence object

 * \param idx       keyframe index

 * \return tangent value

 */

static M3G_INLINE const M3Gfloat *m3gTangentFrom(const KeyframeSequence *seq, M3Gint idx)

{

    M3G_ASSERT(seq->outTangents != NULL);

    return seq->outTangents + idx * seq->numComponents;

}

/*!

 * \internal

 * \brief Get time delta

 *

 * \param sequence  KeyframeSequence object

 * \param ind       keyframe index

 * \return time delta

 */

static M3Gint m3gTimeDelta(const KeyframeSequence *sequence, M3Gint ind)

{

    if (ind == sequence->lastValid) {

        return

            (sequence->duration

             - sequence->keyframeTimes[sequence->lastValid])

            + sequence->keyframeTimes[sequence->firstValid];

    }

    return sequence->keyframeTimes[m3gNextKeyframeIndex(sequence, ind)]

        - sequence->keyframeTimes[ind];

}

/*!

 * \internal

 * \brief Get incoming tangent scale

 *

 * \param sequence  KeyframeSequence object

 * \param ind       keyframe index

 * \return tangent scale

 */

static M3Gfloat m3gIncomingTangentScale(const KeyframeSequence *sequence,

                                        M3Gint ind)

{

    if (!sequence->closed

        && (ind == sequence->firstValid || ind == sequence->lastValid)) {

        return 0;

    }

    else {

        M3Gint prevind = m3gPreviousKeyframeIndex(sequence, ind);

        return m3gDiv(m3gMul(2.0f, (M3Gfloat) m3gTimeDelta(sequence, prevind)),

                      (M3Gfloat)(m3gTimeDelta(sequence, ind)

                                 + m3gTimeDelta(sequence, prevind)));

    }

}

/*!

 * \internal

 * \brief Get outgoing tangent scale

 *

 * \param sequence  KeyframeSequence object

 * \param ind       keyframe index

 * \return tangent scale

 */

static M3Gfloat m3gOutgoingTangentScale(const KeyframeSequence *sequence,

                                        M3Gint ind)

{

    if (!sequence->closed

        && (ind == sequence->firstValid || ind == sequence->lastValid)) {

        return 0;

    }

    else {

        M3Gint prevind = m3gPreviousKeyframeIndex(sequence, ind);

        return m3gDiv(m3gMul(2.0f, (M3Gfloat) m3gTimeDelta(sequence, ind)),

                      (M3Gfloat)(m3gTimeDelta(sequence, ind)

                                 + m3gTimeDelta(sequence, prevind)));

    }

}

/*!

 * \internal

 * \brief Precalculate all tangents

 *

 * \param sequence  KeyframeSequence object

 */

static void m3gPrecalculateTangents(KeyframeSequence *sequence)

{

    M3Gint i, kf = sequence->firstValid;

    do {

        const M3Gfloat *prev = m3gKeyframeBefore(sequence, kf);

        const M3Gfloat *next = m3gKeyframeAfter(sequence, kf);

        const M3Gfloat sIn  = m3gIncomingTangentScale(sequence, kf);

        const M3Gfloat sOut = m3gOutgoingTangentScale(sequence, kf);

        M3Gfloat *in  = (M3Gfloat *) m3gTangentTo(sequence, kf);

        M3Gfloat *out = (M3Gfloat *) m3gTangentFrom(sequence, kf);        

        for (i = 0; i < sequence->numComponents; ++i) {

            in[i]  = m3gMul(m3gMul(0.5f, (m3gSub(next[i], prev[i]))), sIn);

            out[i] = m3gMul(m3gMul(0.5f, (m3gSub(next[i], prev[i]))), sOut);

        }

        kf = m3gNextKeyframeIndex(sequence, kf);

    } while (kf != sequence->firstValid);

}

/*!

 * \internal

 * \brief Precalculate A and B

 *

 * \param sequence  KeyframeSequence object

 */

static void m3gPrecalculateAB(KeyframeSequence *sequence)

{

    Quat start, end, prev, next;

    Vec3 tangent, cfd;

    M3Gfloat temp[4]; /* used for both quats and vectors */

    M3Gint kf = sequence->firstValid;

    do {

        m3gSetQuat(&prev, m3gKeyframeBefore(sequence, kf));

        m3gSetQuat(&start, m3gKeyframeAt(sequence, kf));

        m3gSetQuat(&end, m3gKeyframeAfter(sequence, kf));

        m3gSetQuat(&next, m3gKeyframeAfter(sequence, m3gNextKeyframeIndex(sequence, kf)));

        /* Compute the centered finite difference at this

           keyframe; note that this would be the tangent for basic

           Catmull-Rom interpolation. */

        m3gLogDiffQuat(&cfd, &start, &end);

        m3gLogDiffQuat((Vec3*)temp, &prev, &start);

        m3gAddVec3(&cfd, (Vec3*)temp);

        m3gScaleVec3(&cfd, 0.5f);

        /* Compute the outgoing tangent, scaled to compensate for

           keyframe timing, then compute the "A" intermediate

           quaternion. */

        tangent = cfd;

        m3gScaleVec3(&tangent, m3gOutgoingTangentScale(sequence, kf));

        m3gLogDiffQuat((Vec3*)temp, &start, &end);

        m3gSubVec3(&tangent, (Vec3*)temp);

        m3gScaleVec3(&tangent, 0.5f);

        m3gExpQuat((Quat*)temp, &tangent);

        sequence->a[kf] = start;

        m3gMulQuat(&(sequence->a[kf]), (Quat*)temp);

        /* Then repeat the same steps for the incoming tangent and

           the "B" intermediate quaternion. */

        tangent = cfd;

        m3gScaleVec3(&tangent, m3gIncomingTangentScale(sequence, kf));

        m3gLogDiffQuat((Vec3*)temp, &prev, &start);

        m3gSubVec3((Vec3*)temp, &tangent);

        m3gScaleVec3((Vec3*)temp, 0.5f);

        m3gExpQuat((Quat*)temp, (Vec3*)temp);

        sequence->b[kf] = start;

        m3gMulQuat(&(sequence->b[kf]), (Quat*)temp);

        kf = m3gNextKeyframeIndex(sequence, kf);

    } while (kf != sequence->firstValid);

}

/*!

 * \internal

 * \brief Update all tangents

 *

 * \param sequence  KeyframeSequence object

 */

static void m3gUpdateTangents(KeyframeSequence *sequence)

{

    if (sequence->interpolation == M3G_SPLINE) {

        m3gPrecalculateTangents(sequence);

    }

    else if (sequence->interpolation == M3G_SQUAD) {

        m3gPrecalculateAB(sequence);

    }

}

/*!

 * \internal

 * \brief Linear interpolate

 *

 * \param sequence      KeyframeSequence object

 * \param sample        input samples

 * \param s             speed

 * \param startIndex    start index

 * \param endIndex      end index

 */

static M3G_INLINE void m3gLerpSample(const KeyframeSequence *sequence,

                                     M3Gfloat *sample,

                                     M3Gfloat s,

                                     M3Gint startIndex, M3Gint endIndex)

{

    const M3Gfloat *start = m3gKeyframeAt(sequence, startIndex);

    const M3Gfloat *end   = m3gKeyframeAt(sequence, endIndex);

    m3gLerp(sequence->numComponents, sample, s, start, end);

}

/*!

 * \internal

 * \brief Spline interpolate

 *

 * \param sequence      KeyframeSequence object

 * \param sample        input samples

 * \param s             speed

 * \param startIndex    start index

 * \param endIndex      end index

 */

static M3G_INLINE void m3gSplineSample(const KeyframeSequence *sequence,

                                       M3Gfloat *sample,