////////////////////////////// Shader.h
///////////////////////////////////////
///////////////////////////////////////
 
#ifndef SHADER_H
#define SHADER_H
 
// CG Shader headers
//--------------------------------------------------------------------------
#include <cg\cg.h>
#include <cg\cggl.h>
 
// CG Values of detail levels
//--------------------------------------------------------------------------
namespace VALUE{
	enum ShaderDetail{
		SHADER_DETAIL_NOSHADERS, SHADER_DETAIL_LOW, SHADER_DETAIL_MEDIUM, SHADER_DETAIL_HIGH
	};
	enum BumpDetail{
		BUMP_NOBUMPS, BUMP_SIMPLEBUMP, BUMP_NORMALMAP, BUMP_NORMALMAP_SPECULAR
	};
	enum ShadowDetail{
		SHADOW_NOSHADOWS, SHADOW_SIMPLE, SHADOW_COMPLEX, SHADOW_COMPLEX_SOFT
	};
	enum HighDynamicRangeLighting{
		HIGH_DYNAMIC_RANGE_LIGHTING_OFF, HIGH_DYNAMIC_RANGE_LIGHTING_ON
	};
};
 
// shader management
//--------------------------------------------------------------------------
int initShaders(void);
int deInitShaders(void);
int shadersSetModelAndProjectionStates(void);
 
class Shaders_Wave{
public:
	Shaders_Wave(void);
	int Begin(void);
	void setWaveParameter(float waveMovement);
	int End(void);
	void setModelViewMatrix(void);
private:
	// wave program
	//--------------------------------------------------------------------------
	CGprogram	cgVertexWaveProgram;
	// wave parameters
	//--------------------------------------------------------------------------
	CGparameter position, color, modelViewMatrix, wave;
};
 
class Shaders_Bump{
public:
	Shaders_Bump(void);
	int Begin(void);
	int End(void);
	void setModelViewMatrix(void);
private:
	// bump programs
	//--------------------------------------------------------------------------
	CGprogram	cgVertexBumpProgram;
	CGprogram	cgFragmentBumpProgram;
	// bump parameters
	CGparameter lightPos,		// float3
		eyePos,					// float3
		ModelViewProjMatrix,	// float4x4
		normalMap,				// sampler2d
		normalizeCube;			// samplerCUBE
};
 
class Shaders_Shadow{
public:
	Shaders_Shadow(void);
	int Begin(void);
	int End(void);
	void setModelViewMatrix(void);
private:
	// cg shadow programs
	//--------------------------------------------------------------------------
	CGprogram	cgVertexShadowProgram;
	CGprogram	cgFragmentShadowProgram;
	// bump parameters
	CGparameter lightPos,		// float3
		textureMatrix,			// float4x4
		ModelViewProjMatrix,	// float4x4
		shadowMap;				// sampler2d
};
#endif
 
////////////////////////////// Shader.cpp
/////////////////////////////////////////
/////////////////////////////////////////
#include "shader.h"
 
// shader detail level storage
//--------------------------------------------------------------------------
int shaderDetail;
int bumpDetail;
int shadowDetail;
bool initDone = false;
 
// shader profiles
//--------------------------------------------------------------------------
extern CGprofile cgVertexProfile;
extern CGprofile cgFragmentProfile;
 
// shader context
//--------------------------------------------------------------------------
extern CGcontext	cgContext;
 
int initShaders(void){
	shaderDetail	  = VALUE::SHADER_DETAIL_HIGH;
	bumpDetail		  = VALUE::BUMP_NORMALMAP;
	shadowDetail	  = VALUE::SHADOW_COMPLEX;
	cgVertexProfile   = CG_PROFILE_ARBVP1;
	cgFragmentProfile = CG_PROFILE_ARBFP1;
 
	// Setup Cg
	//--------------------------------------------------------------------------
	cgContext = cgCreateContext();	// Create A New Context For Our Cg Program(s)
 
	// Setup Profiles
	//--------------------------------------------------------------------------
	cgVertexProfile		=	cgGLGetLatestProfile(CG_GL_VERTEX);
		cgGLSetOptimalOptions(cgVertexProfile);
		if (cgVertexProfile ==	CG_PROFILE_UNKNOWN){
			return(false);
		}
 
	cgFragmentProfile	=	cgGLGetLatestProfile(CG_GL_FRAGMENT);
		cgGLSetOptimalOptions(cgFragmentProfile);
		if (cgFragmentProfile == CG_PROFILE_UNKNOWN){
			return(false);
		}
 
	if (cgContext == NULL){
		return(false);
	}
 
	return(true);
}
 
int deInitShaders(void){
	cgDestroyContext(cgContext);
	return 0;
}
Shaders_Wave::Shaders_Wave(void){
	if (!initDone){
		initShaders();
		initDone = true;
	}
	// vertex wave program
	//--------------------------------------------------------------------------
	cgGLSetOptimalOptions(cgVertexProfile);		// Set The Current Profile
	cgVertexWaveProgram = cgCreateProgramFromFile(cgContext, CG_SOURCE, "src/cg/vWave.cg", cgVertexProfile, "main", 0);
	if (cgVertexWaveProgram == NULL){
		int i = 3;
	}
	cgGLLoadProgram(cgVertexWaveProgram);
	position		= cgGetNamedParameter(cgVertexWaveProgram, "IN.position");
	color			= cgGetNamedParameter(cgVertexWaveProgram, "IN.color");
	wave			= cgGetNamedParameter(cgVertexWaveProgram, "IN.wave");
	modelViewMatrix	= cgGetNamedParameter(cgVertexWaveProgram, "ModelViewProj");
}
 
