/*

 * 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