/*

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

*

*/

/*!

 * \internal

 * \file

 * \brief MorphingMesh implementation

 *

 */

#ifndef M3G_CORE_INCLUDE

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

#endif

#include "m3g_morphingmesh.h"

#include "m3g_memory.h"

#include "m3g_animationtrack.h"

#define WEIGHT_SHIFT        ( 8 )

#define WEIGHT_SCALE        ( 1 << WEIGHT_SHIFT )

#define WEIGHT_ROUND_PLUS   ( WEIGHT_SCALE / 4 )

#define WEIGHT_ROUND_MINUS  ( 0 )

/*!

 * \internal

 * \brief offsetof macro

 */

#include <stddef.h>

static M3Gbool m3gMorph(MorphingMesh *momesh);

static M3Gbool m3gCreateClones(VertexBuffer *vertices, VertexBuffer *morphed);

static void m3gDeleteClones(VertexBuffer *morphed);

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

 * Internal functions

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

/*!

 * \internal

 * \brief Destroys this MorphingMesh object.

 *

 * \param obj MorphingMesh object

 */

static void m3gDestroyMorphingMesh(Object *obj)

{

    M3Gint i;

    MorphingMesh *momesh = (MorphingMesh *) obj;

    M3G_VALIDATE_OBJECT(momesh);

    for (i = 0; i < momesh->numTargets; i++) {

        M3G_ASSIGN_REF(momesh->targets[i], NULL);

    }

    M3G_ASSIGN_REF(momesh->morphed, NULL);

    {

        Interface *m3g = M3G_INTERFACE(momesh); 

        m3gFree(m3g, momesh->targets);

        m3gFree(m3g, momesh->weights);

        m3gFree(m3g, momesh->floatWeights);

    }

    m3gDestroyMesh(obj);

}

/*!

 * \internal

 * \brief Overloaded Node method.

 *

 * Setup morphing mesh render. Morph and call Mesh

 * render setup.

 *

 * \param self MorphingMesh 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 m3gMorphingMeshSetupRender(Node *self,

                                          const Node *caller,

                                          SetupRenderState *s,

                                          RenderQueue *renderQueue)

{

    MorphingMesh *momesh = (MorphingMesh *)self;

    M3G_UNREF(caller);

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

    momesh->dirtyState = M3G_TRUE;

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

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

        /* Try view frustum culling */

#       if defined(M3G_ENABLE_VF_CULLING)

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

        if (s->cullMask == 0) {

            m3gIncStat(M3G_INTERFACE(self),

                       M3G_STAT_RENDER_NODES_CULLED, 1);

            return M3G_TRUE;

        }

#       endif

        /* No dice, must morph & render */

        M3G_BEGIN_PROFILE(M3G_INTERFACE(momesh), M3G_PROFILE_MORPH);

        if (!m3gMorph(momesh)) {

            return M3G_FALSE;

        }

        M3G_END_PROFILE(M3G_INTERFACE(momesh), M3G_PROFILE_MORPH);

        return m3gQueueMesh((Mesh*) self, &s->toCamera, renderQueue);

    }

    return M3G_TRUE;

}

/*!

 * \internal

 * \brief Overloaded Node method.

 *

 * Renders one submesh.

 *

 * \param self MorphingMesh object

 * \param ctx current render context

 * \param patchIndex submesh index

 */

static void m3gMorphingMeshDoRender(Node *self,

                                    RenderContext *ctx,

                                    const Matrix *toCamera,

                                    M3Gint patchIndex)

{

    MorphingMesh *momesh = (MorphingMesh *)self;

    Mesh *mesh = (Mesh *)self;

    m3gDrawMesh(ctx,

                momesh->morphed,

                mesh->indexBuffers[patchIndex],

                mesh->appearances[patchIndex],

                toCamera,

                mesh->totalAlphaFactor + 1,

                self->scope);

}

/*!

 * \internal

 * \brief Overloaded Node method.

 *

 * Morph and forward call Mesh internal ray intersect.

 *

 * \param self      MorphingMesh 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 m3gMorphingMeshRayIntersect( Node *self,

                                            M3Gint mask,

                                            M3Gfloat *ray,

                                            RayIntersection *ri,

                                            Matrix *toGroup)

{

    MorphingMesh *momesh = (MorphingMesh *)self;

    M3G_BEGIN_PROFILE(M3G_INTERFACE(momesh), M3G_PROFILE_MORPH);

    if (!m3gMorph(momesh)) {

        return M3G_FALSE;

    }

    M3G_END_PROFILE(M3G_INTERFACE(momesh), M3G_PROFILE_MORPH);

    return m3gMeshRayIntersectInternal(&momesh->mesh, momesh->morphed, mask, ray, ri, toGroup);

}

/*!

 * \internal

 * \brief Morphes short type vertex arrays.

 *

 * \param momesh        MorphingMesh object

 * \param dsta          destination VertexArray object

 * \param base          base VertexArray object

 * \param arrayOffset   offset to VertexArray object inside Mesh object

 * \retval M3G_TRUE     morph ok

 * \retval M3G_FALSE    morph failed, exception raised

 */

