/*
* Copyright (c) 2004-2008 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:  Bump-mapping for effects.
*
*/


// INCLUDE FILES
#include <e32math.h>

#include "AknsRlEffectPluginBumpMap.h"
#include "AknsRlEffectUtil.h"

// CONSTANTS
const TReal KPixelScale = 255.9;

// ====================== TEMPLATED IMPL. OF BUMPMAP ===========================
/**
* Template implementation of BumpMap. Type defines the used data type for
* iterating over the bitmap data. X, R, G and B define the used pixel color bit
* layout.
*/
template<class Type,TInt X, TInt R, TInt G, TInt B>
class AknsRlEffectBumpMap
    {
    public:
    /**
    * @return KErrNone if processing was ok, something else on error.
    */
    static TInt Process( const CFbsBitmap& aTarget,
                         const CFbsBitmap& aSource,
                         const TReal aAzimuth,
                         const TReal aElevation,
                         const TInt aDepth,
                         TAknsRlChannelBlendMode aBlendMode,
                         const TInt aBlendFactor,
                         TUint8* aGrayscale )
        {
        // CFbsBitmap::ScanLineLength returns bytes, determine the scanw when using Type
        TInt scanW  = CFbsBitmap::ScanLineLength( aTarget.SizeInPixels().iWidth,
                                                  aTarget.DisplayMode() ) / sizeof(Type);
        TInt width  = aTarget.SizeInPixels().iWidth;
        TInt height = aTarget.SizeInPixels().iHeight;

        TInt grayW = width + 2;
        TInt grayH = height + 2;

        TInt x, y;

        // Step 1: Grayscale the image
        TInt pitch = scanW - width;
        // The grayscale buffer has that one pixel extra border
        TUint8* buf = aGrayscale + grayW + 1;
        aSource.LockHeap(); // Lock the global bitmap heap
        Type* dataS = reinterpret_cast<Type*>( aSource.DataAddress() );

        for( y=0; y < height; y++ )
            {
            for( x=0; x < width; x++ )
                {
                *buf = AknsRlUtil::Grayscale( AknsRlRgb<Type,X,R,G,B>::R8(*dataS),
                                              AknsRlRgb<Type,X,R,G,B>::G8(*dataS),
                                              AknsRlRgb<Type,X,R,G,B>::B8(*dataS) );
                buf++;
                dataS++;
                }

            // Skip possibly trailing pixels on aSource
            dataS = dataS + pitch;
            buf = buf + 2;
            }

        aSource.UnlockHeap(); // Unlock the global bitmap heap

        // Next, fill the grayscale 1 pixel border by copying the neighbouring
        // pixel values

        // Top row
        buf = aGrayscale + 1;
        for( x=1; x < grayW - 2; x++ )
            {
            *buf = *( buf + grayW );
            buf++;
            }

        // Bottom row
        buf = aGrayscale + grayW * (grayH - 1) + 1;
        for( x=1; x < grayW - 2; x++ )
            {
            *buf = *( buf - grayW );
            buf++;
            }

        // Left column
        buf = aGrayscale + grayW;
        for( y=1; y < grayH - 2; y++ )
            {
            *buf = *( buf + 1 );
            buf = buf + grayW;
            }

        // Right column
        buf = aGrayscale + 2 * grayW - 1;
        for( y=1; y < grayH - 2; y++ )
            {
            *buf = *( buf - 1 );
            buf = buf + grayW;
            }

        // Top left corner
        aGrayscale[ 0 ] = aGrayscale[ grayW + 1 ];
        // Top right corner
        aGrayscale[ grayW - 1 ] = aGrayscale[ 2 * grayW - 2 ];
        // Bottom left corner
        aGrayscale[ (grayH - 1) * grayW ] = aGrayscale[ ((grayH - 2 ) * grayW) + 1];
        // Bottom right corner
        aGrayscale[ (grayH * grayW) - 1 ] = aGrayscale[ (grayH - 2) * grayW + grayW - 2 ];

        // Step 2: Create the bump map by embossing. The embossing routine
        // follows the ANSI C code from the article "Fast Embossing Effects on
        // Raster Image Data" by John Schlag, jfs@kerner.com, in "Graphics Gems
        // IV", Academic Press, 1994

        // Determine the light direction vector
        TReal aziRes, eleRes;
        TInt err;

        err = Math::Cos(aziRes, aAzimuth);
        if( KErrNone != err )
            return err;

        err = Math::Cos(eleRes, aElevation);
        if( KErrNone != err )
            return err;

        TInt lx = TInt( aziRes * eleRes * KPixelScale );

        err = Math::Sin(aziRes, aAzimuth);
        if( KErrNone != err )
            return err;

        TInt ly = TInt( aziRes * eleRes * KPixelScale );

        err = Math::Sin(eleRes, aElevation);
        if( KErrNone != err )
            return err;

        TInt lz = TInt( eleRes * KPixelScale );

        // Determine a constant z of image surface normal
        TInt nz = (6 * 255) / aDepth; // Depth always > 0
        TInt nz2 = nz * nz;
        TInt nzlz = nz * lz;
        TInt nx, ny;
        TInt NdotL;
        TInt shade, root;
        TInt r, g, b;
        TReal sqrt;

        aTarget.LockHeap( ETrue ); // Lock the global bitmap heap
        dataS = reinterpret_cast<Type*>( aSource.DataAddress() );
        Type* dataT = reinterpret_cast<Type*>( aTarget.DataAddress() );

        // The grayscale buffer has that one pixel extra border
        buf = aGrayscale + grayW + 1;

        // We can process the whole source image directly because the
        // grayscale image has 1 pixel extra border (convolution can refer
        // outside the source image dimensions).
        for(y=0; y < height; y++)
            {
            for(x=0; x < width; x++)
                {
                // Do embossing
                nx = *(buf - grayW - 1) + *(buf - 1) + *(buf + grayW - 1) -
                     *(buf - grayW + 1) - *(buf + 1) - *(buf + grayW + 1);
                ny = *(buf + grayW - 1) + *(buf + grayW) + *(buf + grayW + 1) -
                     *(buf - grayW - 1) - *(buf - grayW) - *(buf - grayW + 1);

                if( nx == 0 && ny == 0 )
                    shade = lz;
                else if( (NdotL = nx*lx + ny*ly + nzlz) < 0 )
                    shade = 0;
                else
                    {
                    // Note that the error value is ignored because
                    // nx*nx + ny*ny + nz2 >= 0 always.
                    Math::Sqrt( sqrt, nx*nx + ny*ny + nz2 );
                    root = TInt( sqrt );
                    if( root )
                        shade = NdotL / root;
                    else // Square root was rounded to zero
                        {
                        // ( nx * nx + ny * ny ) is always >= 0. If aDepth is
                        // large enough nz2 will be small enough so that sqrt(
                        // nx*nx + ny*ny + nz2 ) returns < 1.0 and the result
                        // rounds to zero.
                        shade = 255;
                        }
                    }

                if(shade < 0)
                    shade = 0;
                else if(shade > 255)
                    shade = 255;

                // Step 3: Do Channel blending
                r = AknsRlChannelBlend::Blend( aBlendMode,
                                               aBlendFactor,
                                               AknsRlRgb<Type,X,R,G,B>::R8(*dataS),
                                               TUint8( shade ));
                g = AknsRlChannelBlend::Blend( aBlendMode,
                                               aBlendFactor,
                                               AknsRlRgb<Type,X,R,G,B>::G8(*dataS),
                                               TUint8( shade ));
                b = AknsRlChannelBlend::Blend( aBlendMode,
                                               aBlendFactor,
                                               AknsRlRgb<Type,X,R,G,B>::B8(*dataS),
                                               TUint8( shade ));

                AknsRlRgb<Type,X,R,G,B>::SetRgb8(dataT, TUint8(r), TUint8(g), TUint8(b));

                buf++;
                dataS++;
                dataT++;
                }

            buf = buf + 2;
            dataS = dataS + pitch;
            dataT = dataT + pitch;
            }

        aTarget.UnlockHeap( ETrue );

        return KErrNone;
        }
    };

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CAknsRlEffectPluginBumpMap::CAknsRlEffectPluginBumpMap
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CAknsRlEffectPluginBumpMap::CAknsRlEffectPluginBumpMap()
    {
    }

