/*

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

*

*/

/*!

 * \internal

 * \file

 * \brief Texture2D implementation

 */

#ifndef M3G_CORE_INCLUDE

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

#endif

/*

 * Uncomment this line to switch tracing on for this file's functions

 */

/* #define M3G_LOCAL_TRACEF_ON */

#include "m3g_object.h"

#include "m3g_image.h"

#include "m3g_math.h"

#include "m3g_texture.h"

#include "m3g_animationtrack.h"

#include "m3g_transformable.h"

/*!

 * \internal

 * \brief Texture object

 */

struct M3GTextureImpl

{

    Transformable transformable;

    Image *image;

    M3Guint blendColor;

    M3Genum blendFunc;

    M3Genum levelFilter;

    M3Genum imageFilter;

    M3Genum wrapS;

    M3Genum wrapT;

};

/*

 * Uncomment this line to switch tracing on for this file's functions

 */

/* #define M3G_LOCAL_TRACEF_ON */

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

 * Internal functions

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

/*!

 * \internal

 * \brief Destroys this Texture object.

 *

 * \param obj Texture object

 */

static void m3gDestroyTexture(Object *obj)

{

    Texture *tex = (Texture *) obj;

    M3G_VALIDATE_OBJECT(tex);

    M3G_ASSIGN_REF(tex->image, NULL);

    m3gDestroyTransformable(obj);

}

/*!

 * \internal

 * \brief Disables all texturing units and texture coordinate arrays

 */

static void m3gDisableTextures(void)

{

    M3Gint i;

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

        glClientActiveTexture(GL_TEXTURE0 + i);

        glDisableClientState(GL_TEXTURE_COORD_ARRAY);

        glActiveTexture(GL_TEXTURE0 + i);

        glDisable(GL_TEXTURE_2D);

    }

}

/*!

 * \internal

 * \brief Applies texture to OpenGL.

 *

 * \param texture Texture object

 */

static void m3gBindTexture(Texture *texture)

{

    M3Gfloat colors[4];

    M3Gint mode;

    M3G_VALIDATE_OBJECT(texture);

    m3gBindTextureImage(texture->image,

                        texture->levelFilter,

                        texture->imageFilter); 

    /* setting up texturing mode */

    {

        M3GMatrix mtx;

        M3Gfloat matrixValues[16];

        m3gGetCompositeTransform((Transformable *) texture, &mtx);

        m3gGetMatrixColumns(&mtx, matrixValues);

        glMatrixMode(GL_TEXTURE);

        glLoadMatrixf(matrixValues);

    }

    glMatrixMode(GL_MODELVIEW);

    mode = GL_REPLACE;

    switch (texture->blendFunc) {

    case M3G_FUNC_REPLACE:

        mode = GL_REPLACE;

        break;

    case M3G_FUNC_ADD:

        mode = GL_ADD;

        break;

    case M3G_FUNC_BLEND:

        mode = GL_BLEND;

        break;

    case M3G_FUNC_DECAL:

        mode = GL_DECAL;

        break;

    case M3G_FUNC_MODULATE:

        mode = GL_MODULATE;

        break;

    default:

        /* This should never happen */

        M3G_ASSERT(0);

        break;

    }

    glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, (GLfixed)mode);

    m3gFloatColor(texture->blendColor, 1.f, colors);

    glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, colors);

    /* setting up wrapping */

    if (texture->wrapS  == M3G_WRAP_CLAMP) {

        glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

    }

    else {

        glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);

    }

    if (texture->wrapT == M3G_WRAP_CLAMP) {

        glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    }

    else {

        glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

    }

    M3G_ASSERT_GL;

}

/*!

 * \internal

 * \brief Releases a bound texture from the current texture unit

 *

 */

static void m3gReleaseTexture(Texture *texture)

{

    m3gReleaseTextureImage(texture->image);

}

#if defined(M3G_NGL_TEXTURE_API)

/*!

 * \internal

 * \brief Make sure that mipmaps are allocated if needed

 */

static M3Gbool m3gValidateTextureMipmapping(Texture *texture)

{

    return (texture->levelFilter == M3G_FILTER_BASE_LEVEL

            || texture->image->mipData);

}

#endif

/*!

 * \internal

 * \brief Overloaded Object3D method.

 *

 * \param property      animation property

 * \retval M3G_TRUE     property supported

 * \retval M3G_FALSE    property not supported

 */

static M3Gbool m3gTextureIsCompatible(M3Gint property)

{

    switch (property) {

    case M3G_ANIM_COLOR:

        return M3G_TRUE;

    default:

        return m3gTransformableIsCompatible(property);

    }

}

