/*

* Copyright (c) 2009 Symbian Foundation Ltd

* This component and the accompanying materials are made available

* under the terms of the License "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:

* Symbian Foundation Ltd - initial contribution.

* 

* Contributors:

*

* Description:

* Implementation of CTiger class

*/

// INCLUDE FILES

#include <e32std.h>

#include "Tiger.h"

#define assert(a) __ASSERT_ALWAYS(a,User::Invariant());

// CONSTANTS

const float KaspectRatio = 612.0f / 792.0f;

/*--------------------------------------------------------------*/

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

// -----------------------------------------------------------------------------

// CTiger::NewL

//

// The usual Symbian NewL implementation.

// Creates the object, pushes it to cleanup stack and calls ContructL.

// Returns the contructed object or leaves.

// -----------------------------------------------------------------------------

//

CTiger* CTiger::NewL(TUint aWidth, TUint aHeight)

	{

	/* Symbian 2-phase constructor. Calls both the default

	 C++ constructor and Symbian ConstructL methods */

	CTiger* self = new (ELeave) CTiger(aWidth, aHeight);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

// -----------------------------------------------------------------------------

// CTiger::CTiger

//

// C++ constructor. Initializes the size instance variables from arguments.

// -----------------------------------------------------------------------------

//

CTiger::CTiger(TUint aWidth,TUint aHeight) :

	iScreenWidth(aWidth),iScreenHeight(aHeight)

	{

	}

// -----------------------------------------------------------------------------

// CTiger::~CTiger

//

// C++ destructor.

// -----------------------------------------------------------------------------

//

CTiger::~CTiger()

	{

	}

// -----------------------------------------------------------------------------

// CTiger::ConstructL

//

// 2nd phase constructor.

// -----------------------------------------------------------------------------

//

void CTiger::ConstructL(void)

	{

	}

// -----------------------------------------------------------------------------

// CTiger::AppInit

//

// Initializes OpenGL ES, sets the vertex and color arrays and pointers,

// and selects the shading mode.

// -----------------------------------------------------------------------------

//

void CTiger::AppInit(RWindow& /*aWindow*/, CFbsBitmap* aBitmapToDraw)

	{

	// Initialize viewport and projection.

	SetScreenSize(iScreenWidth, iScreenHeight);

	//render into half-screen dimensions 

	iNativeWindowType.iSize = TSize(iScreenWidth, iScreenHeight);

	iBitmapToDraw = aBitmapToDraw;

	init((NativeWindowType) &iNativeWindowType, aBitmapToDraw);

	//render now to save time on redraw

	TRect rect(0, 0, iNativeWindowType.iSize.iWidth, iNativeWindowType.iSize.iHeight);

	//render now to stop render from taking place on draw which causes ViewSrv 11 panic

	AppRender(iNativeWindowType.iSize);

	}

// -----------------------------------------------------------------------------

// CTiger::AppExit

//

// Release any allocations made in AppInit.

// -----------------------------------------------------------------------------

//

void CTiger::AppExit(void)

	{

	if(iTiger)

		PS_destruct(iTiger);

	eglMakeCurrent(iEgldisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);

	__ASSERT_ALWAYS(eglGetError() == EGL_SUCCESS,User::Invariant());

	eglTerminate(iEgldisplay);

	__ASSERT_ALWAYS(eglGetError() == EGL_SUCCESS,User::Invariant());

	eglReleaseThread();

	}

void CTiger::PS_destruct(PS* ps)

	{

	int i;

	__ASSERT_ALWAYS(ps,User::Invariant());

	for (i = 0; i < ps->m_numPaths; i++)

		{

		vgDestroyPaint(ps->m_paths[i].m_fillPaint);

		vgDestroyPaint(ps->m_paths[i].m_strokePaint);

		vgDestroyPath(ps->m_paths[i].m_path);

		}

	delete[] ps->m_paths;

	ps->m_paths = NULL;

	delete ps;

	ps = NULL;

	}

void CTiger::AppRender(const TRect& aRect, CFbsBitmap* aDst)

	{	

	TDisplayMode dispMode=ENone;

	if (iBitmapToDraw == NULL)

		{

		//drawing tiger

		dispMode = EColor16MA;

		TRAPD(err, render(aRect.Width(), aRect.Height()));

		if (err==KErrNoMemory)

			{

			//check heap metrics		

			RDebug::Printf("If rendering fails with KErrNoMemory then you must modify epoc.ini file ");

			RDebug::Printf("to increase the maximum total heap size e.g. to MegabytesOfFreeMemory 64.");

			RDebug::Printf("The Kronos ref OpenVG seems to use a lot of heap so when both NVG engine");

			RDebug::Printf("and the Tiger app are active it pushes it over limit of 48Mb.");

			}

		}

	else

		{

		//draw bitmap

		dispMode = iBitmapToDraw->DisplayMode();

		renderFromBitmap(aRect.Width(), aRect.Height());

		}

	if(aDst)

		{

		//we want to render into the the aDst CFbsBitmap so set up the native window type for this

		aDst->Create(iNativeWindowType.iSize, dispMode); //how does display mode relate to pixel buffer colour depth coming from OpenVG?#

		iNativeWindowType.iBitmap = aDst;

		//swap buffers that will cause actual copy of data into CFbsBitmap

		eglSwapBuffers(iEgldisplay, iEglsurface);

		__ASSERT_ALWAYS(eglGetError() == EGL_SUCCESS,User::Invariant());

		}

	//reset

	iNativeWindowType.iBitmap = NULL;

	}

void CTiger::SetScreenSize(TUint aWidth, TUint aHeight)

	{

	iScreenWidth = aWidth;

	iScreenHeight = aHeight;

	}

///////////////////////////////////////////////////////////////////////////

/*

 * Copied from ri_package_11\samples\tiger\main.c

 */

void CTiger::render(int w, int h)

	{

	if (iRenderWidth != w || iRenderHeight != h)

		{

		float clearColor[4] =

			{

			1, 1, 1, 1

			};

		float scale = w / (KtigerMaxX - KtigerMinX);

		eglSwapBuffers(iEgldisplay, iEglsurface); //force EGL to recognize resize

		vgSetfv(VG_CLEAR_COLOR, 4, clearColor);

		vgClear(0, 0, w, h);

		vgLoadIdentity();

		vgScale(scale, scale);

		vgTranslate(-KtigerMinX, -KtigerMinY + 0.5f * (h / scale - (KtigerMaxY

				- KtigerMinY)));

		PS_render(iTiger);

		__ASSERT_ALWAYS(vgGetError() == VG_NO_ERROR,User::Invariant());

		iRenderWidth = w;

		iRenderHeight = h;

		}

	}

void CTiger::renderFromBitmap(int w, int h)

	{

	if (iRenderWidth != w || iRenderHeight != h)

		{

		TSize sz = iBitmapToDraw->SizeInPixels();

		float scale = w / (sz.iWidth);

		vgLoadIdentity();

		vgScale(scale, scale);

		vgTranslate(-0.0, -0.0 + 0.5f * (h / scale - (sz.iHeight)));

		iRenderWidth = w;

		iRenderHeight = h;

		vgDrawImage(iImage);

		__ASSERT_ALWAYS(vgGetError() == VG_NO_ERROR,User::Invariant());

		eglSwapBuffers(iEgldisplay, iEglsurface); //force GL to recognise resize

		__ASSERT_ALWAYS(eglGetError() == EGL_SUCCESS,User::Invariant());

		}

	}

void CTiger::PS_render(PS* ps)

	{

	int i;

	__ASSERT_ALWAYS(ps,User::Invariant());

	vgSeti(VG_BLEND_MODE, VG_BLEND_SRC_OVER);

	for (i = 0; i < ps->m_numPaths; i++)

		{

		vgSeti(VG_FILL_RULE, ps->m_paths[i].m_fillRule);

		vgSetPaint(ps->m_paths[i].m_fillPaint, VG_FILL_PATH);

		if (ps->m_paths[i].m_paintMode & VG_STROKE_PATH)

			{

			vgSetf(VG_STROKE_LINE_WIDTH, ps->m_paths[i].m_strokeWidth);

			vgSeti(VG_STROKE_CAP_STYLE, ps->m_paths[i].m_capStyle);

			vgSeti(VG_STROKE_JOIN_STYLE, ps->m_paths[i].m_joinStyle);

			vgSetf(VG_STROKE_MITER_LIMIT, ps->m_paths[i].m_miterLimit);

			vgSetPaint(ps->m_paths[i].m_strokePaint, VG_STROKE_PATH);

			}

		vgDrawPath(ps->m_paths[i].m_path, ps->m_paths[i].m_paintMode);

		}

	__ASSERT_ALWAYS(vgGetError() == VG_NO_ERROR,User::Invariant());

	}

PS* CTiger::PS_construct(const char* commands, int commandCount,

		const float* points, int /*pointCount*/)

	{

	PS* ps = new PS;

	assert(ps);

	int p = 0;

	int c = 0;

	int i = 0;

	int paths = 0;

	int maxElements = 0;

	unsigned char* cmd;

	//UNREF(pointCount);

	while (c < commandCount)

		{

		int elements, e;

		c += 4;

		p += 8;

		elements = (int) points[p++];

		assert(elements> 0);

		if (elements > maxElements)

			maxElements = elements;

		for (e = 0; e < elements; e++)

			{

			switch (commands[c])

				{

				case 'M':

					p += 2;

					break;

				case 'L':

					p += 2;

					break;

				case 'C':

					p += 6;

					break;

				case 'E':

					break;

				default:

					assert(0)

					; //unknown command

				}

			c++;

			}

		paths++;

		}

	ps->m_numPaths = paths;

	ps->m_paths = new PathData[paths];//(PathData*)malloc(paths * sizeof(PathData));

	cmd = new unsigned char[maxElements];//(unsigned char*)malloc(maxElements);

	i = 0;

	p = 0;

	c = 0;

	while (c < commandCount)

		{

		int elements, startp, e;

		float color[4];

		//fill type

		int paintMode = 0;

		ps->m_paths[i].m_fillRule = VG_NON_ZERO;

		switch (commands[c])

			{

			case 'N':

				break;

			case 'F':

				ps->m_paths[i].m_fillRule = VG_NON_ZERO;

				paintMode |= VG_FILL_PATH;

				break;

			case 'E':

				ps->m_paths[i].m_fillRule = VG_EVEN_ODD;

				paintMode |= VG_FILL_PATH;

				break;

			default:

				assert(0)

				; //unknown command

			}

		c++;

		//stroke

		switch (commands[c])

			{

			case 'N':

				break;

			case 'S':

				paintMode |= VG_STROKE_PATH;

				break;

			default:

				assert(0)

				; //unknown command

			}

		ps->m_paths[i].m_paintMode = (VGPaintMode) paintMode;

		c++;

		//line cap

		switch (commands[c])

			{

			case 'B':

				ps->m_paths[i].m_capStyle = VG_CAP_BUTT;

				break;

			case 'R':

				ps->m_paths[i].m_capStyle = VG_CAP_ROUND;

				break;

			case 'S':

				ps->m_paths[i].m_capStyle = VG_CAP_SQUARE;

				break;

			default:

				assert(0)

				; //unknown command

			}

		c++;

		//line join

		switch (commands[c])

			{

			case 'M':

				ps->m_paths[i].m_joinStyle = VG_JOIN_MITER;

				break;

			case 'R':

				ps->m_paths[i].m_joinStyle = VG_JOIN_ROUND;

				break;

			case 'B':

				ps->m_paths[i].m_joinStyle = VG_JOIN_BEVEL;

				break;

			default:

				assert(0)

				; //unknown command

			}

		c++;

		//the rest of stroke attributes

		ps->m_paths[i].m_miterLimit = points[p++];

		ps->m_paths[i].m_strokeWidth = points[p++];

		//paints

		color[0] = points[p++];

		color[1] = points[p++];

		color[2] = points[p++];

		color[3] = 1.0f;

		ps->m_paths[i].m_strokePaint = vgCreatePaint();

		vgSetParameteri(ps->m_paths[i].m_strokePaint, VG_PAINT_TYPE,

				VG_PAINT_TYPE_COLOR);

		vgSetParameterfv(ps->m_paths[i].m_strokePaint, VG_PAINT_COLOR, 4, color);

		color[0] = points[p++];

		color[1] = points[p++];

		color[2] = points[p++];

		color[3] = 1.0f;

		ps->m_paths[i].m_fillPaint = vgCreatePaint();

		vgSetParameteri(ps->m_paths[i].m_fillPaint, VG_PAINT_TYPE,

				VG_PAINT_TYPE_COLOR);

		vgSetParameterfv(ps->m_paths[i].m_fillPaint, VG_PAINT_COLOR, 4, color);

		//read number of elements

		elements = (int) points[p++];

		assert(elements> 0);

		startp = p;

		for (e = 0; e < elements; e++)

			{

			switch (commands[c])

				{

				case 'M':

					cmd[e] = VG_MOVE_TO | VG_ABSOLUTE;

					p += 2;

					break;

				case 'L':

					cmd[e] = VG_LINE_TO | VG_ABSOLUTE;

					p += 2;

					break;

				case 'C':

					cmd[e] = VG_CUBIC_TO | VG_ABSOLUTE;

					p += 6;

					break;

				case 'E':

					cmd[e] = VG_CLOSE_PATH;

					break;

				default:

					assert(0)

					; //unknown command

				}

			c++;

			}

		ps->m_paths[i].m_path = vgCreatePath(

				VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 0, 0,

				(unsigned int) VG_PATH_CAPABILITY_ALL);

		vgAppendPathData(ps->m_paths[i].m_path, elements, cmd, points + startp);

		i++;

		}

	delete[] cmd;

	return ps;

	}

void CTiger::init(NativeWindowType window, CFbsBitmap* aBitmapToDraw)

	{

	static const EGLint s_configAttribs[] =

		{

				EGL_RED_SIZE,

				8,

				EGL_GREEN_SIZE,

				8,

				EGL_BLUE_SIZE,

				8,

				EGL_ALPHA_SIZE,

				8,

				EGL_LUMINANCE_SIZE,

				EGL_DONT_CARE, //EGL_DONT_CARE

				EGL_SURFACE_TYPE,

				EGL_WINDOW_BIT,

				EGL_SAMPLES,

				1,

				EGL_NONE

		};

	EGLint numconfigs;

	iEgldisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);

	eglInitialize(iEgldisplay, NULL, NULL);

	assert(eglGetError() == EGL_SUCCESS);

	eglBindAPI(EGL_OPENVG_API);

	eglChooseConfig(iEgldisplay, s_configAttribs, &iEglconfig, 1, &numconfigs);

	assert(eglGetError() == EGL_SUCCESS);

	assert(numconfigs == 1);

	iEglsurface = eglCreateWindowSurface(iEgldisplay, iEglconfig, window, NULL);

	assert(eglGetError() == EGL_SUCCESS);

	iEglcontext = eglCreateContext(iEgldisplay, iEglconfig, NULL, NULL);

	assert(eglGetError() == EGL_SUCCESS);

	eglMakeCurrent(iEgldisplay, iEglsurface, iEglsurface, iEglcontext);

	assert(eglGetError() == EGL_SUCCESS);

	if (aBitmapToDraw == NULL)//render tiger image

		iTiger = PS_construct(KtigerCommands, KtigerCommandCount, KtigerPoints,

				KtigerPointCount);

	else

		{

		//render bitmap through OpenVG

		CreateImage(aBitmapToDraw);

		}

	}

void CTiger::CreateImage(CFbsBitmap* aBitmapToDraw)

	{

	TUint32* address = aBitmapToDraw->DataAddress();

	TSize sz = aBitmapToDraw->SizeInPixels();

	VGImageFormat dataFormat = VG_sRGB_565;

	VGint width = sz.iWidth;

	VGint height = sz.iHeight;

	VGint dataStride = aBitmapToDraw->DataStride();

	vgSeti(VG_IMAGE_QUALITY, VG_IMAGE_QUALITY_NONANTIALIASED);

	vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_NONANTIALIASED);

	//Create VGImage