/*

* 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: Vertex buffer implementation

*

*/

/*!

 * \internal

 * \file

 * \brief Vertex buffer implementation

 */

#ifndef M3G_CORE_INCLUDE

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

#endif

#include "m3g_vertexbuffer.h"

#include "m3g_vertexarray.h"

#include "m3g_appearance.h"

#include "m3g_node.h" /* for NODE_ALPHA_FACTOR_BITS */

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

 * Private functions

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

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

 * Internal functions

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

/*!

 * \internal

 * \brief Deletes a vertex buffer

 *

 * \param obj VertexBuffer object

 */

static void m3gDestroyVertexBuffer(Object *obj)

{

    M3Gint i;

    VertexBuffer *buffer = (VertexBuffer *) obj;

    M3G_VALIDATE_OBJECT(buffer);

    if (buffer->locked) {

        M3G_ASSERT(M3G_FALSE);

        m3gReleaseVertexBuffer(buffer);

    }

    M3G_ASSIGN_REF(buffer->vertices, NULL);

    M3G_ASSIGN_REF(buffer->normals, NULL);

    M3G_ASSIGN_REF(buffer->colors, NULL);

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

        M3G_ASSIGN_REF(buffer->texCoords[i], NULL);

    }

    m3gDestroyObject(&buffer->object);

}

/*!

 * \internal

 * \brief Applies the scale and bias values of a vertex buffer to the

 * current GL state

 *

 * The scale and bias transformations are applied to the existing

 * values in the GL_MODELVIEW and GL_TEXTURE matrix stacks.

 *

 * \param buffer VertexBuffer object

 */

static void m3gApplyScaleAndBias(const VertexBuffer *buffer)

{

    M3G_VALIDATE_OBJECT(buffer);

    glMatrixMode(GL_TEXTURE);

    {

        M3Gint i;

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

            if (buffer->texCoords[i] != NULL) {

                glActiveTexture((GLenum)(GL_TEXTURE0 + i));

                glTranslatef(buffer->texCoordBias[i][0],

                             buffer->texCoordBias[i][1],

                             buffer->texCoordBias[i][2]);

                glScalef(buffer->texCoordScale[i],

                         buffer->texCoordScale[i],

                         buffer->texCoordScale[i]);

            }

        }

    }

    glMatrixMode(GL_MODELVIEW);

    if (buffer->vertices != NULL) {

        glTranslatef(buffer->vertexBias[0],

                     buffer->vertexBias[1],

                     buffer->vertexBias[2]);

        glScalef(buffer->vertexScale,

                 buffer->vertexScale,

                 buffer->vertexScale);

    }

}

/*!

 * \internal

 * \brief Locks a vertex buffer for subsequent rendering

 *

 * \param buffer        VertexBuffer object

 * \param alphaFactor   alpha factor as 1.16 fixed point

 */

static void m3gLockVertexBuffer(const VertexBuffer *buffer,

                                M3Gint alphaFactor)