int Shaders_Wave::Begin(void){
	if (shaderDetail == VALUE::SHADER_DETAIL_HIGH){
		cgGLEnableProfile(cgVertexProfile);	
		cgGLBindProgram(cgVertexWaveProgram);
		cgGLSetParameter4f(color, 1.0f, 1.0f, 1.0f, 1.0f);
	}
	return 0;
}
 
void Shaders_Wave::setWaveParameter(float waveMovement){
	cgGLSetParameter3f(wave, waveMovement, 1.0f, 1.0f);
}
 
int Shaders_Wave::End(void){
	if (shaderDetail == VALUE::SHADER_DETAIL_HIGH){
		cgGLDisableProfile(cgVertexProfile);							// Disable Our Vertex Profile
	}
	return 0;
}
 
void Shaders_Wave::setModelViewMatrix(void){
	cgGLSetStateMatrixParameter(modelViewMatrix, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
}
Shaders_Bump::Shaders_Bump(void){
	if (!initDone){
		initShaders();
		initDone = true;
	}
	// vertex bump program
	//--------------------------------------------------------------------------
	cgGLSetOptimalOptions(cgVertexProfile);
	cgVertexBumpProgram = cgCreateProgramFromFile(cgContext, CG_SOURCE, "src/cg/vBump.cg", cgVertexProfile, "main", 0);
	if (cgVertexBumpProgram == NULL){
		int i = 3;
	}
	cgGLLoadProgram(cgVertexBumpProgram);
	lightPos			= cgGetNamedParameter(cgVertexBumpProgram, "lightPosition");
	eyePos				= cgGetNamedParameter(cgVertexBumpProgram, "eyePosition");
	ModelViewProjMatrix	= cgGetNamedParameter(cgVertexBumpProgram, "modelViewProj");
 
	// fragment bump program
	//--------------------------------------------------------------------------
	cgGLSetOptimalOptions(cgFragmentProfile);
	cgFragmentBumpProgram = cgCreateProgramFromFile(cgContext, CG_SOURCE, "src/cg/fBump.cg", cgFragmentProfile, "main", 0);
	if (cgFragmentBumpProgram == NULL){
		int i = 3;
	}
	cgGLLoadProgram(cgFragmentBumpProgram);
	normalMap			= cgGetNamedParameter(cgFragmentBumpProgram, "normalMap");
	normalizeCube		= cgGetNamedParameter(cgFragmentBumpProgram, "normalizeCube");
}
 
int Shaders_Bump::Begin(void){
	if (shaderDetail == VALUE::SHADER_DETAIL_HIGH){
		cgGLEnableProfile(cgVertexProfile);
		cgGLBindProgram(cgVertexBumpProgram);
		// static params here.
		cgGLEnableProfile(cgFragmentProfile);
		cgGLBindProgram(cgFragmentBumpProgram);
		// and more here.
	}
	return 0;
}
 
int Shaders_Bump::End(void){
	if (shaderDetail == VALUE::SHADER_DETAIL_HIGH){
		cgGLDisableProfile(cgVertexProfile);
		cgGLDisableProfile(cgFragmentProfile);
	}
	return 0;
}
 
void Shaders_Bump::setModelViewMatrix(void){
	cgGLSetStateMatrixParameter(ModelViewProjMatrix, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
}
Shaders_Shadow::Shaders_Shadow(void){
	if (!initDone){
		initShaders();
		initDone = true;
	}
	// vertex shadow program
	//--------------------------------------------------------------------------
	cgGLSetOptimalOptions(cgVertexProfile);
	cgVertexShadowProgram = cgCreateProgramFromFile(cgContext, CG_SOURCE, "src/cg/vShadow.cg", cgVertexProfile, "main", 0);
	if (cgVertexShadowProgram == NULL){
		int i = 3;
	}
	cgGLLoadProgram(cgVertexShadowProgram);
	ModelViewProjMatrix	= cgGetNamedParameter(cgVertexShadowProgram, "modelViewProj");
	lightPos			= cgGetNamedParameter(cgVertexShadowProgram, "lightPosition");
	textureMatrix		= cgGetNamedParameter(cgVertexShadowProgram, "textureMatrix");
 
	// fragment shadow program
	//--------------------------------------------------------------------------
	cgGLSetOptimalOptions(cgFragmentProfile);
	cgFragmentShadowProgram = cgCreateProgramFromFile(cgContext, CG_SOURCE, "src/cg/fShadow.cg", cgFragmentProfile, "main", 0);
	if (cgFragmentShadowProgram == NULL){
		int i = 3;
	}
	shadowMap			= cgGetNamedParameter(cgFragmentShadowProgram, "shadowMap");
}
 
int Shaders_Shadow::Begin(void){
 
	return 0;
}
 
int Shaders_Shadow::End(void){
 
	return 0;
}
 
void Shaders_Shadow::setModelViewMatrix(void){
	cgGLSetStateMatrixParameter(ModelViewProjMatrix, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
}