/*!

 * \internal

 * \brief Overloaded Object3D method.

 *

 * \param self          Texture object

 * \param property      animation property

 * \param valueSize     size of value array

 * \param value         value array

 */

static void m3gTextureUpdateProperty(Object *self,

                                     M3Gint property,

                                     M3Gint valueSize,

                                     const M3Gfloat *value)

{

    Texture *texture = (Texture *)self;

    M3G_VALIDATE_OBJECT(texture);

    M3G_ASSERT_PTR(value);

    switch (property) {

    case M3G_ANIM_COLOR:

        M3G_ASSERT(valueSize >= 3);

        texture->blendColor =

            (valueSize == 3

             ? m3gColor3f(value[0], value[1], value[2])

             : m3gColor4f(value[0], value[1], value[2], value[3]));

        break;

    default:

        m3gTransformableUpdateProperty(self, property, valueSize, value);

    }

}

/*!

 * \internal

 * \brief Overloaded Object3D method.

 *

 * \param self Texture object

 * \param references array of reference objects

 * \return number of references

 */

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

{

    Texture *texture = (Texture *)self;

    M3Gint num = m3gObjectDoGetReferences(self, references);

    if (texture->image != NULL) {

        if (references != NULL)

            references[num] = (Object *)texture->image;

        num++;

    }

    return num;

}

/*!

 * \internal

 * \brief Overloaded Object3D method.

 */

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

{

    Texture *texture = (Texture *)self;

    Object *found = m3gObjectFindID(self, userID);

    if (!found && texture->image != NULL) {

        found = m3gFindID((Object*) texture->image, userID);

    }

    return found;

}

/*!

 * \internal

 * \brief Overloaded Object3D method.

 *

 * \param originalObj original Texture object

 * \param cloneObj pointer to cloned Texture object

 * \param pairs array for all object-duplicate pairs

 * \param numPairs number of pairs

 */

static M3Gbool m3gTextureDuplicate(const Object *originalObj,

                                   Object **cloneObj,

                                   Object **pairs,

                                   M3Gint *numPairs)

{

    Texture *original = (Texture *)originalObj;

    Texture *clone;

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

    /* Create the clone object */

    clone = (Texture *)m3gCreateTexture(originalObj->interface,

                                        original->image);

    if (!clone) {

        return M3G_FALSE;

    }

    *cloneObj = (Object *)clone;

    /* Duplicate base class data */

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

        return M3G_FALSE;

    }

    /* Duplicate our own data */

    clone->blendColor = original->blendColor;

    clone->blendFunc = original->blendFunc;

    clone->levelFilter = original->levelFilter;

    clone->imageFilter = original->imageFilter;

    clone->wrapS = original->wrapS;

    clone->wrapT = original->wrapT;

    return M3G_TRUE;

}

/*!

 * \internal

 * \brief Check texture dimensions.

 *

 * \retval M3G_TRUE dimensions valid

 * \retval M3G_FALSE dimensions invalid

 */

static M3Gbool m3gIsValidDimensions(M3Gint width, M3Gint height)

{

    return (       m3gInRange(width,  1, M3G_MAX_TEXTURE_DIMENSION)

                && m3gInRange(height, 1, M3G_MAX_TEXTURE_DIMENSION)

                && m3gIsPowerOfTwo(width)

                && m3gIsPowerOfTwo(height) );

}

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

 * Virtual function table

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

static const ObjectVFTable m3gvf_Texture = {

    m3gObjectApplyAnimation,

    m3gTextureIsCompatible,

    m3gTextureUpdateProperty,

    m3gTextureDoGetReferences,

    m3gTextureFindID,

    m3gTextureDuplicate,

    m3gDestroyTexture

};

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

 * Public API functions

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

/*!

 * \brief Texture constructor, creates a texture with

 * default values.

 *

 *

 * \param interface             M3G interface

 * \param hImage                texture Image object

 * \retval Texture new Texture object

 * \retval NULL Texture creating failed

 */

M3G_API M3GTexture m3gCreateTexture(M3GInterface interface,

                                    M3GImage hImage)