static M3Gbool m3gMorphShorts(MorphingMesh *momesh, VertexArray *dsta, VertexArray *base, M3Gint arrayOffset)

{

    M3Gint i;

    M3Gint sum, sw;

    M3Gshort *dst, *src;

    M3Gshort j, numMsTargets = 0;

    M3Gshort **srct = m3gAllocTemp(M3G_INTERFACE(momesh), sizeof(M3Gshort *) * momesh->numTargets * 2);

    M3Gshort *msTargets = (M3Gshort *) (srct + momesh->numTargets);

    if (msTargets == NULL) {

        return M3G_FALSE;

    }

    /* Check that target arrays are in same format */

    for (j = 0; j < momesh->numTargets; j++) {

        VertexArray **va;

        va = (VertexArray **)(((M3Gbyte *)momesh->targets[j]) + arrayOffset);

        if (!m3gIsCompatible(*va, base)) {

            /* Unmap all arrays */

            for (j = 0; j < numMsTargets; j++) {

                m3gUnmapVertexArray(*(VertexArray **)(((M3Gbyte *)momesh->targets[msTargets[j]]) + arrayOffset));

            }

            m3gFreeTemp(M3G_INTERFACE(momesh));

            m3gRaiseError(M3G_INTERFACE(momesh), M3G_INVALID_OPERATION);

            return M3G_FALSE;

        }

        /* Use only most significant targets*/

        if (momesh->weights[j] != 0) {

            msTargets[numMsTargets] = j;

            srct[numMsTargets] = (M3Gshort *) m3gMapVertexArrayReadOnly(*va);

            numMsTargets++;

        }

    }

    dst = (M3Gshort *) m3gMapVertexArray(dsta);

    src = (M3Gshort *) m3gMapVertexArrayReadOnly(base);

    sw = momesh->sumWeights;

    for (i = 0; i < base->vertexCount * base->elementSize; i++) {

        sum = src[i] * sw;

        for (j = 0; j < numMsTargets; j++) {

            sum += srct[j][i] * momesh->weights[msTargets[j]];

        }

        /* Round */

        if (sum >= 0) {

            sum += WEIGHT_ROUND_PLUS;

        }

        else {

            sum -= WEIGHT_ROUND_MINUS;

        }

        dst[i] = (M3Gshort)(sum >> WEIGHT_SHIFT);

    }

    /* Unmap all arrays */

    for (j = 0; j < numMsTargets; j++) {

        m3gUnmapVertexArray(*(VertexArray **)(((M3Gbyte *)momesh->targets[msTargets[j]]) + arrayOffset));

    }

    m3gUnmapVertexArray(base);

    m3gUnmapVertexArray(dsta);

    m3gFreeTemp(M3G_INTERFACE(momesh));

    return M3G_TRUE;

}

/*!

 * \internal

 * \brief Morphes byte type vertex arrays.

 *

 * \param momesh        MorphingMesh object

 * \param dsta          destination VertexArray object

 * \param base          base VertexArray object

 * \param arrayOffset   offset to VertexArray object inside Mesh object

 * \retval M3G_TRUE     morph ok

 * \retval M3G_FALSE    morph failed, exception raised

 */

static M3Gbool m3gMorphBytes(MorphingMesh *momesh, VertexArray *dsta, VertexArray *base, M3Gint arrayOffset)

