/*

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

*

*/

/*!

 * \internal

 * \file

 * \brief Node implementation

 */

#ifndef M3G_CORE_INCLUDE

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

#endif

#include "m3g_node.h"

#include "m3g_memory.h"

#include "m3g_animationtrack.h"

#include "m3g_skinnedmesh.h"

#include "m3g_tcache.h"

#include "m3g_transformable.h"

#define TARGET_NONE   0

#define TARGET_X_AXIS 1

#define TARGET_Y_AXIS 2

#define TARGET_Z_AXIS 3

#define TARGET_ORIGIN 4

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

 * Private functions

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

static M3Guint internalTarget(M3Genum target)

{

    switch (target) {

    case M3G_NONE:

        return TARGET_NONE;

    case M3G_ORIGIN:

        return TARGET_ORIGIN;

    case M3G_X_AXIS:

        return TARGET_X_AXIS;

    case M3G_Y_AXIS:

        return TARGET_Y_AXIS;

    case M3G_Z_AXIS:

        return TARGET_Z_AXIS;

    default:

        M3G_ASSERT(M3G_FALSE);

        return TARGET_NONE;

    }

}   

static M3Guint externalTarget(M3Genum target)

{

    switch (target) {

    case TARGET_NONE:

        return M3G_NONE;

    case TARGET_ORIGIN:

        return M3G_ORIGIN;

    case TARGET_X_AXIS:

        return M3G_X_AXIS;

    case TARGET_Y_AXIS:

        return M3G_Y_AXIS;

    case TARGET_Z_AXIS:

        return M3G_Z_AXIS;

    default:

        M3G_ASSERT(M3G_FALSE);

        return M3G_NONE;

    }

}   

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

 * Constructor & destructor

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

/*!

 * \internal

 * \brief Initializes a Node object. See specification

 * for default values.

 *

 * \param m3g           M3G interface

 * \param node          Node object

 * \param vfTable       virtual function table

 */

static void m3gInitNode(Interface *m3g, Node *node, M3GClass classID)

{

	/* Node is derived from Transformable */

	m3gInitTransformable(&node->transformable, m3g, classID);

    /* Set default values */

    node->enableBits = (NODE_RENDER_BIT|NODE_PICK_BIT);

	node->alphaFactor = (1u << NODE_ALPHA_FACTOR_BITS) - 1;

	node->scope = -1;

    node->zTarget = TARGET_NONE;

    node->yTarget = TARGET_NONE;

}

/*!

 * \internal

 * \brief Destroys this Node object.

 *

 * \param obj Node object

 */

static void m3gDestroyNode(Object *obj)

{

    Node *node = (Node *) obj;

    M3G_VALIDATE_OBJECT(node);

    M3G_ASSERT(node->parent == NULL);

    m3gDestroyTransformable((Object *) node);

}

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

 * Internal functions

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

/*!

 * \internal

 * \brief Checks if node is a child of the parent.

 *

 * \param parent    assumed parent Node object

 * \param child     Node object to check

 * \retval          M3G_TRUE is a child

 * \retval          M3G_FALSE is not a child

 */

static M3Gbool m3gIsChildOf(const Node *parent, const Node *child)

{

	const Node *n;

	for (n = child; n != NULL; n = n->parent) {

		if (n->parent == parent) return M3G_TRUE;

	}

	return M3G_FALSE;

}

/*!

 * \internal

 * \brief Executes the given function for each node in a subtree

 *

 * The function \c func is executed recursively in each branch,

 * starting from the leaves. That is, the function is called for the

 * children of each group before the group itself.

 *

 * \param node   the node containing the subtree to process

 * \param func   pointer to the function to all for each node

 * \param params pointer to function-dependent arguments to pass

 * to each \c func invokation; this may be e.g. a structure

 * modified by \c func

 *

 * \return The return value of the top-level call to \c func

 */

static void m3gForSubtree(Node *node, NodeFuncPtr func, void *params)

