/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:    

*

*/

// INCLUDE FILES

#include "HgVgMediaWallRenderer.h"

#include "HgVgHelper.h"

#include "HgConstants.h"

#include "HgVgConstants.h"

#include <VG/vgu.h>

#include <ganes/HgVgItem.h>

#include <AknUtils.h>

#include <layoutmetadata.cdl.h>

#include <AknLayout2ScalableDef.h>

#include <AknsDrawUtils.h>

#include <e32math.h>

using namespace HgVgConstants;

const VGfloat KColorByteToFloat(255.0f);

// Ending position of the left album stack

const VGfloat KLeftStackEndX(-1.04);//-235.0f);

// Ending position of the right album stack

const VGfloat KRightStackStartX(1.04);//235.0f);

// Space between albums in stacks

const VGfloat KSpaceBetween(1.04);//235);

const TInt KGroundHeightFactor(2);

const TInt KNumGroundGradientValues(4);

const VGfloat KGroundGradient[] = {

        0.0f, 0.0f, 0.0f, 1.0f

};

const TInt KGroundVerticesHint(4);

const TInt KGroundSegmentsHint(4);

const VGfloat KGroundScale(1.0f);

const VGfloat KGroundBias(0.0f);

const VGfloat KFov(PI/2);

const VGfloat KFlipAngle(PI);

const VGfloat KQuadVerts[] =

            {

                    -1.0f, -1.0f, 0.0f,

                    1.0f, -1.0f, 0.0f,

                    1.0f, 1.0f, 0.0f,

                    -1.0f, 1.0f, 0.0f

            };

VGfloat EaseOutQuad(VGfloat start, VGfloat end, VGfloat t)

{

    VGfloat s = t - 1.0f;

    VGfloat f = -(s*s*s*s) + 1.0f;    

    return start * (1.0f - f) + end * f;

}   

VGfloat EaseInQuad(VGfloat start, VGfloat end, VGfloat t)

{

    VGfloat s = t;

    VGfloat f = (s*s*s*s);    

    return start * (1.0f - f) + end * f;

}   

VGfloat BoundValue(VGfloat value, VGfloat min, VGfloat max)

{

    if (value > max) return max;

    if (value < min) return min;

    return value;

}

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CHgVgCoverflowRenderer::NewL()

// -----------------------------------------------------------------------------

//

CHgVgMediaWallRenderer* CHgVgMediaWallRenderer::NewL(TInt aMaxQuads, const TRect& aRect, 

        const TRect& aFrontRect, TReal aZOffset )

    {

    CHgVgMediaWallRenderer* self = new (ELeave) CHgVgMediaWallRenderer( aRect, 

            aFrontRect, aZOffset);

    CleanupStack::PushL( self );

    self->ConstructL(aMaxQuads);

    CleanupStack::Pop( self );

    return self;

    }

// -----------------------------------------------------------------------------

// CHgVgMediaWallRenderer::ConstructL()

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CHgVgMediaWallRenderer::ConstructL (TInt aMaxQuads)

    {

    for (TInt i = 0; i < aMaxQuads; i++)

        {

        TQuad* q = new (ELeave)TQuad;

        q->iItemIndex = -1;

        CleanupStack::PushL(q);

        iQuads.AppendL(q);

        CleanupStack::Pop(q);

        }

    CreateGround();

    }

// -----------------------------------------------------------------------------

// CHgVgMediaWallRenderer::CHgVgMediaWallRenderer()

// C++ default constructor can NOT contain any code, that might leave.

// -----------------------------------------------------------------------------

//

CHgVgMediaWallRenderer::CHgVgMediaWallRenderer(

        const TRect& aWindowRect, 

        const TRect& aFrontRect, 

        TReal aZOffset) :

        iRect(aWindowRect),

        iReflectionsEnabled(ETrue), 

        iSelectedItemIndex(KSelectedItemIndex),

        iLeftStackEndX(KLeftStackEndX),

        iRightStackStartX(KRightStackStartX),

        iSpaceBetween(KSpaceBetween),

        iFov(KFov),

        iFlipAngle(KFlipAngle)

    {

    AdjustSettingsBasedOnRects(aFrontRect, aZOffset);

    }

