/*
* Copyright (c) 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: 
*
*/

#ifndef VARIABLE_H
#define VARIABLE_H

#include <string>
#include "Util.h"
#include "GLState.h"

using namespace std;

namespace shadergen
{




class Variable
{
public:

	/* Variable class */
	typedef enum Class
	    {
		CLASS_UNIFORM = 0,
		CLASS_ATTRIBUTE,
		CLASS_VARYING,

		CLASS_MAX
	    } Class;

	/* Variable precision */
	typedef enum Precision
	    {
		PRECISION_LOW = 0,
		PRECISION_MEDIUM,
		PRECISION_HIGH,

		PRECISION_MAX
	    } Precision;

	/* Variable type */
	typedef enum Type
	    {
		TYPE_FLOAT = 0,
		TYPE_VEC2,
		TYPE_VEC3,
		TYPE_VEC4,

		TYPE_INT,
		TYPE_IVEC2,
		TYPE_IVEC3,
		TYPE_IVEC4,

		TYPE_MAT2,
		TYPE_MAT3,
		TYPE_MAT4,

		TYPE_SAMPLER,

		TYPE_MAX
	    } Type;

	/* variable data's type tag --- an ugly hack for now */
	typedef enum Tag
	    {
		DATAPTR = 0,
		DATAPTRPTR,
		TEXTUREUNIT
	    } Tag;

	union variableData 
	    {
		const void *		dataPtr;
		const void * const *	dataPtrPtr;
		int			textureUnit;

		variableData(const void *dataPointer) 
		    {
			dataPtr = dataPointer;
		    }

		variableData(const void * const *dataPointerPointer) 
		    {
			dataPtrPtr = dataPointerPointer;
		    }

		variableData(int unit) 
		    { 
		    textureUnit = unit; 
		    }
	};



	Variable (const Class vclass,
		const char* name,
		const Type type,
		const GLenum format,
		int dim,
		const Precision precision,
		const void* dataPtr)
		: m_class(vclass),
		m_name(name),
		m_type(type),
		m_format(format),
		m_dimension(dim),
		m_precision(precision),
		m_tag(DATAPTR),
		m_variableData(dataPtr),
		m_location(0)
	{
		SG_ASSERT(type != TYPE_SAMPLER);
		SG_ASSERT(format == GL_BYTE			||
			      format == GL_UNSIGNED_BYTE	||
			      format == GL_SHORT			||
			      format == GL_UNSIGNED_SHORT	||
			      format == GL_INT		||
			      format == GL_FLOAT			||
			      format == GL_FIXED);
//		SG_ASSERT((vclass != CLASS_VARYING) == (funcPtr != NULL));
	}


	Variable (const Class vclass,
		const char* name,
		const Type type,
		const GLenum format,
		int dim,
		const Precision precision,
		const void* const* dataPtrPtr)
		: m_class(vclass),
		m_name(name),
		m_type(type),
		m_format(format),
		m_dimension(dim),
		m_precision(precision),
		m_tag(DATAPTRPTR),
		m_variableData(dataPtrPtr),
		m_location(0)
	{
		SG_ASSERT(type != TYPE_SAMPLER);
		SG_ASSERT(format == GL_BYTE			||
			   format == GL_UNSIGNED_BYTE	||
			   format == GL_SHORT			||
			   format == GL_UNSIGNED_SHORT	||
			   format == GL_INT		||
			   format == GL_FLOAT			||
			   format == GL_FIXED);
//		SG_ASSERT((vclass != CLASS_VARYING) == (funcPtr != NULL));
	}



	Variable (const Class vclass,
		const char* name,
		const Type type,
		const GLenum format,
		int dim,
		const Precision precision,
		int textureUnit)
		: m_class(vclass),
		m_name(name),
		m_type(type),
		m_format(format),
		m_dimension(dim),
		m_precision(precision),
		m_tag(TEXTUREUNIT),
		m_variableData(textureUnit),
		m_location(0)
	{
		SG_ASSERT((type == TYPE_SAMPLER) && (format == GL_INT) ||
		          (vclass == CLASS_VARYING && textureUnit == 0));
	}



	string getDeclaration (void) const
	{
		string decl = classToStr() + " " + precisionToStr() + " " + typeToStr() + " " + m_name;

		if (m_dimension != 1)
		{
			SG_ASSERT(SG_IN_RANGE<int>(m_dimension, 1, 9));
			decl += "[";
			decl += (char)('0' + m_dimension);
			decl += "]";
		}

		decl += ";\n";
		return decl;
	}

	const string& getName (void) const
	{
		return m_name;
	}

	Class getClass (void) const
	{
		return m_class;
	}

	Type getType (void) const
	{
		return m_type;
	}

	GLenum getFormat (void) const
	{
		return m_format;
	}

	int getDimension (void) const
	{
		return m_dimension;
	}

	Precision getPrecision (void) const
	{
		return m_precision;
	}

	const void* getPtr(void) const
	{
		switch(m_tag) {
			case DATAPTR : 
				return m_variableData.dataPtr;

			case DATAPTRPTR :
				return *m_variableData.dataPtrPtr;

			case TEXTUREUNIT : 
				return (void *)(&m_variableData.textureUnit);

			default : 
				SG_ASSERT(0);
		}
		return NULL;
	}

    void setLocation(int location)
        {
        m_location = location;
        }

    int location(void) const
        {
        return m_location;
        }

private:

	string typeToStr (void) const
	{
		const char* s_typeStr[] =
		{
			"float",	// TYPE_FLOAT = 0,
			"vec2",		// TYPE_VEC2,
			"vec3",		// TYPE_VEC3,
			"vec4",		// TYPE_VEC4,

			"int",		// TYPE_INT,
			"ivec2",	// TYPE_IVEC2,
			"ivec3",	// TYPE_IVEC3,
			"ivec4",	// TYPE_IVEC4,

			"mat2",		// TYPE_MAT2,
			"mat3",		// TYPE_MAT3,
			"mat4",		// TYPE_MAT4,

			"sampler2D"	// TYPE_SAMPLER
		};

		SG_CT_ASSERT(SG_LENGTH_OF_ARRAY(s_typeStr) == TYPE_MAX);
		return s_typeStr[m_type];
	}

	string classToStr (void) const
	{
		const char* s_classStr[] =
		{
			"uniform",		// CLASS_UNIFORM = 0
			"attribute",		// CLASS_ATTRIBUTE,
			"varying"		// CLASS_VARYING,
		};

		SG_CT_ASSERT(SG_LENGTH_OF_ARRAY(s_classStr) == CLASS_MAX);
		return s_classStr[m_class];
	}

	string precisionToStr (void) const
	{
		const char* s_precStr[] =
		{
			"lowp",		// PRECISION_LOW = 0
			"mediump",	// PRECISION_MEDIUM,
			"highp"		// PRECISION_HIGH,
		};

		SG_CT_ASSERT(SG_LENGTH_OF_ARRAY(s_precStr) == PRECISION_MAX);
		return s_precStr[m_precision];
	}

   

	Class		m_class;
	string		m_name;
	Type		m_type;
	GLenum		m_format;
	int		m_dimension;
	Precision	m_precision;
	Tag		m_tag;
	variableData	m_variableData;
    int m_location;
};

}

#endif /* VARIABLE_H */