/*

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

 *

 */

 /*!

  * \internal

  * \file

  * \brief Mesh implementation

  */

 #ifndef M3G_CORE_INCLUDE

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

 #endif

 #include "m3g_mesh.h"

 #include "m3g_memory.h"

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

  * Internal functions

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

 /*!

  * \internal

  * \brief Destroys this Mesh object.

  *

  * \param obj Mesh object

  */

 static void m3gDestroyMesh(Object *obj)

 {

     M3Gint i;

     Mesh *mesh = (Mesh *) obj;

     M3G_VALIDATE_OBJECT(mesh);

     for (i = 0; i < mesh->trianglePatchCount; ++i) {

         M3G_ASSIGN_REF(mesh->indexBuffers[i], NULL);

         M3G_ASSIGN_REF(mesh->appearances[i], NULL);

     }

     M3G_ASSIGN_REF(mesh->vertexBuffer, NULL);

 	{

 		Interface *m3g = M3G_INTERFACE(mesh);

 		m3gFree(m3g, mesh->indexBuffers);

 		m3gFree(m3g, mesh->appearances);

 	}

     m3gIncStat(M3G_INTERFACE(obj), M3G_STAT_RENDERABLES, -1);

     m3gDestroyNode(obj);

 }

 /*!

  * \internal

  * \brief Insert a mesh into a rendering queue

  */

 static M3Gbool m3gQueueMesh(Mesh *mesh, const Matrix *toCamera,

                             RenderQueue *renderQueue)

 {

     M3Gint i;

     /* Fetch the cumulative alpha factor for this node */

     mesh->totalAlphaFactor =

         (M3Gushort) m3gGetTotalAlphaFactor((Node*) mesh, renderQueue->root);

     /* Insert each submesh into the rendering queue */

     for (i = 0; i < mesh->trianglePatchCount; i++) {

         if (mesh->appearances[i] != NULL) {

             if (!m3gInsertDrawable(M3G_INTERFACE(mesh),

                                    renderQueue,

                                    (Node*) mesh,

                                    toCamera,

                                    i,

                                    m3gGetAppearanceSortKey(mesh->appearances[i])))

                 return M3G_FALSE;

         }

     }

     return M3G_TRUE;

 }

 /*!

  * \internal

  * \brief Overloaded Node method.

  *

  * Setup mesh rendering by adding all submeshes to

  * the render queue.

  *

  * \param self Mesh 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 m3gMeshSetupRender(Node *self,

                                   const Node *caller,

                                   SetupRenderState *s,

                                   RenderQueue *renderQueue)

 {

 	Mesh *mesh = (Mesh *)self;

     M3G_UNREF(caller);

     m3gIncStat(M3G_INTERFACE(self), M3G_STAT_RENDER_NODES, 1);

 	if ((self->enableBits & NODE_RENDER_BIT) != 0 &&

         (self->scope & renderQueue->scope) != 0) {

         /* Check view frustum culling */

 #       if defined(M3G_ENABLE_VF_CULLING)

         AABB bbox;

         m3gGetBoundingBox(mesh->vertexBuffer, &bbox);

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

         if (s->cullMask == 0) {

             m3gIncStat(M3G_INTERFACE(self),

                        M3G_STAT_RENDER_NODES_CULLED, 1);

             return M3G_TRUE;

         }

 #       endif

         /* No dice, let's render... */

         return m3gQueueMesh(mesh, &s->toCamera, renderQueue);

     }

     return M3G_TRUE;

 }

 /*!

  * \internal

  * \brief Overloaded Node method.

  *

  * Renders one submesh.

  *

  * \param self Mesh object

  * \param ctx current render context

  * \param patchIndex submesh index

  */

 static void m3gMeshDoRender(Node *self,

                             RenderContext *ctx,

                             const Matrix *toCamera,

                             M3Gint patchIndex)

 {

     Mesh *mesh = (Mesh *)self;

 	m3gDrawMesh(ctx,

                 mesh->vertexBuffer,

                 mesh->indexBuffers[patchIndex],

                 mesh->appearances[patchIndex],

                 toCamera,

                 mesh->totalAlphaFactor + 1,

                 self->scope);

 }

 /*!

  * \internal

  * \brief Internal equivalent routine called

  * by m3gMeshRayIntersect.

  *

  * \param mesh      Mesh object

  * \param vertices  VertexBuffer object used in calculations

  * \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 m3gMeshRayIntersectInternal(	Mesh *mesh,

                                             VertexBuffer *vertices,

             								M3Gint mask,

             								M3Gfloat *ray,

             								RayIntersection *ri,

             								Matrix *toGroup)

 {

     Vec3 v0, v1, v2, tuv;

     Vec4 transformed, p0, p1;

     M3Gint indices[4] = { 0, 0, 0, 0 }; 

     M3Gint i, j, k, cullMode;

     Matrix t;   /* Reused as texture transform */

     if (vertices == NULL ||

          mesh->appearances == NULL ||

          mesh->indexBuffers == NULL ||

          (((Node *)mesh)->scope & mask) == 0) {

         return M3G_TRUE;

     }

     if (vertices->vertices == NULL) {

         m3gRaiseError(M3G_INTERFACE(mesh), M3G_INVALID_OPERATION);

         return M3G_FALSE;

     }

     p0.x = ray[0];

     p0.y = ray[1];

     p0.z = ray[2];

     p0.w = 1.f;

     p1.x = ray[3];

     p1.y = ray[4];

     p1.z = ray[5];

     p1.w = 1.f;

     m3gCopyMatrix(&t, toGroup);

     M3G_BEGIN_PROFILE(M3G_INTERFACE(mesh), M3G_PROFILE_TRANSFORM_INVERT);

     if (!m3gInvertMatrix(&t)) {

         m3gRaiseError(M3G_INTERFACE(mesh), M3G_ARITHMETIC_ERROR);

         return M3G_FALSE;

     }

     M3G_END_PROFILE(M3G_INTERFACE(mesh), M3G_PROFILE_TRANSFORM_INVERT);

     m3gTransformVec4(&t, &p0);

     m3gTransformVec4(&t, &p1);

     m3gScaleVec3((Vec3*) &p0, m3gRcp(p0.w));

     m3gScaleVec3((Vec3*) &p1, m3gRcp(p1.w));

     m3gSubVec4(&p1, &p0);

     /* Quick bounding box test for Meshes */

     if (m3gGetClass((Object *)mesh) == M3G_CLASS_MESH) {

         AABB boundingBox;

         m3gGetBoundingBox(vertices, &boundingBox);

         if (!m3gIntersectBox((Vec3*) &p0, (Vec3*) &p1, &boundingBox)) {

             return M3G_TRUE;

         }

     }

     /* Apply the inverse of the vertex scale and bias to the ray */

     if (!IS_ZERO(vertices->vertexScale)) {

         const Vec3 *bias = (const Vec3*) vertices->vertexBias;

         M3Gfloat ooScale = m3gRcp(vertices->vertexScale);

         m3gSubVec3((Vec3*) &p0, bias);

         m3gScaleVec3((Vec3*) &p0, ooScale);

         m3gScaleVec3((Vec3*) &p1, ooScale); /* direction vector -> no bias */

     }

     else {

         m3gRaiseError(M3G_INTERFACE(mesh), M3G_ARITHMETIC_ERROR);

         return M3G_FALSE;

     }

     /* Go through all submeshes */

     for (i = 0; i < mesh->trianglePatchCount; i++) {

         /* Do not pick submeshes with null appearance */

         if (mesh->appearances[i] == NULL ||

             mesh->indexBuffers[i] == NULL) continue;

         /* Validate indices versus vertex buffer */

         if (m3gGetMaxIndex(mesh->indexBuffers[i]) >= m3gGetNumVertices(vertices)) {

             m3gRaiseError(M3G_INTERFACE(mesh), M3G_INVALID_OPERATION);

             return M3G_FALSE;

         }

         if (mesh->appearances[i]->polygonMode != NULL) {

             cullMode = m3gGetWinding(mesh->appearances[i]->polygonMode) == M3G_WINDING_CCW ? 0 : 1;

             switch(m3gGetCulling(mesh->appearances[i]->polygonMode)) {

             case M3G_CULL_FRONT: cullMode ^= 1; break;

             case M3G_CULL_NONE:  cullMode  = 2; break;

             }

         }

         else {

             cullMode = 0;

         }

         /* Go through all triangels */

         for (j = 0; m3gGetIndices(mesh->indexBuffers[i], j, indices); j++) {

             /* Ignore zero area triangles */

             if ( indices[0] == indices[1] ||

                  indices[0] == indices[2] ||

                  indices[1] == indices[2]) continue;

             m3gGetVertex(vertices, indices[0], &v0);

             m3gGetVertex(vertices, indices[1], &v1);

             m3gGetVertex(vertices, indices[2], &v2);

             if (m3gIntersectTriangle((Vec3*)&p0, (Vec3*)&p1, &v0, &v1, &v2, &tuv, indices[3] ^ cullMode)) {

                 /* Check that we are going to fill this intersection */

                 if (tuv.x <= 0.f || tuv.x >= ri->tMin) continue;

                 /* Fill in to RayIntersection */

                 ri->tMin = tuv.x;

                 ri->distance = tuv.x;

                 ri->submeshIndex = i;

                 ri->intersected = (Node *)mesh;

                 /* Fetch normal */

                 if (m3gGetNormal(vertices, indices[0], &v0)) {

                     m3gGetNormal(vertices, indices[1], &v1);

                     m3gGetNormal(vertices, indices[2], &v2);

                     ri->normal[0] = m3gAdd(

                         m3gMul(v0.x, m3gSub(1.f, m3gAdd(tuv.y, tuv.z))),

                         m3gAdd(

                             m3gMul(v1.x, tuv.y),

                             m3gMul(v2.x, tuv.z)));

                     ri->normal[1] = m3gAdd(

                         m3gMul(v0.y, m3gSub(1.f, m3gAdd(tuv.y, tuv.z))),

                         m3gAdd(

                             m3gMul(v1.y, tuv.y),

                             m3gMul(v2.y, tuv.z)));

                     ri->normal[2] = m3gAdd(

                         m3gMul(v0.z, m3gSub(1.f, m3gAdd(tuv.y, tuv.z))),

                         m3gAdd(

                             m3gMul(v1.z, tuv.y),

                             m3gMul(v2.z, tuv.z)));

                 }

                 else {

                     ri->normal[0] = 0.f;

                     ri->normal[1] = 0.f;

                     ri->normal[2] = 1.f;

                 }

                 /* Fetch texture coordinates for each unit */

                 for (k = 0; k < M3G_NUM_TEXTURE_UNITS; k++) {

                     if (m3gGetTexCoord(vertices, indices[0], k, &v0)) {

                         m3gGetTexCoord(vertices, indices[1], k, &v1);

                         m3gGetTexCoord(vertices, indices[2], k, &v2);

                         /* Calculate transformed S and T */

                         transformed.x = m3gAdd(

                             m3gMul(v0.x, m3gSub(1.f, m3gAdd(tuv.y, tuv.z))),

                             m3gAdd(

                                 m3gMul(v1.x, tuv.y),

                                 m3gMul(v2.x, tuv.z)));

                         transformed.y = m3gAdd(

                             m3gMul(v0.y, m3gSub(1.f, m3gAdd(tuv.y, tuv.z))),

                             m3gAdd(

                                 m3gMul(v1.y, tuv.y),

                                 m3gMul(v2.y, tuv.z)));

                         transformed.z = 0;

                         transformed.w = 1;

                         /* Transform and * 1/w */

                         if (mesh->appearances[i]->texture[k] != NULL) {

                             m3gGetCompositeTransform((Transformable *)mesh->appearances[i]->texture[k], &t);

                             m3gTransformVec4(&t, &transformed);

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

                         }

                         ri->textureS[k] = transformed.x;

                         ri->textureT[k] = transformed.y;

                     }

                     else {

                         ri->textureS[k] = 0.f;

                         ri->textureT[k] = 0.f;

                     }

                 }

             }

         }

     }

     return M3G_TRUE;

 }

 /*!

  * \internal

  * \brief Overloaded Node method.

  *

  * Just forward call internal ray intersect.

  *

  * \param self      Mesh 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 m3gMeshRayIntersect( Node *self,

     								M3Gint mask,

     								M3Gfloat *ray,

     								RayIntersection *ri,

     								Matrix *toGroup)

 {

     Mesh *mesh = (Mesh *)self;

     return m3gMeshRayIntersectInternal(mesh, mesh->vertexBuffer, mask, ray, ri, toGroup);

 }

 /*!

  * \internal

  * \brief Initializes a Mesh object. See specification

  * for default values.

  *

  * \param m3g                   M3G interface

  * \param mesh                  Mesh object

  * \param hVertices             VertexBuffer object

  * \param hTriangles            array of IndexBuffer objects

  * \param hAppearances          array of Appearance objects

  * \param trianglePatchCount    number of submeshes

  * \param vfTable               virtual function table

  * \retval                      M3G_TRUE success

  * \retval                      M3G_FALSE failed

  */

 static M3Gbool m3gInitMesh(Interface *m3g,

                            Mesh *mesh,

                            M3GVertexBuffer hVertices,

                            M3GIndexBuffer *hTriangles,

                            M3GAppearance *hAppearances,

                            M3Gint trianglePatchCount,

                            M3GClass classID)

 {

     M3Gint i;

     /* Out of memory if more than 65535 triangle patches */

     if (trianglePatchCount > 65535) {

         m3gRaiseError(m3g, M3G_OUT_OF_MEMORY);

         return M3G_FALSE;

     }

 	for (i = 0; i < trianglePatchCount; i++) {

 		if (hTriangles[i] == NULL) {

 			m3gRaiseError(m3g, M3G_NULL_POINTER);

             return M3G_FALSE;

 		}

 	}

 	mesh->indexBuffers =

         m3gAllocZ(m3g, sizeof(IndexBuffer *) * trianglePatchCount);

 	if (!mesh->indexBuffers) {

 		return M3G_FALSE;

 	}

 	mesh->appearances =

         m3gAllocZ(m3g, sizeof(Appearance *) * trianglePatchCount);

 	if (!mesh->appearances) {

 		m3gFree(m3g, mesh->indexBuffers);

 		return M3G_FALSE;

 	}

 	/* Mesh is derived from node */

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

     mesh->node.hasRenderables = M3G_TRUE;

     mesh->node.dirtyBits |= NODE_BBOX_BIT;

     for (i = 0; i < trianglePatchCount; i++) {

         M3G_ASSIGN_REF(mesh->indexBuffers[i], hTriangles[i]);

     }

 	if (hAppearances != NULL) {

         for (i = 0; i < trianglePatchCount; i++) {

             M3G_ASSIGN_REF(mesh->appearances[i], hAppearances[i]);

         }

 	}

 	else {

 		m3gZero(mesh->appearances, sizeof(Appearance *) * trianglePatchCount);

     }

     M3G_ASSIGN_REF(mesh->vertexBuffer, hVertices);

 	mesh->trianglePatchCount = (M3Gshort) trianglePatchCount;

     m3gIncStat(M3G_INTERFACE(mesh), M3G_STAT_RENDERABLES, 1);

 	return M3G_TRUE;

 }

 /*!

  * \internal

  * \brief Overloaded Object3D method.

  *

  * \param self Mesh object

  * \param references array of reference objects

  * \return number of references

  */

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

 {

     Mesh *mesh = (Mesh *)self;

     M3Gint i, num = m3gObjectDoGetReferences(self, references);

     if (references != NULL)

         references[num] = (Object *)mesh->vertexBuffer;

     num++;

     for (i = 0; i < mesh->trianglePatchCount; i++) {

         if (mesh->indexBuffers[i] != NULL) {

             if (references != NULL)

                 references[num] = (Object *)mesh->indexBuffers[i];

             num++;

         }

         if (mesh->appearances[i] != NULL) {

             if (references != NULL)

                 references[num] = (Object *)mesh->appearances[i];

             num++;

         }

     }

     return num;

 }

 /*!

  * \internal

  * \brief Overloaded Object3D method.

  */

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

 {

     int i;

     Mesh *mesh = (Mesh *)self;

     Object *found = m3gObjectFindID(self, userID);

     if (!found) {

         found = m3gFindID((Object*) mesh->vertexBuffer, userID);

     }    

     for (i = 0; !found && i < mesh->trianglePatchCount; ++i) {

         if (mesh->indexBuffers[i] != NULL) {

             found = m3gFindID((Object*) mesh->indexBuffers[i], userID);

         }

         if (!found && mesh->appearances[i] != NULL) {

             found = m3gFindID((Object*) mesh->appearances[i], userID);

         }

     }

     return found;

 }

 /*!

  * \internal

  * \brief Overloaded Object3D method.

  *

  * \param originalObj original Mesh object

  * \param cloneObj pointer to cloned Mesh object

  * \param pairs array for all object-duplicate pairs

  * \param numPairs number of pairs

  */

 static M3Gbool m3gMeshDuplicate(const Object *originalObj,

                                 Object **cloneObj,

                                 Object **pairs,

                                 M3Gint *numPairs)

 {

     /* Create the clone if it doesn't exist; otherwise we'll be all

      * set by the derived class(es) and can just call through to the

      * base class */

     if (*cloneObj == NULL) {

         Mesh *original = (Mesh *)originalObj;

         Mesh *clone = (Mesh *)m3gCreateMesh(originalObj->interface,

                                             original->vertexBuffer,

                                             original->indexBuffers,

                                             original->appearances,

                                             original->trianglePatchCount);

         *cloneObj = (Object *)clone;

         if (*cloneObj == NULL) {

             return M3G_FALSE;

         }

     }

     return m3gNodeDuplicate(originalObj, cloneObj, pairs, numPairs);

 }

 /*!

  * \internal

  * \brief Overloaded Object3D method.

  *

  * \param self Mesh object

  * \param time current world time

  * \return minimum validity

  */

 static M3Gint m3gMeshApplyAnimation(Object *self, M3Gint time)

 {

     M3Gint validity, minValidity;

     Mesh *mesh = (Mesh *)self;

     Object *vb;

     M3G_VALIDATE_OBJECT(mesh);

     minValidity = m3gObjectApplyAnimation(self, time);

     vb = (Object *) mesh->vertexBuffer;

     if (vb != NULL && minValidity > 0) {

         validity = M3G_VFUNC(Object, vb, applyAnimation)(vb, time);

         minValidity = M3G_MIN(validity, minValidity);

     }

     if (mesh->appearances != NULL) {

         Object *app;

         M3Gint i, n;

         n = mesh->trianglePatchCount;

         for (i = 0; i < n && minValidity > 0; ++i) {

             app = (Object *) mesh->appearances[i];

             if (app != NULL) {

                 validity = M3G_VFUNC(Object, app, applyAnimation)(app, time);

                 minValidity = M3G_MIN(validity, minValidity);

             }

         }

     }

     return minValidity;

 }

 /*!

  * \internal

  * \brief Overloaded Node method

  */

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

 {

     Mesh *mesh = (Mesh *) self;

     VertexBuffer *vb = mesh->vertexBuffer;

     if (vb->vertices) {

         m3gGetBoundingBox(vb, bbox);

         return VFC_BBOX_COST + VFC_NODE_OVERHEAD;

     }

     else {

         return 0;

     }

 }

 /*!

  * \internal

  * \brief Overloaded Node method

  */

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

 {

     Mesh *mesh = (Mesh *) self;

     VertexBuffer *vb = mesh->vertexBuffer;

     int i;

     if ((scope & self->scope) != 0) {

         if (stateBits & self->enableBits) {

             /* Validate vertex buffer components */

             for (i = 0; i < mesh->trianglePatchCount; ++i) {

                 Appearance *app = mesh->appearances[i];

                 if (app) {

                     if (!m3gValidateVertexBuffer(

                             vb, app, m3gGetMaxIndex(mesh->indexBuffers[i]))) {

                         m3gRaiseError(M3G_INTERFACE(mesh), M3G_INVALID_OPERATION);

                         return M3G_FALSE;

                     }

                 }

             }

             /* Invalidate cached vertex stuff if source buffer changed */

             {

                 M3Gint vbTimestamp = m3gGetTimestamp(vb);

                 if (mesh->vbTimestamp != vbTimestamp) {

                     m3gInvalidateNode(self, NODE_BBOX_BIT);

                     mesh->vbTimestamp = vbTimestamp;

                 }

             }

             return m3gNodeValidate(self, stateBits, scope);

         }

     }

     return M3G_TRUE;

 }

 #if 0

 /*!

  * \internal

  * \brief Computes the estimated rendering cost for this Mesh node

  */

 static M3Gint m3gMeshRenderingCost(const Mesh *mesh)

 {

     /* Since we're using strips, just assume that each vertex

      * generates a new triangle... */

     return

         mesh->vertexBuffer->vertexCount * (VFC_VERTEX_COST +

                                            VFC_TRIANGLE_COST) +

         mesh->trianglePatchCount * VFC_RENDERCALL_OVERHEAD +

         VFC_NODE_OVERHEAD;

 }

 #endif

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

  * Virtual function table

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

 static const NodeVFTable m3gvf_Mesh = {

     {

         {

             m3gMeshApplyAnimation,

             m3gNodeIsCompatible,

             m3gNodeUpdateProperty,

             m3gMeshDoGetReferences,

             m3gMeshFindID,

             m3gMeshDuplicate,

             m3gDestroyMesh

         }

     },

     m3gNodeAlign,

     m3gMeshDoRender,

     m3gMeshGetBBox,

     m3gMeshRayIntersect,

     m3gMeshSetupRender,

     m3gNodeUpdateDuplicateReferences,

     m3gMeshValidate

 };

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

  * Public API functions

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

 /*!

  * \brief Creates a Mesh object.

  *

  * \param interface             M3G interface

  * \param hVertices             VertexBuffer object

  * \param hTriangles            array of IndexBuffer objects

  * \param hAppearances          array of Appearance objects

  * \param trianglePatchCount    number of submeshes

  * \retval Mesh new Mesh object

  * \retval NULL Mesh creating failed

  */

 M3G_API M3GMesh m3gCreateMesh(M3GInterface interface,

                               M3GVertexBuffer hVertices,

                               M3GIndexBuffer *hTriangles,

                               M3GAppearance *hAppearances,

                               M3Gint trianglePatchCount)

 {

     Interface *m3g = (Interface *) interface;

     M3G_VALIDATE_INTERFACE(m3g);

 	{

 		Mesh *mesh = m3gAllocZ(m3g, sizeof(Mesh));

 		if (mesh != NULL) {

     		if (!m3gInitMesh(m3g, mesh,

                              hVertices, hTriangles, hAppearances,

                              trianglePatchCount,

                              M3G_CLASS_MESH)) {

     			m3gFree(m3g, mesh);

     			return NULL;

     		}

 		}

 		return (M3GMesh)mesh;

 	}

 }

 /*!

  * \brief Sets submesh appearance.

  *

  * \param handle                Mesh object

  * \param appearanceIndex       submesh index

  * \param hAppearance           Appearance object

  */

 M3G_API void m3gSetAppearance(M3GMesh handle,

                               M3Gint appearanceIndex,

                               M3GAppearance hAppearance)

 {

 	Mesh *mesh = (Mesh *)handle;

     M3G_VALIDATE_OBJECT(mesh);

 	if (appearanceIndex < 0 || appearanceIndex >= mesh->trianglePatchCount) {

 		m3gRaiseError(M3G_INTERFACE(mesh), M3G_INVALID_INDEX);

         return;

 	}

     M3G_ASSIGN_REF(mesh->appearances[appearanceIndex], (Appearance *) hAppearance);

 }

 /*!

  * \brief Gets submesh appearance.

  *

  * \param handle                Mesh object

  * \param idx                   submesh index

  * \return                      Appearance object

  */

 M3G_API M3GAppearance m3gGetAppearance(M3GMesh handle,

                                        M3Gint idx)

 {

 	Mesh *mesh = (Mesh *)handle;

     M3G_VALIDATE_OBJECT(mesh);

 	if (idx < 0 || idx >= mesh->trianglePatchCount) {

 		m3gRaiseError(M3G_INTERFACE(mesh), M3G_INVALID_INDEX);

         return NULL;

 	}

     return mesh->appearances[idx];

 }

 /*!

  * \brief Gets submesh index buffer.

  *

  * \param handle                Mesh object

  * \param idx                   submesh index

  * \return                      IndexBuffer object

  */

 M3G_API M3GIndexBuffer m3gGetIndexBuffer(M3GMesh handle,

                                          M3Gint idx)

 {

 	Mesh *mesh = (Mesh *)handle;

     M3G_VALIDATE_OBJECT(mesh);

 	if (idx < 0 || idx >= mesh->trianglePatchCount) {

 		m3gRaiseError(M3G_INTERFACE(mesh), M3G_INVALID_INDEX);

         return NULL;

 	}

     return mesh->indexBuffers[idx];

 }

 /*!

  * \brief Gets VertexBuffer.

  *

  * \param handle                Mesh object

  * \return                      VertexBuffer object

  */

 M3G_API M3GVertexBuffer m3gGetVertexBuffer(M3GMesh handle)

 {

 	Mesh *mesh = (Mesh *)handle;

     M3G_VALIDATE_OBJECT(mesh);

     return mesh->vertexBuffer;

 }

 /*!

  * \brief Gets submesh count.

  *

  * \param handle                Mesh object

  * \return                      submesh count

  */

 M3G_API M3Gint m3gGetSubmeshCount(M3GMesh handle)

 {

 	Mesh *mesh = (Mesh *)handle;

     M3G_VALIDATE_OBJECT(mesh);

     return mesh->trianglePatchCount;

 }