diff -r 000000000000 -r 2f259fa3e83a uifw/ganes/src/HgVgHelper.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uifw/ganes/src/HgVgHelper.cpp Tue Feb 02 01:00:49 2010 +0200 @@ -0,0 +1,535 @@ +/* +* 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: +* +*/ + +// INCLUDE FILES + +#include "HgVgHelper.h" +#include "HgVgDrawBuffer.h" +#include "HgVgImageCreator.h" + +#include +#include +#include +#include +#include +#include + +const TInt KVertexX(0); +const TInt KVertexY(1); +const TInt KVertexZ(2); +const TInt KNumColorValues(4); +const TInt KNumColorTransformValues(8); +const VGfloat KColorByteToFloatFactor(255.0f); + + +namespace HgVgHelper + { + +static VGImage CreateNonMaskedVgImageL( const CFbsBitmap& aBitmap ) + { + TSize size = aBitmap.SizeInPixels(); + VGImage image = vgCreateImage(VG_sRGB_565, size.iWidth, size.iHeight,VG_IMAGE_QUALITY_NONANTIALIASED); + VGErrorCode error = vgGetError(); + if (image == VG_INVALID_HANDLE || error == VG_OUT_OF_MEMORY_ERROR) + { + User::Leave(KErrNoMemory); + } + if (aBitmap.DisplayMode() == EColor64K && !aBitmap.IsCompressedInRAM()) + { + aBitmap.BeginDataAccess(); + TInt stride = aBitmap.DataStride(); + TUint8* ptr = (TUint8*)aBitmap.DataAddress(); + vgImageSubData (image, ptr, stride, VG_sRGB_565, 0, 0, size.iWidth, size.iHeight ); + aBitmap.EndDataAccess(); + } + else + { + TSize size = aBitmap.SizeInPixels(); + CHgVgDrawBuffer* temp = CHgVgDrawBuffer::NewL(size, EColor64K); + temp->Gc().BitBlt(TPoint(0,0), &aBitmap); + temp->GetDrawBufferToVgImage(size, TPoint(0,0), image, + VG_sRGB_565); + delete temp; + } + return image; + } + +static VGImage CreateMaskedVgImageL( CFbsBitmap* aBitmap, CFbsBitmap* aMask ) + { + TSize size = aBitmap->SizeInPixels(); + CHgVgDrawBuffer* temp = CHgVgDrawBuffer::NewL(size, EColor16MA); + temp->Gc().SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha); + temp->Gc().SetBrushColor(TRgb(0,0,0,0)); + temp->Gc().Clear(); + temp->Gc().BitBltMasked(TPoint(0,0), aBitmap, size, aMask, EFalse); + + VGImage image = vgCreateImage(VG_sRGBA_8888, size.iWidth, size.iHeight,VG_IMAGE_QUALITY_NONANTIALIASED); + temp->GetDrawBufferToVgImage(size, TPoint(0,0), image, + VG_sARGB_8888); + + delete temp; + return image; + } + +// --------------------------------------------------------------------------- +// HgVgHelper::CreateVgImageFromIconL() +// --------------------------------------------------------------------------- +// +VGImage CreateVgImageFromIconL(const CGulIcon& aIcon) + { + + CFbsBitmap* bitmap = aIcon.Bitmap(); + User::LeaveIfNull(bitmap); + CFbsBitmap* mask = aIcon.Mask(); + + // if this is NVG image, rasterize it using + // nvg engine + if (bitmap->ExtendedBitmapType() != KNullUid) + { + return CHgVgImageCreator::InstanceL()->RenderImageFromIconL(bitmap); + } + else + { + // otherwise just blit/copy to vg image. + if (mask) + { + return CreateMaskedVgImageL(bitmap, mask); + } + else + { + return CreateNonMaskedVgImageL(*bitmap); + } + } + + } + +// --------------------------------------------------------------------------- +// HgVgHelper::Clamp() +// --------------------------------------------------------------------------- +// +VGfloat Clamp(VGfloat value, VGfloat min, VGfloat max) + { + VGfloat result = (value < min) ? min : value; + return (result > max) ? max : result; + } + +// --------------------------------------------------------------------------- +// HgVgHelper::Lerp() +// --------------------------------------------------------------------------- +// +VGfloat Lerp(VGfloat start, VGfloat end, VGfloat t) + { + return start * (1.0f - t) + end * t; + } + +// --------------------------------------------------------------------------- +// HgVgHelper::Abs() +// --------------------------------------------------------------------------- +// +VGfloat Abs(VGfloat value) + { + return (value < 0) ? -value : value; + } + +// --------------------------------------------------------------------------- +// HgVgHelper::CalculateBoudingRect() +// --------------------------------------------------------------------------- +// +void CalculateBoundingRect(TRect& aRect, VGfloat* aPoints, TInt aNumPoints, + const TRect& aWindowRect) + { + TInt height = aWindowRect.Height(); + + TPoint min((TInt)aPoints[0], height - (TInt)aPoints[1]); + TPoint max((TInt)aPoints[0], height - (TInt)aPoints[1]); + + for (TInt i = 0; i < aNumPoints; i++) + { + + TPoint temp((TInt)aPoints[i*2+0], height - (TInt)aPoints[i*2+1]); + + min.iX = (temp.iX < min.iX) ? temp.iX : min.iX; + max.iX = (temp.iX > max.iX) ? temp.iX : max.iX; + + min.iY = (temp.iY < min.iY) ? temp.iY : min.iY; + max.iY = (temp.iY > max.iY) ? temp.iY : max.iY; + + } + + // Top Left + aRect.iTl = min; + + // Bottom Right + aRect.iBr = max; + + } + +void TVertex::ProjectPoint(VGfloat aScreenWidth, VGfloat aScreenHeight, VGfloat aFov) + { + VGfloat hw = aScreenWidth * 0.5f; + VGfloat hh = aScreenHeight * 0.5f; + VGfloat alpha = aFov / 2.0f; + double tanAlpha; + Math::Tan(tanAlpha, alpha); + VGfloat d = hw / tanAlpha; + iScreenX = (VGfloat)(hw + d * iTx / iTz); + iScreenY = (VGfloat)(hh + d * iTy / iTz); + } + +void TVertex::TransformPoint(const TMatrix& aMatrix) + { + iTx = iX * aMatrix.iM[0][0] + iY * aMatrix.iM[1][0] + iZ * aMatrix.iM[2][0] + aMatrix.iM[3][0]; + iTy = iX * aMatrix.iM[0][1] + iY * aMatrix.iM[1][1] + iZ * aMatrix.iM[2][1] + aMatrix.iM[3][1]; + iTz = iX * aMatrix.iM[0][2] + iY * aMatrix.iM[1][2] + iZ * aMatrix.iM[2][2] + aMatrix.iM[3][2]; + } + +TMatrix::TMatrix() + { + } + +TMatrix::TMatrix(const TMatrix& rhs) + { + (*this) = rhs; + } + +TMatrix::~TMatrix() + { + } + +TMatrix& TMatrix::operator=(const TMatrix& rhs) + { + for (int i = 0; i < 4; ++i) + { + for (int j = 0; j < 4; ++j) + { + iM[i][j] = rhs.iM[i][j]; + } + } + return *this; + } + +void TMatrix::Identity() + { + iM[0][0] = 1.0f; + iM[0][1] = 0.0f; + iM[0][2] = 0.0f; + iM[0][3] = 0.0f; + + iM[1][0] = 0.0f; + iM[1][1] = 1.0f; + iM[1][2] = 0.0f; + iM[1][3] = 0.0f; + + iM[2][0] = 0.0f; + iM[2][1] = 0.0f; + iM[2][2] = 1.0f; + iM[2][3] = 0.0f; + + iM[3][0] = 0.0f; + iM[3][1] = 0.0f; + iM[3][2] = 0.0f; + iM[3][3] = 1.0f; + } + + +void TMatrix::Multiply(const TMatrix& rhs) + { + VGfloat temp[4][4]; + for (int i = 0; i < 4; ++i) + { + for (int j = 0; j < 4; ++j) + { + temp[i][j] = + iM[i][0] * rhs.iM[0][j] + + iM[i][1] * rhs.iM[1][j] + + iM[i][2] * rhs.iM[2][j] + + iM[i][3] * rhs.iM[3][j]; + } + } + for (int i = 0; i < 4; ++i) + { + for (int j = 0; j < 4; ++j) + { + iM[i][j] = temp[i][j]; + } + } + } + + +void TMatrix::RotationX(VGfloat angle) + { + double sa, ca; + Math::Sin(sa, angle); + Math::Cos(ca, angle); + + iM[0][0] = 1.0f; + iM[0][1] = 0.0f; + iM[0][2] = 0.0f; + iM[0][3] = 0.0f; + + iM[1][0] = 0.0f; + iM[1][1] = ca; + iM[1][2] = sa; + iM[1][3] = 0.0f; + + iM[2][0] = 0.0f; + iM[2][1] = -sa; + iM[2][2] = ca; + iM[2][3] = 0.0f; + + iM[3][0] = 0.0f; + iM[3][1] = 0.0f; + iM[3][2] = 0.0f; + iM[3][3] = 1.0f; + } + + +void TMatrix::RotationY(float angle) + { + double sa, ca; + Math::Sin(sa, angle); + Math::Cos(ca, angle); + + iM[0][0] = ca; + iM[0][1] = 0.0f; + iM[0][2] = -sa; + iM[0][3] = 0.0f; + + iM[1][0] = 0.0f; + iM[1][1] = 1.0f; + iM[1][2] = 0.0f; + iM[1][3] = 0.0f; + + iM[2][0] = sa; + iM[2][1] = 0.0f; + iM[2][2] = ca; + iM[2][3] = 0.0f; + + iM[3][0] = 0.0f; + iM[3][1] = 0.0f; + iM[3][2] = 0.0f; + iM[3][3] = 1.0f; + } + +void TMatrix::Scale(VGfloat aSx, VGfloat aSy, VGfloat aSz) + { + Identity(); + iM[0][0] = aSx; + iM[1][1] = aSy; + iM[2][2] = aSz; + } + +void TMatrix::Translation(VGfloat aX, VGfloat aY, VGfloat aZ) +{ + Identity(); + + iM[3][0] = aX; + iM[3][1] = aY; + iM[3][2] = aZ; +} + + +// --------------------------------------------------------------------------- +// HgVgHelper::ComputeRotationMatrixByY +// --------------------------------------------------------------------------- +// +void ComputeRotationMatrixByY(VGfloat* matrix, VGfloat angle) + { + // Build rotation matrix around Y-axis + double sinrad, cosrad; + Math::Sin (sinrad, angle ); + Math::Cos (cosrad, angle ); + VGfloat sa = sinrad; + VGfloat ca = cosrad; + + VGfloat rotMatrix[] = + { + ca, 0, sa, + 0, 1, 0, + sa, 0, -ca + }; + + // copy to result. + for (int i = 0; i < 9; i++ ) + matrix[i] = rotMatrix[i]; + } + + +// --------------------------------------------------------------------------- +// HgVgHelper::MultiplyMatrix() +// --------------------------------------------------------------------------- +// +void MultiplyMatrix(VGfloat* aResult, VGfloat* aA, VGfloat* aB) + { + for (VGint i = 0; i < 3; ++i) + { + for (VGint j = 0; j < 3; ++j) + { + aResult[i*3+j] = + aA[j*3+0] * aB[i*3+0] + + aA[j*3+1] * aB[i*3+1] + + aA[j*3+2] * aB[i*3+2]; + } + } + } + + +// --------------------------------------------------------------------------- +// HgVgHelper::TransformVertex +// --------------------------------------------------------------------------- +// +void TransformVertex(const VGfloat* inVertex, VGfloat* outVertex, + const VGfloat* matrix) + { + VGfloat x = inVertex[KVertexX]; + VGfloat y = inVertex[KVertexY]; + VGfloat z = inVertex[KVertexZ]; + + outVertex[KVertexX] = x * matrix[0] + y * matrix[3] + z * matrix[6]; + outVertex[KVertexY] = x * matrix[1] + y * matrix[4] + z * matrix[7]; + outVertex[KVertexZ] = x * matrix[2] + y * matrix[5] + z * matrix[8]; + } + +// --------------------------------------------------------------------------- +// HgVgHelper::PerspectiveTransformVertex +// --------------------------------------------------------------------------- +// +void PerspectiveTransformVertex(VGfloat* aInVertex, VGfloat* aOutVertex, + VGfloat aScreenWidth, VGfloat aScreenHeight, VGfloat aFov) + { +/* VGfloat x = inVertex[KVertexX]; + VGfloat y = inVertex[KVertexY]; + VGfloat z = inVertex[KVertexZ]; + + outVertex[KVertexX] = screenWidth * 0.5f + fov * x / z; + outVertex[KVertexY] = screenHeight * 0.5f + fov * y / z; +*/ + VGfloat hw = aScreenWidth * 0.5f; + VGfloat hh = aScreenHeight * 0.5f; + VGfloat alpha = aFov / 2.0f; + double tanAlpha; + Math::Tan(tanAlpha, alpha); + VGfloat d = hw / tanAlpha; + aOutVertex[KVertexX] = (VGfloat)(hw + d * aInVertex[KVertexX] / aInVertex[KVertexZ]); + aOutVertex[KVertexY] = (VGfloat)(hh + d * aInVertex[KVertexY] / aInVertex[KVertexZ]); + + } + +// --------------------------------------------------------------------------- +// HgVgHelper::DrawAlphaImage() +// --------------------------------------------------------------------------- +// +void DrawImage(VGImage aImage, + const TPoint& aPos, const TRect& aWindowRect, TBool aCentered) + { + + vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE); + vgLoadIdentity(); + + if (!aCentered) + { + vgScale(1, -1); + vgTranslate(aPos.iX, -(aWindowRect.Height() - aPos.iY)); + } + else + { + VGint w = vgGetParameteri(aImage, VG_IMAGE_WIDTH); + VGint h = vgGetParameteri(aImage, VG_IMAGE_HEIGHT); + vgTranslate(aPos.iX, (aWindowRect.Height() - aPos.iY)); + vgScale(1, -1); + vgTranslate(-(VGfloat)w/2,-(VGfloat)h/2); + } + + vgDrawImage(aImage); + + } + +// --------------------------------------------------------------------------- +// HgVgHelper::DrawImageColorized +// --------------------------------------------------------------------------- +// +void DrawImageColorized(VGImage aImage, const TRgb& aColor, + const TPoint& aPos, const TRect& aWindowRect, TBool aCentered) + { + + VGfloat values[] = { 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0 }; + + values[0] = (VGfloat)aColor.Red() / KColorByteToFloatFactor; + values[1] = (VGfloat)aColor.Green() / KColorByteToFloatFactor; + values[2] = (VGfloat)aColor.Blue() / KColorByteToFloatFactor; + values[3] = (VGfloat)aColor.Alpha() / KColorByteToFloatFactor; + + vgSetfv(VG_COLOR_TRANSFORM_VALUES, KNumColorTransformValues, values); + vgSeti(VG_COLOR_TRANSFORM, VG_TRUE); + + HgVgHelper::DrawImage(aImage, aPos, aWindowRect, aCentered); + + vgSeti(VG_COLOR_TRANSFORM, VG_FALSE); + } + + + +// --------------------------------------------------------------------------- +// HgVgHelper::CreatePath() +// --------------------------------------------------------------------------- +// +VGPath CreatePath(VGuint aNumSegments, const VGubyte* aSegments, const VGfloat* aPoints) + { + VGPath path = vgCreatePath(VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, + 1.0f, 0.0f, 4, 4, (unsigned int)VG_PATH_CAPABILITY_ALL); + + vgAppendPathData(path, aNumSegments, aSegments, aPoints); + + return path; + } + +// --------------------------------------------------------------------------- +// HgVgHelper::CreateColorPaint() +// --------------------------------------------------------------------------- +// +VGPaint CreateColorPaint(const VGfloat* aColor) + { + VGPaint paint = vgCreatePaint(); + + vgSetParameteri(paint, VG_PAINT_TYPE, + VG_PAINT_TYPE_COLOR); + + vgSetParameterfv(paint, VG_PAINT_COLOR, + KNumColorValues, aColor); + + return paint; + } + +// --------------------------------------------------------------------------- +// HgVgHelper::CreateColorPaint() +// --------------------------------------------------------------------------- +// +VGPaint CreateColorPaint(const TRgb& aColor) + { + VGfloat values[4]; + + values[0] = (VGfloat)aColor.Red() / KColorByteToFloatFactor; + values[1] = (VGfloat)aColor.Green() / KColorByteToFloatFactor; + values[2] = (VGfloat)aColor.Blue() / KColorByteToFloatFactor; + values[3] = (VGfloat)aColor.Alpha() / KColorByteToFloatFactor; + + return CreateColorPaint(values); + } + + } + +// End of File