/*
* 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: AnimationController implementation
*
*/


/*!
 * \internal
 * \file
 * \brief AnimationController implementation
 */

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

#include "m3g_animationcontroller.h"
#include "m3g_memory.h"


/*----------------------------------------------------------------------
 * Internal functions
 *--------------------------------------------------------------------*/

/*!
 * \internal
 * \brief Destroys this AnimationController object.
 *
 * \param obj AnimationController object
 */
static void m3gDestroyAnimationController(Object *obj)
{
    AnimationController *animController = (AnimationController *) obj;
    M3G_VALIDATE_OBJECT(animController);

    m3gDestroyObject(&animController->object);
}

/*!
 * \internal
 * \brief Check if controller is active.
 *
 * \param controller AnimationController object
 * \param worldTime current world time
 * \retval M3G_TRUE controller active
 * \retval M3G_FALSE controller not active
 */
static M3Gbool m3gIsActive(const AnimationController *controller,
                        M3Gint worldTime)
{
    if (controller->activationTime == controller->deactivationTime) {
        return M3G_TRUE;
    }
    return (worldTime >= controller->activationTime &&
            worldTime < controller->deactivationTime);
}

/*!
 * \internal
 * \brief Gets time to controller activation.
 *
 * \param controller AnimationController object
 * \param worldTime current world time
 * \return time to controller activation
 */
static M3Gint m3gTimeToActivation(const AnimationController *controller,
                               M3Gint worldTime)
{
    if (worldTime < controller->activationTime) {
        return (controller->activationTime - worldTime);
    }
    else if (worldTime < controller->deactivationTime) {
        return 0;
    }
    return 0x7FFFFFFF;
}

/*!
 * \internal
 * \brief Gets time to controller deactivation.
 *
 * \param controller AnimationController object
 * \param worldTime current world time
 * \return time to controller deactivation
 */
static M3Gint m3gTimeToDeactivation(const AnimationController *controller,
                                 M3Gint worldTime)
{
    if (worldTime < controller->deactivationTime) {
        return (controller->deactivationTime - worldTime);
    }
    return 0x7FFFFFFF;
}

/*!
 * \internal
 * \brief Overloaded Object3D method.
 *
 * \param originalObj original AnimationController object
 * \param cloneObj pointer to cloned AnimationController object
 * \param pairs array for all object-duplicate pairs
 * \param numPairs number of pairs
 */
static M3Gbool m3gAnimationControllerDuplicate(const Object *originalObj,
                                               Object **cloneObj,
                                               Object **pairs,
                                               M3Gint *numPairs)
{
    const AnimationController *original = (AnimationController *)originalObj;
    AnimationController *clone =
        m3gCreateAnimationController(originalObj->interface);
    *cloneObj = (Object *)clone;
    if (*cloneObj == NULL) {
        return M3G_FALSE;
    }

    if (m3gObjectDuplicate(originalObj, cloneObj, pairs, numPairs)) {
        clone->activationTime = original->activationTime;
        clone->deactivationTime = original->deactivationTime;
        clone->weight = original->weight;
        clone->speed = original->speed;
        clone->refWorldTime = original->refWorldTime;
        clone->refSequenceTime = original->refSequenceTime;
        return M3G_TRUE;
    }
    else {
        return M3G_FALSE;
    }
}

/*----------------------------------------------------------------------
 * Virtual function table
 *--------------------------------------------------------------------*/

static const ObjectVFTable m3gvf_AnimationController = {
    m3gObjectApplyAnimation,
    m3gObjectIsCompatible,
    m3gObjectUpdateProperty,
    m3gObjectDoGetReferences,
    m3gObjectFindID,
    m3gAnimationControllerDuplicate,
    m3gDestroyAnimationController
};


/*----------------------------------------------------------------------
 * Public API functions
 *--------------------------------------------------------------------*/

/*!
 * \brief Creates a new AnimationController with default values
 *
 * \param hInterface    M3G interface
 * \retval AnimationController new AnimationController object
 * \retval NULL AnimationController creating failed
 */
M3G_API M3GAnimationController m3gCreateAnimationController(
    M3GInterface hInterface)
{
    Interface *m3g = (Interface *) hInterface;
    M3G_VALIDATE_INTERFACE(m3g);
    {
        AnimationController *controller = m3gAllocZ(m3g, sizeof(AnimationController));

        if (controller != NULL) {
            m3gInitObject(&controller->object, m3g,
                          M3G_CLASS_ANIMATION_CONTROLLER);
            controller->weight = 1;
            controller->speed = 1.0f;
        }

        return (M3GAnimationController) controller;
    }
}

