/*

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

*

*/

/*!

 * \internal

 * \file

 * \brief CompositingMode implementation

 */

#ifndef M3G_CORE_INCLUDE

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

#endif

#include "m3g_compositingmode.h"

#include "m3g_interface.h"

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

 * Internal functions

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

/*!

 * \internal

 * \brief Applies default CompositingMode to OpenGL.

 */

static void m3gApplyDefaultCompositingMode(M3Gbool alphaWrite)

{

    /* depth write = true */

    glDepthFunc(GL_LEQUAL);

    glDepthMask(GL_TRUE);

    /* colorWrite = true */

    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, alphaWrite);

    /* threshold = 0.0 */

    glAlphaFunc(GL_GEQUAL, 0.0f);

    glDisable(GL_ALPHA_TEST);

    /* blend = REPLACE */

    glDisable(GL_BLEND);

    /* factor = 0 && units = 0 */

    glDisable(GL_POLYGON_OFFSET_FILL);

}

/*!

 * \internal

 * \brief Applies CompositingMode to OpenGL.

 *

 * \param compositingMode CompositingMode object

 */

static void m3gApplyCompositingMode(CompositingMode *compositingMode, RenderContext *ctx)

{

	M3Gbool alphaWrite = m3gGetAlphaWrite(ctx);

	if (compositingMode != NULL) {

        glDepthFunc(compositingMode->depthTest ? GL_LEQUAL : GL_ALWAYS);

        glDepthMask(compositingMode->depthWrite);

        if (m3gGetColorMaskWorkaround(M3G_INTERFACE(compositingMode))) {

            glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

        }

        else {

            glColorMask(compositingMode->colorWrite,

                        compositingMode->colorWrite,

                        compositingMode->colorWrite,

						alphaWrite & compositingMode->alphaWrite);

        }

        if (compositingMode->alphaThreshold == 0.0f) {

            glDisable(GL_ALPHA_TEST);

        }

        else {

            glAlphaFunc(GL_GEQUAL, compositingMode->alphaThreshold);

            glEnable(GL_ALPHA_TEST);

        }

        if (compositingMode->blendingMode == M3G_REPLACE) {

            glDisable(GL_BLEND);

        }

        else {

            M3Gint src = GL_ONE;

            M3Gint dst = GL_ZERO;

            switch (compositingMode->blendingMode) {

                case M3G_ALPHA_ADD:

                    src = GL_SRC_ALPHA;

                    dst = GL_ONE;

                    break;

                case M3G_ALPHA_BLEND:

                    src = GL_SRC_ALPHA;

                    dst = GL_ONE_MINUS_SRC_ALPHA;

                    break;

                case M3G_MODULATE:

                    src = GL_ZERO;

                    dst = GL_SRC_COLOR;

                    break;

                case M3G_MODULATE_X2:

                    src = GL_DST_COLOR;

                    dst = GL_SRC_COLOR;

                    break;

            }

            glBlendFunc(src, dst);

            glEnable(GL_BLEND);

        }

        glPolygonOffset(compositingMode->factor, compositingMode->units);

        if (compositingMode->factor != 0 || compositingMode->units != 0) {

            glEnable(GL_POLYGON_OFFSET_FILL);

        }

        else {

            glDisable(GL_POLYGON_OFFSET_FILL);

        }

    }

    else {

		m3gApplyDefaultCompositingMode(alphaWrite);

    }

    M3G_ASSERT_GL;

}

/*!

 * \internal

 * \brief Duplicates a CompositingMode object.

 *

 * \param originalObj original CompositingMode object

 * \param cloneObj pointer to cloned CompositingMode object

 * \param pairs array for all object-duplicate pairs

 * \param numPairs number of pairs

 */

static M3Gbool m3gCompositingModeDuplicate(const Object *originalObj,

                                           Object **cloneObj,

                                           Object **pairs,

                                           M3Gint *numPairs)

{

    CompositingMode *original = (CompositingMode *)originalObj;

    CompositingMode *clone =

        (CompositingMode *)m3gCreateCompositingMode(originalObj->interface);

    *cloneObj = (Object *)clone;

    if (*cloneObj == NULL) {

        return M3G_FALSE;

    }

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

        clone->blendingMode = original->blendingMode;

        clone->alphaThreshold = original->alphaThreshold;

        clone->depthTest = original->depthTest;

        clone->depthWrite = original->depthWrite;

        clone->colorWrite = original->colorWrite;

        clone->alphaWrite = original->alphaWrite;

        clone->factor = original->factor;

        clone->units = original->units;

        return M3G_TRUE;

    }

    else {

        return M3G_FALSE;

    }

}

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

 * Virtual function table

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

