/*

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

     case M3G_FUNC_BLEND:

     case M3G_FUNC_DECAL:

     case M3G_FUNC_MODULATE:

     case M3G_FUNC_REPLACE:

         texture->blendFunc = func;

         break;

     default:

         m3gRaiseError(M3G_INTERFACE(texture), M3G_INVALID_VALUE);

         break;

     }

 }

 /*!

  * \brief Get texture blending function.

  *

  * \param hTexture  Texture object

  * \return          blending function

  */

 M3G_API M3Gint m3gTextureGetBlending(M3GTexture hTexture)

 {

     Texture *texture = (Texture*)hTexture;

     return texture->blendFunc;

 }

 /*!

  * \brief Set texture blend color as RGB.

  *

  * \param hTexture  Texture object

  * \param RGB       blend color as RGB

  */

 M3G_API void m3gSetBlendColor(M3GTexture hTexture, M3Guint RGB)

 {

     Texture *texture = (Texture*)hTexture;

     texture->blendColor = RGB & M3G_RGB_MASK;

 }

 /*!

  * \brief Get texture blend color as RGB.

  *

  * \param hTexture  Texture object

  * \return          blend color as RGB

  */

 M3G_API M3Guint m3gGetBlendColor(M3GTexture hTexture)

 {

     Texture *texture = (Texture*)hTexture;

     return texture->blendColor;

 }

 /*!

  * \brief Get texture filtering

  *

  * \param hTexture      Texture object

  * \param levelFilter   pointer to store level filter

  * \param imageFilter   pointer to store image filter

  */

 M3G_API void m3gGetFiltering(M3GTexture hTexture, M3Gint *levelFilter, M3Gint *imageFilter)

 {

     Texture *texture = (Texture*)hTexture;

     *levelFilter = texture->levelFilter;

     *imageFilter = texture->imageFilter;

 }

 /*

  * Uncomment these lines' opening pair at the begining of the file

  * if you want to switch tracing on for this file.

  */

 #ifdef M3G_LOCAL_TRACEF_ON

 #undef M3G_LOCAL_TRACEF_ON

 #endif