nzp-team/fteqw
0
0
Fork 0
mirror of https://github.com/nzp-team/fteqw.git synced 2025-02-22 03:21:08 +00:00
Code Issues Projects Releases Packages Wiki Activity

fixes for the new backend.

Browse source 
git-svn-id: https://svn.code.sf.net/p/fteqw/code/trunk@418 fc73d0e0-1445-4013-8a0c-d673dee63da5
This commit is contained in:
Spoike 2004-11-13 17:31:04 +00:00
parent bef51071a6
commit a0bf669e3e
13 changed files with 606 additions and 279 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
engine/gl/gl_alias.c
View file

@ -600,7 +600,6 @@ static galiastexnum_t *GL_ChooseSkin(galiasinfo_t *inf, char *modelname, entity_
GL_Bind(texnums->base);
glTexImage2D (GL_TEXTURE_2D, 0, gl_solid_format, scaled_width, scaled_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
@ -623,7 +622,6 @@ static galiastexnum_t *GL_ChooseSkin(galiasinfo_t *inf, char *modelname, entity_
GL_Bind(texnums->fullbright);
glTexImage2D (GL_TEXTURE_2D, 0, gl_alpha_format, scaled_width, scaled_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}
@ -790,6 +788,8 @@ void GL_DrawAliasMesh (mesh_t *mesh, int texnum)
GL_Bind(texnum);
GL_TexEnv(GL_MODULATE);
glVertexPointer(3, GL_FLOAT, 16, mesh->xyz_array);
glEnableClientState( GL_VERTEX_ARRAY );
@ -804,6 +804,8 @@ void GL_DrawAliasMesh (mesh_t *mesh, int texnum)
glColorPointer(4, GL_UNSIGNED_BYTE, 0, mesh->colors_array);
glEnableClientState( GL_COLOR_ARRAY );
}
else
glDisableClientState( GL_COLOR_ARRAY );
glEnableClientState( GL_TEXTURE_COORD_ARRAY );
glTexCoordPointer(2, GL_FLOAT, 0, mesh->st_array);
@ -975,7 +977,7 @@ void R_DrawGAliasModel (entity_t *e)
*/
GL_DisableMultitexture();
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_TexEnv(GL_MODULATE);
if (gl_smoothmodels.value)
glShadeModel (GL_SMOOTH);
if (gl_affinemodels.value)
@ -1023,6 +1025,7 @@ void R_DrawGAliasModel (entity_t *e)
else
{
glDisable(GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
// glEnable (GL_ALPHA_TEST);
@ -1127,6 +1130,7 @@ void R_DrawGAliasModel (entity_t *e)
if (qglPNTrianglesfATI && gl_ati_truform.value)
glEnable(GL_PN_TRIANGLES_ATI);
memset(&mesh, 0, sizeof(mesh));
while(inf)
{
R_GAliasBuildMesh(&mesh, inf, e->frame, e->oldframe, e->lerptime, e->alpha);
@ -1154,7 +1158,7 @@ void R_DrawGAliasModel (entity_t *e)
R_IBrokeTheArrays();
R_PushMesh(&mesh, skin->shader->features|MF_COLORS);
R_PushMesh(&mesh, skin->shader->features | MF_NONBATCHED | MF_COLORS);
R_RenderMeshBuffer ( &mb, false );
}
@ -1221,7 +1225,7 @@ glColor3f(0,0,1);
glDisable(GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
GL_TexEnv(GL_REPLACE);
glEnable(GL_TEXTURE_2D);
@ -1349,7 +1353,7 @@ void R_DrawGAliasModelLighting (entity_t *e)
VectorNormalize (shadevector);
GL_DisableMultitexture();
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_TexEnv(GL_MODULATE);
if (gl_smoothmodels.value)
glShadeModel (GL_SMOOTH);
if (gl_affinemodels.value)
@ -1382,7 +1386,7 @@ void R_DrawGAliasModelLighting (entity_t *e)
if (gl_ati_truform.value)
glDisable(GL_PN_TRIANGLES_ATI);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
GL_TexEnv(GL_REPLACE);
glShadeModel (GL_FLAT);
if (gl_affinemodels.value)

34
engine/gl/gl_backend.c
View file

@ -34,8 +34,8 @@ void GL_MBind( GLenum target, int texnum )
{
GL_SelectTexture( target );
// if ( gl_state.currenttextures[texnum-mtexid0] == texnum )
// return;
if ( gl_state.currenttextures[gl_state.currenttmu] == texnum )
return;
gl_state.currenttextures[gl_state.currenttmu] = texnum;
bindTexFunc (GL_TEXTURE_2D, texnum);
@ -51,9 +51,12 @@ void GL_Bind (int texnum)
}
void GL_BindType (int type, int texnum)
{
bindTexFunc (type, texnum);
if (gl_state.currenttextures[gl_state.currenttmu] == texnum)
return;
gl_state.currenttextures[gl_state.currenttmu] = texnum;
gl_state.currenttextures[gl_state.currenttmu] = -1;
bindTexFunc (type, texnum);
}
//vid restarted.
@ -402,7 +405,7 @@ static void Mesh_DrawPass(shaderpass_t *pass, mesh_t *mesh)
GL_BindType(pass[p].texturetype, pass[p].anim_frames[0]);
glEnable(pass[p].texturetype);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, pass[p].envmode);
GL_TexEnv(pass[p].envmode);
if (pass[p].envmode == GL_COMBINE_ARB)
{
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, pass[p].combinesrc0);
@ -425,7 +428,7 @@ static void Mesh_DrawPass(shaderpass_t *pass, mesh_t *mesh)
{
Mesh_DeformTextureCoords(mesh, pass);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, pass->envmode);
GL_TexEnv(pass->envmode);
GL_Bind(pass->anim_frames[0]);
if (pass->texturetype != GL_TEXTURE_2D)
@ -1059,6 +1062,7 @@ static float frand(void)
R_BackendInit
==============
*/
void R_IBrokeTheArrays(void);
void R_BackendInit (void)
{
int i;
@ -1089,10 +1093,7 @@ void R_BackendInit (void)
r_arrays_locked = false;
r_blocked = false;
qglVertexPointer( 3, GL_FLOAT, 16, vertexArray ); // padded for SIMD
qglColorPointer( 4, GL_UNSIGNED_BYTE, 0, colorArray );
qglEnableClientState( GL_VERTEX_ARRAY );
R_IBrokeTheArrays();
//FIZME: FTE already has some stuff along these lines, surly...
// if ( !r_ignorehwgamma->value )
@ -1122,8 +1123,10 @@ void R_BackendInit (void)
}
}
qboolean varrayactive;
void R_IBrokeTheArrays(void)
{
varrayactive = true;
qglVertexPointer( 3, GL_FLOAT, 16, vertexArray ); // padded for SIMD
qglColorPointer( 4, GL_UNSIGNED_BYTE, 0, colorArray );
@ -1754,6 +1757,10 @@ int R_ShaderpassTex ( shaderpass_t *pass )
{
return lightmap_textures[r_lmtex];
}
/* else if ( (pass->flags & SHADER_PASS_DELUXMAP) && r_lmtex >= 0 )
{
return deluxmap_textures[r_lmtex];
}*/
return pass->anim_frames[0] ? pass->anim_frames[0] : 0;
}
@ -2494,6 +2501,13 @@ void R_RenderMeshBuffer ( meshbuffer_t *mb, qboolean shadowpass )
return;
}
// R_IBrokeTheArrays();
// qglVertexPointer( 3, GL_FLOAT, 16, vertexArray ); // padded for SIMD
// qglColorPointer( 4, GL_UNSIGNED_BYTE, 0, colorArray );
// qglEnableClientState( GL_VERTEX_ARRAY );
shader = mb->shader;
r_lmtex = mb->infokey;

42
engine/gl/gl_draw.c
View file

@ -54,6 +54,7 @@ static int filmtexture;
extern cvar_t gl_nobind;
extern cvar_t gl_max_size;
extern cvar_t gl_picmip;
extern cvar_t gl_picmip2d;
extern cvar_t r_drawdisk;
extern cvar_t gl_compress;
extern cvar_t gl_font, gl_conback, gl_smoothfont;
@ -1208,7 +1209,7 @@ void GLDraw_Crosshair(void)
return;
}
glDisable (GL_BLEND);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_TexEnv(GL_MODULATE);
if (crosshair.value)
{
@ -1268,8 +1269,8 @@ void GLDraw_Crosshair(void)
glEnd ();
}
// glTexEnvf ( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE );
// glTexEnvf ( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
// GL_TexEnv ( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE );
// GL_TexEnv ( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
}
@ -2297,9 +2298,17 @@ void GL_Upload32 (char *name, unsigned *data, int width, int height, qboolean m
;
}
if (mipmap)
{
TRACE(("dbg: GL_Upload32: %f\n", gl_picmip.value));
scaled_width >>= (int)gl_picmip.value;
scaled_height >>= (int)gl_picmip.value;
}
else
{
scaled_width >>= (int)gl_picmip2d.value;
scaled_height >>= (int)gl_picmip2d.value;
}
TRACE(("dbg: GL_Upload32: %f\n", gl_max_size.value));
if (gl_max_size.value)
@ -2466,8 +2475,17 @@ void GL_Upload8Grey (unsigned char*data, int width, int height, qboolean mipmap
;
}
if (mipmap)
{
TRACE(("dbg: GL_Upload8Grey: %f\n", gl_picmip.value));
scaled_width >>= (int)gl_picmip.value;
scaled_height >>= (int)gl_picmip.value;
}
else
{
scaled_width >>= (int)gl_picmip2d.value;
scaled_height >>= (int)gl_picmip2d.value;
}
if (gl_max_size.value)
{
@ -2682,8 +2700,17 @@ void GL_UploadBump(qbyte *data, int width, int height, qboolean mipmap) {
;
}
if (mipmap)
{
TRACE(("dbg: GL_UploadBump: %f\n", gl_picmip.value));
scaled_width >>= (int)gl_picmip.value;
scaled_height >>= (int)gl_picmip.value;
}
else
{
scaled_width >>= (int)gl_picmip2d.value;
scaled_height >>= (int)gl_picmip2d.value;
}
if (gl_max_size.value)
{
@ -2809,8 +2836,17 @@ void GL_Upload8_EXT (qbyte *data, int width, int height, qboolean mipmap, qbool
;
}
if (mipmap)
{
TRACE(("dbg: GL_Upload8_EXT: %f\n", gl_picmip.value));
scaled_width >>= (int)gl_picmip.value;
scaled_height >>= (int)gl_picmip.value;
}
else
{
scaled_width >>= (int)gl_picmip2d.value;
scaled_height >>= (int)gl_picmip2d.value;
}
if (gl_max_size.value)
{

4
engine/gl/gl_hlmdl.c
View file

@ -506,7 +506,7 @@ void R_DrawHLModel(entity_t *curent)
if (sequence->motiontype)
model.frame = sequence->numframes-1;
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_TexEnv(GL_MODULATE);
if (curent->alpha<1)
{
@ -593,7 +593,7 @@ void R_DrawHLModel(entity_t *curent)
glPopMatrix();
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
GL_TexEnv(GL_REPLACE);
}
/*

2
engine/gl/gl_ngraph.c
View file

@ -123,7 +123,7 @@ void GLR_NetGraph (void)
NET_TIMINGS, NET_GRAPHHEIGHT, 0, GL_RGBA,
GL_UNSIGNED_BYTE, ngraph_pixels);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_TexEnv(GL_MODULATE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

409
engine/gl/gl_ppl.c
View file

@ -70,13 +70,22 @@ static unsigned int varray_i_polytotri[MAXARRAYVERTS]; //012 023 034 045...
int varray_ic;
int varray_vc;
#ifdef Q3SHADERS
static qboolean pplvarrayactive;
#endif
#define inline static
extern qboolean varrayactive; //used by the backend
inline void PPL_EnableVertexArrays(void)
{
varrayactive = false;
glDisableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->xyz);
glDisableClientState( GL_COLOR_ARRAY );
}
inline void PPL_FlushArrays(void)
{
@ -245,7 +254,7 @@ static void PPL_BaseChain_NoBump_1TMU(msurface_t *first, texture_t *tex)
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->stw);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
GL_TexEnv(GL_REPLACE);
GL_Bind (tex->gl_texturenum);
for (s=first; s ; s=s->texturechain)
@ -255,13 +264,13 @@ static void PPL_BaseChain_NoBump_1TMU(msurface_t *first, texture_t *tex)
PPL_FlushArrays();
glEnable(GL_BLEND);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_TexEnv(GL_MODULATE);
if (gl_lightmap_format == GL_LUMINANCE || gl_lightmap_format == GL_RGB)
glBlendFunc (GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
else if (gl_lightmap_format == GL_INTENSITY)
{
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_TexEnv(GL_MODULATE);
glColor4f (0,0,0,1);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
@ -310,24 +319,21 @@ static void PPL_BaseChain_NoBump_2TMU(msurface_t *s, texture_t *tex)
if (tex->alphaed)
{
glEnable(GL_BLEND);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_TexEnv(GL_MODULATE);
}
else
{
glDisable(GL_BLEND);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
GL_TexEnv(GL_REPLACE);
}
GL_Bind (tex->gl_texturenum);
qglClientActiveTextureARB(GL_TEXTURE0_ARB);
GL_MBind(GL_TEXTURE0_ARB, tex->gl_texturenum);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->stw);
qglClientActiveTextureARB(GL_TEXTURE1_ARB);
qglActiveTextureARB(GL_TEXTURE1_ARB);
glEnable(GL_TEXTURE_2D);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_SelectTexture(GL_TEXTURE1_ARB);
GL_TexEnv(GL_MODULATE);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->stl);
@ -337,11 +343,13 @@ static void PPL_BaseChain_NoBump_2TMU(msurface_t *s, texture_t *tex)
if (vi != s->lightmaptexturenum)
{
PPL_FlushArrays();
if (vi<0)
glEnable(GL_TEXTURE_2D);
vi = s->lightmaptexturenum;
if (vi>=0)
{
GL_BindType(GL_TEXTURE_2D, lightmap_textures[vi] );
GL_Bind(lightmap_textures[vi] );
if (lightmap[vi]->modified)
{
lightmap[vi]->modified = false;
@ -355,6 +363,8 @@ static void PPL_BaseChain_NoBump_2TMU(msurface_t *s, texture_t *tex)
theRect->w = 0;
}
}
else
glDisable(GL_TEXTURE_2D);
}
PPL_GenerateArrays(s);
@ -363,9 +373,9 @@ static void PPL_BaseChain_NoBump_2TMU(msurface_t *s, texture_t *tex)
glDisable(GL_TEXTURE_2D);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
qglClientActiveTextureARB(GL_TEXTURE0_ARB);
qglActiveTextureARB(GL_TEXTURE0_ARB);
GL_SelectTexture(GL_TEXTURE0_ARB);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
static void PPL_BaseChain_Bump_2TMU(msurface_t *first, texture_t *tex)
@ -378,33 +388,31 @@ static void PPL_BaseChain_Bump_2TMU(msurface_t *first, texture_t *tex)
if (tex->alphaed)
{
glEnable(GL_BLEND);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_TexEnv(GL_MODULATE);
}
else
{
glDisable(GL_BLEND);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
GL_TexEnv(GL_REPLACE);
}
//Bind normal map to texture unit 0
GL_BindType(GL_TEXTURE_2D, tex->gl_texturenumbumpmap);
GL_MBind(GL_TEXTURE0_ARB, tex->gl_texturenumbumpmap);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
GL_TexEnv(GL_COMBINE_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE);
qglClientActiveTextureARB(GL_TEXTURE0_ARB);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->stw);
qglActiveTextureARB(GL_TEXTURE1_ARB); //the deluxmap
GL_MBind(GL_TEXTURE1_ARB, tex->gl_texturenumbumpmap);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
GL_TexEnv(GL_COMBINE_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_DOT3_RGB_ARB);
qglClientActiveTextureARB(GL_TEXTURE1_ARB);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->stl);
@ -417,7 +425,7 @@ static void PPL_BaseChain_Bump_2TMU(msurface_t *first, texture_t *tex)
PPL_FlushArrays();
vi = s->lightmaptexturenum;
GL_BindType(GL_TEXTURE_2D, deluxmap_textures[vi] );
GL_Bind(deluxmap_textures[vi] );
if (lightmap[vi]->deluxmodified)
{
lightmap[vi]->deluxmodified = false;
@ -436,12 +444,11 @@ static void PPL_BaseChain_Bump_2TMU(msurface_t *first, texture_t *tex)
}
PPL_FlushArrays();
qglActiveTextureARB(GL_TEXTURE0_ARB);
GL_Bind (tex->gl_texturenum);
GL_MBind(GL_TEXTURE0_ARB, tex->gl_texturenum);
qglActiveTextureARB(GL_TEXTURE1_ARB);
GL_SelectTexture(GL_TEXTURE1_ARB);
glEnable(GL_TEXTURE_2D);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_TexEnv(GL_MODULATE);
vi = -1;
for (s=first; s ; s=s->texturechain)
@ -451,7 +458,7 @@ static void PPL_BaseChain_Bump_2TMU(msurface_t *first, texture_t *tex)
PPL_FlushArrays();
vi = s->lightmaptexturenum;
GL_BindType(GL_TEXTURE_2D, lightmap_textures[vi] );
GL_Bind(lightmap_textures[vi] );
if (lightmap[vi]->modified)
{
lightmap[vi]->modified = false;
@ -471,8 +478,7 @@ static void PPL_BaseChain_Bump_2TMU(msurface_t *first, texture_t *tex)
PPL_FlushArrays();
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
qglClientActiveTextureARB(GL_TEXTURE0_ARB);
qglActiveTextureARB(GL_TEXTURE0_ARB);
GL_SelectTexture(GL_TEXTURE0_ARB);
}
static void PPL_BaseChain_Bump_4TMU(msurface_t *s, texture_t *tex)
@ -481,44 +487,39 @@ static void PPL_BaseChain_Bump_4TMU(msurface_t *s, texture_t *tex)
glRect_t *theRect;
PPL_EnableVertexArrays();
qglActiveTextureARB(GL_TEXTURE0_ARB);
//Bind normal map to texture unit 0
GL_BindType(GL_TEXTURE_2D, tex->gl_texturenumbumpmap);
GL_MBind(GL_TEXTURE0_ARB, tex->gl_texturenumbumpmap);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE);
GL_TexEnv(GL_REPLACE);
qglClientActiveTextureARB(GL_TEXTURE0_ARB);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->stw);
qglActiveTextureARB(GL_TEXTURE1_ARB); //the deluxmap
//1 gets the deluxmap
GL_SelectTexture(GL_TEXTURE1_ARB);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
GL_TexEnv(GL_COMBINE_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_DOT3_RGB_ARB);
qglClientActiveTextureARB(GL_TEXTURE1_ARB);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->stl);
qglActiveTextureARB(GL_TEXTURE2_ARB);
//2 gets the diffusemap
GL_MBind(GL_TEXTURE2_ARB, tex->gl_texturenum);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_Bind (tex->gl_texturenum);
GL_TexEnv(GL_MODULATE);
qglClientActiveTextureARB(GL_TEXTURE2_ARB);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->stw);
qglActiveTextureARB(GL_TEXTURE3_ARB);
//3 gets the lightmap
GL_SelectTexture(GL_TEXTURE3_ARB);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_TexEnv(GL_MODULATE);
qglClientActiveTextureARB(GL_TEXTURE3_ARB);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->stl);
@ -530,8 +531,7 @@ static void PPL_BaseChain_Bump_4TMU(msurface_t *s, texture_t *tex)
PPL_FlushArrays();
vi = s->lightmaptexturenum;
qglActiveTextureARB(GL_TEXTURE1_ARB);
GL_BindType(GL_TEXTURE_2D, deluxmap_textures[vi] );
GL_MBind(GL_TEXTURE1_ARB, deluxmap_textures[vi] );
if (lightmap[vi]->deluxmodified)
{
lightmap[vi]->deluxmodified = false;
@ -544,8 +544,7 @@ static void PPL_BaseChain_Bump_4TMU(msurface_t *s, texture_t *tex)
theRect->h = 0;
theRect->w = 0;
}
qglActiveTextureARB(GL_TEXTURE3_ARB);
GL_BindType(GL_TEXTURE_2D, lightmap_textures[vi] );
GL_MBind(GL_TEXTURE3_ARB, lightmap_textures[vi] );
if (lightmap[vi]->modified)
{
lightmap[vi]->modified = false;
@ -564,26 +563,23 @@ static void PPL_BaseChain_Bump_4TMU(msurface_t *s, texture_t *tex)
}
PPL_FlushArrays();
qglActiveTextureARB(GL_TEXTURE3_ARB);
GL_SelectTexture(GL_TEXTURE3_ARB);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisable(GL_TEXTURE_2D);
qglActiveTextureARB(GL_TEXTURE2_ARB);
GL_SelectTexture(GL_TEXTURE2_ARB);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisable(GL_TEXTURE_2D);
qglActiveTextureARB(GL_TEXTURE1_ARB);
GL_SelectTexture(GL_TEXTURE1_ARB);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisable(GL_TEXTURE_2D);
qglActiveTextureARB(GL_TEXTURE0_ARB);
qglClientActiveTextureARB(GL_TEXTURE3_ARB);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
qglClientActiveTextureARB(GL_TEXTURE2_ARB);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
qglClientActiveTextureARB(GL_TEXTURE1_ARB);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
qglClientActiveTextureARB(GL_TEXTURE0_ARB);
GL_SelectTexture(GL_TEXTURE0_ARB);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_TexEnv(GL_MODULATE);
}
#ifdef SPECULAR
@ -610,7 +606,7 @@ glDisable(GL_BLEND);
qglActiveTextureARB(GL_TEXTURE0_ARB);
GL_BindType(GL_TEXTURE_2D, tex->gl_texturenumbumpmap);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
GL_TexEnv(GL_REPLACE);
qglClientActiveTextureARB(GL_TEXTURE0_ARB);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->stw);
@ -624,7 +620,7 @@ glDisable(GL_BLEND);
glEnable(GL_TEXTURE_CUBE_MAP_ARB);
if (qglGetError())
Con_Printf("Error binding dot3 cubemap\n");
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
GL_TexEnv(GL_COMBINE_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_DOT3_RGB_ARB);
@ -641,7 +637,7 @@ glDisable(GL_BLEND);
qglActiveTextureARB(GL_TEXTURE2_ARB);
GL_BindType(GL_TEXTURE_2D, tex->gl_texturenumbumpmap); //need to bind something.
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
GL_TexEnv(GL_COMBINE_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);
@ -652,7 +648,7 @@ glDisable(GL_BLEND);
qglActiveTextureARB(GL_TEXTURE3_ARB);
GL_BindType(GL_TEXTURE_2D, tex->gl_texturenumspec);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
GL_TexEnv(GL_COMBINE_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);
@ -673,12 +669,12 @@ glEnable(GL_BLEND);
glBlendFunc(GL_DST_COLOR, GL_ZERO);
// Add normal dot delux times diffusemap then multiple the entire lot by the lightmap.
qglActiveTextureARB(GL_TEXTURE0_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
GL_TexEnv(GL_REPLACE);
qglActiveTextureARB(GL_TEXTURE1_ARB);
glDisable(GL_TEXTURE_CUBE_MAP_ARB);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
GL_TexEnv(GL_COMBINE_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_DOT3_RGB_ARB);
@ -689,7 +685,7 @@ glBlendFunc(GL_DST_COLOR, GL_ZERO);
qglActiveTextureARB(GL_TEXTURE2_ARB);
glEnable(GL_TEXTURE_2D);
GL_BindType(GL_TEXTURE_2D, tex->gl_texturenum);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
GL_TexEnv(GL_COMBINE_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);
@ -700,7 +696,7 @@ glBlendFunc(GL_DST_COLOR, GL_ZERO);
qglActiveTextureARB(GL_TEXTURE3_ARB);
glEnable(GL_TEXTURE_2D);
glDisable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
GL_TexEnv(GL_COMBINE_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);
@ -900,11 +896,17 @@ static void PPL_BaseChain_Specular_FP(msurface_t *s, texture_t *tex)
if (qglGetError())
Con_Printf("GL Error on shadow lighting\n");
qglActiveTextureARB(GL_TEXTURE0_ARB);
GL_BindType(GL_TEXTURE_2D, tex->gl_texturenum);
GL_MBind(GL_TEXTURE0_ARB, tex->gl_texturenum);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->stw);
qglActiveTextureARB(GL_TEXTURE1_ARB);
GL_BindType(GL_TEXTURE_2D, tex->gl_texturenumbumpmap);
GL_MBind(GL_TEXTURE1_ARB, tex->gl_texturenumbumpmap);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->stl);
GL_SelectTexture(GL_TEXTURE2_ARB);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(3, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->ncm);
//qglActiveTextureARB(GL_TEXTURE2_ARB);
//GL_BindType(GL_TEXTURE_2D, ); //lightmap
@ -915,24 +917,12 @@ static void PPL_BaseChain_Specular_FP(msurface_t *s, texture_t *tex)
if (qglGetError())
Con_Printf("GL Error on shadow lighting\n");
qglActiveTextureARB(GL_TEXTURE4_ARB);
GL_BindType(GL_TEXTURE_2D, tex->gl_texturenumspec);
GL_MBind(GL_TEXTURE4_ARB, tex->gl_texturenumspec);
qglActiveTextureARB(GL_TEXTURE5_ARB);
GL_SelectTexture(GL_TEXTURE5_ARB);
GL_BindType(GL_TEXTURE_CUBE_MAP_ARB, normalisationCubeMap);
qglClientActiveTextureARB(GL_TEXTURE0_ARB);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->stw);
qglClientActiveTextureARB(GL_TEXTURE1_ARB);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->stl);
qglClientActiveTextureARB(GL_TEXTURE2_ARB);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(3, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->ncm);
if (qglGetError())
Con_Printf("GL Error on shadow lighting\n");
@ -945,8 +935,7 @@ static void PPL_BaseChain_Specular_FP(msurface_t *s, texture_t *tex)
PPL_FlushArrays();
vi = s->lightmaptexturenum;
qglActiveTextureARB(GL_TEXTURE3_ARB);
GL_BindType(GL_TEXTURE_2D, deluxmap_textures[vi] );
GL_MBind(GL_TEXTURE3_ARB, deluxmap_textures[vi] );
if (lightmap[vi]->deluxmodified)
{
lightmap[vi]->deluxmodified = false;
@ -959,8 +948,7 @@ static void PPL_BaseChain_Specular_FP(msurface_t *s, texture_t *tex)
theRect->h = 0;
theRect->w = 0;
}
qglActiveTextureARB(GL_TEXTURE2_ARB);
GL_BindType(GL_TEXTURE_2D, lightmap_textures[vi] );
GL_MBind(GL_TEXTURE2_ARB, lightmap_textures[vi] );
if (lightmap[vi]->modified)
{
lightmap[vi]->modified = false;
@ -983,17 +971,15 @@ static void PPL_BaseChain_Specular_FP(msurface_t *s, texture_t *tex)
glDisable(GL_FRAGMENT_PROGRAM_ARB);
qglClientActiveTextureARB(GL_TEXTURE1_ARB);
GL_SelectTexture(GL_TEXTURE2_ARB);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
qglClientActiveTextureARB(GL_TEXTURE2_ARB);
GL_SelectTexture(GL_TEXTURE1_ARB);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
qglClientActiveTextureARB(GL_TEXTURE0_ARB);
GL_SelectTexture(GL_TEXTURE0_ARB);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
qglActiveTextureARB(GL_TEXTURE0_ARB);
if (qglGetError())
Con_Printf("GL Error on shadow lighting\n");
@ -1029,45 +1015,42 @@ rgb * lightmap -> rgb
glDisable(GL_BLEND);
//0 takes a normalmap
qglActiveTextureARB(GL_TEXTURE0_ARB);
GL_BindType(GL_TEXTURE_2D, tex->gl_texturenumbumpmap);
qglClientActiveTextureARB(GL_TEXTURE0_ARB);
GL_MBind(GL_TEXTURE0_ARB, tex->gl_texturenumbumpmap);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->stw);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
GL_TexEnv(GL_REPLACE);
//1 takes a cubemap for specular half-vectors.
qglActiveTextureARB(GL_TEXTURE1_ARB);
GL_SelectTexture(GL_TEXTURE1_ARB);
GL_BindType(GL_TEXTURE_CUBE_MAP_ARB, normalisationCubeMap);
glDisable(GL_TEXTURE_2D);
glEnable(GL_TEXTURE_CUBE_MAP_ARB);
qglClientActiveTextureARB(GL_TEXTURE1_ARB);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(3, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->ncm);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
GL_TexEnv(GL_COMBINE_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_DOT3_RGBA_ARB); //writes alpha
//2 takes a normalmap
qglActiveTextureARB(GL_TEXTURE2_ARB);
GL_MBind(GL_TEXTURE2_ARB, tex->gl_texturenumbumpmap);
glEnable(GL_TEXTURE_2D);
GL_BindType(GL_TEXTURE_2D, tex->gl_texturenumbumpmap);
qglClientActiveTextureARB(GL_TEXTURE2_ARB);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->stw);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
GL_TexEnv(GL_COMBINE_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PREVIOUS_ARB); //square the alpha
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, GL_PREVIOUS_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_MODULATE);
//3 takes the deluxmap
qglActiveTextureARB(GL_TEXTURE3_ARB);
GL_SelectTexture(GL_TEXTURE3_ARB);
glEnable(GL_TEXTURE_2D); //bind with the surface texturenum
qglClientActiveTextureARB(GL_TEXTURE3_ARB);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->stl);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
GL_TexEnv(GL_COMBINE_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_DOT3_RGB_ARB);
@ -1075,15 +1058,14 @@ rgb * lightmap -> rgb
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PREVIOUS_ARB); //square the alpha again.
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, GL_PREVIOUS_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_MODULATE);
//4 multiplies with diffuse
qglActiveTextureARB(GL_TEXTURE4_ARB);
GL_MBind(GL_TEXTURE4_ARB, tex->gl_texturenum);
glEnable(GL_TEXTURE_2D);
GL_BindType(GL_TEXTURE_2D, tex->gl_texturenum);
qglClientActiveTextureARB(GL_TEXTURE4_ARB);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->stw);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
GL_TexEnv(GL_COMBINE_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);
@ -1097,22 +1079,20 @@ rgb * lightmap -> rgb
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_MODULATE);
//5 halves rgb and alpha (so that adding will not clamp)
qglActiveTextureARB(GL_TEXTURE5_ARB);
GL_MBind(GL_TEXTURE5_ARB, tex->gl_texturenum); //need to bind something.
glEnable(GL_TEXTURE_2D);
GL_BindType(GL_TEXTURE_2D, tex->gl_texturenum); //need to bind something.
qglClientActiveTextureARB(GL_TEXTURE5_ARB);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->stw);
/* glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, fourhalffloats);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
GL_TexEnv(GL_COMBINE_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_CONSTANT_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);
*/
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
GL_TexEnv(GL_COMBINE_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PREVIOUS_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_ALPHA);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, GL_CONSTANT_ARB);
@ -1126,15 +1106,13 @@ rgb * lightmap -> rgb
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);
//6 adds rgb and alpha, using the glossmap...
qglActiveTextureARB(GL_TEXTURE6_ARB);
GL_MBind(GL_TEXTURE6_ARB, tex->gl_texturenumspec);
glEnable(GL_TEXTURE_2D);
GL_BindType(GL_TEXTURE_2D, tex->gl_texturenumspec);
qglClientActiveTextureARB(GL_TEXTURE6_ARB);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->stw);
//broken diffuse + specular
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
GL_TexEnv(GL_COMBINE_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_ALPHA);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);
@ -1143,13 +1121,13 @@ rgb * lightmap -> rgb
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_ARB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE_ADD_ATI);
//perfect diffuse
/* glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
/* GL_TexEnv(GL_COMBINE_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE);
*/
//perfect specular
/* glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
/* GL_TexEnv(GL_COMBINE_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_ALPHA);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_TEXTURE);
@ -1157,13 +1135,13 @@ rgb * lightmap -> rgb
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);
*/
//7 multiplies by lightmap
qglActiveTextureARB(GL_TEXTURE7_ARB);
GL_SelectTexture(GL_TEXTURE7_ARB);
glEnable(GL_TEXTURE_2D); //bind with the surface texturenum
qglClientActiveTextureARB(GL_TEXTURE7_ARB);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->stl);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
GL_TexEnv(GL_COMBINE_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_ONE_MINUS_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);
@ -1178,8 +1156,7 @@ rgb * lightmap -> rgb
PPL_FlushArrays();
vi = s->lightmaptexturenum;
qglActiveTextureARB(GL_TEXTURE3_ARB);
GL_BindType(GL_TEXTURE_2D, deluxmap_textures[vi] );
GL_MBind(GL_TEXTURE3_ARB, deluxmap_textures[vi] );
if (lightmap[vi]->deluxmodified)
{
lightmap[vi]->deluxmodified = false;
@ -1192,8 +1169,7 @@ rgb * lightmap -> rgb
theRect->h = 0;
theRect->w = 0;
}
qglActiveTextureARB(GL_TEXTURE7_ARB);
GL_BindType(GL_TEXTURE_2D, lightmap_textures[vi] );
GL_MBind(GL_TEXTURE7_ARB, lightmap_textures[vi] );
if (lightmap[vi]->modified)
{
lightmap[vi]->modified = false;
@ -1215,17 +1191,15 @@ rgb * lightmap -> rgb
for (vi = 7; vi > 0; vi--)
{
qglActiveTextureARB(GL_TEXTURE0_ARB+vi);
GL_SelectTexture(GL_TEXTURE0_ARB+vi);
glDisable(GL_TEXTURE_2D);
qglClientActiveTextureARB(GL_TEXTURE0_ARB+vi);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
glDisable(GL_TEXTURE_CUBE_MAP_ARB);
glDisable(GL_TEXTURE_CUBE_MAP_ARB);//1
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
qglActiveTextureARB(GL_TEXTURE0_ARB);
qglClientActiveTextureARB(GL_TEXTURE0_ARB);
GL_SelectTexture(GL_TEXTURE0_ARB);
}
#endif
@ -1239,11 +1213,22 @@ static void PPL_BaseTextureChain(msurface_t *first)
meshbuffer_t mb;
msurface_t *s;
int vi=-1;
int redraw = false;
glRect_t *theRect;
// GL_PushShader(first->texinfo->texture->shader);
if (first->texinfo->texture->shader->flags & SHADER_FLARE )
return;
if (!varrayactive)
R_IBrokeTheArrays();
mb.entity = &r_worldentity;
mb.shader = first->texinfo->texture->shader;
mb.mesh = NULL;
mb.fog = NULL;
mb.infokey = -2;
mb.dlightbits = 0;
GL_DisableMultitexture();
glShadeModel(GL_SMOOTH);
@ -1256,9 +1241,9 @@ static void PPL_BaseTextureChain(msurface_t *first)
vi = s->lightmaptexturenum;
if (vi >= 0)
{
GL_BindType(GL_TEXTURE_2D, deluxmap_textures[vi] );
if (lightmap[vi]->deluxmodified)
{
GL_BindType(GL_TEXTURE_2D, deluxmap_textures[vi] );
lightmap[vi]->deluxmodified = false;
theRect = &lightmap[vi]->deluxrectchange;
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, theRect->t,
@ -1269,9 +1254,9 @@ static void PPL_BaseTextureChain(msurface_t *first)
theRect->h = 0;
theRect->w = 0;
}
GL_BindType(GL_TEXTURE_2D, lightmap_textures[vi] );
if (lightmap[vi]->modified)
{
GL_BindType(GL_TEXTURE_2D, lightmap_textures[vi] );
lightmap[vi]->modified = false;
theRect = &lightmap[vi]->rectchange;
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, theRect->t,
@ -1284,32 +1269,35 @@ static void PPL_BaseTextureChain(msurface_t *first)
}
}
}
if (s->flags&SURF_DRAWALPHA || !(mb.shader->sort & SHADER_SORT_OPAQUE))
{
extern msurface_t *r_alpha_surfaces;
s->nextalphasurface = r_alpha_surfaces;
r_alpha_surfaces = s;
s->ownerent = &r_worldentity;
continue;
}
if (s->mesh)
{
/* MF_NONE = 1<<0,
MF_NORMALS = 1<<1,
MF_TRNORMALS = 1<<2,
MF_COLORS = 1<<3,
MF_STCOORDS = 1<<4,
MF_LMCOORDS = 1<<5,
MF_NOCULL = 1<<6*/
mb.entity = &r_worldentity;
mb.shader = first->texinfo->texture->shader;
mb.fog = s->fog;
mb.mesh = s->mesh;
mb.infokey = vi;
mb.dlightbits = 0;
R_PushMesh(s->mesh, mb.shader->features);
redraw = mb.fog != s->fog || mb.infokey != vi|| mb.shader->flags&SHADER_DEFORMV_BULGE;
if (redraw)
{
if (mb.mesh)
R_RenderMeshBuffer ( &mb, false );
// GL_PushMesh(s->mesh, deluxmap_textures[vi], lightmap_textures[vi]);
redraw = false;
}
mb.infokey = vi;
mb.mesh = s->mesh;
mb.fog = s->fog;
R_PushMesh(s->mesh, mb.shader->features);
}
}
}
// GL_PushShader(NULL); //fixme: remove the need.
if (mb.mesh)
R_RenderMeshBuffer ( &mb, false );
return;
}
#endif
@ -1461,10 +1449,7 @@ void PPL_BaseTextures(model_t *model)
continue;
if ((s->flags & SURF_DRAWTURB) && r_wateralphaval != 1.0)
{
t->texturechain = NULL;
continue; // draw translucent water later
}
PPL_BaseTextureChain(s);
}
@ -1485,6 +1470,8 @@ void PPL_BaseBModelTextures(entity_t *e)
currentmodel = model = e->model;
s = model->surfaces+model->firstmodelsurface;
GL_TexEnv(GL_MODULATE);
if (currententity->alpha<1)
{
glEnable(GL_BLEND);
@ -1543,6 +1530,10 @@ void PPL_BaseBModelTextures(entity_t *e)
glPopMatrix();
GL_DisableMultitexture();
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
if (!varrayactive)
R_IBrokeTheArrays();
}
void PPL_BaseEntTextures(void)
@ -1584,6 +1575,8 @@ void PPL_BaseEntTextures(void)
switch (currententity->model->type)
{
case mod_alias:
if (!varrayactive)
R_IBrokeTheArrays();
R_DrawGAliasModel (currententity);
break;
@ -1714,6 +1707,9 @@ void PPL_LightTextures(model_t *model, vec3_t modelorigin, dlight_t *light)
if (!s)
continue;
if ((s->flags & SURF_DRAWTURB) && r_wateralphaval != 1.0)
continue; // draw translucent water later
{
extern int normalisationCubeMap;
@ -1725,34 +1721,28 @@ void PPL_LightTextures(model_t *model, vec3_t modelorigin, dlight_t *light)
glColorPointer(3, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->stl);
if (t->gl_texturenumbumpmap && gl_mtexarbable>2)
{
qglActiveTextureARB(GL_TEXTURE0_ARB);
GL_BindType(GL_TEXTURE_2D, t->gl_texturenumbumpmap);
GL_MBind(GL_TEXTURE0_ARB, t->gl_texturenumbumpmap);
glEnable(GL_TEXTURE_2D);
//Set up texture environment to do (tex0 dot tex1)*color
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); //make texture normalmap available.
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE);
GL_TexEnv(GL_REPLACE); //make texture normalmap available.
qglClientActiveTextureARB(GL_TEXTURE0_ARB);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->stw);
qglActiveTextureARB(GL_TEXTURE1_ARB);
GL_SelectTexture(GL_TEXTURE1_ARB);
GL_BindType(GL_TEXTURE_CUBE_MAP_ARB, normalisationCubeMap);
glEnable(GL_TEXTURE_CUBE_MAP_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); //normalisation cubemap * normalmap
GL_TexEnv(GL_COMBINE_ARB); //normalisation cubemap * normalmap
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_DOT3_RGB_ARB);
qglClientActiveTextureARB(GL_TEXTURE1_ARB);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(3, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->ncm);
qglActiveTextureARB(GL_TEXTURE2_ARB);
GL_BindType(GL_TEXTURE_2D, t->gl_texturenumbumpmap);
GL_MBind(GL_TEXTURE2_ARB, t->gl_texturenumbumpmap); //a dummy
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); //bumps * color (the attenuation)
GL_TexEnv(GL_COMBINE_ARB); //bumps * color (the attenuation)
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PRIMARY_COLOR_ARB); //(doesn't actually use the bound texture)
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);
@ -1760,15 +1750,14 @@ void PPL_LightTextures(model_t *model, vec3_t modelorigin, dlight_t *light)
}
else
{
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_TexEnv(GL_MODULATE);
glDisable(GL_TEXTURE_2D);
qglActiveTextureARB(GL_TEXTURE1_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_SelectTexture(GL_TEXTURE1_ARB);
GL_TexEnv(GL_MODULATE);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisable(GL_TEXTURE_CUBE_MAP_ARB);
qglActiveTextureARB(GL_TEXTURE0_ARB);
qglClientActiveTextureARB(GL_TEXTURE0_ARB);
GL_SelectTexture(GL_TEXTURE0_ARB);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->stw);
}
@ -1801,16 +1790,16 @@ void PPL_LightTextures(model_t *model, vec3_t modelorigin, dlight_t *light)
}
}
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_TexEnv(GL_MODULATE);
glDisable(GL_TEXTURE_2D);
qglClientActiveTextureARB(GL_TEXTURE1_ARB);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
qglClientActiveTextureARB(GL_TEXTURE0_ARB);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
qglActiveTextureARB(GL_TEXTURE1_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_SelectTexture(GL_TEXTURE1_ARB);
GL_TexEnv(GL_MODULATE);
glDisable(GL_TEXTURE_CUBE_MAP_ARB);
qglActiveTextureARB(GL_TEXTURE0_ARB);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
GL_SelectTexture(GL_TEXTURE0_ARB);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisable(GL_TEXTURE_2D);
}
@ -1841,34 +1830,28 @@ void PPL_LightBModelTextures(entity_t *e, dlight_t *light)
glColorPointer(3, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->stl);
if (t->gl_texturenumbumpmap && gl_mtexarbable>2)
{
qglActiveTextureARB(GL_TEXTURE0_ARB);
GL_BindType(GL_TEXTURE_2D, t->gl_texturenumbumpmap);
GL_MBind(GL_TEXTURE0_ARB, t->gl_texturenumbumpmap);
glEnable(GL_TEXTURE_2D);
//Set up texture environment to do (tex0 dot tex1)*color
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); //make texture normalmap available.
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE);
GL_TexEnv(GL_REPLACE); //make texture normalmap available.
qglClientActiveTextureARB(GL_TEXTURE0_ARB);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->stw);
qglActiveTextureARB(GL_TEXTURE1_ARB);
GL_SelectTexture(GL_TEXTURE1_ARB);
GL_BindType(GL_TEXTURE_CUBE_MAP_ARB, normalisationCubeMap);
glEnable(GL_TEXTURE_CUBE_MAP_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); //normalisation cubemap * normalmap
GL_TexEnv(GL_COMBINE_ARB); //normalisation cubemap * normalmap
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_DOT3_RGB_ARB);
qglClientActiveTextureARB(GL_TEXTURE1_ARB);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(3, GL_FLOAT, sizeof(surfvertexarray_t), varray_v->ncm);
qglActiveTextureARB(GL_TEXTURE2_ARB);
GL_BindType(GL_TEXTURE_2D, t->gl_texturenumbumpmap);
GL_MBind(GL_TEXTURE2_ARB, t->gl_texturenumbumpmap);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); //bumps * color (the attenuation)
GL_TexEnv(GL_COMBINE_ARB); //bumps * color (the attenuation)
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PRIMARY_COLOR_ARB); //(doesn't actually use the bound texture)
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);
@ -1876,10 +1859,10 @@ void PPL_LightBModelTextures(entity_t *e, dlight_t *light)
}
else
{
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_TexEnv(GL_MODULATE);
glDisable(GL_TEXTURE_2D);
qglActiveTextureARB(GL_TEXTURE1_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_TexEnv(GL_MODULATE);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisable(GL_TEXTURE_CUBE_MAP_ARB);
qglActiveTextureARB(GL_TEXTURE0_ARB);
@ -1916,14 +1899,14 @@ void PPL_LightBModelTextures(entity_t *e, dlight_t *light)
PPL_FlushArrays();
}
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_TexEnv(GL_MODULATE);
glDisable(GL_TEXTURE_2D);
qglClientActiveTextureARB(GL_TEXTURE1_ARB);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
qglClientActiveTextureARB(GL_TEXTURE0_ARB);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
qglActiveTextureARB(GL_TEXTURE1_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_TexEnv(GL_MODULATE);
glDisable(GL_TEXTURE_CUBE_MAP_ARB);
qglActiveTextureARB(GL_TEXTURE0_ARB);
glDisable(GL_TEXTURE_2D);
@ -1971,6 +1954,8 @@ void PPL_DrawEntLighting(dlight_t *light)
switch (currententity->model->type)
{
case mod_alias:
// if (!varrayactive)
// R_IBrokeTheArrays();
// R_DrawGAliasModelLighting (currententity);
break;
@ -1994,7 +1979,7 @@ void PPL_FullBrights(model_t *model)
glDepthMask(0); //don't bother writing depth
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_TexEnv(GL_MODULATE);
glShadeModel(GL_FLAT);
@ -2010,12 +1995,15 @@ void PPL_FullBrights(model_t *model)
if (!s)
continue;
if ((s->flags & SURF_DRAWTURB) && r_wateralphaval != 1.0)
continue; // draw translucent water later
PPL_FullBrightTextureChain(s);
t->texturechain=NULL;
}
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
GL_TexEnv(GL_REPLACE);
glDepthMask(1);
}
@ -2034,7 +2022,7 @@ void PPL_FullBrightBModelTextures(entity_t *e)
glColor4f(1, 1, 1, 1);
glDepthMask(0); //don't bother writing depth
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_TexEnv(GL_MODULATE);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glShadeModel(GL_FLAT);
@ -3347,7 +3335,6 @@ void PPL_AddLight(dlight_t *dl)
PPL_UpdateNodeShadowFrames(lvis);
PPL_RecursiveWorldNode(dl);
PPL_DrawShadowMeshes(dl);
Con_Printf("%i ", shadowsurfcount);
shadowsurfcount=0;
glCullFace(GL_FRONT);
@ -3355,7 +3342,6 @@ void PPL_AddLight(dlight_t *dl)
PPL_UpdateNodeShadowFrames(lvis);
PPL_RecursiveWorldNode(dl);
PPL_DrawShadowMeshes(dl);
Con_Printf("%i\n", shadowsurfcount);
glStencilFunc( GL_EQUAL, 0, ~0 );
}
@ -3453,7 +3439,6 @@ void PPL_DrawWorld (void)
}
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
}
// if (qglGetError())
@ -3469,5 +3454,7 @@ void PPL_DrawWorld (void)
shadowsurfcount = 0;
shadowedgecount = 0;
shadowlightfaces = 0;
R_IBrokeTheArrays();
}
#endif