{

    M3Gint i;

    M3Gint sum, sw;

    M3Gbyte *dst, *src;

    M3Gint skip;

    M3Gshort j, numMsTargets = 0;

    M3Gbyte **srct = m3gAllocTemp(M3G_INTERFACE(momesh), sizeof(M3Gbyte *) * momesh->numTargets * 2);

    M3Gshort *msTargets = (M3Gshort *) (srct + momesh->numTargets);

    if (msTargets == NULL) {

        return M3G_FALSE;

    }

    /* Check that target arrays are in same format */

    for (j = 0; j < momesh->numTargets; j++) {

        VertexArray **va;

        va = (VertexArray **)(((M3Gbyte *)momesh->targets[j]) + arrayOffset);

        if (!m3gIsCompatible(*va, base)) {

            /* Unmap all arrays */

            for (j = 0; j < numMsTargets; j++) {

                m3gUnmapVertexArray(*(VertexArray **)(((M3Gbyte *)momesh->targets[msTargets[j]]) + arrayOffset));

            }

            m3gFreeTemp(M3G_INTERFACE(momesh));

            m3gRaiseError(M3G_INTERFACE(momesh), M3G_INVALID_OPERATION);

            return M3G_FALSE;

        }

        /* Use only most significant targets*/

        if (momesh->weights[j] != 0) {

            msTargets[numMsTargets] = j;

            srct[numMsTargets] = (M3Gbyte *) m3gMapVertexArrayReadOnly(*va);

            numMsTargets++;

        }

    }

    dst = (M3Gbyte *) m3gMapVertexArray(dsta);

    src = (M3Gbyte *) m3gMapVertexArrayReadOnly(base);

    sw = momesh->sumWeights;

    skip = base->elementSize;

    for (i = 0; i < base->vertexCount * base->stride; i++) {

        if ((i & 3) >= skip) continue;

        sum = src[i] * sw;

        for (j = 0; j < numMsTargets; j++) {

            sum += srct[j][i] * momesh->weights[msTargets[j]];

        }

        /* Round */

        if (sum >= 0) {

            sum += WEIGHT_ROUND_PLUS;

        }

        else {

            sum -= WEIGHT_ROUND_MINUS;

        }

        dst[i] = (M3Gbyte)(sum >> WEIGHT_SHIFT);

    }

    /* Unmap all arrays */

    for (j = 0; j < numMsTargets; j++) {

        m3gUnmapVertexArray(*(VertexArray **)(((M3Gbyte *)momesh->targets[msTargets[j]]) + arrayOffset));

    }

    m3gUnmapVertexArray(base);

    m3gUnmapVertexArray(dsta);

    m3gFreeTemp(M3G_INTERFACE(momesh));

    return M3G_TRUE;

}

/*!

 * \internal

 * \brief Morphes byte type color vertex arrays.

 *

 * \param momesh        MorphingMesh object

 * \param dsta          destination VertexArray object

 * \param base          base VertexArray object

 * \param arrayOffset   offset to VertexArray object inside Mesh object

 * \retval M3G_TRUE     morph ok

 * \retval M3G_FALSE    morph failed, exception raised

 */

static M3Gbool m3gMorphColorBytes(MorphingMesh *momesh, VertexArray *dsta, VertexArray *base, M3Gint arrayOffset)

{

    M3Gint i;

    M3Gint sum, sw;

    M3Gubyte *dst, *src;

    M3Gint skip;

    M3Gshort j, numMsTargets = 0;

    M3Gubyte **srct = m3gAllocTemp(M3G_INTERFACE(momesh), sizeof(M3Gubyte *) * momesh->numTargets * 2);

    M3Gshort *msTargets = (M3Gshort *) (srct + momesh->numTargets);

    if (msTargets == NULL) {

        return M3G_FALSE;

    }

    /* Check that target arrays are in same format */

    for (j = 0; j < momesh->numTargets; j++) {

        VertexArray **va;

        va = (VertexArray **)(((M3Gbyte *)momesh->targets[j]) + arrayOffset);

        if (!m3gIsCompatible(*va, base)) {

            /* Unmap all arrays */

            for (j = 0; j < numMsTargets; j++) {

                m3gUnmapVertexArray(*(VertexArray **)(((M3Gbyte *)momesh->targets[msTargets[j]]) + arrayOffset));

            }

            m3gFreeTemp(M3G_INTERFACE(momesh));

            m3gRaiseError(M3G_INTERFACE(momesh), M3G_INVALID_OPERATION);

            return M3G_FALSE;

        }

        /* Use only most significant targets*/

        if (momesh->weights[j] != 0) {

            msTargets[numMsTargets] = j;

            srct[numMsTargets] = (M3Gubyte *) m3gMapVertexArrayReadOnly(*va);

            numMsTargets++;

        }

    }

    dst = (M3Gubyte *) m3gMapVertexArray(dsta);

    src = (M3Gubyte *) m3gMapVertexArray(base);

    sw = momesh->sumWeights;

    skip = base->elementSize;

    for (i = 0; i < base->vertexCount * base->stride; i++) {

        if ((i & 3) >= skip) continue;

        sum = src[i] * sw;

        for (j = 0; j < numMsTargets; j++) {

            sum += srct[j][i] * momesh->weights[msTargets[j]];

        }

        /* Round */

        sum += WEIGHT_ROUND_PLUS;

        /* Clamp */

        if (sum > 255 * WEIGHT_SCALE) sum = 255 * WEIGHT_SCALE;

        dst[i] = (M3Gubyte) (sum >> WEIGHT_SHIFT);

    }

    /* Unmap all arrays */

    for (j = 0; j < numMsTargets; j++) {

        m3gUnmapVertexArray(*(VertexArray **)(((M3Gbyte *)momesh->targets[msTargets[j]]) + arrayOffset));

    }

    m3gUnmapVertexArray(base);

    m3gUnmapVertexArray(dsta);

    m3gFreeTemp(M3G_INTERFACE(momesh));

    return M3G_TRUE;

}

