/*

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

*

*/

/*!

 * \internal

 * \file

 * \brief PolygonMode 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_polygonmode.h"

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

 * Internal functions

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

/*!

 * \internal

 * \brief Applies default polygon mode to OpenGL.

 */

static void m3gApplyDefaultPolygonMode()

{

    /* cull = BACK */

    glCullFace(GL_BACK);

    glEnable(GL_CULL_FACE);

    /* shading = M3G_SHADE_SMOOTH */

    glShadeModel(GL_SMOOTH);

    /*  winding = M3G_WINDING_CCW */

    glFrontFace(GL_CCW);

    /* perspective correction = false */

    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);

    /* lighting = ONE_SIDED */

    glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);

}

/*!

 * \internal

 * \brief Applies polygon mode to OpenGL.

 *

 * \param polygonMode   PolygonMode object

 */

static void m3gApplyPolygonMode(PolygonMode *polygonMode)

{

    if (polygonMode != NULL) {

        if (polygonMode->cullingMode == M3G_CULL_NONE) {

            glDisable(GL_CULL_FACE);

        }

        else {

            if (polygonMode->cullingMode == M3G_CULL_BACK) {

                glCullFace(GL_BACK);

            }

            else {

                glCullFace(GL_FRONT);

            }

            glEnable(GL_CULL_FACE);

        }

        if (m3gGetTwoSidedLightingWorkaround(M3G_INTERFACE(polygonMode))) {

            glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);

        }

        else {

            glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, polygonMode->enableTwoSidedLighting);

        }

        if (polygonMode->shadingMode == M3G_SHADE_FLAT) {

            glShadeModel(GL_FLAT);

        }

        else {

            glShadeModel(GL_SMOOTH);

        }

        if (polygonMode->windingMode == M3G_WINDING_CW) {

            glFrontFace(GL_CW);

        }

        else {

            glFrontFace(GL_CCW);

        }

        if (polygonMode->enablePerspectiveCorrection == GL_TRUE) {

            glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);

        }

        else {

            glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);

        }

    }

    else {

        m3gApplyDefaultPolygonMode();

    }

    M3G_ASSERT_GL;

}

/*!

 * \internal

 * \brief Overloaded Object3D method

 *

 * \param originalObj original PolygonMode object

 * \param cloneObj pointer to cloned PolygonMode object

 * \param pairs array for all object-duplicate pairs

 * \param numPairs number of pairs

 */

static M3Gbool m3gPolygonModeDuplicate(const Object *originalObj,

                                       Object **cloneObj,

                                       Object **pairs,

                                       M3Gint *numPairs)

{

    PolygonMode *original = (PolygonMode *)originalObj;

    PolygonMode *clone;

    M3G_ASSERT(*cloneObj == NULL); /* no derived classes */

    /* Create the clone object */

    clone = (PolygonMode *)m3gCreatePolygonMode(originalObj->interface);

    if (!clone) {

        return M3G_FALSE;

    }

    *cloneObj = (Object *)clone;

    /* Duplicate base class data */

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

        return M3G_FALSE;

    }

    /* Duplicate our own data */

    clone->enableLocalCameraLighting = original->enableLocalCameraLighting;

    clone->enablePerspectiveCorrection = original->enablePerspectiveCorrection;

    clone->cullingMode = original->cullingMode;

    clone->windingMode = original->windingMode;

    clone->shadingMode = original->shadingMode;

    clone->enableTwoSidedLighting = original->enableTwoSidedLighting;

    return M3G_TRUE;

}

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

 * Virtual function table

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

static const ObjectVFTable m3gvf_PolygonMode = {

    m3gObjectApplyAnimation,

    m3gObjectIsCompatible,

    m3gObjectUpdateProperty,

    m3gObjectDoGetReferences,

    m3gObjectFindID,

    m3gPolygonModeDuplicate,

    m3gDestroyObject

};

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

 * Public API functions

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

/*!

 * \brief Creates a new PolygonMode object.

 *

 * \param interface     M3G interface object

 * \retval PolygonMode new PolygonMode object

 * \retval NULL PolygonMode creating failed

 */

M3G_API M3GPolygonMode m3gCreatePolygonMode(M3GInterface interface)

{

    Interface *m3g = (Interface *) interface;

    M3G_VALIDATE_INTERFACE(m3g);

    {

        PolygonMode *polygonMode = m3gAllocZ(m3g, sizeof(PolygonMode));

        if (polygonMode != NULL) {

            m3gInitObject(&polygonMode->object, m3g, M3G_CLASS_POLYGON_MODE);

            polygonMode->enableLocalCameraLighting = GL_FALSE;

            polygonMode->enablePerspectiveCorrection = GL_FALSE;

            polygonMode->cullingMode = M3G_CULL_BACK;

            polygonMode->windingMode = M3G_WINDING_CCW;

            polygonMode->shadingMode = M3G_SHADE_SMOOTH;

            polygonMode->enableTwoSidedLighting = GL_FALSE;

        }

        return (M3GPolygonMode)polygonMode;

    }

}

/*!

 * \brief Set local camera lightning.

 *

 * \param handle        PolygonMode object

 * \param enable        enable flag

 */

M3G_API void m3gSetLocalCameraLightingEnable(M3GPolygonMode handle,

                                             M3Gbool enable)

{

    PolygonMode *polygonMode = (PolygonMode*)handle;

    M3G_VALIDATE_OBJECT(polygonMode);

    polygonMode->enableLocalCameraLighting = (GLboolean) enable;

}

