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

_LIT(KGLES1CubeName, "gles1cube");

CEGLRendering* CGLES1Cube::NewL(RWindow& aWindow)

    {

    CGLES1Cube* self = new (ELeave) CGLES1Cube(aWindow);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

const TDesC& CGLES1Cube::Name()

	{

	return KGLES1CubeName;

	}

CGLES1Cube::CGLES1Cube(RWindow& aWindow)

    :   CEGLRendering(aWindow, EGL_OPENGL_ES_API)

    {

    }

CGLES1Cube::~CGLES1Cube()

	{

	RDebug::Printf("[EBT] CGLES1Cube::~CGLES1Cube");

	glDeleteBuffers(1, &iCoordinateColorBuffer);

	glDeleteBuffers(1, &iIndexBuffer);

	}

/*

    v6----- v4

   /|      /|

  v0------v2|

  | |     | |

  | |v7---|-|v5

  |/      |/

  v1------v3

v0: -1.0, +1.0, +1.0,

v1: -1.0, -1.0, +1.0,

v2: +1.0, +1.0, +1.0,

v3: +1.0, -1.0, +1.0,

v4: +1.0, +1.0, -1.0,

v5: +1.0, -1.0, -1.0,

v6: -1.0, +1.0, -1.0,

v7: -1.0, -1.0, -1.0,

*/

static GLfloat CoordinateData[] =

	{

	-1.0, +1.0, +1.0,	// v0

	-1.0, -1.0, +1.0,	// v1

	+1.0, +1.0, +1.0,	// v2

	+1.0, -1.0, +1.0,	// v3

	+1.0, +1.0, -1.0,	// v4

	+1.0, -1.0, -1.0,	// v5

	-1.0, +1.0, -1.0,	// v6

	-1.0, -1.0, -1.0	// v7

	};

static const TInt CoordinateElementCount = 3; // XYZ

static GLfloat ColorData[] =

	{

	 0.0,  1.0,  1.0,  1.0,	// v0

	 0.0,  0.0,  1.0,  1.0,	// v1

	 1.0,  1.0,  1.0,  1.0,	// v2

	 1.0,  0.0,  1.0,  1.0,	// v3

	 1.0,  1.0,  0.0,  1.0,	// v4

	 1.0,  0.0,  0.0,  1.0,	// v5

	 0.0,  1.0,  0.0,  1.0,	// v6

	 0.0,  0.0,  0.0,  1.0	// v7

	};

static const TInt ColorElementCount = 4; // RGBA

static GLubyte FaceData[] =

	{

	0, 1, 3, 2, // front

	2, 3, 5, 4, // right

	4, 5, 7, 6, // left

	6, 7, 1, 0, // back

	6, 0, 2, 4, // top

	1, 7, 5, 3

	};

static const TInt VerticesPerFace = 4;

static const TInt VertexCount = sizeof(FaceData) / sizeof(GLubyte);

static const TInt FaceCount = VertexCount / VerticesPerFace;

static const TInt TrianglesPerFace = 2;

static const TInt VerticesPerTriangle = 3;

static const TInt IndexCount = FaceCount * TrianglesPerFace * VerticesPerTriangle;

static GLubyte FaceIndexData[] =

	{

	0, 2, 1,

	0, 3, 2

	};

void CGLES1Cube::KhrSetup()

    {

	RDebug::Printf("[EBT] CGLES1Cube::KhrSetup");

	RDebug::Printf("[EBT] CGLES1Cube::KhrSetup vertexCount %d", VertexCount);

	RDebug::Printf("[EBT] CGLES1Cube::KhrSetup faceCount %d", FaceCount);

	RDebug::Printf("[EBT] CGLES1Cube::KhrSetup indexCount %d", IndexCount);

	const GLsizeiptr coordinateSize = CoordinateElementCount * sizeof(GLfloat);

	const GLsizeiptr coordinateDataSize = VertexCount * coordinateSize;

	const GLsizeiptr colorSize = ColorElementCount * sizeof(GLfloat);

	const GLsizeiptr colorDataSize = VertexCount * colorSize;

	RDebug::Printf("[EBT] CGLES1Cube::KhrSetup glViewport %d x %d", WindowSize().iWidth, WindowSize().iHeight);

	glViewport(0, 0, WindowSize().iWidth, WindowSize().iHeight);

	GLCheckError();

	glEnable(GL_DEPTH_TEST);

	glEnable(GL_CULL_FACE);

	glClearColor(0.0f, 0.0f, 0.0f, 0.5f);

	// Create coordinate/color buffer

	RDebug::Printf("[EBT] CGLES1Cube::KhrSetup glGenBuffers vertex/color");

	glGenBuffers(1, &iCoordinateColorBuffer);

	GLCheckError();

	RDebug::Printf("[EBT] CGLES1Cube::KhrSetup glBindBuffer vertex/color");

	glBindBuffer(GL_ARRAY_BUFFER, iCoordinateColorBuffer);

	GLCheckError();

	// Allocate memory for coordinate/color buffer

	RDebug::Printf("[EBT] CGLES1Cube::KhrSetup glBufferData coordinate/color");

	glBufferData(GL_ARRAY_BUFFER, coordinateDataSize + colorDataSize, 0, GL_STATIC_DRAW);

	GLCheckError();

	// Upload coordinate/color data

	RDebug::Printf("[EBT] CGLES1Cube::KhrSetup supply coordinate/color data");

	GLubyte indexData[IndexCount];

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

		{

		RDebug::Printf("[EBT] CGLES1Cube::KhrSetup face %d", i);

		// Upload coordinate/color data for this face

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

			{

			const TInt vertexIndex = FaceData[i * VerticesPerFace + j];

			const TInt destIndex = (i * VerticesPerFace) + j;

			const GLfloat *coordSrc = CoordinateData + vertexIndex * CoordinateElementCount;

			const TInt coordDest = destIndex * coordinateSize;

			const GLfloat *colorSrc = ColorData + vertexIndex * ColorElementCount;

			const TInt colorDest = coordinateDataSize + destIndex * colorSize;

			RDebug::Printf("[EBT] CGLES1Cube::KhrSetup vertex %d (%d) destIndex %d coordDest %d colorDest %d",

					       j, vertexIndex, destIndex, coordDest, colorDest);

			RDebug::Printf("[EBT] CGLES1Cube::KhrSetup coord %3.1f %3.1f %3.1f",

						   *(coordSrc), *(coordSrc + 1), *(coordSrc + 2));

			RDebug::Printf("[EBT] CGLES1Cube::KhrSetup color %3.1f %3.1f %3.1f",

						   *(colorSrc), *(colorSrc + 1), *(colorSrc + 2));

			glBufferSubData(GL_ARRAY_BUFFER, coordDest, coordinateSize, coordSrc);

			GLCheckError();

			glBufferSubData(GL_ARRAY_BUFFER, colorDest, colorSize, colorSrc);

			GLCheckError();

			}

		// Store vertex indices for this face

		TInt indexDataOffset = i * TrianglesPerFace * VerticesPerTriangle;

		TInt indexBase = i * VerticesPerFace;

		for (TInt j=0; j<TrianglesPerFace * VerticesPerTriangle; ++j)

			{

			RDebug::Printf("[EBT] CGLES1Cube::KhrSetup index %d offset %d value %d",

						   j, indexDataOffset, indexBase + FaceIndexData[j]);

			indexData[indexDataOffset++] = indexBase + FaceIndexData[j];

			}

		}

	// Tell GL engine how to unpack coordinate/color buffer

	RDebug::Printf("[EBT] CGLES1Cube::KhrSetup glVertexPointer");

	glVertexPointer(CoordinateElementCount, GL_FLOAT, 0, 0);

	GLCheckError();

	RDebug::Printf("[EBT] CGLES1Cube::KhrSetup glColorPointer");

	glColorPointer(ColorElementCount, GL_FLOAT, 0, reinterpret_cast<GLvoid*>(coordinateDataSize));

	GLCheckError();

	// Create index buffer

	RDebug::Printf("[EBT] CGLES1Cube::KhrSetup glGenBuffers index");

	glGenBuffers(1, &iIndexBuffer);

	GLCheckError();

	RDebug::Printf("[EBT] CGLES1Cube::KhrSetup glBindBuffer index");

	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, iIndexBuffer);

	GLCheckError();

	// Allocate memory for index buffer and upload index data

	RDebug::Printf("[EBT] CGLES1Cube::KhrSetup glBufferData index");

	glBufferData(GL_ELEMENT_ARRAY_BUFFER, IndexCount, indexData, GL_STATIC_DRAW);

	GLCheckError();

	glEnableClientState(GL_VERTEX_ARRAY);

	GLCheckError();

	glEnableClientState(GL_COLOR_ARRAY);

	GLCheckError();

	StartRedrawTimer();

    }

void CGLES1Cube::KhrPaint()

	{

	RDebug::Printf("[EBT] CGLES1Cube::KhrPaint");

	glLoadIdentity();

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	glMatrixMode(GL_PROJECTION);

	glLoadIdentity();

	glOrthof(-1.5f, 1.5f, -2.5f, 2.5f, -10.5f, 10.5f);

	glMatrixMode(GL_MODELVIEW);

	iAngle = (iAngle + 1.0f);

	if (iAngle > 360.0f)

		{

		iAngle -= 360.0f;

		}

	glRotatef(iAngle, 0.0f, 1.0f, 0.5f);

	glDrawElements(GL_TRIANGLES, IndexCount, GL_UNSIGNED_BYTE, 0);

    }