// -----------------------------------------------------------------------------

// CHgVgScrollBar::~CHgVgScrollBar()

// Destructor.

// -----------------------------------------------------------------------------

//

CHgVgMediaWallRenderer::~CHgVgMediaWallRenderer ( )

    {

    if (iDefaultImage != VG_INVALID_HANDLE)

        vgDestroyImage(iDefaultImage);

    if (iChildBlurImage != VG_INVALID_HANDLE)

        vgDestroyImage(iChildBlurImage);

    if (iBlurImage != VG_INVALID_HANDLE)

        vgDestroyImage(iBlurImage);

    vgDestroyPaint(iGroundPaint);

    vgDestroyPath(iGroundPath);

    iQuads.ResetAndDestroy();

    iSortedQuads.Reset();

    }

// -----------------------------------------------------------------------------

// CHgMediaWallRenderer::SetDefaultImage()

// Setter for default image used to draw quads.

// -----------------------------------------------------------------------------

//

void CHgVgMediaWallRenderer::SetDefaultIconL(const CGulIcon& aIcon)

    {    

    iDefaultImage = HgVgHelper::CreateVgImageFromIconL(aIcon);

    }

// -----------------------------------------------------------------------------

// CHgMediaWallRenderer::SetCameraPosition()

// Setter for camera position modifier.

// -----------------------------------------------------------------------------

//

void CHgVgMediaWallRenderer::SetCameraPosition(TReal aX, TReal aY, TReal aZ)

    {

    iCameraX = aX;

    iCameraY = aY;

    iCameraZ = aZ;

    }

// -----------------------------------------------------------------------------

// CHgMediaWallRenderer::SetCameraRotation()

// -----------------------------------------------------------------------------

//

void CHgVgMediaWallRenderer::SetCameraRotation(TReal aAngle)

    {

    iCameraRotation = aAngle;

    }

// -----------------------------------------------------------------------------

// CHgVgScrollBar::SortQuads

// Sorts quads from iQuads to iSortedQuads.

// -----------------------------------------------------------------------------

//

void CHgVgMediaWallRenderer::SortQuadsL(TInt aNumQuads)

    {

    iSortedQuads.Reset();

    for(TInt i = 0; i < aNumQuads; ++i)

        {

        iSortedQuads.AppendL(iQuads[i]);

        }

    for (TInt i = 1; i < aNumQuads; i++)

        {

        for (int j = 0; j < aNumQuads; j++)

            {

            if( iSortedQuads[i]->iZ > iSortedQuads[j]->iZ )

                {

                TQuad* q1 = iSortedQuads[i];

                TQuad* q2 = iSortedQuads[j];

                iSortedQuads[i] = q2;

                iSortedQuads[j] = q1;

                }

            }

        }

    }

// -----------------------------------------------------------------------------

// CHgVgScrollBar::GetItemIndex

// gets index of the item under pointer position.

// -----------------------------------------------------------------------------

//

TInt CHgVgMediaWallRenderer::GetItemIndex(const TPoint& aPointerPosition) const

    {

    for (TInt i = 0; i < iSortedQuads.Count(); i++)

        {

        VGfloat* verts = iSortedQuads[iSortedQuads.Count()-i-1]->iPoints;

        TRect rect;

        HgVgHelper::CalculateBoundingRect(rect, verts, 4, iRect);

        if (rect.Contains(aPointerPosition))

            {

            TInt index = iSortedQuads.Count()-i-1;

            return iSortedQuads[index]->iItemIndex;

            }

        }

    return KErrNotFound;    

    }

// -----------------------------------------------------------------------------

// CHgVgScrollBar::TransformQuads

// Draws quads using OpenVG.

// -----------------------------------------------------------------------------

//

