/*

* 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: AnimationTrack implementation

*

*/

/*!

 * \internal

 * \file

 * \brief AnimationTrack implementation

 */

#ifndef M3G_CORE_INCLUDE

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

#endif

#include "m3g_animationtrack.h"

#include "m3g_keyframesequence.h"

#include "m3g_memory.h"

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

 * Internal functions

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

/*!

 * \internal

 * \brief Destroys this AnimationTrack object.

 *

 * \param obj AnimationTrack object

 */

static void m3gDestroyAnimationTrack(Object *obj)

{

    AnimationTrack *animTrack = (AnimationTrack *) obj;

    M3G_VALIDATE_OBJECT(animTrack);

    M3G_ASSIGN_REF(animTrack->sequence,   NULL);

    M3G_ASSIGN_REF(animTrack->controller, NULL);

    m3gDestroyObject(&animTrack->object);

}

/*!

 * \internal

 * \brief Calculates animation track contribution.

 *

 * \param track AnimationTrack object

 * \param time current world time

 * \param accumSamples accumulated samples

 * \param sampleInfo sample information

 */

static void m3gGetContribution(const AnimationTrack *track, M3Gint time,

                               M3Gfloat *accumSamples, SampleInfo *sampleInfo)

{

    if (track->controller == NULL || !m3gIsActive(track->controller, time)) {

        sampleInfo->weight = 0;

        sampleInfo->validity = (track->controller ?

                                m3gTimeToActivation(track->controller, time) :

                                0x7FFFFFFF);

        if (sampleInfo->validity < 1)

            sampleInfo->validity = 1;

        return;

    }

    {

        M3Gfloat stackSampleVector[4];

        Interface *m3g = M3G_INTERFACE(track);

        M3Gint i, sampleTime, sampleValidity;

        M3Gfloat weight;

        M3Gint sampleLength = m3gGetNumComponents(track->sequence);

        M3Gfloat *sample;

        /* Before sampling, make sure that this track has some effect

         * on the end result */

        weight = m3gGetWeight(track->controller);

        sampleInfo->weight = weight;

        if (weight <= 0.0f) {

            sampleInfo->validity = 0x7FFFFFFF;

            return;

        }

        /* We use the stack-allocated sample vector by default, but

         * the MORPH_WEIGHTS target may have more than 4 components,

         * in which case we resort to the global temp vector. This

         * means that the temp vector can not be used in the keyframe

         * sampling code, but it doesn't seem likely that it would be

         * needed there. */

        if (sampleLength > 4) {

            sample = (M3Gfloat*) m3gAllocTemp(m3g, (M3Gsize) sampleLength * sizeof(M3Gfloat));

            if (!sample) {

                sampleInfo->validity = 0;

                return; /* automatic out-of-memory error */

            }

        }

        else {

            sample = stackSampleVector;

        }

        sampleTime = m3gRoundToInt(m3gGetPosition(track->controller, time));

        sampleValidity = m3gGetSample(track->sequence, sampleTime, sample);

        sampleInfo->validity = sampleValidity;

        /* Only bother if there was no error in GetSample... */

        if (sampleValidity > 0) {

            /* Resolve the validity time of the sample */

            sampleValidity = m3gTimeToDeactivation(track->controller, time);

            if (sampleValidity < sampleInfo->validity) {

                sampleInfo->validity = sampleValidity;

            }

            /* Add the weighted sample to the accumulated value

             * and return */

            for (i = 0; i < sampleLength; ++i) {

                accumSamples[i] = m3gAdd(accumSamples[i],

                                         m3gMul(sample[i], weight));

            }

        }

        if (sample != stackSampleVector) {

            m3gFreeTemp(m3g);

        }

    }

}

/*!

 * \internal

 * \brief Checks animation property size.

 *

 * \param m3g M3G interface

 * \param property animation property

 * \param numComponents number of components

 * \retval M3G_TRUE valid size for property

 * \retval M3G_FALSE invalid size for property

 */

static M3Gbool m3gIsValidSize(Interface *m3g, M3Gint property, M3Gint numComponents)

{

    switch (property) {

    case M3G_ANIM_ALPHA:

    case M3G_ANIM_DENSITY:

    case M3G_ANIM_FAR_DISTANCE:

    case M3G_ANIM_FIELD_OF_VIEW:

    case M3G_ANIM_INTENSITY:

    case M3G_ANIM_NEAR_DISTANCE:

    case M3G_ANIM_PICKABILITY:

    case M3G_ANIM_SHININESS:

    case M3G_ANIM_SPOT_ANGLE:

    case M3G_ANIM_SPOT_EXPONENT:

    case M3G_ANIM_VISIBILITY:

        return (numComponents == 1);

    case M3G_ANIM_CROP:

        return (numComponents == 2 || numComponents == 4);

    case M3G_ANIM_COLOR:

    case M3G_ANIM_AMBIENT_COLOR:

    case M3G_ANIM_DIFFUSE_COLOR:

    case M3G_ANIM_EMISSIVE_COLOR:

    case M3G_ANIM_SPECULAR_COLOR:

        return (numComponents == 3);

    case M3G_ANIM_TRANSLATION:

        return (numComponents == 3);

    case M3G_ANIM_ORIENTATION:

        return (numComponents == 4);

    case M3G_ANIM_SCALE:

        return (numComponents == 1 || numComponents == 3);

    case M3G_ANIM_MORPH_WEIGHTS:

        return (numComponents > 0);

    default:

        m3gRaiseError(m3g, M3G_INVALID_ENUM);

    }

    return M3G_FALSE;

}

/*!

 * \internal

 * \brief Overloaded Object3D method.

 *

 * \param self AnimationTrack object

 * \param references array of reference objects

 * \return number of references

 */

