#include "common.h"
#include "Material.h"
#include "Texture.h"
#include "glInterface.h"
#include "RenderState.h"


using namespace std;


namespace CHCDemoEngine
{

RgbaColor RandomColor(float a, float b)
{
	return RgbaColor(a + Random(b), a + Random(b), a + Random(b), 1);
}


void Technique::Init()
{
	mTexture = NULL;
	mAlphaTestEnabled = false;
	mCullFaceEnabled = true;
	
	mVertexProgramParameters.Reset();
	mFragmentProgramParameters.Reset();
	
	mVertexProgram = NULL;
	mFragmentProgram = NULL;

	// if this material can write colors
	mColorWriteEnabled = true;
	// if lighting is used
	mLightingEnabled = true;
	/// if depth write should be enabled
	mDepthWriteEnabled = true;

	mRenderQueueBucket = NULL;
}


Technique::Technique():
mAmbientColor(RgbaColor(0.2f, 0.2f, 0.2f, 1.0f)),
mDiffuseColor(RgbaColor(1.0f, 1.0f, 1.0f, 1.0f)),
mSpecularColor(RgbaColor(.0f, .0f, .0f, 1.0f)),
mEmmisiveColor(RgbaColor(.0f, .0f, .0f, 1.0f))
{
	Init();
}


Technique::Technique(const RgbaColor &color):
mDiffuseColor(color),
mAmbientColor(color),
mSpecularColor(0, 0, 0, 1),
mTexture(NULL)
{
	Init();
}

/*
Technique::Technique(const Technique &tech)
{
	mAmbientColor = tech.mAmbientColor;
	mDiffuseColor = tech.mDiffuseColor;
	mSpecularColor = tech.mSpecularColor;
	mEmmisiveColor = tech.mEmmisiveColor;

	mVertexProgram = tech.mVertexProgram;
	mFragmentProgram = tech.mFragmentProgram;

	mAlphaTestEnabled = tech.mAlphaTestEnabled;
	mCullFaceEnabled =tech.mCullFaceEnabled;

	mTexture = tech.mTexture;

	mVertexProgramParameters = tech.mVertexProgramParameters;
	mFragmentProgramParameters = tech.mFragmentProgramParameters;

	mColorWriteEnabled = tech.mColorWriteEnabled;
	mLightingEnabled = tech.mLightingEnabled;
	mDepthWriteEnabled = tech.mDepthWriteEnabled;
}*/


Technique::~Technique()
{
}


void Technique::Render(RenderState *state)
{
	glMaterialfv(GL_FRONT, GL_AMBIENT, (float *)&mAmbientColor.r);
	glMaterialfv(GL_FRONT, GL_DIFFUSE, (float *)&mDiffuseColor.r);
	glMaterialfv(GL_FRONT, GL_EMISSION, (float *)&mEmmisiveColor.r);
	glMaterialfv(GL_FRONT, GL_SPECULAR, (float *)&mSpecularColor.r);

	state->SetState(this);
}


void Technique::SetFragmentProgram(ShaderProgram *p) 
{ 
	mFragmentProgram = p; 

	mFragmentProgramParameters.Reset();
	mFragmentProgramParameters.SetProgram(p);
}
	

void Technique::SetVertexProgram(ShaderProgram *p) 
{ 
	mVertexProgram = p; 

	mVertexProgramParameters.Reset();
	mVertexProgramParameters.SetProgram(p);
}


/***********************************************/
/*        class Material implementation        */
/***********************************************/


void Material::Render(RenderState *state)
{
	mTechniques[state->GetRenderTechnique()]->Render(state);
}


Technique *Material::GetDefaultTechnique() const
{
	return mTechniques[0];
}


Technique *Material::GetTechnique(int i) const
{
	return mTechniques[i];
}


Material::Material()
{
	Technique *tech = new Technique();

	mTechniques.push_back(tech);
}


Material::~Material()
{
	CLEAR_CONTAINER(mTechniques);
}


int Material::GetNumTechniques() const
{
	return (int)mTechniques.size();
}


void Material::AddTechnique(Technique *tech)
{
	mTechniques.push_back(tech);
}


}