/*
* 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: Juha Kauppinen, Mika Hokkanen
* 
* Description: Photo Browser
*
*/

#include "CDrawMagGlass.h"
#include "TextureLoader.h"
#include "DrawUtility.h"
#include "ImagicConsts.h"


GLfixed CDrawMagGlass::iMagGlassVertices[VERTICES_PER_LINE*VERTICES_PER_LINE*3];
GLfixed CDrawMagGlass::iMagGlassTex[VERTICES_PER_LINE*VERTICES_PER_LINE*2];
    
const TInt CDrawMagGlass::iMagGlassTriCount=(VERTICES_PER_LINE-1)*(VERTICES_PER_LINE-1)*2;
GLushort CDrawMagGlass::iMagGlassIndices[CDrawMagGlass::iMagGlassTriCount*3];



// Texture coordinate data
const GLfixed CDrawMagGlass::iGlobalTexCoords[] =
   {
   //bitmap has to be flipped over
   0,       1<<16,
   1<<16,   1<<16,
   0,       0,
   1<<16,   0
   };

CDrawMagGlass::CDrawMagGlass()
    {
    // No implementation required
    }

CDrawMagGlass::~CDrawMagGlass()
    {
    }

CDrawMagGlass* CDrawMagGlass::NewLC(CImagicContainerBrowser* aContainer, CDrawOneByOne* aDrawOneByOne)
    {
    CDrawMagGlass* self = new (ELeave) CDrawMagGlass();
    CleanupStack::PushL(self);
    self->ConstructL(aContainer,aDrawOneByOne);
    return self;
    }

CDrawMagGlass* CDrawMagGlass::NewL(CImagicContainerBrowser* aContainer, CDrawOneByOne* aDrawOneByOne)
    {
    CDrawMagGlass* self = CDrawMagGlass::NewLC(aContainer,aDrawOneByOne);
    CleanupStack::Pop(); // self;
    return self;
    }

void CDrawMagGlass::ConstructL(CImagicContainerBrowser* aContainer, CDrawOneByOne* aDrawOneByOne)
    {
    iContainer = aContainer;
    iDrawOneByOne = aDrawOneByOne;
    }

TReal CDrawMagGlass::GetMagGlassZoomFactor()
    {
    DP1_IMAGIC(_L("CDrawMagGlass::GetMagGlassZoomFactor - magGlass: %f"), iMagGlassZoomFactor);
    return iMagGlassZoomFactor;
    }

/*----------------------------------------------------------------------*/
// Interpolates given value into target value with step
//
void CDrawMagGlass::Interpolate(float &aValue, const float aTarget, const float aStep)
    {
    //DP0_IMAGIC(_L("CImagicContainerBrowser::Interpolate"));
    // Calculate new value
    float diff = aTarget-aValue;
    aValue += diff * aStep * 0.2/*iTimeDiff*/ * 30; 
    //float timediff = Min(0.1f, iTimeDiff); // so max value of timediff is 100tick (100ms)
    //aValue += diff * aStep * timediff * 30; 
    
    // Check that value is in range
    if (aValue > aTarget && diff > 0)
        aValue = aTarget;
    if (aValue < aTarget && diff < 0)
        aValue = aTarget;
    }

void CDrawMagGlass::InitDrawMagGlass()
    {
    iMagGlassZoomFactor = 1;
    
    TInt pos=0;
    for (TInt y=0; y<VERTICES_PER_LINE-1; y++)
        {
        TInt startvert=y*VERTICES_PER_LINE;
        for (TInt x=0; x<VERTICES_PER_LINE-1; x++, pos+=6)
            {
            // First triangle
            iMagGlassIndices[pos+0]=startvert+x;
            iMagGlassIndices[pos+1]=startvert+x+1;
            iMagGlassIndices[pos+2]=startvert+x+VERTICES_PER_LINE;
            
            // Second triangle
            iMagGlassIndices[pos+3]=startvert+x+VERTICES_PER_LINE;
            iMagGlassIndices[pos+4]=startvert+x+1;
            iMagGlassIndices[pos+5]=startvert+x+VERTICES_PER_LINE+1;
            }
        }
    }
    