// -----------------------------------------------------------------------------
// Destructor
// -----------------------------------------------------------------------------
//
CAknsRlEffectPluginBumpMap::~CAknsRlEffectPluginBumpMap()
    {
    // The user of this plugin should call deactivate eventually...but we
    // delete grayscale buffer here too (just in case)
    delete [] iGrayscale;
    iContext = NULL;
    }

// -----------------------------------------------------------------------------
// CAknsRlEffectPluginBumpMap::EffectUid
// -----------------------------------------------------------------------------
//
TUid CAknsRlEffectPluginBumpMap::EffectUid() const
    {
    return TUid::Uid( KAknsRlEffectPluginBumpMapUID );
    }

// -----------------------------------------------------------------------------
// CAknsRlEffectPluginBumpMap::Effect
// -----------------------------------------------------------------------------
//
MAknsRlEffect* CAknsRlEffectPluginBumpMap::Effect( const TInt aInterface )
    {
    if( aInterface == KAknsRlEffectPluginInterfaceEffect )
        return this;
    return NULL;
    }

// -----------------------------------------------------------------------------
// CAknsRlEffectPluginBumpMap::InitializeL
// -----------------------------------------------------------------------------
//
void CAknsRlEffectPluginBumpMap::InitializeL()
    {
    iContext = NULL;
    }

