/*
* 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;
}