diff -r 000000000000 -r 15bf7259bb7c uiacceltk/hitchcock/coretoolkit/src/HuiFxVisualLayer.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uiacceltk/hitchcock/coretoolkit/src/HuiFxVisualLayer.cpp Tue Feb 02 07:56:43 2010 +0200 @@ -0,0 +1,441 @@ +/* +* Copyright (c) 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: +* +*/ + + + +#include "HuiFxVisualLayer.h" +#include "Matrix.h" +#include "HuiFxParameterManager.h" +#include +#include "HuiFxConstants.h" +#include +#include "HuiCmdBufferBrush.h" + +EXPORT_C CHuiFxVisualLayer* CHuiFxVisualLayer::NewL(MHuiEffectable& aVisual) + { + CHuiFxVisualLayer* e = new (ELeave) CHuiFxVisualLayer(); + CleanupStack::PushL(e); + e->ConstructL(aVisual); + CleanupStack::Pop(e); + return e; + } + +EXPORT_C void CHuiFxVisualLayer::ConstructL(MHuiEffectable& aVisual) + { +#ifdef HUIFX_TRACE + RDebug::Print(_L("CHuiFxVisualLayer::ConstructL - 0x%x "), this); +#endif + CHuiFxLayer::ConstructL( ELayerTypeVisual ); + iParameterManager = CHuiFxParameterManager::NewL(); + iVisual = &aVisual; + iSrcType = EVisualSrcVisual; + iExtBitmapFile = NULL; + + iTranslationX = 0.0f; + iTranslationY = 0.0f; + iTranslationZ = 0.0f; + + iScaleX = 1.0f; + iScaleY = 1.0f; + iScaleZ = 1.0f; + iScaleOriginX = 0.0f; + iScaleOriginY = 0.0f; + iScaleOriginZ = 0.0f; + + iRotationOriginX = 0.0f; + iRotationOriginY = 0.0f; + iRotationOriginZ = 0.0f; + iRotationAngle = 0.0f; + iRotationAxisX = 0.0f; + iRotationAxisY = 0.0f; + iRotationAxisZ = 1.0f; + + iSkewAngleX = 0.0f; + iSkewAngleY = 0.0f; + iSkewAngleZ = 0.0f; + iSkewOriginX = 0.0f; + iSkewOriginY = 0.0f; + iSkewOriginZ = 0.0f; + + // We use the visual's own target opacity if we haven't set something explicitly + if (iVisual) + { + //iOpacity = iVisual->iOpacity.Target(); + iOpacity = iVisual->EffectOpacityTarget(); + } + else + { + iOpacity = 1.0; + } + RegisterParameterL(KLitTranslationX, &iTranslationX); + RegisterParameterL(KLitTranslationY, &iTranslationY); + RegisterParameterL(KLitTranslationZ, &iTranslationZ); + + RegisterParameterL(KLitScaleX, &iScaleX); + RegisterParameterL(KLitScaleY, &iScaleY); + RegisterParameterL(KLitScaleZ, &iScaleZ); + RegisterParameterL(KLitScaleOriginX, &iScaleOriginX); + RegisterParameterL(KLitScaleOriginY, &iScaleOriginY); + RegisterParameterL(KLitScaleOriginZ, &iScaleOriginZ); + + RegisterParameterL(KLitRotationOriginX, &iRotationOriginX); + RegisterParameterL(KLitRotationOriginY, &iRotationOriginY); + RegisterParameterL(KLitRotationOriginZ, &iRotationOriginZ); + RegisterParameterL(KLitRotationAngle, &iRotationAngle); + RegisterParameterL(KLitRotationAxisX, &iRotationAxisX); + RegisterParameterL(KLitRotationAxisY, &iRotationAxisY); + RegisterParameterL(KLitRotationAxisZ, &iRotationAxisZ); + + RegisterParameterL(KLitSkewAngleX, &iSkewAngleX); + RegisterParameterL(KLitSkewAngleY, &iSkewAngleY); + RegisterParameterL(KLitSkewAngleZ, &iSkewAngleZ); + RegisterParameterL(KLitSkewOriginX, &iSkewOriginX); + RegisterParameterL(KLitSkewOriginY, &iSkewOriginY); + RegisterParameterL(KLitSkewOriginZ, &iSkewOriginZ); + + RegisterParameterL(KLitOpacityParameter, &iOpacity); + } + +EXPORT_C CHuiFxVisualLayer *CHuiFxVisualLayer::CloneL() const +{ + CHuiFxVisualLayer *layer = new (ELeave) CHuiFxVisualLayer; + layer->CHuiFxLayer::ConstructL( ELayerTypeVisual ); + layer->CHuiFxLayer::CopyFromL(this); + layer->iVisual = iVisual; // visual will be set later... + layer->iParameterManager = iParameterManager->CloneL(); + layer->iParameterManager->CopyParameterL(KLitTranslationX, &layer->iTranslationX, iParameterManager); + layer->iParameterManager->CopyParameterL(KLitTranslationY, &layer->iTranslationY, iParameterManager); + layer->iParameterManager->CopyParameterL(KLitTranslationZ, &layer->iTranslationZ, iParameterManager); + + layer->iParameterManager->CopyParameterL(KLitScaleX, &layer->iScaleX, iParameterManager); + layer->iParameterManager->CopyParameterL(KLitScaleY, &layer->iScaleY, iParameterManager); + layer->iParameterManager->CopyParameterL(KLitScaleZ, &layer->iScaleZ, iParameterManager); + layer->iParameterManager->CopyParameterL(KLitScaleOriginX, &layer->iScaleOriginX, iParameterManager); + layer->iParameterManager->CopyParameterL(KLitScaleOriginY, &layer->iScaleOriginY, iParameterManager); + layer->iParameterManager->CopyParameterL(KLitScaleOriginZ, &layer->iScaleOriginZ, iParameterManager); + + layer->iParameterManager->CopyParameterL(KLitRotationOriginX, &layer->iRotationOriginX, iParameterManager); + layer->iParameterManager->CopyParameterL(KLitRotationOriginY, &layer->iRotationOriginY, iParameterManager); + layer->iParameterManager->CopyParameterL(KLitRotationOriginZ, &layer->iRotationOriginZ, iParameterManager); + layer->iParameterManager->CopyParameterL(KLitRotationAngle, &layer->iRotationAngle, iParameterManager); + layer->iParameterManager->CopyParameterL(KLitRotationAxisX, &layer->iRotationAxisX, iParameterManager); + layer->iParameterManager->CopyParameterL(KLitRotationAxisY, &layer->iRotationAxisY, iParameterManager); + layer->iParameterManager->CopyParameterL(KLitRotationAxisZ, &layer->iRotationAxisZ, iParameterManager); + + layer->iParameterManager->CopyParameterL(KLitSkewAngleX, &layer->iSkewAngleX, iParameterManager); + layer->iParameterManager->CopyParameterL(KLitSkewAngleY, &layer->iSkewAngleY, iParameterManager); + layer->iParameterManager->CopyParameterL(KLitSkewAngleZ, &layer->iSkewAngleZ, iParameterManager); + layer->iParameterManager->CopyParameterL(KLitSkewOriginX, &layer->iSkewOriginX, iParameterManager); + layer->iParameterManager->CopyParameterL(KLitSkewOriginY, &layer->iSkewOriginY, iParameterManager); + layer->iParameterManager->CopyParameterL(KLitSkewOriginZ, &layer->iSkewOriginZ, iParameterManager); + + layer->iParameterManager->CopyParameterL(KLitOpacityParameter, &layer->iOpacity, iParameterManager); + + layer->iSrcType = iSrcType; + layer->iTranslationX = iTranslationX; + layer->iTranslationY = iTranslationY; + layer->iTranslationZ = iTranslationZ; + layer->iScaleX = iScaleX; + layer->iScaleY = iScaleY; + layer->iScaleZ = iScaleZ; + layer->iScaleOriginX = iScaleOriginX; + layer->iScaleOriginY = iScaleOriginY; + layer->iScaleOriginZ = iScaleOriginZ; + layer->iRotationOriginX = iRotationOriginX; + layer->iRotationOriginY = iRotationOriginY; + layer->iRotationOriginZ = iRotationOriginZ; + layer->iRotationAngle = iRotationAngle; + layer->iRotationAxisX = iRotationAxisX; + layer->iRotationAxisY = iRotationAxisY; + layer->iRotationAxisZ = iRotationAxisZ; + layer->iSkewAngleX = iSkewAngleX; + layer->iSkewAngleY = iSkewAngleY; + layer->iSkewAngleZ = iSkewAngleZ; + + layer->iSkewOriginX = iSkewOriginX; + layer->iSkewOriginY = iSkewOriginY; + layer->iSkewOriginZ = iSkewOriginZ; + if (iExtBitmapFile) + layer->iExtBitmapFile = iExtBitmapFile->AllocL(); + else + layer->iExtBitmapFile = NULL; + layer->iOpacity = iOpacity; + return layer; +} +EXPORT_C void CHuiFxVisualLayer::SetExtRect( TRect * /*aExtRect*/ ) + { + // not needed.. + } +EXPORT_C void CHuiFxVisualLayer::SetVisual( CHuiVisual * aVisual ) + { + iVisual = aVisual->Effectable(); + + if (Math::IsInfinite(iOpacity)) + { + iOpacity = aVisual->iOpacity.Target(); + } + } +EXPORT_C void CHuiFxVisualLayer::SetVisual( MHuiEffectable *aVisual ) + { + iVisual = aVisual; + + if (Math::IsInfinite(iOpacity)) + { + //iOpacity = iVisual->iOpacity.Target(); + iOpacity = iVisual->EffectOpacityTarget(); + } + } + + + +EXPORT_C CHuiFxVisualLayer::~CHuiFxVisualLayer() + { +#ifdef HUIFX_TRACE + RDebug::Print(_L("CHuiFxVisualLayer::~CHuiFxVisualLayer - 0x%x "), this); +#endif + delete iExtBitmapFile; + delete iParameterManager; + iParameterManager = NULL; + } + +EXPORT_C TBool CHuiFxVisualLayer::Changed() const + { + TBool ret = iParameterManager->HasAnimatedParameters(); +#ifdef HUIFX_TRACE + RDebug::Print(_L("CHuiFxVisualLayer::Changed - 0x%x , ret %d"), this, ret); +#endif + return ret; + } + +EXPORT_C void CHuiFxVisualLayer::AdvanceTime(TReal32 aElapsedTime) + { + iParameterManager->AdvanceTime(aElapsedTime); + } + +EXPORT_C TBool CHuiFxVisualLayer::PrepareDrawL(CHuiFxEngine& aEngine) + { + iParameterManager->Update(aEngine, VisualRect()); + return ETrue; + } + +EXPORT_C void CHuiFxVisualLayer::Draw(CHuiFxEngine& aEngine, CHuiGc& aGc, CHuiFxRenderbuffer &aTarget, CHuiFxRenderbuffer& /*aSource*/) + { +#ifdef HUIFX_TRACE + RDebug::Print(_L("CHuiFxVisualLayer::Draw - 0x%x "), this); +#endif + aTarget.BindAsRenderTarget(); + aGc.Push(EHuiGcMatrixModel); + + THuiFxEngineType engineType = aEngine.EngineType(); + TRenderBufferType bufferType = aTarget.BufferType(); + if(engineType == EHuiFxEngineGles20) + { + if(bufferType == EBufferTypeOffscreen) + { + aGc.Enable(CHuiGc::EFeatureBlending, ETrue); + aGc.SetBlendMode(CHuiGc::EBlendReplace); + } + TRect viewPort(TPoint(0,0), aTarget.Size()); + aGc.SetProjection(CHuiGc::EProjectionOrthographic, viewPort); + } + + aGc.Translate(EHuiGcMatrixModel, VisualRect().iTl.iX, VisualRect().iTl.iY, 0.0f); + ApplyTransformations(aGc); + aGc.Translate(EHuiGcMatrixModel, -VisualRect().iTl.iX, -VisualRect().iTl.iY, 0.0f); + + aGc.SetBlendMode( CHuiGc::EBlendNormal ); + //iVisual->iOpacity.Set( iOpacity ); + iVisual->EffectSetOpacity( iOpacity ); + + // Set new clipping region which does not clip anything. + // We want always draw visual fully to the aTarget. + aGc.PushClip(); + TRect bufferArea = TRect(TPoint(0,0), aTarget.Size()); + aGc.SetClip(bufferArea); // this does not transform bufferArea which is fine for us + + // Draw visual content to aTarget + //iVisual->DrawSelf(aGc, TargetRect()); + iVisual->EffectSetSource(iSrcType==EVisualSrcInput1); + iVisual->EffectDrawSelf( aGc, TargetRect() ); + iVisual->EffectSetSource(EFalse); + + // Restore original clipping + aGc.PopClip(); + + if(engineType == EHuiFxEngineGles20) + { + if(bufferType == EBufferTypeOffscreen) + { + aGc.SetBlendMode(CHuiGc::EBlendNormal); + } + aGc.SetProjection(CHuiGc::EProjectionOrthographic); + } + + aGc.Pop(EHuiGcMatrixModel); + aTarget.UnbindAsRenderTarget(); + } + +void CHuiFxVisualLayer::ApplyTransformations(CHuiGc& aGc) + { +#ifdef HUIFX_TRACE + RDebug::Print(_L("CHuiFxVisualLayer::ApplyTransformations - 0x%x "), this); +#endif + // Matrix multiplication is generally not commutative. + // Therefore the order of the transformations matters. + // In order to prevent the scaling ang skewing from affecting the translation, + // if seems wiser to do the translation first, otherwise the results seem to be unpredictable. + + // Translation + if (iTranslationX != 0.0f || iTranslationY != 0.0f || iTranslationZ != 0.0f) + { + aGc.Translate(EHuiGcMatrixModel, iTranslationX, iTranslationY, iTranslationZ); + } + + // Scaling + if (iScaleX != 1.0f || iScaleY != 1.0f || iScaleZ != 1.0f) + { + if ( iScaleOriginX != 0 || iScaleOriginY != 0 || iScaleOriginZ != 0 ) + { + aGc.Translate(EHuiGcMatrixModel, iScaleOriginX, iScaleOriginY, iScaleOriginZ); + aGc.Scale(EHuiGcMatrixModel, iScaleX, iScaleY, iScaleZ); + aGc.Translate(EHuiGcMatrixModel, -iScaleOriginX, -iScaleOriginY, -iScaleOriginZ); + } + else + { + aGc.Scale(EHuiGcMatrixModel, iScaleX, iScaleY, iScaleZ); + } + } + + // Skewing + if (iSkewAngleX != 0.0f || iSkewAngleY != 0.0f || iSkewAngleZ != 0.0f) + { + const TReal32 radsPerDeg = 2.0f * (float)M_PI / 360.0f; + TReal32 skewX = tan(iSkewAngleX * radsPerDeg); + TReal32 skewY = tan(iSkewAngleY * radsPerDeg); + TReal32 skewZ = tan(iSkewAngleZ * radsPerDeg); + if ( iSkewOriginX != 0 || iSkewOriginY != 0 || iSkewOriginZ != 0 ) + { + aGc.Translate(EHuiGcMatrixModel, iSkewOriginX, iSkewOriginY, iSkewOriginZ); + aGc.Shear(EHuiGcMatrixModel, skewX, skewY, skewZ); + aGc.Translate(EHuiGcMatrixModel, -iSkewOriginX, -iSkewOriginY, -iSkewOriginZ); + } + else + { + aGc.Shear(EHuiGcMatrixModel, skewX, skewY, skewZ); + } + } + + // Rotation + if (iRotationAngle != 0.0f) + { + if ( iRotationOriginX != 0 || iRotationOriginY != 0 || iRotationOriginZ != 0 ) + { + aGc.Translate(EHuiGcMatrixModel, iRotationOriginX, iRotationOriginY, iRotationOriginZ); + aGc.Rotate(EHuiGcMatrixModel, iRotationAngle, iRotationAxisX, iRotationAxisY, iRotationAxisZ); + aGc.Translate(EHuiGcMatrixModel, -iRotationOriginX, -iRotationOriginY, -iRotationOriginZ); + } + else + { + aGc.Rotate(EHuiGcMatrixModel, iRotationAngle, iRotationAxisX, iRotationAxisY, iRotationAxisZ); + } + } + + // Translation +/* + if (iTranslationX != 0.0f || iTranslationY != 0.0f || iTranslationZ != 0.0f) + { + aGc.Translate(EHuiGcMatrixModel, iTranslationX, iTranslationY, iTranslationZ); + } +*/ + } + +EXPORT_C TBool CHuiFxVisualLayer::VisualArea( TRect& aRect ) + { + // TODO: cache? + // TODO: transforms + //aRect = iVisual->DisplayRect(); + THuiRealRect rect = iVisual->EffectDisplayRect(); + aRect = rect; + return ETrue; + } + +EXPORT_C TBool CHuiFxVisualLayer::Margin(TMargins &m) + { + m.iLeft = iTranslationX < 0.0 ? -iTranslationX : 0.0; + m.iRight = iTranslationX > 0.0 ? iTranslationX : 0.0; + m.iTop = iTranslationY < 0.0 ? -iTranslationY : 0.0; + m.iBottom = iTranslationY > 0.0 ? iTranslationY : 0.0; + return ETrue; + } + +EXPORT_C MHuiFxParameter* CHuiFxVisualLayer::Parameter(const TDesC& aName) + { + return iParameterManager->Parameter(aName); + } + +EXPORT_C void CHuiFxVisualLayer::RegisterParameterL(const TDesC& aName, TReal32* aValue) + { + iParameterManager->RegisterParameterL(aName, aValue); + } + +EXPORT_C void CHuiFxVisualLayer::RegisterParameterL(const TDesC& aName, TRgb* aValue) + { + iParameterManager->RegisterParameterL(aName, aValue); + } + +void CHuiFxVisualLayer::SetSourceType( const THuiFxVisualSrcType aSrcType ) + { + iSrcType = aSrcType; + } + +THuiFxVisualSrcType CHuiFxVisualLayer::SourceType() const + { + return iSrcType; + } + +void CHuiFxVisualLayer::SetExtBitmapFileL( TDesC& aFilename ) + { +#ifdef HUIFX_TRACE + RDebug::Print(_L("CHuiFxVisualLayer::SetExtBitmapFileL - 0x%x, %S "), this, &aFilename); +#endif + delete iExtBitmapFile; + iExtBitmapFile = NULL; + if ( aFilename.Length() == 0 ) + { + // don't set an empty filename + return; + } + iExtBitmapFile = HBufC::NewL( aFilename.Length() ); + *iExtBitmapFile = aFilename; + //TODO: the bitmap from this filename should be loaded as texture to the visual. + } +void CHuiFxVisualLayer::FxmlVisualInputs(RArray &aArray) + { + aArray.Append(iSrcType); + } + +TBool CHuiFxVisualLayer::IsSemitransparent() const + { + if (iOpacity < 1.f) + { + return ETrue; + } + else + { + return EFalse; + } + }