/*

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

*

*/

/*!

 * \internal

 * \file

 * \brief VertexArray implementation

 *

 */

#ifndef M3G_CORE_INCLUDE

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

#endif

#include "m3g_vertexarray.h"

#define DIRTY_ALPHA_FACTOR (-1)

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

 * Private functions

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

/*!

 * \internal

 * \brief Signals that the contents of an array have changed

 */

static M3G_INLINE void m3gInvalidateArray(VertexArray *array)

{

    array->cachedAlphaFactor = DIRTY_ALPHA_FACTOR;

    array->rangeMin = 1;

    array->rangeMax = 0;

    ++array->timestamp;

}

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

 * Internal functions

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

/*!

 * \internal

 * \brief Destroys this VertexArray object.

 *

 * \param obj VertexArray object

 */

static void m3gDestroyVertexArray(Object *obj)

{

    VertexArray *array = (VertexArray *) obj;

    M3G_VALIDATE_OBJECT(array);

    M3G_ASSERT(array->numLocks == 0);

    {

        Interface *m3g = M3G_INTERFACE(array);

        m3gFreeObject(m3g, array->data);

        m3gFreeObject(m3g, array->cachedColors);

    }

    m3gDestroyObject(&array->object);

}

/*!

 * \internal

 * \brief Sends color array to OpenGL.

 *

 * \note Alpha scaling currently prevents an array from being used for

 * anything else while it is being bound as a color array.

 *

 * \param array         VertexArray object

 * \param alphaFactor   1.16 alpha factor in [0, 0x10000]

 */

static void m3gLockColorArray(const VertexArray *array, M3Gint alphaFactor)

{

    Interface *m3g = M3G_INTERFACE(array);

    M3G_VALIDATE_OBJECT(array);

    M3G_ASSERT(!array->mapCount);

    M3G_ASSERT(array->numLocks == 0);

    M3G_ASSERT(m3gInRange(alphaFactor, 0, 0x10000));

    /* With an alpha factor of 1.0, we can just load up the original data */

    if (alphaFactor >= 0x10000) {

        GLenum type = array->elementType;

        if (type >= GL_BYTE && type <= GL_UNSIGNED_SHORT) {

            type |= 0x01; /* force type to unsigned for GL */

        }

        glColorPointer(type == GL_UNSIGNED_BYTE ? 4 : array->elementSize,

                       type,

                       array->stride,

                       m3gMapObject(m3g, array->data));

    }

    else {

        /* With a non-unit alpha factor, we may need to update the

         * cached pre-scaled colors. */

        M3Gubyte* const cache = (M3Gubyte *)

            m3gMapObject(m3g, array->cachedColors);

        if (array->cachedAlphaFactor != alphaFactor) {

            M3Gubyte *dst = cache;

            int i, n;

            M3G_VALIDATE_MEMBLOCK(cache);

            /* Scale the colors, converting from the source format */

            n = array->vertexCount;

            /* Byte colors are always padded to 4 bytes per entry,

             * with the implicit alpha set to 0xFF for RGB colors, so

             * we can do a near-straight copy. */

            switch (array->elementType) {

            case GL_BYTE:

            case GL_UNSIGNED_BYTE:

            {   

                const M3Gubyte *src = (M3Gubyte *)m3gMapObject(m3g,

                                                               array->data);

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

                    *dst++ = *src++;

                    *dst++ = *src++;

                    *dst++ = *src++;

                    {

                        M3Guint tmp = *src++ * (M3Guint) alphaFactor;

                        *dst++ = (M3Gubyte)(tmp >> 16);

                    }

                }

                m3gUnmapObject(m3g, array->data);

                break;

            }

            default:

                M3G_ASSERT(M3G_FALSE);

            }

            ((VertexArray*)array)->cachedAlphaFactor = alphaFactor;

        }

        /* We now have the scaled colors in the cache, so just set the

         * pointer there */

        glColorPointer(4, GL_UNSIGNED_BYTE, 0, cache);

    }

    M3G_ASSERT_GL;

    ++((VertexArray*)array)->numLocks;

}

/*!

 * \internal

 * \brief Creates the color cache required for alpha factors

 */

static M3Gbool m3gCreateAlphaColorCache(VertexArray *array)

{

    M3G_VALIDATE_OBJECT(array);

    M3G_ASSERT(array->cachedColors == 0);

    /* There are always four bytes per color entry */

    array->cachedColors = m3gAllocObject(M3G_INTERFACE(array),

                                         4 * array->vertexCount);

    return (array->cachedColors != 0);

}

/*!

 * \internal

 * \brief Sends normal array to OpenGL.

 *

 * \param array VertexArray object

 */

static void m3gLockNormalArray(const VertexArray *array)

{

    M3G_VALIDATE_OBJECT(array);

    M3G_ASSERT(!array->mapCount);

    glNormalPointer(array->elementType, array->stride,

                    m3gMapObject(M3G_INTERFACE(array), array->data));

    M3G_ASSERT_GL;

    ++((VertexArray*)array)->numLocks;

}

