/*

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

*

*/

/*!

 * \internal

 * \file

 * \brief Material implementation

 */

#ifndef M3G_CORE_INCLUDE

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

#endif

#include "m3g_material.h"

#include "m3g_animationtrack.h"

#define ALL_TARGET_MASK (M3G_AMBIENT_BIT | M3G_DIFFUSE_BIT | M3G_EMISSIVE_BIT | M3G_SPECULAR_BIT)

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

 * Internal functions

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

/*!

 * \internal

 * \brief Applies default material to OpenGL.

 */

static void m3gApplyDefaultMaterial(void)

{

    glDisable(GL_COLOR_MATERIAL);

    glDisable(GL_LIGHTING);

}

/*!

 * \internal

 * \brief Applies material to OpenGL.

 *

 * \param material Material object

 * \param alphaFactor alpha factor as 1.16 fixed point

 */

static void m3gApplyMaterial(Material *material, M3Gint alphaFactor)

{

    if (material != NULL) {

    	M3Gfloat colors[4];

        /* NOTE We must set the ColorMaterial state *before* setting

         * any of the material colors, as they will not change if

         * tracking is enabled! */

        if (material->vertexColorTracking) {

            glEnable(GL_COLOR_MATERIAL);

        }

        else {

            glDisable(GL_COLOR_MATERIAL);

            /* Ambient and diffuse only need to be set when tracking

             * is disabled */

            m3gFloatColor(material->ambientColor, 1.0f, colors);

            glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, colors);

            m3gFloatColor(material->diffuseColor, 1.0f, colors);

            if (alphaFactor < 0x10000) {

                colors[3] = m3gMul(colors[3],

                                   m3gMul((M3Gfloat) alphaFactor,

                                          1.f/65536.f));

            }

            glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, colors);

        }

        m3gFloatColor(material->emissiveColor, 1.0f, colors);

        glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, colors);

        m3gFloatColor(material->specularColor, 1.0f, colors);

        glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, colors);

        glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, material->shininess);

        glEnable(GL_LIGHTING);

    }

    else {

        m3gApplyDefaultMaterial();

    }

    M3G_ASSERT_GL;

}

/*!

 * \internal

 * \brief Overloaded Object3D method.

 *

 * \param property      animation property

 * \retval M3G_TRUE     property supported

 * \retval M3G_FALSE    property not supported

 */

static M3Gbool m3gMaterialIsCompatible(M3Gint property)

{

    switch (property) {

    case M3G_ANIM_ALPHA:

    case M3G_ANIM_AMBIENT_COLOR:

    case M3G_ANIM_DIFFUSE_COLOR:

    case M3G_ANIM_EMISSIVE_COLOR:

    case M3G_ANIM_SHININESS:

    case M3G_ANIM_SPECULAR_COLOR:

        return M3G_TRUE;

    default:

        return m3gObjectIsCompatible(property);

    }

}

/*!

 * \internal

 * \brief Overloaded Object3D method.

 *

 * \param self          Material object

 * \param property      animation property

 * \param valueSize     size of value array

 * \param value         value array

 */

static void m3gMaterialUpdateProperty(Object *self,

                                      M3Gint property,

                                      M3Gint valueSize,

                                      const M3Gfloat *value)

{

    Material *material = (Material *)self;

    M3G_VALIDATE_OBJECT(material);

    M3G_ASSERT_PTR(value);

    switch (property) {

    case M3G_ANIM_ALPHA:

        M3G_ASSERT(valueSize >= 1);

        material->diffuseColor = (material->diffuseColor | M3G_ALPHA_MASK) &

            m3gAlpha1f(value[0]);

        break;

    case M3G_ANIM_AMBIENT_COLOR:

        M3G_ASSERT(valueSize >= 3);

        material->ambientColor = m3gColor3f(value[0], value[1], value[2]);

        break;

    case M3G_ANIM_DIFFUSE_COLOR:

        M3G_ASSERT(valueSize >= 3);

        material->diffuseColor = (material->diffuseColor | M3G_RGB_MASK)

            & m3gColor3f(value[0], value[1], value[2]);

        break;

    case M3G_ANIM_EMISSIVE_COLOR:

        M3G_ASSERT(valueSize >= 3);

        material->emissiveColor = m3gColor3f(value[0], value[1], value[2]) & M3G_RGB_MASK;

        break;

    case M3G_ANIM_SHININESS:

        M3G_ASSERT(valueSize >= 1);

        material->shininess = m3gClampFloat(value[0], 0.f, 128.f);

        break;

    case M3G_ANIM_SPECULAR_COLOR:

        M3G_ASSERT(valueSize >= 3);

        material->specularColor = m3gColor3f(value[0], value[1], value[2]);

        break;

    default:

        m3gObjectUpdateProperty(self, property, valueSize, value);

    }

}

/*!

 * \internal

 * \brief Overloaded Object3D method.

 *

 * \param originalObj original Material object

 * \param cloneObj pointer to cloned Material object

 * \param pairs array for all object-duplicate pairs

 * \param numPairs number of pairs

 */

static M3Gbool m3gMaterialDuplicate(const Object *originalObj,

                                    Object **cloneObj,

                                    Object **pairs,

                                    M3Gint *numPairs)

