static void fshader_select (int select_in)
{
FShader* s;
Env* e;
fshader_selected = select_in - FSHADER_BASE;
if (fshader_selected == -1 || !CVarUtils::GetCVar<bool> ("render.textured")) {
cgGLDisableProfile (cgp_fragment);
return;
}
if (!CVarUtils::GetCVar<bool> ("render.shaders"))
return;
s = &fshader_list[fshader_selected];
e = EnvGet ();
cgGLEnableProfile (cgp_fragment);
cgGLBindProgram (s->program);
if (select_in == FSHADER_CLOUDS) {
GLrgba c = (e->color[ENV_COLOR_SKY] + e->color[ENV_COLOR_HORIZON]) / 2.0f;
cgGLSetParameter3f (s->fogcolor, c.red, c.green, c.blue);
} else
cgGLSetParameter3f (s->fogcolor, e->color[ENV_COLOR_FOG].red, e->color[ENV_COLOR_FOG].green, e->color[ENV_COLOR_FOG].blue);
cgGLSetTextureParameter (s->texture, TextureIdFromName ("clouds.png"));
cgGLSetParameter4f (s->data, wind, e->cloud_cover, 1 - e->star_fade, 0);
cgGLEnableTextureParameter (s->texture);
}
void OpenMDLmodel::EnableMaterial( OpenMDL::Material* material )
{
OpenMDL::String fullname;
if( material->HasDiffuseMap() )
{
glActiveTextureARB( GL_TEXTURE0_ARB );
glEnable( GL_TEXTURE_2D );
char tmps[256];
sprintf( tmps, "Textures/%s", material->GetDiffuseMap().GetBuffer() );
BindTextureByName( tmps );
}
glActiveTextureARB( GL_TEXTURE1_ARB );
if( material->HasSpecularMap() )
{
glEnable( GL_TEXTURE_2D );
fullname = OpenMDL::String("Textures/") + material->GetSpecularMap();
BindTextureByName( fullname.GetBuffer() );
cgSetParameter1i( m_UberShader_bSpecularMapping, 1 );
}
else
{
glDisable( GL_TEXTURE_2D );
cgSetParameter1i( m_UberShader_bSpecularMapping, 0 );
}
/*
glActiveTextureARB( GL_TEXTURE2_ARB );
if( material->HasNormalMap() )
{
glEnable( GL_TEXTURE_2D );
fullname = OpenMDL::String("Textures/") + material->GetNormalMap();
BindTextureByName( fullname.GetBuffer() );
cgSetParameter1i( m_UberShader_bNormalMapping, 1 );
}
else
{
glDisable( GL_TEXTURE_2D );
cgSetParameter1i( m_UberShader_bNormalMapping, 0 );
}
*/
glActiveTextureARB( GL_TEXTURE0_ARB );
cgGLSetStateMatrixParameter( m_UberShader_ModelCamProj, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY );
cgGLSetStateMatrixParameter( m_UberShader_ModelCam, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_IDENTITY );
cgGLSetParameter3f( m_UberShader_Lightpos_Pixel, m_LightInWorldSpace.x, m_LightInWorldSpace.y, m_LightInWorldSpace.z );
cgGLSetParameter1f( m_UberShader_Ambient, m_Ambient );
cgGLSetParameter3f( m_UberShader_CamPos, m_CamPos.x, m_CamPos.y, m_CamPos.z );
cgGLSetParameter3f( m_UberShader_LightColor, m_LightColor.x, m_LightColor.y, m_LightColor.z );
cgGLSetMatrixParameterfc( m_UberShader_WorldCam, m_WorldCam );
cgGLSetParameter1f( m_UberShader_SpecularPower, material->GetSpecularCoeff() );
cgGLSetParameter3f( m_UberShader_ClipPlane_Point, m_ClipPlane_Point.x, m_ClipPlane_Point.y, m_ClipPlane_Point.z );
cgGLSetParameter3f( m_UberShader_ClipPlane_Normal, m_ClipPlane_Normal.x, m_ClipPlane_Normal.y, m_ClipPlane_Normal.z );
m_UberShader.EnablePrograms();
}
void Cg::SetParameter(CGparameter param,double* f){
if (param != NULL)
cgGLSetParameter3f(param, (float)f[0],(float)f[1],(float)f[2]);
else
{
cout<<"CGparameter is null"<<endl;
abort();
}
CheckCgError();
}
void CgSetOffset (GLvector p)
{
VShader* s;
if (vshader_selected == VSHADER_NONE)
return;
s = &vshader_list[vshader_selected];
cgGLSetParameter3f (s->offset, p.x, p.y, p.z);
}
static void vshader_select (int select)
{
VShader* s;
GLvector p;
Env* e;
GLrgba c;
float val1, val2;
vshader_selected = select;
if (!CVarUtils::GetCVar<bool> ("render.shaders"))
return;
if (select == VSHADER_NONE) {
cgGLDisableProfile (cgp_vertex);
return;
}
val1 = val2 = 0.0f;
if (select == VSHADER_TREES || select == VSHADER_GRASS)
val1 = wind;
if (select == VSHADER_CLOUDS)
val1 = wind / 5;
s = &vshader_list[select];
e = EnvGet ();
cgGLEnableProfile (cgp_vertex);
cgGLBindProgram (s->program);
cgGLSetParameter3f (s->lightpos, -e->light.x, -e->light.y, -e->light.z);
c = e->color[ENV_COLOR_LIGHT];
cgGLSetParameter3f (s->lightcol, c.red, c.green, c.blue);
c = e->color[ENV_COLOR_AMBIENT] * glRgba (0.2f, 0.2f, 1.0f);
cgGLSetParameter3f (s->ambientcol, c.red, c.green, c.blue);
p = AvatarCameraPosition ();
cgGLSetParameter3f (s->eyepos, p.x, p.y, p.z);
cgGLSetStateMatrixParameter(s->matrix, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MODELVIEW_MATRIX);
cgGLSetParameter2f (s->fog, e->fog.rmin, e->fog.rmax);
cgGLSetParameter4f (s->data, SceneVisibleRange (), SceneVisibleRange () * 0.05, val1, val2);
glColor3f (1,1,1);
}
void Material::bind()
{
//bytt til egen shader
if(m_shaderSys)
m_shaderSys->enableProfiles();
if(m_vertexShader) {
m_vertexShader->bind();
cgGLSetStateMatrixParameter(m_vertexShader->getParameter("worldViewProj"), CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
cgGLSetStateMatrixParameter(m_vertexShader->getParameter("worldView"), CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_IDENTITY);
cgGLSetParameter4f(m_vertexShader->getParameter("lightPos"), g_lightPos.x,g_lightPos.y,g_lightPos.z,1);
cgGLSetMatrixParameterfc(m_vertexShader->getParameter("view"),g_viewMat);
cgUpdateProgramParameters(m_vertexShader->getProgram());
}
if(m_fragmentShader) {
m_fragmentShader->bind();
cgGLSetParameter3f(m_fragmentShader->getParameter("col"),m_color.x,m_color.y,m_color.z);
cgUpdateProgramParameters(m_fragmentShader->getProgram());
}
}
void CG_initialize(void)
{
cgVertexProfile = cgGLGetLatestProfile(CG_GL_VERTEX);
cgFragmentProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT);
cgGLSetOptimalOptions(cgVertexProfile);
cgGLSetOptimalOptions(cgFragmentProfile);
cgContext = cgCreateContext();
cgVertexProgram = cgCreateProgramFromFile(cgContext,
CG_SOURCE,
"CG_ENVIRO_MAPPING/oglu_per_vertex_reflective_environment_mapping_vs.cg",
cgVertexProfile,
NULL,
NULL);
cgGLLoadProgram(cgVertexProgram);
enviroCgVertexParam_lightPosition = cgGetNamedParameter(cgVertexProgram, "lightPosition");
enviroCgVertexParam_globalAmbient = cgGetNamedParameter(cgVertexProgram, "globalAmbient");
enviroCgVertexParam_lightColor = cgGetNamedParameter(cgVertexProgram, "lightColor");
//enviroCgVertexParam_Ke = cgGetNamedParameter(cgVertexProgram, "Ke");
enviroCgVertexParam_Ka = cgGetNamedParameter(cgVertexProgram, "Ka");
enviroCgVertexParam_Kd = cgGetNamedParameter(cgVertexProgram, "Kd");
enviroCgVertexParam_Ks = cgGetNamedParameter(cgVertexProgram, "Ks");
enviroCgVertexParam_shininess = cgGetNamedParameter(cgVertexProgram, "shininess");
enviroCgVertexParam_time = cgGetNamedParameter(cgVertexProgram, "time");
cgModelViewProj = cgGetNamedParameter(cgVertexProgram, "ModelViewProj");
cgModelView = cgGetNamedParameter(cgVertexProgram, "ModelView");
cgModelViewI = cgGetNamedParameter(cgVertexProgram, "ModelViewI");
cgModelViewIT = cgGetNamedParameter(cgVertexProgram, "ModelViewIT");
cgPosition = cgGetNamedParameter(cgVertexProgram, "position");
cgNormal = cgGetNamedParameter(cgVertexProgram, "N");
cgTexcoords = cgGetNamedParameter(cgVertexProgram, "texCoord");
cgEyePosition = cgGetNamedParameter(cgVertexProgram, "eyePosition");
cgGLSetParameter3f(cgEyePosition, 0, 0, 0);
cgFragmentProgram = cgCreateProgramFromFile(cgContext,
CG_SOURCE,
"CG_ENVIRO_MAPPING/oglu_per_vertex_reflective_environment_mapping_ps.cg",
cgFragmentProfile,
NULL,
NULL );
cgGLLoadProgram(cgFragmentProgram);
cgEnvironmentMap = cgGetNamedParameter(cgFragmentProgram, "environmentMap");
loadCubeMap();
cgGLSetTextureParameter(cgEnvironmentMap, cubemapTexture[0]);
}
static void gl_cg_set_uniform_parameter(
void *data,
struct uniform_info *param,
void *uniform_data)
{
CGparameter location;
cg_shader_data_t *cg = (cg_shader_data_t*)data;
if (!param || !param->enabled)
return;
if (param->lookup.enable)
{
char ident[64];
CGprogram prog = 0;
switch (param->lookup.type)
{
case SHADER_PROGRAM_VERTEX:
prog = cg->prg[param->lookup.idx].vprg;
break;
case SHADER_PROGRAM_FRAGMENT:
default:
prog = cg->prg[param->lookup.idx].fprg;
break;
}
if (param->lookup.add_prefix)
snprintf(ident, sizeof(ident), "IN.%s", param->lookup.ident);
location = cgGetNamedParameter(prog, param->lookup.add_prefix ? ident : param->lookup.ident);
}
else
{
struct uniform_cg *cg_param = (struct uniform_cg*)uniform_data;
location = cg_param->loc;
}
switch (param->type)
{
case UNIFORM_1F:
cgGLSetParameter1f(location, param->result.f.v0);
break;
case UNIFORM_2F:
cgGLSetParameter2f(location, param->result.f.v0, param->result.f.v1);
break;
case UNIFORM_3F:
cgGLSetParameter3f(location, param->result.f.v0, param->result.f.v1,
param->result.f.v2);
break;
case UNIFORM_4F:
cgGLSetParameter4f(location, param->result.f.v0, param->result.f.v1,
param->result.f.v2, param->result.f.v3);
break;
case UNIFORM_1FV:
cgGLSetParameter1fv(location, param->result.floatv);
break;
case UNIFORM_2FV:
cgGLSetParameter2fv(location, param->result.floatv);
break;
case UNIFORM_3FV:
cgGLSetParameter3fv(location, param->result.floatv);
break;
case UNIFORM_4FV:
cgGLSetParameter3fv(location, param->result.floatv);
break;
case UNIFORM_1I:
/* Unimplemented - Cg limitation */
break;
}
}
void Effect::setParam( const char *_name, float _x, float _y, float _z ) {
CGparameter param = cgGetNamedEffectParameter( effect, _name );
cgGLSetParameter3f( param, _x, _y, _z );
}
void IOGLBaseShader::SetUniform(const CString& strName, const Math::CVector3D& vValue){
cgGLSetParameter3f(this->GetParameter(strName), vValue.X, vValue.Y, vValue.Z);
}
void Application::DrawGLScene ()
{
int TimeDelta = GetTickCount () - gTime;
gTime = GetTickCount ();
// Do shaders
static float wave_movement = 0.0f;
wave_movement += 0.03f; // Increment our wave movement
if (wave_movement > 6.2831853071) // Prevent crashing
wave_movement = 0.0f;
cgGLSetParameter3f(mWave, wave_movement, 1.0f, 1.0f);
IVector SunDirection = mpEngine->GetSunlightVector ();
cgGLSetParameter3f (mSunVector, SunDirection.GetX (), SunDirection.GetY (),
SunDirection.GetZ ());
mpFog->Draw ();
mpEngine->Draw ();
mpEngine->GetParticleManager ()->UpdateAndDrawAll ();
mpSun->Draw ();
// Press 'F' for cloud dissipation or 'G' for cloud formation
if (Keys::FPressed == true)
{
mpCloudManager->Form (0.0f, 6000, 10000);
}
if (Keys::GPressed == true)
{
mpCloudManager->Form (100.0f, 6000, 10000);
}
// Turn wind on or off
static bool MovedL = false;
if (Keys::LeftPressed == true && MovedL == false)
{
mpSceneManager->mWind.MoveX (-2.0f);
MovedL = true;
}
static bool MovedR = false;
if (Keys::RightPressed == true && MovedR == false)
{
mpSceneManager->mWind.SetXYZ (0.0f, 0.0f, 0.0f);
MovedR = true;
}
// Make our two boxes crash into each other
if (mpPolyObj0->Collision (mpPolyObj1) == false)
{
mpPolyObj0->Translate (0.0f, 0.0f, -0.1f);
mpPolyObj1->Translate (0.0f, 0.0f, 0.5f);
}
// Experimental - move some vertices around after the collision
else
mpPolyObj0->MoveVerticesByBoneId(static_cast<char> (0), 0.0f, 0.0f, 0.001f);
IVector FountainPos = mpEngine->GetTerrain ()->GetWorldPositionAtCoord (134, 190);
mpFountain->SetOrigin (FountainPos);
// Watch the terrain rise like yeast!
static float MaxTerrainHeight = -1.5f;
static bool CloudsAdded = false;
MaxTerrainHeight += 0.05f;
if (MaxTerrainHeight < 20.0f)
{
mpEngine->GetTerrain ()->SetMaxHeight
((MaxTerrainHeight >= 1.0f) ? MaxTerrainHeight : 1.0f);
}
else
{
mpEngine->GetLightManager ()->Translate (gLightNumber, 0.0f, 0.0f, 0.5f);
if (!CloudsAdded)
{
mpCloudManager->AddCloudPuff (50, FountainPos, 1.0f);
CloudsAdded = true;
}
}
mpCloudManager->Draw (mpEngine->GetCamera ());
// Make our pixmap fade away
static unsigned char c = 255;
if (c > 0) c--;
mpPixmap->SetOpaqueness (c);
//mpPixmap->Draw ();
mpFpsCounter->Draw ();
mpTimeOfDay->Update (TimeDelta);
mpTimeOfDay->Draw ();
mpEngine->UpdateProceduralSkybox (mpTimeOfDay);
mpEngine->Update (TimeDelta);
// Draw a frames per second counter
mpFpsCounter->Update (TimeDelta);
mpFpsCounter->Draw ();
}
void Sarge::Render() {
cgGLBindProgram(vsSargeProgram);
cgGLEnableProfile(vsSargeProfile);
CheckForCgError("sarge", "enabling vertex program");
cgGLBindProgram(psSargeProgram);
cgGLEnableProfile(psSargeProfile);
CheckForCgError("sarge", "enabling pixel program");
// mSkydome->getSunPos()
//Vector3 tmpsun = mWorldMode->getSkydome().getSunPos();
cgGLSetParameter4f(lightPosition, 0.0, 20.0, 0.0, 1.0);
//cgGLSetParameter4f(lightPosition, tmpsun.GetX(), tmpsun.GetY(), tmpsun.GetZ(), 1.0);
cgGLSetParameter3f(eyevector, 0.0, 0.0, 5.0);
cgGLEnableTextureParameter(normalmap);
cgGLEnableTextureParameter(decalmap);
/*
glActiveTextureARB(GL_TEXTURE0_ARB);
//glEnable(GL_TEXTURE_2D);
//glBindTexture(GL_TEXTURE_2D, sargeNormalTexture.TextureID);
glActiveTextureARB(GL_TEXTURE1_ARB);
//glEnable(GL_TEXTURE_2D);
//glBindTexture(GL_TEXTURE_2D, sargeColorTexture.TextureID);
glActiveTextureARB(GL_TEXTURE2_ARB);
glActiveTextureARB(GL_TEXTURE3_ARB);
glActiveTextureARB(GL_TEXTURE4_ARB);
*/
glDisable(GL_LIGHTING);
//Pixel Parameters
// cgGLEnableTextureParameter(text1);
glPushMatrix();
cgGLSetStateMatrixParameter(lightViewProj, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
glTranslatef(mPos.GetX(), mPos.GetY(), mPos.GetZ());
glRotatef(-mTheta * 180/PI - 90, 0, 1, 0);
glRotatef(90, 1, 0, 0);
//glScalef(0.6,0.6,0.6);
cgGLSetStateMatrixParameter(modelViewProj, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
mDriverParticleSystem.Render();
if(burned) glColor3f(0, 0, 0);
else glColor3f(1, 1, 1);
mMeshObject.GLDraw();
glColor3f(1, 1, 1);
glPopMatrix();
glEnable(GL_LIGHTING);
cgGLDisableProfile(vsSargeProfile);
cgGLDisableProfile(psSargeProfile);
/*
//glDisable(GL_TEXTURE_2D);
glActiveTextureARB(GL_TEXTURE1_ARB);
glDisable(GL_TEXTURE_2D);
glActiveTextureARB(GL_TEXTURE2_ARB);
glDisable(GL_TEXTURE_2D);
glActiveTextureARB(GL_TEXTURE3_ARB);
glDisable(GL_TEXTURE_2D);
glActiveTextureARB(GL_TEXTURE4_ARB);
glDisable(GL_TEXTURE_2D);
*/
glActiveTextureARB(GL_TEXTURE0_ARB);
if(frozen)
{ FreezeEffectBegin();
glTranslatef(mPos.GetX(), mPos.GetY(), mPos.GetZ());
glRotatef(-mTheta * 180/PI - 90, 0, 1, 0);
glScalef(2.5,2.5,2.5);
cgGLSetStateMatrixParameter(vsFreezeEffectMVMatrix, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
FreezeEffectEnd();
if(freezeCounter > (16.0f/3.0f) && freezeCounter <= 8.0f)
{
glPushMatrix();
mFreezeParticleSystem.Render(mPos.GetX(), mPos.GetY(), mPos.GetZ(),-mTheta * 180/PI - 90, 0, 1, 0);
glPopMatrix();
}
}
}