static M3Gint m3gAnimationTrackDoGetReferences(Object *self, Object **references)

{

    AnimationTrack *track = (AnimationTrack *) self;

    M3Gint num = m3gObjectDoGetReferences(self, references);

    if (track->sequence != NULL) {

        if (references != NULL)

            references[num] = (Object *)track->sequence;

        num++;

    }

    if (track->controller != NULL) {

        if (references != NULL)

            references[num] = (Object *)track->controller;

        num++;

    }

    return num;

}

/*!

 * \internal

 * \brief Overloaded Object3D method

 */

static Object *m3gAnimationTrackFindID(Object *self, M3Gint userID)

{

    AnimationTrack *track = (AnimationTrack *) self;

    Object *found = m3gObjectFindID(self, userID);

    if (!found && track->sequence != NULL) {

        found = m3gFindID((Object*) track->sequence, userID);

    }

    if (!found && track->controller != NULL) {

        found = m3gFindID((Object*) track->controller, userID);

    }

    return found;

}

/*!

 * \internal

 * \brief Overloaded Object3D method.

 *

 * \param originalObj original AnimationTrack object

 * \param cloneObj pointer to cloned AnimationTrack object

 * \param pairs array for all object-duplicate pairs

 * \param numPairs number of pairs

 */

static M3Gbool m3gAnimationTrackDuplicate(const Object *originalObj,

                                          Object **cloneObj,

                                          Object **pairs,

                                          M3Gint *numPairs)

{

    AnimationTrack *original = (AnimationTrack *)originalObj;

    AnimationTrack *clone =

        (AnimationTrack *)m3gCreateAnimationTrack(originalObj->interface,

                                                  original->sequence,

                                                  original->property);

    *cloneObj = (Object *)clone;

    if (*cloneObj == NULL) {

        return M3G_FALSE;

    }

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

        M3G_ASSIGN_REF(clone->controller, original->controller);

        return M3G_TRUE;

    }

    else {

        return M3G_FALSE;

    }

}

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

 * Virtual function table

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

static const ObjectVFTable m3gvf_AnimationTrack = {

    m3gObjectApplyAnimation,

    m3gObjectIsCompatible,

    m3gObjectUpdateProperty,

    m3gAnimationTrackDoGetReferences,

    m3gAnimationTrackFindID,

    m3gAnimationTrackDuplicate,

    m3gDestroyAnimationTrack

};

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

 * Public API functions

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

/*!

 * \brief Creates a new AnimationTrack with default values

 *

 * \param hInterface            M3G interface

 * \param hSequence             KeyframeSequence object

 * \param property              target animation property

 * \retval AnimationTrack new AnimationTrack object

 * \retval NULL AnimationTrack creating failed

 */

M3G_API M3GAnimationTrack m3gCreateAnimationTrack(M3GInterface hInterface,

                                                  M3GKeyframeSequence hSequence,

                                                  M3Gint property)

{

    KeyframeSequence *sequence = (KeyframeSequence *)hSequence;

    Interface *m3g = (Interface *) hInterface;

    M3G_VALIDATE_INTERFACE(m3g);

    /* Check for invalid arguments */

    if (sequence == NULL) {

        m3gRaiseError(m3g, M3G_NULL_POINTER);

        return NULL;

    }

    if (property < M3G_ANIM_ALPHA || property > M3G_ANIM_VISIBILITY) {

        m3gRaiseError(m3g, M3G_INVALID_ENUM);

        return NULL;

    }

    if (!m3gIsValidSize(m3g, property, m3gGetNumComponents(sequence))) {

        m3gRaiseError(m3g, M3G_INVALID_VALUE);

        return NULL;

    }

    /* Allocate and initialize the object */

    {

        AnimationTrack *track = m3gAllocZ(m3g, sizeof(AnimationTrack));

        if (track != NULL) {

            M3G_ASSIGN_REF(track->sequence, sequence);

            track->property = property;

            m3gInitObject(&track->object, m3g, M3G_CLASS_ANIMATION_TRACK);

        }

        return track;

    }

}

/*!

 * \brief Get animation controller.

 *

 * \param hTrack                AnimationTrack object

 * \retval                      AnimationController object

 */

M3G_API M3GAnimationController m3gGetController(M3GAnimationTrack hTrack)

{

    AnimationTrack *track = (AnimationTrack *) hTrack;

    M3G_VALIDATE_OBJECT(track);

    return track->controller;

}

/*!

 * \brief Get key frame sequence.

 *

 * \param hTrack                AnimationTrack object

 * \retval                      KeyframeSequence object

 */

M3G_API M3GKeyframeSequence m3gGetSequence(M3GAnimationTrack hTrack)

{

    AnimationTrack *track = (AnimationTrack *) hTrack;

    M3G_VALIDATE_OBJECT(track);

    return track->sequence;

}

/*!

 * \brief Get animation target property.

 *

 * \param hTrack                AnimationTrack object

 * \retval                      target property

 */

M3G_API M3Gint m3gGetTargetProperty(M3GAnimationTrack hTrack)

{

    AnimationTrack *track = (AnimationTrack *) hTrack;

    M3G_VALIDATE_OBJECT(track);

    return track->property;

}

/*!

 * \brief Set animation controller.

 *

 * \param hTrack                AnimationTrack object

 * \param hController           AnimationController object

 */

M3G_API void m3gSetController(M3GAnimationTrack hTrack,

                              M3GAnimationController hController)

{

    AnimationTrack *track = (AnimationTrack *) hTrack;

    M3G_VALIDATE_OBJECT(track);

    M3G_ASSIGN_REF(track->controller, hController);

}