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