/*!

 * \internal

 * \brief Sends texture coordinate array to OpenGL.

 *

 * \param array VertexArray object

 */

static void m3gLockTexCoordArray(const VertexArray *array)

{

    M3G_VALIDATE_OBJECT(array);

    M3G_ASSERT(!array->mapCount);

    glTexCoordPointer(array->elementSize,

                      array->elementType,

                      array->stride,

                      m3gMapObject(M3G_INTERFACE(array), array->data));

    M3G_ASSERT_GL;

    ++((VertexArray*)array)->numLocks;

}

/*!

 * \internal

 * \brief Sends vertex array to OpenGL.

 *

 * \param array VertexArray object

 */

static void m3gLockVertexArray(const VertexArray *array)

{

    M3G_VALIDATE_OBJECT(array);

    M3G_ASSERT(!array->mapCount);

    glVertexPointer(array->elementSize,

                    array->elementType,

                    array->stride,

                    m3gMapObject(M3G_INTERFACE(array), array->data));

    M3G_ASSERT_GL;

    ++((VertexArray*)array)->numLocks;

}

/*!

 * \internal

 * \brief Decreases array lock count.

 *

 * \param array VertexArray object

 */

static void m3gUnlockArray(const VertexArray *array)

{

    M3G_VALIDATE_OBJECT(array);

    M3G_ASSERT(array->numLocks > 0);

    m3gUnmapObject(M3G_INTERFACE(array), array->data);

    --((VertexArray*)array)->numLocks;

}

/*!

 * \internal

 * \brief Clones a VertexArray.

 *

 * Used by MorphingMesh.

 *

 * \param array VertexArray object

 * \return cloned VertexArray object

 *

 */

static VertexArray *m3gCloneVertexArray(const VertexArray *array)

{

	VertexArray *clone;

	Interface *m3g = M3G_INTERFACE(array);

    M3G_VALIDATE_OBJECT(array);

    M3G_ASSERT(!array->mapCount);

	clone = (VertexArray *) m3gAlloc(m3g, sizeof(VertexArray));

	if (clone == NULL) {

        return NULL;

    }

	m3gCopy(clone, array, sizeof(VertexArray));

    m3gInitObject((Object*) clone, m3g, M3G_CLASS_VERTEX_ARRAY);

	clone->data = m3gAllocObject(m3g, array->vertexCount * array->stride);

	if (!clone->data) {

        m3gDestroyObject((Object*) clone);

		m3gFree(m3g, clone);

		return NULL;

	}

	m3gCopy(m3gMapObject(m3g, clone->data),

            m3gMapObject(m3g, array->data),

            array->vertexCount * array->stride);

    m3gUnmapObject(m3g, clone->data);

    m3gUnmapObject(m3g, array->data);

	return clone;

}

/*!

 * \internal

 * \brief Gets array vertex count.

 *

 * \param array VertexArray object

 * \return number of vertices

 */

static M3Gint m3gGetArrayVertexCount(const VertexArray *array)

{

    return array->vertexCount;

}

/*!

 * \internal

 * \brief Returns the minimum and maximum value stored in the array

 */

static void m3gGetArrayValueRange(const VertexArray *array,

                                  M3Gint *minValue, M3Gint *maxValue)

{

    Interface *m3g = M3G_INTERFACE(array);

    if (array->rangeMin > array->rangeMax) {

        M3Gint count = array->elementSize * array->vertexCount;

        M3Gint minVal = 0, maxVal = 0;

        if (count > 0) {

            switch (array->elementType) {

            case GL_BYTE:

            {

                const GLbyte *src = (const GLbyte*) m3gMapObject(m3g,

                                                                 array->data);

                const M3Gint c = array->elementSize;

                const M3Gint skip = array->stride - c;

                minVal = maxVal = (M3Gint) *src++;

                while (count) {

                    M3Gint i;

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

                        M3Gint v = (M3Gint) *src++;

                        minVal = M3G_MIN(minVal, v);

                        maxVal = M3G_MAX(maxVal, v);

                    }

                    count -= c;

                    src += skip;

                }

                break;

            }

            case GL_UNSIGNED_BYTE:

            {

                const GLubyte *src = (const GLubyte*) m3gMapObject(m3g,

                                                                   array->data);

                const M3Gint c = array->elementSize;

                const M3Gint skip = array->stride - c;

                minVal = maxVal = (M3Gint) *src++;

                while (count) {

                    M3Gint i;

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

                        M3Gint v = (M3Gint) *src++;

                        minVal = M3G_MIN(minVal, v);

                        maxVal = M3G_MAX(maxVal, v);

                    }

                    count -= c;

                    src += skip;

                }

                break;

            }

            case GL_SHORT:

            {

                const GLshort *src = (const GLshort*)

                    m3gMapObject(m3g, array->data);

                minVal = maxVal = (M3Gint) *src++;

                while (--count) {

                    M3Gint v = (M3Gint) *src++;

                    minVal = M3G_MIN(minVal, v);

                    maxVal = M3G_MAX(maxVal, v);

                }

                break;

            }

            case GL_UNSIGNED_SHORT:

            {

                const GLushort *src = (const GLushort*)

                    m3gMapObject(m3g, array->data);

                minVal = maxVal = (M3Gint) *src++;

                while (--count) {

                    M3Gint v = (M3Gint) *src++;

                    minVal = M3G_MIN(minVal, v);

                    maxVal = M3G_MAX(maxVal, v);

                }

                break;

            }

            default:

                M3G_ASSERT(M3G_FALSE);

            }

        }

        m3gUnmapObject(m3g, array->data);

        M3G_ASSERT(m3gInRange(minVal, -32768, 32767));

        M3G_ASSERT(m3gInRange(maxVal, -32768, 32767));

        ((VertexArray*)array)->rangeMin = (M3Gshort) minVal;

        ((VertexArray*)array)->rangeMax = (M3Gshort) maxVal;

    }

    *minValue = array->rangeMin;

    *maxValue = array->rangeMax;

}

