source: GTP/trunk/App/Demos/Vis/FriendlyCulling/src/Material.cpp @ 3054

#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);
}


}