/*

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

*

*/

#ifndef __M3G_NODE_H__

#define __M3G_NODE_H__

/*!

 * \internal

 * \file

 * \brief Node interface

 */

#include "m3g_transformable.h"

#include "m3g_gl.h"

#include "m3g_math.h"

#include "m3g_lightmanager.h"

#include "m3g_renderqueue.h"

#define NODE_ALPHA_FACTOR_BITS  16

/* NOTE: Implementation depends on these values -- do not change! */

#define CULLMASK_OUTSIDE        0x0

#define CULLMASK_INSIDE         0x1

#define CULLMASK_INTERSECTS     0x2

#define CULLMASK_ALL            0xAAA

M3G_CT_ASSERT(CULLMASK_INSIDE == (CULLMASK_INTERSECTS >> 1));

/*

 * Estimated load metrics for VF culling

 *

 */

#define VFC_BBOX_COST           30

#define VFC_NODE_OVERHEAD       10

#define VFC_RENDERCALL_OVERHEAD 15

#define VFC_TRIANGLE_COST       1

#define VFC_VERTEX_COST         1

/*

 * Enable bit masks

 */

#define NODE_RENDER_BIT 0x1

#define NODE_PICK_BIT   0x2

/*!

 * \internal

 * \brief RayIntersection object

*/

struct M3GRayIntersectionImpl

{

    Node *root;

    Camera *camera;

    M3Gfloat x;

    M3Gfloat y;

    M3Gfloat tMin;

	M3Gfloat distance;

	M3Gint submeshIndex;

	M3Gfloat textureS[M3G_NUM_TEXTURE_UNITS];

	M3Gfloat textureT[M3G_NUM_TEXTURE_UNITS];

	M3Gfloat normal[3];

    Node *intersected;

};

/*

RayIntersection Java side result must be in this format.

Offsets Contents

-------------------------------------

0       distance

1       subMeshIndex

2-3     textureS coordinates

4-5     textureT coordinates

6-8     normal coordinates

9-14    ray coordinates and direction

*/

/*!

 * \internal

 * \brief Recursively inherited state passed to each SetupRender call

 */

typedef struct 

{

    Matrix toCamera;

    M3Gbitmask cullMask;

} SetupRenderState;

/* Function pointer prototypes */

typedef M3Gbool (*m3gAlignFuncPtr)			    (Node *self, const Node *refNode);

typedef void    (*m3gDoRenderFuncPtr)		    (Node *self, RenderContext *ctx, const Matrix *toCamera, M3Gint patchIndex);

typedef M3Gint  (*m3gGetBBoxFuncPtr)            (Node *self, AABB *bbox);

typedef M3Gbool (*m3gRayIntersectFuncPtr)       (Node *self, M3Gint mask, M3Gfloat *ray, RayIntersection *ri, Matrix *toGroup);

typedef M3Gbool (*m3gSetupRenderFuncPtr)	    (Node *self, const Node *caller, SetupRenderState *rs, RenderQueue *renderQueue);

typedef void    (*m3gUpdateDuplicateRefFuncPtr)	(Node *self, Object **pairs, M3Gint numPairs);

typedef M3Gbool (*m3gValidate)                  (Node *self, M3Gbitmask state, M3Gint scope);

/*!

 * \internal

 * \brief Node class virtual functions

 */

typedef struct

{

	TransformableVFTable transformable;

	m3gAlignFuncPtr                 align;

	m3gDoRenderFuncPtr              doRender;

    m3gGetBBoxFuncPtr               getBBox;

	m3gRayIntersectFuncPtr          rayIntersect;

	m3gSetupRenderFuncPtr           setupRender;

    m3gUpdateDuplicateRefFuncPtr    updateDuplicateReferences;

    m3gValidate                     validate;

} NodeVFTable;

/*!

 * \internal

 * \brief Node class structure

 *

 */

struct M3GNodeImpl

{

	Transformable transformable;

