/*
* 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: Background implementation
*
*/


/*!
 * \internal
 * \file
 * \brief Background implementation
 */

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

#include "m3g_background.h"
#include "m3g_image.h"
#include "m3g_memory.h"
#include "m3g_animationtrack.h"
#include "m3g_rendercontext.h"

/*----------------------------------------------------------------------
 * Internal functions
 *--------------------------------------------------------------------*/

/*!
 * \internal
 * \brief Destroys this Background object.
 *
 * \param obj Background object
 */
static void m3gDestroyBackground(Object *obj)
{
    Background *background = (Background *) obj;
    M3G_VALIDATE_OBJECT(background);

    M3G_ASSIGN_REF(background->image, NULL);
    m3gDestroyObject(obj);
}

/*!
 * \internal
 * \brief Applies background color and image
 * using a textured quad.
 *
 * \param ctx           render context
 * \param background    Background object
 */
static void m3gApplyBackground(RenderContext *ctx, Background *background)
{
    GLbitfield glBits = 0;
    GLfixed temp[4];
    
    if (background->depthClearEnable) {
        glBits |= GL_DEPTH_BUFFER_BIT;
    }

    /* Skip color buffer clearing if the background image
     * fills the whole viewport. This is guaranteed to happen
     * if the crop rectangle is non-zero and both X and Y
     * wrapping modes are REPEAT. */
    
    if (background->colorClearEnable) {
        if (background->image == NULL ||
            background->crop.width == 0 ||
            background->crop.height == 0 ||
            background->modeX == M3G_BORDER ||
            background->modeY == M3G_BORDER)
        {
            glBits |= GL_COLOR_BUFFER_BIT;
            m3gGLColor(background->color, temp);
            glClearColorx(temp[0], temp[1], temp[2], temp[3]);
        }
    }
    
    /* Clear color and/or depth buffer (or neither) */
    glClear(glBits);

    /* Apply background image using a quad that
       fills the viewport */

    if (background->colorClearEnable &&
        background->image != NULL &&
        background->crop.width != 0 && 
        background->crop.height != 0)
    {
        {
            /* Texture coordinates */
            M3Gshort texvert[4 * 2];
            /* Quad that fills the viewport */
            M3Gint vert[4 * 3]   = { -65536,  65536, 0,
                                     -65536, -65536, 0,
                                      65536,  65536, 0,
                                      65536, -65536, 0 };
            Rect rImage, rIntersection;
            M3Gbool intersects;
            Image *imagePow2;

            /* Get power of two image */
            imagePow2 = m3gGetPowerOfTwoImage(background->image);
            /* If NULL -> out of memory */
            if (!imagePow2) {
                return;
            }

            rImage.x = 0;
            rImage.y = 0;
            rImage.width = m3gGetWidth(background->image);
            rImage.height = m3gGetHeight(background->image);

            /* Intersection of source image and crop rectangle */
            intersects = m3gIntersectRectangle(&rIntersection, &rImage, &background->crop);

            /* Setup X vertices and texture S coordinates */
            if (background->modeX == M3G_BORDER) {
                /* If both modes are border and no intersection ->
                   nothing to draw */
                if (background->modeY == M3G_BORDER && !intersects) {
                    return;
                }

                texvert[0 * 2 + 0] = (M3Gshort) rIntersection.x;
                texvert[1 * 2 + 0] = (M3Gshort) rIntersection.x;
                texvert[2 * 2 + 0] = (M3Gshort) (rIntersection.x + rIntersection.width);
                texvert[3 * 2 + 0] = (M3Gshort) (rIntersection.x + rIntersection.width);

                vert[0 * 3 + 0] = -65536 + 2 * 65536 * (rIntersection.x - background->crop.x) / background->crop.width;
                vert[1 * 3 + 0] = vert[0 * 3 + 0];
                vert[2 * 3 + 0] = vert[0 * 3 + 0] + 2 * 65536 * rIntersection.width / background->crop.width;
                vert[3 * 3 + 0] = vert[2 * 3 + 0];
            }
            else {
                /* In repeat mode texture coordinates are directly crop rectangle coordinates */
                texvert[0 * 2 + 0] = (M3Gshort) background->crop.x;
                texvert[1 * 2 + 0] = (M3Gshort) background->crop.x;
                texvert[2 * 2 + 0] = (M3Gshort) (background->crop.x + background->crop.width);
                texvert[3 * 2 + 0] = (M3Gshort) (background->crop.x + background->crop.width);
            }

            /* Setup Y vertices and texture T coordinates */
            if (background->modeY == M3G_BORDER) {
                texvert[0 * 2 + 1] = (M3Gshort) rIntersection.y;
                texvert[1 * 2 + 1] = (M3Gshort) (rIntersection.y + rIntersection.height);
                texvert[2 * 2 + 1] = (M3Gshort) rIntersection.y;
                texvert[3 * 2 + 1] = (M3Gshort) (rIntersection.y + rIntersection.height);


                vert[0 * 3 + 1] =  65536 - 2 * 65536 * (rIntersection.y - background->crop.y) / background->crop.height;
                vert[1 * 3 + 1] = vert[0 * 3 + 1] - 2 * 65536 * rIntersection.height / background->crop.height;
                vert[2 * 3 + 1] = vert[0 * 3 + 1];
                vert[3 * 3 + 1] = vert[1 * 3 + 1];
            }
            else {
                /* In repeat mode texture coordinates are directly crop rectangle coordinates */
                texvert[0 * 2 + 1] = (M3Gshort) background->crop.y;
                texvert[1 * 2 + 1] = (M3Gshort) (background->crop.y + background->crop.height);
                texvert[2 * 2 + 1] = (M3Gshort) background->crop.y;
                texvert[3 * 2 + 1] = (M3Gshort) (background->crop.y + background->crop.height);
            }

            /* Disable unwanted state and depth writes */
            m3gApplyAppearance(NULL, ctx, 0);
            glDepthMask(GL_FALSE);

            /* Disable color array, normals and textures*/
            glDisableClientState(GL_COLOR_ARRAY);
            glDisableClientState(GL_NORMAL_ARRAY);
        
            /* Background image to texture unit 0 */
            glClientActiveTexture(GL_TEXTURE0);
            glActiveTexture(GL_TEXTURE0);
            glEnableClientState(GL_TEXTURE_COORD_ARRAY);
            glTexCoordPointer(2, GL_SHORT, 0, texvert);
            glEnable(GL_TEXTURE_2D);
            glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, (GLfixed) GL_REPLACE);
            m3gBindTextureImage(imagePow2,
                                M3G_FILTER_BASE_LEVEL,
                                m3gIsAccelerated(ctx) ? M3G_FILTER_LINEAR : M3G_FILTER_NEAREST);

            /* Set wrapping */
            if (background->modeX == M3G_REPEAT) {
                glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
            }
            else {
                glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
            }
    
            if (background->modeY == M3G_REPEAT) {
                glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
            }
            else {
                glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
            }

            /* Texture matrix scale */
            glMatrixMode(GL_TEXTURE);
            glLoadIdentity();
            glScalef(   m3gRcp((M3Gfloat)m3gGetWidth(background->image)),
                        m3gRcp((M3Gfloat)m3gGetHeight(background->image)),
                        1.f);
            glMatrixMode(GL_MODELVIEW);

            /* Load vertices */
            glEnableClientState(GL_VERTEX_ARRAY);
            glVertexPointer(3, GL_FIXED, 0, vert);
        
            /* Set up an identity modelview and projection */
            m3gPushScreenSpace(ctx, M3G_FALSE);

            /* Load indices -> draws the background */
            M3G_BEGIN_PROFILE(M3G_INTERFACE(ctx), M3G_PROFILE_NGL_DRAW);
            glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
            M3G_END_PROFILE(M3G_INTERFACE(ctx), M3G_PROFILE_NGL_DRAW);
        
            m3gPopSpace(ctx);
            m3gReleaseTextureImage(imagePow2);
        }
    }
}

