/*

 * Name        : Overlay.cpp

 * Description : 

 * Project     : This file is part of OpenMAR, an Open Mobile Augmented Reality browser

 * Website     : http://OpenMAR.org

 *

 * Copyright (c) 2010 David Caabeiro

 *

 * All rights reserved. This program and the accompanying materials are made available 

 * under the terms of the Eclipse Public License v1.0 which accompanies this 

 * distribution, and is available at http://www.eclipse.org/legal/epl-v10.html

 *

 */

#include "Overlay.h"

#include <coemain.h>

#include <gdi.h>

#include <w32std.h>

#include "Vector3d.h"

#include "Vector4d.h"

#include "Accelerometer.h"

#include "Magnetometer.h"

#include "AutoRotation.h"

#include "Logger.h"

#include "Manager.h"

COverlay* COverlay::NewL(SParameter& aParameter)

{

    COverlay* self = new(ELeave) COverlay(aParameter);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

}

COverlay::COverlay(SParameter& aParameter)

    : iWindow(aParameter.iWindow), iRect(aParameter.iRect)

{}

void COverlay::ConstructL()

{

    LOGTXT("Initializing EGL..");

    iEglDisplay = ::eglGetDisplay(EGL_DEFAULT_DISPLAY);

    if (iEglDisplay == 0)

    {

        _LIT(KGetDisplayFailed, "eglGetDisplay failed");

        User::Panic(KGetDisplayFailed, 0);

    }

    if (::eglInitialize(iEglDisplay, 0, 0) == EGL_FALSE)

    {

        _LIT(KInitializeFailed, "eglInitialize failed");

        User::Panic(KInitializeFailed, 0);

    }

    EGLConfig* configList = 0;

    EGLint configSize     = 0;

    EGLint numOfConfigs   = 0;

    // Get the number of possible EGLConfigs

    if (::eglGetConfigs(iEglDisplay, configList, configSize, &numOfConfigs) == EGL_FALSE)

    {

        _LIT(KGetConfigsFailed, "eglGetConfigs failed");

        User::Panic( KGetConfigsFailed, 0 );

    }

    configSize = numOfConfigs;

    // Allocate memory for the configList

    configList = (EGLConfig*) User::Alloc(sizeof(EGLConfig) * configSize);

    if (configList == 0)

    {

        _LIT(KConfigAllocFailed, "Config alloc failed");

        User::Panic(KConfigAllocFailed, 0);

    }

    /*

     * Define properties for the wanted EGLSurface. To get the best possible 

     * performance, choose an EGLConfig with a buffersize matching the current 

     * window's display mode

     */

    TDisplayMode displayMode = iWindow.DisplayMode();

    TInt bufferSize = 0;

    switch (displayMode)

    {

        case EColor4K:

            bufferSize = 12;

            break;

        case EColor64K:

            bufferSize = 16;

            break;

        case EColor16M:

            bufferSize = 24;

            break;

        case EColor16MU:

        case EColor16MA:

        case EColor16MAP:

            bufferSize = 32;

            break;

        default:

            _LIT(KDisplayModeError, "Unsupported display mode");

            User::Panic(KDisplayModeError, 0);

            break;

    }

    // Define properties for the wanted EGLSurface 

    const EGLint attrib_list[] = { 

            EGL_SURFACE_TYPE,       EGL_PBUFFER_BIT,

//            EGL_TRANSPARENT_TYPE,   EGL_TRANSPARENT_RGB,

            EGL_BUFFER_SIZE,        bufferSize,

            EGL_NONE

    };

    // Choose an EGLConfig that best matches to the properties in attrib_list_fsaa

    if (::eglChooseConfig(iEglDisplay, attrib_list, configList, configSize, &numOfConfigs) == EGL_FALSE)

    {

        _LIT( KChooseConfigFailed, "eglChooseConfig failed");

        User::Panic(KChooseConfigFailed, 0);

    }

    iConfig = configList[0];    // Choose the best EGLConfig. EGLConfigs

                                // returned by eglChooseConfig are sorted so

                                // that the best matching EGLConfig is first in

                                // the list.

    User::Free(configList);

    TInt width  = iRect.Size().iWidth;

    TInt height = iRect.Size().iHeight;

    LOGARG("Window size is %d x %d", width, height);

    const EGLint attrib_list2[] = { 

            EGL_WIDTH,  width,

            EGL_HEIGHT, height,

            EGL_NONE

    };

    // Create a window where the graphics are blitted

    iEglSurface = ::eglCreatePbufferSurface(iEglDisplay, iConfig, attrib_list2);

    if (iEglSurface == 0)

    {

        _LIT(KCreateWindowSurfaceFailed, "eglCreateWindowSurface failed");

        User::Panic(KCreateWindowSurfaceFailed, 0);

    }

    // Create a rendering context

    iEglContext = ::eglCreateContext(iEglDisplay, iConfig, EGL_NO_CONTEXT, 0);

    if (iEglContext == 0)

    {

        _LIT(KCreateContextFailed, "eglCreateContext failed");

        User::Panic(KCreateContextFailed, 0);

    }

    // Make the context current. Binds context to the current rendering thread and surface.

    if (::eglMakeCurrent(iEglDisplay, iEglSurface, iEglSurface, iEglContext) == EGL_FALSE)

    {

        _LIT(KMakeCurrentFailed, "eglMakeCurrent failed");

        User::Panic(KMakeCurrentFailed, 0);

    }

    // Create a Symbian bitmap where the graphics from the Pbuffer are copied

    iPixmap = new(ELeave) CWsBitmap(CCoeEnv::Static()->WsSession());

    iPixmap->Create(iRect.Size(), iWindow.DisplayMode());

    // Manager is in charge of POIs from different providers

    iManager = CManager::NewL();

}