void CHgVgMediaWallRenderer::TransformQuads(TInt aNumVisibleQuads,

        TBool aMirrored, VGfloat aFov, CHgVgMediaWall::THgVgOpeningAnimationType aOpeningAnimationType)

    {

    VGfloat scW = (VGfloat) iRect.Width();

    VGfloat scH = (VGfloat) iRect.Height();

    VGfloat imW = (VGfloat)iImageSize.iWidth;

    VGfloat imH = (VGfloat)iImageSize.iHeight;

    // construct mirror matrix

    HgVgHelper::TMatrix mirrorMatrix;

    mirrorMatrix.Scale(1, -1, 1);

    // construct camera rotation matrix

    HgVgHelper::TMatrix cameraRotMatrix;    

    if (iFlipXY)

        {

        cameraRotMatrix.RotationX(iCameraRotation);

        }

    else

        {

        cameraRotMatrix.RotationY(iCameraRotation);

        }

    // mat[0] = transform

    // mat[1] = mirrored transform

    HgVgHelper::TMatrix mat[2];

    VGfloat cameraX = iCameraBaseX + iCameraX;

    VGfloat cameraY = iCameraBaseY + iCameraY;

    VGfloat cameraZ = iCameraBaseZ + iCameraZ;

    if (iFlipXY)

        {

        VGfloat foobar = cameraX;

        cameraX = cameraY;

        cameraY = foobar;

        }

    // scaling matrix is used to set correct size for the 

    // quad by image size

    VGfloat hImW = (VGfloat)KWorldQuadWidth * 0.5f;

    VGfloat hImH = (VGfloat)imH * (KWorldQuadWidth / imW) * 0.5f;

    VGfloat oldHImH = hImH;

    // flips image upside down

    HgVgHelper::TMatrix scaleMatrix;

    scaleMatrix.Scale(hImW, -hImH, 1); // negative scale because our all images are updaside down.

    TBool deform = 

            (aOpeningAnimationType == CHgVgMediaWall::EHgVgOpeningAnimationFlipToFront) ||

            (aOpeningAnimationType == CHgVgMediaWall::EHgVgOpeningAnimationZoomToFront);

    for (TInt j = 0; j < aNumVisibleQuads; j++)

        {

        TQuad* q = iQuads[j];

        if (q->iFlipped && deform)

            {

            // animate scaling to flipped rect size

            VGfloat newH = (VGfloat)iFlippedHeight * (KWorldQuadWidth / iFlippedWidth) * 0.5f;

            hImH = HgVgHelper::Lerp(hImH, newH, iBlurAlpha);

            mat[0].Identity();

            mat[0].Scale(hImW, -hImH, 1);

            }

        else

            {

            // restore old normal half image height

            hImH = oldHImH;

            mat[0] = scaleMatrix;        

            }

        // rotMatrix rotates by quads angle

        HgVgHelper::TMatrix rotMatrix;

        rotMatrix.RotationY(-q->iAngle);

        // trMatrix translates by quads position

        HgVgHelper::TMatrix trMatrix;

        trMatrix.Translation(q->iX, q->iY + hImH, q->iZ);

        // then rotate

        if (q->iAngle != 0)

            {

            mat[0].Multiply(rotMatrix);

            }

        // then translate to position

        mat[0].Multiply(trMatrix);

        // construct mirroring matrix

        if (aMirrored)

            {

            mat[1] = mat[0];

            mat[1].Multiply(mirrorMatrix);

            }

        // construct camera translation matrix

        HgVgHelper::TMatrix cameraMatrix;

        cameraMatrix.Translation(-cameraX, -cameraY - hImH, -cameraZ);

        // apply camera movement

        mat[0].Multiply(cameraMatrix);

        // apply camera rotation hack

        mat[0].Multiply(cameraRotMatrix);

        // apply to mirror matrix also

        if (aMirrored)

            {

            mat[1].Multiply(cameraMatrix);

            mat[1].Multiply(cameraRotMatrix);

            }

        // transform all points by resulting transformation matrix

        // and project to screen coordinates.

        TInt count = aMirrored ? 2 : 1;

        for (TInt k = 0; k < count; k++)            

            {

            VGfloat* tverts = NULL;

            VGfloat* tm = NULL; 

            if (k == 0)

                {

                tverts = q->iPoints;

                tm = q->iTM;

                }

            else

                {

                tverts = q->iMirroredPoints;

                tm = q->iMirroredTM;

                }

            for (TInt i = 0; i < 4; i++)

                {

                HgVgHelper::TVertex v;

                v.iX = KQuadVerts[i*3+0];

                v.iY = KQuadVerts[i*3+1];

                v.iZ = KQuadVerts[i*3+2];

                v.TransformPoint(mat[k]);

                v.ProjectPoint(scW, scH, aFov);

                tverts[i*2+0] = v.iScreenX;

                tverts[i*2+1] = v.iScreenY;

                }

            VGImage image = q->iNoImage ? iDefaultImage : q->iImage;

            VGfloat pxWidth = vgGetParameteri(image, VG_IMAGE_WIDTH);

            VGfloat pxHeight = vgGetParameteri(image, VG_IMAGE_HEIGHT); 

            // use screen coordinates to build warp matrix

            // for rendering the image

            vguComputeWarpQuadToQuad(tverts[0], tverts[1], tverts[2], tverts[3],

                    tverts[4], tverts[5], tverts[6], tverts[7], 0, 0, pxWidth, 0,

                    pxWidth, pxHeight, 0, pxHeight, tm);

            }

        }    

    }