/*!
 * \internal
 * \brief Overloaded Object3D method.
 *
 * \param property      animation property
 * \retval M3G_TRUE     property supported
 * \retval M3G_FALSE    property not supported
 */
static M3Gbool m3gBackgroundIsCompatible(M3Gint property)
{
    switch (property) {
    case M3G_ANIM_ALPHA:
    case M3G_ANIM_COLOR:
    case M3G_ANIM_CROP:
        return M3G_TRUE;
    default:
        return m3gObjectIsCompatible(property);
    }
}

/*!
 * \internal
 * \brief Overloaded Object3D method.
 *
 * \param self          Background object
 * \param property      animation property
 * \param valueSize     size of value array
 * \param value         value array
 */
static void m3gBackgroundUpdateProperty(Object *self,
                                        M3Gint property,
                                        M3Gint valueSize,
                                        const M3Gfloat *value)
{
    Background *background = (Background *)self;
    M3G_VALIDATE_OBJECT(background);
    M3G_ASSERT_PTR(value);
    
    switch (property) {
    case M3G_ANIM_ALPHA:
        M3G_ASSERT(valueSize >= 1);
        background->color = m3gAlpha1f(value[0])
            & (background->color | M3G_ALPHA_MASK);
        break;
    case M3G_ANIM_COLOR:
        M3G_ASSERT(valueSize >= 3);
        background->color = m3gColor3f(value[0], value[1], value[2])
            & (background->color | M3G_RGB_MASK);
        break;
    case M3G_ANIM_CROP:
        M3G_ASSERT(valueSize >= 2);
        background->crop.x = m3gRoundToInt(value[0]);
        background->crop.y = m3gRoundToInt(value[1]);
        if (valueSize > 2) {
            M3G_ASSERT(valueSize >= 4);
            background->crop.width =
                (value[2] < 0) ? 0 : m3gRoundToInt(value[2]);
            background->crop.height =
                (value[3] < 0) ? 0 : m3gRoundToInt(value[3]);
        }
        break;
    default:
        m3gObjectUpdateProperty(self, property, valueSize, value);
    }
}