COverlay::~COverlay()

{

    delete iManager;

    delete iPixmap;

    iPixmap = 0;

    ::eglMakeCurrent(iEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);

    ::eglDestroyContext(iEglDisplay, iEglContext);

    ::eglDestroySurface(iEglDisplay, iEglSurface);

    ::eglTerminate(iEglDisplay);

}

void COverlay::StartL()

{

    // First off we enable the position and orientation sensors

    iPosition = CPosition::NewL(*this);

    iPosition->Request();

#if defined(__MARM__)

    iAccelerometer = CAccelerometer::NewL();

    iAccelerometer->StartL();

    iMagnetometer = CMagnetometer::NewL();

    iMagnetometer->StartL();

    iAutoRotation = CAutoRotation::NewL();

    iAutoRotation->ResetL();

#endif

    // We now calculate the view frustum and create the appropriate projection matrix

    TReal near = 1.0f;

    TReal far  = 3000.0f;

    TReal fovy = 0;

    Math::Tan(fovy, 45 * KDegToRad / 2);

    TInt width  = iWindow.Size().iWidth;

    TInt height = iWindow.Size().iHeight;

    TReal aspectRatio = static_cast<TReal>(width) / height;

    TReal top    = near * fovy;

    TReal bottom = -top;

    TReal left   = bottom * aspectRatio;

    TReal right  = top * aspectRatio;

    iProjection.Load(

            2 * near / (right - left),       0,                               0,                            0,

            0                        ,       2 * near / (top - bottom),       0,                            0,

            (right + left) / (right - left), (top + bottom) / (top - bottom), -(far + near) / (far - near), -1,

            0                              , 0                              , - 2 * far * near / (far - near), 0

    );

    ::glViewport(0, 0, width, height);

    ::glMatrixMode(GL_PROJECTION);

    ::glLoadMatrixf(iProjection.m);

    ::glMatrixMode(GL_MODELVIEW);

    ::glEnableClientState(GL_VERTEX_ARRAY);

    ::glEnableClientState(GL_TEXTURE_COORD_ARRAY);

//    ::glEnableClientState(GL_NORMAL_ARRAY);

    ::glEnable(GL_DEPTH_TEST);

    ::glDepthFunc(GL_LESS);

    // Set background transparency 

    ::glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

}

void COverlay::Stop()