{

    M3GClass nodeClass;

    M3G_VALIDATE_OBJECT(node);

    /* Recurse into the children first */

    nodeClass = M3G_CLASS(node);

    if (nodeClass == M3G_CLASS_SKINNED_MESH) {

        m3gForSubtree((Node*)((SkinnedMesh*)node)->skeleton, func, params);

    }

    else if (nodeClass == M3G_CLASS_GROUP ||

             nodeClass == M3G_CLASS_WORLD) {

        Group *group = (Group*) node;

        Node *child = group->firstChild;

        if (child) {

            do {

                Node *next = child->right;

                m3gForSubtree(child, func, params);

                child = next;

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

        }

    }

    /* Execute function on self */

    (*func)(node, params);

}

/*!

 * \internal

 * \brief Overloaded Object3D method

 *

 * \param property      animation property

 * \retval M3G_TRUE     property supported

 * \retval M3G_FALSE    property not supported

 */

static M3Gbool m3gNodeIsCompatible(M3Gint property)

{

    switch (property) {

    case M3G_ANIM_ALPHA:

    case M3G_ANIM_PICKABILITY:

    case M3G_ANIM_VISIBILITY:

        return M3G_TRUE;

    default:

        return m3gTransformableIsCompatible(property);

    }

}

/*!

 * \internal

 * \brief Overloaded Object3D method

 *

 * \param self          Node object

 * \param property      animation property

 * \param valueSize     size of value array

 * \param value         value array

 */

static void m3gNodeUpdateProperty(Object *self,

                                  M3Gint property,

                                  M3Gint valueSize,

                                  const M3Gfloat *value)

{

    Node *node = (Node *)self;

    M3G_VALIDATE_OBJECT(node);

    M3G_ASSERT_PTR(value);

    switch (property) {

    case M3G_ANIM_ALPHA:

        M3G_ASSERT(valueSize >= 1);

        node->alphaFactor =

            m3gRoundToInt(

                m3gMul(m3gClampFloat(value[0], 0.f, 1.f),

                       (float)((1 << NODE_ALPHA_FACTOR_BITS) - 1)));

        break;

    case M3G_ANIM_PICKABILITY:

        M3G_ASSERT(valueSize >= 1);

        node->enableBits &= ~NODE_PICK_BIT;

        if (value[0] >= 0.5f) {

            node->enableBits |= NODE_PICK_BIT;

        }

        break;

    case M3G_ANIM_VISIBILITY:

        M3G_ASSERT(valueSize >= 1);

        node->enableBits &= ~NODE_RENDER_BIT;

        if (value[0] >= 0.5f) {

            node->enableBits |= NODE_RENDER_BIT;

        }

        break;

    default:

        m3gTransformableUpdateProperty(self, property, valueSize, value);

    }

}

/*!

 * \internal

 * \brief Overloaded Object3D method

 *

 * \param originalObj original Node object

 * \param cloneObj pointer to cloned Node object

 * \param pairs array for all object-duplicate pairs

 * \param numPairs number of pairs

 */

static M3Gbool m3gNodeDuplicate(const Object *originalObj,

                                Object **cloneObj,

                                Object **pairs,

                                M3Gint *numPairs)

{

    Node *original = (Node *)originalObj;

    Node *clone = (Node *)*cloneObj;

    M3G_ASSERT_PTR(*cloneObj); /* abstract class, must be derived */

    /* Duplicate base class data */

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

        return M3G_FALSE;

    }

    /* Duplicate our own data */

    clone->zReference  = original->zReference;

    clone->yReference  = original->yReference;

    clone->zTarget     = original->zTarget;

    clone->yTarget     = original->yTarget;

    clone->enableBits  = original->enableBits;

    clone->alphaFactor = original->alphaFactor;

    clone->scope       = original->scope;

    clone->hasBones    = original->hasBones;

    clone->hasRenderables = original->hasRenderables;

    return M3G_TRUE;

}

/*!

 * \internal

 * \brief Find corresponding duplicate for a Node

 *

 * \param node Node object

 * \param pairs array for all object-duplicate pairs

 * \param numPairs number of pairs

 */

static Node *m3gGetDuplicatedInstance(Node *node, Object **pairs, M3Gint numPairs)

{

    M3Gint i;

    for (i = 0; i < numPairs; i++)

        if (pairs[i * 2] == (Object *)node)

            return (Node *)pairs[i * 2 + 1];

    return NULL;

}

/*!

 * \internal

 * \brief Updates references of the duplicate object.

 *

 * When objects are duplicated scenegraph references

 * must be updated to equivalent duplicated references.

 * This function is overloaded by objects that have

 * references that has to be updated.

 *

 * \param self Node object

 * \param pairs array for all object-duplicate pairs

 * \param numPairs number of pairs

 */

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

{

    if (self->zTarget != TARGET_NONE && self->zReference != NULL) {

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

        Node *duplicatedRef = m3gGetDuplicatedInstance(self->zReference, pairs, numPairs);

        if (duplicatedRef != NULL

            && m3gIsChildOf(m3gGetRoot(duplicatedInstance), duplicatedRef)) {

            duplicatedInstance->zReference = duplicatedRef;

        }

    }

    if (self->yTarget != TARGET_NONE && self->yReference != NULL) {

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

        Node *duplicatedRef = m3gGetDuplicatedInstance(self->yReference, pairs, numPairs);

        if (duplicatedRef != NULL

            && m3gIsChildOf(m3gGetRoot(duplicatedInstance), duplicatedRef)) {

            duplicatedInstance->yReference = duplicatedRef;

        }

    }

}

/*!

 * \internal

 * \brief Gets size of the subtree

 *

 * \param node Node object

 * \param numRef number of references

 */

static void m3gDoGetSubtreeSize(Node *node, void *numRef)

{

    M3Gint *num = (M3Gint *)numRef;

    M3G_UNREF(node);

    (*num)++;

}