{

    const Material *original = (const Material *)originalObj;

    /* Create the clone object */

    Material *clone = (Material *)m3gCreateMaterial(originalObj->interface);

    if (!clone) {

        return M3G_FALSE;

    }

    *cloneObj = (Object *)clone;

    /* Duplicate base class and own data */

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

        clone->vertexColorTracking = original->vertexColorTracking;

        clone->ambientColor = original->ambientColor;

        clone->diffuseColor = original->diffuseColor;

        clone->emissiveColor = original->emissiveColor;

        clone->specularColor = original->specularColor;

        clone->shininess = original->shininess;

        return M3G_TRUE;

    }

    else {

        return M3G_FALSE;

    }

}

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

 * Virtual function table

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

static const ObjectVFTable m3gvf_Material = {

    m3gObjectApplyAnimation,

    m3gMaterialIsCompatible,

    m3gMaterialUpdateProperty,

    m3gObjectDoGetReferences,

    m3gObjectFindID,

    m3gMaterialDuplicate,

    m3gDestroyObject

};

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

 * Public API functions

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

/*!

 * \brief Creates a Material object.

 *

 * \param interface     M3G interface

 * \retval Material new Material object

 * \retval NULL Material creating failed

 */

M3G_API M3GMaterial m3gCreateMaterial(M3GInterface interface)

{

    Interface *m3g = (Interface *) interface;

    M3G_VALIDATE_INTERFACE(m3g);

    {

        Material *material = m3gAllocZ(m3g, sizeof(Material));

        if (material != NULL) {

            m3gInitObject(&material->object, m3g, M3G_CLASS_MATERIAL);

            /* Default values are from the jsr-184 specification */

            material->vertexColorTracking = GL_FALSE;

            material->ambientColor = 0x00333333U;

            material->diffuseColor = 0xFFCCCCCCU;

            material->emissiveColor = 0x00000000U;

            material->specularColor = 0x00000000U;

            material->shininess = 0.0f;

        }

        return (M3GMaterial)material;

    }

}

/*!

 * \brief Set material color.

 *

 * \param hMaterial Material object

 * \param target    color target

 * \param ARGB      ARGB color

 */

M3G_API void m3gSetColor(M3GMaterial hMaterial, M3Genum target, M3Guint ARGB)

{

    Material *material = (Material *) hMaterial;

    M3G_VALIDATE_OBJECT(material);

    /* is invalid target in the mask OR no target */

    if (((target | ALL_TARGET_MASK) != ALL_TARGET_MASK) || ((target & ALL_TARGET_MASK) == 0)) {

        m3gRaiseError(M3G_INTERFACE(material), M3G_INVALID_VALUE);

        return;

    }

    if ((target & M3G_AMBIENT_BIT) != 0) {

        material->ambientColor = ARGB & M3G_RGB_MASK;

    }

    if ((target & M3G_DIFFUSE_BIT) != 0) {

        material->diffuseColor = ARGB;

    }

    if ((target & M3G_EMISSIVE_BIT) != 0) {

        material->emissiveColor = ARGB & M3G_RGB_MASK;

    }

    if ((target & M3G_SPECULAR_BIT) != 0) {

        material->specularColor = ARGB & M3G_RGB_MASK;

    }

}

/*!

 * \brief Get material color.

 *

 * \param hMaterial Material object

 * \param target    color target

 * \return          ARGB color

 */

M3G_API M3Guint m3gGetColor(M3GMaterial hMaterial, M3Genum target)

{

    Material *material = (Material *) hMaterial;

    M3G_VALIDATE_OBJECT(material);

    switch (target) {

    case M3G_AMBIENT_BIT:

        return material->ambientColor;

    case M3G_DIFFUSE_BIT:

        return material->diffuseColor;

    case M3G_EMISSIVE_BIT:

        return material->emissiveColor;

    case M3G_SPECULAR_BIT:

        return material->specularColor;

    default:

        m3gRaiseError(M3G_INTERFACE(material), M3G_INVALID_VALUE);

        break;

    }

    return 0; /* Error */

}

/*!

 * \brief Set material shininess.

 *

 * \param hMaterial Material object

 * \param shininess shininess

 */

M3G_API void m3gSetShininess(M3GMaterial hMaterial, M3Gfloat shininess)

{

    Material *material = (Material *) hMaterial;

    M3G_VALIDATE_OBJECT(material);

    if (!m3gInRangef(shininess, 0.0f, 128.f)) {

        m3gRaiseError(M3G_INTERFACE(material), M3G_INVALID_VALUE);

        return;

    }

    material->shininess = shininess;

}

/*!

 * \brief Get material shininess.

 *

 * \param hMaterial Material object

 * \return          shininess

 */

M3G_API GLfloat m3gGetShininess(M3GMaterial hMaterial)

{

    Material *material = (Material *) hMaterial;

    M3G_VALIDATE_OBJECT(material);

    return material->shininess;

}

/*!

 * \brief Set vertex color tracking enable.

 *

 * \param hMaterial Material object

 * \param enable color tracking enable

 */

M3G_API void m3gSetVertexColorTrackingEnable(M3GMaterial hMaterial,

                                             M3Gbool enable)

{

    Material *material = (Material *) hMaterial;

    M3G_VALIDATE_OBJECT(material);

    material->vertexColorTracking = (GLboolean) enable;

}

/*!

 * \brief Get vertex color tracking enable.

 *

 * \param hMaterial Material object

 * \retval M3G_TRUE color tracking enabled

 * \retval M3G_FALSE color tracking disabled

 */

M3G_API M3Gbool m3gIsVertexColorTrackingEnabled(M3GMaterial hMaterial)

{

    Material *material = (Material *) hMaterial;

    M3G_VALIDATE_OBJECT(material);

    return (M3Gbool) material->vertexColorTracking;

}