/*!
 * \internal
 * \brief Overloaded Object3D method.
 *
 * \param self Background object
 * \param references array of reference objects
 * \return number of references
 */
static M3Gint m3gBackgroundDoGetReferences(Object *self, Object **references)
{
    Background *bg = (Background *)self;
    M3Gint num = m3gObjectDoGetReferences(self, references);
    if (bg->image != NULL) {
        if (references != NULL)
            references[num] = (Object *)bg->image;
        num++;
    }
    return num;
}

/*!
 * \internal
 * \brief Overloaded Object3D method.
 */
static Object *m3gBackgroundFindID(Object *self, M3Gint userID)
{
    Background *bg = (Background *)self;
    Object *found = m3gObjectFindID(self, userID);

    if (!found && bg->image) {
        found = m3gFindID((Object*) bg->image, userID);
    }
    return found;
}

/*!
 * \internal
 * \brief Overloaded Object3D method.
 *
 * \param originalObj original Background object
 * \param cloneObj pointer to cloned Background object
 * \param pairs array for all object-duplicate pairs
 * \param numPairs number of pairs
 */
static M3Gbool m3gBackgroundDuplicate(const Object *originalObj,
                                      Object **cloneObj,
                                      Object **pairs,
                                      M3Gint *numPairs)
{
    Background *original = (Background *)originalObj;
    Background *clone = (Background *)m3gCreateBackground(originalObj->interface);
    *cloneObj = (Object *)clone;
    if (*cloneObj == NULL) {
        return M3G_FALSE;
    }

    if (m3gObjectDuplicate(originalObj, cloneObj, pairs, numPairs)) {
        clone->color = original->color;
        clone->modeX = original->modeX;
        clone->modeY = original->modeY;
        clone->crop = original->crop;
        clone->colorClearEnable = original->colorClearEnable;
        clone->depthClearEnable = original->depthClearEnable;
        M3G_ASSIGN_REF(clone->image, original->image);
        return M3G_TRUE;
    }
    else {
        return M3G_FALSE;
    }
}

/*!
 * \internal
 * \brief Initializes a Background object. See specification
 * for default values.
 *
 * \param m3g           M3G interface
 * \param background    Background object
 */