// -----------------------------------------------------------------------------
// CAknsRlEffectPluginBumpMap::Release
// -----------------------------------------------------------------------------
//
void CAknsRlEffectPluginBumpMap::Release()
    {
    }

// -----------------------------------------------------------------------------
// CAknsRlEffectPluginBumpMap::ActivateL
// -----------------------------------------------------------------------------
//
void CAknsRlEffectPluginBumpMap::ActivateL( MAknsRlEffectContext* aContext )
    {
    if( !aContext ) // We absolutely need the context
        {
        User::Leave( KErrArgument );
        }

    iContext = aContext;

    iAzimuth     = 0.0;
    iElevation   = 0.59; // ~34 in degrees
    iDepth       = 10;
    iBlendMode   = EAknsRlChannelBlendNormal;
    iBlendFactor = 255;

    // Because the grayscale image is convoluted we need to create grayscale
    // image that has extra one pixel border.
    TSize size = aContext->LayerSize();
    size.iWidth  = size.iWidth + 2;
    size.iHeight = size.iHeight + 2;

    // Calling activate multiple times in row in unlikely but we delete the
    // grayscale buffer just in case.
    delete [] iGrayscale;
    iGrayscale = NULL;
    iGrayscale = new(ELeave) TUint8[ size.iWidth * size.iHeight ]; //lint !e119 Enough arguments
    }

// -----------------------------------------------------------------------------
// CAknsRlEffectPluginBumpMap::Deactivate
// -----------------------------------------------------------------------------
//
void CAknsRlEffectPluginBumpMap::Deactivate()
    {
    delete [] iGrayscale;
    iGrayscale = NULL;
    }

// -----------------------------------------------------------------------------
// CAknsRlEffectPluginBumpMap::SetParametersL
// -----------------------------------------------------------------------------
//
void CAknsRlEffectPluginBumpMap::SetParametersL( MAknsRlParameterIterator& aParameters )
    {
    while( aParameters.HasNext() )
        {
        const TAknsRlParameterData* param = aParameters.NextL();

        // Fetch azimuth value
        if( param->iName->Compare( KAknsRlEffectBumpMapAzimuth ) == 0 )
            {
            if( param->iType != EAknsRlParameterTypeNumber )
                User::Leave( KErrArgument );

            if( param->iNumber < 0 || param->iNumber > 360 )
                User::Leave( KErrArgument );

            // Convert from degrees to radians: [0, 360] -> [0, 2 * KPi]
            iAzimuth = (TReal( param->iNumber ) / 360.0) * 2 * KPi;
            }
        // Fetch elevation value
        else if( param->iName->Compare( KAknsRlEffectBumpMapElevation ) == 0 )
            {
            if( param->iType != EAknsRlParameterTypeNumber )
                User::Leave( KErrArgument );

            if( param->iNumber < 0 || param->iNumber > 180 )
                User::Leave( KErrArgument );

            // Convert from degrees to radians: [0, 180] -> [0, KPi]
            iElevation = (TReal( param->iNumber ) / 180.0) * KPi;
            }
        // Fetch depth value
        else if( param->iName->Compare( KAknsRlEffectBumpMapDepth ) == 0 )
            {
            if( param->iType != EAknsRlParameterTypeNumber )
                User::Leave( KErrArgument );

            if( param->iNumber <= 0 )
                User::Leave( KErrArgument );

            iDepth = param->iNumber;
            }
        // Fetch blend mode value
        else if( param->iName->Compare( KAknsRlEffectBumpMapBlendMode ) == 0 )
            {
            if( param->iType != EAknsRlParameterTypeNumber )
                User::Leave( KErrArgument );

            if( param->iNumber < EAknsRlChannelBlendNormal ||
                param->iNumber > EAknsRlChannelBlendBurn )
                User::Leave( KErrArgument );

            iBlendMode = param->iNumber;
            }
        // Fetch blend factor value
        else if( param->iName->Compare( KAknsRlEffectBumpMapBlendFactor ) == 0 )
            {
            if( param->iType != EAknsRlParameterTypeNumber )
                User::Leave( KErrArgument );

            iBlendFactor = param->iNumber;
            }
        }
    }