{

    M3G_VALIDATE_OBJECT(buffer);

    M3G_ASSERT(!buffer->locked);

    if (buffer->colors != NULL) {

        glEnableClientState(GL_COLOR_ARRAY);

        m3gLockColorArray(buffer->colors, alphaFactor);

    }

    else {

        GLfixed r = buffer->defaultColor.r;

        GLfixed g = buffer->defaultColor.g;

        GLfixed b = buffer->defaultColor.b;

        GLfixed a = buffer->defaultColor.a * alphaFactor;

        r = (r << 8) + r + (r >> 7);

        g = (g << 8) + g + (g >> 7);

        b = (b << 8) + b + (b >> 7);

        a = (a >> (NODE_ALPHA_FACTOR_BITS - 8))

            + (a >> NODE_ALPHA_FACTOR_BITS)

            + (a >> (NODE_ALPHA_FACTOR_BITS + 7));

        glDisableClientState(GL_COLOR_ARRAY);

        glColor4x(r, g, b, a);

    }

    if (buffer->normals != NULL) {

        glEnableClientState(GL_NORMAL_ARRAY);

        m3gLockNormalArray(buffer->normals);

    }

    else {

        glDisableClientState(GL_NORMAL_ARRAY);

    }

    if (buffer->vertices != NULL) {

        glEnableClientState(GL_VERTEX_ARRAY);

        m3gLockVertexArray(buffer->vertices);

    }

    else {

        glDisableClientState(GL_VERTEX_ARRAY);

    }

    {

        M3Gint i;

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

            const VertexArray *array = buffer->texCoords[i];

            glClientActiveTexture(GL_TEXTURE0 + i);

            glActiveTexture(GL_TEXTURE0 + i);

            if (array != NULL) {

                glEnableClientState(GL_TEXTURE_COORD_ARRAY);

                m3gLockTexCoordArray(array);

            }

            else {

                glDisableClientState(GL_TEXTURE_COORD_ARRAY);

            }    

        }

    }

    ((VertexBuffer*)buffer)->locked = M3G_TRUE;

}

/*!

 * \internal

 * \brief Releases a vertex buffer

 *

 * \param buffer        VertexBuffer object

 */

static void m3gReleaseVertexBuffer(const VertexBuffer *buffer)

{

    M3G_VALIDATE_OBJECT(buffer);

    M3G_ASSERT(buffer->locked);

    if (buffer->colors != NULL) {

        m3gUnlockArray(buffer->colors);

    }

    if (buffer->normals != NULL) {

        m3gUnlockArray(buffer->normals);

    }

    if (buffer->vertices != NULL) {

        m3gUnlockArray(buffer->vertices);

    }

    {

        M3Gint i;

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

            const VertexArray *array = buffer->texCoords[i];

            if (array != NULL) {

                m3gUnlockArray(array);

            }

        }

    }

    ((VertexBuffer*)buffer)->locked = M3G_FALSE;

}

/*!

 * \internal

 * \brief Gets a vertex position. Scale and bias

 * are not applied.

 *

 * \param buffer    VertexBuffer object

 * \param idx       index of coordinate

 * \param v         vector to fill in

 * \retval          M3G_TRUE get ok

 * \retval          M3G_FALSE no such vertex

 */

static M3Gbool m3gGetVertex(const VertexBuffer *buffer, M3Gint idx, M3GVec3 *v)

{

}

/*!

 * \internal

 * \brief Gets a normal coordinate.

 *

 * \param buffer    VertexBuffer object

 * \param idx       index of coordinate

 * \param v         vector to fill in

 * \retval          M3G_TRUE get ok

 * \retval          M3G_FALSE no such vertex

 */

static M3Gbool m3gGetNormal(const VertexBuffer *buffer, M3Gint idx, M3GVec3 *v)

{

}

/*!

 * \internal

 * \brief Gets a texture coordinate, used in pick routines.

 * Scale and bias are applied to the coordinates.

 *

 * \param buffer    VertexBuffer object

 * \param idx       index of coordinate

 * \param unit      texturing unit

 * \param v         vector to fill in

 * \retval          M3G_TRUE get ok

 * \retval          M3G_FALSE no such vertex

 */

static M3Gbool m3gGetTexCoord(const VertexBuffer *buffer, M3Gint idx, M3Gint unit, M3GVec3 *v)

{

    v->x = m3gMul(v->x, buffer->texCoordScale[unit]);

    v->y = m3gMul(v->y, buffer->texCoordScale[unit]);

    v->x = m3gAdd(v->x, buffer->texCoordBias[unit][0]);

    v->y = m3gAdd(v->y, buffer->texCoordBias[unit][1]);

    v->z = 0.f;

    return res;

}

/*!

 * \internal

 * \brief Gets vertex buffer positions bounding box.

 *

 * The bounding box is returned as floats, with scale and bias

 * applied.

 *

 * \param buffer        VertexBuffer object

 * \param boundingBox   bounding box float array

 */