/*!
 * \brief Set active interval.
 *
 * \param hController AnimationController object
 * \param worldTimeMin active interval start
 * \param worldTimeMax active interval end
 */
M3G_API void m3gSetActiveInterval(M3GAnimationController hController,
                                  M3Gint worldTimeMin,
                                  M3Gint worldTimeMax)
{
    AnimationController *controller = (AnimationController *) hController;
    M3G_VALIDATE_OBJECT(controller);

    if (worldTimeMin > worldTimeMax) {
        m3gRaiseError(M3G_INTERFACE(controller), M3G_INVALID_VALUE);
        return;
    }
    controller->activationTime   = worldTimeMin;
    controller->deactivationTime = worldTimeMax;
}

/*!
 * \brief Get active interval start.
 *
 * \param hController AnimationController object
 * \return active interval start
 */
M3G_API M3Gint m3gGetActiveIntervalStart(M3GAnimationController hController)
{
    AnimationController *controller = (AnimationController *) hController;
    M3G_VALIDATE_OBJECT(controller);

    return controller->activationTime;
}

/*!
 * \brief Get active interval end.
 *
 * \param hController AnimationController object
 * \return active interval end
 */
M3G_API M3Gint m3gGetActiveIntervalEnd(M3GAnimationController hController)
{
    AnimationController *controller = (AnimationController *) hController;
    M3G_VALIDATE_OBJECT(controller);

    return controller->deactivationTime;
}

/*!
 * \brief Set speed.
 *
 * \param hController   AnimationController object
 * \param factor        speed factor
 * \param worldTime     reference world time
 */
M3G_API void m3gSetSpeed(M3GAnimationController hController,
                         M3Gfloat factor, M3Gint worldTime)
{
    AnimationController *controller = (AnimationController *) hController;
    M3G_VALIDATE_OBJECT(controller);

    controller->refSequenceTime = m3gGetPosition(controller, worldTime);
    controller->refWorldTime = worldTime;
    controller->speed = factor;
}

/*!
 * \brief Get speed.
 *
 * \param hController   AnimationController object
 * \return              speed factor
 */
M3G_API M3Gfloat m3gGetSpeed(M3GAnimationController hController)
{
    AnimationController *controller = (AnimationController *) hController;
    M3G_VALIDATE_OBJECT(controller);

    return controller->speed;
}

/*!
 * \brief Set position.
 *
 * \param hController   AnimationController object
 * \param sequenceTime  sequence time
 * \param worldTime     world time
 */
M3G_API void m3gSetPosition(M3GAnimationController hController,
                            M3Gfloat sequenceTime, M3Gint worldTime)
{
    AnimationController *controller = (AnimationController *) hController;
    M3G_VALIDATE_OBJECT(controller);

    controller->refWorldTime = worldTime;
    controller->refSequenceTime = sequenceTime;
}

/*!
 * \brief Get position.
 *
 * \param hController   AnimationController object
 * \param worldTime     current world time
 * \retrun              position
 */
M3G_API M3Gfloat m3gGetPosition(M3GAnimationController hController, M3Gint worldTime)
{
    AnimationController *controller = (AnimationController *) hController;
    M3G_VALIDATE_OBJECT(controller);

    return m3gAdd(controller->refSequenceTime,
                  m3gMul(controller->speed, (M3Gfloat) worldTime - controller->refWorldTime));
}


/*!
 * \brief Set controller weight.
 *
 * \param hController   AnimationController object
 * \param weight        controller weight
 */
M3G_API void m3gSetWeight(M3GAnimationController hController, M3Gfloat weight)
{
    AnimationController *controller = (AnimationController *) hController;
    M3G_VALIDATE_OBJECT(controller);

    if (weight < 0) {
        m3gRaiseError(M3G_INTERFACE(controller), M3G_INVALID_VALUE);
        return;
    }
    controller->weight = weight;
}

/*!
 * \brief Get controller weight.
 *
 * \param hController   AnimationController object
 * \return              controller weight
 */
M3G_API M3Gfloat m3gGetWeight(M3GAnimationController hController)
{
    AnimationController *controller = (AnimationController *) hController;
    M3G_VALIDATE_OBJECT(controller);

    return controller->weight;
}

/*!
 * \brief Get reference world time.
 *
 * \param hController   AnimationController object
 * \return              reference world time
 */
M3G_API M3Gint m3gGetRefWorldTime(M3GAnimationController hController)
{
    AnimationController *controller = (AnimationController *) hController;
    M3G_VALIDATE_OBJECT(controller);

    return controller->refWorldTime;
}