static void m3gInitBackground(Interface *m3g, Background *background)
{
    /* Background is derived from Object */
    m3gInitObject(&background->object, m3g, M3G_CLASS_BACKGROUND);

    background->modeX = M3G_BORDER; 
    background->modeY = M3G_BORDER; 
    background->colorClearEnable = M3G_TRUE;
    background->depthClearEnable = M3G_TRUE;
}

/*----------------------------------------------------------------------
 * Virtual function table
 *--------------------------------------------------------------------*/

static const ObjectVFTable m3gvf_Background = {
    m3gObjectApplyAnimation,
    m3gBackgroundIsCompatible,
    m3gBackgroundUpdateProperty,
    m3gBackgroundDoGetReferences,
    m3gBackgroundFindID,
    m3gBackgroundDuplicate,
    m3gDestroyBackground
};


/*----------------------------------------------------------------------
 * Public API functions
 *--------------------------------------------------------------------*/

/*!
 * \brief Creates a Background object.
 *
 * \param interface     M3G interface
 * \retval Background new Background object
 * \retval NULL Background creating failed
 */

/*@access M3GInterface@*/
/*@access M3Gobject@*/
M3G_API M3GBackground m3gCreateBackground(M3GInterface interface)
{
    Interface *m3g = (Interface *) interface;
    M3G_VALIDATE_INTERFACE(m3g);

    {
        Background *background =  m3gAllocZ(m3g, sizeof(Background));
    
        if (background != NULL) {
            m3gInitBackground(m3g, background);
        }

        return (M3GBackground) background;
    }
}

/*!
 * \brief Sets background color.
 *
 * \param handle        Background object
 * \param ARGB          background color as ARGB
 */

/*@access M3Gobject@*/
M3G_API void m3gSetBgColor(M3GBackground handle, M3Guint ARGB)
{
    Background *background = (Background *) handle;
    M3G_VALIDATE_OBJECT(background);
    
    background->color = ARGB;
}

/*!
 * \brief Sets background image x and y mode.
 *
 * \param handle        Background object
 * \param modeX         Image X mode
 * \param modeY         Image Y mode
 */

/*@access M3Gobject@*/
M3G_API void m3gSetBgMode(M3GBackground handle, M3Gint modeX, M3Gint modeY)
{
    Background *background = (Background *) handle;
    M3G_VALIDATE_OBJECT(background);
    
    /* Check for errors */
    if (modeX < M3G_BORDER || modeX > M3G_REPEAT ||
        modeY < M3G_BORDER || modeY > M3G_REPEAT) {
        m3gRaiseError(M3G_INTERFACE(background), M3G_INVALID_VALUE);
        return;
    }

    background->modeX = modeX;
    background->modeY = modeY;
}

/*!
 * \brief Sets background image crop rectangle.
 *
 * \param handle        Background object
 * \param cropX         crop upper left x
 * \param cropY         crop upper left y
 * \param width         crop width
 * \param height        crop height
 */

/*@access M3Gobject@*/
M3G_API void m3gSetBgCrop(M3GBackground handle,
                          M3Gint cropX, M3Gint cropY,
                          M3Gint width, M3Gint height)
{
    Background *background = (Background *) handle;
    M3G_VALIDATE_OBJECT(background);

    /* Check for errors */
    if (width < 0 || height < 0) {
        m3gRaiseError(M3G_INTERFACE(background), M3G_INVALID_VALUE);
        return;
    }

    background->crop.x = cropX;
    background->crop.y = cropY;
    background->crop.width = width;
    background->crop.height = height;
}

/*!
 * \brief Sets background image.
 *
 * \param handle        Background object
 * \param hImage        Image2D object or NULL
 */

/*@access M3Gobject@*/
M3G_API void m3gSetBgImage(M3GBackground handle, M3GImage hImage)
{
    Background *background = (Background *) handle;
    Image *image = (Image *)hImage;
    M3G_VALIDATE_OBJECT(background);

    if (image != NULL) {
        /* Check allowed formats */
        if (m3gGetFormat(image) != M3G_RGB &&
            m3gGetFormat(image) != M3G_RGBA) {
            m3gRaiseError(M3G_INTERFACE(background), M3G_INVALID_VALUE);
            return;
        }

        background->crop.x = 0;
        background->crop.y = 0;
        background->crop.width = m3gGetWidth(image);
        background->crop.height = m3gGetHeight(image);
    }

    M3G_ASSIGN_REF(background->image, image);
}

