tenebrae2/gl_bumpgeneric.c
cholleme 75112cbf74 Removed old driver memory support
Added Vbo support (only on ARB2)
2004-02-08 09:49:53 +00:00

1139 lines
28 KiB
C

/*
Copyright (C) 2001-2002 Charles Hollemeersch
Copyright (C) 2003 Jarno Paananen
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
PENTA: the whole file is freakin penta...
Generic bumpmapping with some Geforce optimizations
*/
#include "quakedef.h"
static cvar_t sh_fakespecular = {"sh_fakespecular","1", true};
//#define GENDEBUG
#if defined(GENDEBUG) && defined(_WIN32)
static void generic_checkerror()
{
GLuint error = glGetError();
if ( error != GL_NO_ERROR )
{
_asm { int 3 };
}
}
#else
#define generic_checkerror() do { } while(0)
#endif
/************************
Generic "fragment programs"
************************/
/**
Light attenuation shader
*/
void GL_EnableGenericAttShader() {
GL_Bind(glow_texture_object);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_EnableMultitexture();
GL_Bind(glow_texture_object);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
}
void GL_DisableGenericAttShader() {
GL_DisableMultitexture();
}
/**
Color map modulation shader
primary color = light color
tu0 = light filter cube map
tu1 = material color map
*/
void GL_EnableGenericColorShader (qboolean specular) {
GL_SelectTexture(GL_TEXTURE0_ARB);
glDisable(GL_TEXTURE_2D);
glEnable(GL_TEXTURE_CUBE_MAP_ARB);
GL_SelectTexture(GL_TEXTURE0_ARB);
glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, currentshadowlight->filtercube);
glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS_ARB);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_TEXTURE);
glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);
if (!specular) {
GL_EnableMultitexture();
glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS_ARB);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_TEXTURE);
glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);
} else {
GL_EnableMultitexture();
glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS_ARB);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_TEXTURE);
glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_ALPHA);
glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);
}
}
void GL_DisableGenericColorShader (qboolean specular) {
if (!specular) {
GL_DisableMultitexture();
} else {
glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR);
GL_DisableMultitexture();
}
glEnable(GL_TEXTURE_2D);
glDisable(GL_TEXTURE_CUBE_MAP_ARB);
}
/**
Diffuse dot product shader
texture coords for unit 0: Tangent space light vector
texture coords for unit 1: Normal map texture coords
*/
void GL_EnableGenericDiffuseShader () {
GL_SelectTexture(GL_TEXTURE0_ARB);
glDisable(GL_TEXTURE_2D);
glEnable(GL_TEXTURE_CUBE_MAP_ARB);
glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, normcube_texture_object);
glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_TEXTURE);
glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE);
GL_EnableMultitexture();
glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS_ARB);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_TEXTURE);
glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_DOT3_RGBA_ARB);
}
void GL_DisableGenericDiffuseShader () {
GL_DisableMultitexture();
glEnable(GL_TEXTURE_2D);
glDisable(GL_TEXTURE_CUBE_MAP_ARB);
}
/************************
Shader utility routines
*************************/
void Generic_SetupTcMod(tcmod_t *tc)
{
switch (tc->type)
{
case TCMOD_ROTATE:
glTranslatef(0.5,0.5,0.0);
glRotatef(realtime * tc->params[0],0,0,1);
glTranslatef(-0.5, -0.5, 0.0);
break;
case TCMOD_SCROLL:
glTranslatef(realtime * tc->params[0], realtime * tc->params[1], 0.0);
break;
case TCMOD_SCALE:
glScalef(tc->params[0],tc->params[1],1.0);
break;
case TCMOD_STRETCH:
//PENTA: fixme
glScalef(1.0, 1.0, 1.0);
break;
}
}
void Generic_SetupSimpleStage(stage_t *s)
{
tcmod_t *tc;
int i;
if (s->type != STAGE_SIMPLE)
{
Con_Printf("Non simple stage, in simple stage list");
return;
}
glMatrixMode(GL_TEXTURE);
glPushMatrix();
for (i=0; i<s->numtcmods; i++)
{
Generic_SetupTcMod(&s->tcmods[i]);
}
if (s->src_blend > -1)
{
glBlendFunc(s->src_blend, s->dst_blend);
glEnable(GL_BLEND);
}
if (s->alphatresh > 0)
{
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GREATER, s->alphatresh);
}
if ((s->numtextures > 0) && (s->texture[0]))
GL_BindAdvanced(s->texture[0]);
}
/************************
Generic triangle list routines
*************************/
void FormatError(); // In gl_bumpgf.c
/*
void Generic_drawTriangleListBump (const vertexdef_t *verts, int *indecies,
int numIndecies, shader_t *shader,
const transform_t *tr, const lightobject_t *lo)
{
return;
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, verts->vertexstride, verts->vertices);
GL_AddColor();
glColor3fv(&currentshadowlight->color[0]);
Generic_EnableBumpShader(tr,currentshadowlight->origin,true, shader);
//bind the correct textures
GL_SelectTexture(GL_TEXTURE0_ARB);
qglClientActiveTextureARB(GL_TEXTURE0_ARB);
if (shader->numbumpstages > 0)
GL_BindAdvanced(shader->bumpstages[0].texture[0]);
if (!verts->texcoords)
FormatError();
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, verts->texcoordstride, verts->texcoords);
GL_SelectTexture(GL_TEXTURE1_ARB);
qglClientActiveTextureARB(GL_TEXTURE1_ARB);
if (shader->numcolorstages > 0)
GL_BindAdvanced(shader->colorstages[0].texture[0]);
if (!verts->tangents)
FormatError();
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(3, GL_FLOAT, verts->tangentstride, verts->tangents);
if (!verts->binormals)
FormatError();
GL_SelectTexture(GL_TEXTURE2_ARB);
qglClientActiveTextureARB(GL_TEXTURE2_ARB);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(3, GL_FLOAT, verts->binormalstride, verts->binormals);
if (!verts->normals)
FormatError();
GL_SelectTexture(GL_TEXTURE3_ARB);
qglClientActiveTextureARB(GL_TEXTURE3_ARB);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(3, GL_FLOAT, verts->normalstride, verts->normals);
glDrawElements(GL_TRIANGLES, numIndecies, GL_UNSIGNED_INT, indecies);
qglClientActiveTextureARB(GL_TEXTURE3_ARB);
glDisableClientState(GL_VERTEX_ARRAY);
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);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
Generic_DisableBumpShader(shader);
}
*/
static const lightobject_t *currentLo;
void VertWV(float *pos, float *tex, float *lm, float *tg, float *bn, float*nr) {
glTexCoord3fv(pos);
qglMultiTexCoord2fvARB(GL_TEXTURE1_ARB, tex);
glVertex3fv(pos);
}
void VertTex(float *pos, float *tex, float *lm, float *tg, float *bn, float*nr) {
glTexCoord2fv(tex);
glVertex3fv(pos);
}
void VertFakeSpecular(float *pos, float *tex, float *lm, float *tg, float *bn, float*nr) {
glNormal3fv(nr);
glTexCoord3fv(pos);
qglMultiTexCoord2fvARB(GL_TEXTURE1_ARB, tex);
glVertex3fv(pos);
}
void VertAtt(float *pos, float *tex, float *lm, float *tg, float *bn, float*nr) {
vec3_t nearToVert;
float tu, tv, tw;
VectorSubtract (pos, currentLo->objectorigin, nearToVert);
tu = (nearToVert[0]/currentshadowlight->radiusv[0])*0.5+0.5;
tv = (nearToVert[1]/currentshadowlight->radiusv[1])*0.5+0.5;
tw = (nearToVert[2]/currentshadowlight->radiusv[2])*0.5+0.5;
glTexCoord2f(tu, tv);
qglMultiTexCoord2fARB(GL_TEXTURE1_ARB, tw, 0.5);
glVertex3fv(pos);
}
void VertDiffuse(float *pos, float *tex, float *lm, float *tg, float *bn, float*nr) {
vec3_t lightDir, tsLightDir;
VectorSubtract(currentLo->objectorigin, pos, lightDir);
tsLightDir[0] = DotProduct(lightDir,tg);
tsLightDir[1] = -DotProduct(lightDir,bn);
tsLightDir[2] = DotProduct(lightDir,nr);
qglMultiTexCoord3fvARB(GL_TEXTURE0_ARB, &tsLightDir[0]);
qglMultiTexCoord2fvARB(GL_TEXTURE1_ARB, tex);
glVertex3fv(pos);
}
void Generic_DrawTriWithFunc(const vertexdef_t *verts, int *indecies,
int numIndecies, void (*VertFunc) (float *, float *, float *, float *, float *, float*))
{
int i;
vertexdef_t v = *verts;
if (!v.vertexstride) v.vertexstride = 12;
if (!v.texcoordstride) v.texcoordstride = 8;
if (!v.lightmapstride) v.lightmapstride = 8;
if (!v.tangentstride) v.lightmapstride = 12;
if (!v.binormalstride) v.binormalstride = 12;
if (!v.normalstride) v.normalstride = 12;
glBegin(GL_TRIANGLES);
for (i=0; i<numIndecies; i++) {
int ind = indecies[i];
VertFunc( (float *)((byte *)v.vertices + ind*v.vertexstride),
(float *)((byte *)v.texcoords + ind*v.texcoordstride),
(float *)((byte *)v.lightmapcoords + ind*v.lightmapstride),
(float *)((byte *)v.tangents + ind*v.tangentstride),
(float *)((byte *)v.binormals + ind*v.binormalstride),
(float *)((byte *)v.normals + ind*v.normalstride)
);
}
glEnd();
}
void Generic_drawTriangleListBump (const vertexdef_t *verts, int *indecies,
int numIndecies, shader_t *shader,
const transform_t *tr, const lightobject_t *lo)
{
glDepthMask (0);
currentLo = lo;
//attenuate with projected 2D attenuation map
GL_DrawAlpha();
GL_EnableGenericAttShader();
Generic_DrawTriWithFunc(verts, indecies, numIndecies, VertAtt);
GL_DisableGenericAttShader();
// modulate diffuse bump (n dot l) to alpha
GL_ModulateAlphaDrawAlpha();
GL_EnableGenericDiffuseShader();
if (shader->numbumpstages > 0) {
GL_BindAdvanced(shader->bumpstages[0].texture[0]);
}
Generic_DrawTriWithFunc(verts, indecies, numIndecies, VertDiffuse);
GL_DisableGenericDiffuseShader ();
//Do fake specular
if (sh_fakespecular.value) {
float black[4] = {0.0, 0.0, 0.0, 1.0};
float white[4] = {1.0, 1.0, 1.0, 1.0};
float pos[4];
GL_ModulateAlphaDrawColor();
glColorMask(true, true, true, false);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
VectorCopy(lo->objectorigin, pos);
pos[3] = 1.0;
glLightfv(GL_LIGHT0, GL_POSITION, pos);
glLightfv(GL_LIGHT0, GL_DIFFUSE, black);
glLightfv(GL_LIGHT0, GL_AMBIENT, black);
glLightfv(GL_LIGHT0, GL_SPECULAR, &currentshadowlight->color[0]);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, white);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 16);
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
glEnable(GL_COLOR_MATERIAL);
glColor4fv(white);
GL_EnableGenericColorShader (true);
if (shader->numbumpstages > 0) {
GL_BindAdvanced(shader->bumpstages[0].texture[0]);
}
Generic_DrawTriWithFunc(verts, indecies, numIndecies, VertFakeSpecular);
GL_DisableGenericColorShader (true);
glDisable(GL_LIGHTING);
}
// Then modulate Color map and light filter with alpha and add to color
GL_ModulateAlphaDrawColor();
glColor3fv(&currentshadowlight->color[0]);
if ( currentshadowlight->filtercube )
{
glMatrixMode(GL_TEXTURE);
glPushMatrix();
GL_SetupCubeMapMatrix(tr);
GL_EnableGenericColorShader (false);
if (shader->numcolorstages > 0) {
GL_BindAdvanced(shader->colorstages[0].texture[0]);
}
Generic_DrawTriWithFunc(verts, indecies, numIndecies, VertWV);
GL_DisableGenericColorShader (false);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
}
else
{
// Just alpha * light color
GL_DisableMultitexture();
if (shader->numcolorstages > 0) {
GL_BindAdvanced(shader->colorstages[0].texture[0]);
}
glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
Generic_DrawTriWithFunc(verts, indecies, numIndecies, VertTex);
}
GL_DrawColor();
glColor3f (1,1,1);
glDisable (GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDepthMask (1);
}
void Generic_drawTriangleListBase (vertexdef_t *verts, int *indecies,
int numIndecies, shader_t *shader,
int lightmapIndex)
{
int i;
glVertexPointer(3, GL_FLOAT, verts->vertexstride, verts->vertices);
glEnableClientState(GL_VERTEX_ARRAY);
GL_SelectTexture(GL_TEXTURE0_ARB);
qglClientActiveTextureARB(GL_TEXTURE0_ARB);
glTexCoordPointer(2, GL_FLOAT, verts->texcoordstride, verts->texcoords);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
if (!shader->cull)
{
glDisable(GL_CULL_FACE);
}
for ( i = 0; i < shader->numstages; i++)
{
Generic_SetupSimpleStage(&shader->stages[i]);
glDrawElements(GL_TRIANGLES,numIndecies,GL_UNSIGNED_INT,indecies);
glPopMatrix();
}
glMatrixMode(GL_MODELVIEW);
if (verts->lightmapcoords && (lightmapIndex >= 0) && (shader->flags & SURF_PPLIGHT))
{
if (shader->numstages && shader->numcolorstages)
{
if (shader->colorstages[0].src_blend >= 0)
{
glEnable(GL_BLEND);
glBlendFunc(shader->colorstages[0].src_blend, shader->colorstages[0].dst_blend);
}
else
{
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
}
}
else
{
glDisable(GL_BLEND);
}
if (shader->numcolorstages)
{
if (shader->colorstages[0].numtextures)
GL_BindAdvanced(shader->colorstages[0].texture[0]);
if (shader->colorstages[0].alphatresh > 0)
{
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GEQUAL, shader->colorstages[0].alphatresh);
}
}
GL_SelectTexture(GL_TEXTURE0_ARB);
qglClientActiveTextureARB(GL_TEXTURE0_ARB);
glTexCoordPointer(2, GL_FLOAT, verts->texcoordstride, verts->texcoords);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_SelectTexture(GL_TEXTURE1_ARB);
glEnable(GL_TEXTURE_2D);
GL_Bind(lightmap_textures+lightmapIndex);
qglClientActiveTextureARB(GL_TEXTURE1_ARB);
glTexCoordPointer(2, GL_FLOAT, verts->lightmapstride, verts->lightmapcoords);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glDrawElements(GL_TRIANGLES,numIndecies,GL_UNSIGNED_INT,indecies);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisable(GL_TEXTURE_2D);
GL_SelectTexture(GL_TEXTURE0_ARB);
}
else
{
if (verts->colors && (shader->flags & SURF_PPLIGHT))
{
glColorPointer(3, GL_UNSIGNED_BYTE, verts->colorstride, verts->colors);
glEnableClientState(GL_COLOR_ARRAY);
glShadeModel(GL_SMOOTH);
if (shader->numstages && shader->numcolorstages)
{
if (shader->colorstages[0].src_blend >= 0)
{
glEnable(GL_BLEND);
glBlendFunc(shader->colorstages[0].src_blend, shader->colorstages[0].dst_blend);
}
else
{
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
}
}
else
{
glDisable(GL_BLEND);
}
if (shader->numcolorstages)
{
if (shader->colorstages[0].numtextures)
GL_BindAdvanced(shader->colorstages[0].texture[0]);
if (shader->colorstages[0].alphatresh > 0)
{
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GEQUAL, shader->colorstages[0].alphatresh);
}
}
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glDrawElements(GL_TRIANGLES,numIndecies,GL_UNSIGNED_INT,indecies);
glDisableClientState(GL_COLOR_ARRAY);
}
else
{
if (shader->flags & SURF_PPLIGHT)
{
glColor3f(0,0,0);
glDisable(GL_TEXTURE_2D);
glDrawElements(GL_TRIANGLES,numIndecies,GL_UNSIGNED_INT,indecies);
glEnable(GL_TEXTURE_2D);
}
}
}
if (!shader->cull)
{
glEnable(GL_CULL_FACE);
//Con_Printf("Cullstuff %s\n",shader->name);
}
qglClientActiveTextureARB(GL_TEXTURE0_ARB);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
glDisable(GL_BLEND);
glDisable(GL_ALPHA_TEST);
}
/*************************
Generic world surfaces routines
**************************/
void Generic_sendSurfacesBase(msurface_t **surfs, int numSurfaces,
qboolean bindLightmap)
{
int i, j;
glpoly_t *p;
msurface_t *surf;
float *v;
for ( i = 0; i < numSurfaces; i++)
{
surf = surfs[i];
if (surf->visframe != r_framecount)
continue;
p = surf->polys;
if (bindLightmap)
{
if (surf->lightmaptexturenum < 0)
continue;
GL_Bind(lightmap_textures+surf->lightmaptexturenum);
}
glBegin(GL_TRIANGLES);
for (j=0; j<surf->polys->numindecies; j++) {
v = (float *)(&cl.worldmodel->userVerts[surf->polys->indecies[j]]);
qglMultiTexCoord2fvARB(GL_TEXTURE0_ARB, &v[3]);
qglMultiTexCoord3fvARB(GL_TEXTURE1_ARB, &v[5]);
glVertex3fv(&v[0]);
}
glEnd();
}
}
void Generic_drawSurfaceListBase (vertexdef_t* verts, msurface_t** surfs,
int numSurfaces, shader_t* shader)
{
int i;
GL_SelectTexture(GL_TEXTURE0_ARB);
glColor3ub(255,255,255);
if (!shader->cull)
{
glDisable(GL_CULL_FACE);
//Con_Printf("Cullstuff %s\n",shader->name);
}
for (i = 0; i < shader->numstages; i++)
{
Generic_SetupSimpleStage(&shader->stages[i]);
Generic_sendSurfacesBase(surfs, numSurfaces, false);
glPopMatrix();
}
if (verts->lightmapcoords && (shader->flags & SURF_PPLIGHT))
{
GL_SelectTexture(GL_TEXTURE1_ARB);
// Regular lightmapping
if (shader->numstages && shader->numcolorstages)
{
if (shader->colorstages[0].src_blend >= 0)
{
glEnable(GL_BLEND);
glBlendFunc(shader->colorstages[0].src_blend,
shader->colorstages[0].dst_blend);
}
else
{
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
}
}
else
{
glDisable(GL_BLEND);
}
GL_SelectTexture(GL_TEXTURE0_ARB);
if (shader->numcolorstages)
{
if (shader->colorstages[0].numtextures)
GL_BindAdvanced(shader->colorstages[0].texture[0]);
if (shader->colorstages[0].alphatresh > 0)
{
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GEQUAL, shader->colorstages[0].alphatresh);
}
}
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
GL_EnableMultitexture();
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glColor3f(sh_lightmapbright.value, sh_lightmapbright.value,
sh_lightmapbright.value);
Generic_sendSurfacesBase(surfs, numSurfaces, true);
GL_DisableMultitexture();
GL_SelectTexture(GL_TEXTURE0_ARB);
}
if (!shader->cull)
{
glEnable(GL_CULL_FACE);
}
glDisable(GL_ALPHA_TEST);
glMatrixMode(GL_MODELVIEW);
glDisable(GL_BLEND);
}
void Generic_sendSurfacesDiffuse(msurface_t **surfs, int numSurfaces)
{
int i,j;
glpoly_t *p;
msurface_t *surf;
shader_t *shader, *lastshader;
float *v;
qboolean cull;
vec3_t lightDir;
float tsLightDir[3];
cull = true;
lastshader = NULL;
for (i=0; i<numSurfaces; i++)
{
surf = surfs[i];
if (surf->visframe != r_framecount)
continue;
if (!(surf->flags & SURF_PPLIGHT))
continue;
shader = surf->shader->shader;
if (shader->numbumpstages > 0)
GL_BindAdvanced(shader->bumpstages[0].texture[0]);
else
continue;
p = surf->polys;
//less state changes
if (lastshader != shader)
{
if (!shader->cull)
{
glDisable(GL_CULL_FACE);
cull = false;
}
else
{
if (!cull)
glEnable(GL_CULL_FACE);
cull = true;
}
lastshader = shader;
}
glBegin(GL_TRIANGLES);
for (j=0; j<surf->polys->numindecies; j++) {
v = (float *)(&cl.worldmodel->userVerts[surf->polys->indecies[j]]);
VectorSubtract(currentshadowlight->origin, (&v[0]), lightDir);
if (surf->flags & SURF_PLANEBACK) {
tsLightDir[2] = -DotProduct(lightDir,surf->plane->normal);
} else {
tsLightDir[2] = DotProduct(lightDir,surf->plane->normal);
}
tsLightDir[1] = -DotProduct(lightDir,surf->binormal);
tsLightDir[0] = DotProduct(lightDir,surf->tangent);
qglMultiTexCoord3fvARB(GL_TEXTURE0_ARB, &tsLightDir[0]);
qglMultiTexCoord2fvARB(GL_TEXTURE1_ARB, &v[3]);
glVertex3fv(&v[0]);
}
glEnd();
}
if (!cull)
glEnable(GL_CULL_FACE);
}
void Generic_sendSurfacesATT(msurface_t **surfs, int numSurfaces)
{
int i, j;
glpoly_t *p;
msurface_t *surf;
shader_t *shader, *lastshader;
qboolean cull;
float tu, tv, tw;
vec3_t nearToVert;
float *v;
cull = true;
lastshader = NULL;
for ( i = 0; i < numSurfaces; i++)
{
surf = surfs[i];
if (surf->visframe != r_framecount)
continue;
if (!(surf->flags & SURF_PPLIGHT))
continue;
shader = surf->shader->shader;
if (shader->numbumpstages == 0)
continue;
p = surf->polys;
if (lastshader != shader)
{
if (!shader->cull)
{
glDisable(GL_CULL_FACE);
cull = false;
}
else
{
if (!cull)
glEnable(GL_CULL_FACE);
cull = true;
}
lastshader = shader;
}
glColor4f(1, 1, 1, 1);
glBegin(GL_TRIANGLES);
for (j=0; j<surf->polys->numindecies; j++) {
v = (float *)(&cl.worldmodel->userVerts[surf->polys->indecies[j]]);
VectorSubtract (v, currentshadowlight->origin, nearToVert);
tu = (nearToVert[0]/currentshadowlight->radiusv[0])*0.5+0.5;
tv = (nearToVert[1]/currentshadowlight->radiusv[1])*0.5+0.5;
tw = (nearToVert[2]/currentshadowlight->radiusv[2])*0.5+0.5;
glTexCoord2f(tu, tv);
qglMultiTexCoord2fARB(GL_TEXTURE1_ARB, tw, 0.5);
glVertex3fv(&v[0]);
}
glEnd();
}
if (!cull)
glEnable(GL_CULL_FACE);
}
void Generic_sendSurfacesWV(msurface_t **surfs, int numSurfaces, qboolean specular)
{
int i, j;
glpoly_t *p;
msurface_t *surf;
shader_t *shader, *lastshader;
qboolean cull;
float *v;
cull = true;
lastshader = NULL;
for ( i = 0; i < numSurfaces; i++)
{
surf = surfs[i];
if (surf->visframe != r_framecount)
continue;
if (!(surf->flags & SURF_PPLIGHT))
continue;
shader = surf->shader->shader;
if (shader->numbumpstages == 0)
continue;
p = surf->polys;
if (lastshader != shader)
{
if (!shader->cull)
{
glDisable(GL_CULL_FACE);
cull = false;
}
else
{
if (!cull)
glEnable(GL_CULL_FACE);
cull = true;
}
lastshader = shader;
GL_SelectTexture(GL_TEXTURE1_ARB);
if (!specular) {
if (shader->numcolorstages > 0)
GL_BindAdvanced(shader->colorstages[0].texture[0]);
} else {
if (shader->numbumpstages > 0)
GL_BindAdvanced(shader->bumpstages[0].texture[0]);
}
}
glNormal3fv(surf->plane->normal);
glBegin(GL_TRIANGLES);
for (j=0; j<surf->polys->numindecies; j++) {
v = (float *)(&cl.worldmodel->userVerts[surf->polys->indecies[j]]);
glTexCoord3fv(&v[0]);
qglMultiTexCoord2fARB(GL_TEXTURE1_ARB, v[3], v[4]);
glVertex3fv(&v[0]);
}
glEnd();
}
if (!cull)
glEnable(GL_CULL_FACE);
}
void Generic_sendSurfacesTex(msurface_t **surfs, int numSurfaces)
{
int i, j;
glpoly_t *p;
msurface_t *surf;
shader_t *shader, *lastshader;
qboolean cull;
float *v;
cull = true;
lastshader = NULL;
for ( i = 0; i < numSurfaces; i++)
{
surf = surfs[i];
if (surf->visframe != r_framecount)
continue;
if (!(surf->flags & SURF_PPLIGHT))
continue;
shader = surf->shader->shader;
if (shader->numbumpstages == 0)
continue;
p = surf->polys;
if (lastshader != shader)
{
if (!shader->cull)
{
glDisable(GL_CULL_FACE);
cull = false;
}
else
{
if (!cull)
glEnable(GL_CULL_FACE);
cull = true;
}
lastshader = shader;
GL_SelectTexture(GL_TEXTURE0_ARB);
if (shader->numcolorstages > 0)
GL_BindAdvanced(shader->colorstages[0].texture[0]);
}
/*
glBegin(GL_TRIANGLE_FAN);
v = (float *)(&globalVertexTable[surf->polys->firstvertex]);
for (j = 0; j < p->numverts; j++, v+= VERTEXSIZE)
{
glTexCoord2fv(&v[3]);
glVertex3fv(&v[0]);
}
glEnd();
*/
glBegin(GL_TRIANGLES);
for (j=0; j<surf->polys->numindecies; j++) {
v = (float *)(&cl.worldmodel->userVerts[surf->polys->indecies[j]]);
glTexCoord2fv(&v[3]);
glVertex3fv(&v[0]);
}
glEnd();
}
if (!cull)
glEnable(GL_CULL_FACE);
}
void Generic_drawSurfaceListBump (vertexdef_t *verts, msurface_t **surfs,
int numSurfaces,const transform_t *tr, const lightobject_t *lo)
{
glDepthMask (0);
//attenuate with projected 2D attenuation map
GL_DrawAlpha();
GL_EnableGenericAttShader();
Generic_sendSurfacesATT(surfs, numSurfaces);
GL_DisableGenericAttShader();
// modulate diffuse bump (n dot l) to alpha
GL_ModulateAlphaDrawAlpha();
GL_EnableGenericDiffuseShader();
Generic_sendSurfacesDiffuse(surfs, numSurfaces);
GL_DisableGenericDiffuseShader ();
//Do fake specular
if (sh_fakespecular.value) {
//This is so fake...
//-it gets attenuated with the diffuse dot product and the light attenuation
//-The specular gets caclulated per vertex
//-But it remotely looks like specular at the cost of one extra pass
float black[4] = {0.0, 0.0, 0.0, 1.0};
float white[4] = {1.0, 1.0, 1.0, 1.0};
float pos[4];
GL_ModulateAlphaDrawColor();
glColorMask(true, true, true, false);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
VectorCopy(lo->objectorigin, pos);
pos[3] = 1.0;
glLightfv(GL_LIGHT0, GL_POSITION, pos);
glLightfv(GL_LIGHT0, GL_DIFFUSE, black);
glLightfv(GL_LIGHT0, GL_AMBIENT, black);
glLightfv(GL_LIGHT0, GL_SPECULAR, &currentshadowlight->color[0]);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, white);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 16);
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
glEnable(GL_COLOR_MATERIAL);
glColor4fv(white);
GL_EnableGenericColorShader (true);
Generic_sendSurfacesWV(surfs, numSurfaces, true);
GL_DisableGenericColorShader (true);
glDisable(GL_LIGHTING);
}
// Then modulate Color map and light filter with alpha and add to color
GL_ModulateAlphaDrawColor();
glColor3fv(&currentshadowlight->baseColor[0]);
if ( currentshadowlight->filtercube )
{
glMatrixMode(GL_TEXTURE);
glPushMatrix();
GL_SetupCubeMapMatrix(tr);
GL_EnableGenericColorShader (false);
Generic_sendSurfacesWV(surfs, numSurfaces, false);
GL_DisableGenericColorShader (false);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
}
else
{
// Just alpha * light color
GL_SelectTexture(GL_TEXTURE1_ARB);
glDisable(GL_TEXTURE_2D);
GL_SelectTexture(GL_TEXTURE0_ARB);
glEnable(GL_TEXTURE_2D);
glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS_ARB);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_TEXTURE);
glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);
//glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
Generic_sendSurfacesTex(surfs, numSurfaces);
}
GL_DrawColor();
glColor3f (1,1,1);
glDisable (GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDepthMask (1);
}
void Generic_freeDriver(void)
{
//nothing here...
}
void BUMP_InitGeneric(void)
{
if ( gl_cardtype != GENERIC && gl_cardtype != GEFORCE )
return;
Cvar_RegisterVariable(&sh_fakespecular);
//bind the correct stuff to the bump mapping driver
gl_bumpdriver.drawSurfaceListBase = Generic_drawSurfaceListBase;
gl_bumpdriver.drawSurfaceListBump = Generic_drawSurfaceListBump;
gl_bumpdriver.drawTriangleListBase = Generic_drawTriangleListBase;
gl_bumpdriver.drawTriangleListBump = Generic_drawTriangleListBump;
gl_bumpdriver.freeDriver = Generic_freeDriver;
}