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 "HuiFxVg10TransformFilter.h"

    19 #include <math.h>

    20 #include "HuiFxConstants.h"

    21 

    22 

    23 CHuiFxVg10TransformFilter* CHuiFxVg10TransformFilter::NewL()

    24     {

    25     CHuiFxVg10TransformFilter* self = new (ELeave) CHuiFxVg10TransformFilter();

    26     CleanupStack::PushL( self );

    27     self->ConstructL();

    28     CleanupStack::Pop( self );

    29     return self;

    30     }

    31 void CHuiFxVg10TransformFilter::ConstructL()

    32     {

    33     CHuiFxFilter::ConstructL();

    34     iTranslationX = 0.0f;

    35     iTranslationY = 0.0f;

    36     iTranslationZ = 0.0f;

    37     

    38     iScaleX = 1.0f;

    39     iScaleY = 1.0f;

    40     iScaleZ = 1.0f;

    41     iScaleOriginX = 0.0f;

    42     iScaleOriginY = 0.0f;

    43     iScaleOriginZ = 0.0f;

    44     

    45     iRotationOriginX = 0.0f;

    46     iRotationOriginY = 0.0f;

    47     iRotationOriginZ = 0.0f;

    48     iRotationAngle = 0.0f;

    49     iRotationAxisX = 0.0f;

    50     iRotationAxisY = 0.0f;

    51     iRotationAxisZ = 1.0f;

    52     

    53     iSkewAngleX = 0.0f;

    54     iSkewAngleY = 0.0f;

    55     iSkewAngleZ = 0.0f;

    56     iSkewOriginX = 0.0f;

    57     iSkewOriginY = 0.0f;

    58     iSkewOriginZ = 0.0f;

    59     

    60     RegisterParameterL(KLitTranslationX, &iTranslationX);

    61     RegisterParameterL(KLitTranslationY, &iTranslationY);

    62     RegisterParameterL(KLitTranslationZ, &iTranslationZ);

    63     

    64     RegisterParameterL(KLitScaleX, &iScaleX);

    65     RegisterParameterL(KLitScaleY, &iScaleY);

    66     RegisterParameterL(KLitScaleZ, &iScaleZ);

    67     RegisterParameterL(KLitScaleOriginX, &iScaleOriginX);

    68     RegisterParameterL(KLitScaleOriginY, &iScaleOriginY);

    69     RegisterParameterL(KLitScaleOriginZ, &iScaleOriginZ);

    70     

    71     RegisterParameterL(KLitRotationOriginX, &iRotationOriginX);

    72     RegisterParameterL(KLitRotationOriginY, &iRotationOriginY);

    73     RegisterParameterL(KLitRotationOriginZ, &iRotationOriginZ);

    74     RegisterParameterL(KLitRotationAngle, &iRotationAngle);

    75     RegisterParameterL(KLitRotationAxisX, &iRotationAxisX);

    76     RegisterParameterL(KLitRotationAxisY, &iRotationAxisY);

    77     RegisterParameterL(KLitRotationAxisZ, &iRotationAxisZ);

    78     

    79     RegisterParameterL(KLitSkewAngleX, &iSkewAngleX);

    80     RegisterParameterL(KLitSkewAngleY, &iSkewAngleY);

    81     RegisterParameterL(KLitSkewAngleZ, &iSkewAngleZ);

    82     RegisterParameterL(KLitSkewOriginX, &iSkewOriginX);

    83     RegisterParameterL(KLitSkewOriginY, &iSkewOriginY);

    84     RegisterParameterL(KLitSkewOriginZ, &iSkewOriginZ);

    85     }

    86 

    87 CHuiFxVg10TransformFilter *CHuiFxVg10TransformFilter::CloneL() const

    88     {

    89     CHuiFxVg10TransformFilter *filter = new(ELeave)CHuiFxVg10TransformFilter;

    90     filter->CHuiFxFilter::CopyFromL(this);

    91     filter->iTranslationX = iTranslationX;

    92     filter->iTranslationY = iTranslationY;

    93     filter->iTranslationZ = iTranslationZ;

    94     

    95     filter->iScaleX = iScaleX;

    96     filter->iScaleY = iScaleY;

    97     filter->iScaleZ = iScaleZ;

    98     filter->iScaleOriginX = iScaleOriginX;

    99     filter->iScaleOriginY = iScaleOriginY;

   100     filter->iScaleOriginZ = iScaleOriginZ;

   101     

   102     filter->iRotationOriginX = iRotationOriginX;

   103     filter->iRotationOriginY = iRotationOriginY;

   104     filter->iRotationOriginZ = iRotationOriginZ;

   105     filter->iRotationAngle = iRotationAngle;

   106     filter->iRotationAxisX = iRotationAxisX;

   107     filter->iRotationAxisY = iRotationAxisY;

   108     filter->iRotationAxisZ = iRotationAxisZ;

   109     

   110     filter->iSkewAngleX = iSkewAngleX;

   111     filter->iSkewAngleY = iSkewAngleY;

   112     filter->iSkewAngleZ = iSkewAngleZ;

   113     filter->iSkewOriginX = iSkewOriginX;

   114     filter->iSkewOriginY = iSkewOriginY;

   115     filter->iSkewOriginZ = iSkewOriginZ;

   116     

   117     filter->CopyParameterL(KLitTranslationX, &filter->iTranslationX, this);

   118     filter->CopyParameterL(KLitTranslationY, &filter->iTranslationY, this);

   119     filter->CopyParameterL(KLitTranslationZ, &filter->iTranslationZ, this);

   120     

   121     filter->CopyParameterL(KLitScaleX, &filter->iScaleX, this);

   122     filter->CopyParameterL(KLitScaleY, &filter->iScaleY, this);

   123     filter->CopyParameterL(KLitScaleZ, &filter->iScaleZ, this);

   124     filter->CopyParameterL(KLitScaleOriginX, &filter->iScaleOriginX, this);

   125     filter->CopyParameterL(KLitScaleOriginY, &filter->iScaleOriginY, this);

   126     filter->CopyParameterL(KLitScaleOriginZ, &filter->iScaleOriginZ, this);

   127     

   128     filter->CopyParameterL(KLitRotationOriginX, &filter->iRotationOriginX, this);

   129     filter->CopyParameterL(KLitRotationOriginY, &filter->iRotationOriginY, this);

   130     filter->CopyParameterL(KLitRotationOriginZ, &filter->iRotationOriginZ, this);

   131     filter->CopyParameterL(KLitRotationAngle, &filter->iRotationAngle, this);

   132     filter->CopyParameterL(KLitRotationAxisX, &filter->iRotationAxisX, this);

   133     filter->CopyParameterL(KLitRotationAxisY, &filter->iRotationAxisY, this);

   134     filter->CopyParameterL(KLitRotationAxisZ, &filter->iRotationAxisZ, this);

   135     

   136     filter->CopyParameterL(KLitSkewAngleX, &filter->iSkewAngleX, this);

   137     filter->CopyParameterL(KLitSkewAngleY, &filter->iSkewAngleY, this);

   138     filter->CopyParameterL(KLitSkewAngleZ, &filter->iSkewAngleZ, this);

   139     filter->CopyParameterL(KLitSkewOriginX, &filter->iSkewOriginX, this);

   140     filter->CopyParameterL(KLitSkewOriginY, &filter->iSkewOriginY, this);

   141     filter->CopyParameterL(KLitSkewOriginZ, &filter->iSkewOriginZ, this);

   142     return filter;

   143     }

   144 

   145 

   146 void CHuiFxVg10TransformFilter::CalculateMargin(TMargins &aMargin) const

   147 {

   148     aMargin.iLeft = iTranslationX < 0.0 ? -iTranslationX : 0.0;

   149     aMargin.iRight = iTranslationX > 0.0 ? iTranslationX : 0.0;

   150     aMargin.iTop = iTranslationY < 0.0 ? -iTranslationY : 0.0;

   151     aMargin.iBottom = iTranslationY > 0.0 ? iTranslationY : 0.0;

   152     // TODO, how to deal with translationZ/ scale / rotation / skew?

   153 }

   154 

   155 TBool CHuiFxVg10TransformFilter::Draw(CHuiFxEngine& /*aEngine*/, CHuiGc& /*aGc*/,

   156         CHuiFxRenderbuffer& aTarget, CHuiFxRenderbuffer& aSource,

   157         const TRect& /*aTargetRect*/, const TRect& aSourceRect)

   158     {

   159     aSource.BindAsTexture(ERenderbufferUsageReadOnly);

   160     aTarget.BindAsRenderTarget();

   161 

   162     VGImage srcImage  = (reinterpret_cast<CHuiFxVg10RenderbufferBase*>(&aSource))->AcquireSubImage(aSourceRect);

   163 

   164     vgLoadIdentity();

   165     vgScale(iScaleX, iScaleY);

   166     vgSeti(VG_BLEND_MODE, VG_BLEND_SRC);

   167     vgSeti(VG_IMAGE_MODE, VG_DRAW_IMAGE_NORMAL);

   168     

   169     identity();

   170     

   171     // Matrix multiplication is generally not commutative.

   172     // Therefore the order of the transformations matters.

   173     // In order to prevent the scaling ang skewing from affecting the translation,

   174     // if seems wiser to do the translation first, otherwise the results seem to be unpredictable.

   175     

   176     // Translation

   177     if (iTranslationX != 0.0f || iTranslationY != 0.0f || iTranslationZ != 0.0f)

   178         {

   179         translate(iTranslationX, iTranslationY, iTranslationZ);

   180         }    

   181 

   182     // Scaling

   183     if (iScaleX != 1.0f || iScaleY != 1.0f || iScaleZ != 1.0f)

   184         {

   185         translate(iScaleOriginX, iScaleOriginY, iScaleOriginZ);

   186         scale(iScaleX, iScaleY, iScaleZ); 

   187         translate(-iScaleOriginX, -iScaleOriginY, -iScaleOriginZ);

   188         }

   189     

   190     // Skewing

   191     if (iSkewAngleX != 0.0f || iSkewAngleY != 0.0f || iSkewAngleZ != 0.0f)

   192         {

   193         const TReal32 radsPerDeg = 2.0f * (float)M_PI / 360.0f;

   194         TReal32 skewX = tan(iSkewAngleX * radsPerDeg);

   195         TReal32 skewY = tan(iSkewAngleY * radsPerDeg);

   196         TReal32 skewZ = tan(iSkewAngleZ * radsPerDeg);

   197         translate(iSkewOriginX, iSkewOriginY, iSkewOriginZ);

   198         shear(skewX, skewY, skewZ); 

   199         translate(-iSkewOriginX, -iSkewOriginY, -iSkewOriginZ);

   200         }

   201 

   202     // Rotation

   203     if (iRotationAngle != 0.0f)

   204         {

   205         translate(iRotationOriginX, iRotationOriginY, iRotationOriginZ);

   206         rotate(iRotationAngle, iRotationAxisX, iRotationAxisY, iRotationAxisZ); 

   207         translate(-iRotationOriginX, -iRotationOriginY, -iRotationOriginZ);

   208         }

   209 

   210 /*

   211     // Translation

   212     if (iTranslationX != 0.0f || iTranslationY != 0.0f || iTranslationZ != 0.0f)

   213         {

   214         translate(iTranslationX, iTranslationY, iTranslationZ);

   215         }    

   216 */

   217         

   218    ASSERT(!"TODO: implement the following:");

   219     // TODO: project vertices

   220     // TODO: create warp quad matrix from projected vertices,

   221     // see http://torus.untergrund.net/misc/projective_image_warping.pdf

   222     // TODO load matrix

   223     vgDrawImage(srcImage);

   224     

   225     // TODO: pixel relative parameters

   226     HUIFX_VG_INVARIANT();

   227     (reinterpret_cast<CHuiFxVg10RenderbufferBase*>(&aSource))->ReleaseSubImage(srcImage);

   228 

   229     aTarget.UnbindAsRenderTarget();

   230     aSource.UnbindAsTexture();

   231     

   232     return ETrue;

   233     }