/*
===============
CreateDSTTex_ARB
Create the texture which warps texture shaders
===============
*/
void CreateDSTTex_ARB (void)
{
unsigned char dist[DST_SIZE][DST_SIZE][4];
int x,y;
srand(GetTickCount());
for (x=0; x<DST_SIZE; x++)
for (y=0; y<DST_SIZE; y++) {
dist[x][y][0] = rand()%255;
dist[x][y][1] = rand()%255;
dist[x][y][2] = rand()%48;
dist[x][y][3] = rand()%48;
}
qglGenTextures(1,&dst_texture_ARB);
qglBindTexture(GL_TEXTURE_2D, dst_texture_ARB);
qglTexImage2D (GL_TEXTURE_2D, 0, 4, DST_SIZE, DST_SIZE, 0, GL_RGBA, GL_UNSIGNED_BYTE, dist);
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
qglHint(GL_GENERATE_MIPMAP_HINT_SGIS, GL_NICEST);
qglTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, GL_TRUE);
}
/*
=================
R_Fog (void)
=================
*/
void R_Fog( glfog_t *curfog ) {
if ( !r_wolffog->integer ) {
R_FogOff();
return;
}
if ( !curfog->registered ) { //----(SA)
R_FogOff();
return;
}
//----(SA) assme values of '0' for these parameters means 'use default'
if ( !curfog->density ) {
curfog->density = 1;
}
if ( !curfog->hint ) {
curfog->hint = GL_DONT_CARE;
}
if ( !curfog->mode ) {
curfog->mode = GL_LINEAR;
}
//----(SA) end
R_FogOn();
// only send changes if necessary
#ifndef VCMODS_OPENGLES
qglFogi( GL_FOG_MODE, curfog->mode );
#endif
qglFogfv( GL_FOG_COLOR, curfog->color );
qglFogf( GL_FOG_DENSITY, curfog->density );
qglHint( GL_FOG_HINT, curfog->hint );
qglFogf( GL_FOG_START, curfog->start );
if ( r_zfar->value ) { // (SA) allow override for helping level designers test fog distances
qglFogf( GL_FOG_END, r_zfar->value );
} else {
qglFogf( GL_FOG_END, curfog->end );
}
#ifndef VCMODS_OPENGLES
// TTimo - from SP NV fog code
// NV fog mode
if ( glConfig.NVFogAvailable ) {
qglFogi( GL_FOG_DISTANCE_MODE_NV, glConfig.NVFogMode );
}
// end
#endif
qglClearColor( curfog->color[0], curfog->color[1], curfog->color[2], curfog->color[3] );
}
/*
===========
R_Fog
NeVo - draw fog in an area
===========
*/
void R_Fog (fogmode_t fog)
{
float colors[4];
// disable fog for now
qglDisable(GL_FOG);
// Set up our colors
colors[0] = fog.red;
colors[1] = fog.green;
colors[2] = fog.blue;
colors[3] = fog.alpha;
// Set our mode
switch (fog.mode)
{
case FOGMODE_LINEAR:
qglFogi(GL_FOG_MODE, GL_LINEAR);
break;
case FOGMODE_EXP:
qglFogi(GL_FOG_MODE, GL_EXP);
break;
case FOGMODE_EXP2:
qglFogi(GL_FOG_MODE, GL_EXP2);
break;
default:
qglFogi(GL_FOG_MODE, GL_LINEAR);
break;
}
if (gl_config.coordinatefog && fog.usecoords)
qglFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT);
else
qglFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
// Hint for nicest fog possible
qglHint(GL_FOG_HINT, GL_NICEST);
qglFogfv(GL_FOG_COLOR, colors);
qglFogf(GL_FOG_START, fog.neardist);
qglFogf(GL_FOG_END, fog.fardist);
qglFogf(GL_FOG_DENSITY, fog.fogdensity);
// Reenable fog
if (gl_state.fogenabled)
qglEnable(GL_FOG);
}
/*
================
R_SetFog
================
*/
void R_SetFog (void)
{
if (!r_fogenable) // engine fog not enabled
return; // leave fog enabled if set by game DLL
r_fogColor[3] = 1.0;
qglEnable(GL_FOG);
qglClearColor (r_fogColor[0], r_fogColor[1], r_fogColor[2], r_fogColor[3]); // Clear the background color to the fog color
qglFogi(GL_FOG_MODE, r_fogmodel);
qglFogfv(GL_FOG_COLOR, r_fogColor);
if (r_fogmodel == GL_LINEAR)
{
qglFogf(GL_FOG_START, r_fognear);
qglFogf(GL_FOG_END, r_fogfar);
}
else
qglFogf(GL_FOG_DENSITY, r_fogdensity/10000.f);
qglHint (GL_FOG_HINT, GL_NICEST);
}
/*
=====================
RE_AddFogToScene
=====================
*/
void RE_AddFogToScene( float start, float end, float r, float g, float b, float opacity, float mode, float hint ) {
int fogMode[] = { GL_EXP, GL_EXP2, GL_LINEAR }; // Storage For Three Types Of Fog
int fogModefilter = mode; // Which Fog To Use
int fogHint[] = { GL_DONT_CARE, GL_FASTEST, GL_NICEST };// Storage For Three Types Of Fog
int fogHintfilter = hint; // Which Fog To Use
float fogColor[4] = {r, g, b, 1.0f}; // Fog Color
if ( ( start == 0 && end == 0 ) || opacity == 0 ){
qglDisable(GL_FOG); // Disables GL_FOG
return;
}
else
{
qglEnable(GL_FOG); // Enables GL_FOG
}
qglFogi(GL_FOG_MODE, fogMode[fogModefilter]); // Fog Mode
qglFogfv(GL_FOG_COLOR, fogColor); // Set Fog Color
qglFogf(GL_FOG_DENSITY, opacity); // How Dense Will The Fog Be
qglHint(GL_FOG_HINT, fogHint[fogHintfilter]); // Fog Hint Value
qglFogf(GL_FOG_START, start); // Fog Start Depth
qglFogf(GL_FOG_END, end); // Fog End Depth
}
/*
=================
RB_Fog
=================
*/
void RB_Fog( int fogNum ) {
//static int lastFogMode = 0;
//static vec3_t lastColor = { -1, -1, -1 };
//static float lastDensity = -1;
//static int lastHint = -1;
//static float lastStart = -1, lastEnd = -1;
int fogMode;
vec3_t color;
float density;
int hint;
float start, end;
if ( !r_useGlFog->integer ) {
R_FogOff();
lastGlfogType = FT_NONE;
return;
}
if ( R_IsGlobalFog( fogNum ) ) {
lastGlfogType = backEnd.refdef.fogType;
switch ( backEnd.refdef.fogType ) {
case FT_LINEAR:
fogMode = GL_LINEAR;
break;
case FT_EXP:
fogMode = GL_EXP;
break;
default:
R_FogOff();
lastGlfogType = FT_NONE;
return;
}
VectorCopy( backEnd.refdef.fogColor, color );
end = backEnd.refdef.fogDepthForOpaque;
density = backEnd.refdef.fogDensity;
} else {
fog_t *fog;
fog = tr.world->fogs + fogNum;
if ( !fog->shader ) {
R_FogOff();
lastGlfogType = FT_NONE;
return;
}
lastGlfogType = fog->shader->fogParms.fogType;
switch ( fog->shader->fogParms.fogType ) {
case FT_LINEAR:
fogMode = GL_LINEAR;
break;
case FT_EXP:
fogMode = GL_EXP;
break;
default:
R_FogOff();
return;
}
VectorCopy( fog->shader->fogParms.color, color );
end = fog->shader->fogParms.depthForOpaque;
density = fog->shader->fogParms.density;
}
hint = GL_DONT_CARE;
start = 0;
RB_FogOn();
// only send changes if necessary
//if ( fogMode != lastFogMode ) {
qglFogi( GL_FOG_MODE, fogMode );
// lastFogMode = fogMode;
//}
//if ( color[0] != lastColor[0] || color[1] != lastColor[1] || color[2] != lastColor[2] || !lastFogMode ) {
qglFogfv( GL_FOG_COLOR, color );
// VectorCopy( lastColor, color );
//}
//if ( density != lastDensity || !lastFogMode ) {
qglFogf( GL_FOG_DENSITY, density );
// lastDensity = density;
//}
//if ( hint != lastHint || !lastFogMode ) {
qglHint( GL_FOG_HINT, hint );
// lastHint = hint;
//}
//if ( start != lastStart || !lastFogMode ) {
qglFogf( GL_FOG_START, start );
// lastStart = start;
//}
//if ( end != lastEnd || !lastFogMode ) {
qglFogf( GL_FOG_END, end );
// lastEnd = end;
//}
#if 0 // ZTM: TODO: Add NVidia fog code?
// TTimo - from SP NV fog code
// NV fog mode
if ( glConfig.NVFogAvailable ) {
qglFogi( GL_FOG_DISTANCE_MODE_NV, glConfig.NVFogMode );
}
// end
#endif
//qglClearColor( color[0], color[1], color[2], 1.0f );
}
/*
=================
R_Fog (void)
=================
*/
void R_Fog(glfog_t *curfog) {
if (!r_wolffog->integer) {
R_FogOff();
return;
}
if (!curfog->registered) { //----(SA)
R_FogOff();
return;
}
//----(SA) assme values of '0' for these parameters means 'use default'
if (!curfog->density) {
curfog->density = 1;
}
if (!curfog->hint) {
curfog->hint = GL_DONT_CARE;
}
if (!curfog->mode) {
curfog->mode = GL_LINEAR;
}
//----(SA) end
R_FogOn();
qglFogi(GL_FOG_MODE, curfog->mode);
qglFogfv(GL_FOG_COLOR, curfog->color);
qglFogf(GL_FOG_DENSITY, curfog->density);
qglHint(GL_FOG_HINT, curfog->hint);
if (backEnd.refdef.rdflags & RDF_SNOOPERVIEW) {
qglFogf(GL_FOG_START, curfog->end); // snooper starts GL fog out further
} else {
qglFogf(GL_FOG_START, curfog->start);
}
if (r_zfar->value) { // (SA) allow override for helping level designers test fog distances
qglFogf(GL_FOG_END, r_zfar->value);
} else {
if (backEnd.refdef.rdflags & RDF_SNOOPERVIEW) {
qglFogf(GL_FOG_END, curfog->end + 1000); // snooper ends GL fog out further. this works fine with our maps, but could be 'funky' with later maps
}
else {
qglFogf(GL_FOG_END, curfog->end);
}
}
#ifndef USE_OPENGLES
//----(SA) added
// NV fog mode
if (glConfig.NVFogAvailable) {
qglFogi(GL_FOG_DISTANCE_MODE_NV, glConfig.NVFogMode);
}
//----(SA) end
#endif
qglClearColor(curfog->color[0], curfog->color[1], curfog->color[2], curfog->color[3]);
}
