/*

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

*

*/

/*!

 * \internal

 * \file

 * \brief Group implementation

 */

#ifndef M3G_CORE_INCLUDE

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

#endif

#include "m3g_group.h"

#include "m3g_memory.h"

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

 * Internal functions

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

/*!

 * \internal

 * \brief Links a new child into the child list of this node.

 *

 * This assumes that all error checking has been done prior to calling

 * the function, and the operation is a valid one.

 *

 * \param child Node object

 * \param group Group object

 */

static void m3gLinkChild(Node *child, Group *group)

{

    M3G_VALIDATE_OBJECT(child);

    M3G_VALIDATE_OBJECT(group);

	if (group->firstChild == NULL) {

		group->firstChild = child;

		child->left = child;

		child->right = child;

	}

	else {

        Node *linkChild = group->firstChild;

		child->left = linkChild->left;

		linkChild->left->right = child;

		child->right = linkChild;

		linkChild->left = child;

	}

    m3gSetParent(child, (Node *) group);    

}

/*!

 * \internal

 * \brief Removes a child from the child list of this node.

 *

 * This assumes that all error checking has been done prior to calling

 * the function, and the operation is a valid one.

 *

 * \param child Node object

 * \param group Group object

 */

static void m3gDetachChild(Node *child, Group *group)

{

	Node *n;

    M3G_VALIDATE_OBJECT(child);

    M3G_VALIDATE_OBJECT(group);

    n = group->firstChild;

	do {

		if (n == child) {

            M3G_VALIDATE_OBJECT(child->right);

            M3G_VALIDATE_OBJECT(child->left);

			n->right->left = n->left;

			n->left->right = n->right;

			if (group->firstChild == n) {

				group->firstChild = (n->right != n) ? n->right : NULL;

			}

            n->left = NULL;

            n->right = NULL;

            m3gSetParent(n, NULL);

			return;

		}

        n = n->right;

	} while (n != group->firstChild);

}

/*!

 * \internal

 * \brief Destroys this Group object.

 *

 * \param obj Group object

 */

static void m3gDestroyGroup(Object *obj)

{

    /* Release child references so they can be deleted */

	Group *group = (Group *) obj;

	while (group->firstChild != NULL) {

        m3gDetachChild(group->firstChild, group);

	}

#   if defined(M3G_ENABLE_VF_CULLING)

    if (group->bbox) {

        m3gFree(M3G_INTERFACE(group), group->bbox);

        m3gIncStat(M3G_INTERFACE(group), M3G_STAT_BOUNDING_BOXES, -1);

    }

#   endif

    m3gDestroyNode(obj);

}

/*!

 * \internal

 * \brief Overloaded Node method.

 *

 * \param self Group object

 * \param refNode alignment reference Node object

 *

 * \retval M3G_TRUE continue align

 * \retval M3G_FALSE abort align

 */

static M3Gbool m3gGroupAlign(Node *self, const Node *refNode)

{

	Group *group = (Group *)self;

	Node *child = group->firstChild;

    if (!m3gNodeAlign(self, refNode)) {

        return M3G_FALSE;

    }

    if (child) {

        do {

            if (!M3G_VFUNC(Node, child, align)(child, refNode)) {

                return M3G_FALSE;

            }

            child = child->right;

        } while (child != group->firstChild);

	}

    return M3G_TRUE;

}

/*!

 * \internal

 * \brief Overloaded Node method.

 *

 * Setup group rendering by calling child

 * nodes' render setup.

 *

 * \param self Group object

 * \param toCamera transform to camera

 * \param alphaFactor total alpha factor

 * \param caller caller node

 * \param renderQueue RenderQueue

 *

 * \retval M3G_TRUE continue render setup

 * \retval M3G_FALSE abort render setup

 */

static M3Gbool m3gGroupSetupRender(Node *self,

                                   const Node *caller,

                                   SetupRenderState *s,

                                   RenderQueue *renderQueue)