{

    ::glDisable(GL_DEPTH_TEST);

//    ::glDisableClientState(GL_NORMAL_ARRAY);

    ::glDisableClientState(GL_TEXTURE_COORD_ARRAY);

    ::glDisableClientState(GL_VERTEX_ARRAY);

#if defined(__MARM__)

    iAutoRotation->RestoreL();

    delete iAutoRotation;

    iAutoRotation = 0;

    iMagnetometer->Stop();

    delete iMagnetometer;

    iMagnetometer = 0;

    iAccelerometer->Stop();

    delete iAccelerometer;

    iAccelerometer = 0;

#endif

    delete iPosition;

    iPosition = 0;

}

const CFbsBitmap& COverlay::RenderScene()

{

    // Estimate orientation based on sensor data

#if defined(__MARM__)

/*

 * +X is defined as the cross product Y.Z (it is tangential to

 * the ground at the device's current location and roughly points East)

 * +Y is tangential to the ground at the device's current location and

 * points towards the magnetic North Pole

 * +Z points towards the sky and is perpendicular to the ground

 */

    Vector3d A = iAccelerometer->GetValue();

    Vector3d E = iMagnetometer->GetValue();

    Vector3d H = Vector3d::Cross(E, A);

    Scalar hNorm = H.Norm();

    H.mX /= hNorm;

    H.mY /= hNorm;

    H.mZ /= hNorm;

    Scalar aNorm = A.Norm();

    A.mX /= aNorm;

    A.mY /= aNorm;

    A.mZ /= aNorm;

    Vector3d M = Vector3d::Cross(A, H);

    iModelView.Load(

            H.mX, H.mY, H.mZ, 0,

            M.mX, M.mY, M.mZ, 0,

            A.mX, A.mY, A.mZ, 0,

            0, 0, 0, 1

    );

    ::glLoadMatrixf(iModelView.m);

#else

    ::glLoadIdentity();

#endif

    ::glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    iManager->Render();

    ::eglCopyBuffers(iEglDisplay, iEglSurface, iPixmap);

    return *iPixmap;

}

/*

 * Callback from position provider. We use current position to set up world's origin

 * and make request to different providers

 */

void COverlay::PositionUpdateL(TInt aError, const TPosition& aPosition)

{

    LOGARG("Got position: lat=%f,lon=%f,alt=%f", aPosition.Latitude(), aPosition.Longitude(), aPosition.Altitude());

    // Set the "world" origin

    iManager->SetOrigin(aPosition);

    // Request POIs for that position

    iManager->RequestL(aPosition);

}

/*

 * From the current list of POIs retrieved, find the one that is closest to the

 * screen center.

 * 

 * We use both projection and modelview transforms to obtain screen coordinates.

 * Note that both matrices are in column-major ordering, so we need to transpose them.

 */

TInt COverlay::GetFocusedPOI()

{

    const TPoint viewportCenter(iRect.Center());

    TInt mostCentered = KMaxTInt; 

    TInt focused = KErrNotFound;

    for (TInt i = 0; i < iManager->iObjectList.Count(); ++i)

    {

        const Vector3d position(iManager->iObjectList[i]->GetPosition());

        const Vector4d world(position.mX, position.mY, position.mZ, 1);

        const Vector4d camera(iModelView.Transpose() * world);

        const Vector4d projection(iProjection.Transpose() * camera);

        // Screen transformation

        TReal x = projection.mX / projection.mW;

        TReal y = projection.mY / projection.mW;

        TReal z = projection.mZ / projection.mW;

        TReal screenX = viewportCenter.iX * (x + 1);

        TReal screenY = viewportCenter.iY * (y + 1);

//        TReal screenZ = (z + 1) / 2;

        TBool visible = (x > -1 && x < 1) && (y > -1 && y < 1) && (z > -1 && z < 1);

        TInt centered = (screenX - viewportCenter.iX) * (screenX - viewportCenter.iX) + (screenY - viewportCenter.iY) * (screenY - viewportCenter.iY);

        if (visible && centered < mostCentered)

        {

            mostCentered = centered; 

            focused = i;

        }

    }

    return focused;

}