/*!
 * \brief Gets background image.
 *
 * \param handle        Background object
 * \return              Image2D object or NULL
 */

/*@access M3GObject@*/
M3G_API M3GImage m3gGetBgImage(M3GBackground handle)
{
    Background *bg = (Background *) handle;
    M3G_VALIDATE_OBJECT(bg);

    return (M3GImage) bg->image;
}

/*!
 * \brief Gets background color as ARGB.
 *
 * \param handle        Background object
 * \return              ARGB color
 */

/*@access M3Gobject@*/
M3G_API M3Guint m3gGetBgColor(M3GBackground handle)
{
    Background *background = (Background *) handle;
    M3G_VALIDATE_OBJECT(background);

    return background->color;
}

/*!
 * \brief Gets background image x or y mode.
 *
 * \param handle        Background object
 * \param which         which mode to return
 *                      \arg M3G_GET_MODEX
 *                      \arg M3G_GET_MODEY
 * \return              image x or y mode
 */

/*@access M3Gobject@*/
M3G_API M3Gint m3gGetBgMode(M3GBackground handle, M3Gint which)
{
    Background *background = (Background *) handle;
    M3G_VALIDATE_OBJECT(background);

    switch(which) {
        case M3G_GET_MODEX:
            return background->modeX;
        case M3G_GET_MODEY:
        default:
            return background->modeY;
    }
}

/*!
 * \brief Gets background image crop parameter.
 *
 * \param handle        Background object
 * \param which         which crop parameter to return
 *                      \arg M3G_GET_CROPX
 *                      \arg M3G_GET_CROPY
 *                      \arg M3G_GET_CROPWIDTH
 *                      \arg M3G_GET_CROPHEIGHT
 * \return              image crop parameter
 */

/*@access M3Gobject@*/
M3G_API M3Gint m3gGetBgCrop(M3GBackground handle, M3Gint which)
{
    Background *background = (Background *) handle;
    M3G_VALIDATE_OBJECT(background);

    switch(which) {
        case M3G_GET_CROPX:
            return background->crop.x;
        case M3G_GET_CROPY:
            return background->crop.y;
        case M3G_GET_CROPWIDTH:
            return background->crop.width;
        case M3G_GET_CROPHEIGHT:
        default:
            return background->crop.height;
    }
}

/*!
 * \brief Sets background color or depth clear enable.
 *
 * \param handle        Background object
 * \param which         which clear to enable
 *                      \arg M3G_SETGET_COLORCLEAR
 *                      \arg M3G_SETGET_DEPTHCLEAR
 * \param enable        clear enable/disable
 */

/*@access M3Gobject@*/
M3G_API void m3gSetBgEnable(M3GBackground handle, M3Gint which, M3Gbool enable)
{
    Background *background = (Background *) handle;
    M3G_VALIDATE_OBJECT(background);

    switch(which) {
        case M3G_SETGET_COLORCLEAR:
            background->colorClearEnable = enable;
            break;
        case M3G_SETGET_DEPTHCLEAR:
        default:
            background->depthClearEnable = enable;
            break;
    }
}

/*!
 * \brief Gets background color or depth clear enable.
 *
 * \param handle        Background object
 * \param which         which clear to return
 *                      \arg M3G_SETGET_COLORCLEAR
 *                      \arg M3G_SETGET_DEPTHCLEAR
 * \return              clear enabled
 */

/*@access M3Gobject@*/
M3G_API M3Gbool m3gIsBgEnabled(M3GBackground handle, M3Gint which)
{
    Background *background = (Background *) handle;
    M3G_VALIDATE_OBJECT(background);

    switch(which) {
        case M3G_SETGET_COLORCLEAR:
            return background->colorClearEnable;
        case M3G_SETGET_DEPTHCLEAR:
        default:
            return background->depthClearEnable;
    }
}