/*!

 * \internal

 * \brief Morphes all MorphingMesh vertex arrays. That

 * is positions, normals, texture coordinates and colors.

 *

 * \param momesh        MorphingMesh object

 * \retval M3G_TRUE     morph ok

 * \retval M3G_FALSE    morph failed, exception raised

 */

static M3Gbool m3gMorph(MorphingMesh *momesh)

{

    M3Gint i, j;

    M3Gint nullValues;

    if (momesh->cloneArrayMask != m3gGetArrayMask(momesh->base)) {

        if (!m3gCreateClones(momesh->base, momesh->morphed)) {

            return M3G_FALSE;

        }

        momesh->cloneArrayMask = m3gGetArrayMask(momesh->base);

        momesh->dirtyState = M3G_TRUE;

    }

    if (momesh->dirtyState == M3G_FALSE) return M3G_TRUE;

    if (momesh->base->vertices != NULL) {

        nullValues = 0;

        for (i = 0; i < momesh->numTargets; i++) {

            if (momesh->targets[i]->vertices == NULL) {

                nullValues++;

            }           

        }

        if (nullValues != momesh->numTargets && nullValues != 0) {

            m3gRaiseError(M3G_INTERFACE(momesh), M3G_INVALID_OPERATION);

            return M3G_FALSE;

        }

        if (nullValues == 0) {

            if (momesh->base->vertices->elementType == M3G_GLTYPE(M3G_SHORT)) {

                if (!m3gMorphShorts( momesh,

                                     momesh->morphed->vertices,

                                     momesh->base->vertices,

                                     offsetof(VertexBuffer, vertices) )) return M3G_FALSE;

            }

            else {

                if (!m3gMorphBytes(  momesh,

                                     momesh->morphed->vertices,

                                     momesh->base->vertices,

                                     offsetof(VertexBuffer, vertices) )) return M3G_FALSE;

            }

        }

        else {

            m3gCopy(m3gMapVertexArray(momesh->morphed->vertices),

                    m3gMapVertexArrayReadOnly(momesh->base->vertices),

                    momesh->base->vertices->stride * momesh->base->vertices->vertexCount );

            m3gUnmapVertexArray(momesh->base->vertices);

            m3gUnmapVertexArray(momesh->morphed->vertices);

        }

    }

    else {

        for (i = 0; i < momesh->numTargets; i++) {

            if (momesh->targets[i]->vertices != NULL) {

                m3gRaiseError(M3G_INTERFACE(momesh), M3G_INVALID_OPERATION);

                return M3G_FALSE;

            }           

        }

    }

    if (momesh->base->normals != NULL) {

        nullValues = 0;

        for (i = 0; i < momesh->numTargets; i++) {

            if (momesh->targets[i]->normals == NULL) {

                nullValues++;

            }           

        }

        if (nullValues != momesh->numTargets && nullValues != 0) {

            m3gRaiseError(M3G_INTERFACE(momesh), M3G_INVALID_OPERATION);

            return M3G_FALSE;

        }

        if (nullValues == 0) {

            if (momesh->base->normals->elementType == M3G_GLTYPE(M3G_SHORT)) {

                if (!m3gMorphShorts( momesh,

                                     momesh->morphed->normals,

                                     momesh->base->normals,

                                     offsetof(VertexBuffer, normals) )) return M3G_FALSE;

            }

            else {

                if (!m3gMorphBytes(  momesh,

                                     momesh->morphed->normals,

                                     momesh->base->normals,

                                     offsetof(VertexBuffer, normals) )) return M3G_FALSE;

            }

        }

        else {

            m3gCopy(m3gMapVertexArray(momesh->morphed->normals),

                    m3gMapVertexArrayReadOnly(momesh->base->normals),

                    momesh->base->normals->stride * momesh->base->normals->vertexCount );

            m3gUnmapVertexArray(momesh->base->normals);

            m3gUnmapVertexArray(momesh->morphed->normals);

        }

    }

    else {