/*!

 * \internal

 * \brief Compares attributes of two vertex arrays.

 *

 * \param array         VertexArray object

 * \param other         VertexArray object

 * \retval M3G_TRUE     arrays are compatible

 * \retval M3G_FALSE    arrays are not compatible

 */

static M3Gbool m3gIsCompatible(const VertexArray *array, const VertexArray *other)

{

    return( other != NULL &&

            other->elementType == array->elementType &&

            other->elementSize == array->elementSize &&

            other->vertexCount == array->vertexCount);

}

/*!

 * \internal

 * \brief Overloaded Object3D method.

 *

 * \param originalObj original VertexArray object

 * \param cloneObj pointer to cloned VertexArray object

 * \param pairs array for all object-duplicate pairs

 * \param numPairs number of pairs

 */

static M3Gbool m3gVertexArrayDuplicate(const Object *originalObj,

                                       Object **cloneObj,

                                       Object **pairs,

                                       M3Gint *numPairs)

{

    VertexArray *clone = m3gCloneVertexArray((VertexArray *)originalObj);

    if (!clone) {

        return M3G_FALSE;

    }

    *cloneObj = (Object*) clone;

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

}

/*!

 * \internal

 * \brief Gets array timestamp.

 *

 * \param array VertexArray object

 * \return timestamp

 */

static M3Gint m3gGetArrayTimestamp(const VertexArray *array)

{

    return array->timestamp;

}

/*!

 * \internal

 * \brief Gets array bounding box as shorts.

 *

 * \param array VertexArray object

 * \param boundingBox   array to fill in

 *                      \arg [0] = minX

 *                      \arg [1] = minY

 *                      \arg [2] = minZ

 *                      \arg [3] = maxX

 *                      \arg [4] = maxY

 *                      \arg [5] = maxZ

 */

static void m3gGetArrayBoundingBox(const VertexArray *array, M3Gshort *boundingBox)

{

    Interface *m3g = M3G_INTERFACE(array);

    M3Gint i;

    M3Gshort minX, minY, minZ;

    M3Gshort maxX, maxY, maxZ;

    M3Gbyte *bptr;

    M3Gshort *sptr;

    /* Only support 3 component arrays */

    if (array->elementSize != 3 || array->vertexCount == 0) {

        return;

    }

    switch(array->elementType) {

    case M3G_GLTYPE(M3G_BYTE):

    case M3G_GLTYPE(M3G_UBYTE):

        bptr = (M3Gbyte *) m3gMapObject(m3g, array->data);

        minX = maxX = bptr[0];

        minY = maxY = bptr[1];

        minZ = maxZ = bptr[2];

        bptr += 4;

        for (i = 0; i < array->vertexCount - 1; i++) {

            if (bptr[0] < minX) minX = bptr[0];

            if (bptr[0] > maxX) maxX = bptr[0];

            if (bptr[1] < minY) minY = bptr[1];

            if (bptr[1] > maxY) maxY = bptr[1];

            if (bptr[2] < minZ) minZ = bptr[2];

            if (bptr[2] > maxZ) maxZ = bptr[2];

            bptr += 4;

        }

        break;

    case M3G_GLTYPE(M3G_SHORT):

    case M3G_GLTYPE(M3G_USHORT):

        sptr = (M3Gshort *) m3gMapObject(m3g, array->data);

        minX = maxX = sptr[0];

        minY = maxY = sptr[1];

        minZ = maxZ = sptr[2];

        sptr += 3;

        for (i = 0; i < array->vertexCount - 1; i++) {

            if (sptr[0] < minX) minX = sptr[0];

            if (sptr[0] > maxX) maxX = sptr[0];

            if (sptr[1] < minY) minY = sptr[1];

            if (sptr[1] > maxY) maxY = sptr[1];

            if (sptr[2] < minZ) minZ = sptr[2];

            if (sptr[2] > maxZ) maxZ = sptr[2];

            sptr += 3;

        }

        break;

    default: /* Error */

        M3G_ASSERT(0);

        return;

    }

    m3gUnmapObject(m3g, array->data);

    boundingBox[0] = minX;

    boundingBox[1] = minY;