{

	Group *group = (Group *)self;

    M3Gbool enabled, success = M3G_TRUE;

    /* Check whether we're going up or down, and optimize the

     * rendering-enabled and visibility checking based on that */

    enabled = (self->enableBits & NODE_RENDER_BIT) != 0;

    if (caller != self->parent) {

        enabled = m3gHasEnabledPath(self, renderQueue->root);

        s->cullMask = CULLMASK_ALL;

    }

    M3G_ASSERT(!self->dirtyBits || !enabled);

	/* First do the child nodes, unless disabled (inheritable, so

     * children would be, too) */

    if (enabled && (group->numNonCullables > 0 || group->numRenderables > 0)) {

        Node *child = group->firstChild;

        if (child) {

            /* Check the bounding box if we have one */

#           if defined(M3G_ENABLE_VF_CULLING)

            if (group->bbox) {

                m3gValidateAABB(group->bbox);

                m3gUpdateCullingMask(s, renderQueue->camera, group->bbox);

            }

#           endif

            /* If we're not culled, or if we carry lights, we really

             * need to recurse into each child node */

            if (s->cullMask || group->numNonCullables > 0) {

                do {

                    if (child != caller) {

                        SetupRenderState cs;

                        cs.cullMask = s->cullMask;

                        M3G_BEGIN_PROFILE(M3G_INTERFACE(group),

                                          M3G_PROFILE_SETUP_TRANSFORMS);

                        m3gGetCompositeNodeTransform(child, &cs.toCamera);

                        m3gPreMultiplyMatrix(&cs.toCamera, &s->toCamera);

                        M3G_END_PROFILE(M3G_INTERFACE(group),

                                        M3G_PROFILE_SETUP_TRANSFORMS);

                        if (!M3G_VFUNC(Node, child, setupRender)(

                                child, self, &cs, renderQueue)) {

                            return M3G_FALSE;

                        }

                    }

                    child = child->right;

                } while (child != group->firstChild);

            }

            else {

                M3GInterface m3g = M3G_INTERFACE(group);

                M3Gint n = group->numRenderables;

                m3gIncStat(m3g, M3G_STAT_RENDER_NODES, n);

                m3gIncStat(m3g, M3G_STAT_RENDER_NODES_CULLED, n);

            }

        }

    }

	/* Then do the parent node if we're going up the tree.  Again, we

     * can discard the old traversal state at this point. */

	if (self != renderQueue->root) {

	    Node *parent = self->parent;

	    if (parent != caller && parent != NULL) {

            Matrix t;

            M3G_BEGIN_PROFILE(M3G_INTERFACE(self), M3G_PROFILE_SETUP_TRANSFORMS);

            if (!m3gGetInverseNodeTransform(self, &t)) {

                return M3G_FALSE;

            }

			m3gMulMatrix(&s->toCamera, &t);

            M3G_END_PROFILE(M3G_INTERFACE(self), M3G_PROFILE_SETUP_TRANSFORMS);

            success = M3G_VFUNC(Node, parent, setupRender)(parent,

                                                           self,

                                                           s,

                                                           renderQueue);

	    }

	}

    return success;

}

/*!

 * \internal

 * \brief Overloaded Object3D method.

 *

 * \param self Group object

 * \param time current world time

 * \return minimum validity

 */

static M3Gint m3gGroupApplyAnimation(Object *self, M3Gint time)

{

    M3Gint validity, minValidity;

	Node *child;

    Group *group = (Group *)self;

    M3G_VALIDATE_OBJECT(group);

    minValidity = m3gObjectApplyAnimation(self, time);

    child = group->firstChild;

    if (child && minValidity > 0) {

        do {

            validity = M3G_VFUNC(Object, child, applyAnimation)(

                (Object *)child, time);

            minValidity = validity < minValidity ? validity : minValidity;

            child = child->right;

        } while (minValidity > 0 && child != group->firstChild);

    }

    return minValidity;

}

/*!

 * \internal

 * \brief Overloaded Node method.

 *

 * Call child nodes' ray intersect.

 *

 * \param self      Group object

 * \param mask      pick scope mask

 * \param ray       pick ray

 * \param ri        RayIntersection object

 * \param toGroup   transform to originating group

 * \retval          M3G_TRUE    continue pick

 * \retval          M3G_FALSE   abort pick

 */

static M3Gbool m3gGroupRayIntersect(Node *self,

                                    M3Gint mask,

                                    M3Gfloat *ray,

                                    RayIntersection *ri,

                                    Matrix *toGroup)

{

    Group *group = (Group *)self;

    Node *child;

    Matrix t, nt;

    m3gIdentityMatrix(&t);

    m3gIdentityMatrix(&nt);

    child = group->firstChild;

    if (child) {

        do {

            if (m3gHasPickablePath(child, ri->root)) {

                m3gCopyMatrix(&t, toGroup);

                m3gGetCompositeNodeTransform(child, &nt);

                m3gRightMulMatrix(&t, &nt);

                if (!M3G_VFUNC(Node, child, rayIntersect)(

                        child, mask, ray, ri, &t)) {

                    return M3G_FALSE;

                }

            }    

            child = child->right;

        } while (child != group->firstChild);

    }

    return M3G_TRUE;

}

