1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:    

    15 *

    16 */

    17 

    18 #include "hgtransformedquad.h"

    19 #include "hgquad.h"

    20 #include "trace.h"

    21 #include <qvector2d>

    22 #include <qpolygon>

    23 #include <qmatrix4x4>

    24 #include <qpainter>

    25 

    26     HgTransformedQuad::HgTransformedQuad(qreal yDir) : mYDir(yDir)

    27     {

    28         

    29     }

    30 

    31     HgTransformedQuad::~HgTransformedQuad()

    32     {

    33         

    34     }

    35 

    36     int HgTransformedQuad::index() const

    37         {

    38         return mIndex;

    39         }

    40 

    41     bool HgTransformedQuad::isPointInside(const QPointF& point) const

    42     {    

    43         QPolygonF poly;

    44         getTransformedPoints(poly);

    45         QRectF rect = poly.boundingRect();

    46         if (rect.contains(point))

    47         {

    48             return true;

    49         }

    50         return false;

    51     }

    52 

    53     void HgTransformedQuad::transformQuad(int index, const QMatrix4x4& projView, HgQuad* quad, 

    54         qreal mirroringPlaneY, const QVector2D& translate, const QPointF& center, 

    55         const QSizeF& windowSize)

    56     {

    57         mIndex = index;

    58         mQuad = quad;

    59             

    60         QMatrix4x4 tm;

    61         tm.setToIdentity();

    62         tm.rotate(quad->outerRotation());

    63 

    64         if (mQuad->mirrorImageEnabled())

    65         {

    66             computeMirroredPoints(tm, projView, mirroringPlaneY, translate, center, windowSize);

    67         }

    68         

    69         tm.translate(quad->position());    

    70         tm.rotate(quad->rotation());    

    71         tm.scale(quad->scale().x(), quad->scale().y());

    72 

    73         tm = projView * tm;         

    74         

    75         perspectiveTransformPoints(mTransformedPoints, tm, center, windowSize);

    76         

    77         for (int i = 0; i < 4; i++)

    78             mTransformedPoints[i] += translate;

    79         

    80     }

    81     

    82     void HgTransformedQuad::getTransformedPoints(QPolygonF& poly) const

    83     {

    84         poly.clear();

    85         poly.append(mTransformedPoints[0].toPointF());

    86         poly.append(mTransformedPoints[1].toPointF());

    87         poly.append(mTransformedPoints[2].toPointF());

    88         poly.append(mTransformedPoints[3].toPointF());    

    89     }

    90 

    91     bool HgTransformedQuad::quadSorter(HgTransformedQuad* a, HgTransformedQuad* b)

    92     {

    93         return a->mQuad->position().z() < b->mQuad->position().z();

    94     }

    95 

    96     HgQuad* HgTransformedQuad::quad() const

    97     {

    98         return mQuad;

    99     }

   100     

   101     void HgTransformedQuad::computeMirroredPoints(const QMatrix4x4& trans, const QMatrix4x4& projView, 

   102         qreal mirroringPlaneY, const QVector2D& translate, const QPointF& center, 

   103         const QSizeF& windowSize)

   104     {

   105         HgQuad* quad = mQuad;

   106 

   107         QMatrix4x4 mirror = trans;

   108 

   109         qreal distToPlane = qAbs(quad->position().y() - mirroringPlaneY);

   110         

   111         mirror.translate(quad->position().x(), mirroringPlaneY - distToPlane/1, quad->position().z());

   112         mirror.scale(quad->scale().x(), -quad->scale().y()/1);

   113         mirror.rotate(quad->rotation());

   114             

   115         QMatrix4x4 modelViewProjMatrix = projView * mirror;

   116         

   117         perspectiveTransformPoints(mMirroredPoints, modelViewProjMatrix, center, windowSize);    

   118         

   119         for (int i = 0; i < 4; i++)

   120             mMirroredPoints[i] += translate;

   121 

   122     }

   123 

   124     void HgTransformedQuad::perspectiveTransformPoints(QVector2D* outPoints, const QMatrix4x4& matrix, 

   125         const QPointF& center, const QSizeF& windowSize)

   126     {

   127         const QVector4D points[] = 

   128         {

   129             QVector4D(-0.5f, -0.5f, 0.0f, 1.0f),

   130             QVector4D( 0.5f, -0.5f, 0.0f, 1.0f),

   131             QVector4D( 0.5f,  0.5f, 0.0f, 1.0f),

   132             QVector4D(-0.5f,  0.5f, 0.0f, 1.0f)

   133         };

   134 

   135         qreal hw = windowSize.width() * 0.5f;

   136         qreal hh = windowSize.height() * 0.5f;

   137         

   138         for (int i = 0; i < 4; i++)

   139         {

   140             QVector4D temp = matrix * points[i];

   141                                 

   142             outPoints[i] = QVector2D(

   143                 center.x() + temp.x() / temp.w() * hw, 

   144                 center.y() + (temp.y() / temp.w() * hh) * mYDir);

   145 

   146         }

   147         

   148     }

   149