/*

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

    if (group->bbox && !(self->dirtyBits & NODE_BBOX_BIT)) {

        *bbox = *group->bbox;

    }

    else {

        /* Compute local bounding box by recursively merging the

         * bounding boxes of all renderable child nodes */

        Node *child = group->firstChild;

        M3Gint groupYield = 0;

        do {

            if (child->hasRenderables && child->enableBits) {

                /* Get the transformation for the child node, then

                 * update our existing state with its bounding box */

                AABB childBBox;

                M3Gint childYield;

                Matrix t;

                childYield = m3gGetNodeBBox(child, &childBBox);

                if (childYield > 0) {

                    m3gGetCompositeNodeTransform(child, &t);

                    m3gTransformAABB(&childBBox, &t);

                    if (groupYield) {

                        m3gFitAABB(bbox, &childBBox, bbox);

                    }

                    else {

                        *bbox = childBBox;

                    }

                    groupYield += childYield;

                }

            }

            child = child->right;

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

        /* Store the updated bbox locally if we have one, or return

         * the combined child yield factor if we don't */

        if (group->bbox) {

            *group->bbox = *bbox;

        }

        else {

            return (groupYield > 0) ? groupYield + VFC_NODE_OVERHEAD : 0;

        }

    }

    return VFC_BBOX_COST + VFC_NODE_OVERHEAD;

}

/*!

 * \internal

 * \brief Overloaded Node method

 */

static M3Gbool m3gGroupValidate(Node *self, M3Gbitmask stateBits, M3Gint scope)