static void m3gGetBoundingBox(VertexBuffer *vb, AABB *boundingBox)

{

    /* If timestamp is changed, refresh bounding box */

    if (vb->vertices && (m3gGetArrayTimestamp(vb->vertices)

                         != vb->verticesTimestamp)) {

        M3Gshort ab[6];

        vb->verticesTimestamp = m3gGetArrayTimestamp(vb->vertices);

        m3gGetArrayBoundingBox(vb->vertices, ab);

        vb->bbox.min[0] = m3gMadd(ab[0], vb->vertexScale, vb->vertexBias[0]);

        vb->bbox.min[1] = m3gMadd(ab[1], vb->vertexScale, vb->vertexBias[1]);

        vb->bbox.min[2] = m3gMadd(ab[2], vb->vertexScale, vb->vertexBias[2]);

        vb->bbox.max[0] = m3gMadd(ab[3], vb->vertexScale, vb->vertexBias[0]);

        vb->bbox.max[1] = m3gMadd(ab[4], vb->vertexScale, vb->vertexBias[1]);

        vb->bbox.max[2] = m3gMadd(ab[5], vb->vertexScale, vb->vertexBias[2]);

        /* Flip the bounding box if the scale was negative */

        if (vb->vertexScale < 0) {

            M3Gint i;

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

                M3Gfloat t = vb->bbox.min[i];

                vb->bbox.min[i] = vb->bbox.max[i];

                vb->bbox.max[i] = t;

            }

        }

    }

    *boundingBox = vb->bbox;

}

/*!

 * \internal

 * \brief Gets vertex buffer timestamp.

 *

 * \param buffer        VertexBuffer object

 * \return timestamp

 */

static M3Gint m3gGetTimestamp(const VertexBuffer *buffer)

{

    if (buffer->vertices &&

        m3gGetArrayTimestamp(buffer->vertices) != buffer->verticesTimestamp) {

        return buffer->timestamp + 1;

    }

    return buffer->timestamp;

}

/**

 * Updates the vertex count bookkeeping when setting vertex

 * arrays.

 *

 * \param buffer        VertexBuffer object

 * \param oldArray      VertexArray object

 * \param newArray      VertexArray object

 * \param maskBit       array mask bit

 */

static void m3gUpdateArray(VertexBuffer *buffer,

                           VertexArray *oldArray,

                           VertexArray *newArray,

                           M3Gbitmask maskBit)

{

    M3Gint change = (oldArray == NULL && newArray != NULL) ?  1 :

        (oldArray != NULL && newArray == NULL) ? -1 :

        0;

    /* If adding or replacing an array, set the initial vertex count,

     * or compare the new array against the current vertex count */

    if (newArray != NULL) {

    	if (buffer->arrayCount == 0 || (buffer->arrayCount == 1

                                        && change == 0)) {

    		buffer->vertexCount = m3gGetArrayVertexCount(newArray);

    	}

    	else if (m3gGetArrayVertexCount(newArray) != buffer->vertexCount) {

            m3gRaiseError(M3G_INTERFACE(buffer), M3G_INVALID_VALUE);

            return;

    	}

    }

    /* Update the array bitmask */

    if (newArray != NULL) {

        buffer->arrayMask |= maskBit;

    }

    else {

        buffer->arrayMask &= ~maskBit;

    }

    /* Update the array count, and reset the vertex count to zero if

     * no arrays remain */

    buffer->arrayCount += change;

    if (buffer->arrayCount == 0) {

        M3G_ASSERT(buffer->arrayMask == 0);

        buffer->vertexCount = 0;

    }

}

/*!

 * \internal

 * \brief Overloaded Object3D method

 *

 * \param self VertexBuffer object

 * \param references array of reference objects

 * \return number of references

 */

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

