/*

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