// -----------------------------------------------------------------------------

// CHgVgScrollBar::DrawQuads

// Draws quads using OpenVG.

// -----------------------------------------------------------------------------

//

void CHgVgMediaWallRenderer::DrawQuads(TBool aDrawMirrored)

    {    

    VGfloat values[] = { 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0 };

    vgSeti(VG_COLOR_TRANSFORM, VG_TRUE);

    for (TInt j = 0; j < iSortedQuads.Count(); j++)

        {

        TQuad* q = iSortedQuads[j];

        if (q->iAlpha < 0.01f)

            continue;

        values[3] = q->iAlpha;

        vgSetfv(VG_COLOR_TRANSFORM_VALUES, 8, values);

        if (q->iZ < 0)

            continue;

        DrawQuad(q, aDrawMirrored);

        }

    vgSeti(VG_COLOR_TRANSFORM, VG_FALSE);

    }

// -----------------------------------------------------------------------------

// CHgVgMediaWallRenderer::DrawQuad

// -----------------------------------------------------------------------------

//

void CHgVgMediaWallRenderer::DrawQuad(CHgVgMediaWallRenderer::TQuad* q, TBool aDrawMirrored)

    {

    vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE);    

    vgLoadIdentity();

    if (iLandscape)

    {

        vgTranslate(0.0f, 640.0f); 

        vgRotate(-90.0f);

    }

    vgTranslate(iOffset.iX, iOffset.iY);

    VGImage image = q->iImage;

    if (q->iNoImage)

        {

        image = iDefaultImage;

        }

    if (aDrawMirrored)

        {

        vgMultMatrix(q->iMirroredTM);

        }

    else

        {

        vgMultMatrix(q->iTM);

        if ((iBlurImage != VG_INVALID_HANDLE) && (iChildBlurImage != VG_INVALID_HANDLE) && q->iFlipped)

            {

            vgGaussianBlur(iChildBlurImage, image, iBlurDeviationX*iBlurAlpha, 

                    iBlurDeviationY*iBlurAlpha, VG_TILE_PAD);

            image = iChildBlurImage;

            }

        }

    vgDrawImage(image);    

    }

// -----------------------------------------------------------------------------

// CHgVgScrollBar::Draw()

// -----------------------------------------------------------------------------

//

void CHgVgMediaWallRenderer::Draw(RPointerArray<CHgVgItem>& aItems,

        TInt aSelectedIndex, TReal aNextIndex,

        TReal aViewPosition,

        TReal aAnimationAlpha,

        CHgVgMediaWall::THgVgAnimationState aState, 

        CHgVgMediaWall::THgVgOpeningAnimationType aSelectionAnimationType, 

        CHgVgMediaWall::THgVgMediaWallStyle /*aStyle*/,

        TReal aStartIndex, 

        TReal aSpringVelocity)

    { 

    TInt itemsOnScreen = 0;

    itemsOnScreen = SetupQuads(aItems,

            aSelectedIndex, aNextIndex,

            aViewPosition,

            aAnimationAlpha,

            aState, aSelectionAnimationType, aStartIndex, aSpringVelocity);

    TransformAndDraw(itemsOnScreen, aSelectionAnimationType);

    }

// ---------------------------------------------------------------------------

// CHgVgMediaWallRenderer::DrawGrid()

// ---------------------------------------------------------------------------