void CDrawMagGlass::DrawMagGlass(const TSize &aScreenPhysicalSize, TReal aImageAspectRatio)
    {
    TInt pos=0;
    
#ifdef __WINS__ 
    // Fake touhcpoint for emulator
    iContainer->iLastTouchPoint.iX=320/2;
    iContainer->iLastTouchPoint.iY=240/2;
#endif
        
    // Calculate finger position on screen
    // First calculate position on 0-1 range
    GLfixed xFinger;
    GLfixed yFinger;
    if(iContainer->GetScreenOrientation())
        {
        const TInt fingerOffset = 100;
        xFinger=iContainer->iLastTouchPoint.iX*(1<<16) / aScreenPhysicalSize.iWidth;
        yFinger=(iContainer->iLastTouchPoint.iY-fingerOffset)*(1<<16) / aScreenPhysicalSize.iHeight;
        }
    else
        {
        const TInt fingerOffset = 100;
        xFinger=(iContainer->iLastTouchPoint.iX-fingerOffset)*(1<<16) / aScreenPhysicalSize.iWidth;
        yFinger=(iContainer->iLastTouchPoint.iY)*(1<<16) / aScreenPhysicalSize.iHeight;
        }
    
    // Move center to match OpenGL center
    xFinger=-(0.5*(1<<16)-xFinger);
    yFinger=0.5*(1<<16)-yFinger;
    // Then scale it to opengl window size
    /*xFinger=xFinger*iContainer->iDrawOnebyOneW*2;
    yFinger=yFinger*iContainer->iDrawOnebyOneH*2;*/
    xFinger=xFinger*iDrawOneByOne->GetDrawOneByOneWidth()*2;
    yFinger=yFinger*iDrawOneByOne->GetDrawOneByOneHeight()*2;
        
    
    CImageData* data=iContainer->iIEngine->GetImageData(iContainer->GetCurrentIndex());
    
    if((data->GetOrientation() == 0 || data->GetOrientation() == 180) && !iContainer->GetScreenOrientation())
        {
        GLfixed tmpX=xFinger;
        GLfixed tmpY=yFinger;
        xFinger = tmpY;
        yFinger = tmpX * -1;
        }
    else if(data->GetOrientation() == 0)
        ;
    else if((data->GetOrientation() == 90 || data->GetOrientation() == 270) && iContainer->GetScreenOrientation())
        {
        GLfixed tmpX=xFinger;
        GLfixed tmpY=yFinger;
        xFinger = tmpY;
        yFinger = tmpX * -1;
        }
    else if((data->GetOrientation() == 90 || data->GetOrientation() == 270) && !iContainer->GetScreenOrientation())
        {
        xFinger = xFinger * -1;
        yFinger = yFinger * -1;
        }
    
    
    //Interpolate(iMagGlassZoomFactor, 1.8, 0.05);
    //const float step=0.3; 
    //const float step=0.2;
    /*
    if (iMagGlassZoomFactor < CDrawOneByOne::KMaxMagGlassZoomFactor-step)
        //iDrawOneByOne->IncMagGlassZoomFactor(step);
        iMagGlassZoomFactor += step;
    else
        //iDrawOneByOne->SetMagGlassZoomFactor(CDrawOneByOne::KMaxMagGlassZoomFactor);
        iMagGlassZoomFactor = CDrawOneByOne::KMaxMagGlassZoomFactor;
    */
    Interpolate(iMagGlassZoomFactor, CDrawOneByOne::KMaxMagGlassZoomFactor, 0.1);
    DP1_IMAGIC(_L("CDrawMagGlass::DrawMagGlass - magGlass: %f"), iMagGlassZoomFactor);
    
    /*CImageData* data=iIEngine->GetImageData(iCurrentIndex, iImagicAppUi->GetUIDrawMode());
    if(data->GetOrientation() == 90 || data->GetOrientation() == 270)
        aImageAspectRatio = 1/aImageAspectRatio;*/
    
    // Create vertices
    pos=0;
    TInt texPos=0;
    for (TInt y=0; y<VERTICES_PER_LINE; y++)
        for (TInt x=0; x<VERTICES_PER_LINE; x++,pos+=3,texPos+=2)
            {
            // Calculate new vertex coordinates
            // First, calculate center
            GLfixed xCoord= x;
            GLfixed yCoord=-y;
            GLfixed zCoord= 0;
            // Then convert to fixed point
            xCoord*=(1<<16)/(VERTICES_PER_LINE-1);
            yCoord*=(1<<16)/(VERTICES_PER_LINE-1);
            // shift 0.5 to locate image center at (0,0) 
            xCoord -= (1<<15);
            yCoord += (1<<15);
            
            // Set aspect ratio
            if (aImageAspectRatio > 1)
                yCoord *= (1/aImageAspectRatio);
            else
                xCoord *= (1*aImageAspectRatio);
            
            
            // Zoom ball sizes
            const float ballSize=0.35;      // Zoom ball size
            const float zoomSize=0.2;     // Sharp zoom size, has to be at least 0.1 smaller bigger than ball size
            // Calculate squared values
            const GLfixed ballSizeSquared=(ballSize*(1<<8))*(ballSize*(1<<8));
            const GLfixed zoomSizeSquared=(zoomSize*(1<<8))*(zoomSize*(1<<8));
            
            // Calculate distance to finger with both axis
            GLfixed xDist=xFinger-xCoord;
            GLfixed yDist=yFinger-yCoord;
            // Calculate squared distance with phytagoras
            GLfixed dist=(xDist/(1<<8))*(xDist/(1<<8)) + (yDist/(1<<8))*(yDist/(1<<8));
            
            // Are we close enough
            if (dist < ballSizeSquared)
                {
                // Zoom factor
                //const float iMagGlassZoomFactor=1.8;
                
                // Determine proper zoom for this vertex
                //float zoom=iContainer->iMagGlassZoomFactor;
                float zoom=iMagGlassZoomFactor;
                
                if (dist > zoomSizeSquared)
                    {
                    // We are between sharp zoom and ball edge
                    // Calculat escale factor for zoom
                    float scale=((float)(dist-zoomSizeSquared))/(ballSizeSquared-zoomSizeSquared);
                    zoom=(zoom-1)*(1.0-scale)+1;
                    }
                
                // Calculate new axis distances with zoom
                xDist*=zoom;
                yDist*=zoom;
                // Calculate new coordinates based on distances
                xCoord=xFinger-xDist;
                yCoord=yFinger-yDist;
                zCoord=128;     // Set coordinate a bit above of original picture
                }
            
            // Store vertex data
            iMagGlassVertices[pos+0]=xCoord;
            iMagGlassVertices[pos+1]=yCoord;
            iMagGlassVertices[pos+2]=zCoord;
            
            // Set texture coodrinates
            iMagGlassTex[texPos+0]=x*(1<<16)/(VERTICES_PER_LINE-1);
            iMagGlassTex[texPos+1]=y*(1<<16)/(VERTICES_PER_LINE-1);
            }
    
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_CULL_FACE);
    glCullFace(GL_FRONT);
    
    // Set vertex and texture coordinates and draw
    glVertexPointer(3, GL_FIXED, 0, iMagGlassVertices);
    glTexCoordPointer(2, GL_FIXED, 0, iMagGlassTex);
    glDrawElements(GL_TRIANGLES,iMagGlassTriCount*3,GL_UNSIGNED_SHORT,iMagGlassIndices);
    //glDrawElements(GL_LINES,triCount*3,GL_UNSIGNED_SHORT,indices);
    
    glDisable(GL_CULL_FACE);
    glDisable(GL_DEPTH_TEST);
    }