diff -r 000000000000 -r 5d03bc08d59c graphicsdeviceinterface/directgdi/test/tdirectgdieglcontent_cube.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graphicsdeviceinterface/directgdi/test/tdirectgdieglcontent_cube.cpp	Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,424 @@
+// 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;
+		}
+	}