/*!

 * \internal

 * \brief Default function for non-pickable objects

 *

 * \param self      Camera object

 * \param mask      pick scope mask

 * \param ray       pick ray

 * \param ri        RayIntersection object

 * \param toGroup   transform to originating group

 * \retval M3G_TRUE always return success

 */

static M3Gbool m3gNodeRayIntersect(Node *self,

                                   M3Gint mask,

                                   M3Gfloat *ray,

                                   RayIntersection *ri,

                                   Matrix *toGroup)

{

    M3G_UNREF(self);

    M3G_UNREF(mask);

    M3G_UNREF(ray);

    M3G_UNREF(ri);

    M3G_UNREF(toGroup);

    return M3G_TRUE;

}

/*!

 * \internal

 * \brief Computes the bounding box for this node

 *

 * \param self  node pointer

 * \param bbox  bounding box structure filled in for non-zero return values

 * 

 * \return The "yield" factor for the node, i.e. the approximate

 * rendering cost of the node \em including any internal bounding box

 * checks; the yield factor is used to estimate the benefit of adding

 * enclosing bounding boxes at higher levels in the scene tree

 */

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

{

    M3G_UNREF(self);

    M3G_UNREF(bbox);

    return 0;

}

/*!

 * \internal

 * \brief Updates the bounding box for this node

 */

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

{

    M3G_UNREF(stateBits);

    M3G_UNREF(scope);

    /* Invalidate parent state in case we've encountered a previously

     * disabled node, then reset the dirty bits */

    if (self->dirtyBits && self->parent) {

        m3gInvalidateNode(self->parent, self->dirtyBits);

    }

    self->dirtyBits = 0;

    return M3G_TRUE;

}

/*!

 * \internal

 * \brief Gets a vector according to alignment target

 * and transforms it with a given transform.

 *

 * \param target        alignment target

 * \param transform     transform to be applied

 * \param out           vector to fill in

 */

static void m3gTransformAlignmentTarget(M3Genum target,

                                        const Matrix *transform,

                                        Vec4 *out)

{

	switch (target) {

    case TARGET_ORIGIN:

		*out = Vec4_ORIGIN;

	    break;

	case TARGET_X_AXIS:

		*out = Vec4_X_AXIS;

	    break;

	case TARGET_Y_AXIS:

		*out = Vec4_Y_AXIS;

	    break;

	case TARGET_Z_AXIS:

		*out = Vec4_Z_AXIS;

	    break;

	default:

		M3G_ASSERT(M3G_FALSE);

	}

	m3gTransformVec4(transform, out);

}

/*!

 * \internal

 * \brief Computes a single alignment rotation for a node.

 *

 * \param node              Node object

 * \param srcAxis           source axis

 * \param targetNode        Node object

 * \param targetAxisName    target axis name

 * \param constraint        constraint

 */

static M3Gbool m3gComputeAlignmentRotation(Node *node,

                                           const Vec3 *srcAxis,

                                           const Node *targetNode,

                                           M3Genum targetAxisName,

                                           M3Genum constraint)

{

    const Node *parent = node->parent;

    Matrix transform;

    Vec4 targetAxis;

    M3G_VALIDATE_OBJECT(parent);

    M3G_ASSERT(constraint == TARGET_NONE || constraint == TARGET_Z_AXIS);

    /* Get the transformation from the reference target node to the

     * current node, omitting all components except translation.

     * Rotation is also applied if this is a constrained alignment. */

    {

        const Transformable *tf = &node->transformable;

        if (!m3gGetTransformTo((M3GNode) targetNode, (M3GNode) parent,

                               &transform)) {

            return M3G_FALSE;

        }

        m3gPreTranslateMatrix(&transform, -tf->tx, -tf->ty, -tf->tz);

        if (constraint != TARGET_NONE) {

            Quat rot = tf->orientation;

            rot.w = -rot.w;

            m3gPreRotateMatrixQuat(&transform, &rot);

        }

    }

    m3gTransformAlignmentTarget(targetAxisName, &transform, &targetAxis);

    /* Apply the Z constraint if enabled; this is done by simply

     * zeroing the Z component of the target vector.  If the X and Y

     * alone don't span a non-zero vector, just exit as there's

     * nothing defined to rotate about. */

    if (constraint == TARGET_Z_AXIS) {

        M3Gfloat norm = m3gAdd(m3gMul(targetAxis.x, targetAxis.x),

                               m3gMul(targetAxis.y, targetAxis.y));

        if (norm < 1.0e-5f) {

            return M3G_TRUE;

        }

        norm = m3gRcpSqrt(norm);

        targetAxis.x = m3gMul(targetAxis.x, norm);

        targetAxis.y = m3gMul(targetAxis.y, norm);

        targetAxis.z = 0.0f;

        M3G_ASSERT(srcAxis->z == 0.0f);

    }

    else {

        m3gNormalizeVec3((Vec3*)&targetAxis); /* srcAxis will be unit length */

    }

    if (constraint != TARGET_NONE) {

        Quat rot;