//-------------------------------------------------------------
// ARBProgram::setFloatVector() set shader parameter
//-------------------------------------------------------------
bool ARBProgram::setFloatVector (char *name, float *d, int pid){
if(vshader->isActive())
glProgramEnvParameter4fARB(vshader->getProgramType(),pid,d[0],d[1],d[2],d[3]);
if(fshader->isActive())
glProgramEnvParameter4fARB(fshader->getProgramType(),pid,d[0],d[1],d[2],d[3]);
return true;
}
void setprogpar(int n,float p1,float p2,float p3,float p4,bool vtxorfrg)
{
#if defined(GL_ARB_vertex_program) && defined(GL_ARB_fragment_program)
if (vtxorfrg) glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,n,p1,p2,p3,p4);
else glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,n,p1,p2,p3,p4);
#endif
}
void CShadowHandler::CreateShadows()
{
// NOTE:
// we unbind later in WorldDrawer::GenerateIBLTextures() to save render
// context switches (which are one of the slowest OpenGL operations!)
// together with VP restoration
fb.Bind();
glDisable(GL_BLEND);
glDisable(GL_LIGHTING);
glDisable(GL_ALPHA_TEST);
glDisable(GL_TEXTURE_2D);
glShadeModel(GL_FLAT);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
glDepthMask(GL_TRUE);
glEnable(GL_DEPTH_TEST);
glClear(GL_DEPTH_BUFFER_BIT);
CCamera* prvCam = CCamera::GetSetActiveCamera(CCamera::CAMTYPE_SHADOW);
CCamera* curCam = CCamera::GetActiveCamera();
SetShadowMapSizeFactors();
SetShadowMatrix(prvCam, curCam);
SetShadowCamera(curCam);
if (globalRendering->haveARB) {
// set the shadow-parameter registers
// NOTE: so long as any part of Spring rendering still uses
// ARB programs at run-time, these lines can not be removed
// (all ARB programs share the same environment)
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 16, shadowTexProjCenter.x, shadowTexProjCenter.y, 0.0f, 0.0f);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 17, shadowTexProjCenter.z, shadowTexProjCenter.z, 0.0f, 0.0f);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 18, shadowTexProjCenter.w, shadowTexProjCenter.w, 0.0f, 0.0f);
}
if (globalRendering->haveGLSL) {
for (int i = 0; i < SHADOWGEN_PROGRAM_LAST; i++) {
shadowGenProgs[i]->Enable();
shadowGenProgs[i]->SetUniform4fv(0, &shadowTexProjCenter.x);
shadowGenProgs[i]->Disable();
}
}
if ((sky->GetLight())->GetLightIntensity() > 0.0f)
DrawShadowPasses();
CCamera::SetActiveCamera(prvCam->GetCamType());
prvCam->Update();
glShadeModel(GL_SMOOTH);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
}
void setprogpars(int n,int count,const float *params,bool vtxorfrg)
{
#if defined(GL_ARB_vertex_program) && defined(GL_ARB_fragment_program)
if (vtxorfrg)
for (int i=0; i<count; i++)
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,n+i,params[4*i],params[4*i+1],params[4*i+2],params[4*i+3]);
else
for (int i=0; i<count; i++)
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,n+i,params[4*i],params[4*i+1],params[4*i+2],params[4*i+3]);
#endif
}
void gDP_SetPrimColor(unsigned int w0, unsigned int w1)
{
Gfx.PrimColor.R = _SHIFTR(w1, 24, 8) * 0.0039215689f;
Gfx.PrimColor.G = _SHIFTR(w1, 16, 8) * 0.0039215689f;
Gfx.PrimColor.B = _SHIFTR(w1, 8, 8) * 0.0039215689f;
Gfx.PrimColor.A = _SHIFTR(w1, 0, 8) * 0.0039215689f;
Gfx.PrimColor.M = _SHIFTL(w0, 8, 8);
Gfx.PrimColor.L = _SHIFTL(w0, 0, 8) * 0.0039215689f;
if(OpenGL.Ext_FragmentProgram && do_arb) {
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 1, Gfx.PrimColor.R, Gfx.PrimColor.G, Gfx.PrimColor.B, Gfx.PrimColor.A);
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 2, Gfx.PrimColor.L, Gfx.PrimColor.L, Gfx.PrimColor.L, Gfx.PrimColor.L);
}
}
static void draw_arrays(int i)
{
struct galaxy *g = get_galaxy(i);
GLsizei sz = sizeof (struct star);
if (GL_has_vertex_program)
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,
1, g->magnitude, 0, 0, 0);
/* Enable the star arrays. */
glEnableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
/* Bind the vertex buffers. */
if (GL_has_vertex_buffer_object)
{
glEnableVertexAttribArrayARB(6);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, g->buffer);
glColorPointer (3, GL_UNSIGNED_BYTE, sz, (GLvoid *) 0);
glVertexPointer(3, GL_FLOAT, sz, (GLvoid *) 4);
glVertexAttribPointerARB(6, 1, GL_FLOAT, 0, sz, (GLvoid *) 16);
}
else
{
glColorPointer (3, GL_UNSIGNED_BYTE, sz, g->S->col);
glVertexPointer(3, GL_FLOAT, sz, g->S->pos);
}
}
void gDP_SetEnvColor(unsigned int w0, unsigned int w1)
{
Gfx.EnvColor.R = _SHIFTR(w1, 24, 8) * 0.0039215689f;
Gfx.EnvColor.G = _SHIFTR(w1, 16, 8) * 0.0039215689f;
Gfx.EnvColor.B = _SHIFTR(w1, 8, 8) * 0.0039215689f;
Gfx.EnvColor.A = _SHIFTR(w1, 0, 8) * 0.0039215689f;
if(OpenGL.Ext_FragmentProgram) {
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 0, Gfx.EnvColor.R, Gfx.EnvColor.G, Gfx.EnvColor.B, Gfx.EnvColor.A);
}
}
bool ATITShader::setParameter4f(StringTableEntry name, F32 value0, F32 value1, F32 value2, F32 value3)
{
ASMShaderParameter* param = getNamedParameter(name);
if(!param)
return false;
if(param->mVertexId != -1)
{
if(param->mVertexIsEnv)
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, param->mVertexId, value0, value1, value2, value3);
else
glProgramLocalParameter4fARB(GL_VERTEX_PROGRAM_ARB, param->mVertexId, value0, value1, value2, value3);
}
if(param->mFragmentId != -1)
{
if(param->mFragmentIsEnv)
glProgramEnvParameter4fARB(GL_TEXT_FRAGMENT_SHADER_ATI, param->mFragmentId, value0, value1, value2, value3);
else
glProgramLocalParameter4fARB(GL_TEXT_FRAGMENT_SHADER_ATI, param->mFragmentId, value0, value1, value2, value3);
}
return true;
}
void RDP_Macro_LoadTextureSF64()
{
Gfx.CurrentTexture = ((nw0[1] & 0x0F00) ? 1 : 0);
Gfx.IsMultiTexture = Gfx.CurrentTexture;
gDP_SetTImg(nw0[3], nw1[3]);
gDP_SetTile(nw0[1], nw1[1]);
gDP_SetTileSize(nw0[2], nw1[2]);
if(Gfx.IsMultiTexture) {
Gfx.EnvColor = (__RGBA){ 0.5f, 0.5f, 0.5f, 0.5f };
} else {
Gfx.EnvColor = (__RGBA){ 1.0f, 1.0f, 1.0f, 0.75f };
}
if(OpenGL.Ext_FragmentProgram) glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 0, Gfx.EnvColor.R, Gfx.EnvColor.G, Gfx.EnvColor.B, Gfx.EnvColor.A);
RDP_InitLoadTexture();
}
void ARBProgramObject::SetUniform4i(int idx, int v0, int v1, int v2, int v3) { glProgramEnvParameter4fARB(uniformTarget, idx, float(v0), float(v1), float(v2), float(v3)); }
void CAdvTreeDrawer::DrawShadowPass(void)
{
float treeDistance=oldTreeDistance;
int activeFarTex=camera->forward.z<0 ? treeGen->farTex[0] : treeGen->farTex[1];
bool drawDetailed=true;
if(treeDistance<4)
drawDetailed=false;
glBindTexture(GL_TEXTURE_2D, activeFarTex);
glEnable(GL_TEXTURE_2D);
glBindProgramARB( GL_VERTEX_PROGRAM_ARB, treeGen->treeFarShadowVP );
glEnable( GL_VERTEX_PROGRAM_ARB );
glEnable(GL_ALPHA_TEST);
glPolygonOffset(1,1);
glEnable(GL_POLYGON_OFFSET_FILL);
CAdvTreeSquareDrawer_SP drawer;
int cx = drawer.cx=(int)(camera->pos.x/(SQUARE_SIZE*TREE_SQUARE_SIZE));
int cy = drawer.cy=(int)(camera->pos.z/(SQUARE_SIZE*TREE_SQUARE_SIZE));
drawer.drawDetailed = drawDetailed;
drawer.td = this;
drawer.treeDistance = treeDistance * SQUARE_SIZE * TREE_SQUARE_SIZE;
GML_STDMUTEX_LOCK(tree); // DrawShadowPass
// draw with extraSize=1
readmap->GridVisibility (camera, TREE_SQUARE_SIZE, drawer.treeDistance * 2.0f, &drawer, 1);
if(drawDetailed){
int xstart=std::max(0,cx-2);
int xend=std::min(gs->mapx/TREE_SQUARE_SIZE-1,cx+2);
int ystart=std::max(0,cy-2);
int yend=std::min(gs->mapy/TREE_SQUARE_SIZE-1,cy+2);
glBindTexture(GL_TEXTURE_2D, treeGen->barkTex);
glEnable(GL_TEXTURE_2D);
glBindProgramARB( GL_VERTEX_PROGRAM_ARB, treeGen->treeShadowVP );
glEnable( GL_VERTEX_PROGRAM_ARB );
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,13, camera->right.x,camera->right.y,camera->right.z,0);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,9, camera->up.x,camera->up.y,camera->up.z,0);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,11, 1,1,1,0.85f);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,12, 0,0,0,0.20f*(1.0f/MAX_TREE_HEIGHT)); //w=alpha/height modifier
glAlphaFunc(GL_GREATER,0.5f);
glEnable(GL_ALPHA_TEST);
glColor4f(1,1,1,1);
va=GetVertexArray();
va->Initialize();
struct FadeTree{
float3 pos;
float relDist;
float deltaY;
int type;
};
static FadeTree fadeTrees[3000];
FadeTree *pFT=fadeTrees;
for(TreeSquareStruct* pTSS=trees+ystart*treesX; pTSS<=trees+yend*treesX; pTSS+=treesX) {
for(TreeSquareStruct* tss=pTSS+xstart; tss<=pTSS+xend; ++tss) {
tss->lastSeen=gs->frameNum;
va->EnlargeArrays(12*tss->trees.size(),0,VA_SIZE_T); //!alloc room for all tree vertexes
for(std::map<int,TreeStruct>::iterator ti=tss->trees.begin();ti!=tss->trees.end();++ti){
TreeStruct* ts=&ti->second;
float3 pos(ts->pos);
int type=ts->type;
float dy;
unsigned int displist;
if(type<8){
dy=0.5f;
displist=treeGen->pineDL+type;
} else {
type-=8;
dy=0;
displist=treeGen->leafDL+type;
}
if(camera->InView(pos+float3(0,MAX_TREE_HEIGHT/2,0),MAX_TREE_HEIGHT/2+150)){
float camDist=(pos-camera->pos).SqLength();
if(camDist<SQUARE_SIZE*SQUARE_SIZE*110*110){ //draw detailed tree
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,10,pos.x,pos.y,pos.z,0);
glCallList(displist);
} else if(camDist<SQUARE_SIZE*SQUARE_SIZE*125*125){ //draw fading tree
float relDist=(pos.distance(camera->pos)-SQUARE_SIZE*110)/(SQUARE_SIZE*15);
glAlphaFunc(GL_GREATER,0.8f+relDist*0.2f);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,10,pos.x,pos.y,pos.z,0);
glCallList(displist);
glAlphaFunc(GL_GREATER,0.5f);
pFT->pos=pos;
pFT->deltaY=dy;
pFT->type=type;
pFT->relDist=relDist;
++pFT;
} else { //draw undetailed tree
DrawTreeVertex(pos, type*0.125f, dy, false);
}
}
}
}
}
//draw trees that have been marked as falling
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,10,0,0,0,0);
for(std::list<FallingTree>::iterator fti=fallingTrees.begin(); fti!=fallingTrees.end(); ++fti){
float3 pos=fti->pos-UpVector*(fti->fallPos*20);
if(camera->InView(pos+float3(0,MAX_TREE_HEIGHT/2,0),MAX_TREE_HEIGHT/2)){
float ang=fti->fallPos*PI;
float3 up(fti->dir.x*sin(ang),cos(ang),fti->dir.z*sin(ang));
float3 z(up.cross(float3(1,0,0)));
z.ANormalize();
float3 x(z.cross(up));
CMatrix44f transMatrix(pos,x,up,z);
glPushMatrix();
glMultMatrixf(&transMatrix[0]);
int type=fti->type;
int displist;
if(type<8){
displist=treeGen->pineDL+type;
} else {
type-=8;
displist=treeGen->leafDL+type;
}
glCallList(displist);
glPopMatrix();
}
}
glBindProgramARB( GL_VERTEX_PROGRAM_ARB, treeGen->treeFarShadowVP );
glBindTexture(GL_TEXTURE_2D, activeFarTex);
va->DrawArrayT(GL_QUADS);
for(FadeTree *pFTree=fadeTrees; pFTree<pFT; ++pFTree) { //faded close trees
va=GetVertexArray();
va->Initialize();
va->CheckInitSize(12*VA_SIZE_T);
DrawTreeVertex(pFTree->pos, pFTree->type*0.125f, pFTree->deltaY, false);
glAlphaFunc(GL_GREATER,1-pFTree->relDist*0.5f);
va->DrawArrayT(GL_QUADS);
}
}
glDisable(GL_POLYGON_OFFSET_FILL);
glDisable( GL_VERTEX_PROGRAM_ARB );
glDisable(GL_TEXTURE_2D);
glDisable(GL_ALPHA_TEST);
}
void CAdvTreeDrawer::Draw(float treeDistance,bool drawReflection)
{
int activeFarTex=camera->forward.z<0 ? treeGen->farTex[0] : treeGen->farTex[1];
bool drawDetailed=true;
if(treeDistance<4)
drawDetailed=false;
if(drawReflection)
drawDetailed=false;
CBaseGroundDrawer *gd = readmap->GetGroundDrawer ();
glEnable(GL_ALPHA_TEST);
if(gu->drawFog) {
glFogfv(GL_FOG_COLOR, mapInfo->atmosphere.fogColor);
glEnable(GL_FOG);
}
if(shadowHandler->drawShadows && !gd->DrawExtraTex()){
glBindProgramARB( GL_VERTEX_PROGRAM_ARB, treeGen->treeFarVP );
glEnable(GL_VERTEX_PROGRAM_ARB);
glBindTexture(GL_TEXTURE_2D,shadowHandler->shadowTexture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC_ARB, GL_LEQUAL);
glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE_ARB, GL_ALPHA);
if(shadowHandler->useFPShadows){
glBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, treeGen->treeFPShadow );
glEnable( GL_FRAGMENT_PROGRAM_ARB );
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,10, mapInfo->light.groundAmbientColor.x,mapInfo->light.groundAmbientColor.y,mapInfo->light.groundAmbientColor.z,1);
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,11, 0,0,0,1-mapInfo->light.groundShadowDensity*0.5f);
glActiveTextureARB(GL_TEXTURE1_ARB);
glBindTexture(GL_TEXTURE_2D, activeFarTex);
} else {
glEnable(GL_TEXTURE_2D);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FAIL_VALUE_ARB, 1-mapInfo->light.groundShadowDensity*0.5f);
float texConstant[]={mapInfo->light.groundAmbientColor.x,mapInfo->light.groundAmbientColor.y,mapInfo->light.groundAmbientColor.z,0.0f};
glTexEnvfv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_COLOR,texConstant);
glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE0_RGB_ARB,GL_PREVIOUS_ARB);
glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE1_RGB_ARB,GL_CONSTANT);
glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE2_RGB_ARB,GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV,GL_OPERAND2_RGB_ARB,GL_SRC_ALPHA);
glTexEnvi(GL_TEXTURE_ENV,GL_COMBINE_RGB_ARB,GL_INTERPOLATE_ARB);
glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE0_ALPHA_ARB,GL_PREVIOUS_ARB);
glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE1_ALPHA_ARB,GL_CONSTANT);
glTexEnvi(GL_TEXTURE_ENV,GL_COMBINE_ALPHA_ARB,GL_ADD);
glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_COMBINE_ARB);
glActiveTextureARB(GL_TEXTURE1_ARB);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, activeFarTex);
}
glActiveTextureARB(GL_TEXTURE0_ARB);
glMatrixMode(GL_MATRIX0_ARB);
glLoadMatrixf(shadowHandler->shadowMatrix.m);
glMatrixMode(GL_MODELVIEW);
} else {
glBindTexture(GL_TEXTURE_2D, activeFarTex);
}
glEnable(GL_TEXTURE_2D);
int cx=(int)(camera->pos.x/(SQUARE_SIZE*TREE_SQUARE_SIZE));
int cy=(int)(camera->pos.z/(SQUARE_SIZE*TREE_SQUARE_SIZE));
CAdvTreeSquareDrawer drawer;
drawer.td = this;
drawer.cx = cx;
drawer.cy = cy;
drawer.treeDistance = treeDistance * SQUARE_SIZE * TREE_SQUARE_SIZE;
drawer.drawDetailed = drawDetailed;
GML_STDMUTEX_LOCK(tree); // Draw
// draw far away trees using the map dependent grid visibility
oldTreeDistance=treeDistance;
readmap->GridVisibility (camera, TREE_SQUARE_SIZE, drawer.treeDistance * 2.0f, &drawer);
if(drawDetailed){
int xstart=std::max(0,cx-2);
int xend=std::min(gs->mapx/TREE_SQUARE_SIZE-1,cx+2);
int ystart=std::max(0,cy-2);
int yend=std::min(gs->mapy/TREE_SQUARE_SIZE-1,cy+2);
if(shadowHandler->drawShadows && !gd->DrawExtraTex()){
glBindProgramARB( GL_VERTEX_PROGRAM_ARB, treeGen->treeVP );
glActiveTextureARB(GL_TEXTURE1_ARB);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, treeGen->barkTex);
glActiveTextureARB(GL_TEXTURE0_ARB);
} else {
glBindTexture(GL_TEXTURE_2D, treeGen->barkTex);
glBindProgramARB( GL_VERTEX_PROGRAM_ARB, treeGen->treeNSVP );
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,15, 1.0f/(gs->pwr2mapx*SQUARE_SIZE),1.0f/(gs->pwr2mapy*SQUARE_SIZE),1.0f/(gs->pwr2mapx*SQUARE_SIZE),1);
}
glEnable( GL_VERTEX_PROGRAM_ARB );
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,13, camera->right.x,camera->right.y,camera->right.z,0);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,9, camera->up.x,camera->up.y,camera->up.z,0);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,11, mapInfo->light.groundSunColor.x,mapInfo->light.groundSunColor.y,mapInfo->light.groundSunColor.z,0.85f);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,14, mapInfo->light.groundAmbientColor.x,mapInfo->light.groundAmbientColor.y,mapInfo->light.groundAmbientColor.z,0.85f);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,12, 0,0,0,0.20f*(1.0f/MAX_TREE_HEIGHT)); //w=alpha/height modifier
glAlphaFunc(GL_GREATER,0.5f);
glDisable(GL_BLEND);
glColor4f(1,1,1,1);
va=GetVertexArray();
va->Initialize();
struct FadeTree{
float3 pos;
float relDist;
float deltaY;
int type;
};
static FadeTree fadeTrees[3000];
FadeTree *pFT=fadeTrees;
for(TreeSquareStruct* pTSS=trees+ystart*treesX; pTSS<=trees+yend*treesX; pTSS+=treesX) {
for(TreeSquareStruct* tss=pTSS+xstart; tss<=pTSS+xend; ++tss) {
tss->lastSeen=gs->frameNum;
va->EnlargeArrays(12*tss->trees.size(),0,VA_SIZE_T); //!alloc room for all tree vertexes
for(std::map<int,TreeStruct>::iterator ti=tss->trees.begin();ti!=tss->trees.end();++ti){
TreeStruct* ts=&ti->second;
float3 pos(ts->pos);
int type=ts->type;
float dy;
unsigned int displist;
if(type<8){
dy=0.5f;
displist=treeGen->pineDL+type;
} else {
type-=8;
dy=0;
displist=treeGen->leafDL+type;
}
if(camera->InView(pos+float3(0,MAX_TREE_HEIGHT/2,0),MAX_TREE_HEIGHT/2)){
float camDist=(pos-camera->pos).SqLength();
if(camDist<SQUARE_SIZE*SQUARE_SIZE*110*110){ //draw detailed tree
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,10,pos.x,pos.y,pos.z,0);
glCallList(displist);
} else if(camDist<SQUARE_SIZE*SQUARE_SIZE*125*125){ //draw fading tree
float relDist=(pos.distance(camera->pos)-SQUARE_SIZE*110)/(SQUARE_SIZE*15);
glAlphaFunc(GL_GREATER,0.8f+relDist*0.2f);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,10,pos.x,pos.y,pos.z,0);
glCallList(displist);
glAlphaFunc(GL_GREATER,0.5f);
pFT->pos=pos;
pFT->deltaY=dy;
pFT->type=type;
pFT->relDist=relDist;
++pFT;
} else { //draw undetailed tree
DrawTreeVertex(pos, type*0.125f, dy, false);
}
}
}
}
}
//draw trees that has been marked as falling
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,10,0,0,0,0);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,13, camera->right.x,camera->right.y,camera->right.z,0);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,9, camera->up.x,camera->up.y,camera->up.z,0);
for(std::list<FallingTree>::iterator fti=fallingTrees.begin(); fti!=fallingTrees.end(); ++fti){
float3 pos=fti->pos-UpVector*(fti->fallPos*20);
if(camera->InView(pos+float3(0,MAX_TREE_HEIGHT/2,0),MAX_TREE_HEIGHT/2)){
float ang=fti->fallPos*PI;
float3 up(fti->dir.x*sin(ang),cos(ang),fti->dir.z*sin(ang));
float3 z(up.cross(float3(-1,0,0)));
z.ANormalize();
float3 x(up.cross(z));
CMatrix44f transMatrix(pos,x,up,z);
glPushMatrix();
glMultMatrixf(&transMatrix[0]);
int type=fti->type;
int displist;
if(type<8){
displist=treeGen->pineDL+type;
} else {
type-=8;
displist=treeGen->leafDL+type;
}
glCallList(displist);
glPopMatrix();
}
}
glDisable( GL_VERTEX_PROGRAM_ARB );
if(shadowHandler->drawShadows && !gd->DrawExtraTex()){
glBindProgramARB( GL_VERTEX_PROGRAM_ARB, treeGen->treeFarVP );
glEnable(GL_VERTEX_PROGRAM_ARB);
glActiveTextureARB(GL_TEXTURE1_ARB);
glBindTexture(GL_TEXTURE_2D, activeFarTex);
glActiveTextureARB(GL_TEXTURE0_ARB);
} else {
glBindTexture(GL_TEXTURE_2D, activeFarTex);
}
va->DrawArrayT(GL_QUADS);
for(FadeTree *pFTree=fadeTrees; pFTree<pFT; ++pFTree) { //faded close trees
va=GetVertexArray();
va->Initialize();
va->CheckInitSize(12*VA_SIZE_T);
DrawTreeVertex(pFTree->pos, pFTree->type*0.125f, pFTree->deltaY, false);
glAlphaFunc(GL_GREATER,1-pFTree->relDist*0.5f);
va->DrawArrayT(GL_QUADS);
}
}
if(shadowHandler->drawShadows && !gd->DrawExtraTex()){
glDisable( GL_VERTEX_PROGRAM_ARB );
if(shadowHandler->useFPShadows){
glDisable(GL_FRAGMENT_PROGRAM_ARB);
}
glActiveTextureARB(GL_TEXTURE1_ARB);
glDisable(GL_TEXTURE_2D);
glActiveTextureARB(GL_TEXTURE0_ARB);
glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB, GL_NONE);
glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE_ARB, GL_LUMINANCE);
}
glDisable(GL_FOG);
glDisable(GL_ALPHA_TEST);
//clean out squares from memory that are no longer visible
int startClean=lastListClean*20%(nTrees);
lastListClean=gs->frameNum;
int endClean=gs->frameNum*20%(nTrees);
if(startClean>endClean){
for(TreeSquareStruct *pTSS=trees+startClean; pTSS<trees+nTrees; ++pTSS) {
if(pTSS->lastSeen<gs->frameNum-50 && pTSS->displist){
glDeleteLists(pTSS->displist,1);
pTSS->displist=0;
}
if(pTSS->lastSeenFar<gs->frameNum-50 && pTSS->farDisplist){
glDeleteLists(pTSS->farDisplist,1);
pTSS->farDisplist=0;
}
}
for(TreeSquareStruct *pTSS=trees; pTSS<trees+endClean; ++pTSS) {
if(pTSS->lastSeen<gs->frameNum-50 && pTSS->displist){
glDeleteLists(pTSS->displist,1);
pTSS->displist=0;
}
if(pTSS->lastSeenFar<gs->frameNum-50 && pTSS->farDisplist){
glDeleteLists(pTSS->farDisplist,1);
pTSS->farDisplist=0;
}
}
} else {
for(TreeSquareStruct *pTSS=trees+startClean; pTSS<trees+endClean; ++pTSS) {
if(pTSS->lastSeen<gs->frameNum-50 && pTSS->displist){
glDeleteLists(pTSS->displist,1);
pTSS->displist=0;
}
if(pTSS->lastSeenFar<gs->frameNum-50 && pTSS->farDisplist){
glDeleteLists(pTSS->farDisplist,1);
pTSS->farDisplist=0;
}
}
}
}
static void ProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
glProgramEnvParameter4fARB(target, index, x, y, z, w);
}
void ARBProgramObject::SetUniform2f(int idx, float v0, float v1 ) { glProgramEnvParameter4fARB(uniformTarget, idx, v0, v1, 0.0f, 0.0f); }
void ARBProgramObject::SetUniform4f(int idx, float v0, float v1, float v2, float v3) { glProgramEnvParameter4fARB(uniformTarget, idx, v0, v1, v2, v3); }
static void draw_galaxy(int i, int j, int f, float a)
{
struct galaxy *g = get_galaxy(i);
float V[6][4];
float p[4] = { 0.0, 0.0, 0.0, 1.0 };
init_galaxy(i);
glPushMatrix();
{
/* Apply the local coordinate system transformation. */
transform_entity(j);
get_viewfrust(V);
get_viewpoint(p);
/* Supply the view position as a vertex program parameter. */
if (GL_has_vertex_program)
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 0,
p[0], p[1], p[2], p[3]);
glPushAttrib(GL_ENABLE_BIT |
GL_TEXTURE_BIT |
GL_DEPTH_BUFFER_BIT |
GL_COLOR_BUFFER_BIT);
glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT);
{
/* Set up the GL state for star rendering. */
draw_brush(g->brush, a * get_entity_alpha(j));
glBindTexture(GL_TEXTURE_2D, g->texture);
glDisable(GL_TEXTURE_2D);
glDisable(GL_LIGHTING);
glEnable(GL_COLOR_MATERIAL);
glDepthMask(GL_FALSE);
glBlendFunc(GL_ONE, GL_ONE);
if (GL_has_vertex_program)
glEnable(GL_VERTEX_PROGRAM_POINT_SIZE_ARB);
if (GL_has_point_sprite)
{
glEnable(GL_POINT_SPRITE_ARB);
glTexEnvi(GL_POINT_SPRITE_ARB,
GL_COORD_REPLACE_ARB, GL_TRUE);
}
draw_arrays(i);
/* Render all stars. */
node_draw(g->N, 0, 0, V);
}
glPopClientAttrib();
glPopAttrib();
/* Render all child entities in this coordinate system. */
draw_entity_tree(j, f, a * get_entity_alpha(j));
}
glPopMatrix();
}
void CDynWater::DrawWaves(void)
{
float dx=camPosBig.x-oldCamPosBig.x;
float dy=camPosBig.z-oldCamPosBig.z;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0,1,0,1,-1,1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glActiveTextureARB(GL_TEXTURE0_ARB);
glBindTexture(GL_TEXTURE_2D,waveTex3);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
/*glActiveTextureARB(GL_TEXTURE0_ARB);
glBindTexture(GL_TEXTURE_2D,0);
glActiveTextureARB(GL_TEXTURE1_ARB);
glBindTexture(GL_TEXTURE_2D,0);
glActiveTextureARB(GL_TEXTURE2_ARB);
glBindTexture(GL_TEXTURE_2D,0);
glActiveTextureARB(GL_TEXTURE3_ARB);
glBindTexture(GL_TEXTURE_2D,0);
glActiveTextureARB(GL_TEXTURE4_ARB);
glBindTexture(GL_TEXTURE_2D,0);
glActiveTextureARB(GL_TEXTURE5_ARB);
glBindTexture(GL_TEXTURE_2D,0);
glActiveTextureARB(GL_TEXTURE0_ARB);*/
GLenum status;
float start=0.1f/1024;
float end=1023.9f/1024;
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,8, -1.0f/1024, 1.0f/1024, 0,0);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,9, 0, 1.0f/1024, 0,0);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,10, 1.0f/1024, 1.0f/1024, 0,0);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,11, 1.0f/1024, 0, 0,0);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,12, float(WF_SIZE)/(gs->pwr2mapx*SQUARE_SIZE), float(WF_SIZE)/(gs->pwr2mapy*SQUARE_SIZE), 0,0);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,13, (camPosBig.x-WH_SIZE)/(gs->pwr2mapx*SQUARE_SIZE), (camPosBig.z-WH_SIZE)/(gs->pwr2mapy*SQUARE_SIZE), 0, 0);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,14, dx/WF_SIZE, dy/WF_SIZE, 0,0);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,15, (camPosBig.x-WH_SIZE)/WF_SIZE*4, (camPosBig.x-WH_SIZE)/WF_SIZE*4, 0,0);
//////////////////////////////////////
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, frameBuffer);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, waveTex3, 0);
glViewport(0,0,1024,1024);
status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
logOutput.Print("FBO not ready2");
glActiveTextureARB(GL_TEXTURE0_ARB);
glBindTexture(GL_TEXTURE_2D,waveTex2);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
glActiveTextureARB(GL_TEXTURE1_ARB);
glBindTexture(GL_TEXTURE_2D,waveTex1);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
glActiveTextureARB(GL_TEXTURE2_ARB);
glBindTexture(GL_TEXTURE_2D,waveTex1);
glActiveTextureARB(GL_TEXTURE3_ARB);
glBindTexture(GL_TEXTURE_2D,waveTex1);
glActiveTextureARB(GL_TEXTURE4_ARB);
glBindTexture(GL_TEXTURE_2D,waveTex1);
glActiveTextureARB(GL_TEXTURE5_ARB);
glBindTexture(GL_TEXTURE_2D,waveTex1);
glActiveTextureARB(GL_TEXTURE6_ARB);
glBindTexture(GL_TEXTURE_2D, readmap->GetShadingTexture ());
glActiveTextureARB(GL_TEXTURE0_ARB);
glBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, waveFP2 );
glEnable( GL_FRAGMENT_PROGRAM_ARB );
glBindProgramARB( GL_VERTEX_PROGRAM_ARB, waveVP2 );
glEnable( GL_VERTEX_PROGRAM_ARB );
//update flows pass
int resetTexs[]={0,1,2,3,4,5,-1};
DrawUpdateSquare(dx,dy,resetTexs);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glFlush();
///////////////////////////////////////
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, frameBuffer);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, waveTex2, 0);
status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
logOutput.Print("FBO not ready1");
glActiveTextureARB(GL_TEXTURE0_ARB);
glBindTexture(GL_TEXTURE_2D,waveTex1);
glActiveTextureARB(GL_TEXTURE1_ARB);
glBindTexture(GL_TEXTURE_2D,waveTex3);
glActiveTextureARB(GL_TEXTURE2_ARB);
glBindTexture(GL_TEXTURE_2D,waveTex3);
glActiveTextureARB(GL_TEXTURE3_ARB);
glBindTexture(GL_TEXTURE_2D,waveTex3);
glActiveTextureARB(GL_TEXTURE4_ARB);
glBindTexture(GL_TEXTURE_2D,waveTex3);
glActiveTextureARB(GL_TEXTURE5_ARB);
glBindTexture(GL_TEXTURE_2D,waveTex3);
glActiveTextureARB(GL_TEXTURE6_ARB);
glBindTexture(GL_TEXTURE_2D,detailNormalTex);
glActiveTextureARB(GL_TEXTURE0_ARB);
glBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, waveFP );
glBindProgramARB( GL_VERTEX_PROGRAM_ARB, waveVP );
//update height pass
int resetTexs2[]={0,-1};
DrawUpdateSquare(dx,dy,resetTexs2);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glFlush();
////////////////////////////////
glActiveTextureARB(GL_TEXTURE0_ARB);
glBindTexture(GL_TEXTURE_2D,waveTex2);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glActiveTextureARB(GL_TEXTURE1_ARB);
glBindTexture(GL_TEXTURE_2D,waveTex2);
glActiveTextureARB(GL_TEXTURE2_ARB);
glBindTexture(GL_TEXTURE_2D,waveTex2);
glActiveTextureARB(GL_TEXTURE3_ARB);
glBindTexture(GL_TEXTURE_2D,waveTex2);
glActiveTextureARB(GL_TEXTURE4_ARB);
glBindTexture(GL_TEXTURE_2D,0);
glActiveTextureARB(GL_TEXTURE5_ARB);
glBindTexture(GL_TEXTURE_2D,0);
glActiveTextureARB(GL_TEXTURE6_ARB);
glBindTexture(GL_TEXTURE_2D,0);
glActiveTextureARB(GL_TEXTURE0_ARB);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, frameBuffer);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, waveTex1, 0);
status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
logOutput.Print("FBO not ready3");
glBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, waveNormalFP );
glBindProgramARB( GL_VERTEX_PROGRAM_ARB, waveNormalVP );
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,0, 0, 0, W_SIZE*2, 0);
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,1, W_SIZE*2, 0, 0, 0);
//update normals pass
glBegin(GL_QUADS);
glTexCoord2f(start,start);glVertex3f(0,0,0);
glTexCoord2f(start,end);glVertex3f(0,1,0);
glTexCoord2f(end,end);glVertex3f(1,1,0);
glTexCoord2f(end,start);glVertex3f(1,0,0);
glEnd();
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glFlush();
glDisable(GL_VERTEX_PROGRAM_ARB);
glDisable(GL_FRAGMENT_PROGRAM_ARB);
glActiveTextureARB(GL_TEXTURE0_ARB);
glBindTexture(GL_TEXTURE_2D,0);
glActiveTextureARB(GL_TEXTURE1_ARB);
glBindTexture(GL_TEXTURE_2D,0);
glActiveTextureARB(GL_TEXTURE2_ARB);
glBindTexture(GL_TEXTURE_2D,0);
glActiveTextureARB(GL_TEXTURE3_ARB);
glBindTexture(GL_TEXTURE_2D,0);
glActiveTextureARB(GL_TEXTURE0_ARB);
unsigned int temp=waveTex1;
waveTex1=waveTex2;
waveTex2=waveTex3;
waveTex3=temp;
}
void CShadowHandler::CreateShadows(void)
{
fb.Bind();
glDisable(GL_BLEND);
glDisable(GL_LIGHTING);
glDisable(GL_ALPHA_TEST);
glDisable(GL_TEXTURE_2D);
glShadeModel(GL_FLAT);
glColor4f(1, 1, 1, 1);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
glDepthMask(GL_TRUE);
glEnable(GL_DEPTH_TEST);
glViewport(0, 0, shadowMapSize, shadowMapSize);
// glClearColor(0, 0, 0, 0);
// glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glClear(GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, 1, 0, 1, 0, -1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
cross1 = (mapInfo->light.sunDir.cross(UpVector)).ANormalize();
cross2 = cross1.cross(mapInfo->light.sunDir);
centerPos = camera->pos;
//! derive the size of the shadow-map from the
//! intersection points of the camera frustum
//! with the xz-plane
CalcMinMaxView();
SetShadowMapSizeFactors();
// it should be possible to tweak a bit more shadow map resolution from this
const float maxLength = 12000.0f;
const float maxLengthX = (x2 - x1) * 1.5f;
const float maxLengthY = (y2 - y1) * 1.5f;
#if (SHADOWMATRIX_NONLINEAR == 1)
xmid = 1.0f - (sqrt(fabs(x2)) / (sqrt(fabs(x2)) + sqrt(fabs(x1))));
ymid = 1.0f - (sqrt(fabs(y2)) / (sqrt(fabs(y2)) + sqrt(fabs(y1))));
#else
xmid = 0.5f;
ymid = 0.5f;
#endif
shadowMatrix[ 0] = cross1.x / maxLengthX;
shadowMatrix[ 4] = cross1.y / maxLengthX;
shadowMatrix[ 8] = cross1.z / maxLengthX;
shadowMatrix[12] = -(cross1.dot(centerPos)) / maxLengthX;
shadowMatrix[ 1] = cross2.x / maxLengthY;
shadowMatrix[ 5] = cross2.y / maxLengthY;
shadowMatrix[ 9] = cross2.z / maxLengthY;
shadowMatrix[13] = -(cross2.dot(centerPos)) / maxLengthY;
shadowMatrix[ 2] = -mapInfo->light.sunDir.x / maxLength;
shadowMatrix[ 6] = -mapInfo->light.sunDir.y / maxLength;
shadowMatrix[10] = -mapInfo->light.sunDir.z / maxLength;
shadowMatrix[14] = ((centerPos.x * mapInfo->light.sunDir.x + centerPos.z * mapInfo->light.sunDir.z) / maxLength) + 0.5f;
glLoadMatrixf(shadowMatrix.m);
//! set the shadow-parameter registers
//! NOTE: so long as any part of Spring rendering still uses
//! ARB programs at run-time, these lines can not be removed
//! (all ARB programs share the same environment)
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 16, xmid, ymid, 0.0f, 0.0f);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 17, p17, p17, 0.0f, 0.0f);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 18, p18, p18, 0.0f, 0.0f);
if (globalRendering->haveGLSL) {
for (int i = 0; i < SHADOWGEN_PROGRAM_LAST; i++) {
shadowGenProgs[i]->Enable();
shadowGenProgs[i]->SetUniform4f(0, xmid, ymid, p17, p18);
shadowGenProgs[i]->Disable();
}
}
//! move view into sun-space
float3 oldup = camera->up;
camera->right = cross1;
camera->up = cross2;
camera->pos2 = camera->pos + mapInfo->light.sunDir * 8000;
DrawShadowPasses();
camera->up = oldup;
camera->pos2 = camera->pos;
shadowMatrix[14] -= 0.00001f;
glShadeModel(GL_SMOOTH);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
//we do this later to save render context switches (this is one of the slowest opengl operations!)
//fb.Unbind();
//glViewport(globalRendering->viewPosX,0,globalRendering->viewSizeX,globalRendering->viewSizeY);
}
void CShadowHandler::CreateShadows()
{
fb.Bind();
glDisable(GL_BLEND);
glDisable(GL_LIGHTING);
glDisable(GL_ALPHA_TEST);
glDisable(GL_TEXTURE_2D);
glShadeModel(GL_FLAT);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
glDepthMask(GL_TRUE);
glEnable(GL_DEPTH_TEST);
glViewport(0, 0, shadowMapSize, shadowMapSize);
// glClearColor(0, 0, 0, 0);
// glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glClear(GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, 1, 0, 1, 0, -1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
const ISkyLight* L = sky->GetLight();
// sun direction is in world-space, invert it
sunDirZ = -L->GetLightDir();
sunDirX = (sunDirZ.cross(UpVector)).ANormalize();
sunDirY = (sunDirX.cross(sunDirZ)).ANormalize();
SetShadowMapSizeFactors();
// NOTE:
// the xy-scaling factors from CalcMinMaxView do not change linearly
// or smoothly with camera movements, creating visible artefacts (eg.
// large jumps in shadow resolution)
//
// therefore, EITHER use "fixed" scaling values such that the entire
// map barely fits into the sun's frustum (by pretending it is embedded
// in a sphere and taking its diameter), OR variable scaling such that
// everything that can be seen by the camera maximally fills the sun's
// frustum (choice of projection-style is left to the user and can be
// changed at run-time)
//
// the first option means larger maps will have more blurred/aliased
// shadows if the depth buffer is kept at the same size, but no (map)
// geometry is ever omitted
//
// the second option means shadows have higher average resolution, but
// become less sharp as the viewing volume increases (through eg.camera
// rotations) and geometry can be omitted in some cases
//
// NOTE:
// when DynamicSun is enabled, the orbit is always circular in the xz
// plane, instead of elliptical when the map has an aspect-ratio != 1
//
const float xyScale = GetShadowProjectionRadius(camera, centerPos, -sunDirZ);
const float xScale = xyScale;
const float yScale = xyScale;
const float zScale = globalRendering->viewRange;
shadowMatrix[ 0] = sunDirX.x / xScale;
shadowMatrix[ 1] = sunDirY.x / yScale;
shadowMatrix[ 2] = sunDirZ.x / zScale;
shadowMatrix[ 4] = sunDirX.y / xScale;
shadowMatrix[ 5] = sunDirY.y / yScale;
shadowMatrix[ 6] = sunDirZ.y / zScale;
shadowMatrix[ 8] = sunDirX.z / xScale;
shadowMatrix[ 9] = sunDirY.z / yScale;
shadowMatrix[10] = sunDirZ.z / zScale;
// rotate the target position into sun-space for the translation
shadowMatrix[12] = (-sunDirX.dot(centerPos) / xScale);
shadowMatrix[13] = (-sunDirY.dot(centerPos) / yScale);
shadowMatrix[14] = (-sunDirZ.dot(centerPos) / zScale) + 0.5f;
glLoadMatrixf(shadowMatrix.m);
// set the shadow-parameter registers
// NOTE: so long as any part of Spring rendering still uses
// ARB programs at run-time, these lines can not be removed
// (all ARB programs share the same environment)
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 16, shadowTexProjCenter.x, shadowTexProjCenter.y, 0.0f, 0.0f);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 17, shadowTexProjCenter.z, shadowTexProjCenter.z, 0.0f, 0.0f);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 18, shadowTexProjCenter.w, shadowTexProjCenter.w, 0.0f, 0.0f);
if (globalRendering->haveGLSL) {
for (int i = 0; i < SHADOWGEN_PROGRAM_LAST; i++) {
shadowGenProgs[i]->Enable();
shadowGenProgs[i]->SetUniform4fv(0, &shadowTexProjCenter.x);
shadowGenProgs[i]->Disable();
}
}
if (L->GetLightIntensity() > 0.0f) {
// move view into sun-space
const float3 oldup = camera->up;
camera->right = sunDirX;
camera->up = sunDirY;
DrawShadowPasses();
camera->up = oldup;
}
glShadeModel(GL_SMOOTH);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
// we do this later to save render context switches (this is one of the slowest opengl operations!)
// fb.Unbind();
// glViewport(globalRendering->viewPosX,0,globalRendering->viewSizeX,globalRendering->viewSizeY);
}
void CDynWater::DrawDetailNormalTex(void)
{
for(int a=0;a<8;++a){
glActiveTextureARB(GL_TEXTURE0_ARB+a);
glBindTexture(GL_TEXTURE_2D,rawBumpTexture[0]);
}
glActiveTextureARB(GL_TEXTURE0_ARB);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, frameBuffer);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, detailNormalTex, 0);
glViewport(0,0,256,256);
int status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
logOutput.Print("FBO not ready5");
glBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, dwDetailNormalFP );
glEnable( GL_FRAGMENT_PROGRAM_ARB );
glBindProgramARB( GL_VERTEX_PROGRAM_ARB, dwDetailNormalVP );
glEnable( GL_VERTEX_PROGRAM_ARB );
float swh=0.05f; //height of detail normal waves
float lwh=1.0f; //height of larger ambient waves
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 9, gs->frameNum, 0, 0, 0);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 10, 5, 0, 0, 1.0f/120); //controls the position and speed of the waves
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 11, 14, 0, 0, 1.0f/90);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 12, 29, 0, 0, 1.0f/55);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 13, 9, 4, 0, 1.0f/100);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 14, -5, 14, 0, 1.0f/90);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 15, 27, 27, 0, 1.0f/75);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 16, -3, -5, 0, 1.0f/100);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 17, -10, 24, 0, 1.0f/60);
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,0, 0.2f*swh, 0.0f*swh, 0.7f*lwh, 0); //controls the height of the waves
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,1, 0.2f*swh, 0.0f*swh, 0.7f*lwh, 0);
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,2, 0.2f*swh, 0.0f*swh, 0.7f*lwh, 0);
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,3, 0.2f*swh, 0.01f*swh, 0.4f*lwh, 0);
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,4, 0.07f*swh, 0.2f*swh, 0.7f*lwh, 0);
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,5, 0.2f*swh, 0.2f*swh, 0.7f*lwh, 0);
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,6, 0.12f*swh, 0.2f*swh, 0.7f*lwh, 0);
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,7, 0.08f*swh, 0.2f*swh, 0.7f*lwh, 0);
//update detail normals
glBegin(GL_QUADS);
glTexCoord2f(0,0);glVertex3f(0,0,0);
glTexCoord2f(0,1);glVertex3f(0,1,0);
glTexCoord2f(1,1);glVertex3f(1,1,0);
glTexCoord2f(1,0);glVertex3f(1,0,0);
glEnd();
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glDisable( GL_FRAGMENT_PROGRAM_ARB );
glDisable( GL_VERTEX_PROGRAM_ARB );
glFlush();
glBindTexture(GL_TEXTURE_2D,detailNormalTex);
glGenerateMipmapEXT(GL_TEXTURE_2D);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_glProgramEnvParameter4fARB(JNIEnv *__env, jclass clazz, jint target, jint index, jfloat x, jfloat y, jfloat z, jfloat w) {
glProgramEnvParameter4fARBPROC glProgramEnvParameter4fARB = (glProgramEnvParameter4fARBPROC)tlsGetFunction(1382);
UNUSED_PARAM(clazz)
glProgramEnvParameter4fARB(target, index, x, y, z, w);
}
void CAdvWater::Draw(bool useBlending)
{
if(readmap->minheight>10)
return;
float3 dir,zpos;
float3 base=camera->CalcPixelDir(0,gu->screeny);
float3 dv=camera->CalcPixelDir(0,0)-camera->CalcPixelDir(0,gu->screeny);
float3 dh=camera->CalcPixelDir(gu->screenx,0)-camera->CalcPixelDir(0,0);
float3 xbase;
const int numDivs=20;
base*=numDivs;
float maxY=-0.1f;
float yInc=1.0f/numDivs;
float screenY=1;
unsigned char col[4];
col[0]=(unsigned char)(waterSurfaceColor.x*255);
col[1]=(unsigned char)(waterSurfaceColor.y*255);
col[2]=(unsigned char)(waterSurfaceColor.z*255);
glDisable(GL_ALPHA_TEST);
if(useBlending) {
glEnable(GL_BLEND);
} else
glDisable(GL_BLEND);
glDepthMask(0);
glBindTexture(GL_TEXTURE_2D, reflectTexture);
glActiveTextureARB(GL_TEXTURE1_ARB);
glBindTexture(GL_TEXTURE_2D, bumpTexture);
GLfloat plan[]={0.02f,0,0,0};
glTexGeni(GL_S,GL_TEXTURE_GEN_MODE,GL_EYE_LINEAR);
glTexGenfv(GL_S,GL_EYE_PLANE,plan);
glEnable(GL_TEXTURE_GEN_S);
GLfloat plan2[]={0,0,0.02f,0};
glTexGeni(GL_T,GL_TEXTURE_GEN_MODE,GL_EYE_LINEAR);
glTexGenfv(GL_T,GL_EYE_PLANE,plan2);
glEnable(GL_TEXTURE_GEN_T);
glActiveTextureARB(GL_TEXTURE0_ARB);
glBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, waterFP );
glEnable( GL_FRAGMENT_PROGRAM_ARB );
float3 forward=camera->forward;
forward.y=0;
forward.Normalize();
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,0, forward.z,forward.x,0,0);
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,1, -forward.x,forward.z,0,0);
CVertexArray* va=GetVertexArray();
va->Initialize();
for(int a=0;a<5;++a){
bool maxReached=false;
for(int y=0;y<numDivs;++y){
dir=base;
dir.Normalize();
if(dir.y>=maxY){
maxReached=true;
break;
}
xbase=base;
for(int x=0;x<numDivs+1;++x){
dir=xbase+dv;
dir.Normalize();
zpos=camera->pos+dir*(camera->pos.y/-dir.y);
zpos.y=sin(zpos.z*0.1+gs->frameNum*0.06)*0.06+0.05;
col[3]=(unsigned char)((0.8+0.7*(dir.y))*255);
va->AddVertexTC(zpos,x*(1.0f/numDivs),screenY-yInc,col);
dir=xbase;
dir.Normalize();
zpos=camera->pos+dir*(camera->pos.y/-dir.y);
zpos.y=sin(zpos.z*0.1+gs->frameNum*0.06)*0.06+0.05;
col[3]=(unsigned char)((0.8+0.7*(dir.y))*255);
va->AddVertexTC(zpos,x*(1.0f/numDivs),screenY,col);
xbase+=dh;
}
va->EndStrip();
base+=dv;
screenY-=yInc;
}
if(!maxReached)
break;
dv*=0.5;
maxY*=0.5;
yInc*=0.5;
}
va->DrawArrayTC(GL_TRIANGLE_STRIP);
glDepthMask(1);
glDisable( GL_FRAGMENT_PROGRAM_ARB );
glActiveTextureARB(GL_TEXTURE1_ARB);
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glActiveTextureARB(GL_TEXTURE0_ARB);
if(!useBlending) // for translucent stuff like water, the default mode is blending and alpha testing enabled
glEnable(GL_BLEND);
}
void ARBProgramObject::SetUniform1i(int idx, int v0 ) { glProgramEnvParameter4fARB(uniformTarget, idx, float(v0), float( 0), float( 0), float( 0)); }
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBProgram_nglProgramEnvParameter4fARB(JNIEnv *env, jclass clazz, jint target, jint index, jfloat x, jfloat y, jfloat z, jfloat w, jlong function_pointer) {
glProgramEnvParameter4fARBPROC glProgramEnvParameter4fARB = (glProgramEnvParameter4fARBPROC)((intptr_t)function_pointer);
glProgramEnvParameter4fARB(target, index, x, y, z, w);
}
void CDynWater::AddShipWakes()
{
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, frameBuffer);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, waveTex1, 0);
glViewport(0,0,1024,1024);
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0,1,0,1,-1,1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
GLenum status;
status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
logOutput.Print("FBO not ready6");
glBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, dwAddSplashFP );
glEnable( GL_FRAGMENT_PROGRAM_ARB );
glBindProgramARB( GL_VERTEX_PROGRAM_ARB, dwAddSplashVP );
glEnable( GL_VERTEX_PROGRAM_ARB );
glDisable(GL_CULL_FACE);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 10, 1.0f/WF_SIZE, 1.0f/WF_SIZE, 0, 1);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 11, -(oldCamPosBig.x-WH_SIZE)/WF_SIZE, -(oldCamPosBig.z-WH_SIZE)/WF_SIZE, 0, 0);
CVertexArray* va=GetVertexArray();
va->Initialize();
CVertexArray* va2=GetVertexArray(); //never try to get more than 2 at once
va2->Initialize();
{
GML_RECMUTEX_LOCK(unit); // AddShipWakes
int nadd=uh->renderUnits.size()*4;
va->EnlargeArrays(nadd,0,VA_SIZE_TN);
va2->EnlargeArrays(nadd,0,VA_SIZE_TN);
for(std::list<CUnit*>::iterator ui=uh->renderUnits.begin(); ui!=uh->renderUnits.end();++ui){
CUnit* unit=*ui;
if(unit->moveType && unit->mobility) {
if(unit->unitDef->canhover){ //hover
float3 pos=unit->pos;
if(fabs(pos.x-camPosBig.x)>WH_SIZE-50 || fabs(pos.z-camPosBig.z)>WH_SIZE-50)
continue;
if(!(unit->losStatus[gu->myAllyTeam] & LOS_INLOS) && !gu->spectatingFullView)
continue;
if(pos.y>-4 && pos.y<4){
float3 frontAdd=unit->frontdir*unit->radius*0.75f;
float3 sideAdd=unit->rightdir*unit->radius*0.75f;
float depth=sqrt(sqrt(unit->mass))*0.4f;
float3 n(depth, 0.05f*depth, depth);
va2->AddVertexQTN(pos+frontAdd+sideAdd,0,0,n);
va2->AddVertexQTN(pos+frontAdd-sideAdd,1,0,n);
va2->AddVertexQTN(pos-frontAdd-sideAdd,1,1,n);
va2->AddVertexQTN(pos-frontAdd+sideAdd,0,1,n);
}
}
else if(unit->floatOnWater){ //boat
float speedf=unit->speed.Length2D();
float3 pos=unit->pos;
if(fabs(pos.x-camPosBig.x)>WH_SIZE-50 || fabs(pos.z-camPosBig.z)>WH_SIZE-50)
continue;
if(!(unit->losStatus[gu->myAllyTeam] & LOS_INLOS) && !gu->spectatingFullView)
continue;
if(pos.y>-4 && pos.y<1){
float3 frontAdd=unit->frontdir*unit->radius*0.75f;
float3 sideAdd=unit->rightdir*unit->radius*0.18f;
float depth=sqrt(sqrt(unit->mass));
float3 n(depth, 0.04f*speedf*depth, depth);
va->AddVertexQTN(pos+frontAdd+sideAdd,0,0,n);
va->AddVertexQTN(pos+frontAdd-sideAdd,1,0,n);
va->AddVertexQTN(pos-frontAdd-sideAdd,1,1,n);
va->AddVertexQTN(pos-frontAdd+sideAdd,0,1,n);
}
}
}
}
}
glActiveTextureARB(GL_TEXTURE0_ARB);
glBindTexture(GL_TEXTURE_2D,boatShape);
va->DrawArrayTN(GL_QUADS);
glActiveTextureARB(GL_TEXTURE0_ARB);
glBindTexture(GL_TEXTURE_2D,hoverShape);
va2->DrawArrayTN(GL_QUADS);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glDisable(GL_BLEND);
glDisable( GL_FRAGMENT_PROGRAM_ARB );
glDisable( GL_VERTEX_PROGRAM_ARB );
glFlush();
}
void Renderer::SetVSConstant4f(unsigned int const_number, float f1, float f2, float f3, float f4)
{
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, const_number, f1, f2, f3, f4);
}
void CAdvWater::Draw(bool useBlending)
{
if (!mapInfo->water.forceRendering && (readmap->currMinHeight > 1.0f)) {
return;
}
float3 base = camera->CalcPixelDir(globalRendering->viewPosX, globalRendering->viewSizeY);
float3 dv = camera->CalcPixelDir(globalRendering->viewPosX, 0) - camera->CalcPixelDir(globalRendering->viewPosX, globalRendering->viewSizeY);
float3 dh = camera->CalcPixelDir(globalRendering->viewPosX + globalRendering->viewSizeX, 0) - camera->CalcPixelDir(globalRendering->viewPosX, 0);
float3 xbase;
const int numDivs = 20;
base *= numDivs;
float maxY = -0.1f;
float yInc = 1.0f / numDivs;
float screenY = 1;
unsigned char col[4];
col[0] = (unsigned char)(waterSurfaceColor.x * 255);
col[1] = (unsigned char)(waterSurfaceColor.y * 255);
col[2] = (unsigned char)(waterSurfaceColor.z * 255);
glDisable(GL_ALPHA_TEST);
if (useBlending) {
glEnable(GL_BLEND);
} else {
glDisable(GL_BLEND);
}
glDepthMask(0);
glActiveTextureARB(GL_TEXTURE1_ARB);
glBindTexture(GL_TEXTURE_2D, bumpTexture);
GLfloat plan[] = {0.02f, 0, 0, 0};
glTexGeni(GL_S,GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGenfv(GL_S,GL_EYE_PLANE, plan);
glEnable(GL_TEXTURE_GEN_S);
GLfloat plan2[] = {0, 0, 0.02f, 0};
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGenfv(GL_T, GL_EYE_PLANE, plan2);
glEnable(GL_TEXTURE_GEN_T);
glActiveTextureARB(GL_TEXTURE0_ARB);
glBindTexture(GL_TEXTURE_2D, reflectTexture);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, waterFP);
glEnable(GL_FRAGMENT_PROGRAM_ARB);
float3 forward = camera->forward;
forward.y = 0;
forward.ANormalize();
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 0, forward.z, forward.x, 0, 0);
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 1, -forward.x, forward.z, 0, 0);
CVertexArray* va = GetVertexArray();
va->Initialize();
va->EnlargeArrays(5*numDivs*(numDivs + 1)*2, 5*numDivs, VA_SIZE_TC); //! alloc room for all vertexes and strips
float3 dir, zpos;
for (int a = 0; a < 5; ++a) { //! CAUTION: loop count must match EnlargeArrays above
bool maxReached = false;
for (int y = 0; y < numDivs; ++y) {
dir = base;
dir.ANormalize();
if (dir.y >= maxY) {
maxReached = true;
break;
}
xbase = base;
for (int x = 0; x < numDivs + 1; ++x) { //! CAUTION: loop count must match EnlargeArrays above
dir = xbase + dv;
dir.ANormalize();
zpos = camera->pos + dir*(camera->pos.y / -dir.y);
zpos.y = sin(zpos.z*0.1f + gs->frameNum*0.06f)*0.06f + 0.05f;
col[3] = (unsigned char)((0.8f + 0.7f*dir.y)*255);
va->AddVertexQTC(zpos, x*(1.0f/numDivs), screenY - yInc, col);
dir = xbase;
dir.ANormalize();
zpos = camera->pos + dir*(camera->pos.y / -dir.y);
zpos.y = sin(zpos.z*0.1f + gs->frameNum*0.06f)*0.06f + 0.05f;
col[3] = (unsigned char)((0.8f + 0.7f*dir.y)*255);
va->AddVertexQTC(zpos, x*(1.0f/numDivs), screenY, col);
xbase += dh;
}
va->EndStripQ();
base += dv;
screenY -= yInc;
}
if (!maxReached) {
break;
}
dv *= 0.5f;
maxY *= 0.5f;
yInc *= 0.5f;
}
va->DrawArrayTC(GL_TRIANGLE_STRIP);
glDepthMask(1);
glDisable(GL_FRAGMENT_PROGRAM_ARB);
glActiveTextureARB(GL_TEXTURE1_ARB);
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glActiveTextureARB(GL_TEXTURE0_ARB);
if (!useBlending) { // for translucent stuff like water, the default mode is blending and alpha testing enabled
glEnable(GL_BLEND);
}
}
void CDynWater::AddExplosions()
{
GML_STDMUTEX_LOCK(water); // AddExplosions
if(explosions.empty())
return;
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, frameBuffer);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, waveTex1, 0);
glViewport(0,0,1024,1024);
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0,1,0,1,-1,1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glActiveTextureARB(GL_TEXTURE0_ARB);
glBindTexture(GL_TEXTURE_2D,splashTex);
GLenum status;
status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
logOutput.Print("FBO not ready7");
glBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, dwAddSplashFP );
glEnable( GL_FRAGMENT_PROGRAM_ARB );
glBindProgramARB( GL_VERTEX_PROGRAM_ARB, dwAddSplashVP );
glEnable( GL_VERTEX_PROGRAM_ARB );
glDisable(GL_CULL_FACE);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 10, 1.0f/WF_SIZE, 1.0f/WF_SIZE, 0, 1);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 11, -(oldCamPosBig.x-WH_SIZE)/WF_SIZE, -(oldCamPosBig.z-WH_SIZE)/WF_SIZE, 0, 0);
CVertexArray* va=GetVertexArray();
va->Initialize();
int nadd=explosions.size()*4;
va->EnlargeArrays(nadd,0,VA_SIZE_TN);
for(std::vector<Explosion>::iterator ei=explosions.begin(); ei!=explosions.end();++ei){
Explosion& explo=*ei;
float3 pos=explo.pos;
if(fabs(pos.x-camPosBig.x)>WH_SIZE-50 || fabs(pos.z-camPosBig.z)>WH_SIZE-50)
continue;
float inv=1.01f;
if(pos.y<0){
if(pos.y<-explo.radius*0.5f)
inv=0.99f;
pos.y=pos.y*-0.5f;
}
float size=explo.radius-pos.y;
if(size<8)
continue;
float strength=explo.strength * (size/explo.radius)*0.5f;
float3 n(strength, strength*0.005f, strength*inv);
va->AddVertexQTN(pos+float3(1,0,1)*size,0,0,n);
va->AddVertexQTN(pos+float3(-1,0,1)*size,1,0,n);
va->AddVertexQTN(pos+float3(-1,0,-1)*size,1,1,n);
va->AddVertexQTN(pos+float3(1,0,-1)*size,0,1,n);
}
explosions.clear();
va->DrawArrayTN(GL_QUADS);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glDisable(GL_BLEND);
glDisable( GL_FRAGMENT_PROGRAM_ARB );
glDisable( GL_VERTEX_PROGRAM_ARB );
glFlush();
}
void CShadowHandler::CreateShadows(void)
{
fb.Bind();
glDisable(GL_BLEND);
glDisable(GL_LIGHTING);
glDisable(GL_ALPHA_TEST);
glDisable(GL_TEXTURE_2D);
glShadeModel(GL_FLAT);
glColor4f(1, 1, 1, 1);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
glViewport(0,0,shadowMapSize,shadowMapSize);
//glClearColor(0, 0, 0, 0);
//glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glClear(GL_DEPTH_BUFFER_BIT);
firstDraw=false;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0,1,0,1,0,-1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
float3 sundir=mapInfo->light.sunDir;
cross1=(sundir.cross(UpVector)).ANormalize();
cross2=cross1.cross(sundir);
centerPos=camera->pos;
// centerPos.x=((int)((centerPos.x+4)/8))*8;
// centerPos.y=((int)((centerPos.y+4)/8))*8;
// centerPos.z=((int)((centerPos.z+4)/8))*8;
// centerPos.y=(ground->GetHeight(centerPos.x,centerPos.z));
CalcMinMaxView();
//it should be possible to tweak a bit more shadow map resolution from this
float maxLength=12000;
float maxLengthX=(x2-x1)*1.5f;
float maxLengthY=(y2-y1)*1.5f;
xmid=1-(sqrt(fabs(x2))/(sqrt(fabs(x2))+sqrt(fabs(x1))));
ymid=1-(sqrt(fabs(y2))/(sqrt(fabs(y2))+sqrt(fabs(y1))));
//logOutput.Print("%.0f %.0f %.2f %.0f",y1,y2,ymid,maxLengthY);
shadowMatrix[0]=cross1.x/maxLengthX;
shadowMatrix[4]=cross1.y/maxLengthX;
shadowMatrix[8]=cross1.z/maxLengthX;
shadowMatrix[12]=-(cross1.dot(centerPos))/maxLengthX;
shadowMatrix[1]=cross2.x/maxLengthY;
shadowMatrix[5]=cross2.y/maxLengthY;
shadowMatrix[9]=cross2.z/maxLengthY;
shadowMatrix[13]=-(cross2.dot(centerPos))/maxLengthY;
shadowMatrix[2]=-sundir.x/maxLength;
shadowMatrix[6]=-sundir.y/maxLength;
shadowMatrix[10]=-sundir.z/maxLength;
shadowMatrix[14]=(centerPos.x*sundir.x+centerPos.z*sundir.z)/maxLength+0.5f;
glLoadMatrixf(shadowMatrix.m);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,16, xmid,ymid,0,0); //these registers should not be overwritten by anything
GetShadowMapSizeFactors(p17, p18);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,17, p17,p17,0.0f,0.0f); //these registers should not be overwritten by anything
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB,18, p18,p18,0.0f,0.0f); //these registers should not be overwritten by anything
float3 oldup=camera->up;
camera->right=shadowHandler->cross1;
camera->up=shadowHandler->cross2;
camera->pos2=camera->pos+sundir*8000;
DrawShadowPasses();
camera->up=oldup;
camera->pos2=camera->pos;
shadowMatrix[14]-=0.00001f;
glShadeModel(GL_SMOOTH);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
fb.Unbind();
glViewport(gu->viewPosX,0,gu->viewSizeX,gu->viewSizeY);
}
void CDynWater::Draw()
{
if (!mapInfo->water.forceRendering && readmap->currMinHeight > 1.0f)
return;
glDisable(GL_BLEND);
glDisable(GL_ALPHA_TEST);
glEnable(GL_FOG);
glActiveTextureARB(GL_TEXTURE0_ARB);
glBindTexture(GL_TEXTURE_2D, waveTex3);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glActiveTextureARB(GL_TEXTURE1_ARB);
glBindTexture(GL_TEXTURE_2D,reflectTexture);
glActiveTextureARB(GL_TEXTURE2_ARB);
glBindTexture(GL_TEXTURE_2D,waveHeight32);
glActiveTextureARB(GL_TEXTURE3_ARB);
glBindTexture(GL_TEXTURE_2D,refractTexture);
glActiveTextureARB(GL_TEXTURE4_ARB);
glBindTexture(GL_TEXTURE_2D,readmap->GetShadingTexture());
glActiveTextureARB(GL_TEXTURE5_ARB);
glBindTexture(GL_TEXTURE_2D,foamTex);
glActiveTextureARB(GL_TEXTURE6_ARB);
glBindTexture(GL_TEXTURE_2D,detailNormalTex);
glActiveTextureARB(GL_TEXTURE7_ARB);
glBindTexture(GL_TEXTURE_2D,shadowHandler->shadowTexture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC_ARB, GL_LEQUAL);
glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE_ARB, GL_LUMINANCE);
glActiveTextureARB(GL_TEXTURE0_ARB);
glColor4f(1,1,1,0.5f);
glBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, waterFP );
glEnable( GL_FRAGMENT_PROGRAM_ARB );
glBindProgramARB( GL_VERTEX_PROGRAM_ARB, waterVP );
glEnable( GL_VERTEX_PROGRAM_ARB );
float dx=float(gu->viewSizeX)/gu->viewSizeY * camera->GetTanHalfFov();
float dy=float(gu->viewSizeY)/gu->viewSizeY * camera->GetTanHalfFov();
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 10, 1.0f/(W_SIZE*256),1.0f/(W_SIZE*256), 0, 0);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 11, -camPosX/256.0f+0.5f,-camPosZ/256.0f+0.5f, 0, 0);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 12, 1.0f/WF_SIZE,1.0f/WF_SIZE, 0, 0);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 13, -(camPosBig.x-WH_SIZE)/WF_SIZE,-(camPosBig.z-WH_SIZE)/WF_SIZE, 0, 0);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 14, 1.0f/(gs->pwr2mapx*SQUARE_SIZE),1.0f/(gs->pwr2mapy*SQUARE_SIZE), 0, 0);
// glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,0, 1.0f/4096.0f,1.0f/4096.0f,0,0);
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,1, camera->pos.x,camera->pos.y,camera->pos.z,0);
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,2, reflectRight.x,reflectRight.y,reflectRight.z,0);
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,3, reflectUp.x,reflectUp.y,reflectUp.z,0);
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,4, 0.5f/dx,0.5f/dy,1,1);
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,5, reflectForward.x,reflectForward.y,reflectForward.z,0);
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,6, 0.05f, 1-0.05f, 0, 0);
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,7, 0.2f, 0, 0, 0);
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,8, 0.5f, 0.6f, 0.8f, 0);
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,9, mapInfo->light.sunDir.x, mapInfo->light.sunDir.y, mapInfo->light.sunDir.z, 0);
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,10, mapInfo->light.groundSunColor.x, mapInfo->light.groundSunColor.y, mapInfo->light.groundSunColor.z, 0);
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,11, mapInfo->light.groundAmbientColor.x, mapInfo->light.groundAmbientColor.y, mapInfo->light.groundAmbientColor.z, 0);
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,12, refractRight.x,refractRight.y,refractRight.z,0);
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,13, refractUp.x,refractUp.y,refractUp.z,0);
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,14, 0.5f/dx,0.5f/dy,1,1);
glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB,15, refractForward.x,refractForward.y,refractForward.z,0);
DrawWaterSurface();
glBindTexture(GL_TEXTURE_2D, fixedUpTex);
DrawOuterSurface();
glDisable( GL_FRAGMENT_PROGRAM_ARB );
glDisable( GL_VERTEX_PROGRAM_ARB );
/*
glBindTexture(GL_TEXTURE_2D, 0);
glActiveTextureARB(GL_TEXTURE1_ARB);
glBindTexture(GL_TEXTURE_2D,0);
glActiveTextureARB(GL_TEXTURE2_ARB);
glBindTexture(GL_TEXTURE_2D,0);
glActiveTextureARB(GL_TEXTURE3_ARB);
glBindTexture(GL_TEXTURE_2D,0);
glActiveTextureARB(GL_TEXTURE4_ARB);
glBindTexture(GL_TEXTURE_2D,0);
glActiveTextureARB(GL_TEXTURE5_ARB);
glBindTexture(GL_TEXTURE_2D,0);
glActiveTextureARB(GL_TEXTURE6_ARB);
glBindTexture(GL_TEXTURE_2D,0);
glActiveTextureARB(GL_TEXTURE7_ARB);
glBindTexture(GL_TEXTURE_2D,0);
glActiveTextureARB(GL_TEXTURE0_ARB);
*/
}
