rq3/reaction
0
0
Fork 0
mirror of https://github.com/ReactionQuake3/reaction.git synced 2025-02-02 14:42:41 +00:00
Code Issues Projects Releases Packages Wiki Activity

Appying the differences between v11 and v12 renderers

Browse source
This commit is contained in:
Richard Allen 2011-03-31 18:11:49 +00:00
parent e8c2e6ba5b
commit 23fb28d4c9
10 changed files with 1198 additions and 1277 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
reaction/code/renderer/tr_backend.c
View file

@ -914,7 +914,6 @@ Used for cinematics.
void RE_StretchRaw (int x, int y, int w, int h, int cols, int rows, const byte *data, int client, qboolean dirty) { void RE_StretchRaw (int x, int y, int w, int h, int cols, int rows, const byte *data, int client, qboolean dirty) {
int i, j; int i, j;
int start, end; int start, end;
matrix_t matrix;
if ( !tr.registered ) { if ( !tr.registered ) {
return; return;
@ -1022,22 +1021,13 @@ void RE_StretchRaw (int x, int y, int w, int h, int cols, int rows, const byte *
if (glRefConfig.glsl && r_arb_shader_objects->integer) if (glRefConfig.glsl && r_arb_shader_objects->integer)
{ {
shaderProgram_t *sp = &tr.genericShader[0]; shaderProgram_t *sp = &tr.textureOnlyShader;
GLSL_VertexAttribsState(ATTR_POSITION | ATTR_TEXCOORD); GLSL_VertexAttribsState(ATTR_POSITION | ATTR_TEXCOORD);
GLSL_BindProgram(sp); GLSL_BindProgram(sp);
GLSL_SetUniform_ModelViewProjectionMatrix(sp, glState.modelviewProjection); GLSL_SetUniformMatrix16(sp, TEXTUREONLY_UNIFORM_MODELVIEWPROJECTIONMATRIX, glState.modelviewProjection);
GLSL_SetUniform_FogAdjustColors(sp, 0);
GLSL_SetUniform_DeformGen(sp, DGEN_NONE);
GLSL_SetUniform_TCGen0(sp, TCGEN_TEXTURE);
Matrix16Identity(matrix);
GLSL_SetUniform_Texture0Matrix(sp, matrix);
GLSL_SetUniform_Texture1Env(sp, 0);
GLSL_SetUniform_ColorGen(sp, CGEN_IDENTITY);
GLSL_SetUniform_AlphaGen(sp, AGEN_IDENTITY);
} }
else else
{ {

9
reaction/code/renderer/tr_bsp.c
View file

@ -40,7 +40,7 @@ int c_subdivisions;
int c_gridVerts; int c_gridVerts;
//=============================================================================== //===============================================================================
/* #if 0
static void HSVtoRGB( float h, float s, float v, float rgb[3] ) static void HSVtoRGB( float h, float s, float v, float rgb[3] )
{ {
int i; int i;
@ -742,7 +742,9 @@ static void ParseTriSurf( dsurface_t *ds, drawVert_t *verts, msurface_t *surf, i
cv->numTriangles -= badTriangles; cv->numTriangles -= badTriangles;
} }
} }
#endif
#if 0
/* /*
=============== ===============
ParseFlare ParseFlare
@ -773,6 +775,7 @@ static void ParseFlare( dsurface_t *ds, drawVert_t *verts, msurface_t *surf, int
flare->normal[i] = LittleFloat( ds->lightmapVecs[2][i] ); flare->normal[i] = LittleFloat( ds->lightmapVecs[2][i] );
} }
} }
#endif
/* /*
@ -2795,6 +2798,10 @@ void R_MergeLeafSurfaces(void)
default: default:
break; break;
// never happens, but silences a compile warning
default:
break;
} }
} }

2
reaction/code/renderer/tr_cmds.c
View file

@ -73,6 +73,8 @@ void R_PerformanceCounters( void ) {
{ {
ri.Printf( PRINT_ALL, "VBO draws: static %i dynamic %i\nMultidraws: %i merged %i\n", ri.Printf( PRINT_ALL, "VBO draws: static %i dynamic %i\nMultidraws: %i merged %i\n",
backEnd.pc.c_staticVboDraws, backEnd.pc.c_dynamicVboDraws, backEnd.pc.c_multidraws, backEnd.pc.c_multidrawsMerged ); backEnd.pc.c_staticVboDraws, backEnd.pc.c_dynamicVboDraws, backEnd.pc.c_multidraws, backEnd.pc.c_multidrawsMerged );
ri.Printf( PRINT_ALL, "GLSL binds: %i draws: gen %i lightmap %i fog %i dlight %i\n",
backEnd.pc.c_glslShaderBinds, backEnd.pc.c_genericDraws, backEnd.pc.c_lightmappedDraws, backEnd.pc.c_fogDraws, backEnd.pc.c_dlightDraws);
} }
Com_Memset( &tr.pc, 0, sizeof( tr.pc ) ); Com_Memset( &tr.pc, 0, sizeof( tr.pc ) );

8
reaction/code/renderer/tr_extramath.c
View file

@ -83,10 +83,10 @@ void Matrix16Transform( const matrix_t in1, const vec4_t in2, vec4_t out )
qboolean Matrix16Compare( const matrix_t a, const matrix_t b ) qboolean Matrix16Compare( const matrix_t a, const matrix_t b )
{ {
return (a[ 0] == b[ 0] && a[ 4] == b[ 4] && a[ 8] == b[ 8] && a[12] == b[12] && return !(a[ 0] != b[ 0] || a[ 4] != b[ 4] || a[ 8] != b[ 8] || a[12] != b[12] ||
a[ 1] == b[ 1] && a[ 5] == b[ 5] && a[ 9] == b[ 9] && a[13] == b[13] && a[ 1] != b[ 1] || a[ 5] != b[ 5] || a[ 9] != b[ 9] || a[13] != b[13] ||
a[ 2] == b[ 2] && a[ 6] == b[ 6] && a[10] == b[10] && a[14] == b[14] && a[ 2] != b[ 2] || a[ 6] != b[ 6] || a[10] != b[10] || a[14] != b[14] ||
a[ 3] == b[ 3] && a[ 7] == b[ 7] && a[11] == b[11] && a[15] == b[15]); a[ 3] != b[ 3] || a[ 7] != b[ 7] || a[11] != b[11] || a[15] != b[15]);
} }
void Matrix16Dump( const matrix_t in ) void Matrix16Dump( const matrix_t in )

1035
reaction/code/renderer/tr_glsl.c
View file

File diff suppressed because it is too large Load diff

945
reaction/code/renderer/tr_local.h
View file

@ -677,6 +677,15 @@ enum
GLSLDEF_COUNT = 0x0010, GLSLDEF_COUNT = 0x0010,
}; };
enum
{
GLSL_INT,
GLSL_FLOAT,
GLSL_VEC2,
GLSL_VEC3,
GLSL_VEC4,
GLSL_MAT16
};
// Tr3B - shaderProgram_t represents a pair of one // Tr3B - shaderProgram_t represents a pair of one
// GLSL vertex and one GLSL fragment shader // GLSL vertex and one GLSL fragment shader
@ -690,841 +699,101 @@ typedef struct shaderProgram_s
uint32_t attribs; // vertex array attributes uint32_t attribs; // vertex array attributes
// uniform parameters // uniform parameters
GLint u_Texture0Map; int numUniforms;
GLint u_Texture1Map; GLint *uniforms;
GLint u_Texture2Map; GLint *uniformTypes;
GLint u_Texture3Map; int *uniformBufferOffsets;
char *uniformBuffer;
GLint u_PortalRange;
float t_PortalRange;
GLint u_FogAdjustColors;
int t_FogAdjustColors;
GLint u_FogDistance;
vec4_t t_FogDistance;
GLint u_FogDepth;
vec4_t t_FogDepth;
GLint u_FogEyeT;
float t_FogEyeT;
GLint u_ModelMatrix; // model -> world
matrix_t t_ModelMatrix;
GLint u_ModelViewProjectionMatrix;
matrix_t t_ModelViewProjectionMatrix;
GLint u_AlphaTest;
alphaTest_t t_AlphaTest;
GLint u_ColorGen;
colorGen_t t_ColorGen;
GLint u_AlphaGen;
alphaGen_t t_AlphaGen;
GLint u_TCGen0;
texCoordGen_t t_TCGen0;
GLint u_TCGen1;
texCoordGen_t t_TCGen1;
GLint u_TCGen0Vector0;
vec4_t t_TCGen0Vector0;
GLint u_TCGen0Vector1;
vec4_t t_TCGen0Vector1;
GLint u_TCGen1Vector0;
vec4_t t_TCGen1Vector0;
GLint u_TCGen1Vector1;
vec4_t t_TCGen1Vector1;
GLint u_DeformGen;
deformGen_t t_DeformGen;
GLint u_DeformWave;
vec4_t t_DeformWave;
GLint u_DeformBulge;
vec3_t t_DeformBulge;
GLint u_DeformSpread;
float t_DeformSpread;
GLint u_Time;
float t_Time;
GLint u_Color;
vec4_t t_Color;
GLint u_AmbientLight;
vec3_t t_AmbientLight;
GLint u_DirectedLight;
vec3_t t_DirectedLight;
GLint u_LightDir;
vec3_t t_LightDir;
GLint u_ViewOrigin;
vec4_t t_ViewOrigin;
GLint u_Texture0Matrix;
matrix_t t_Texture0Matrix;
GLint u_Texture1Matrix;
matrix_t t_Texture1Matrix;
GLint u_Texture1Env;
uint32_t t_Texture1Env;
GLint u_Texture2Matrix;
matrix_t t_Texture2Matrix;
GLint u_Texture3Matrix;
matrix_t t_Texture3Matrix;
GLint u_VertexLerp;
float t_VertexLerp;
} shaderProgram_t; } shaderProgram_t;
enum
{
LIGHTMAPPED_UNIFORM_MODELVIEWPROJECTIONMATRIX = 0,
LIGHTMAPPED_UNIFORM_TEXTURE0MATRIX,
LIGHTMAPPED_UNIFORM_TEXTURE1ENV,
LIGHTMAPPED_UNIFORM_TEXTURE0MAP,
LIGHTMAPPED_UNIFORM_TEXTURE1MAP,
LIGHTMAPPED_UNIFORM_COUNT
};
enum
{
TEXTUREONLY_UNIFORM_MODELVIEWPROJECTIONMATRIX = 0,
TEXTUREONLY_UNIFORM_TEXTURE0MAP,
TEXTUREONLY_UNIFORM_COUNT
};
enum
{
FOGPASS_UNIFORM_FOGDISTANCE = 0,
FOGPASS_UNIFORM_FOGDEPTH,
FOGPASS_UNIFORM_FOGEYET,
FOGPASS_UNIFORM_DEFORMGEN,
FOGPASS_UNIFORM_DEFORMWAVE,
FOGPASS_UNIFORM_DEFORMBULGE,
FOGPASS_UNIFORM_DEFORMSPREAD,
FOGPASS_UNIFORM_TIME,
FOGPASS_UNIFORM_COLOR,
FOGPASS_UNIFORM_MODELVIEWPROJECTIONMATRIX,
FOGPASS_UNIFORM_VERTEXLERP,
FOGPASS_UNIFORM_COUNT
};
enum
{
DLIGHT_UNIFORM_DLIGHTINFO = 0,
DLIGHT_UNIFORM_DEFORMGEN,
DLIGHT_UNIFORM_DEFORMWAVE,
DLIGHT_UNIFORM_DEFORMBULGE,
DLIGHT_UNIFORM_DEFORMSPREAD,
DLIGHT_UNIFORM_TIME,
DLIGHT_UNIFORM_COLOR,
DLIGHT_UNIFORM_MODELVIEWPROJECTIONMATRIX,
DLIGHT_UNIFORM_VERTEXLERP,
DLIGHT_UNIFORM_COUNT
};
enum
{
GENERIC_UNIFORM_TEXTURE0MAP = 0,
GENERIC_UNIFORM_TEXTURE1MAP,
GENERIC_UNIFORM_TEXTURE0MATRIX,
GENERIC_UNIFORM_TEXTURE1ENV,
GENERIC_UNIFORM_VIEWORIGIN,
GENERIC_UNIFORM_TCGEN0,
GENERIC_UNIFORM_TCGEN0VECTOR0,
GENERIC_UNIFORM_TCGEN0VECTOR1,
GENERIC_UNIFORM_DEFORMGEN,
GENERIC_UNIFORM_DEFORMWAVE,
GENERIC_UNIFORM_DEFORMBULGE,
GENERIC_UNIFORM_DEFORMSPREAD,
GENERIC_UNIFORM_COLORGEN,
GENERIC_UNIFORM_ALPHAGEN,
GENERIC_UNIFORM_COLOR,
GENERIC_UNIFORM_AMBIENTLIGHT,
GENERIC_UNIFORM_DIRECTEDLIGHT,
GENERIC_UNIFORM_LIGHTDIR,
GENERIC_UNIFORM_PORTALRANGE,
GENERIC_UNIFORM_FOGDISTANCE,
GENERIC_UNIFORM_FOGDEPTH,
GENERIC_UNIFORM_FOGEYET,
GENERIC_UNIFORM_FOGADJUSTCOLORS,
GENERIC_UNIFORM_MODELVIEWPROJECTIONMATRIX,
GENERIC_UNIFORM_TIME,
GENERIC_UNIFORM_VERTEXLERP,
GENERIC_UNIFORM_COUNT
};
// //
// Tr3B: these are fire wall functions to avoid expensive redundant glUniform* calls // Tr3B: these are fire wall functions to avoid expensive redundant glUniform* calls
#define USE_UNIFORM_FIREWALL 1 #define USE_UNIFORM_FIREWALL 1
//#define LOG_GLSL_UNIFORMS 1 //#define LOG_GLSL_UNIFORMS 1
#if defined(LOG_GLSL_UNIFORMS)
extern cvar_t *r_logFile; // number of frames to emit GL logs
void GLimp_LogComment(char *comment);
#define GLimp_LogUniformComment(...) GLimp_LogComment(__VA_ARGS__)
#else
#define GLimp_LogUniformComment(...)
#endif
// *INDENT-OFF*
static ID_INLINE void GLSL_SetUniform_Texture0Matrix(shaderProgram_t * program, const matrix_t m)
{
if (program->u_Texture0Matrix == -1)
return;
#if defined(USE_UNIFORM_FIREWALL)
if(Matrix16Compare(program->t_Texture0Matrix, m))
return;
Matrix16Copy(m, program->t_Texture0Matrix);
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniform_Texture0Matrix( program = %s, "
"matrix = \n"
"( %5.3f, %5.3f, %5.3f, %5.3f )\n"
"( %5.3f, %5.3f, %5.3f, %5.3f )\n"
"( %5.3f, %5.3f, %5.3f, %5.3f )\n"
"( %5.3f, %5.3f, %5.3f, %5.3f ) ) ---\n",
program->name,
m[0], m[4], m[8], m[12],
m[1], m[5], m[9], m[13],
m[2], m[6], m[10], m[14],
m[3], m[7], m[11], m[15]));
qglUniformMatrix4fvARB(program->u_Texture0Matrix, 1, GL_FALSE, m);
}
static ID_INLINE void GLSL_SetUniform_Texture1Matrix(shaderProgram_t * program, const matrix_t m)
{
if (program->u_Texture1Matrix == -1)
return;
#if defined(USE_UNIFORM_FIREWALL)
if(Matrix16Compare(program->t_Texture1Matrix, m))
return;
Matrix16Copy(m, program->t_Texture1Matrix);
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniform_Texture1Matrix( program = %s, "
"matrix = \n"
"( %5.3f, %5.3f, %5.3f, %5.3f )\n"
"( %5.3f, %5.3f, %5.3f, %5.3f )\n"
"( %5.3f, %5.3f, %5.3f, %5.3f )\n"
"( %5.3f, %5.3f, %5.3f, %5.3f ) ) ---\n",
program->name,
m[0], m[4], m[8], m[12],
m[1], m[5], m[9], m[13],
m[2], m[6], m[10], m[14],
m[3], m[7], m[11], m[15]));
qglUniformMatrix4fvARB(program->u_Texture1Matrix, 1, GL_FALSE, m);
}
static ID_INLINE void GLSL_SetUniform_Texture1Env(shaderProgram_t * program, uint32_t env)
{
uint32_t value;
if (program->u_Texture1Env == -1)
return;
switch ( env )
{
case GL_MODULATE:
value = 1;
break;
case GL_REPLACE:
value = 2;
break;
case GL_DECAL:
value = 3;
break;
case GL_ADD:
value = 4;
break;
default:
value = 0;
break;
}
#if defined(USE_UNIFORM_FIREWALL)
if(program->t_Texture1Env == value)
return;
program->t_Texture1Env = value;
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniform_Texture1Env( program = %s, value = %i ) ---\n", program->name, value));
qglUniform1iARB(program->u_Texture1Env, value);
}
static ID_INLINE void GLSL_SetUniform_Texture2Matrix(shaderProgram_t * program, const matrix_t m)
{
if (program->u_Texture2Matrix == -1)
return;
#if defined(USE_UNIFORM_FIREWALL)
if(Matrix16Compare(program->t_Texture2Matrix, m))
return;
Matrix16Copy(m, program->t_Texture2Matrix);
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniform_Texture2Matrix( program = %s, "
"matrix = \n"
"( %5.3f, %5.3f, %5.3f, %5.3f )\n"
"( %5.3f, %5.3f, %5.3f, %5.3f )\n"
"( %5.3f, %5.3f, %5.3f, %5.3f )\n"
"( %5.3f, %5.3f, %5.3f, %5.3f ) ) ---\n",
program->name,
m[0], m[4], m[8], m[12],
m[1], m[5], m[9], m[13],
m[2], m[6], m[10], m[14],
m[3], m[7], m[11], m[15]));
qglUniformMatrix4fvARB(program->u_Texture2Matrix, 1, GL_FALSE, m);
}
static ID_INLINE void GLSL_SetUniform_Texture3Matrix(shaderProgram_t * program, const matrix_t m)
{
if (program->u_Texture3Matrix == -1)
return;
#if defined(USE_UNIFORM_FIREWALL)
if(Matrix16Compare(program->t_Texture3Matrix, m))
return;
Matrix16Copy(m, program->t_Texture3Matrix);
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniform_Texture3Matrix( program = %s, "
"matrix = \n"
"( %5.3f, %5.3f, %5.3f, %5.3f )\n"
"( %5.3f, %5.3f, %5.3f, %5.3f )\n"
"( %5.3f, %5.3f, %5.3f, %5.3f )\n"
"( %5.3f, %5.3f, %5.3f, %5.3f ) ) ---\n",
program->name,
m[0], m[4], m[8], m[12],
m[1], m[5], m[9], m[13],
m[2], m[6], m[10], m[14],
m[3], m[7], m[11], m[15]));
qglUniformMatrix4fvARB(program->u_Texture3Matrix, 1, GL_FALSE, m);
}
static ID_INLINE void GLSL_SetUniform_AlphaTest(shaderProgram_t * program, uint32_t stateBits)
{
alphaTest_t value;
if (program->u_AlphaTest == -1)
return;
switch (stateBits & GLS_ATEST_BITS)
{
case GLS_ATEST_GT_0:
value = ATEST_GT_0;
break;
case GLS_ATEST_LT_128:
value = ATEST_LT_128;
break;
case GLS_ATEST_GE_128:
value = ATEST_GE_128;
break;
default:
value = ATEST_NONE;
break;
}
// don't just call LogComment, or we will get
// a call to va() every frame!
GLimp_LogUniformComment(va("--- GLSL_SetUniformAlphaTest( program = %s, value = %i ) ---\n", program->name, value));
#if defined(USE_UNIFORM_FIREWALL)
if(program->t_AlphaTest == value)
return;
program->t_AlphaTest = value;
#endif
qglUniform1iARB(program->u_AlphaTest, value);
}
static ID_INLINE void GLSL_SetUniform_ViewOrigin(shaderProgram_t * program, const vec3_t v)
{
if (program->u_ViewOrigin == -1)
return;
#if defined(USE_UNIFORM_FIREWALL)
if(VectorCompare(program->t_ViewOrigin, v))
return;
VectorCopy(v, program->t_ViewOrigin);
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniform_ViewOrigin( program = %s, viewOrigin = ( %5.3f, %5.3f, %5.3f ) ) ---\n", program->name, v[0], v[1], v[2]));
qglUniform3fARB(program->u_ViewOrigin, v[0], v[1], v[2]);
}
static ID_INLINE void GLSL_SetUniform_TCGen0(shaderProgram_t * program, texCoordGen_t value)
{
if (program->u_TCGen0 == -1)
return;
#if defined(USE_UNIFORM_FIREWALL)
if(program->t_TCGen0 == value)
return;
program->t_TCGen0 = value;
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniform_TCGen( program = %s, value = %i ) ---\n", program->name, value));
qglUniform1iARB(program->u_TCGen0, value);
}
static ID_INLINE void GLSL_SetUniform_TCGen1(shaderProgram_t * program, texCoordGen_t value)
{
if (program->u_TCGen1 == -1)
return;
#if defined(USE_UNIFORM_FIREWALL)
if(program->t_TCGen1 == value)
return;
program->t_TCGen1 = value;
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniform_TCGen( program = %s, value = %i ) ---\n", program->name, value));
qglUniform1iARB(program->u_TCGen1, value);
}
static ID_INLINE void GLSL_SetUniform_TCGen0Vector0(shaderProgram_t * program, const vec4_t v)
{
if (program->u_TCGen0Vector0 == -1)
return;
#if defined(USE_UNIFORM_FIREWALL)
if(VectorCompare(program->t_TCGen0Vector0, v))
return;
VectorCopy(v, program->t_TCGen0Vector0);
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniform_TCGen0Vector0( program = %s, color = ( %5.3f, %5.3f, %5.3f, %5.3f ) ) ---\n", program->name, v[0], v[1], v[2], v[3]));
qglUniform4fARB(program->u_TCGen0Vector0, v[0], v[1], v[2], v[3]);
}
static ID_INLINE void GLSL_SetUniform_TCGen0Vector1(shaderProgram_t * program, const vec4_t v)
{
if (program->u_TCGen0Vector1 == -1)
return;
#if defined(USE_UNIFORM_FIREWALL)
if(VectorCompare(program->t_TCGen0Vector1, v))
return;
VectorCopy(v, program->t_TCGen0Vector1);
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniform_TCGen0Vector1( program = %s, color = ( %5.3f, %5.3f, %5.3f, %5.3f ) ) ---\n", program->name, v[0], v[1], v[2], v[3]));
qglUniform4fARB(program->u_TCGen0Vector1, v[0], v[1], v[2], v[3]);
}
static ID_INLINE void GLSL_SetUniform_TCGen1Vector0(shaderProgram_t * program, const vec4_t v)
{
if (program->u_TCGen1Vector0 == -1)
return;
#if defined(USE_UNIFORM_FIREWALL)
if(VectorCompare(program->t_TCGen1Vector0, v))
return;
VectorCopy(v, program->t_TCGen1Vector0);
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniform_TCGen1Vector0( program = %s, color = ( %5.3f, %5.3f, %5.3f, %5.3f ) ) ---\n", program->name, v[0], v[1], v[2], v[3]));
qglUniform4fARB(program->u_TCGen1Vector0, v[0], v[1], v[2], v[3]);
}
static ID_INLINE void GLSL_SetUniform_TCGen1Vector1(shaderProgram_t * program, const vec4_t v)
{
if (program->u_TCGen1Vector1 == -1)
return;
#if defined(USE_UNIFORM_FIREWALL)
if(VectorCompare(program->t_TCGen1Vector1, v))
return;
VectorCopy(v, program->t_TCGen1Vector1);
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniform_TCGen1Vector1( program = %s, color = ( %5.3f, %5.3f, %5.3f, %5.3f ) ) ---\n", program->name, v[0], v[1], v[2], v[3]));
qglUniform4fARB(program->u_TCGen1Vector1, v[0], v[1], v[2], v[3]);
}
static ID_INLINE void GLSL_SetUniform_DeformGen(shaderProgram_t * program, deformGen_t value)
{
if (program->u_DeformGen == -1)
return;
#if defined(USE_UNIFORM_FIREWALL)
if(program->t_DeformGen == value)
return;
program->t_DeformGen = value;
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniform_DeformGen( program = %s, value = %i ) ---\n", program->name, value));
qglUniform1iARB(program->u_DeformGen, value);
}
static ID_INLINE void GLSL_SetUniform_DeformWave(shaderProgram_t * program, const waveForm_t * wf)
{
vec4_t v;
if (program->u_DeformWave == -1)
return;
VectorSet4(v, wf->base, wf->amplitude, wf->phase, wf->frequency);
#if defined(USE_UNIFORM_FIREWALL)
if(VectorCompare4(program->t_DeformWave, v))
return;
VectorCopy4(v, program->t_DeformWave);
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniform_DeformWave( program = %s, wave form = ( %5.3f, %5.3f, %5.3f, %5.3f ) ) ---\n", program->name, v[0], v[1], v[2], v[3]));
qglUniform4fARB(program->u_DeformWave, v[0], v[1], v[2], v[3]);
}
static ID_INLINE void GLSL_SetUniform_DeformBulge(shaderProgram_t * program, const deformStage_t * ds)
{
vec3_t v;
if (program->u_DeformBulge == -1)
return;
VectorSet(v, ds->bulgeWidth, ds->bulgeHeight, ds->bulgeSpeed);
#if defined(USE_UNIFORM_FIREWALL)
if(VectorCompare(program->t_DeformBulge, v))
return;
VectorCopy(v, program->t_DeformBulge);
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniform_DeformBulge( program = %s, bulge = ( %5.3f, %5.3f, %5.3f ) ) ---\n", program->name, v[0], v[1], v[2]));
qglUniform3fARB(program->u_DeformBulge, v[0], v[1], v[2]);
}
static ID_INLINE void GLSL_SetUniform_DeformSpread(shaderProgram_t * program, float value)
{
if (program->u_DeformSpread == -1)
return;
#if defined(USE_UNIFORM_FIREWALL)
if(program->t_DeformSpread == value)
return;
program->t_DeformSpread = value;
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniform_DeformSpread( program = %s, value = %f ) ---\n", program->name, value));
qglUniform1fARB(program->u_DeformSpread, value);
}
static ID_INLINE void GLSL_SetUniform_ColorGen(shaderProgram_t * program, colorGen_t value)
{
#if 0
float floatValue;
switch (value)
{
case CGEN_VERTEX:
floatValue = 1.0f;
break;
case CGEN_ONE_MINUS_VERTEX:
floatValue = -1.0f;
break;
default:
floatValue = 0.0f;
break;
}
#if defined(USE_UNIFORM_FIREWALL)
if(program->t_ColorGen == floatValue)
return;
program->t_ColorGen = floatValue;
#endif
qglUniform1fARB(program->u_ColorGen, floatValue);
#else
if (program->u_ColorGen == -1)
return;
#if defined(USE_UNIFORM_FIREWALL)
if(program->t_ColorGen == value)
return;
program->t_ColorGen = value;
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniform_ColorGen( program = %s, value = %i ) ---\n", program->name, value));
qglUniform1iARB(program->u_ColorGen, value);
#endif
}
static ID_INLINE void GLSL_SetUniform_AlphaGen(shaderProgram_t * program, alphaGen_t value)
{
#if 0
float floatValue;
switch (value)
{
case AGEN_VERTEX:
floatValue = 1.0f;
break;
case AGEN_ONE_MINUS_VERTEX:
floatValue = -1.0f;
break;
default:
floatValue = 0.0f;
break;
}
#if defined(USE_UNIFORM_FIREWALL)
if(program->t_AlphaGen == floatValue)
return;
program->t_AlphaGen = floatValue;
#endif
qglUniform1fARB(program->u_AlphaGen, floatValue);
#else
#if defined(USE_UNIFORM_FIREWALL)
if (program->u_AlphaGen == -1)
return;
if(program->t_AlphaGen == value)
return;
program->t_AlphaGen = value;
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniform_AlphaGen( program = %s, value = %i ) ---\n", program->name, value));
qglUniform1iARB(program->u_AlphaGen, value);
#endif
}
static ID_INLINE void GLSL_SetUniform_Color(shaderProgram_t * program, const vec4_t v)
{
if (program->u_Color == -1)
return;
#if defined(USE_UNIFORM_FIREWALL)
if(VectorCompare4(program->t_Color, v))
return;
VectorCopy4(v, program->t_Color);
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniform_Color( program = %s, color = ( %5.3f, %5.3f, %5.3f, %5.3f ) ) ---\n", program->name, v[0], v[1], v[2], v[3]));
qglUniform4fARB(program->u_Color, v[0], v[1], v[2], v[3]);
}
static ID_INLINE void GLSL_SetUniform_AmbientLight(shaderProgram_t * program, const vec3_t v)
{
if (program->u_AmbientLight == -1)
return;
#if defined(USE_UNIFORM_FIREWALL)
if(VectorCompare(program->t_AmbientLight, v))
return;
VectorCopy(v, program->t_AmbientLight);
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniform_AmbientLight( program = %s, color = ( %5.3f, %5.3f, %5.3f ) ) ---\n", program->name, v[0], v[1], v[2]));
qglUniform3fARB(program->u_AmbientLight, v[0], v[1], v[2]);
}
static ID_INLINE void GLSL_SetUniform_DirectedLight(shaderProgram_t * program, const vec3_t v)
{
if (program->u_DirectedLight == -1)
return;
#if defined(USE_UNIFORM_FIREWALL)
if(VectorCompare(program->t_DirectedLight, v))
return;
VectorCopy(v, program->t_DirectedLight);
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniform_DirectedLight( program = %s, color = ( %5.3f, %5.3f, %5.3f ) ) ---\n", program->name, v[0], v[1], v[2]));
qglUniform3fARB(program->u_DirectedLight, v[0], v[1], v[2]);
}
static ID_INLINE void GLSL_SetUniform_LightDir(shaderProgram_t * program, const vec3_t v)
{
if (program->u_LightDir == -1)
return;
#if defined(USE_UNIFORM_FIREWALL)
if(VectorCompare(program->t_LightDir, v))
return;
VectorCopy(v, program->t_LightDir);
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniform_LightDir( program = %s, color = ( %5.3f, %5.3f, %5.3f ) ) ---\n", program->name, v[0], v[1], v[2]));
qglUniform3fARB(program->u_LightDir, v[0], v[1], v[2]);
}
static ID_INLINE void GLSL_SetUniform_PortalRange(shaderProgram_t * program, float value)
{
if (program->u_PortalRange == -1)
return;
#if defined(USE_UNIFORM_FIREWALL)
if(program->t_PortalRange == value)
return;
program->t_PortalRange = value;
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniform_PortalRange( program = %s, value = %f ) ---\n", program->name, value));
qglUniform1fARB(program->u_PortalRange, value);
}
static ID_INLINE void GLSL_SetUniform_FogDistance(shaderProgram_t * program, const vec4_t v)
{
if (program->u_FogDistance == -1)
return;
#if defined(USE_UNIFORM_FIREWALL)
if(VectorCompare4(program->t_FogDistance, v))
return;
VectorCopy(v, program->t_FogDistance);
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniformFogDistance( program = %s, viewOrigin = ( %5.3f, %5.3f, %5.3f, %5.3f ) ) ---\n", program->name, v[0], v[1], v[2], v[3]));
qglUniform4fARB(program->u_FogDistance, v[0], v[1], v[2], v[3]);
}
static ID_INLINE void GLSL_SetUniform_FogDepth(shaderProgram_t * program, const vec4_t v)
{
if (program->u_FogDepth == -1)
return;
#if defined(USE_UNIFORM_FIREWALL)
if(VectorCompare4(program->t_FogDepth, v))
return;
VectorCopy(v, program->t_FogDepth);
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniformFogDepth( program = %s, viewOrigin = ( %5.3f, %5.3f, %5.3f, %5.3f ) ) ---\n", program->name, v[0], v[1], v[2], v[3]));
qglUniform4fARB(program->u_FogDepth, v[0], v[1], v[2], v[3]);
}
static ID_INLINE void GLSL_SetUniform_FogEyeT(shaderProgram_t * program, float value)
{
if (program->u_FogEyeT == -1)
return;
#if defined(USE_UNIFORM_FIREWALL)
if(program->t_FogEyeT == value)
return;
program->t_FogEyeT = value;
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniform_FogEyeT( program = %s, value = %f ) ---\n", program->name, value));
qglUniform1fARB(program->u_FogEyeT, value);
}
static ID_INLINE void GLSL_SetUniform_FogAdjustColors(shaderProgram_t * program, int value)
{
if (program->u_FogAdjustColors == -1)
return;
#if defined(USE_UNIFORM_FIREWALL)
if(program->t_FogAdjustColors == value)
return;
program->t_FogAdjustColors = value;
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniform_FogAdjustColors( program = %s, value = %i ) ---\n", program->name, value));
qglUniform1iARB(program->u_FogAdjustColors, value);
}
static ID_INLINE void GLSL_SetUniform_ModelMatrix(shaderProgram_t * program, const matrix_t m)
{
if (program->u_ModelMatrix == -1)
return;
#if defined(USE_UNIFORM_FIREWALL)
if(Matrix16Compare(program->t_ModelMatrix, m))
return;
Matrix16Copy(m, program->t_ModelMatrix);
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniform_ModelMatrix( program = %s, "
"matrix = \n"
"( %5.3f, %5.3f, %5.3f, %5.3f )\n"
"( %5.3f, %5.3f, %5.3f, %5.3f )\n"
"( %5.3f, %5.3f, %5.3f, %5.3f )\n"
"( %5.3f, %5.3f, %5.3f, %5.3f ) ) ---\n",
program->name,
m[0], m[4], m[8], m[12],
m[1], m[5], m[9], m[13],
m[2], m[6], m[10], m[14],
m[3], m[7], m[11], m[15]));
qglUniformMatrix4fvARB(program->u_ModelMatrix, 1, GL_FALSE, m);
}
static ID_INLINE void GLSL_SetUniform_ModelViewProjectionMatrix(shaderProgram_t * program, const matrix_t m)
{
if (program->u_ModelViewProjectionMatrix == -1)
return;
#if defined(USE_UNIFORM_FIREWALL)
if(Matrix16Compare(program->t_ModelViewProjectionMatrix, m))
return;
Matrix16Copy(m, program->t_ModelViewProjectionMatrix);
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniform_ModelViewProjectionMatrix( program = %s, "
"matrix = \n"
"( %5.3f, %5.3f, %5.3f, %5.3f )\n"
"( %5.3f, %5.3f, %5.3f, %5.3f )\n"
"( %5.3f, %5.3f, %5.3f, %5.3f )\n"
"( %5.3f, %5.3f, %5.3f, %5.3f ) ) ---\n",
program->name,
m[0], m[4], m[8], m[12],
m[1], m[5], m[9], m[13],
m[2], m[6], m[10], m[14],
m[3], m[7], m[11], m[15]));
qglUniformMatrix4fvARB(program->u_ModelViewProjectionMatrix, 1, GL_FALSE, m);
}
static ID_INLINE void GLSL_SetUniform_Time(shaderProgram_t * program, float value)
{
if (program->u_Time == -1)
return;
#if defined(USE_UNIFORM_FIREWALL)
if(program->t_Time == value)
return;
program->t_Time = value;
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniform_Time( program = %s, value = %f ) ---\n", program->name, value));
qglUniform1fARB(program->u_Time, value);
}
static ID_INLINE void GLSL_SetUniform_VertexLerp(shaderProgram_t * program, float value)
{
if (program->u_VertexLerp == -1)
return;
#if defined(USE_UNIFORM_FIREWALL)
if(program->t_VertexLerp == value)
return;
program->t_VertexLerp = value;
#endif
GLimp_LogUniformComment(va("--- GLSL_SetUniform_VertexLerp( program = %s, value = %f ) ---\n", program->name, value));
qglUniform1fARB(program->u_VertexLerp, value);
}
// trRefdef_t holds everything that comes in refdef_t, // trRefdef_t holds everything that comes in refdef_t,
// as well as the locally generated scene information // as well as the locally generated scene information
@ -2211,6 +1480,12 @@ typedef struct {
int c_flareTests; int c_flareTests;
int c_flareRenders; int c_flareRenders;
int c_glslShaderBinds;
int c_genericDraws;
int c_lightmappedDraws;
int c_fogDraws;
int c_dlightDraws;
int msec; // total msec for backend run int msec; // total msec for backend run
} backEndCounters_t; } backEndCounters_t;
@ -2314,6 +1589,10 @@ typedef struct {
// //
shaderProgram_t genericShader[GLSLDEF_COUNT]; shaderProgram_t genericShader[GLSLDEF_COUNT];
shaderProgram_t lightmappedShader;
shaderProgram_t textureOnlyShader;
shaderProgram_t fogShader;
shaderProgram_t dlightShader;
// ----------------------------------------- // -----------------------------------------
@ -2769,10 +2048,12 @@ void RB_StageIteratorGeneric( void );
void RB_StageIteratorGenericVBO( void ); void RB_StageIteratorGenericVBO( void );
void RB_StageIteratorSky( void ); void RB_StageIteratorSky( void );
void RB_StageIteratorVertexLitTexture( void ); void RB_StageIteratorVertexLitTexture( void );
void RB_StageIteratorLightmappedMultitextureVBOGLSL( void );
void RB_StageIteratorLightmappedMultitexture( void ); void RB_StageIteratorLightmappedMultitexture( void );
void RB_AddQuadStamp( vec3_t origin, vec3_t left, vec3_t up, byte *color ); void RB_AddQuadStamp( vec3_t origin, vec3_t left, vec3_t up, byte *color );
void RB_AddQuadStampExt( vec3_t origin, vec3_t left, vec3_t up, byte *color, float s1, float t1, float s2, float t2 ); void RB_AddQuadStampExt( vec3_t origin, vec3_t left, vec3_t up, byte *color, float s1, float t1, float s2, float t2 );
void RB_InstantQuad( vec4_t quadVerts[4] );
void RB_ShowImages( void ); void RB_ShowImages( void );
@ -2929,6 +2210,16 @@ void GLSL_VertexAttribsState(uint32_t stateBits);
void GLSL_VertexAttribPointers(uint32_t attribBits); void GLSL_VertexAttribPointers(uint32_t attribBits);
void GLSL_BindProgram(shaderProgram_t * program); void GLSL_BindProgram(shaderProgram_t * program);
void GLSL_BindNullProgram(void); void GLSL_BindNullProgram(void);
void GLSL_SetNumUniforms(shaderProgram_t *program, int numUniforms);
void GLSL_SetUniformName(shaderProgram_t *program, int uniformNum, const char *name);
void GLSL_SetUniformInt(shaderProgram_t *program, int uniformNum, GLint value);
void GLSL_SetUniformFloat(shaderProgram_t *program, int uniformNum, GLfloat value);
void GLSL_SetUniformVec2(shaderProgram_t *program, int uniformNum, const vec2_t v);
void GLSL_SetUniformVec3(shaderProgram_t *program, int uniformNum, const vec3_t v);
void GLSL_SetUniformVec4(shaderProgram_t *program, int uniformNum, const vec4_t v);
void GLSL_SetUniformMatrix16(shaderProgram_t *program, int uniformNum, const matrix_t matrix);
shaderProgram_t *GLSL_GetGenericShaderProgram(void); shaderProgram_t *GLSL_GetGenericShaderProgram(void);
/* /*

366
reaction/code/renderer/tr_shade.c
View file

@ -300,25 +300,16 @@ static void DrawTris (shaderCommands_t *input) {
{ {
if (glRefConfig.glsl && r_arb_shader_objects->integer) if (glRefConfig.glsl && r_arb_shader_objects->integer)
{ {
matrix_t matrix; shaderProgram_t *sp = &tr.textureOnlyShader;
shaderProgram_t *sp = &tr.genericShader[0];
GLSL_VertexAttribsState(ATTR_POSITION); GLSL_VertexAttribsState(ATTR_POSITION);
GLSL_BindProgram(sp); GLSL_BindProgram(sp);
GLSL_SetUniform_ModelViewProjectionMatrix(sp, glState.modelviewProjection); GLSL_SetUniformMatrix16(sp, TEXTUREONLY_UNIFORM_MODELVIEWPROJECTIONMATRIX, glState.modelviewProjection);
//GLSL_SetUniform_DeformGen(sp, DGEN_NONE);
GLSL_SetUniform_TCGen0(sp, TCGEN_IDENTITY);
Matrix16Identity(matrix);
GLSL_SetUniform_Texture0Matrix(sp, matrix);
GLSL_SetUniform_Texture1Env(sp, 0);
GLSL_SetUniform_ColorGen(sp, CGEN_IDENTITY);
GLSL_SetUniform_AlphaGen(sp, AGEN_IDENTITY);
if (input->multiDrawPrimitives) if (input->multiDrawPrimitives)
{ {
R_DrawMultiElementsVBO(input->multiDrawPrimitives, (const GLvoid **) input->multiDrawFirstIndex, input->multiDrawNumIndexes); R_DrawMultiElementsVBO(input->multiDrawPrimitives, (const GLvoid **)input->multiDrawFirstIndex, input->multiDrawNumIndexes);
} }
else else
{ {
@ -732,7 +723,7 @@ static void DrawMultitexturedVBO( shaderCommands_t *input, int stage ) {
if (input->multiDrawPrimitives) if (input->multiDrawPrimitives)
{ {
R_DrawMultiElementsVBO(input->multiDrawPrimitives, (const GLvoid **) input->multiDrawFirstIndex, input->multiDrawNumIndexes); R_DrawMultiElementsVBO(input->multiDrawPrimitives, (const GLvoid **)input->multiDrawFirstIndex, input->multiDrawNumIndexes);
} }
else else
{ {
@ -1120,7 +1111,6 @@ static void ProjectDlightTextureVBOGLSL( void ) {
dlight_t *dl; dlight_t *dl;
shaderProgram_t *sp; shaderProgram_t *sp;
vec4_t vector; vec4_t vector;
matrix_t matrix;
if ( !( tess.dlightBits & ( 1 << l ) ) ) { if ( !( tess.dlightBits & ( 1 << l ) ) ) {
continue; // this surface definately doesn't have any of this light continue; // this surface definately doesn't have any of this light
@ -1131,28 +1121,69 @@ static void ProjectDlightTextureVBOGLSL( void ) {
radius = dl->radius; radius = dl->radius;
scale = 1.0f / radius; scale = 1.0f / radius;
sp = GLSL_GetGenericShaderProgram(); sp = &tr.dlightShader;
backEnd.pc.c_dlightDraws++;
GLSL_BindProgram(sp); GLSL_BindProgram(sp);
GLSL_SetUniform_TCGen0(sp, TCGEN_DLIGHT); GLSL_SetUniformMatrix16(sp, DLIGHT_UNIFORM_MODELVIEWPROJECTIONMATRIX, glState.modelviewProjection);
Matrix16Identity(matrix);
GLSL_SetUniform_Texture0Matrix(sp, matrix); GLSL_SetUniformFloat(sp, DLIGHT_UNIFORM_VERTEXLERP, glState.vertexAttribsInterpolation);
GLSL_SetUniform_Texture1Env(sp, 0);
GLSL_SetUniform_ColorGen(sp, CGEN_DLIGHT); // u_DeformGen
GLSL_SetUniform_AlphaGen(sp, AGEN_CONST); if(!ShaderRequiresCPUDeforms(tess.shader))
{
deformStage_t *ds;
// only support the first one
ds = &tess.shader->deforms[0];
switch (ds->deformation)
{
case DEFORM_WAVE:
GLSL_SetUniformInt(sp, DLIGHT_UNIFORM_DEFORMGEN, ds->deformationWave.func);
{
vec4_t v;
waveForm_t *wf = &ds->deformationWave;
VectorSet4(v, wf->base, wf->amplitude, wf->phase, wf->frequency);
GLSL_SetUniformVec4(sp, DLIGHT_UNIFORM_DEFORMWAVE, v);
}
GLSL_SetUniformFloat(sp, DLIGHT_UNIFORM_DEFORMSPREAD, ds->deformationSpread);
GLSL_SetUniformFloat(sp, DLIGHT_UNIFORM_TIME, tess.shaderTime);
break;
case DEFORM_BULGE:
GLSL_SetUniformInt(sp, DLIGHT_UNIFORM_DEFORMGEN, DGEN_BULGE);
{
vec3_t v;
VectorSet(v, ds->bulgeWidth, ds->bulgeHeight, ds->bulgeSpeed);
GLSL_SetUniformVec3(sp, DLIGHT_UNIFORM_DEFORMBULGE, v);
}
GLSL_SetUniformFloat(sp, DLIGHT_UNIFORM_TIME, tess.shaderTime);
break;
default:
GLSL_SetUniformInt(sp, DLIGHT_UNIFORM_DEFORMGEN, DGEN_NONE);
break;
}
}
else
{
GLSL_SetUniformInt(sp, DLIGHT_UNIFORM_DEFORMGEN, DGEN_NONE);
}
vector[0] = dl->color[0]; vector[0] = dl->color[0];
vector[1] = dl->color[1]; vector[1] = dl->color[1];
vector[2] = dl->color[2]; vector[2] = dl->color[2];
vector[3] = 1.0f; vector[3] = 1.0f;
GLSL_SetUniform_Color(sp, vector); GLSL_SetUniformVec4(sp, DLIGHT_UNIFORM_COLOR, vector);
vector[0] = origin[0]; vector[0] = origin[0];
vector[1] = origin[1]; vector[1] = origin[1];
vector[2] = origin[2]; vector[2] = origin[2];
vector[3] = scale; vector[3] = scale;
GLSL_SetUniform_TCGen0Vector0(sp, vector); GLSL_SetUniformVec4(sp, DLIGHT_UNIFORM_DLIGHTINFO, vector);
GL_Bind( tr.dlightImage ); GL_Bind( tr.dlightImage );
@ -1167,7 +1198,7 @@ static void ProjectDlightTextureVBOGLSL( void ) {
if (tess.multiDrawPrimitives) if (tess.multiDrawPrimitives)
{ {
R_DrawMultiElementsVBO(tess.multiDrawPrimitives, (const GLvoid **) tess.multiDrawFirstIndex, tess.multiDrawNumIndexes); R_DrawMultiElementsVBO(tess.multiDrawPrimitives, (const GLvoid **)tess.multiDrawFirstIndex, tess.multiDrawNumIndexes);
} }
else else
{ {
@ -1225,29 +1256,70 @@ Blends a fog texture on top of everything else
*/ */
static void RB_FogPassVBOGLSL( void ) { static void RB_FogPassVBOGLSL( void ) {
fog_t *fog; fog_t *fog;
vec3_t local;
vec4_t color; vec4_t color;
matrix_t matrix; vec4_t fogDistanceVector, fogDepthVector = {0, 0, 0, 0};
shaderProgram_t *sp = GLSL_GetGenericShaderProgram(); float eyeT;
shaderProgram_t *sp = &tr.fogShader;
backEnd.pc.c_fogDraws++;
GLSL_BindProgram(sp); GLSL_BindProgram(sp);
fog = tr.world->fogs + tess.fogNum; fog = tr.world->fogs + tess.fogNum;
GLSL_SetUniform_FogAdjustColors(sp, 4); GLSL_SetUniformMatrix16(sp, FOGPASS_UNIFORM_MODELVIEWPROJECTIONMATRIX, glState.modelviewProjection);
GLSL_SetUniform_TCGen0(sp, TCGEN_IDENTITY);
Matrix16Identity(matrix); GLSL_SetUniformFloat(sp, FOGPASS_UNIFORM_VERTEXLERP, glState.vertexAttribsInterpolation);
GLSL_SetUniform_Texture0Matrix(sp, matrix);
GLSL_SetUniform_Texture1Env(sp, 0); // u_DeformGen
GLSL_SetUniform_ColorGen(sp, CGEN_CONST); if(!ShaderRequiresCPUDeforms(tess.shader))
GLSL_SetUniform_AlphaGen(sp, AGEN_CONST); {
deformStage_t *ds;
// only support the first one
ds = &tess.shader->deforms[0];
switch (ds->deformation)
{
case DEFORM_WAVE:
GLSL_SetUniformInt(sp, FOGPASS_UNIFORM_DEFORMGEN, ds->deformationWave.func);
{
vec4_t v;
waveForm_t *wf = &ds->deformationWave;
VectorSet4(v, wf->base, wf->amplitude, wf->phase, wf->frequency);
GLSL_SetUniformVec4(sp, FOGPASS_UNIFORM_DEFORMWAVE, v);
}
GLSL_SetUniformFloat(sp, FOGPASS_UNIFORM_DEFORMSPREAD, ds->deformationSpread);
GLSL_SetUniformFloat(sp, FOGPASS_UNIFORM_TIME, tess.shaderTime);
break;
case DEFORM_BULGE:
GLSL_SetUniformInt(sp, FOGPASS_UNIFORM_DEFORMGEN, DGEN_BULGE);
{
vec3_t v;
VectorSet(v, ds->bulgeWidth, ds->bulgeHeight, ds->bulgeSpeed);
GLSL_SetUniformVec3(sp, FOGPASS_UNIFORM_DEFORMBULGE, v);
}
GLSL_SetUniformFloat(sp, FOGPASS_UNIFORM_TIME, tess.shaderTime);
break;
default:
GLSL_SetUniformInt(sp, FOGPASS_UNIFORM_DEFORMGEN, DGEN_NONE);
break;
}
}
else
{
GLSL_SetUniformInt(sp, FOGPASS_UNIFORM_DEFORMGEN, DGEN_NONE);
}
color[0] = ((unsigned char *)(&fog->colorInt))[0] / 255.0f; color[0] = ((unsigned char *)(&fog->colorInt))[0] / 255.0f;
color[1] = ((unsigned char *)(&fog->colorInt))[1] / 255.0f; color[1] = ((unsigned char *)(&fog->colorInt))[1] / 255.0f;
color[2] = ((unsigned char *)(&fog->colorInt))[2] / 255.0f; color[2] = ((unsigned char *)(&fog->colorInt))[2] / 255.0f;
color[3] = ((unsigned char *)(&fog->colorInt))[3] / 255.0f; color[3] = ((unsigned char *)(&fog->colorInt))[3] / 255.0f;
GLSL_SetUniform_Color(sp, color); GLSL_SetUniformVec4(sp, FOGPASS_UNIFORM_COLOR, color);
#if 0 // already set
// from RB_CalcFogTexCoords() // from RB_CalcFogTexCoords()
VectorSubtract( backEnd.or.origin, backEnd.viewParms.or.origin, local ); VectorSubtract( backEnd.or.origin, backEnd.viewParms.or.origin, local );
fogDistanceVector[0] = -backEnd.or.modelMatrix[2]; fogDistanceVector[0] = -backEnd.or.modelMatrix[2];
@ -1278,14 +1350,9 @@ static void RB_FogPassVBOGLSL( void ) {
fogDistanceVector[3] += 1.0/512; fogDistanceVector[3] += 1.0/512;
//ri.Printf(PRINT_ALL,"eyeT %f fogDistanceVector %f %f %f %f fogDepthVector %f %f %f %f\n", eyeT, fogDistanceVector[0], fogDistanceVector[1], fogDistanceVector[2], fogDistanceVector[3], fogDepthVector[0], fogDepthVector[1], fogDepthVector[2], fogDepthVector[3]); GLSL_SetUniformVec4(sp, FOGPASS_UNIFORM_FOGDISTANCE, fogDistanceVector);
//ri.Printf(PRINT_ALL, "fogsurface %f %f %f %f\n", fog->surface[0], fog->surface[1], fog->surface[2], fog->surface[3]); GLSL_SetUniformVec4(sp, FOGPASS_UNIFORM_FOGDEPTH, fogDepthVector);
GLSL_SetUniformFloat(sp, FOGPASS_UNIFORM_FOGEYET, eyeT);
GLSL_SetUniform_TCGen0Vector0(sp, fogDistanceVector);
GLSL_SetUniform_TCGen0Vector1(sp, fogDepthVector);
GLSL_SetUniform_FogEyeT(sp, eyeT);
#endif
GL_Bind( tr.fogImage );
if ( tess.shader->fogPass == FP_EQUAL ) { if ( tess.shader->fogPass == FP_EQUAL ) {
GL_State( GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA | GLS_DEPTHFUNC_EQUAL ); GL_State( GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA | GLS_DEPTHFUNC_EQUAL );
@ -1295,7 +1362,7 @@ static void RB_FogPassVBOGLSL( void ) {
if (tess.multiDrawPrimitives) if (tess.multiDrawPrimitives)
{ {
R_DrawMultiElementsVBO(tess.multiDrawPrimitives, (const GLvoid **) tess.multiDrawFirstIndex, tess.multiDrawNumIndexes); R_DrawMultiElementsVBO(tess.multiDrawPrimitives, (const GLvoid **)tess.multiDrawFirstIndex, tess.multiDrawNumIndexes);
} }
else else
{ {
@ -1879,6 +1946,8 @@ static void ComputeColorMatrix( shaderStage_t *pStage, float *outmatrix, qboolea
outmatrix[15] = 0.0f; outmatrix[15] = 0.0f;
} }
break; break;
default:
break;
} }
// //
@ -2289,7 +2358,7 @@ static void RB_IterateStagesGenericVBO( shaderCommands_t *input )
if (input->multiDrawPrimitives) if (input->multiDrawPrimitives)
{ {
R_DrawMultiElementsVBO(input->multiDrawPrimitives, (const GLvoid **) input->multiDrawFirstIndex, input->multiDrawNumIndexes); R_DrawMultiElementsVBO(input->multiDrawPrimitives, (const GLvoid **)input->multiDrawFirstIndex, input->multiDrawNumIndexes);
} }
else else
{ {
@ -2324,18 +2393,18 @@ static void DrawMultitexturedVBOGLSL( shaderProgram_t *sp, shaderCommands_t *inp
// //
// base // base
// //
GLSL_SetUniform_TCGen0(sp, pStage->bundle[0].tcGen); GLSL_SetUniformInt(sp, GENERIC_UNIFORM_TCGEN0, pStage->bundle[0].tcGen);
if (pStage->bundle[0].tcGen == TCGEN_VECTOR) if (pStage->bundle[0].tcGen == TCGEN_VECTOR)
{ {
vector[3] = 0.0f; vector[3] = 0.0f;
VectorCopy(pStage->bundle[0].tcGenVectors[0], vector); VectorCopy(pStage->bundle[0].tcGenVectors[0], vector);
GLSL_SetUniform_TCGen0Vector0(sp, vector); GLSL_SetUniformVec4(sp, GENERIC_UNIFORM_TCGEN0VECTOR0, vector);
VectorCopy(pStage->bundle[0].tcGenVectors[1], vector); VectorCopy(pStage->bundle[0].tcGenVectors[1], vector);
GLSL_SetUniform_TCGen0Vector1(sp, vector); GLSL_SetUniformVec4(sp, GENERIC_UNIFORM_TCGEN0VECTOR1, vector);
} }
ComputeTexMatrix( pStage, 0, matrix ); ComputeTexMatrix( pStage, 0, matrix );
GLSL_SetUniform_Texture0Matrix(sp, matrix); GLSL_SetUniformMatrix16(sp, GENERIC_UNIFORM_TEXTURE0MATRIX, matrix);
R_BindAnimatedImageToTMU( &pStage->bundle[0], 0 ); R_BindAnimatedImageToTMU( &pStage->bundle[0], 0 );
@ -2343,16 +2412,16 @@ static void DrawMultitexturedVBOGLSL( shaderProgram_t *sp, shaderCommands_t *inp
// lightmap/secondary pass // lightmap/secondary pass
// //
if ( r_lightmap->integer ) { if ( r_lightmap->integer ) {
GLSL_SetUniform_Texture1Env(sp, GL_REPLACE); GLSL_SetUniformInt(sp, GENERIC_UNIFORM_TEXTURE1ENV, GL_REPLACE);
} else { } else {
GLSL_SetUniform_Texture1Env(sp, tess.shader->multitextureEnv); GLSL_SetUniformInt(sp, GENERIC_UNIFORM_TEXTURE1ENV, tess.shader->multitextureEnv);
} }
R_BindAnimatedImageToTMU( &pStage->bundle[1], 1 ); R_BindAnimatedImageToTMU( &pStage->bundle[1], 1 );
if (input->multiDrawPrimitives) if (input->multiDrawPrimitives)
{ {
R_DrawMultiElementsVBO(input->multiDrawPrimitives, (const GLvoid **) input->multiDrawFirstIndex, input->multiDrawNumIndexes); R_DrawMultiElementsVBO(input->multiDrawPrimitives, (const GLvoid **)input->multiDrawFirstIndex, input->multiDrawNumIndexes);
} }
else else
{ {
@ -2385,13 +2454,13 @@ static void RB_IterateStagesGenericVBOGLSL( shaderCommands_t *input )
GLSL_BindProgram(sp); GLSL_BindProgram(sp);
GLSL_SetUniform_ModelViewProjectionMatrix(sp, glState.modelviewProjection); GLSL_SetUniformMatrix16(sp, GENERIC_UNIFORM_MODELVIEWPROJECTIONMATRIX, glState.modelviewProjection);
GLSL_SetUniform_ViewOrigin(sp, backEnd.or.viewOrigin); GLSL_SetUniformVec3(sp, GENERIC_UNIFORM_VIEWORIGIN, backEnd.or.viewOrigin);
GLSL_SetUniform_VertexLerp(sp, glState.vertexAttribsInterpolation); GLSL_SetUniformFloat(sp, GENERIC_UNIFORM_VERTEXLERP, glState.vertexAttribsInterpolation);
// u_DeformGen // u_DeformGen
if(input->shader->numDeforms) if(!ShaderRequiresCPUDeforms(input->shader))
{ {
deformStage_t *ds; deformStage_t *ds;
@ -2401,26 +2470,39 @@ static void RB_IterateStagesGenericVBOGLSL( shaderCommands_t *input )
switch (ds->deformation) switch (ds->deformation)
{ {
case DEFORM_WAVE: case DEFORM_WAVE:
GLSL_SetUniform_DeformGen(sp, ds->deformationWave.func); GLSL_SetUniformInt(sp, GENERIC_UNIFORM_DEFORMGEN, ds->deformationWave.func);
GLSL_SetUniform_DeformWave(sp, &ds->deformationWave); {
GLSL_SetUniform_DeformSpread(sp, ds->deformationSpread); vec4_t v;
GLSL_SetUniform_Time(sp, tess.shaderTime); waveForm_t *wf = &ds->deformationWave;
VectorSet4(v, wf->base, wf->amplitude, wf->phase, wf->frequency);
GLSL_SetUniformVec4(sp, GENERIC_UNIFORM_DEFORMWAVE, v);
}
GLSL_SetUniformFloat(sp, GENERIC_UNIFORM_DEFORMSPREAD, ds->deformationSpread);
GLSL_SetUniformFloat(sp, GENERIC_UNIFORM_TIME, tess.shaderTime);
break; break;
case DEFORM_BULGE: case DEFORM_BULGE:
GLSL_SetUniform_DeformGen(sp, DGEN_BULGE); GLSL_SetUniformInt(sp, GENERIC_UNIFORM_DEFORMGEN, DGEN_BULGE);
GLSL_SetUniform_DeformBulge(sp, ds); {
GLSL_SetUniform_Time(sp, tess.shaderTime); vec3_t v;
VectorSet(v, ds->bulgeWidth, ds->bulgeHeight, ds->bulgeSpeed);
GLSL_SetUniformVec3(sp, GENERIC_UNIFORM_DEFORMBULGE, v);
}
GLSL_SetUniformFloat(sp, GENERIC_UNIFORM_TIME, tess.shaderTime);
break; break;
default: default:
GLSL_SetUniform_DeformGen(sp, DGEN_NONE); GLSL_SetUniformInt(sp, GENERIC_UNIFORM_DEFORMGEN, DGEN_NONE);
break; break;
} }
} }
else else
{ {
GLSL_SetUniform_DeformGen(sp, DGEN_NONE); GLSL_SetUniformInt(sp, GENERIC_UNIFORM_DEFORMGEN, DGEN_NONE);
} }
if ( input->fogNum ) { if ( input->fogNum ) {
@ -2455,9 +2537,9 @@ static void RB_IterateStagesGenericVBOGLSL( shaderCommands_t *input )
eyeT = 1; // non-surface fog always has eye inside eyeT = 1; // non-surface fog always has eye inside
} }
GLSL_SetUniform_FogDistance(sp, fogDistanceVector); GLSL_SetUniformVec4(sp, GENERIC_UNIFORM_FOGDISTANCE, fogDistanceVector);
GLSL_SetUniform_FogDepth(sp, fogDepthVector); GLSL_SetUniformVec4(sp, GENERIC_UNIFORM_FOGDEPTH, fogDepthVector);
GLSL_SetUniform_FogEyeT(sp, eyeT); GLSL_SetUniformFloat(sp, GENERIC_UNIFORM_FOGEYET, eyeT);
} }
for ( stage = 0; stage < MAX_SHADER_STAGES; stage++ ) for ( stage = 0; stage < MAX_SHADER_STAGES; stage++ )
@ -2484,13 +2566,13 @@ static void RB_IterateStagesGenericVBOGLSL( shaderCommands_t *input )
switch (pStage->alphaGen) switch (pStage->alphaGen)
{ {
case AGEN_SKIP:
case AGEN_IDENTITY: case AGEN_IDENTITY:
case AGEN_LIGHTING_SPECULAR: case AGEN_LIGHTING_SPECULAR:
case AGEN_VERTEX: case AGEN_VERTEX:
case AGEN_ONE_MINUS_VERTEX: case AGEN_ONE_MINUS_VERTEX:
case AGEN_PORTAL: case AGEN_PORTAL:
break; break;
case AGEN_SKIP:
default: default:
setcolor = qtrue; setcolor = qtrue;
} }
@ -2499,10 +2581,10 @@ static void RB_IterateStagesGenericVBOGLSL( shaderCommands_t *input )
{ {
vec4_t color; vec4_t color;
// JBravo: silincing a compiler warning about color being uninitialized VectorSet4(color, 1.0f, 1.0f, 1.0f, 1.0f);
MAKERGBA(color, 1.f, 1.f, 1.f, 1.f);
ComputeHelperColor (pStage, color); ComputeHelperColor (pStage, color);
GLSL_SetUniform_Color(sp, color); GLSL_SetUniformVec4(sp, GENERIC_UNIFORM_COLOR, color);
} }
if (pStage->rgbGen == CGEN_LIGHTING_DIFFUSE) if (pStage->rgbGen == CGEN_LIGHTING_DIFFUSE)
@ -2510,29 +2592,29 @@ static void RB_IterateStagesGenericVBOGLSL( shaderCommands_t *input )
vec3_t vec; vec3_t vec;
VectorScale(backEnd.currentEntity->ambientLight, 1.0f / 255.0f, vec); VectorScale(backEnd.currentEntity->ambientLight, 1.0f / 255.0f, vec);
GLSL_SetUniform_AmbientLight(sp, vec); GLSL_SetUniformVec3(sp, GENERIC_UNIFORM_AMBIENTLIGHT, vec);
VectorScale(backEnd.currentEntity->directedLight, 1.0f / 255.0f, vec); VectorScale(backEnd.currentEntity->directedLight, 1.0f / 255.0f, vec);
GLSL_SetUniform_DirectedLight(sp, vec); GLSL_SetUniformVec3(sp, GENERIC_UNIFORM_DIRECTEDLIGHT, vec);
GLSL_SetUniform_LightDir(sp, backEnd.currentEntity->lightDir); GLSL_SetUniformVec3(sp, GENERIC_UNIFORM_LIGHTDIR, backEnd.currentEntity->lightDir);
} }
if (pStage->alphaGen == AGEN_PORTAL) if (pStage->alphaGen == AGEN_PORTAL)
{ {
GLSL_SetUniform_PortalRange(sp, tess.shader->portalRange); GLSL_SetUniformFloat(sp, GENERIC_UNIFORM_PORTALRANGE, tess.shader->portalRange);
} }
GLSL_SetUniform_ColorGen(sp, pStage->rgbGen); GLSL_SetUniformInt(sp, GENERIC_UNIFORM_COLORGEN, pStage->rgbGen);
GLSL_SetUniform_AlphaGen(sp, pStage->alphaGen); GLSL_SetUniformInt(sp, GENERIC_UNIFORM_ALPHAGEN, pStage->alphaGen);
if ( input->fogNum ) if ( input->fogNum )
{ {
GLSL_SetUniform_FogAdjustColors(sp, pStage->adjustColorsForFog); GLSL_SetUniformInt(sp, GENERIC_UNIFORM_FOGADJUSTCOLORS, pStage->adjustColorsForFog);
} }
else else
{ {
GLSL_SetUniform_FogAdjustColors(sp, 0); GLSL_SetUniformInt(sp, GENERIC_UNIFORM_FOGADJUSTCOLORS, 0);
} }
// //
@ -2544,20 +2626,20 @@ static void RB_IterateStagesGenericVBOGLSL( shaderCommands_t *input )
} }
else else
{ {
GLSL_SetUniform_TCGen0(sp, pStage->bundle[0].tcGen); GLSL_SetUniformInt(sp, GENERIC_UNIFORM_TCGEN0, pStage->bundle[0].tcGen);
if (pStage->bundle[0].tcGen == TCGEN_VECTOR) if (pStage->bundle[0].tcGen == TCGEN_VECTOR)
{ {
vec4_t vector; vec4_t vector;
VectorCopy(pStage->bundle[0].tcGenVectors[0], vector); VectorCopy(pStage->bundle[0].tcGenVectors[0], vector);
vector[3] = 0.0f; vector[3] = 0.0f;
GLSL_SetUniform_TCGen0Vector0(sp, vector); GLSL_SetUniformVec4(sp, GENERIC_UNIFORM_TCGEN0VECTOR0, vector);
VectorCopy(pStage->bundle[0].tcGenVectors[1], vector); VectorCopy(pStage->bundle[0].tcGenVectors[1], vector);
GLSL_SetUniform_TCGen0Vector1(sp, vector); GLSL_SetUniformVec4(sp, GENERIC_UNIFORM_TCGEN0VECTOR1, vector);
} }
ComputeTexMatrix( pStage, 0, matrix ); ComputeTexMatrix( pStage, 0, matrix );
GLSL_SetUniform_Texture0Matrix(sp, matrix); GLSL_SetUniformMatrix16(sp, GENERIC_UNIFORM_TEXTURE0MATRIX, matrix);
// //
// set state // set state
@ -2569,7 +2651,7 @@ static void RB_IterateStagesGenericVBOGLSL( shaderCommands_t *input )
else else
R_BindAnimatedImage( &pStage->bundle[0] ); R_BindAnimatedImage( &pStage->bundle[0] );
GLSL_SetUniform_Texture1Env(sp, 0); GLSL_SetUniformInt(sp, GENERIC_UNIFORM_TEXTURE1ENV, 0);
// //
// draw // draw
@ -2577,7 +2659,7 @@ static void RB_IterateStagesGenericVBOGLSL( shaderCommands_t *input )
if (input->multiDrawPrimitives) if (input->multiDrawPrimitives)
{ {
R_DrawMultiElementsVBO(input->multiDrawPrimitives, (const GLvoid **) input->multiDrawFirstIndex, input->multiDrawNumIndexes); R_DrawMultiElementsVBO(input->multiDrawPrimitives, (const GLvoid **)input->multiDrawFirstIndex, input->multiDrawNumIndexes);
} }
else else
{ {
@ -2728,6 +2810,8 @@ void RB_StageIteratorGenericVBO( void )
return; return;
} }
backEnd.pc.c_genericDraws++;
if (tess.useInternalVBO) if (tess.useInternalVBO)
{ {
RB_DeformTessGeometry(); RB_DeformTessGeometry();
@ -2914,6 +2998,116 @@ void RB_StageIteratorVertexLitTexture( void )
//define REPLACE_MODE //define REPLACE_MODE
void RB_StageIteratorLightmappedMultitextureVBOGLSL( void )
{
shaderCommands_t *input;
unsigned int vertexAttribs = 0;
shaderProgram_t *sp;
shaderStage_t *pStage;
matrix_t matrix;
input = &tess;
if (!input->numVertexes || !input->numIndexes)
{
return;
}
backEnd.pc.c_lightmappedDraws++;
vertexAttribs = ATTR_POSITION | ATTR_TEXCOORD | ATTR_LIGHTCOORD; //RB_CalcShaderVertexAttribs( input );
if (tess.useInternalVBO)
{
RB_UpdateVBOs(vertexAttribs);
}
else
{
backEnd.pc.c_staticVboDraws++;
}
//
// log this call
//
if ( r_logFile->integer )
{
// don't just call LogComment, or we will get
// a call to va() every frame!
GLimp_LogComment( va("--- RB_StageIteratorLightmappedMultitextureVBOGLSL( %s ) ---\n", tess.shader->name) );
}
//
// set face culling appropriately
//
GL_Cull( input->shader->cullType );
//
// Set vertex attribs and pointers
//
if (glRefConfig.glsl && r_arb_shader_objects->integer)
{
GLSL_VertexAttribsState(vertexAttribs);
}
//
// Bind lightmapped shader
//
sp = &tr.lightmappedShader;
GLSL_BindProgram(sp);
GLSL_SetUniformMatrix16(sp, LIGHTMAPPED_UNIFORM_MODELVIEWPROJECTIONMATRIX, glState.modelviewProjection);
pStage = input->xstages[0];
GL_State( pStage->stateBits );
//
// base
//
ComputeTexMatrix( pStage, 0, matrix );
GLSL_SetUniformMatrix16(sp, LIGHTMAPPED_UNIFORM_TEXTURE0MATRIX, matrix);
R_BindAnimatedImageToTMU( &pStage->bundle[0], 0 );
//
// lightmap/secondary pass
//
#if 0
if ( r_lightmap->integer ) {
GLSL_SetUniformInt(sp, LIGHTMAPPED_UNIFORM_TEXTURE1ENV, GL_REPLACE);
} else {
GLSL_SetUniformInt(sp, LIGHTMAPPED_UNIFORM_TEXTURE1ENV, tess.shader->multitextureEnv);
}
#endif
R_BindAnimatedImageToTMU( &pStage->bundle[1], 1 );
//
// draw
//
if (input->multiDrawPrimitives)
{
R_DrawMultiElementsVBO(input->multiDrawPrimitives, (const GLvoid **)input->multiDrawFirstIndex, input->multiDrawNumIndexes);
}
else
{
R_DrawElementsVBO(input->numIndexes, input->firstIndex);
}
//
// now do any dynamic lighting needed
//
if ( tess.dlightBits && tess.shader->sort <= SS_OPAQUE
&& !(tess.shader->surfaceFlags & (SURF_NODLIGHT | SURF_SKY) ) ) {
ProjectDlightTextureVBOGLSL();
}
//
// now do fog
//
if ( tess.fogNum && tess.shader->fogPass ) {
RB_FogPassVBOGLSL();
}
}
void RB_StageIteratorLightmappedMultitexture( void ) { void RB_StageIteratorLightmappedMultitexture( void ) {
shaderCommands_t *input; shaderCommands_t *input;

21
reaction/code/renderer/tr_shader.c
View file

@ -1656,9 +1656,12 @@ static void ComputeStageIteratorFunc( void )
if ( glRefConfig.vertexBufferObject && r_arb_vertex_buffer_object->integer ) if ( glRefConfig.vertexBufferObject && r_arb_vertex_buffer_object->integer )
{ {
// VBOs don't support the fast path! if (!(glRefConfig.glsl && r_arb_shader_objects->integer))
{
// VBOs without shader objects don't support the fast path!
return; return;
} }
}
// //
// see if this can go into the vertex lit fast path // see if this can go into the vertex lit fast path
@ -1676,8 +1679,15 @@ static void ComputeStageIteratorFunc( void )
if ( !shader.multitextureEnv ) if ( !shader.multitextureEnv )
{ {
if ( !shader.numDeforms ) if ( !shader.numDeforms )
{
if (glRefConfig.vertexBufferObject && r_arb_vertex_buffer_object->integer && glRefConfig.glsl && r_arb_shader_objects->integer)
{
//shader.optimalStageIteratorFunc = RB_StageIteratorVertexLitTextureVBOGLSL;
}
else
{ {
shader.optimalStageIteratorFunc = RB_StageIteratorVertexLitTexture; shader.optimalStageIteratorFunc = RB_StageIteratorVertexLitTexture;
}
goto done; goto done;
} }
} }
@ -1701,9 +1711,16 @@ static void ComputeStageIteratorFunc( void )
{ {
if ( !shader.numDeforms ) if ( !shader.numDeforms )
{ {
if ( shader.multitextureEnv ) if ( shader.multitextureEnv == GL_MODULATE && !stages[0].adjustColorsForFog )
{
if (glRefConfig.vertexBufferObject && r_arb_vertex_buffer_object->integer && glRefConfig.glsl && r_arb_shader_objects->integer)
{
shader.optimalStageIteratorFunc = RB_StageIteratorLightmappedMultitextureVBOGLSL;
}
else
{ {
shader.optimalStageIteratorFunc = RB_StageIteratorLightmappedMultitexture; shader.optimalStageIteratorFunc = RB_StageIteratorLightmappedMultitexture;
}
goto done; goto done;
} }
} }

18
reaction/code/renderer/tr_sky.c
View file

@ -448,22 +448,22 @@ static void DrawSkySideVBO( struct image_s *image, const int mins[2], const int
GLSL_VertexAttribsState(ATTR_POSITION | ATTR_TEXCOORD); GLSL_VertexAttribsState(ATTR_POSITION | ATTR_TEXCOORD);
GLSL_BindProgram(sp); GLSL_BindProgram(sp);
GLSL_SetUniform_ModelViewProjectionMatrix(sp, glState.modelviewProjection); GLSL_SetUniformMatrix16(sp, GENERIC_UNIFORM_MODELVIEWPROJECTIONMATRIX, glState.modelviewProjection);
GLSL_SetUniform_FogAdjustColors(sp, 0); GLSL_SetUniformInt(sp, GENERIC_UNIFORM_FOGADJUSTCOLORS, 0);
GLSL_SetUniform_DeformGen(sp, DGEN_NONE); GLSL_SetUniformInt(sp, GENERIC_UNIFORM_DEFORMGEN, DGEN_NONE);
GLSL_SetUniform_TCGen0(sp, TCGEN_TEXTURE); GLSL_SetUniformInt(sp, GENERIC_UNIFORM_TCGEN0, TCGEN_TEXTURE);
Matrix16Identity(matrix); Matrix16Identity(matrix);
GLSL_SetUniform_Texture0Matrix(sp, matrix); GLSL_SetUniformMatrix16(sp, GENERIC_UNIFORM_TEXTURE0MATRIX, matrix);
GLSL_SetUniform_Texture1Env(sp, 0); GLSL_SetUniformInt(sp, GENERIC_UNIFORM_TEXTURE1ENV, 0);
GLSL_SetUniform_ColorGen(sp, CGEN_CONST); GLSL_SetUniformInt(sp, GENERIC_UNIFORM_COLORGEN, CGEN_CONST);
GLSL_SetUniform_AlphaGen(sp, AGEN_CONST); GLSL_SetUniformInt(sp, GENERIC_UNIFORM_ALPHAGEN, AGEN_CONST);
color[0] = tr.identityLight; color[0] = tr.identityLight;
color[1] = tr.identityLight; color[1] = tr.identityLight;
color[2] = tr.identityLight; color[2] = tr.identityLight;
color[3] = 1.0f; color[3] = 1.0f;
GLSL_SetUniform_Color(sp, color); GLSL_SetUniformVec4(sp, GENERIC_UNIFORM_COLOR, color);
} }
else else
{ {

35
reaction/code/renderer/tr_surface.c
View file

@ -173,8 +173,6 @@ based on Tess_InstantQuad from xreal
*/ */
void RB_InstantQuad(vec4_t quadVerts[4]) void RB_InstantQuad(vec4_t quadVerts[4])
{ {
matrix_t matrix;
GLimp_LogComment("--- RB_InstantQuad ---\n"); GLimp_LogComment("--- RB_InstantQuad ---\n");
tess.numVertexes = 0; tess.numVertexes = 0;
@ -216,25 +214,16 @@ void RB_InstantQuad(vec4_t quadVerts[4])
tess.indexes[tess.numIndexes++] = 2; tess.indexes[tess.numIndexes++] = 2;
tess.indexes[tess.numIndexes++] = 3; tess.indexes[tess.numIndexes++] = 3;
// FIXME: A lot of this can probably be removed for speed
RB_UpdateVBOs(ATTR_POSITION | ATTR_TEXCOORD); RB_UpdateVBOs(ATTR_POSITION | ATTR_TEXCOORD);
if (glRefConfig.glsl && r_arb_shader_objects->integer) if (glRefConfig.glsl && r_arb_shader_objects->integer)
{ {
shaderProgram_t *sp = &tr.genericShader[0]; shaderProgram_t *sp = &tr.textureOnlyShader;
GLSL_VertexAttribsState(ATTR_POSITION | ATTR_TEXCOORD); GLSL_VertexAttribsState(ATTR_POSITION | ATTR_TEXCOORD);
GLSL_BindProgram(sp); GLSL_BindProgram(sp);
GLSL_SetUniform_ModelViewProjectionMatrix(sp, glState.modelviewProjection); GLSL_SetUniformMatrix16(sp, TEXTUREONLY_UNIFORM_MODELVIEWPROJECTIONMATRIX, glState.modelviewProjection);
GLSL_SetUniform_FogAdjustColors(sp, 0);
GLSL_SetUniform_DeformGen(sp, DGEN_NONE);
GLSL_SetUniform_TCGen0(sp, TCGEN_TEXTURE);
Matrix16Identity(matrix);
GLSL_SetUniform_Texture0Matrix(sp, matrix);
GLSL_SetUniform_Texture1Env(sp, 0);
GLSL_SetUniform_ColorGen(sp, CGEN_IDENTITY);
GLSL_SetUniform_AlphaGen(sp, AGEN_IDENTITY);
} }
else else
{ {
@ -592,22 +581,22 @@ static void RB_SurfaceBeam( void )
GLSL_VertexAttribsState(ATTR_POSITION); GLSL_VertexAttribsState(ATTR_POSITION);
GLSL_BindProgram(sp); GLSL_BindProgram(sp);
GLSL_SetUniform_ModelViewProjectionMatrix(sp, glState.modelviewProjection); GLSL_SetUniformMatrix16(sp, GENERIC_UNIFORM_MODELVIEWPROJECTIONMATRIX, glState.modelviewProjection);
GLSL_SetUniform_FogAdjustColors(sp, 0); GLSL_SetUniformInt(sp, GENERIC_UNIFORM_FOGADJUSTCOLORS, 0);
GLSL_SetUniform_DeformGen(sp, DGEN_NONE); GLSL_SetUniformInt(sp, GENERIC_UNIFORM_DEFORMGEN, DGEN_NONE);
GLSL_SetUniform_TCGen0(sp, TCGEN_IDENTITY); GLSL_SetUniformInt(sp, GENERIC_UNIFORM_TCGEN0, TCGEN_IDENTITY);
Matrix16Identity(matrix); Matrix16Identity(matrix);
GLSL_SetUniform_Texture0Matrix(sp, matrix); GLSL_SetUniformMatrix16(sp, GENERIC_UNIFORM_TEXTURE0MATRIX, matrix);
GLSL_SetUniform_Texture1Env(sp, 0); GLSL_SetUniformInt(sp, GENERIC_UNIFORM_TEXTURE1ENV, 0);
GLSL_SetUniform_ColorGen(sp, CGEN_CONST); GLSL_SetUniformInt(sp, GENERIC_UNIFORM_COLORGEN, CGEN_CONST);
GLSL_SetUniform_AlphaGen(sp, AGEN_CONST); GLSL_SetUniformInt(sp, GENERIC_UNIFORM_ALPHAGEN, AGEN_CONST);
color[0] = 1.0f; color[0] = 1.0f;
color[1] = 0.0f; color[1] = 0.0f;
color[2] = 0.0f; color[2] = 0.0f;
color[3] = 1.0f; color[3] = 1.0f;
GLSL_SetUniform_Color(sp, color); GLSL_SetUniformVec4(sp, GENERIC_UNIFORM_COLOR, color);
} }
else else
{ {