static const ObjectVFTable m3gvf_CompositingMode = {

    m3gObjectApplyAnimation,

    m3gObjectIsCompatible,

    m3gObjectUpdateProperty,

    m3gObjectDoGetReferences,

    m3gObjectFindID,

    m3gCompositingModeDuplicate,

    m3gDestroyObject

};

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

 * Public API functions

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

/*!

 * \brief Creates a new CompositingMode object.

 *

 * \param interface     M3G interface

 * \retval CompositingMode new CompositingMode object

 * \retval NULL CompositingMode creating failed

 */

M3G_API M3GCompositingMode m3gCreateCompositingMode(M3GInterface interface)

{

    Interface *m3g = (Interface *) interface;

    M3G_VALIDATE_INTERFACE(m3g);

    {

        CompositingMode *compositingMode = m3gAllocZ(m3g, sizeof(CompositingMode));

        if (compositingMode != NULL) {

            m3gInitObject(&compositingMode->object, m3g,

                          M3G_CLASS_COMPOSITING_MODE);

            compositingMode->blendingMode = M3G_REPLACE;

            compositingMode->alphaThreshold = 0.0f;

            compositingMode->depthTest = GL_TRUE;

            compositingMode->depthTest = GL_TRUE;

            compositingMode->depthWrite = GL_TRUE;

            compositingMode->colorWrite = GL_TRUE;

            compositingMode->alphaWrite = GL_TRUE;

            compositingMode->factor = 0.0f;

            compositingMode->units = 0.0f;

        }

        return (M3GCompositingMode) compositingMode;

    }

}

/*!

 * \brief Set blending mode.

 *

 * \param handle CompositingMode object

 * \param mode blending mode

 */

M3G_API void m3gSetBlending(M3GCompositingMode handle, M3Gint mode)

{

    CompositingMode *compositingMode = (CompositingMode*)handle;

    if (mode != M3G_REPLACE && mode != M3G_ALPHA_BLEND && mode != M3G_MODULATE && mode != M3G_MODULATE_X2 && mode != M3G_ALPHA_ADD) {

        m3gRaiseError(M3G_INTERFACE(compositingMode), M3G_INVALID_VALUE);

        return;

    }

    M3G_VALIDATE_OBJECT(compositingMode);

    compositingMode->blendingMode = mode;

}

/*!

 * \brief Get blending mode.

 *

 * \param handle CompositingMode object

 * \return blending mode

 */

M3G_API M3Gint m3gGetBlending(M3GCompositingMode handle)

{

    CompositingMode *compositingMode = (CompositingMode*)handle;

    M3G_VALIDATE_OBJECT(compositingMode);

    return compositingMode->blendingMode;

}

/*!

 * \brief Set alpha threshold [0, 1].

 *

 * \param handle CompositingMode object

 * \param threshold alpha threshold [0, 1]

 */

M3G_API void m3gSetAlphaThreshold(M3GCompositingMode handle,

                                  M3Gfloat threshold)

{

    CompositingMode *compositingMode = (CompositingMode*)handle;

    M3G_VALIDATE_OBJECT(compositingMode);

    if (!m3gInRangef(threshold, 0.0f, 1.0f)) {

        m3gRaiseError(M3G_INTERFACE(compositingMode), M3G_INVALID_VALUE);

        return;

    }

    compositingMode->alphaThreshold = threshold;

}

/*!

 * \brief Get alpha threshold.

 *

 * \param handle CompositingMode object

 * \return alpha threshold

 */

M3G_API M3Gfloat m3gGetAlphaThreshold(M3GCompositingMode handle)

{

    CompositingMode *compositingMode = (CompositingMode*)handle;

    M3G_VALIDATE_OBJECT(compositingMode);

    return compositingMode->alphaThreshold;

}

/*!

 * \brief Set depth test enable.

 *

 * \param handle CompositingMode object

 * \param enable depth test enable

 */

M3G_API void m3gEnableDepthTest(M3GCompositingMode handle, M3Gbool enable)

{

    CompositingMode *compositingMode = (CompositingMode*)handle;

    M3G_VALIDATE_OBJECT(compositingMode);

    compositingMode->depthTest = (GLboolean) enable;

}