	/* See default values form RI implementation Node.java */

    /* These scene graph pointers are managed by the Group class */

	Node *parent;

	Node *left;

	Node *right;

	M3Gint scope;

    /* Alignment references */

    Node *zReference;

	Node *yReference;

    /* Various node flags and other bitfield data */

    M3Guint alphaFactor : NODE_ALPHA_FACTOR_BITS;

	M3Guint zTarget     : 3; /* Z alignment target */

	M3Guint yTarget     : 3; /* Y alignment target */

	M3Guint enableBits  : 2; /* Rendering/picking enable bits */

    M3Guint hasBones    : 1; /* Node is part of a SkinnedMesh skeleton */

    M3Guint hasRenderables : 1; /* Node has renderables in its subtree */

    M3Guint dirtyBits   : 2; /* BBox and transform dirty bits */

};

/*!

 * \internal \brief Node bounding box in valid/dirty bitmasks

 */

#define NODE_BBOX_BIT           0x01

/*!

 * \internal \brief Node-child transformations in valid/dirty bitmasks

 */

#define NODE_TRANSFORMS_BIT     0x02

/* Sanity check; check compiler padding settings if this assert fails */

M3G_CT_ASSERT(sizeof(Node) == sizeof(Transformable) + 28);

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

 * Virtual functions

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

static void m3gDestroyNode(Object *obj);

static M3Gbool m3gNodeAlign(Node *self, const Node *refNode);

static M3Gbool m3gNodeDuplicate(const Object *original, Object **clone, Object **pairs, M3Gint *numPairs);

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

static M3Gbool m3gNodeIsCompatible(M3Gint property);

static M3Gbool m3gNodeRayIntersect(Node *self, M3Gint mask, M3Gfloat *ray, RayIntersection *ri, Matrix *toGroup);

static void m3gNodeUpdateProperty(Object *self, M3Gint property, M3Gint valueSize, const M3Gfloat *value);

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

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

static M3G_INLINE M3Gint m3gGetNodeBBox(Node *node, AABB *bbox)

{

    return M3G_VFUNC(Node, node, getBBox)(node, bbox);

}

static M3G_INLINE M3Gbool m3gValidateNode(Node *node, M3Gbitmask stateBits, M3Gint scope) 

{

    return M3G_VFUNC(Node, node, validate)(node, stateBits, scope);

}

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

 * Internal functions

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

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

static M3Guint m3gGetTotalAlphaFactor(Node *node, const Node *root);

static M3Gbool m3gHasEnabledPath(const Node *node, const Node *root);

static M3Gbool m3gHasPickablePath(const Node *node, const Node *root);

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

static Node *m3gGetRoot(const Node *node);

static void m3gInvalidateNode(Node *node, M3Gbitmask flags);

typedef void    (*NodeFuncPtr)  (Node *node, void *params);

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

static void     m3gSetParent    (Node *node, Node *parent);

static Node *m3gGetDuplicatedInstance(Node *self, Object **references, M3Gint numRef);

#if defined(M3G_ENABLE_VF_CULLING)           

static void m3gUpdateCullingMask(SetupRenderState *s, const Camera *cam, const AABB *bbox);

#endif

/*!

 * \internal

 * \brief Type-safe helper function

 */

static M3G_INLINE void m3gGetCompositeNodeTransform(const Node *node, Matrix *mtx)

{

    m3gGetCompositeTransform((Transformable*) node, mtx);

    M3G_ASSERT(m3gIsWUnity(mtx));

}

/*!

 * \internal

 * \brief Type-safe helper function

 */

static M3G_INLINE M3Gbool m3gGetInverseNodeTransform(const Node *node, Matrix *mtx)

{

    M3Gbool ok = m3gGetInverseCompositeTransform((Transformable*) node, mtx);

    M3G_ASSERT(m3gIsWUnity(mtx));

    return ok;

}

#endif /*__M3G_NODE_H__*/