/*

* 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;

}