/*

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

*

*/

/*!

 * \internal

 * \file

 * \brief World implementation

 */

#ifndef M3G_CORE_INCLUDE

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

#endif

#include "m3g_world.h"

#include "m3g_memory.h"

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

 * Internal functions

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

/*!

 * \internal

 * \brief Destroys this World object.

 *

 * \param obj World object

 */

static void m3gDestroyWorld(Object *obj)

{

    World *world = (World *) obj;

    M3G_VALIDATE_OBJECT(world);

    M3G_ASSIGN_REF(world->activeCamera, NULL);

    M3G_ASSIGN_REF(world->background, NULL);

    m3gDestroyGroup(obj);

}

/*!

 * \internal

 * \brief Overloaded Object3D method.

 *

 * \param self World object

 * \param time current world time

 * \return minimum validity

 */

static M3Gint m3gWorldApplyAnimation(Object *self, M3Gint time)

{

    M3Gint minValidity;

    World *world = (World *)self;

    M3G_VALIDATE_OBJECT(world);

    minValidity = m3gGroupApplyAnimation(self, time);

    if (world->background != NULL && minValidity > 0) {

        M3Gint validity = M3G_VFUNC(Object, world->background, applyAnimation)((Object *)world->background, time);

        minValidity = (minValidity < validity ? minValidity : validity);

    }

    return minValidity;

}

/*!

 * \internal

 * \brief Overloaded Object3D method.

 *

 * \param self World object

 * \param references array of reference objects

 * \return number of references

 */

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

{

    World *world = (World *)self;

    M3Gint num = m3gGroupDoGetReferences(self, references);

    if (world->activeCamera != NULL) {

        if (references != NULL)

            references[num] = (Object *)world->activeCamera;

        num++;

    }

    if (world->background != NULL) {

        if (references != NULL)

            references[num] = (Object *)world->background;

        num++;

    }

    return num;

}

/*!

 * \internal

 * \brief Overloaded Object3D method.

 */

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

{

    World *world = (World *)self;

    Object *found = m3gGroupFindID(self, userID);

    if (!found && world->activeCamera != NULL) {

        found = m3gFindID((Object*) world->activeCamera, userID);

    }

    if (!found && world->background != NULL) {

        found = m3gFindID((Object*) world->background, userID);

    }

    return found;

}

/*!

 * \internal

 * \brief Overloaded Object3D method.

 *

 * \param originalObj original World object

 * \param cloneObj pointer to cloned World object

 * \param pairs array for all object-duplicate pairs

 * \param numPairs number of pairs

 */

static M3Gbool m3gWorldDuplicate(const Object *originalObj,

                                 Object **cloneObj,

                                 Object **pairs,

                                 M3Gint *numPairs)

{

    World *original = (World *)originalObj;

    World *clone;

    M3G_ASSERT(*cloneObj == NULL); /* no derived classes */

    /* Create the clone object */

    clone = (World *)m3gCreateWorld(originalObj->interface);

    if (!clone) {

        return M3G_FALSE;

    }

    *cloneObj = (Object *)clone;

    /* Duplicate base class data */

    if (!m3gGroupDuplicate(originalObj, cloneObj, pairs, numPairs)) {

        return M3G_FALSE;

    }

    /* Duplicate our own data */

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

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

    return M3G_TRUE;

}

/*!

 * \internal

 * \brief Overloaded Object3D method.

 *

 * \param self World object

 * \param pairs array for all object-duplicate pairs

 * \param numPairs number of pairs

 */

static void m3gWorldUpdateDuplicateReferences(Node *self, Object **pairs, M3Gint numPairs)

{

    World *world = (World *)self;

    m3gGroupUpdateDuplicateReferences(self, pairs, numPairs);

    if (world->activeCamera != NULL) {

        Node *duplicatedInstance = m3gGetDuplicatedInstance(self, pairs, numPairs);

        Node *activeCamDuplicate = m3gGetDuplicatedInstance((Node *)world->activeCamera, pairs, numPairs);

        if (activeCamDuplicate != NULL &&

            m3gIsChildOf(duplicatedInstance, activeCamDuplicate)) {

            M3G_ASSIGN_REF(((World *)duplicatedInstance)->activeCamera, activeCamDuplicate);

        }

    }

}

/*!

 * \internal

 * \brief Initializes a World object. See specification

 * for default values.

 *

 * \param m3g           M3G interface

 * \param world         World object

 */

static void m3gInitWorld(Interface *m3g, World *world)

{

	/* World is derived from group */

	m3gInitGroup(m3g, &world->group, M3G_CLASS_WORLD);

}

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

 * Virtual function table

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

static const NodeVFTable m3gvf_World = {

    {

        {

            m3gWorldApplyAnimation,

            m3gNodeIsCompatible,

            m3gNodeUpdateProperty,

            m3gWorldDoGetReferences,

            m3gWorldFindID,

            m3gWorldDuplicate,

            m3gDestroyWorld

        }

    },

    m3gGroupAlign,

    NULL, /* pure virtual DoRender */

    m3gGroupGetBBox,

    m3gGroupRayIntersect,

    m3gGroupSetupRender,

    m3gWorldUpdateDuplicateReferences,

    m3gGroupValidate

};

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

 * Public API functions

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

/*!

 * \brief Creates a World object.

 *

 * \param interface M3G interface

 * \retval World new World object

 * \retval NULL World creating failed

 */

/*@access M3Ginterface@*/

/*@access M3Gobject@*/

M3G_API M3GWorld m3gCreateWorld(M3GInterface interface)

{

    Interface *m3g = (Interface *) interface;

    M3G_VALIDATE_INTERFACE(m3g);

	{

		World *world = m3gAllocZ(m3g, sizeof(World));

        if (world != NULL) {

    		m3gInitWorld(m3g, world);

        }

		return (M3GWorld) world;

	}

}

/*!

 * \brief Set active camera.

 *

 * \param handle        World object

 * \param hCamera       Camera object

 */

/*@access M3Gobject@*/

M3G_API void m3gSetActiveCamera(M3GWorld handle, M3GCamera hCamera)

{

    World *world = (World *) handle;

    M3G_VALIDATE_OBJECT(world);

    if(hCamera == NULL) {

        m3gRaiseError(M3G_INTERFACE(world), M3G_NULL_POINTER);

        return;

    }

    M3G_ASSIGN_REF(world->activeCamera, hCamera);

}

/*!

 * \brief Set background.

 *

 * \param handle        World object

 * \param hBackground   Background object

 */

/*@access M3Gobject@*/

M3G_API void m3gSetBackground(M3GWorld handle, M3GBackground hBackground)

{

    World *world = (World *) handle;

    M3G_VALIDATE_OBJECT(world);

    M3G_ASSIGN_REF(world->background, hBackground);

}

/*!

 * \brief Get background.

 *

 * \param handle        World object

 * \return              Background object

 */

/*@access M3Gobject@*/

M3G_API M3GBackground m3gGetBackground(M3GWorld handle)

{

    World *world = (World *) handle;

    M3G_VALIDATE_OBJECT(world);

    return world->background;

}

/*!

 * \brief Get active camera.

 *

 * \param handle        World object

 * \return              Camera object

 */

/*@access M3Gobject@*/

M3G_API M3GCamera m3gGetActiveCamera(M3GWorld handle)

{

    World *world = (World *) handle;

    M3G_VALIDATE_OBJECT(world);

    return world->activeCamera;

}