{

    Interface *m3g = (Interface *) interface;

    Image* image = (Image *)hImage;

    M3G_VALIDATE_INTERFACE(m3g);

    /* Check inputs */

    if (image == NULL) {

        m3gRaiseError(m3g, M3G_NULL_POINTER);

        return NULL;

    }

    if (!m3gIsValidDimensions(image->width, image->height)) {

        m3gRaiseError(m3g, M3G_INVALID_VALUE);

        return NULL;

    }

    /* Allocate and initialize the object */

    {

        Texture *texture;

        texture = m3gAllocZ(m3g, sizeof(Texture));

        if (texture != NULL) {

            m3gInitTransformable(&texture->transformable, m3g,

                                 M3G_CLASS_TEXTURE);

            M3G_ASSIGN_REF(texture->image, image);

            texture->blendColor = 0x00000000;   /* Black */

            texture->blendFunc = M3G_FUNC_MODULATE;

            texture->levelFilter = M3G_FILTER_BASE_LEVEL;

            texture->imageFilter = M3G_FILTER_NEAREST;

            texture->wrapS = M3G_WRAP_REPEAT;

            texture->wrapT = M3G_WRAP_REPEAT;

        }

        return (M3GTexture)texture;

    }

}

/*!

 * \brief Set texture image.

 *

 * \param hTexture  Texture object

 * \param hImage    Image object

 */

M3G_API void m3gSetTextureImage(M3GTexture hTexture, M3GImage hImage)

{

    Texture *texture = (Texture*)hTexture;

    Image *image = (Image *)hImage;

    M3G_VALIDATE_OBJECT(texture);

    if (image == NULL) {

        m3gRaiseError(M3G_INTERFACE(texture), M3G_NULL_POINTER);

        return;

    }

    if (!m3gIsValidDimensions(image->width, image->height)) {

        m3gRaiseError(M3G_INTERFACE(texture), M3G_INVALID_VALUE);

        return;

    }

    M3G_ASSIGN_REF(texture->image, image);

}

/*!

 * \brief Get texture image.

 *

 * \param hTexture  Texture object

 * \return          Image object

 */

M3G_API M3GImage m3gGetTextureImage(M3GTexture hTexture)

{

    const Texture *texture = (const Texture *) hTexture;

    M3G_VALIDATE_OBJECT(texture);

    return (M3GImage)(texture->image);

}

/*!

 * \brief Set texture filtering.

 *

 * \param hTexture      Texture object

 * \param levelFilter   level filter type

 * \param imageFilter   image filter type

 */

M3G_API void m3gSetFiltering(M3GTexture hTexture,

                             M3Gint levelFilter,

                             M3Gint imageFilter)

{

    Texture *texture = (Texture*)hTexture;

    if ((levelFilter != M3G_FILTER_LINEAR &&

         levelFilter != M3G_FILTER_NEAREST &&

         levelFilter != M3G_FILTER_BASE_LEVEL)

        || (imageFilter != M3G_FILTER_LINEAR &&

            imageFilter != M3G_FILTER_NEAREST)) {

        m3gRaiseError(M3G_INTERFACE(texture), M3G_INVALID_VALUE);

        return;

    }

    texture->levelFilter = levelFilter;

    texture->imageFilter = imageFilter;

}

/*!

 * \brief Set texture S & T wrapping mode.

 *

 * \param hTexture  Texture object

 * \param wrapS     S wrap mode

 * \param wrapT     T wrap mode

 */

M3G_API void m3gSetWrapping(M3GTexture hTexture, M3Gint wrapS, M3Gint wrapT)

{

    Texture *texture = (Texture*)hTexture;

    if (wrapS != M3G_WRAP_CLAMP && wrapS != M3G_WRAP_REPEAT) {

        m3gRaiseError(M3G_INTERFACE(texture), M3G_INVALID_VALUE);

        return;

    }

    if (wrapT != M3G_WRAP_CLAMP && wrapT != M3G_WRAP_REPEAT) {

        m3gRaiseError(M3G_INTERFACE(texture), M3G_INVALID_VALUE);

        return;

    }

    texture->wrapS = wrapS;

    texture->wrapT = wrapT;

}

/*!

 * \brief Get texture S wrapping mode.

 *

 * \param hTexture  Texture object

 * \return S wrapping mode

 */

M3G_API M3Gint m3gGetWrappingS(M3GTexture hTexture)

{

    Texture *texture = (Texture*)hTexture;

    return texture->wrapS;

}

/*!

 * \brief Get texture T wrapping mode.

 *

 * \param hTexture  Texture object

 * \return T wrapping mode

 */

M3G_API M3Gint m3gGetWrappingT(M3GTexture hTexture)

{

    Texture *texture = (Texture*)hTexture;

    return texture->wrapT;

}

/*!

 * \brief Set texture blending function.

 *

 * \param hTexture  Texture object

 * \param func      blending function

 */

M3G_API void m3gTextureSetBlending(M3GTexture hTexture, M3Gint func)

{

    Texture *texture = (Texture*)hTexture;

    switch (func) {

    case M3G_FUNC_ADD: