/*
============
V_PolyBlend -- johnfitz -- moved here from gl_rmain.c, and rewritten to use glOrtho
============
*/
void V_PolyBlend (void)
{
if (!gl_polyblend.value || !v_blend[3])
return;
GL_DisableMultitexture();
glDisable (GL_ALPHA_TEST);
glDisable (GL_TEXTURE_2D);
glDisable (GL_DEPTH_TEST);
glEnable (GL_BLEND);
glMatrixMode(GL_PROJECTION);
glLoadIdentity ();
glOrtho (0, 1, 1, 0, -99999, 99999);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity ();
glColor4fv (v_blend);
glBegin (GL_QUADS);
glVertex2f (0,0);
glVertex2f (1, 0);
glVertex2f (1, 1);
glVertex2f (0, 1);
glEnd ();
glDisable (GL_BLEND);
glEnable (GL_DEPTH_TEST);
glEnable (GL_TEXTURE_2D);
glEnable (GL_ALPHA_TEST);
}
/*
============
R_PolyBlend
============
*/
void R_PolyBlend (void)
{
if (!gl_polyblend.value)
return;
if (!v_blend[3])
return;
GL_DisableMultitexture();
glDisable (GL_ALPHA_TEST);
glEnable (GL_BLEND);
glDisable (GL_DEPTH_TEST);
glDisable (GL_TEXTURE_2D);
glLoadIdentity ();
glRotatef (-90, 1, 0, 0); // put Z going up
glRotatef (90, 0, 0, 1); // put Z going up
glColor4fv (v_blend);
glBegin (GL_QUADS);
glVertex3f (10, 100, 100);
glVertex3f (10, -100, 100);
glVertex3f (10, -100, -100);
glVertex3f (10, 100, -100);
glEnd ();
glDisable (GL_BLEND);
glEnable (GL_TEXTURE_2D);
glEnable (GL_ALPHA_TEST);
}
/*
================
R_RenderScene
r_refdef must be set before the first call
================
*/
void R_RenderScene (void)
{
R_SetupFrame ();
R_SetFrustum ();
R_SetupGL ();
R_MarkLeaves (); // done here so we know if we're in water
R_DrawWorld (); // adds static entities to the list
S_ExtraUpdate (); // don't let sound get messed up if going slow
R_DrawEntitiesOnList ();
GL_DisableMultitexture();
R_RenderDlights ();
R_DrawParticles ();
#ifdef GLTEST
Test_Draw ();
#endif
}
static void R_DrawSkyDome (void)
{
int i;
GL_DisableMultitexture();
GL_Bind (solidskytexture);
speedscale = r_refdef2.time*8;
speedscale -= (int)speedscale & ~127;
for (i = 0; i < 6; i++) {
if ((skymins[0][i] >= skymaxs[0][i] || skymins[1][i] >= skymaxs[1][i]))
continue;
DrawSkyFace (i);
}
glEnable (GL_BLEND);
GL_Bind (alphaskytexture);
speedscale = r_refdef2.time*16;
speedscale -= (int)speedscale & ~127;
for (i = 0; i < 6; i++) {
if ((skymins[0][i] >= skymaxs[0][i] || skymins[1][i] >= skymaxs[1][i]))
continue;
DrawSkyFace (i);
}
}
/*
=================
R_DrawSkyChain
=================
*/
void R_DrawSkyChain (msurface_t *s)
{
GL_Use (gl_polygon1textureprogram);
glUniformMatrix4fv(gl_polygon1textureprogram_transform, 1, 0, gl_polygon_matrix);
msurface_t *fa;
GL_DisableMultitexture();
// used when gl_texsort is on
GL_Bind(solidskytexture);
speedscale = realtime*8;
speedscale -= (int)speedscale & ~127 ;
for (fa=s ; fa ; fa=fa->texturechain)
EmitSkyPolys (fa);
glEnable (GL_BLEND);
GL_Bind (alphaskytexture);
speedscale = realtime*16;
speedscale -= (int)speedscale & ~127 ;
for (fa=s ; fa ; fa=fa->texturechain)
EmitSkyPolys (fa);
glDisable (GL_BLEND);
}
/*
=================
R_DrawSkyChain
=================
*/
void
R_DrawSkyChain(msurface_t *s)
{
msurface_t *fa;
texture_t *t = s->texinfo->texture;
if (gl_mtexable) {
GL_SelectTexture(GL_TEXTURE0_ARB);
GL_Bind(t->gl_texturenum);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
GL_EnableMultitexture();
GL_Bind(t->gl_texturenum_alpha);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
speedscale = realtime * 8;
speedscale -= (int)speedscale & ~127;
speedscale2 = realtime * 16;
speedscale2 -= (int)speedscale2 & ~127;
for (fa = s; fa; fa = fa->texturechain)
EmitSkyPolysMtex(fa);
GL_DisableMultitexture();
} else {
GL_DisableMultitexture();
GL_Bind(t->gl_texturenum);
speedscale = realtime * 8;
speedscale -= (int)speedscale & ~127;
for (fa = s; fa; fa = fa->texturechain)
EmitSkyPolys(fa);
glEnable(GL_BLEND);
GL_Bind(t->gl_texturenum_alpha);
speedscale = realtime * 16;
speedscale -= (int)speedscale & ~127;
for (fa = s; fa; fa = fa->texturechain)
EmitSkyPolys(fa);
glDisable(GL_BLEND);
}
}
/*
=================
R_DrawSpriteModel
=================
*/
void R_DrawSpriteModel (entity_t *e)
{
vec3_t point;
mspriteframe_t *frame;
float *up, *right;
vec3_t v_forward, v_right, v_up;
msprite_t *psprite;
// don't even bother culling, because it's just a single
// polygon without a surface cache
frame = R_GetSpriteFrame (e);
psprite = currententity->model->cache.data;
if (psprite->type == SPR_ORIENTED)
{ // bullet marks on walls
AngleVectors (currententity->angles, v_forward, v_right, v_up);
up = v_up;
right = v_right;
}
else
{ // normal sprite
up = vup;
right = vright;
}
glColor3f (1,1,1);
GL_DisableMultitexture();
GL_Bind(frame->gl_texturenum);
glEnable (GL_ALPHA_TEST);
glBegin (GL_QUADS);
glTexCoord2f (0, 1);
VectorMA (e->origin, frame->down, up, point);
VectorMA (point, frame->left, right, point);
glVertex3fv (point);
glTexCoord2f (0, 0);
VectorMA (e->origin, frame->up, up, point);
VectorMA (point, frame->left, right, point);
glVertex3fv (point);
glTexCoord2f (1, 0);
VectorMA (e->origin, frame->up, up, point);
VectorMA (point, frame->right, right, point);
glVertex3fv (point);
glTexCoord2f (1, 1);
VectorMA (e->origin, frame->down, up, point);
VectorMA (point, frame->right, right, point);
glVertex3fv (point);
glEnd ();
glDisable (GL_ALPHA_TEST);
}
/*
================
R_RenderScene
r_refdef must be set before the first call
================
*/
void R_RenderScene (void)
{
R_SetupFrame ();
R_SetFrustum ();
R_SetupGL ();
R_MarkLeaves (); // done here so we know if we're in water
/* Experimenting with lighting.
glEnable(GL_LIGHTING);
glShadeModel(GL_SMOOTH);
glEnable(GL_LIGHT0);
glEnable(GL_COLOR_MATERIAL);
GLfloat specular[4] = {1, 1, 1, 1};
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular);
int li = 0;
for (; li < 8; li += 1)
{
if (cl_dlights[li].die >= cl.time && cl_dlights[li].radius)
{
GLfloat pos[4] = { cl_dlights[li].origin[0], cl_dlights[li].origin[1], cl_dlights[li].origin[2], 1.0};
glLightfv(GL_LIGHT0+li, GL_POSITION, pos);
glLightf(GL_LIGHT0+li, GL_CONSTANT_ATTENUATION, 0.1);
glEnable(GL_LIGHT0+li);
}
else
{
break;
}
}
*/
R_DrawWorld (); // adds static entities to the list
S_ExtraUpdate (); // don't let sound get messed up if going slow
/*for (li -=1; li >= 0; li -= 1)
{
glDisable(GL_LIGHT0+li);
}
glDisable(GL_LIGHTING);*/
R_DrawEntitiesOnList ();
GL_DisableMultitexture();
R_RenderDlights ();
R_DrawParticles ();
#ifdef GLTEST
Test_Draw ();
#endif
}
/*
=============
GL_DrawAliasShadow -- johnfitz -- rewritten
TODO: orient shadow onto "lightplane" (a global mplane_t*)
=============
*/
void GL_DrawAliasShadow (entity_t *e)
{
float shadowmatrix[16] = {1, 0, 0, 0,
0, 1, 0, 0,
SHADOW_SKEW_X, SHADOW_SKEW_Y, SHADOW_VSCALE, 0,
0, 0, SHADOW_HEIGHT, 1};
float lheight;
aliashdr_t *paliashdr;
lerpdata_t lerpdata;
if (R_CullModelForEntity(e))
return;
if (e == &cl.viewent || e->model->flags & MOD_NOSHADOW)
return;
entalpha = ENTALPHA_DECODE(e->alpha);
if (entalpha == 0) return;
paliashdr = (aliashdr_t *)Mod_Extradata (e->model);
R_SetupAliasFrame (paliashdr, e->frame, &lerpdata);
R_SetupEntityTransform (e, &lerpdata);
R_LightPoint (e->origin);
lheight = currententity->origin[2] - lightspot[2];
// set up matrix
glPushMatrix ();
glTranslatef (lerpdata.origin[0], lerpdata.origin[1], lerpdata.origin[2]);
glTranslatef (0,0,-lheight);
glMultMatrixf (shadowmatrix);
glTranslatef (0,0,lheight);
glRotatef (lerpdata.angles[1], 0, 0, 1);
glRotatef (-lerpdata.angles[0], 0, 1, 0);
glRotatef (lerpdata.angles[2], 1, 0, 0);
glTranslatef (paliashdr->scale_origin[0], paliashdr->scale_origin[1], paliashdr->scale_origin[2]);
glScalef (paliashdr->scale[0], paliashdr->scale[1], paliashdr->scale[2]);
// draw it
glDepthMask(GL_FALSE);
glEnable (GL_BLEND);
GL_DisableMultitexture ();
glDisable (GL_TEXTURE_2D);
shading = false;
glColor4f(0,0,0,entalpha * 0.5);
GL_DrawAliasFrame (paliashdr, lerpdata);
glEnable (GL_TEXTURE_2D);
glDisable (GL_BLEND);
glDepthMask(GL_TRUE);
//clean up
glPopMatrix ();
}
/*
============
R_PolyBlend
============
*/
void R_PolyBlend (void)
{
if (!gl_polyblend.value)
return;
if (!v_blend[3])
return;
GL_DisableMultitexture();
glDisable (GL_ALPHA_TEST);
glEnable (GL_BLEND);
glDisable (GL_DEPTH_TEST);
glDisable (GL_TEXTURE_2D);
glLoadIdentity ();
glRotatef (-90, 1, 0, 0); // put Z going up
glRotatef (90, 0, 0, 1); // put Z going up
glColor4f (v_blend[0], v_blend[1], v_blend[2], v_blend[3]);
#ifdef ESQUAKE
static const float quadVertices3[] =
{
10, 100, 100,
10, -100, 100,
10, -100, -100,
10, 100, -100
};
glVertexPointer(3, GL_FLOAT, sizeof(GLfloat)*3, quadVertices3);
glEnableClientState(GL_VERTEX_ARRAY);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glDisableClientState(GL_VERTEX_ARRAY);
#else
glBegin (GL_QUADS);
glVertex3f (10, 100, 100);
glVertex3f (10, -100, 100);
glVertex3f (10, -100, -100);
glVertex3f (10, 100, -100);
glEnd ();
#endif
glDisable (GL_BLEND);
glEnable (GL_TEXTURE_2D);
glEnable (GL_ALPHA_TEST);
}
/*
============
R_PolyBlend
============
*/
void R_PolyBlend (void)
{
if (!gl_polyblend.value)
return;
if (!v_blend[3])
return;
GL_DisableMultitexture();
glDisable (GL_ALPHA_TEST);
glEnable (GL_BLEND);
glDisable (GL_DEPTH_TEST);
glDisable (GL_TEXTURE_2D);
glLoadIdentity ();
glRotatef (-90, 1, 0, 0); // put Z going up
glRotatef (90, 0, 0, 1); // put Z going up
glColor4fv (v_blend);
#ifdef USE_OPENGLES
float vertex[3*4] = {
10, 100, 100,
10, -100, 100,
10, -100, -100,
10, 100, -100
};
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glVertexPointer( 3, GL_FLOAT, 0, vertex);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
#else
glBegin (GL_QUADS);
glVertex3f (10, 100, 100);
glVertex3f (10, -100, 100);
glVertex3f (10, -100, -100);
glVertex3f (10, 100, -100);
glEnd ();
#endif
glDisable (GL_BLEND);
glEnable (GL_TEXTURE_2D);
glEnable (GL_ALPHA_TEST);
}
/*
R_DrawSkyChain
*/
void
R_DrawSkyChain ( msurface_t *s )
{
msurface_t *fa;
int i;
vec3_t verts[MAX_CLIP_VERTS];
glpoly_t *p;
if (r_sky->value) {
c_sky = 0;
GL_Bind(solidskytexture);
// calculate vertex values for sky box
for (fa=s ; fa ; fa=fa->texturechain) {
for (p=fa->polys ; p ; p=p->next) {
for (i=0 ; i<p->numverts ; i++) {
VectorSubtract (p->verts[i], r_origin, verts[i]);
}
ClipSkyPolygon (p->numverts, verts[0], 0);
}
}
} else {
GL_DisableMultitexture();
// used when gl_texsort is on
GL_Bind(solidskytexture);
speedscale = realtime*8;
speedscale -= (int)speedscale & ~127 ;
for (fa=s ; fa ; fa=fa->texturechain)
EmitSkyPolys (fa);
glEnable (GL_BLEND);
GL_Bind (alphaskytexture);
speedscale = realtime*16;
speedscale -= (int)speedscale & ~127 ;
for ( fa=s ; fa != NULL ; fa = fa->texturechain )
EmitSkyPolys (fa);
glDisable (GL_BLEND);
}
}
/*
===============
EmitBothSkyLayers
Does a sky warp on the pre-fragmented glpoly_t chain
This will be called for brushmodels, the world
will have them chained together.
===============
*/
void EmitBothSkyLayers (msurface_t *fa)
{
GL_DisableMultitexture();
GL_Bind (solidskytexture);
speedscale = realtime*8;
speedscale -= (int)speedscale & ~127 ;
EmitSkyPolys (fa);
glEnable (GL_BLEND);
GL_Bind (alphaskytexture);
speedscale = realtime*16;
speedscale -= (int)speedscale & ~127 ;
EmitSkyPolys (fa);
glDisable (GL_BLEND);
}
/*
===============
EmitBothSkyLayers
Does a sky warp on the pre-fragmented glpoly_t chain
This will be called for brushmodels, the world
will have them chained together.
===============
*/
void
EmitBothSkyLayers(msurface_t *fa)
{
texture_t *t = fa->texinfo->texture;
GL_DisableMultitexture();
GL_Bind(t->gl_texturenum);
speedscale = realtime * 8;
speedscale -= (int)speedscale & ~127;
EmitSkyPolys(fa);
glEnable(GL_BLEND);
GL_Bind(t->gl_texturenum_alpha);
speedscale = realtime * 16;
speedscale -= (int)speedscale & ~127;
EmitSkyPolys(fa);
glDisable(GL_BLEND);
}
/*
=================
R_DrawSkyChain
=================
*/
void R_DrawSkyChain (msurface_t *s)
{
msurface_t *fa;
GL_DisableMultitexture();
GL_Bind0(solidskytexture);
speedscale = realtime*8;
speedscale -= (int)speedscale & ~127 ;
for (fa=s ; fa ; fa=fa->texturechain)
EmitSkyPolys (fa);
QGX_Blend(TRUE);
GL_Bind0 (alphaskytexture);
speedscale = realtime*16;
speedscale -= (int)speedscale & ~127 ;
for (fa=s ; fa ; fa=fa->texturechain)
EmitSkyPolys (fa);
QGX_Blend(FALSE);
}
/*
=================
R_DrawSkyChain
=================
*/
void R_DrawSkyChain (msurface_t *s)
{
msurface_t *fa;
GL_DisableMultitexture();
// used when gl_texsort is on
GL_Bind(solidskytexture);
speedscale = realtime*8;
speedscale -= (int)speedscale & ~127 ;
for (fa=s ; fa ; fa=fa->texturechain)
EmitSkyPolys (fa);
glEnable (GL_BLEND);
GL_Bind (alphaskytexture);
speedscale = realtime*16;
speedscale -= (int)speedscale & ~127 ;
for (fa=s ; fa ; fa=fa->texturechain)
EmitSkyPolys (fa);
glDisable (GL_BLEND);
}
/*
===============
R_DrawParticles
===============
*/
void
R_DrawParticles(void)
{
particle_t *p;
#ifdef GLQUAKE
#ifdef QW_HACK
unsigned char *at;
unsigned char theAlpha;
#endif
qboolean alphaTestEnabled;
vec3_t up, right;
float scale;
#ifdef NQ_HACK
/*
* FIXME - shouldn't need to do this, just get the caller to make sure
* multitexture is not enabled.
*/
GL_DisableMultitexture();
#endif
GL_Bind(particletexture);
alphaTestEnabled = glIsEnabled(GL_ALPHA_TEST);
if (alphaTestEnabled)
glDisable(GL_ALPHA_TEST);
glEnable(GL_BLEND);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glDepthMask(GL_FALSE);
glBegin(GL_TRIANGLES);
VectorScale(vup, 1.5, up);
VectorScale(vright, 1.5, right);
#else
D_StartParticles();
VectorScale(vright, xscaleshrink, r_pright);
VectorScale(vup, yscaleshrink, r_pup);
VectorCopy(vpn, r_ppn);
#endif
for (p = active_particles; p; p = p->next) {
#ifdef GLQUAKE
// hack a scale up to keep particles from disapearing
scale =
(p->org[0] - r_origin[0]) * vpn[0] + (p->org[1] -
r_origin[1]) * vpn[1]
+ (p->org[2] - r_origin[2]) * vpn[2];
if (scale < 20)
scale = 1;
else
scale = 1 + scale * 0.004;
#ifdef QW_HACK
at = (byte *)&d_8to24table[(int)p->color];
if (p->type == pt_fire)
theAlpha = 255 * (6 - p->ramp) / 6;
else
theAlpha = 255;
glColor4ub(*at, *(at + 1), *(at + 2), theAlpha);
#endif
#ifdef NQ_HACK
glColor3ubv((byte *)&d_8to24table[(int)p->color]);
#endif
glTexCoord2f(0, 0);
glVertex3fv(p->org);
glTexCoord2f(1, 0);
glVertex3f(p->org[0] + up[0] * scale, p->org[1] + up[1] * scale,
p->org[2] + up[2] * scale);
glTexCoord2f(0, 1);
glVertex3f(p->org[0] + right[0] * scale,
p->org[1] + right[1] * scale,
p->org[2] + right[2] * scale);
#else
D_DrawParticle(p);
#endif
}
#ifdef GLQUAKE
glEnd();
glDepthMask(GL_TRUE);
glDisable(GL_BLEND);
if (alphaTestEnabled)
glEnable(GL_ALPHA_TEST);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
#else
D_EndParticles();
#endif
}
/*
=================
R_DrawSpriteModel
=================
*/
void R_DrawSpriteModel (entity_t *e)
{
vec3_t point;
mspriteframe_t *frame;
float *up, *right;
vec3_t v_forward, v_right, v_up;
msprite_t *psprite;
// don't even bother culling, because it's just a single
// polygon without a surface cache
frame = R_GetSpriteFrame (e);
psprite = (msprite_t*) currententity->model->cache.data;
if (psprite->type == SPR_ORIENTED)
{ // bullet marks on walls
AngleVectors (currententity->angles, v_forward, v_right, v_up);
up = v_up;
right = v_right;
}
else
{ // normal sprite
up = vup;
right = vright;
}
glColor3f (1,1,1);
GL_DisableMultitexture();
GL_Bind(frame->gl_texturenum);
glEnable (GL_ALPHA_TEST);
#ifdef USE_OPENGLES
{
float* pPoint = gVertexBuffer;
float texCoords[] = {
0, 1,
0, 0,
1, 0,
1, 1
};
VectorMA (e->origin, frame->down, up, point);
VectorMA (point, frame->left, right, pPoint);
pPoint += 3;
VectorMA (e->origin, frame->up, up, point);
VectorMA (point, frame->left, right, pPoint);
pPoint += 3;
VectorMA (e->origin, frame->up, up, point);
VectorMA (point, frame->right, right, pPoint);
pPoint += 3;
VectorMA (e->origin, frame->down, up, point);
VectorMA (point, frame->right, right, pPoint);
glVertexPointer(3, GL_FLOAT, 0, gVertexBuffer);
glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}
#else
glBegin (GL_QUADS);
glTexCoord2f (0, 1);
VectorMA (e->origin, frame->down, up, point);
VectorMA (point, frame->left, right, point);
glVertex3fv (point);
glTexCoord2f (0, 0);
VectorMA (e->origin, frame->up, up, point);
VectorMA (point, frame->left, right, point);
glVertex3fv (point);
glTexCoord2f (1, 0);
VectorMA (e->origin, frame->up, up, point);
VectorMA (point, frame->right, right, point);
glVertex3fv (point);
glTexCoord2f (1, 1);
VectorMA (e->origin, frame->down, up, point);
VectorMA (point, frame->right, right, point);
glVertex3fv (point);
glEnd ();
#endif
glDisable (GL_ALPHA_TEST);
}
/*
=============
GLSLGamma_GammaCorrect
=============
*/
void GLSLGamma_GammaCorrect (void)
{
float smax, tmax;
if (!gl_glsl_gamma_able)
return;
if (vid_gamma.value == 1 && vid_contrast.value == 1)
return;
// create render-to-texture texture if needed
if (!r_gamma_texture)
{
glGenTextures (1, &r_gamma_texture);
glBindTexture (GL_TEXTURE_2D, r_gamma_texture);
r_gamma_texture_width = glwidth;
r_gamma_texture_height = glheight;
if (!gl_texture_NPOT)
{
r_gamma_texture_width = TexMgr_Pad(r_gamma_texture_width);
r_gamma_texture_height = TexMgr_Pad(r_gamma_texture_height);
}
glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, r_gamma_texture_width, r_gamma_texture_height, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
}
// create shader if needed
if (!r_gamma_program)
{
GLSLGamma_CreateShaders ();
if (!r_gamma_program)
{
Sys_Error("GLSLGamma_CreateShaders failed");
}
}
// copy the framebuffer to the texture
GL_DisableMultitexture();
glBindTexture (GL_TEXTURE_2D, r_gamma_texture);
glCopyTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0, glx, gly, glwidth, glheight);
// draw the texture back to the framebuffer with a fragment shader
GL_UseProgramFunc (r_gamma_program);
GL_Uniform1fFunc (gammaLoc, vid_gamma.value);
GL_Uniform1fFunc (contrastLoc, q_min(2.0, q_max(1.0, vid_contrast.value)));
GL_Uniform1iFunc (textureLoc, 0); // use texture unit 0
glDisable (GL_ALPHA_TEST);
glDisable (GL_DEPTH_TEST);
glViewport (glx, gly, glwidth, glheight);
smax = glwidth/(float)r_gamma_texture_width;
tmax = glheight/(float)r_gamma_texture_height;
glBegin (GL_QUADS);
glTexCoord2f (0, 0);
glVertex2f (-1, -1);
glTexCoord2f (smax, 0);
glVertex2f (1, -1);
glTexCoord2f (smax, tmax);
glVertex2f (1, 1);
glTexCoord2f (0, tmax);
glVertex2f (-1, 1);
glEnd ();
GL_UseProgramFunc (0);
// clear cached binding
GL_ClearBindings ();
}
/*
=================
R_DrawSpriteModel -- johnfitz -- rewritten: now supports all orientations
=================
*/
void R_DrawSpriteModel (entity_t *e)
{
vec3_t point, v_forward, v_right, v_up;
msprite_t *psprite;
mspriteframe_t *frame;
float *s_up, *s_right;
float angle, sr, cr;
//TODO: frustum cull it?
frame = R_GetSpriteFrame (e);
psprite = (msprite_t *) currententity->model->cache.data;
switch(psprite->type)
{
case SPR_VP_PARALLEL_UPRIGHT: //faces view plane, up is towards the heavens
v_up[0] = 0;
v_up[1] = 0;
v_up[2] = 1;
s_up = v_up;
s_right = vright;
break;
case SPR_FACING_UPRIGHT: //faces camera origin, up is towards the heavens
VectorSubtract(currententity->origin, r_origin, v_forward);
v_forward[2] = 0;
VectorNormalizeFast(v_forward);
v_right[0] = v_forward[1];
v_right[1] = -v_forward[0];
v_right[2] = 0;
v_up[0] = 0;
v_up[1] = 0;
v_up[2] = 1;
s_up = v_up;
s_right = v_right;
break;
case SPR_VP_PARALLEL: //faces view plane, up is towards the top of the screen
s_up = vup;
s_right = vright;
break;
case SPR_ORIENTED: //pitch yaw roll are independent of camera
AngleVectors (currententity->angles, v_forward, v_right, v_up);
s_up = v_up;
s_right = v_right;
break;
case SPR_VP_PARALLEL_ORIENTED: //faces view plane, but obeys roll value
angle = currententity->angles[ROLL] * M_PI_DIV_180;
sr = sin(angle);
cr = cos(angle);
v_right[0] = vright[0] * cr + vup[0] * sr;
v_right[1] = vright[1] * cr + vup[1] * sr;
v_right[2] = vright[2] * cr + vup[2] * sr;
v_up[0] = vright[0] * -sr + vup[0] * cr;
v_up[1] = vright[1] * -sr + vup[1] * cr;
v_up[2] = vright[2] * -sr + vup[2] * cr;
s_up = v_up;
s_right = v_right;
break;
default:
return;
}
//johnfitz: offset decals
if (psprite->type == SPR_ORIENTED)
GL_PolygonOffset (OFFSET_DECAL);
glColor3f (1,1,1);
GL_DisableMultitexture();
GL_Bind(frame->gltexture);
glEnable (GL_ALPHA_TEST);
glBegin (GL_TRIANGLE_FAN); //was GL_QUADS, but changed to support r_showtris
glTexCoord2f (0, frame->tmax);
VectorMA (e->origin, frame->down, s_up, point);
VectorMA (point, frame->left, s_right, point);
glVertex3fv (point);
glTexCoord2f (0, 0);
VectorMA (e->origin, frame->up, s_up, point);
VectorMA (point, frame->left, s_right, point);
glVertex3fv (point);
glTexCoord2f (frame->smax, 0);
VectorMA (e->origin, frame->up, s_up, point);
VectorMA (point, frame->right, s_right, point);
glVertex3fv (point);
glTexCoord2f (frame->smax, frame->tmax);
VectorMA (e->origin, frame->down, s_up, point);
VectorMA (point, frame->right, s_right, point);
glVertex3fv (point);
glEnd ();
glDisable (GL_ALPHA_TEST);
//johnfitz: offset decals
if (psprite->type == SPR_ORIENTED)
GL_PolygonOffset (OFFSET_NONE);
}
/*
=================
R_DrawAliasModel
=================
*/
void R_DrawAliasModel (entity_t *e)
{
int i, j;
int lnum;
vec3_t dist;
float add;
model_t *clmodel;
vec3_t mins, maxs;
aliashdr_t *paliashdr;
trivertx_t *verts, *v;
int index;
float s, t, an;
int anim;
clmodel = currententity->model;
VectorAdd (currententity->origin, clmodel->mins, mins);
VectorAdd (currententity->origin, clmodel->maxs, maxs);
if (R_CullBox (mins, maxs))
return;
VectorCopy (currententity->origin, r_entorigin);
VectorSubtract (r_origin, r_entorigin, modelorg);
//
// get lighting information
//
ambientlight = shadelight = R_LightPoint (currententity->origin);
// allways give the gun some light
if (e == &cl.viewent && ambientlight < 24)
ambientlight = shadelight = 24;
for (lnum=0 ; lnum<MAX_DLIGHTS ; lnum++)
{
if (cl_dlights[lnum].die >= cl.time)
{
VectorSubtract (currententity->origin,
cl_dlights[lnum].origin,
dist);
add = cl_dlights[lnum].radius - Length(dist);
if (add > 0) {
ambientlight += add;
//ZOID models should be affected by dlights as well
shadelight += add;
}
}
}
// clamp lighting so it doesn't overbright as much
if (ambientlight > 128)
ambientlight = 128;
if (ambientlight + shadelight > 192)
shadelight = 192 - ambientlight;
// ZOID: never allow players to go totally black
i = currententity - cl_entities;
if (i >= 1 && i<=cl.maxclients /* && !strcmp (currententity->model->name, "progs/player.mdl") */)
if (ambientlight < 8)
ambientlight = shadelight = 8;
// HACK HACK HACK -- no fullbright colors, so make torches full light
if (!strcmp (clmodel->name, "progs/flame2.mdl")
|| !strcmp (clmodel->name, "progs/flame.mdl") )
ambientlight = shadelight = 256;
shadedots = r_avertexnormal_dots[((int)(e->angles[1] * (SHADEDOT_QUANT / 360.0))) & (SHADEDOT_QUANT - 1)];
shadelight = shadelight / 200.0;
an = e->angles[1]/180*M_PI;
shadevector[0] = cos(-an);
shadevector[1] = sin(-an);
shadevector[2] = 1;
VectorNormalize (shadevector);
//
// locate the proper data
//
paliashdr = (aliashdr_t *)Mod_Extradata (currententity->model);
c_alias_polys += paliashdr->numtris;
//
// draw all the triangles
//
GL_DisableMultitexture();
glPushMatrix ();
R_RotateForEntity (e);
if (!strcmp (clmodel->name, "progs/eyes.mdl") && gl_doubleeyes.value) {
glTranslatef (paliashdr->scale_origin[0], paliashdr->scale_origin[1], paliashdr->scale_origin[2] - (22 + 8));
// double size of eyes, since they are really hard to see in gl
glScalef (paliashdr->scale[0]*2, paliashdr->scale[1]*2, paliashdr->scale[2]*2);
} else {
glTranslatef (paliashdr->scale_origin[0], paliashdr->scale_origin[1], paliashdr->scale_origin[2]);
glScalef (paliashdr->scale[0], paliashdr->scale[1], paliashdr->scale[2]);
}
anim = (int)(cl.time*10) & 3;
GL_Bind(paliashdr->gl_texturenum[currententity->skinnum][anim]);
// we can't dynamically colormap textures, so they are cached
// seperately for the players. Heads are just uncolored.
if (currententity->colormap != vid.colormap && !gl_nocolors.value)
{
i = currententity - cl_entities;
if (i >= 1 && i<=cl.maxclients /* && !strcmp (currententity->model->name, "progs/player.mdl") */)
GL_Bind(playertextures - 1 + i);
}
if (gl_smoothmodels.value)
glShadeModel (GL_SMOOTH);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
if (gl_affinemodels.value)
glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
R_SetupAliasFrame (currententity->frame, paliashdr);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glShadeModel (GL_FLAT);
if (gl_affinemodels.value)
glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glPopMatrix ();
if (r_shadows.value)
{
glPushMatrix ();
R_RotateForEntity (e);
glDisable (GL_TEXTURE_2D);
glEnable (GL_BLEND);
glColor4f (0,0,0,0.5);
GL_DrawAliasShadow (paliashdr, lastposenum);
glEnable (GL_TEXTURE_2D);
glDisable (GL_BLEND);
glColor4f (1,1,1,1);
glPopMatrix ();
}
}
/*
=================
R_DrawSpriteModel
=================
*/
void R_DrawSpriteModel (entity_t *e)
{
//vec3_t point;
mspriteframe_t *frame;
float *up, *right;
vec3_t v_forward, v_right, v_up;
msprite_t *psprite;
// don't even bother culling, because it's just a single
// polygon without a surface cache
frame = R_GetSpriteFrame (e);
psprite = currententity->model->cache.data;
if (psprite->type == SPR_ORIENTED)
{ // bullet marks on walls
AngleVectors (currententity->angles, v_forward, v_right, v_up);
up = v_up;
right = v_right;
}
else
{ // normal sprite
up = vup;
right = vright;
}
glColor4ub (255,255,255,255);
GL_DisableMultitexture();
GL_Bind(frame->gl_texturenum);
glEnable (GL_ALPHA_TEST);
#ifdef ESQUAKE
float quadTexCoord[] =
{
0, 1,
0, 0,
1, 0,
1, 1
};
float quadVertices3[3*4];
vec_t * pVec = quadVertices3;
VectorMA (e->origin, frame->down, up, pVec);
VectorMA (pVec, frame->left, right, pVec);
pVec += 3;
VectorMA (e->origin, frame->up, up, pVec);
VectorMA (pVec, frame->left, right, pVec);
pVec += 3;
VectorMA (e->origin, frame->up, up, pVec);
VectorMA (pVec, frame->right, right, pVec);
pVec += 3;
VectorMA (e->origin, frame->down, up, pVec);
VectorMA (pVec, frame->right, right, pVec);
glTexCoordPointer(2, GL_FLOAT, sizeof(GLfloat)*2, quadTexCoord);
glVertexPointer(3, GL_FLOAT, sizeof(GLfloat)*3, quadVertices3);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
#else
glBegin (GL_QUADS);
glTexCoord2f (0, 1);
VectorMA (e->origin, frame->down, up, point);
VectorMA (point, frame->left, right, point);
glVertex3fv (point);
glTexCoord2f (0, 0);
VectorMA (e->origin, frame->up, up, point);
VectorMA (point, frame->left, right, point);
glVertex3fv (point);
glTexCoord2f (1, 0);
VectorMA (e->origin, frame->up, up, point);
VectorMA (point, frame->right, right, point);
glVertex3fv (point);
glTexCoord2f (1, 1);
VectorMA (e->origin, frame->down, up, point);
VectorMA (point, frame->right, right, point);
glVertex3fv (point);
glEnd ();
#endif
glDisable (GL_ALPHA_TEST);
}
/*
=================
R_DrawAliasModel -- johnfitz -- almost completely rewritten
=================
*/
void R_DrawAliasModel (entity_t *e)
{
aliashdr_t *paliashdr;
int i, anim;
gltexture_t *tx, *fb;
lerpdata_t lerpdata;
//
// setup pose/lerp data -- do it first so we don't miss updates due to culling
//
paliashdr = (aliashdr_t *)Mod_Extradata (e->model);
R_SetupAliasFrame (paliashdr, e->frame, &lerpdata);
R_SetupEntityTransform (e, &lerpdata);
//
// cull it
//
if (R_CullModelForEntity(e))
return;
//
// transform it
//
glPushMatrix ();
R_RotateForEntity (lerpdata.origin, lerpdata.angles);
glTranslatef (paliashdr->scale_origin[0], paliashdr->scale_origin[1], paliashdr->scale_origin[2]);
glScalef (paliashdr->scale[0], paliashdr->scale[1], paliashdr->scale[2]);
//
// random stuff
//
if (gl_smoothmodels.value && !r_drawflat_cheatsafe)
glShadeModel (GL_SMOOTH);
if (gl_affinemodels.value)
glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
overbright = gl_overbright_models.value;
shading = true;
//
// set up for alpha blending
//
if (r_drawflat_cheatsafe || r_lightmap_cheatsafe) //no alpha in drawflat or lightmap mode
entalpha = 1;
else
entalpha = ENTALPHA_DECODE(e->alpha);
if (entalpha == 0)
goto cleanup;
if (entalpha < 1)
{
if (!gl_texture_env_combine) overbright = false; //overbright can't be done in a single pass without combiners
glDepthMask(GL_FALSE);
glEnable(GL_BLEND);
}
//
// set up lighting
//
rs_aliaspolys += paliashdr->numtris;
R_SetupAliasLighting (e);
//
// set up textures
//
GL_DisableMultitexture();
anim = (int)(cl.time*10) & 3;
tx = paliashdr->gltextures[e->skinnum][anim];
fb = paliashdr->fbtextures[e->skinnum][anim];
if (e->colormap != vid.colormap && !gl_nocolors.value)
{
i = e - cl_entities;
if (i >= 1 && i<=cl.maxclients /* && !strcmp (currententity->model->name, "progs/player.mdl") */)
tx = playertextures[i - 1];
}
if (!gl_fullbrights.value)
fb = NULL;
//
// draw it
//
if (r_drawflat_cheatsafe)
{
glDisable (GL_TEXTURE_2D);
GL_DrawAliasFrame (paliashdr, lerpdata);
glEnable (GL_TEXTURE_2D);
srand((int) (cl.time * 1000)); //restore randomness
}
else if (r_fullbright_cheatsafe)
{
GL_Bind (tx);
shading = false;
glColor4f(1,1,1,entalpha);
GL_DrawAliasFrame (paliashdr, lerpdata);
if (fb)
{
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_Bind(fb);
glEnable(GL_BLEND);
glBlendFunc (GL_ONE, GL_ONE);
glDepthMask(GL_FALSE);
glColor3f(entalpha,entalpha,entalpha);
Fog_StartAdditive ();
GL_DrawAliasFrame (paliashdr, lerpdata);
Fog_StopAdditive ();
glDepthMask(GL_TRUE);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_BLEND);
}
}
else if (r_lightmap_cheatsafe)
{
glDisable (GL_TEXTURE_2D);
shading = false;
glColor3f(1,1,1);
GL_DrawAliasFrame (paliashdr, lerpdata);
glEnable (GL_TEXTURE_2D);
}
else if (overbright)
{
if (gl_texture_env_combine && gl_mtexable && gl_texture_env_add && fb) //case 1: everything in one pass
{
GL_Bind (tx);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_MODULATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_PRIMARY_COLOR_EXT);
glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT, 2.0f);
GL_EnableMultitexture(); // selects TEXTURE1
GL_Bind (fb);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD);
glEnable(GL_BLEND);
GL_DrawAliasFrame (paliashdr, lerpdata);
glDisable(GL_BLEND);
GL_DisableMultitexture();
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
}
else if (gl_texture_env_combine) //case 2: overbright in one pass, then fullbright pass
{
// first pass
GL_Bind(tx);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_MODULATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_PRIMARY_COLOR_EXT);
glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT, 2.0f);
GL_DrawAliasFrame (paliashdr, lerpdata);
glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT, 1.0f);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
// second pass
if (fb)
{
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_Bind(fb);
glEnable(GL_BLEND);
glBlendFunc (GL_ONE, GL_ONE);
glDepthMask(GL_FALSE);
shading = false;
glColor3f(entalpha,entalpha,entalpha);
Fog_StartAdditive ();
GL_DrawAliasFrame (paliashdr, lerpdata);
Fog_StopAdditive ();
glDepthMask(GL_TRUE);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_BLEND);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
}
}
else //case 3: overbright in two passes, then fullbright pass
{
// first pass
GL_Bind(tx);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_DrawAliasFrame (paliashdr, lerpdata);
// second pass -- additive with black fog, to double the object colors but not the fog color
glEnable(GL_BLEND);
glBlendFunc (GL_ONE, GL_ONE);
glDepthMask(GL_FALSE);
Fog_StartAdditive ();
GL_DrawAliasFrame (paliashdr, lerpdata);
Fog_StopAdditive ();
glDepthMask(GL_TRUE);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_BLEND);
// third pass
if (fb)
{
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_Bind(fb);
glEnable(GL_BLEND);
glBlendFunc (GL_ONE, GL_ONE);
glDepthMask(GL_FALSE);
shading = false;
glColor3f(entalpha,entalpha,entalpha);
Fog_StartAdditive ();
GL_DrawAliasFrame (paliashdr, lerpdata);
Fog_StopAdditive ();
glDepthMask(GL_TRUE);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_BLEND);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
}
}
}
else
{
if (gl_mtexable && gl_texture_env_add && fb) //case 4: fullbright mask using multitexture
{
GL_DisableMultitexture(); // selects TEXTURE0
GL_Bind (tx);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_EnableMultitexture(); // selects TEXTURE1
GL_Bind (fb);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD);
glEnable(GL_BLEND);
GL_DrawAliasFrame (paliashdr, lerpdata);
glDisable(GL_BLEND);
GL_DisableMultitexture();
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
}
else //case 5: fullbright mask without multitexture
{
// first pass
GL_Bind(tx);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_DrawAliasFrame (paliashdr, lerpdata);
// second pass
if (fb)
{
GL_Bind(fb);
glEnable(GL_BLEND);
glBlendFunc (GL_ONE, GL_ONE);
glDepthMask(GL_FALSE);
shading = false;
glColor3f(entalpha,entalpha,entalpha);
Fog_StartAdditive ();
GL_DrawAliasFrame (paliashdr, lerpdata);
Fog_StopAdditive ();
glDepthMask(GL_TRUE);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_BLEND);
}
}
}
cleanup:
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glShadeModel (GL_FLAT);
glDepthMask(GL_TRUE);
glDisable(GL_BLEND);
glColor3f(1,1,1);
glPopMatrix ();
}
/*
==============
R_DrawSky
Draw either the classic cloudy quake sky or a skybox
==============
*/
void R_DrawSky (void)
{
msurface_t *fa;
qbool ignore_z;
extern msurface_t *skychain;
GL_DisableMultitexture ();
if (r_fastsky.value) {
glDisable (GL_TEXTURE_2D);
glColor3ubv (r_skycolor.color);
for (fa = skychain; fa; fa = fa->texturechain)
EmitFlatPoly (fa);
skychain = NULL;
glEnable (GL_TEXTURE_2D);
glColor3f (1, 1, 1);
return;
}
if (r_viewleaf->contents == CONTENTS_SOLID) {
// always draw if we're in a solid leaf (probably outside the level)
// FIXME: we don't really want to add all six planes every time!
// FIXME: also handle r_fastsky case
int i;
for (i = 0; i < 6; i++) {
skymins[0][i] = skymins[1][i] = -1;
skymaxs[0][i] = skymaxs[1][i] = 1;
}
ignore_z = true;
}
else {
if (!skychain)
return; // no sky at all
// figure out how much of the sky box we need to draw
ClearSky ();
for (fa = skychain; fa; fa = fa->texturechain)
R_AddSkyBoxSurface (fa);
ignore_z = false;
}
// turn off Z tests & writes to avoid problems on large maps
glDisable (GL_DEPTH_TEST);
// draw a skybox or classic quake clouds
if (r_skyboxloaded)
R_DrawSkyBox ();
else
R_DrawSkyDome ();
glEnable (GL_DEPTH_TEST);
// draw the sky polys into the Z buffer
// don't need depth test yet
if (!ignore_z) {
if (gl_fogenable.value && gl_fogsky.value) {
glEnable(GL_FOG);
glColor4f(gl_fogred.value, gl_foggreen.value, gl_fogblue.value, 1);
glBlendFunc(GL_ONE, GL_ZERO);
}
else {
glColorMask (GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
glBlendFunc(GL_ZERO, GL_ONE);
}
glDisable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
for (fa = skychain; fa; fa = fa->texturechain)
EmitFlatPoly (fa);
if (gl_fogenable.value && gl_fogsky.value)
glDisable (GL_FOG);
else {
glColorMask (GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
}
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable (GL_TEXTURE_2D);
glDisable(GL_BLEND);
}
skychain = NULL;
skychain_tail = &skychain;
}
//Does a water warp on the pre-fragmented glpoly_t chain
void EmitWaterPolys (msurface_t *fa) {
glpoly_t *p;
float *v, s, t, os, ot;
int i;
byte *col;
extern cvar_t r_telecolor, r_watercolor, r_slimecolor, r_lavacolor;
float wateralpha = bound((1 - r_refdef2.max_watervis), r_wateralpha.value, 1);
vec3_t nv;
GLint shader, u_gamma, u_contrast;
GL_DisableMultitexture();
if (gl_fogenable.value)
glEnable(GL_FOG);
GL_Bind (fa->texinfo->texture->gl_texturenum);
/* FIXME: do the uniforms somewhere else */
shader = glsl_shaders[SHADER_TURB].shader;
qglUseProgram(shader);
u_gamma = qglGetUniformLocation(shader, "gamma");
u_contrast = qglGetUniformLocation(shader, "contrast");
qglUniform1f(u_gamma, v_gamma.value);
qglUniform1f(u_contrast, v_contrast.value);
if (r_fastturb.value)
{
GL_Bind(whitetexture);
if (strstr (fa->texinfo->texture->name, "water") || strstr (fa->texinfo->texture->name, "mwat"))
col = r_watercolor.color;
else if (strstr (fa->texinfo->texture->name, "slime"))
col = r_slimecolor.color;
else if (strstr (fa->texinfo->texture->name, "lava"))
col = r_lavacolor.color;
else if (strstr (fa->texinfo->texture->name, "tele"))
col = r_telecolor.color;
else
col = (byte *) &fa->texinfo->texture->flatcolor3ub;
glColor3ubv (col);
if (wateralpha < 1.0 && wateralpha >= 0) {
glEnable (GL_BLEND);
col[3] = wateralpha*255;
glColor4ubv (col); // 1, 1, 1, wateralpha
glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
if (wateralpha < 0.9)
glDepthMask (GL_FALSE);
}
EmitFlatWaterPoly (fa);
if (wateralpha < 1.0 && wateralpha >= 0) {
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glColor3ubv (color_white);
glDisable (GL_BLEND);
if (wateralpha < 0.9)
glDepthMask (GL_TRUE);
}
glColor3ubv (color_white);
} else {
for (p = fa->polys; p; p = p->next) {
glBegin(GL_POLYGON);
for (i = 0, v = p->verts[0]; i < p->numverts; i++, v += VERTEXSIZE) {
os = v[3];
ot = v[4];
s = os + SINTABLE_APPROX(ot * 2 + r_refdef2.time);
s *= (1.0 / 64);
t = ot + SINTABLE_APPROX(os * 2 + r_refdef2.time);
t *= (1.0 / 64);
//VULT RIPPLE : Not sure where this came from first, but I've seen in it more than one engine
//I got this one from the QMB engine though
VectorCopy(v, nv);
//Over 20 this setting gets pretty cheaty
if (amf_waterripple.value && (cls.demoplayback || cl.spectator) && !strstr (fa->texinfo->texture->name, "tele"))
nv[2] = v[2] + (bound(0, amf_waterripple.value, 20)) *sin(v[0]*0.02+r_refdef2.time)*sin(v[1]*0.02+r_refdef2.time)*sin(v[2]*0.02+r_refdef2.time);
glTexCoord2f (s, t);
glVertex3fv (nv);
}
glEnd();
}
}
qglUseProgram(0);
if (gl_fogenable.value)
glDisable(GL_FOG);
}
void R_DrawSkyChain (void) {
msurface_t *fa;
extern cvar_t gl_fogsky;
if (!skychain)
return;
GL_DisableMultitexture();
if (gl_fogenable.value && gl_fogsky.value)
glEnable(GL_FOG);
if (r_fastsky.value || cl.worldmodel->bspversion == HL_BSPVERSION) {
glDisable (GL_TEXTURE_2D);
glColor3ubv (r_skycolor.color);
for (fa = skychain; fa; fa = fa->texturechain)
EmitFlatPoly (fa);
glEnable (GL_TEXTURE_2D);
glColor3ubv (color_white);
} else {
if (gl_mtexable) {
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_Bind (solidskytexture);
GL_EnableMultitexture();
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
GL_Bind (alphaskytexture);
speedscale = r_refdef2.time * 8;
speedscale -= (int) speedscale & ~127;
speedscale2 = r_refdef2.time * 16;
speedscale2 -= (int) speedscale2 & ~127;
for (fa = skychain; fa; fa = fa->texturechain)
EmitSkyPolys (fa, true);
GL_DisableMultitexture();
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
} else {
GL_Bind(solidskytexture);
speedscale = r_refdef2.time * 8;
speedscale -= (int) speedscale & ~127;
for (fa = skychain; fa; fa = fa->texturechain)
EmitSkyPolys (fa, false);
glEnable (GL_BLEND);
GL_Bind (alphaskytexture);
speedscale = r_refdef2.time * 16;
speedscale -= (int) speedscale & ~127;
for (fa = skychain; fa; fa = fa->texturechain)
EmitSkyPolys (fa, false);
glDisable (GL_BLEND);
}
}
if (gl_fogenable.value && gl_fogsky.value)
glDisable(GL_FOG);
skychain = NULL;
skychain_tail = &skychain;
}