// -----------------------------------------------------------------------------
// CAknsRlEffectPluginBumpMap::GetCapabilities
// -----------------------------------------------------------------------------
//
void CAknsRlEffectPluginBumpMap::GetCapabilities( TAknsRlEffectCaps& aCaps )
    {
    aCaps.iOutputLayerSupport = KAknsRlLayerRGBOnly;
    aCaps.iInputLayerASupport = KAknsRlLayerRGBOnly;
    aCaps.iInputLayerBSupport = KAknsRlLayerNone;
    }

// -----------------------------------------------------------------------------
// CAknsRlEffectPluginBumpMap::Render
// -----------------------------------------------------------------------------
//
TInt CAknsRlEffectPluginBumpMap::Render( const TAknsRlRenderOpParam& aParam )
    {
    if( !iContext ) // We absolutely need the context
        {
        return KErrBadHandle;
        }

    // To do anything we need both, the output layer and input layer
    if( ( aParam.iOutputLayerStatus & KAknsRlLayerRGBOnly ) &&
        ( aParam.iInputLayerAStatus & KAknsRlLayerRGBOnly ) )
        {
        // Query the layers, uninitialized because we process the whole image
        TAknsRlLayerData dataTarget;
        TRAPD( err, iContext->GetLayerDataL( dataTarget, aParam.iOutputLayerIndex,
                                             aParam.iOutputLayerStatus, EFalse ) );
        if( KErrNone != err )
            return KErrArgument;

        TAknsRlLayerData dataSource;
        TRAP( err, iContext->GetLayerDataL( dataSource, aParam.iInputLayerAIndex,
                                            aParam.iInputLayerAStatus, EFalse ) );
        if( KErrNone != err )
            return KErrArgument;

        if( !dataTarget.iRGBBitmap ) // We need the target bitmap
            return KErrBadHandle;

        if( !dataSource.iRGBBitmap ) // We need the source bitmap
            return KErrBadHandle;

        TDisplayMode modeT = dataTarget.iRGBBitmap->DisplayMode();
        TDisplayMode modeS = dataSource.iRGBBitmap->DisplayMode();

        // Rgb -> Rgb modes
        if( EColor64K == modeS && EColor64K == modeT )
            {
            return AknsRlEffectBumpMap<TUint16,0,5,6,5>::Process(
                            *dataTarget.iRGBBitmap,
                            *dataSource.iRGBBitmap,
                            iAzimuth,
                            iElevation,
                            iDepth,
                            TAknsRlChannelBlendMode( iBlendMode ),
                            iBlendFactor,
                            iGrayscale );
            }
        else if( EColor16MU == modeS && EColor16MU == modeT )
            {
            return AknsRlEffectBumpMap<TUint32,8,8,8,8>::Process(
                            *dataTarget.iRGBBitmap,
                            *dataSource.iRGBBitmap,
                            iAzimuth,
                            iElevation,
                            iDepth,
                            TAknsRlChannelBlendMode( iBlendMode ),
                            iBlendFactor,
                            iGrayscale );
            }
        else
            {
            // Provided layers have illegal display mode combination
            return KErrArgument;
            }
        }

    // The else part, required layers were not provided
    return KErrArgument;
    }

// End of File