/*!

 * \internal

 * \brief Initializes pick traversing.

 *

 * \param ri        RayIntersection object

 * \param root      Root node for the traversing

 * \param camera    Camera object used in pick (2D pick only)

 * \param x         viewport x (2D pick only)

 * \param y         viewport y (2D pick only)

 */

static void m3gInitPick(RayIntersection *ri, Node *root, Camera *camera, M3Gfloat x, M3Gfloat y)

{

    m3gZero(ri, sizeof(*ri));

    ri->root = root;

    ri->camera = camera;

    ri->x = x;

    ri->y = y;

    ri->tMin = M3G_MAX_POSITIVE_FLOAT;

}

/*!

 * \internal

 * \brief Fills Java side RayIntersection result.

 *

 * \param ri        RayIntersection object

 * \param ray       Ray used in pick

 * \param result    Java side float array

 */

static void m3gFillPickResult(RayIntersection *ri, M3Gfloat *ray, M3Gfloat *result)

{

    if (ri->intersected != NULL) {

        Vec3 n;

        /* Fill in the values */

        result[0] = ri->distance;

        result[1] = (M3Gfloat)ri->submeshIndex;

        result[2] = ri->textureS[0];

        result[3] = ri->textureS[1];

        result[4] = ri->textureT[0];

        result[5] = ri->textureT[1];

        /* Normalize normal */

        n.x = ri->normal[0];

        n.y = ri->normal[1];

        n.z = ri->normal[2];

        m3gNormalizeVec3(&n);

        result[6] = n.x;

        result[7] = n.y;

        result[8] = n.z;

        result[9] = ray[0];

        result[10] = ray[1];

        result[11] = ray[2];

        result[12] = m3gSub(ray[3], ray[0]);

        result[13] = m3gSub(ray[4], ray[1]);

        result[14] = m3gSub(ray[5], ray[2]);

    }

}

/*!

 * \internal

 * \brief Overloaded Object3D method.

 *

 * \param self Group object

 * \param references array of reference objects

 * \return number of references

 */

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

{

    Group *group = (Group *)self;

    M3Gint num = m3gObjectDoGetReferences(self, references);

    Node *child = group->firstChild;

    if (child) {

        do {

            if (references != NULL)

                references[num] = (Object *)child;

            child = child->right;

            num++;

        } while (child != group->firstChild);

    }

    return num;

}

/*!

 * \internal

 * \brief Overloaded Object3D method.

 *

 * \param self Group object

 * \param references array of reference objects

 * \return number of references

 */

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

{

    Group *group = (Group *)self;

    Object *found = m3gObjectFindID(self, userID);

    Node *child = group->firstChild;

    if (child && !found) {

        do {

            found = m3gFindID((Object*) child, userID);

            child = child->right;

        } while (!found && child != group->firstChild);

    }

    return found;

}

/*!

 * \internal

 * \brief Overloaded Object3D method.

 *

 * \param originalObj original Group object

 * \param cloneObj pointer to cloned Group object

 * \param pairs array for all object-duplicate pairs

 * \param numPairs number of pairs

 */

static M3Gbool m3gGroupDuplicate(const Object *originalObj,

                                 Object **cloneObj,

                                 Object **pairs,

                                 M3Gint *numPairs)

{

    Node *child;

    Group *original = (Group *)originalObj;

    Group *clone;

    /* Create the clone object, unless already created in a derived

     * class function */

    if (*cloneObj == NULL) {

        clone = (Group *)m3gCreateGroup(originalObj->interface);

        if (!clone) {

            return M3G_FALSE; /* out of memory */

        }

        *cloneObj = (Object *)clone;

    }

    else {

        clone = (Group *)*cloneObj;

    }

    /* Call base class function to duplicate base class data */

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

        return M3G_FALSE; /* out of memory; caller will delete us */

    }

    /* Duplicate child nodes. */

    child = original->firstChild;

    if (child) {

        do {

            Node *temp = NULL;

            if (!M3G_VFUNC(Object, child, duplicate)(

                    (Object *)child, (Object**)&temp, pairs, numPairs)) {

                m3gDeleteObject((Object*) temp); /* we have the only reference */

                return M3G_FALSE;

            }

            m3gAddChild(clone, temp);

            child = child->right;

        } while (child != original->firstChild);

    }

    return M3G_TRUE;

}

/*!

 * \internal

 * \brief Overloaded Node method

 */

static M3Gint m3gGroupGetBBox(Node *self, AABB *bbox)

{

    Group *group = (Group*) self;

    /* Quick exit for empty volumes */

    if (!group->firstChild || !self->hasRenderables) {

        return 0;

    }

    /* Assume our existing bbox is ok, but compute a new one if it

     * isn't */