/*!

 * \brief Set perspective correction.

 *

 * \param handle        PolygonMode object

 * \param enable        enable flag

 */

void m3gSetPerspectiveCorrectionEnable(M3GPolygonMode handle, M3Gbool enable)

{

    PolygonMode *polygonMode = (PolygonMode*)handle;

    M3G_VALIDATE_OBJECT(polygonMode);

    polygonMode->enablePerspectiveCorrection = (GLboolean) enable;

}

/*!

 * \brief Set culling mode.

 *

 * \param handle        PolygonMode object

 * \param mode          culling mode

 */

void m3gSetCulling(M3GPolygonMode handle, M3Gint mode)

{

    PolygonMode *polygonMode = (PolygonMode*)handle;

    M3G_VALIDATE_OBJECT(polygonMode);

    switch (mode) {

    case M3G_CULL_BACK:

    case M3G_CULL_FRONT:

    case M3G_CULL_NONE:

        polygonMode->cullingMode = mode;

        break;

    default:

        m3gRaiseError(M3G_INTERFACE(polygonMode), M3G_INVALID_VALUE);

        break;

    }

}

/*!

 * \brief Get culling mode.

 *

 * \param handle        PolygonMode object

 * \return              culling mode

 */

M3G_API M3Gint m3gGetCulling(M3GPolygonMode handle)

{

    PolygonMode *polygonMode = (PolygonMode*)handle;

    M3G_VALIDATE_OBJECT(polygonMode);

    return polygonMode->cullingMode;

}

/*!

 * \brief Set winding mode.

 *

 * \param handle        PolygonMode object

 * \param mode          winding mode

 */

M3G_API void m3gSetWinding(M3GPolygonMode handle, M3Gint mode)

{

    PolygonMode *polygonMode = (PolygonMode*)handle;

    M3G_VALIDATE_OBJECT(polygonMode);

    if (mode != M3G_WINDING_CCW && mode != M3G_WINDING_CW) {

        m3gRaiseError(M3G_INTERFACE(polygonMode), M3G_INVALID_VALUE);

    }

    else {

        polygonMode->windingMode = mode;

    }

}

/*!

 * \brief Get winding mode.

 *

 * \param handle        PolygonMode object

 * \return              winding mode

 */

M3G_API M3Gint m3gGetWinding(M3GPolygonMode handle)

{

    PolygonMode *polygonMode = (PolygonMode*)handle;

    M3G_VALIDATE_OBJECT(polygonMode);

    return polygonMode->windingMode;

}

/*!

 * \brief Set shading mode.

 *

 * \param handle        PolygonMode object

 * \param mode          shading mode

 */

M3G_API void m3gSetShading(M3GPolygonMode handle, M3Gint mode)

{

    PolygonMode *polygonMode = (PolygonMode*)handle;

    M3G_VALIDATE_OBJECT(polygonMode);

    if (mode != M3G_SHADE_FLAT && mode != M3G_SHADE_SMOOTH) {

        m3gRaiseError(M3G_INTERFACE(polygonMode), M3G_INVALID_VALUE);

    }

    else {

        polygonMode->shadingMode = mode;

    }

}

/*!

 * \brief Get shading mode.

 *

 * \param handle        PolygonMode object

 * \return              shading mode

 */

M3G_API M3Gint m3gGetShading(M3GPolygonMode handle)

{

    PolygonMode *polygonMode = (PolygonMode*)handle;

    M3G_VALIDATE_OBJECT(polygonMode);

    return polygonMode->shadingMode;

}

/*!

 * \brief Set two sided lighting.

 *

 * \param handle        PolygonMode object

 * \param enable        enable flag

 */

M3G_API void m3gSetTwoSidedLightingEnable(M3GPolygonMode handle,

                                          M3Gbool enable)

{

    PolygonMode *polygonMode = (PolygonMode*)handle;

    M3G_VALIDATE_OBJECT(polygonMode);

    polygonMode->enableTwoSidedLighting = (GLboolean) enable;

}

/*!

 * \brief Get two sided lighting.

 *

 * \param handle        PolygonMode object

 * \retval M3G_TRUE     enabled

 * \retval M3G_FALSE    disabled

 */

M3G_API M3Gbool m3gIsTwoSidedLightingEnabled(M3GPolygonMode handle)

{

    PolygonMode *polygonMode = (PolygonMode*)handle;

    M3G_VALIDATE_OBJECT(polygonMode);

    return (M3Gbool) polygonMode->enableTwoSidedLighting;

}

/*!

 * \brief Get local camera lighting.

 *

 * \param handle        PolygonMode object

 * \retval M3G_TRUE     enabled

 * \retval M3G_FALSE    disabled

 */

M3G_API M3Gbool m3gIsLocalCameraLightingEnabled(M3GPolygonMode handle)

{

    PolygonMode *polygonMode = (PolygonMode*)handle;

    M3G_VALIDATE_OBJECT(polygonMode);

    return (M3Gbool) polygonMode->enableLocalCameraLighting;

}

/*!

 * \brief Get perspective correction.

 *

 * \param handle        PolygonMode object

 * \retval M3G_TRUE     enabled

 * \retval M3G_FALSE    disabled

 */

M3G_API M3Gbool m3gIsPerspectiveCorrectionEnabled(M3GPolygonMode handle)

{

    PolygonMode *polygonMode = (PolygonMode*)handle;

    M3G_VALIDATE_OBJECT(polygonMode);

    return (M3Gbool) polygonMode->enablePerspectiveCorrection;

}

/*

 * 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