12
engine/gl/gl_rlight.c
View file

@ -412,11 +412,15 @@ void GLQ3_LightGrid(vec3_t point, vec3_t res_diffuse, vec3_t res_ambient, vec3_t
res_dir[2] = 0.1;
}
if (!lg)
// if (!lg)
{
res_ambient[0] = 255;
res_ambient[1] = 255;
res_ambient[2] = 255;
res_ambient[0] = 64;
res_ambient[1] = 64;
res_ambient[2] = 64;
res_diffuse[0] = 192;
res_diffuse[1] = 192;
res_diffuse[2] = 192;
return;
}

50
engine/gl/gl_rsurf.c
View file

@ -2083,7 +2083,7 @@ void GLR_DrawWaterSurfaces (void)
glEnable (GL_BLEND);
glDisable (GL_ALPHA_TEST);
glColor4f (1,1,1,r_wateralphaval);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_TexEnv(GL_MODULATE);
}
if (gl_waterripples.value)
@ -2105,8 +2105,6 @@ void GLR_DrawWaterSurfaces (void)
if ( !(s->flags & SURF_DRAWTURB ) )
continue;
// set modulate mode explicitly
GL_Bind (t->gl_texturenum);
for ( ; s ; s=s->texturechain)
@ -2116,7 +2114,7 @@ void GLR_DrawWaterSurfaces (void)
}
if (r_wateralphaval < 1.0) {
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
GL_TexEnv(GL_REPLACE);
glColor4f (1,1,1,1);
glDisable (GL_BLEND);
@ -2132,7 +2130,29 @@ static void GLR_DrawAlphaSurface(msurface_t *s)
{
glPushMatrix();
R_RotateForEntity(s->ownerent);
#ifdef Q3SHADERS
if (s->texinfo->texture->shader)
{
meshbuffer_t mb;
mb.dlightbits = 0;
mb.entity = s->ownerent;
mb.shader = s->texinfo->texture->shader;
mb.sortkey = 0;
mb.infokey = s->lightmaptexturenum;
mb.mesh = s->mesh;
mb.fog = s->fog;
currententity = s->ownerent;
if (s->mesh)
{
R_PushMesh(s->mesh, mb.shader->features|MF_NONBATCHED);
R_RenderMeshBuffer ( &mb, false );
}
glPopMatrix();
return;
}
#endif
GL_Bind(s->texinfo->texture->gl_texturenum);
if (s->texinfo->flags & SURF_TRANS33)
@ -2153,10 +2173,10 @@ static void GLR_DrawAlphaSurface(msurface_t *s)
int i;
float *v;
glpoly_t *p;
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
GL_TexEnv(GL_REPLACE);
GL_EnableMultitexture();
GL_Bind(lightmap_textures[s->lightmaptexturenum]);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND);
GL_TexEnv(GL_BLEND);
p = s->polys;
glColor4f (1,1,1,1);
@ -2209,16 +2229,12 @@ void GLR_DrawAlphaSurfaces (void)
//
glLoadMatrixf (r_world_matrix);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_TexEnv(GL_MODULATE);
glEnable(GL_ALPHA_TEST);
glDisable(GL_BLEND);
if (cl.worldmodel && (cl.worldmodel->fromgame == fg_quake3|| cl.worldmodel->fromgame == fg_quake2))
if (cl.worldmodel && (cl.worldmodel->fromgame == fg_quake2))
{ //this is a mahoosive hack.
//we need to use different blending modes for lights and 'rugs'...
//we could do this by seeing if a texture includes alpha - rug, or if it's fully solid - light.
if (cl.worldmodel->fromgame == fg_quake3)
glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_COLOR);
glDepthMask(0); //this makes no difference to the cheating.
glDisable(GL_ALPHA_TEST);
@ -2250,10 +2266,10 @@ void GLR_DrawAlphaSurfaces (void)
float *v;
glpoly_t *p;
GL_Bind(s->texinfo->texture->gl_texturenum);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
GL_TexEnv(GL_REPLACE);
GL_EnableMultitexture();
GL_Bind(lightmap_textures[s->lightmaptexturenum]);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND);
GL_TexEnv(GL_BLEND);
p = s->polys;
@ -2297,7 +2313,7 @@ void GLR_DrawAlphaSurfaces (void)
RQ_RenderDistAndClear();
glDepthMask(1);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
GL_TexEnv(GL_REPLACE);
glColor4f (1,1,1,1);
glDisable (GL_BLEND);
@ -2468,13 +2484,13 @@ static void DrawTextureChains (model_t *model, float alpha, vec3_t relativelight
glEnable(GL_TEXTURE_2D);
//Set up texture environment to do (tex0 dot tex1)*color
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
GL_TexEnv(GL_COMBINE_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE);
qglActiveTextureARB(GL_TEXTURE1_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
GL_TexEnv(GL_COMBINE_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_DOT3_RGB_ARB);

2
engine/gl/gl_shader.c
View file

@ -1894,7 +1894,7 @@ int R_LoadShader ( char *name, int type )
s->numpasses = 1;
s->numdeforms = 0;
s->flags = SHADER_NOPICMIP|SHADER_NOMIPMAPS;
s->flags = SHADER_NOPICMIP|SHADER_NOMIPMAPS|SHADER_BLEND;
s->features = MF_STCOORDS|MF_COLORS;
s->sort = SHADER_SORT_ADDITIVE;
s->registration_sequence = 1;//fizme: registration_sequence;

3
engine/gl/gl_warp.c
View file

@ -323,7 +323,10 @@ void EmitSkyPolys (msurface_t *fa)
if (fa->mesh)
{
fa->mesh->colors_array = NULL;
glDisable(GL_TEXTURE_2D);
glColor3f(0,0,0);
GL_DrawAliasMesh(fa->mesh, 1);
glEnable(GL_TEXTURE_2D);
}
else
{

264
engine/gl/glmod_doom.c
View file

@ -1628,6 +1628,264 @@ int Doom_PointContents(hull_t *hull, vec3_t p)
return FTECONTENTS_EMPTY;
}
#define NEWTRACES
#ifdef NEWTRACES
static qboolean ispoint;
static void ClipToBlockMap(hull_t *hull, int block, vec3_t start, vec3_t end, trace_t *trace)
{
unsigned short *linedefs;
dlinedef_t *ld;
plane_t *lp;
float planedist;
float d1, d2; //distance start, end
trace->endpos[0] = end[0];
trace->endpos[1] = end[1];
trace->endpos[2] = end[2];
trace->fraction = 1;
for(linedefs = (short*)blockmapl + blockmapofs[block]+1; *linedefs != 0xffff; linedefs++)
{
ld = linedefsl + *linedefs;
lp = lineplanes + *linedefs;
if (ispoint)
planedist = lp->dist;
else
{ //figure out how far to move the plane out by (tracebox instead of tracecylinder
vec3_t ofs;
int j;
for (j=0 ; j<2 ; j++)
{
if (lp->normal[j] < 0)
ofs[j] = hull->clip_maxs[j];
else
ofs[j] = hull->clip_mins[j];
}
ofs[2] = 0;
planedist = lp->dist - DotProduct (ofs, lp->normal);
}
d1 = DotProduct(lp->normal, start) - (planedist);
d2 = DotProduct(lp->normal, end) - (planedist);
if (d1 > 0 && d2 > 0)
continue; //both points on the front side.
if (d1 < 0 && d2 < 0)
continue; //both points on the back side.
}
}
static int numinsectors;
static int insector[8];
static trace_t *trace_trace;
static hull_t *trace_hull;
static vec3_t trace_end;
static vec3_t trace_start;
static qboolean EnterSector(int secnum, float z)
{
int i;
for (i = 0; i < numinsectors; i++)
if (insector[i] == secnum)
return true; //erm. already in this one
if (i == sizeof(insector)/sizeof(insector[0]))
{
Con_DPrintf("Trace was in too many sectors\n");
return false; //you're not allowed to enter
}
if (z + trace_hull->clip_mins[2] < sectorm[secnum].floorheight) //was outside
return false;
if (z + trace_hull->clip_mins[2] > sectorm[secnum].ceilingheight) //was outside
return false;
insector[i] = secnum;
return true; //yay, the trace entered a big enough hole!
}
void LeaveSector(int secnum, float x, float y)
{
float z;
int i;
for (i = 0; i < numinsectors; i++)
if (insector[i] == secnum)
{
//switch with last.
insector[i] = insector[numinsectors-1];
numinsectors--;
//z at x,y
if (trace_end[0]-trace_start[0])
z = (trace_end[2]-trace_start[2])/(trace_end[0]-trace_start[0]);
else if (trace_end[1]-trace_start[1])
z = (trace_end[2]-trace_start[2])/(trace_end[1]-trace_start[1]);
else
{ //was a vertical trace.
z = trace_end[2];
}
if (z > sectorm[secnum].ceilingheight)
{
z = sectorm[secnum].ceilingheight;
if (z < trace_trace->endpos[2])
{
trace_trace->endpos[0] -= (trace_end[0]-trace_start[0])/(z-trace_start[0]);
trace_trace->endpos[1] -= (trace_end[1]-trace_start[1])/(z-trace_start[1]);
trace_trace->endpos[2] = z;
}
}
if (z < sectorm[secnum].floorheight)
{
z = sectorm[secnum].floorheight;
if (z < trace_trace->endpos[2])
{
trace_trace->endpos[0] -= (trace_end[0]-trace_start[0])/(z-trace_start[0]);
trace_trace->endpos[1] -= (trace_end[1]-trace_start[1])/(z-trace_start[1]);
trace_trace->endpos[2] = z;
}
}
return;
}
Con_DPrintf("Trace wasn't in sector\n");
}
void Doom_ClipToInitialNode(int nodenum)
{
int s;
int seg;
ddoomnode_t *node;
if (nodenum & NODE_IS_SSECTOR)
{
nodenum -= NODE_IS_SSECTOR;
for (seg = ssectorsl[nodenum].first; seg < ssectorsl[nodenum].first + ssectorsl[nodenum].segcount; seg++)
if (segsl[seg].linedef != 0xffff)
break;
s = sidedefsm[linedefsl[segsl[seg].linedef].sidedef[segsl[seg].direction]].sector;
if (!EnterSector(s, trace_start[2]))
{ //clipped by floor
trace_trace->fraction = 0;
trace_trace->allsolid = trace_trace->startsolid = true;
trace_trace->endpos[0] = trace_start[0];
trace_trace->endpos[1] = trace_start[1];
trace_trace->endpos[2] = trace_start[2]; //yeah, we do mean this - startsolid
// if (IS_NAN(trace->endpos[2]))
// Con_Printf("Nanny\n");
}
return;
}
node = nodel + nodenum;
if (node->x1lower+trace_hull->clip_mins[0] <= trace_start[0] && node->x1upper+trace_hull->clip_maxs[0] >= trace_start[0])
if (node->y1lower+trace_hull->clip_mins[1] <= trace_start[1] && node->y1upper+trace_hull->clip_maxs[1] >= trace_start[1])
Doom_ClipToInitialNode(node->node1);
if (node->x2lower+trace_hull->clip_mins[0] <= trace_start[0] && node->x2upper+trace_hull->clip_maxs[0] >= trace_start[0])
if (node->y2lower+trace_hull->clip_mins[1] <= trace_start[1] && node->y2upper+trace_hull->clip_maxs[1] >= trace_start[1])
Doom_ClipToInitialNode(node->node2);
}
void Doom_ClipToInitialSectors(void)
{
Doom_ClipToInitialNode(nodec-1);
/*
ddoomnode_t *node;
plane_t *plane;
int num;
int seg;
float d;
num = nodec-1;
while (1)
{
if (num & NODE_IS_SSECTOR)
{
num -= NODE_IS_SSECTOR;
for (seg = ssectorsl[num].first; seg < ssectorsl[num].first + ssectorsl[num].segcount; seg++)
if (segsl[seg].linedef != 0xffff)
break;
return sidedefsm[linedefsl[segsl[seg].linedef].sidedef[segsl[seg].direction]].sector;
}
node = nodel + num;
plane = nodeplanes + num;
// if (plane->type < 3)
// d = p[plane->type] - plane->dist;
// else
d = DotProduct (plane->normal, p) - plane->dist;
if (d < 0)
num = node->node2;
else
num = node->node1;
}
return num;
*/
}
qboolean Doom_RecursiveHullCheck (hull_t *hull, int num, float p1f, float p2f, vec3_t start, vec3_t end, trace_t *trace)
{
int bmi;
ispoint = !hull->clip_mins[0] && !hull->clip_mins[1] && !hull->clip_maxs[0] && !hull->clip_maxs[1];
trace->allsolid = trace->startsolid = false;
trace->contents = FTECONTENTS_EMPTY;
trace_trace = trace;
trace_hull = hull;
trace_end[0] = end[0];
trace_end[1] = end[1];
trace_end[2] = end[2];
trace_start[0] = start[0];
trace_start[1] = start[1];
trace_start[2] = start[2];
Doom_ClipToInitialNode(nodec-1);
if (trace->allsolid) //started outside gamespace
return trace->fraction==1;
//clip to the blockmap.
//blockmap is 128*128
bmi = ((int)start[0] - blockmapl->xorg)/128 + (((int)start[1] - blockmapl->yorg)/128)*blockmapl->columns;
if (end[0] - start[0] > 0)
{
if (end[1] - start[1] > 0)
{
ClipToBlockMap(hull, bmi, start, end, trace);
}
else
{
trace->endpos[0] = start[0];
trace->endpos[1] = start[1];
trace->endpos[2] = start[2];
trace->fraction = 0;
}
}
else
{
trace->endpos[0] = start[0];
trace->endpos[1] = start[1];
trace->endpos[2] = start[2];
trace->fraction = 0;
}
return trace->fraction==1;
}
#else
qboolean Doom_RecursiveHullCheck (hull_t *hull, int num, float p1f, float p2f, vec3_t start, vec3_t p2, trace_t *trace)
{
#define TRACESTEP 16
@ -1643,8 +1901,11 @@ qboolean Doom_RecursiveHullCheck (hull_t *hull, int num, float p1f, float p2f, v
int j;
float clipfrac;
qboolean ispoint;
#define DIST_EPSILON (0.03125)
ispoint = !hull->clip_mins[0] && !hull->clip_mins[1] && !hull->clip_maxs[0] && !hull->clip_maxs[1];
// Con_Printf("%i\n", sec1);
if (start[2] < sectorm[sec1].floorheight-hull->clip_mins[2]) //whoops, started outside... ?
@ -1715,7 +1976,7 @@ qboolean Doom_RecursiveHullCheck (hull_t *hull, int num, float p1f, float p2f, v
lp = lineplanes + *linedefs;
if (1)
if (!ispoint)
{ //figure out how far to move the plane out by
for (j=0 ; j<2 ; j++)
{
@ -2014,6 +2275,7 @@ qboolean Doom_RecursiveHullCheck (hull_t *hull, int num, float p1f, float p2f, v
//Con_Printf("total = %f\n", trace->fraction);
return trace->fraction==1;
}
#endif
void Doom_SetHullFuncs(hull_t *hull)
{

3
engine/gl/shader.h
View file

@ -198,7 +198,8 @@ typedef struct shader_s {
SHADER_ENTITY_MERGABLE = 1 << 9,
SHADER_VIDEOMAP = 1 << 10,
SHADER_DEPTHWRITE = 1 << 11,
SHADER_AGEN_PORTAL = 1 << 12
SHADER_AGEN_PORTAL = 1 << 12,
SHADER_BLEND = 1 << 13 //blend or alphatest (not 100% opaque).
} flags;
shaderpass_t passes[SHADER_PASS_MAX];