// Copyright (c) 2007-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 "tdirectgdieglcontent_cube.h"

 #include "tdisplaymode_mapping.h"

 #include <fbs.h>

 #include <graphics/sgimage_sw.h>

 #include <graphics/fbsdefs.h>

 // CONSTANTS

 /** Camera parameters */

 const TInt KCameraDistance = 100;

 const TReal32 KFrustumLeft = -1.f;	//left vertical clipping plane

 const TReal32 KFrustumRight = 1.f;	//right vertical clipping plane

 const TReal32 KFrustumBottom = -1.f;//bottom horizontal clipping plane

 const TReal32 KFrustumTop = 1.f;	//top horizontal clipping plane

 const TReal32 KFrustumNear = 3.f;	//near depth clipping plane

 const TReal32 KFrustumFar = 1000.f;	//far depth clipping plane

 /* Define vertice coordinates for the cube

    Duplication of vertices needed for texturing every surface of the cube */

 static const GLbyte KVertices[24 * 3] =

 	{

 	/* top */

 	-1,  1,  1,

 	1,  1,  1,

 	1, -1,  1,

 	-1, -1,  1,

 	/* front */

 	1,  1,  1,

 	1,  1, -1,

 	1, -1, -1,

 	1, -1,  1,

 	/* right */

 	-1,  1,  1,

 	-1,  1, -1,

 	1,  1, -1,

 	1,  1,  1,

 	/* left */

 	1, -1,  1,

 	1, -1, -1,

 	-1, -1, -1,

 	-1, -1,  1,

 	/* back */

 	-1, -1,  1,

 	-1, -1, -1,

 	-1,  1, -1,

 	-1,  1,  1,

 	/* bottom */

 	-1,  1, -1,

 	1,  1, -1,

 	1, -1, -1,

 	-1, -1, -1

 	};

 /**

 Indices for drawing the triangles.

 The color of the triangle is determined by 

 the color of the last vertex of the triangle.

 */

 static const GLubyte KTriangles[12 * 3] =

 	{

 	/* top */

 	1,0,3,

 	1,3,2,

 	/* front */

 	5,4,7,

 	5,7,6,

 	/* right */

 	9,8,11,

 	9,11,10,

 	/* left */

 	13,12,15,

 	13,15,14,

 	/* back */

 	17,16,19,

 	17,19,18,

 	/* bottom */

 	21,22,23,

 	21,23,20

 	};

 /* Macro for changing the input texture coordinate values from

    GLubyte [0,255] to GLbyte [-128,127]. See more info below. */

 #define tex(u,v) (GLbyte)( (u) - 128 ) , (GLbyte)( (v) - 128 )

 /* Input texture coordinates for each of the object vertices.

    The coordinates are given in GLbyte [-128,127] format.

    Since the texture picture coordinates are between values

    [0,255] for both width and height, we have defined a macro

    to change the input coordinates into a appropriate form.

    It is easier to think the texture coordinates as corresponding

    image pixel coordinates. This alone is not enough because

    if texture coordinates are not given between values [0,1],

    texture wrapping will occur. Therefore we need to

    scale the texture coordinates with appropriate texture matrix,

    which is defined in AppInit(). */

 static const GLbyte KTexCoords[24 * 2] = 

 	{

 	/* top */

 	tex(0,0), 

 	tex(255,0),

 	tex(255,255), 

 	tex(0,255), 

 	/* front */

 	tex(0,255),

 	tex(127,255),

 	tex(127,127),

 	tex(0,127),

 	/* right */

 	tex(127,255),

 	tex(255,255),

 	tex(255,127),

 	tex(127,127),

 	/* left */

 	tex(0,127),

 	tex(127,127),

 	tex(127,0),

 	tex(0,0),

 	/* back */

 	tex(127,127),

 	tex(255,127),

 	tex(255,0),

 	tex(127,0),

 	/* bottom */

 	tex(255,255),

 	tex(255,0),

 	tex(0,0),

 	tex(0,255)

 	};

 /**

 Static constructor.

 @param aPixelFormat Pixel format of pixmap buffer.

 @param aSize Size of pixmap buffer.

 */

 CGLCube* CGLCube::NewL(TUidPixelFormat aPixelFormat, const TSize& aSize)

 	{

 	CGLCube* self = NewLC(aPixelFormat, aSize);

 	CleanupStack::Pop(self);

 	return self;

 	}

 CGLCube* CGLCube::NewLC(TUidPixelFormat aPixelFormat, const TSize& aSize)

 	{

 	CGLCube* self = new(ELeave) CGLCube();

 	CleanupStack::PushL(self);

 	self->ConstructL(aPixelFormat, aSize);

 	return self;

 	}

 /**

 1st phase constructor

 */

 CGLCube::CGLCube()

 	{

 	}

 /**

 2nd phase constructor

 @param aPixelFormat Pixel format of pixmap buffer.

 @param aSize Size of pixmap buffer.

 */

 void CGLCube::ConstructL(TUidPixelFormat aPixelFormat, const TSize& aSize)

 	{

 	// init graphic environment

 	User::LeaveIfError(SgDriver::Open());

 	FbsStartup();

 	User::LeaveIfError(RFbsSession::Connect());	

 	InitEglL(aPixelFormat, aSize);

 	}

 /**

 Destructor

 */

 CGLCube::~CGLCube()

 	{

 	// deinit gfx environment

 	DeInitEgl();

 	SgDriver::Close();

 	RFbsSession::Disconnect();

 	}

 /**

 Egl environment initialisation for pixmap surface rendering.

 @param aPixelFormat Pixel format of pixmap buffer.

 @param aSize Size of pixmap buffer.

 */

 void CGLCube::InitEglL(TUidPixelFormat aPixelFormat, const TSize& aSize)

 	{

 	// Get the display for drawing graphics

 	iEglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);

 	if(iEglDisplay == NULL)

 		{

 		_LIT(KGetDisplayFailed, "eglGetDisplay failed");

 		User::Panic(KGetDisplayFailed, 0);

 		}

 	// Initialize display

 	if(eglInitialize(iEglDisplay, NULL, NULL) == EGL_FALSE)

 		{

 		_LIT(KInitializeFailed, "eglInitialize failed");

 		User::Panic(KInitializeFailed, 0);

 		}

 	// switch api to GLES

 	eglBindAPI(EGL_OPENGL_ES_API);

 	iImageInfo.iSizeInPixels = aSize;

 	iImageInfo.iPixelFormat =  aPixelFormat;

 	iImageInfo.iCpuAccess = ESgCpuAccessNone;

 	iImageInfo.iUsage = ESgUsageOpenGlesTarget|ESgUsageDirectGdiSource;

 	iImageInfo.iShareable = ETrue;

 	iImageInfo.iScreenId = KSgScreenIdMain;

 	for(TInt i=0; i<KEglContentBuffers; i++)

 		{

 		User::LeaveIfError(iImages[i].Create(iImageInfo, NULL, 0));

 		EGLint numOfConfigs = 0; 

 		// Define properties for the wanted EGLSurface 

 		const EGLint attribList[] =

 			{

 			EGL_MATCH_NATIVE_PIXMAP, (EGLint)&iImages[i],

 			EGL_SURFACE_TYPE, EGL_PIXMAP_BIT,

 			EGL_RENDERABLE_TYPE, EGL_OPENGL_ES_BIT,

 			EGL_NONE

 			};

 		// Choose an EGLConfig that best matches to the properties in attribList

 		if(eglChooseConfig(iEglDisplay, attribList, &iConfig, 1, &numOfConfigs) == EGL_FALSE)

 			{

 			_LIT(KChooseConfigFailed, "eglChooseConfig failed");

 			User::Panic(KChooseConfigFailed, 0);

 			}

 		const EGLint ppixmapAttribs[] = { EGL_NONE };

 		iEglSurfaces[i] = eglCreatePixmapSurface(iEglDisplay, iConfig, &iImages[i], ppixmapAttribs);

 		if(iEglSurfaces[i] == NULL)

 			{

 			_LIT(KCreatePixmapSurfaceFailed, "eglCreatePixmapSurface failed");

 			User::Panic(KCreatePixmapSurfaceFailed, 0);

 			}

 		}

 	iEglContext = eglCreateContext(iEglDisplay, iConfig, EGL_NO_CONTEXT, NULL);

 	if(iEglContext == NULL)

 		{

 		_LIT(KCreateContextFailed, "eglCreateContext failed");

 		User::Panic(KCreateContextFailed, 0);

 		}

 	if(eglMakeCurrent(iEglDisplay, iEglSurfaces[iCurrentImage], iEglSurfaces[iCurrentImage], iEglContext) == EGL_FALSE)

 		{

 		_LIT(KMakeCurrentFailed, "eglMakeCurrent failed");

 		User::Panic(KMakeCurrentFailed, 0);

 		}

 	// Prepare texture map (shaded chessboard)

 	GLubyte* texData = new(ELeave) GLubyte[64*64*4];

 	for(TInt i=0; i<64; i++)

 		{

 		for(TInt j=0; j<64; j++)

 			{

 			if((i&8)^(j&8)) // switch 'white' and 'black' fields

 				{

 				texData[i*64*4+j*4+0] = i*4; // r

 				texData[i*64*4+j*4+1] = j*4; // g

 				texData[i*64*4+j*4+2] = (i+j)*2; // b

 				}

 			else

 				{

 				texData[i*64*4+j*4+0] = 255-i*4; // r

 				texData[i*64*4+j*4+1] = 255-j*4; // g

 				texData[i*64*4+j*4+2] = 255-(i+j)*2; // b

 				}

 			texData[i*64*4+j*4+3] = 255; // alpha

 			}

 		}

 	// Generate texture

 	glEnable(GL_TEXTURE_2D);

 	glGenTextures(1, &iTexId);

 	glBindTexture(GL_TEXTURE_2D, iTexId);

 	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

 	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

 	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, texData);

 	delete [] texData;

 	}

 /**

 Egl environment destroying.

 */

 void CGLCube::DeInitEgl()

 	{

 	glDeleteTextures(1, &iTexId);

 	eglMakeCurrent(iEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);

 	eglDestroyContext(iEglDisplay, iEglContext);

 	for(TInt i=0; i<KEglContentBuffers; i++)

 		{

 		eglDestroySurface(iEglDisplay, iEglSurfaces[i]);

 		iImages[i].Close();

 		}

 	eglTerminate(iEglDisplay);

 	eglReleaseThread();

 	}

 /**

 Render frame of spinning cube.

 @param aFrame Number of frame to render.

 */

 void CGLCube::Render(TInt aFrame)

 	{

 	if(eglMakeCurrent(iEglDisplay, iEglSurfaces[iCurrentImage], iEglSurfaces[iCurrentImage], iEglContext) == EGL_FALSE)

 		{

 		_LIT(KMakeCurrentFailed, "eglMakeCurrent failed");

 		User::Panic(KMakeCurrentFailed, 0);

 		}

 	// Set the screen background color. 

 	glClearColor(0.f, 0.f, 0.f, 1.f);

 	// Enable back face culling, texturing, and normalization.

 	glEnable(GL_CULL_FACE);

 	glEnable(GL_TEXTURE_2D);

 	glEnable(GL_NORMALIZE);

 	// Initialize viewport and projection. 

 	glViewport(0, 0, iImageInfo.iSizeInPixels.iWidth, iImageInfo.iSizeInPixels.iHeight);

 	// Calculate the view frustrum

 	GLfloat aspectRatio = (GLfloat)(iImageInfo.iSizeInPixels.iWidth) / (GLfloat)(iImageInfo.iSizeInPixels.iHeight);

 	glMatrixMode(GL_PROJECTION);

 	glLoadIdentity();

 	glFrustumf(KFrustumLeft * aspectRatio, KFrustumRight * aspectRatio,

 			KFrustumBottom, KFrustumTop,

 			KFrustumNear, KFrustumFar);

 	/* Initialize appropriate texture matrix. First we have to translate the

        input texture coordinate values to be within a range of [0,255]. Hence

        we translate the x- and y-coordinate values by 128. Recall that the 

        values in nokTexCoords are between [-128,127], now they are in a range 

        of [0,255]. After that we scale the values by 1/255 to make the values 

        to be in range [0,1]. */

 	glMatrixMode(GL_TEXTURE);

 	glLoadIdentity();

 	glScalef(1.0f/255.0f, 1.0f/255.0f, 1.0f);

 	glTranslatef(128.0f, 128.0f, 0.0f);

 	// Remember to change the matrix mode to modelview.

 	glMatrixMode(GL_MODELVIEW);

 	// Enable vertex and texture arrays.

 	glEnableClientState(GL_VERTEX_ARRAY);

 	glEnableClientState(GL_TEXTURE_COORD_ARRAY);

 	// Set array pointers. 

 	glVertexPointer(3, GL_BYTE, 0, KVertices);

 	glTexCoordPointer(2, GL_BYTE, 0, KTexCoords);

 	// Set the initial shading mode 

 	glShadeModel(GL_FLAT);

 	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_DONT_CARE);

 	glClear(GL_COLOR_BUFFER_BIT);

 	// Animate and draw box 

 	glLoadIdentity();

 	glTranslatex(0 , 0 , -KCameraDistance << 16);

 	glRotatex(aFrame << 18, 1 << 16,    0   ,    0   );

 	glRotatex(aFrame << 17,    0   , 1 << 16,    0   );

 	glRotatex(aFrame << 16,    0   ,    0   , 1 << 16);

 	glScalex(20 << 16, 20 << 16, 20 << 16);

 	glBindTexture(GL_TEXTURE_2D, iTexId);

 	glDrawElements(GL_TRIANGLES, 12 * 3, GL_UNSIGNED_BYTE, KTriangles);

 	iLastImage = iCurrentImage;

 	}

 /**

 Get image id of current frame. Current image to render is switch to next.

 @param aId Reference to drawable id class to store image id.

 */

 void CGLCube::GetImage(TSgDrawableId& aId)

 	{

 	// finish rendering

 	glFinish();

 	aId = iImages[iLastImage].Id();

 	// switch to next buffer to prevent overdraw of image by asynchronous rendering

 	if(iLastImage == iCurrentImage)

 		{

 		iCurrentImage = (iCurrentImage+1)%KEglContentBuffers;

 		}

 	}