/*

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

 *

 */

 /*!

  * \internal

  * \file

  * \brief Appearance implementation

  */

 #ifndef M3G_CORE_INCLUDE

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

 #endif

 #include "m3g_appearance.h"

 #include "m3g_vertexbuffer.h"

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

  * Private functions

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

 /*!

  * \internal

  * \brief Applies default appearance values to OpenGL.

  */

 static void m3gApplyAppearanceDefaults(RenderContext *ctx)

 {

     int i;

     m3gApplyCompositingMode(NULL, ctx);

     m3gApplyPolygonMode(NULL);

     m3gApplyMaterial(NULL, 0x10000);

 	m3gApplyFog(NULL);

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

         glActiveTexture(GL_TEXTURE0 + i);

         glDisable(GL_TEXTURE_2D);

     }

 }

 /*!

  * \internal

  * \brief Generate a hash number for a pointer

  */

 static M3Guint m3gGenPointerHash(const void *ptr)

 {

     M3Guint p = ((M3Guint) ptr) >> 2;

     M3Guint key = p ^ (p >> 5) ^ (p >> 10) ^ (p >> 15) ^ (p >> 20) ^ (p >> 25);

     return key;

 }

 /*!

  * \internal

  * \brief Generate a quick hash bit pattern for the textures of this

  * appearance object

  */

 static M3Guint m3gGen12BitTextureHash(const Appearance *app)

 {

     M3Guint key = 0; 

     int i;

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

         const Texture *tex = app->texture[i];

         if (tex) {

             key ^= (m3gGenPointerHash(m3gGetTextureImage((M3GTexture)tex)) >> i) << 6;

             key ^= (m3gGenPointerHash(tex) >> i) & 0x3Fu;

         }

     }

     return key & ((1u<<12)-1);

 }

 /*!

  * \internal

  * \brief Generate the sorting key for render queue

  *

  * Sort key is a combination of user settable layer and

  * blending mode. Blended objects are always drawn last.

  *

  * \param appearance    Appearance object

  * \return              sort key

  */

 static void m3gRegenerateSortKey(Appearance *appearance)

 {

 	M3Guint key = 0;

     M3G_VALIDATE_OBJECT(appearance);

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

      * First do the mandatory sorting by layer index and blending

      * state; this currently uses the top eight bits, 31..24

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

     key = (appearance->layer - M3G_APPEARANCE_MIN_LAYER)

         << (33 - M3G_APPEARANCE_HARD_SORT_BITS);

     /* NOTE the blending state bit is not set here, but dynamically in

      * m3gGetAppearanceSortKey; this way we do not need to implement

      * signaling from CompositingMode to Appearance when the blending

      * state changes */

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

      * The rest of the bits, 23..0, affect performance only; ideally,

      * these should be sorted so that the more expensive state is in the

      * higher bits, but this is largely dependent on the hardware

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

     /* Texturing changes are often expensive in graphics hardware, so

      * we put a hash of the texture objects into the top twelve

      * bits

      *

      * NOTE we do not currently update this if a texture image

      * changes, but that shouldn't happen too often and only has

      * relatively minor performance implications

      */

     key |= m3gGen12BitTextureHash(appearance) << 12;

     /* Use the rest of the bits for the various components; depth

      * function changes are another potentially costly operation, so

      * put that next */

     key |= (m3gGenPointerHash(appearance->compositingMode) & 0x0Fu) << 8;

     key |= (m3gGenPointerHash(appearance->material) & 0x07u) << 5;

     key |= (m3gGenPointerHash(appearance->polygonMode) & 0x07u) << 2;

     key |= (m3gGenPointerHash(appearance->fog) & 0x03u);

     /* Store the final value */

     appearance->sortKey = key;

 }

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

  * Internal functions

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

 /*!

  * \internal

  * \brief Destroys this Appearance object.

  *

  * \param obj Appearance object

  */

 static void m3gDestroyAppearance(Object *obj)

 {

     int i;

     Appearance *appearance = (Appearance *) obj;

     M3G_VALIDATE_OBJECT(appearance);

     M3G_ASSIGN_REF(appearance->compositingMode, NULL);

     M3G_ASSIGN_REF(appearance->fog,             NULL);

     M3G_ASSIGN_REF(appearance->material,        NULL);

     M3G_ASSIGN_REF(appearance->polygonMode,     NULL);

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

         M3G_ASSIGN_REF(appearance->texture[i], NULL);

     }

     m3gDestroyObject(obj);

 }

 /*!

  * \internal

  * \brief Applies Apperance settings to current OpenGL state

  *

  * \note m3gReleaseTextures must be called when no longer using this,

  * to properly reset texture usage counters and unmap the texture

  * images.

  * 

  * \param appearance    Appearance object

  * \param alphaFactor   alpha factor as 1.16 fixed point

  */

 static void m3gApplyAppearance(const Appearance *appearance,

 							   RenderContext *ctx,

                                M3Gint alphaFactor)

 {

     M3G_ASSERT_GL;

     if (appearance != NULL) {

         int i;

 #       if defined(M3G_NGL_TEXTURE_API)

         m3gLockMemory(M3G_INTERFACE(appearance)); /* for textures */

 #       endif

         m3gApplyCompositingMode(appearance->compositingMode, ctx);

         m3gApplyPolygonMode(appearance->polygonMode);

         m3gApplyMaterial(appearance->material, alphaFactor);

         m3gApplyFog(appearance->fog);

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

             Texture *tex = appearance->texture[i];

             glActiveTexture(GL_TEXTURE0 + i);

             if (tex != NULL) {

                 glEnable(GL_TEXTURE_2D);

                 m3gBindTexture(appearance->texture[i]);

             }

             else {

                 glDisable(GL_TEXTURE_2D);

             }

         }

     }

     else {

         m3gApplyAppearanceDefaults(ctx);

     }

     M3G_ASSERT_GL;

 }

 /*!

  * \internal

  * \brief Release the textures bound for this appearance

  */

 static void m3gReleaseTextures(const Appearance *appearance)

 {

     if (appearance != NULL) {

         int i;

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

             Texture *tex = appearance->texture[i];

             if (tex != NULL) {

                 m3gReleaseTexture(tex);

             }

         }

 #       if defined(M3G_NGL_TEXTURE_API)

         m3gUnlockMemory(M3G_INTERFACE(appearance));

 #       endif

     }

 }

 /*!

  * \internal

  * \brief Overloaded Object3D method.

  *

  * \param self Appearance object

  * \param time current world time

  * \return minimum validity

  */

 static M3Gint m3gAppearanceApplyAnimation(Object *self, M3Gint time) {

     M3Gint i, validity, minValidity = 0x7fffffff;

     Appearance *appearance = (Appearance *)self;

     M3G_VALIDATE_OBJECT(appearance);

     if (appearance->compositingMode != NULL) {

         validity = M3G_VFUNC(Object, appearance->compositingMode, applyAnimation)((Object *)appearance->compositingMode, time);

         minValidity = (validity < minValidity ? validity : minValidity);

     }

     if (appearance->fog != NULL) {

         validity = M3G_VFUNC(Object, appearance->fog, applyAnimation)((Object *)appearance->fog, time);

         minValidity = (validity < minValidity ? validity : minValidity);

     }

     if (appearance->material != NULL) {

         validity = M3G_VFUNC(Object, appearance->material, applyAnimation)((Object *)appearance->material, time);

         minValidity = (validity < minValidity ? validity : minValidity);

     }

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

         if (appearance->texture[i] != NULL) {

             validity = M3G_VFUNC(Object, appearance->texture[i], applyAnimation)((Object *)appearance->texture[i], time);

             minValidity = (validity < minValidity ? validity : minValidity);

         }

     }

     /* no animations can target an Appearance directly, so we need

        not call super.applyAnimation() here. */

     return minValidity;

 }    

 /*!

  * \internal

  * \brief Overloaded Object3D method.

  */

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

 {

     int i;

     Appearance *app = (Appearance *)self;

     Object *found = m3gObjectFindID(self, userID);

     if (!found && app->compositingMode) {

         found = m3gFindID((Object*) app->compositingMode, userID);

     }

     if (!found && app->polygonMode) {

         found = m3gFindID((Object*) app->polygonMode, userID);

     }

     if (!found && app->fog) {

         found = m3gFindID((Object*) app->fog, userID);

     }

     if (!found && app->material) {

         found = m3gFindID((Object*) app->material, userID);

     }

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

         if (app->texture[i]) {

             found = m3gFindID((Object*) app->texture[i], userID);

         }

     }

     return found;

 }

 /*!

  * \internal

  * \brief Overloaded Object3D method.

  *

  * \param self Appearance object

  * \param references array of reference objects

  * \return number of references

  */

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

 {

     Appearance *app = (Appearance *)self;

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

     if (app->compositingMode != NULL) {

         if (references != NULL)

             references[num] = (Object *)app->compositingMode;

         num++;

     }

     if (app->polygonMode != NULL) {

         if (references != NULL)

             references[num] = (Object *)app->polygonMode;

         num++;

     }

     if (app->fog != NULL) {

         if (references != NULL)

             references[num] = (Object *)app->fog;

         num++;

     }

     if (app->material != NULL) {

         if (references != NULL)

             references[num] = (Object *)app->material;

         num++;

     }

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

         if (app->texture[i] != NULL) {

             if (references != NULL)

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

             num++;

         }

     }

     return num;

 }

 /*!

  * \internal

  * \brief Overloaded Object3D method.

  *

  * \param originalObj original Appearance object

  * \param cloneObj pointer to cloned Appearance object

  * \param pairs array for all object-duplicate pairs

  * \param numPairs number of pairs

  */

 static M3Gbool m3gAppearanceDuplicate(const Object *originalObj,

                                       Object **cloneObj,

                                       Object **pairs,

                                       M3Gint *numPairs)

 {

     M3Gint i;

     Appearance *original = (Appearance *)originalObj;

     Appearance *clone = (Appearance *)m3gCreateAppearance(originalObj->interface);

     *cloneObj = (Object *)clone;

     if (*cloneObj == NULL) {

         return M3G_FALSE;

     }

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

         clone->layer = original->layer;

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

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

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

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

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

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

         }

         m3gRegenerateSortKey(clone);

         return M3G_TRUE;

     }

     else {

         return M3G_FALSE;

     }

 }

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

  * Virtual function table

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

 static const ObjectVFTable m3gvf_Appearance = {

     m3gAppearanceApplyAnimation,

     m3gObjectIsCompatible,

     m3gObjectUpdateProperty,

     m3gAppearanceDoGetReferences,

     m3gAppearanceFindID,

     m3gAppearanceDuplicate,

     m3gDestroyAppearance

 };

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

  * Public API functions

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

 /*!

  * \brief Creates a new Appearance with default values

  *

  * \param hInterface            M3G interface

  * \retval Appearance new Appearance object

  * \retval NULL Appearance creating failed

  */

 /*@access M3GInterface@*/

 /*@access M3GAppearance@*/

 M3G_API M3GAppearance m3gCreateAppearance(M3GInterface hInterface)

 {

     Interface *m3g = (Interface *) hInterface;

     M3G_VALIDATE_INTERFACE(m3g);

     {

         Appearance *appearance = m3gAllocZ(m3g, sizeof(Appearance));

         if (appearance != NULL) {

     		m3gInitObject(&appearance->object, m3g, M3G_CLASS_APPEARANCE);

             m3gRegenerateSortKey(appearance);

         }

         return (M3GAppearance) appearance;

     }

 }

 /*!

  * \brief Get compositing mode

  *

  * \param hAppearance Appearance object

  * \return CompositingMode object

  */

 M3G_API M3GCompositingMode m3gGetCompositingMode(M3GAppearance hAppearance)

 {

     const Appearance *appearance = (const Appearance *) hAppearance;

     M3G_VALIDATE_OBJECT(appearance);

     return (M3GCompositingMode)(appearance->compositingMode);

 }

 /*!

  * \brief Get fog

  *

  * \param hAppearance Appearance object

  * \return Fog object

  */

 M3G_API M3GFog m3gGetFog(M3GAppearance hAppearance)

 {

     const Appearance *appearance = (const Appearance *) hAppearance;

     M3G_VALIDATE_OBJECT(appearance);

     return (M3GFog)(appearance->fog);

 }

 /*!

  * \brief Get material

  *

  * \param hAppearance Appearance object

  * \return Material object

  */

 M3G_API M3GMaterial m3gGetMaterial(M3GAppearance hAppearance)

 {

     const Appearance *appearance = (const Appearance *) hAppearance;

     M3G_VALIDATE_OBJECT(appearance);

     return (M3GMaterial)(appearance->material);

 }

 /*!

  * \brief Get polygon mode

  *

  * \param hAppearance Appearance object

  * \return PolygonMode object

  */

 M3G_API M3GPolygonMode m3gGetPolygonMode(M3GAppearance hAppearance)

 {

     const Appearance *appearance = (const Appearance *) hAppearance;

     M3G_VALIDATE_OBJECT(appearance);

     return (M3GPolygonMode)(appearance->polygonMode);

 }

 /*!

  * \brief Get texture

  *

  * \param hAppearance Appearance object

  * \param unit texturing unit

  * \return Texture2D object

  */

 M3G_API M3GTexture m3gGetTexture(M3GAppearance hAppearance, M3Gint unit)

 {

     const Appearance *appearance = (const Appearance *) hAppearance;

     M3G_VALIDATE_OBJECT(appearance);

     if (!m3gInRange(unit, 0, M3G_NUM_TEXTURE_UNITS - 1)) {

         m3gRaiseError(M3G_INTERFACE(appearance), M3G_INVALID_INDEX);

         return (M3GTexture) NULL;

     }

     return (M3GTexture)(appearance->texture[unit]);

 }

 /*!

  * \brief Get layer

  *

  * \param hAppearance Appearance object

  * \return layer number

  */

 M3G_API M3Gint m3gGetLayer(M3GAppearance hAppearance)

 {

     const Appearance *appearance = (const Appearance *) hAppearance;

     M3G_VALIDATE_OBJECT(appearance);

     return appearance->layer;

 }

 /*!

  * \brief Set compositing mode

  *

  * \param hAppearance Appearance object

  * \param hMode CompositingMode object

  */

 M3G_API void m3gSetCompositingMode(M3GAppearance hAppearance,

                                    M3GCompositingMode hMode)

 {

     Appearance *appearance = (Appearance *) hAppearance;

     CompositingMode *mode = (CompositingMode *) hMode;

     M3G_VALIDATE_OBJECT(appearance);

     M3G_ASSIGN_REF(appearance->compositingMode, mode);

     m3gRegenerateSortKey(appearance);

 }

 /*!

  * \brief Set polygon mode

  *

  * \param hAppearance Appearance object

  * \param hMode PolygonMode object

  */

 M3G_API void m3gSetPolygonMode(M3GAppearance hAppearance,

                                M3GPolygonMode hMode)

 {

     Appearance *appearance = (Appearance *) hAppearance;

     PolygonMode *mode = (PolygonMode *) hMode;

     M3G_VALIDATE_OBJECT(appearance);

     M3G_ASSIGN_REF(appearance->polygonMode, mode);

     m3gRegenerateSortKey(appearance);

 }

 /*!

  * \brief Set layer

  *

  * \param hAppearance Appearance object

  * \param layer layer number

  */

 M3G_API void m3gSetLayer(M3GAppearance hAppearance, M3Gint layer)

 {

     Appearance *appearance = (Appearance *) hAppearance;

     M3G_VALIDATE_OBJECT(appearance);

     /* Check for errors */

     if (!m3gInRange(layer, M3G_APPEARANCE_MIN_LAYER, M3G_APPEARANCE_MAX_LAYER)) {

         m3gRaiseError(M3G_INTERFACE(appearance), M3G_INVALID_INDEX);

         return;

     }

     appearance->layer = (M3Gshort) layer;

     m3gRegenerateSortKey(appearance);

 }

 /*!

  * \brief Set material

  *

  * \param hAppearance Appearance object

  * \param hMaterial Material object

  */

 M3G_API void m3gSetMaterial(M3GAppearance hAppearance,

                             M3GMaterial hMaterial)

 {

     Appearance *appearance = (Appearance *) hAppearance;

     Material *material = (Material *) hMaterial;

     M3G_VALIDATE_OBJECT(appearance);

     M3G_ASSIGN_REF(appearance->material, material);

     if (material != NULL) {

         appearance->vertexMask |= (M3Gushort)M3G_NORMAL_BIT;

     }

     else {

         appearance->vertexMask &= ~(M3Gushort)M3G_NORMAL_BIT;

     }

     m3gRegenerateSortKey(appearance);

 }

 /*!

  * \brief Set texture

  *

  * \param hAppearance Appearance object

  * \param unit texturing unit

  * \param hTexture Texture2D object

  */

 M3G_API void m3gSetTexture(M3GAppearance hAppearance,

                            M3Gint unit, M3GTexture hTexture)

 {

     Appearance *appearance = (Appearance *) hAppearance;

     Texture *texture = (Texture *) hTexture;

     M3G_VALIDATE_OBJECT(appearance);

     if (!m3gInRange(unit, 0, M3G_NUM_TEXTURE_UNITS - 1)) {

         m3gRaiseError(M3G_INTERFACE(appearance), M3G_INVALID_INDEX);

         return;

     }

     M3G_ASSIGN_REF(appearance->texture[unit], texture);

     if (texture != NULL) {

         appearance->vertexMask |= (M3Gushort) (M3G_TEXCOORD0_BIT << unit);

     }

     else {

         appearance->vertexMask &= (M3Gushort) ~(M3G_TEXCOORD0_BIT << unit);

     }

     m3gRegenerateSortKey(appearance);

 }

 /*!

  * \brief Set fog

  *

  * \param hAppearance Appearance object

  * \param hFog Fog object

  */

 M3G_API void m3gSetFog(M3GAppearance hAppearance, M3GFog hFog)

 {

     Appearance *appearance = (Appearance *) hAppearance;

     M3G_VALIDATE_OBJECT(appearance);

 	M3G_ASSIGN_REF(appearance->fog, hFog);

     m3gRegenerateSortKey(appearance);

 }