/*!

 * \brief Set depth write enable.

 *

 * \param handle CompositingMode object

 * \param enable depth write enable

 */

M3G_API void m3gEnableDepthWrite(M3GCompositingMode handle, M3Gbool enable)

{

    CompositingMode *compositingMode = (CompositingMode*)handle;

    M3G_VALIDATE_OBJECT(compositingMode);

    compositingMode->depthWrite = (GLboolean) enable;

}

/*!

 * \brief Set color write enable.

 *

 * \param handle CompositingMode object

 * \param enable color write enable

 */

M3G_API void m3gEnableColorWrite(M3GCompositingMode handle, M3Gbool enable)

{

    CompositingMode *compositingMode = (CompositingMode*)handle;

    M3G_VALIDATE_OBJECT(compositingMode);

    compositingMode->colorWrite = (GLboolean) enable;

}

/*!

 * \brief Set depth offset with factor and units.

 *

 * \param handle CompositingMode object

 * \param factor slope dependent depth offset

 * \param units constant depth offset

 */

M3G_API void m3gSetDepthOffset(M3GCompositingMode handle,

                               M3Gfloat factor, M3Gfloat units)

{

    CompositingMode *compositingMode = (CompositingMode*)handle;

    M3G_VALIDATE_OBJECT(compositingMode);

    compositingMode->factor = factor;

    compositingMode->units = units;

}

/*!

 * \brief Get depth offset factor.

 *

 * \param handle CompositingMode object

 * \return slope dependent depth offset

 */

M3G_API M3Gfloat m3gGetDepthOffsetFactor(M3GCompositingMode handle)

{

    CompositingMode *compositingMode = (CompositingMode*)handle;

    M3G_VALIDATE_OBJECT(compositingMode);

    return compositingMode->factor;

}

/*!

 * \brief Get depth offset units.

 *

 * \param handle CompositingMode object

 * \return constant depth offset

 */

M3G_API M3Gfloat m3gGetDepthOffsetUnits(M3GCompositingMode handle)

{

    CompositingMode *compositingMode = (CompositingMode*)handle;

    M3G_VALIDATE_OBJECT(compositingMode);

    return compositingMode->units;

}

/*!

 * \brief Get alpha write enable.

 *

 * \param handle CompositingMode object

 * \retval M3G_TRUE alpha write enabled

 * \retval M3G_FALSE alpha write disabled

 */

M3G_API M3Gbool m3gIsAlphaWriteEnabled(M3GCompositingMode handle)

{

    CompositingMode *compositingMode = (CompositingMode*)handle;

    M3G_VALIDATE_OBJECT(compositingMode);

    return compositingMode->alphaWrite;

}

/*!

 * \brief Get color write enable.

 *

 * \param handle CompositingMode object

 * \retval M3G_TRUE color write enabled

 * \retval M3G_FALSE color  write disabled

 */

M3G_API M3Gbool m3gIsColorWriteEnabled(M3GCompositingMode handle)

{

    CompositingMode *compositingMode = (CompositingMode*)handle;

    M3G_VALIDATE_OBJECT(compositingMode);

    return compositingMode->colorWrite;

}

/*!

 * \brief Get depth test enable.

 *

 * \param handle CompositingMode object

 * \retval M3G_TRUE depth test enabled

 * \retval M3G_FALSE depth test disabled

 */

M3G_API M3Gbool m3gIsDepthTestEnabled(M3GCompositingMode handle)

{

    CompositingMode *compositingMode = (CompositingMode*)handle;

    M3G_VALIDATE_OBJECT(compositingMode);

    return compositingMode->depthTest;

}

/*!

 * \brief Get depth write enable.

 *

 * \param handle CompositingMode object

 * \retval M3G_TRUE depth write enabled

 * \retval M3G_FALSE depth write disabled

 */

M3G_API M3Gbool m3gIsDepthWriteEnabled(M3GCompositingMode handle)

{

    CompositingMode *compositingMode = (CompositingMode*)handle;

    M3G_VALIDATE_OBJECT(compositingMode);

    return compositingMode->depthWrite;

}

/*!

 * \brief Set alpha write enable.

 *

 * \param handle CompositingMode object

 * \param enable alpha write enable

 */

M3G_API void m3gSetAlphaWriteEnable(M3GCompositingMode handle, M3Gbool enable)

{

    CompositingMode *compositingMode = (CompositingMode*)handle;

    M3G_VALIDATE_OBJECT(compositingMode);

    compositingMode->alphaWrite = (GLboolean) enable;

}