/*
* 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);
}