#include "ShaderProgram.h"
#include "Matrix4x4.h"


using namespace std;

namespace CHCDemoEngine 
{ 


GPUProgramParameters::GPUProgramParameters(ShaderProgram *p)
: mProgram(p)
{
}

void GPUProgramParameters::SetValue1f(int idx, float value)
{
}


void GPUProgramParameters::SetValue2f(int idx, float val1, float val2)
{
}


void GPUProgramParameters::SetValue3f(int idx, float val1, float val, float val3)
{
}


void GPUProgramParameters::SetArray1f(int idx, float *vals, int numElements)
{
}


void GPUProgramParameters::SetArray2f(int idx, float *vals, int numElements)
{
}


void GPUProgramParameters::SetArray3f(int idx, float *vals, int numElements)
{
}


void GPUProgramParameters::SetTexture(int idx, unsigned int tex)
{
	mTextures.push_back(IntParam(idx, tex));
}


void GPUProgramParameters::SetMatrix(int idx, Matrix4x4 *mat)
{
}


void GPUProgramParameters::SetValue1f(const string &name, float val)
{
	SetValue1f(mProgram->GetParamIdxByName(name), val);
}


void GPUProgramParameters::SetValue2f(const string &name, float val1, float val2)
{
	SetValue2f(mProgram->GetParamIdxByName(name), val1, val2);
}


void GPUProgramParameters::SetValue3f(const string &name, float val1, float val2, float val3)
{
	SetValue3f(mProgram->GetParamIdxByName(name), val1, val2, val3);
}


void GPUProgramParameters::SetArray1f(const string &name, float *vals, int numElements)
{
	SetArray1f(mProgram->GetParamIdxByName(name), vals, numElements);
}


void GPUProgramParameters::SetArray2f(const string &name, float *vals, int numElements)
{
	SetArray2f(mProgram->GetParamIdxByName(name), vals, numElements);
}


void GPUProgramParameters::SetArray3f(const string &name, float *vals, int numElements)
{
	SetArray3f(mProgram->GetParamIdxByName(name), vals, numElements);
}


void GPUProgramParameters::SetMatrix(const string &name, Matrix4x4 *mat)
{
	SetMatrix(mProgram->GetParamIdxByName(name), mat);
}


void GPUProgramParameters::SetTexture(const string &name, unsigned int tex)
{
	SetTexture(mProgram->GetParamIdxByName(name), tex);
}


void GPUProgramParameters::UpdateParameters()
{
	for (size_t i = 0; i < mFloats.size(); ++ i)
	{
		const FloatParam &p = mFloats[i];

		switch (p.mNumComponents)
		{
		case 1:
			mProgram->SetValue1f(p.mIndex, p.mValues[0]);
			break;
		case 2:
			mProgram->SetValue2f(p.mIndex, p.mValues[0], p.mValues[1]);
			break;
		case 3:
			mProgram->SetValue3f(p.mIndex, p.mValues[0], p.mValues[1], p.mValues[2]);
			break;
		default:
			mProgram->SetValue1f(p.mIndex, p.mValues[0]);
		}
	}

	for (size_t i = 0; i < mTextures.size(); ++ i)
	{
		const IntParam &p = mTextures[i];
		mProgram->SetTexture(p.mIndex, p.mValue);
	}

	for (size_t i = 0; i < mMatrices.size(); ++ i)
	{
		const MatrixParam &p = mMatrices[i];
		mProgram->SetMatrix(p.mIndex, *p.mValue);
	}
}



/********************************************************/
/*             ShaderProgram implementation             */
/********************************************************/


ShaderProgram::ShaderProgram(CGcontext context, 
							 const std::string &filename, 
							 CGprofile profile,
							 const std::string &functionName)
{
	mProgram = cgCreateProgramFromFile(context, 
		                               CG_SOURCE,
									   filename.c_str(), 
									   profile,
									   functionName.c_str(),
									   NULL);

	if (mProgram) cgGLLoadProgram(mProgram);

	const int maxParams = 64;
	mParameters.resize(maxParams);

	for (int i = 0; i < maxParams; ++ i)
	{
		mParameters[i] = NULL;
	}
}


void ShaderProgram::Bind()
{
	cgGLBindProgram(mProgram);

	// enable all texture parameters
	CGParameterArray::const_iterator it, it_end = mTextureParams.end();

	for (it = mTextureParams.begin(); it != it_end; ++ it) 
		cgGLEnableTextureParameter(*it);
}


/*void ShaderProgram::Release()
{
	CGParameterArray::const_iterator it, it_end = mTextureParams.end();

	// disable all texture parameters
	for (it = mTextureParams.begin(); it != it_end; ++ it)
		cgGLDisableTextureParameter(*it);
}*/


CGparameter ShaderProgram::AddParameter(const string &name, int idx)
{
	CGparameter p = GetOrCreateParameter(name);

	mParamHash[name] = idx;
	mParameters[idx] = p;

	return p;
}


CGparameter ShaderProgram::GetOrCreateParameter(const string &name)
{
	CGparameter p;
	CGParameterMap::const_iterator it = mParamHash.find(name);

	if (it == mParamHash.end())
	{
		p = cgGetNamedParameter(mProgram, name.c_str());
	}
	else
	{
		p = mParameters[(*it).second];
	}

	//cout << "name: " << name << " " << p << " " << mProgram << endl;
	return p;
}


CGparameter ShaderProgram::GetParameter(int idx) const
{
	return mParameters[idx];
}


void ShaderProgram::SetValue1f(int idx, float val)
{
	cgGLSetParameter1f(GetParameter(idx), val);
}


void ShaderProgram::SetValue2f(int idx, float val1, float val2)
{
	cgGLSetParameter2f(GetParameter(idx), val1, val2);
}


void ShaderProgram::SetValue3f(int idx, float val1, float val2, float val3)
{
	cgGLSetParameter3f(GetParameter(idx), val1, val2, val3);
}


void ShaderProgram::SetArray1f(int idx, float *vals, int numElements)
{
	cgGLSetParameterArray1f(GetParameter(idx), 0, numElements, (const float *)vals);
}


void ShaderProgram::SetArray2f(int idx, float *vals, int numElements)
{
	cgGLSetParameterArray2f(GetParameter(idx), 0, numElements, (const float *)vals);
}


void ShaderProgram::SetArray3f(int idx, float *vals, int numElements)
{
	cgGLSetParameterArray3f(GetParameter(idx), 0, numElements, (const float *)vals);
}


void ShaderProgram::SetMatrix(int idx, const Matrix4x4 &mat)
{
	cgGLSetMatrixParameterfc(GetParameter(idx), (const float *)mat.x);
}


void ShaderProgram::SetTexture(int idx, unsigned int tex)
{
	CGparameter p = GetParameter(idx);

	cgGLSetTextureParameter(p, tex);
	cgGLEnableTextureParameter(p);
}


void ShaderProgram::SetValue1f(const string &name, float val)
{
	cgGLSetParameter1f(GetOrCreateParameter(name), val);
}


void ShaderProgram::SetValue2f(const string &name, float val1, float val2)
{
	cgGLSetParameter2f(GetOrCreateParameter(name), val1, val2);
}


void ShaderProgram::SetValue3f(const string &name, float val1, float val2, float val3)
{
	cgGLSetParameter3f(GetOrCreateParameter(name), val1, val2, val3);
}


void ShaderProgram::SetArray1f(const string &name, float *vals, int numElements)
{
	cgGLSetParameterArray1f(GetOrCreateParameter(name), 0, numElements, (const float *)vals);
}


void ShaderProgram::SetArray2f(const string &name, float *vals, int numElements)
{
	cgGLSetParameterArray2f(GetOrCreateParameter(name), 0, numElements, (const float *)vals);
}


void ShaderProgram::SetArray3f(const string &name, float *vals, int numElements)
{
	cgGLSetParameterArray3f(GetOrCreateParameter(name), 0, numElements, (const float *)vals);
}


void ShaderProgram::SetMatrix(const string &name, const Matrix4x4 &mat)
{
	cgGLSetMatrixParameterfc(GetOrCreateParameter(name), (const float *)mat.x);
}


void ShaderProgram::SetTexture(const string &name, unsigned int tex)
{
	CGparameter p = GetOrCreateParameter(name);

	cgGLSetTextureParameter(p, tex);
	cgGLEnableTextureParameter(p);

	mTextureParams.push_back(p);
}


int ShaderProgram::GetParamIdxByName(const std::string &name) const
{
	CGParameterMap::const_iterator it = mParamHash.find(name);
	return (*it).second;
}


} // namespace