{

    Group *group = (Group*) self;

    if (stateBits & self->enableBits) {

        /* First validate child nodes to ensure we don't skip anything,

         * and allow children to invalidate our state */

        Node *child = group->firstChild;

        if (child) {

            do {

                if (!m3gValidateNode(child, stateBits, scope)) {

                    return M3G_FALSE;

                }

                child = child->right;

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

        }

        /* Re-evaluate our local bounding box if necessary */

        if (self->hasRenderables && self->dirtyBits & NODE_BBOX_BIT) {

            AABB bbox;

            M3Gint yield;

            M3G_BEGIN_PROFILE(M3G_INTERFACE(self), M3G_PROFILE_VFC_UPDATE);

            yield = m3gGetNodeBBox(self, &bbox);

            /* Think about adding a bounding box if we don't yet have one,

             * or removing the current one if it doesn't seem worth it */

            if (!group->bbox) {

                if (yield > (3*VFC_BBOX_COST) >> 1) {

                    group->bbox = m3gAlloc(M3G_INTERFACE(group),

                                           sizeof(*group->bbox));

                    if (group->bbox) {

                        m3gIncStat(M3G_INTERFACE(group),

                                   M3G_STAT_BOUNDING_BOXES, 1);

                        *group->bbox = bbox;

                    }

                    else {

                        return M3G_FALSE;

                    }

                }

            }

            else if (yield <= VFC_BBOX_COST) {

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

                group->bbox = NULL;

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

            }

            M3G_END_PROFILE(M3G_INTERFACE(self), M3G_PROFILE_VFC_UPDATE);

        }

        return m3gNodeValidate(self, stateBits, scope);

    }

    return M3G_TRUE;

}

/*!

 * \internal

 * \brief Overloaded Node method.

 *

 * \param self Group object

 * \param pairs array for all object-duplicate pairs

 * \param numPairs number of pairs

 */

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

{

    Group *group = (Group *)self;

    Node *child = group->firstChild;

    m3gNodeUpdateDuplicateReferences(self, pairs, numPairs);

    if (child) {

        do {

            M3G_VFUNC(Node, child, updateDuplicateReferences)(

                child, pairs, numPairs);

            child = child->right;

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

    }

}

/*!

 * \internal

 * \brief Initializes a Group object. See specification

 * for default values.

 *

 * \param m3g           M3G interface

 * \param group         Group object

 * \param vfTable       virtual function table

 */

static void m3gInitGroup(Interface *m3g, Group *group, M3GClass classID)

{

	/* Group is derived from Node */

	m3gInitNode(m3g, &group->node, classID);

}

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

 * Virtual function table

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

static const NodeVFTable m3gvf_Group = {

    {

        {

            m3gGroupApplyAnimation,

            m3gNodeIsCompatible,

            m3gNodeUpdateProperty,

            m3gGroupDoGetReferences,

            m3gGroupFindID,

            m3gGroupDuplicate,

            m3gDestroyGroup

        }

    },

    m3gGroupAlign,

    NULL, /* pure virtual m3gNodeDoRender */

    m3gGroupGetBBox,

    m3gGroupRayIntersect,

    m3gGroupSetupRender,

    m3gGroupUpdateDuplicateReferences,

    m3gGroupValidate

};

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

 * Public API functions

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

/*!

 * \brief Creates a Group object.

 *

 * \param interface     M3G interface

 * \retval Group new Group object

 * \retval NULL Group creating failed

 */

M3G_API M3GGroup m3gCreateGroup(M3GInterface interface)

{

    Interface *m3g = (Interface *) interface;

    M3G_VALIDATE_INTERFACE(m3g);

	{

		Group *group =  m3gAllocZ(m3g, sizeof(Group));

        if (group != NULL) {

    		m3gInitGroup(m3g, group, M3G_CLASS_GROUP);

        }

		return (M3GGroup) group;

	}

}

/*!

 * \brief Adds a node to this group.

 *

 * \param handle        Group object

 * \param hNode         Node object

 */

M3G_API void m3gAddChild(M3GGroup handle, M3GNode hNode)

{

    Group *group = (Group *) handle;

	Node *child = (Node *) hNode;

    M3G_VALIDATE_OBJECT(group);

    if (child == NULL) {

        m3gRaiseError(M3G_INTERFACE(group), M3G_NULL_POINTER);

        return;

    }

    if (child == (Node *)group   ||

        (child->parent != NULL && child->parent != (Node *)group) ||

        m3gIsChildOf(child, (Node *)group) ||

        m3gGetClass((Object *) child) == M3G_CLASS_WORLD) {

        m3gRaiseError(M3G_INTERFACE(group), M3G_INVALID_VALUE);

        return;

    }

    if (child->parent == NULL) {

        m3gLinkChild(child, group);

    }

}

/*!

 * \brief Removes a node from this group.

 *

 * \param handle        Group object

 * \param hNode         Node object

 */

M3G_API void m3gRemoveChild(M3GGroup handle, M3GNode hNode)

{

    Group *group = (Group *) handle;

	Node *child = (Node *)hNode;

    M3G_VALIDATE_OBJECT(group);

    if (child == NULL) {

        return;

    }

    if (child->hasBones == M3G_TRUE) {

        m3gRaiseError(M3G_INTERFACE(group), M3G_INVALID_VALUE);

        return;

    }

    if (group->firstChild == NULL) {

        return;

    }

    m3gDetachChild(child, group);

}

/*!

 * \brief Performs 3D pick.

 *

 * \param handle        Group object

 * \param mask          pick scope mask

 * \param ray           pick ray

 * \arg ray[0]          origin X

 * \arg ray[1]          origin Y

 * \arg ray[2]          origin Z

 * \arg ray[3]          direction X

 * \arg ray[4]          direction Y

 * \arg ray[5]          direction Z

 * \param result        java side RayIntersection result

 * \arg result[0]       distance

 * \arg result[1]       submesh index

 * \arg result[2]       textureS[0]

 * \arg result[3]       textureS[1]

 * \arg result[4]       textureT[0]

 * \arg result[5]       textureT[1]

 * \arg result[6]       normal X

 * \arg result[7]       normal Y

 * \arg result[8]       normal Z

 * \arg result[9]       ray ox

 * \arg result[10]      ray oy

 * \arg result[11]      ray oz

 * \arg result[12]      ray dx

 * \arg result[13]      ray dy

 * \arg result[14]      ray dz

 * \return              intersected Node object

 */

#ifdef M3G_ENABLE_PROFILING

static M3GNode m3gPick3DInternal(M3GGroup handle,

                          M3Gint mask,

                          M3Gfloat *ray,

                          M3Gfloat *result);

M3G_API M3GNode m3gPick3D(M3GGroup handle,

                          M3Gint mask,

                          M3Gfloat *ray,

                          M3Gfloat *result)

{

    M3GNode pickResult;

    M3G_BEGIN_PROFILE(M3G_INTERFACE(handle), M3G_PROFILE_PICK);

    pickResult = m3gPick3DInternal(handle, mask, ray, result);

    M3G_END_PROFILE(M3G_INTERFACE(handle), M3G_PROFILE_PICK);

    return pickResult;

}

static M3GNode m3gPick3DInternal(M3GGroup handle,

                          M3Gint mask,

                          M3Gfloat *ray,

                          M3Gfloat *result)

#else

M3G_API M3GNode m3gPick3D(M3GGroup handle,

                          M3Gint mask,

                          M3Gfloat *ray,

                          M3Gfloat *result)

#endif

{

    RayIntersection ri;

    Matrix toGroup;

    Group *group = (Group *) handle;

    M3G_VALIDATE_OBJECT(group);

    M3G_LOG1(M3G_LOG_STAGES, "Picking group 0x%08X\n", (unsigned) group);

    /* Check for errors */

    if (ray[3] == 0 && ray[4] == 0 && ray[5] == 0) {

        m3gRaiseError(M3G_INTERFACE(group), M3G_INVALID_VALUE);

        return NULL;

    }

    if (!m3gValidateNode((Node*) group, NODE_PICK_BIT, mask)) {

        return NULL;

    }

    m3gInitPick(&ri, (Node *)group, NULL, 0, 0);

    m3gIdentityMatrix(&toGroup);

    ray[3] = m3gAdd(ray[3], ray[0]);

    ray[4] = m3gAdd(ray[4], ray[1]);

    ray[5] = m3gAdd(ray[5], ray[2]);

    M3G_VFUNC(Node, group, rayIntersect)(   (Node *)group,

                                            mask,

                                            ray,

                                            &ri,

                                            &toGroup);

    m3gFillPickResult(&ri, ray, result);

    return ri.intersected;

}

/*!

 * \brief Performs 2D pick.

 *

 * \param handle        Group object

 * \param mask          pick scope mask

 * \param x             viewport x

 * \param y             viewport y

 * \param hCamera       Camera object

 * \param result        java side RayIntersection result, see m3gPick3D

 * \return              intersected Node object

 */

#ifdef M3G_ENABLE_PROFILING

static M3GNode m3gPick2DInternal(M3GGroup handle,

                          M3Gint mask,

                          M3Gfloat x, M3Gfloat y,

                          M3GCamera hCamera,

                          M3Gfloat *result);

M3G_API M3GNode m3gPick2D(M3GGroup handle,

                          M3Gint mask,

                          M3Gfloat x, M3Gfloat y,

                          M3GCamera hCamera,

                          M3Gfloat *result)

{

    M3GNode pickResult;

    M3G_BEGIN_PROFILE(M3G_INTERFACE(handle), M3G_PROFILE_PICK);

    pickResult = m3gPick2DInternal(handle, mask, x, y, hCamera, result);

    M3G_END_PROFILE(M3G_INTERFACE(handle), M3G_PROFILE_PICK);

    return pickResult;

}

static M3GNode m3gPick2DInternal(M3GGroup handle,

                          M3Gint mask,

                          M3Gfloat x, M3Gfloat y,

                          M3GCamera hCamera,

                          M3Gfloat *result)

#else

M3G_API M3GNode m3gPick2D(M3GGroup handle,

                          M3Gint mask,

                          M3Gfloat x, M3Gfloat y,

                          M3GCamera hCamera,

                          M3Gfloat *result)

#endif

{

    Vec4 farp, nearp;

    RayIntersection ri;

    Matrix toGroup;

    M3Gfloat ray[6 + 2];    /* Extra floats to store near and far plane z */

    Node *root;

    Group *group = (Group *) handle;    

    M3G_LOG2(M3G_LOG_STAGES, "Picking group 0x%08X via camera 0x%08X\n",

             (unsigned) group, (unsigned) hCamera);

    M3G_VALIDATE_OBJECT(group);

    if (hCamera == 0) {

        m3gRaiseError(M3G_INTERFACE(group), M3G_NULL_POINTER);

        return NULL;

    }

    root = m3gGetRoot((Node *)hCamera);

    if (root != m3gGetRoot(&group->node)) {

        m3gRaiseError(M3G_INTERFACE(group), M3G_INVALID_OPERATION);

        return NULL;

    }

    if (!m3gValidateNode(root, NODE_PICK_BIT, mask)) {

        return NULL;

    }

    farp.x = m3gSub(m3gMul(2, x), 1.f);

    farp.y = m3gSub(1.f, m3gMul(2, y));

    farp.z = 1.f;

    farp.w = 1.f;

    nearp.x = farp.x;

    nearp.y = farp.y;

    nearp.z = -1.f;

    nearp.w =  1.f;

    m3gCopyMatrix(&toGroup, m3gProjectionMatrix((Camera *)hCamera));

    M3G_BEGIN_PROFILE(M3G_INTERFACE(group), M3G_PROFILE_TRANSFORM_INVERT);

    if (!m3gInvertMatrix(&toGroup)) {

        m3gRaiseError(M3G_INTERFACE(group), M3G_ARITHMETIC_ERROR);

        return NULL;

    }

    M3G_END_PROFILE(M3G_INTERFACE(group), M3G_PROFILE_TRANSFORM_INVERT);

    m3gTransformVec4(&toGroup, &nearp);

    m3gTransformVec4(&toGroup, &farp);

    m3gScaleVec4(&nearp, m3gRcp(nearp.w));

    m3gScaleVec4(&farp, m3gRcp(farp.w));

    /* Store near and far plane z for sprite picking */

    ray[6] = nearp.z;

    ray[7] = farp.z;

    if (!m3gGetTransformTo((M3GNode) hCamera, (Node *) group, &toGroup)) {

        return NULL;

    }

    m3gTransformVec4(&toGroup, &nearp);

    m3gTransformVec4(&toGroup, &farp);

    m3gScaleVec4(&nearp, m3gRcp(nearp.w));

    m3gScaleVec4(&farp, m3gRcp(farp.w));