/*
* 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: 
*
*/

#ifndef HUIFXVG10TRANSFORMFILTER_H_
#define HUIFXVG10TRANSFORMFILTER_H_

#include <math.h>
#include "HuiFxVg10FilterBase.h"

class CHuiFxVg10TransformFilter: public CHuiFxVg10FilterBase
    {
public: // from CHuiFxFilter
    virtual TBool Draw(CHuiFxEngine& aEngine, CHuiGc& aGc,
                       CHuiFxRenderbuffer& aTarget, CHuiFxRenderbuffer& aSource,
                       const TRect& aTargetRect, const TRect& aSourceRect);
    static CHuiFxVg10TransformFilter* NewL();
    void DrawEffect(CHuiFxEngine& /*aEngine*/, VGImage /*aTargetImage*/, VGImage /*aSourceImage*/, TInt /*aWidth*/, TInt /*aHeight*/) {}
    void CalculateMargin(TMargins &aMargin) const;  
    CHuiFxVg10TransformFilter *CloneL() const;
protected:
    void ConstructL();
    
    void identity()
        {
        iMatrix [0] = 1.f; iMatrix [1] = 0.f; iMatrix [2] = 0.f; iMatrix [3] = 0.f;
        iMatrix [4] = 0.f; iMatrix [5] = 1.f; iMatrix [6] = 0.f; iMatrix [7] = 0.f;
        iMatrix [8] = 0.f; iMatrix [9] = 0.f; iMatrix[10] = 1.f; iMatrix[11] = 0.f;
        iMatrix[12] = 0.f; iMatrix[13] = 0.f; iMatrix[14] = 0.f; iMatrix[15] = 1.f;
        }
    
    void translate(TReal32 tx, TReal32 ty, TReal32 tz)
        {
        const TReal32 tm[16] =
        {
            1.f, 0.f, 0.f, 0.f,
            0.f, 1.f, 0.f, 0.f,
            0.f, 0.f, 1.f, 0.f,
            tx,  ty,  tz,  1.f
        };
        
        multiply(tm); 
        }
    
    void scale (const TReal32 sx, const TReal32 sy, const TReal32 sz)
        {
        const TReal32 sm[16] =
        {
            sx, 0.f, 0.f, 0.f,
            0.f,  sy, 0.f, 0.f,
            0.f, 0.f,  sz, 0.f,
            0.f, 0.f, 0.f, 1.f
        };

        multiply(sm);
        }
    
    void rotate (const TReal32 angle, const TReal32 x, const TReal32 y, const TReal32 z)
        {
        static const TReal32 deg_to_rad = 2.f * (TReal32)M_PI / 360.f;
        // normalised vector components
        TReal32 x_n;
        TReal32 y_n;
        TReal32 z_n;
        TReal32 angle_rad = angle * deg_to_rad;

        // normalise if needed
        const TReal32 length = (TReal32)sqrt(double(x * x) + 
                      double(y * y) + 
                      double(z * z));
        if(fabs(length - 1.0f) > EPSILON) {
            // in fp calculations, division by zero -> (+/-)inf
            // can't really help if it's the case.
            const TReal32 inv_length = 1.f / length;
            x_n = x * inv_length;
            y_n = y * inv_length;
            z_n = z * inv_length;
        } else {
            x_n = x;
            y_n = y;
            z_n = z;
        }

        const TReal32 c = cos(angle_rad);
        const TReal32 s = sin(angle_rad);
        const TReal32 c_1 = 1.f - c;

        const TReal32 rm[16] =
        {
                x_n * x_n * c_1 + c,       y_n * x_n * c_1 + z_n * s, x_n * z_n * c_1 - y_n * s, 0.f,
                x_n * y_n * c_1 - z_n * s, y_n * y_n * c_1 + c,       y_n * z_n * c_1 + x_n * s, 0.f,
                x_n * z_n * c_1 + y_n * s, y_n * z_n * c_1 - x_n * s, z_n * z_n * c_1 + c,   0.f,
                0.f,               0.f,               0.f,           1.f
        };

        multiply(rm);
        }
 
    void frustum (const TReal32 l, const TReal32 r, const TReal32 b, const TReal32 t, const TReal32 n, const TReal32 f)
        {
        const TReal32 rl = 1.f / (r - l);
        const TReal32 tb = 1.f / (t - b);
        const TReal32 fn = 1.f / (f - n);

        const TReal32 A = (r + l) * rl;
        const TReal32 B = (t + b) * tb;
        const TReal32 C = -(f + n) * fn; 
        const TReal32 D = -2.f * f * n * fn;

        const TReal32 fm[16] =
        {
            2.f * n * rl,   0.f,        0.f,    0.f,
            0.f,        2.f * n * tb,   0.f,    0.f,
            A,      B,      C,  -1.f,
            0.f,        0.f,        D,  0.f
        };
        
        multiply(fm);
        }

    void multiply (const TReal32* b)
        {
        TReal32 dst[16];
        for (int i = 0; i < 4; i++)
        {
            for (int j = 0; j < 4; j++)
            {
                TReal32 sum = 0.f;
                for (int k = 0; k < 4; k++)
                    sum += iMatrix[i + 4 * k] * b[k + 4 * j];

                dst[i + 4 * j] = sum;
            }
        }

        for (int i = 0; i < 16; i++)
            iMatrix[i] = dst[i];
        }
    
    void shear (const TReal32 aX, const TReal32 aY, const TReal32 aZ)
        {
        TReal32 shearMatrix[16] =
            {
            1.0f,   aX,   aX, 0.0f,
              aY, 1.0f,   aY, 0.0f,
              aZ,   aZ, 1.0f, 0.0f,
            0.0f, 0.0f, 0.0f, 1.0f,
            };
        
        multiply(shearMatrix);

        }

private:
    TReal32             iTranslationX;
    TReal32             iTranslationY;
    TReal32             iTranslationZ;
    
    TReal32             iScaleX;
    TReal32             iScaleY;
    TReal32             iScaleZ;
    TReal32             iScaleOriginX;
    TReal32             iScaleOriginY;
    TReal32             iScaleOriginZ;
    
    TReal32             iRotationOriginX;
    TReal32             iRotationOriginY;
    TReal32             iRotationOriginZ;
    TReal32             iRotationAngle;
    TReal32             iRotationAxisX;
    TReal32             iRotationAxisY;
    TReal32             iRotationAxisZ;
    
    TReal32             iSkewAngleX;
    TReal32             iSkewAngleY;
    TReal32             iSkewAngleZ;
    TReal32             iSkewOriginX;
    TReal32             iSkewOriginY;
    TReal32             iSkewOriginZ;
    
    TReal32             iMatrix[16];
    };

#endif