--- /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;
+ }
+ }