{

    VertexBuffer *vb = (VertexBuffer *)self;

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

    if (vb->vertices != NULL) {

        if (references != NULL)

            references[num] = (Object *)vb->vertices;

        num++;

    }

    if (vb->normals != NULL) {

        if (references != NULL)

            references[num] = (Object *)vb->normals;

        num++;

    }

    if (vb->colors != NULL) {

        if (references != NULL)

            references[num] = (Object *)vb->colors;

        num++;

    }

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

        if (vb->texCoords[i] != NULL) {

            if (references != NULL)

                references[num] = (Object *)vb->texCoords[i];

            num++;

        }

    }

    return num;

}

/*!

 * \internal

 * \brief Overloaded Object3D method

 */

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

{

    int i;

    VertexBuffer *vb = (VertexBuffer *)self;

    Object *found = m3gObjectFindID(self, userID);

    if (!found && vb->vertices != NULL) {

        found = m3gFindID((Object*) vb->vertices, userID);

    }

    if (!found && vb->normals != NULL) {

        found = m3gFindID((Object*) vb->normals, userID);

    }

    if (!found && vb->colors != NULL) {

        found = m3gFindID((Object*) vb->colors, userID);

    }

    for (i = 0; !found && i < M3G_NUM_TEXTURE_UNITS; ++i) {

        if (vb->texCoords[i] != NULL) {

            found = m3gFindID((Object*) vb->texCoords[i], userID);

        }

    }

    return found;

}

/*!

 * \internal

 * \brief Duplicates vertex buffer data and array configuration

 */

static void m3gDuplicateVertexBufferData(VertexBuffer *clone,

                                         const VertexBuffer *original)

{

    M3Gint i;

    clone->vertexScale = original->vertexScale;

    m3gCopy(clone->vertexBias, original->vertexBias, 3 * sizeof(GLfloat));

    clone->defaultColor = original->defaultColor;

    clone->locked = original->locked;

    clone->vertexCount = original->vertexCount;

    clone->arrayCount = original->arrayCount;

    clone->arrayMask = original->arrayMask;

    clone->timestamp = original->timestamp;

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

        clone->texCoordScale[i] = original->texCoordScale[i];

        clone->texCoordBias[i][0] = original->texCoordBias[i][0];

        clone->texCoordBias[i][1] = original->texCoordBias[i][1];

        clone->texCoordBias[i][2] = original->texCoordBias[i][2];

        M3G_ASSIGN_REF(clone->texCoords[i], original->texCoords[i]);

    }

    M3G_ASSIGN_REF(clone->colors, original->colors);

    M3G_ASSIGN_REF(clone->normals, original->normals);

    M3G_ASSIGN_REF(clone->vertices, original->vertices);

}

/*!

 * \internal

 * \brief Overloaded Object3D method

 *

 * \param originalObj original VertexBuffer object

 * \param cloneObj pointer to cloned VertexBuffer object

 * \param pairs array for all object-duplicate pairs

 * \param numPairs number of pairs

 */

static M3Gbool m3gVertexBufferDuplicate(const Object *originalObj,

                                        Object **cloneObj,

                                        Object **pairs,

                                        M3Gint *numPairs)

{

    VertexBuffer *original = (VertexBuffer*) originalObj;

    VertexBuffer *clone;

    M3G_ASSERT(*cloneObj == NULL); /* no derived classes */

    /* Create the clone object */

    clone = (VertexBuffer*) m3gCreateVertexBuffer(originalObj->interface);

    if (!clone) {

        return M3G_FALSE;

    }

    *cloneObj = (Object *)clone;

    /* Duplicate base class data */

    if (!m3gObjectDuplicate(originalObj, cloneObj, pairs, numPairs)) {

        return M3G_FALSE;

    }

    /* Duplicate our own data */

    m3gDuplicateVertexBufferData(clone, original);

    return M3G_TRUE;

}

/*!

 * \internal

 * \brief Overloaded Object3D method.