/*

* 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 "hgtransformedquadrenderer.h"

#include "hgquad.h"

#include "hgtransformedquad.h"

#include "trace.h"

#include "hgimage.h"

#include <qvector2d>

#include <qpolygon>

#include <qmatrix4x4>

#include <qpainter>

HgTransformedQuadRenderer::HgTransformedQuadRenderer(int maxQuads) : 

    HgQuadRenderer(maxQuads)

{

}

HgTransformedQuadRenderer::~HgTransformedQuadRenderer()

{

    qDeleteAll(mTransformedQuads.begin(), mTransformedQuads.end());

}

void HgTransformedQuadRenderer::init(int maxQuads)

{

    for (int i = 0; i < maxQuads; i++)

    {

        mTransformedQuads.append(createNativeQuad());

    }    

}

HgQuad* HgTransformedQuadRenderer::getQuadAt(const QPointF& point) const

{

    QList<HgTransformedQuad*>::const_iterator i = mSortedQuads.begin();

    while(i != mSortedQuads.end())

    {

        HgTransformedQuad* q = (*i);

        if (q->isPointInside(point))

        {

            return q->quad();

        }

        i++;

    }

    return NULL;

}

void HgTransformedQuadRenderer::transformQuads(const QMatrix4x4& view, const QMatrix4x4& proj, 

    const QPointF& center, const QSizeF& windowSize)

{

    QMatrix4x4 pv = proj * view;

    mSortedQuads.clear();

    for (int i = 0; i < mQuads.size(); i++)

    {

        HgQuad* q = mQuads[i];

        HgTransformedQuad* tq = mTransformedQuads[i];

        if (q->visible())

        {

            tq->transformQuad(i, pv, q, mMirroringPlaneY, mTranslation, center, windowSize);   

            mSortedQuads.append(tq);

        }

    }

    qSort(mSortedQuads.begin(), mSortedQuads.end(), HgTransformedQuad::quadSorter);

}

bool HgTransformedQuadRenderer::getQuadTranformedPointsByUserData(QPolygonF& points, const QVariant& userData) const

{    

    for (int i = 0; i < mSortedQuads.count(); i++)

    {

        HgTransformedQuad* quad = mSortedQuads[i];

        if (quad->quad())

        {

            if (quad->quad()->userData() == userData)

            {

                quad->getTransformedPoints(points);

                return true;                

            }                

        }

    }

    return false;

}

QList<HgQuad*> HgTransformedQuadRenderer::getVisibleQuads(const QRectF& rect) const

{

    // this implementation isn't 100% precise

    QList<HgQuad*> result;

    for (int i = 0; i < mSortedQuads.count(); i++) {

       QPolygonF poly;

       mSortedQuads[i]->getTransformedPoints(poly);

       QRectF bounds = poly.boundingRect();       

       if (bounds.intersects(rect) || rect.contains(bounds)) {

           result.append(mSortedQuads[i]->quad());

       }           

    }

    return result;    

}

void HgTransformedQuadRenderer::drawTransformedQuads(QPainter* painter, const QRectF& rect)

{

    // draw quads

    for (int i = 0; i < mSortedQuads.size(); i++)

    {

        mSortedQuads[i]->draw(painter, rect);

    }    

}