void CQuickSpriteSystem::Flush(void)
{
if (mNextVert==0)
{
return;
}
/*
if (mUseFog && r_drawfog->integer == 2 &&
mFogIndex == tr.world->globalFog)
{ //enable hardware fog when we draw this thing if applicable -rww
fog_t *fog = tr.world->fogs + mFogIndex;
#ifdef _XBOX
qglFogi(GL_FOG_MODE, GL_EXP2);
#else
qglFogf(GL_FOG_MODE, GL_EXP2);
#endif
qglFogf(GL_FOG_DENSITY, logtestExp2 / fog->parms.depthForOpaque);
qglFogfv(GL_FOG_COLOR, fog->parms.color);
qglEnable(GL_FOG);
}
*/
//this should not be needed, since I just wait to disable fog for the surface til after surface sprites are done
//
// render the main pass
//
R_BindAnimatedImage( mTexBundle );
GL_State(mGLStateBits);
//
// set arrays and lock
//
qglEnableClientState( GL_TEXTURE_COORD_ARRAY);
qglTexCoordPointer( 2, GL_FLOAT, 0, mTextureCoords );
qglEnableClientState( GL_COLOR_ARRAY);
qglColorPointer( 4, GL_UNSIGNED_BYTE, 0, mColors );
qglVertexPointer (3, GL_FLOAT, 16, mVerts);
if ( qglLockArraysEXT )
{
qglLockArraysEXT(0, mNextVert);
GLimp_LogComment( "glLockArraysEXT\n" );
}
qglDrawArrays(GL_QUADS, 0, mNextVert);
backEnd.pc.c_vertexes += mNextVert;
backEnd.pc.c_indexes += mNextVert;
backEnd.pc.c_totalIndexes += mNextVert;
//only for software fog pass (global soft/volumetric) -rww
if (mUseFog && (r_drawfog->integer != 2 || mFogIndex != tr.world->globalFog))
{
fog_t *fog = tr.world->fogs + mFogIndex;
//
// render the fog pass
//
GL_Bind( tr.fogImage );
GL_State( GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA | GLS_DEPTHFUNC_EQUAL );
//
// set arrays and lock
//
qglTexCoordPointer( 2, GL_FLOAT, 0, mFogTextureCoords);
// qglEnableClientState( GL_TEXTURE_COORD_ARRAY); // Done above
qglDisableClientState( GL_COLOR_ARRAY );
qglColor4ubv((GLubyte *)&fog->colorInt);
// qglVertexPointer (3, GL_FLOAT, 16, mVerts); // Done above
qglDrawArrays(GL_QUADS, 0, mNextVert);
// Second pass from fog
backEnd.pc.c_totalIndexes += mNextVert;
}
//
// unlock arrays
//
if (qglUnlockArraysEXT)
{
qglUnlockArraysEXT();
GLimp_LogComment( "glUnlockArraysEXT\n" );
}
mNextVert=0;
}
/*
=============
GL_DrawAliasFrameLerp
interpolates between two frames and origins
FIXME: batch lerp all vertexes
=============
*/
void GL_DrawAliasFrameLerp (dmdl_t *paliashdr, float backlerp)
{
float l;
daliasframe_t *frame, *oldframe;
dtrivertx_t *v, *ov, *verts;
int *order;
int count;
float frontlerp;
float alpha;
vec3_t move, delta, vectors[3];
vec3_t frontv, backv;
int i;
int index_xyz;
float *lerp;
frame = (daliasframe_t *)((byte *)paliashdr + paliashdr->ofs_frames
+ currententity->frame * paliashdr->framesize);
verts = v = frame->verts;
oldframe = (daliasframe_t *)((byte *)paliashdr + paliashdr->ofs_frames
+ currententity->oldframe * paliashdr->framesize);
ov = oldframe->verts;
order = (int *)((byte *)paliashdr + paliashdr->ofs_glcmds);
// glTranslatef (frame->translate[0], frame->translate[1], frame->translate[2]);
// glScalef (frame->scale[0], frame->scale[1], frame->scale[2]);
if (currententity->flags & RF_TRANSLUCENT)
alpha = currententity->alpha;
else
alpha = 1.0;
// PMM - added double shell
if ( currententity->flags & ( RF_SHELL_RED | RF_SHELL_GREEN | RF_SHELL_BLUE | RF_SHELL_DOUBLE | RF_SHELL_HALF_DAM) )
qglDisable( GL_TEXTURE_2D );
frontlerp = 1.0 - backlerp;
// move should be the delta back to the previous frame * backlerp
VectorSubtract (currententity->oldorigin, currententity->origin, delta);
AngleVectors (currententity->angles, vectors[0], vectors[1], vectors[2]);
move[0] = DotProduct (delta, vectors[0]); // forward
move[1] = -DotProduct (delta, vectors[1]); // left
move[2] = DotProduct (delta, vectors[2]); // up
VectorAdd (move, oldframe->translate, move);
for (i=0 ; i<3 ; i++)
{
move[i] = backlerp*move[i] + frontlerp*frame->translate[i];
}
for (i=0 ; i<3 ; i++)
{
frontv[i] = frontlerp*frame->scale[i];
backv[i] = backlerp*oldframe->scale[i];
}
lerp = s_lerped[0];
GL_LerpVerts( paliashdr->num_xyz, v, ov, verts, lerp, move, frontv, backv );
if ( gl_vertex_arrays->value )
{
float colorArray[MAX_VERTS*4];
qglEnableClientState( GL_VERTEX_ARRAY );
qglVertexPointer( 3, GL_FLOAT, 16, s_lerped ); // padded for SIMD
// if ( currententity->flags & ( RF_SHELL_RED | RF_SHELL_GREEN | RF_SHELL_BLUE ) )
// PMM - added double damage shell
if ( currententity->flags & ( RF_SHELL_RED | RF_SHELL_GREEN | RF_SHELL_BLUE | RF_SHELL_DOUBLE | RF_SHELL_HALF_DAM) )
{
qglColor4f( shadelight[0], shadelight[1], shadelight[2], alpha );
}
else
{
qglEnableClientState( GL_COLOR_ARRAY );
qglColorPointer( 3, GL_FLOAT, 0, colorArray );
//
// pre light everything
//
for ( i = 0; i < paliashdr->num_xyz; i++ )
{
float l = shadedots[verts[i].lightnormalindex];
colorArray[i*3+0] = l * shadelight[0];
colorArray[i*3+1] = l * shadelight[1];
colorArray[i*3+2] = l * shadelight[2];
}
}
if ( qglLockArraysEXT != 0 )
qglLockArraysEXT( 0, paliashdr->num_xyz );
while (1)
{
// get the vertex count and primitive type
count = *order++;
if (!count)
break; // done
if (count < 0)
{
count = -count;
qglBegin (GL_TRIANGLE_FAN);
}
else
{
qglBegin (GL_TRIANGLE_STRIP);
}
// PMM - added double damage shell
if ( currententity->flags & ( RF_SHELL_RED | RF_SHELL_GREEN | RF_SHELL_BLUE | RF_SHELL_DOUBLE | RF_SHELL_HALF_DAM) )
{
do
{
index_xyz = order[2];
order += 3;
qglVertex3fv( s_lerped[index_xyz] );
} while (--count);
}
else
{
do
{
// texture coordinates come from the draw list
qglTexCoord2f (((float *)order)[0], ((float *)order)[1]);
index_xyz = order[2];
order += 3;
// normals and vertexes come from the frame list
// l = shadedots[verts[index_xyz].lightnormalindex];
// qglColor4f (l* shadelight[0], l*shadelight[1], l*shadelight[2], alpha);
qglArrayElement( index_xyz );
} while (--count);
}
qglEnd ();
}
if ( qglUnlockArraysEXT != 0 )
qglUnlockArraysEXT();
}
else
{
while (1)
{
// get the vertex count and primitive type
count = *order++;
if (!count)
break; // done
if (count < 0)
{
count = -count;
qglBegin (GL_TRIANGLE_FAN);
}
else
{
qglBegin (GL_TRIANGLE_STRIP);
}
if ( currententity->flags & ( RF_SHELL_RED | RF_SHELL_GREEN | RF_SHELL_BLUE ) )
{
do
{
index_xyz = order[2];
order += 3;
qglColor4f( shadelight[0], shadelight[1], shadelight[2], alpha);
qglVertex3fv (s_lerped[index_xyz]);
} while (--count);
}
else
{
do
{
// texture coordinates come from the draw list
qglTexCoord2f (((float *)order)[0], ((float *)order)[1]);
index_xyz = order[2];
order += 3;
// normals and vertexes come from the frame list
l = shadedots[verts[index_xyz].lightnormalindex];
qglColor4f (l* shadelight[0], l*shadelight[1], l*shadelight[2], alpha);
qglVertex3fv (s_lerped[index_xyz]);
} while (--count);
}
qglEnd ();
}
}
// if ( currententity->flags & ( RF_SHELL_RED | RF_SHELL_GREEN | RF_SHELL_BLUE ) )
// PMM - added double damage shell
if ( currententity->flags & ( RF_SHELL_RED | RF_SHELL_GREEN | RF_SHELL_BLUE | RF_SHELL_DOUBLE | RF_SHELL_HALF_DAM) )
qglEnable( GL_TEXTURE_2D );
}
void RB_StageIteratorLightmappedMultitexture( void ) {
shaderCommands_t *input;
shader_t *shader;
input = &tess;
shader = input->shader;
//
// 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_StageIteratorLightmappedMultitexture( %s ) ---\n", tess.shader->name) );
}
//
// set face culling appropriately
//
GL_Cull( shader->cullType );
//
// set color, pointers, and lock
//
GL_State( GLS_DEFAULT );
qglVertexPointer( 3, GL_FLOAT, 16, input->xyz );
#ifdef REPLACE_MODE
qglDisableClientState( GL_COLOR_ARRAY );
qglColor3f( 1, 1, 1 );
qglShadeModel( GL_FLAT );
#else
qglEnableClientState( GL_COLOR_ARRAY );
qglColorPointer( 4, GL_UNSIGNED_BYTE, 0, tess.constantColor255 );
#endif
//
// select base stage
//
GL_SelectTexture( 0 );
qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
R_BindAnimatedImage( &tess.xstages[0]->bundle[0] );
qglTexCoordPointer( 2, GL_FLOAT, 16, tess.texCoords[0][0] );
//
// configure second stage
//
GL_SelectTexture( 1 );
qglEnable( GL_TEXTURE_2D );
if ( r_lightmap->integer ) {
GL_TexEnv( GL_REPLACE );
} else {
GL_TexEnv( GL_MODULATE );
}
R_BindAnimatedImage( &tess.xstages[0]->bundle[1] );
qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
qglTexCoordPointer( 2, GL_FLOAT, 16, tess.texCoords[0][1] );
//
// lock arrays
//
if ( qglLockArraysEXT ) {
qglLockArraysEXT(0, input->numVertexes);
GLimp_LogComment( "glLockArraysEXT\n" );
}
R_DrawElements( input->numIndexes, input->indexes );
//
// disable texturing on TEXTURE1, then select TEXTURE0
//
qglDisable( GL_TEXTURE_2D );
qglDisableClientState( GL_TEXTURE_COORD_ARRAY );
GL_SelectTexture( 0 );
#ifdef REPLACE_MODE
GL_TexEnv( GL_MODULATE );
qglShadeModel( GL_SMOOTH );
#endif
//
// now do any dynamic lighting needed
//
if ( tess.dlightBits && tess.shader->sort <= SS_OPAQUE ) {
ProjectDlightTexture();
}
//
// now do fog
//
if ( tess.fogNum && tess.shader->fogPass ) {
RB_FogPass();
}
//
// unlock arrays
//
if ( qglUnlockArraysEXT ) {
qglUnlockArraysEXT();
GLimp_LogComment( "glUnlockArraysEXT\n" );
}
}
void R_RenderShadowEdges( void ) {
int i;
#if 0
int numTris;
// dumb way -- render every triangle's edges
numTris = tess.numIndexes / 3;
for ( i = 0 ; i < numTris ; i++ ) {
int i1, i2, i3;
if ( !facing[i] ) {
continue;
}
i1 = tess.indexes[ i*3 + 0 ];
i2 = tess.indexes[ i*3 + 1 ];
i3 = tess.indexes[ i*3 + 2 ];
qglBegin( GL_TRIANGLE_STRIP );
qglVertex3fv( tess.xyz[ i1 ] );
qglVertex3fv( tess.xyz[ i1 + tess.numVertexes ] );
qglVertex3fv( tess.xyz[ i2 ] );
qglVertex3fv( tess.xyz[ i2 + tess.numVertexes ] );
qglVertex3fv( tess.xyz[ i3 ] );
qglVertex3fv( tess.xyz[ i3 + tess.numVertexes ] );
qglVertex3fv( tess.xyz[ i1 ] );
qglVertex3fv( tess.xyz[ i1 + tess.numVertexes ] );
qglEnd();
}
#else
int c, c2;
int j, k;
int i2;
int c_edges, c_rejected;
int hit[2];
// an edge is NOT a silhouette edge if its face doesn't face the light,
// or if it has a reverse paired edge that also faces the light.
// A well behaved polyhedron would have exactly two faces for each edge,
// but lots of models have dangling edges or overfanned edges
c_edges = 0;
c_rejected = 0;
unsigned short indicies[4];
for ( i = 0 ; i < tess.numVertexes ; i++ ) {
c = numEdgeDefs[ i ];
for ( j = 0 ; j < c ; j++ ) {
if ( !edgeDefs[ i ][ j ].facing ) {
continue;
}
hit[0] = 0;
hit[1] = 0;
i2 = edgeDefs[ i ][ j ].i2;
c2 = numEdgeDefs[ i2 ];
for ( k = 0 ; k < c2 ; k++ ) {
if ( edgeDefs[ i2 ][ k ].i2 == i ) {
hit[ edgeDefs[ i2 ][ k ].facing ]++;
}
}
// if it doesn't share the edge with another front facing
// triangle, it is a sil edge
if ( hit[ 1 ] == 0 ) {
indicies[0] = i;
indicies[1] = i + tess.numVertexes;
indicies[2] = i2;
indicies[3] = i2 + tess.numVertexes;
qglVertexPointer(3, GL_FLOAT, 16, tess.xyz);
qglDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_SHORT, indicies);
c_edges++;
} else {
c_rejected++;
}
}
}
#endif
}
/*
** RB_StageIteratorVertexLitTexture
*/
void RB_StageIteratorVertexLitTexture( void ) {
shaderCommands_t *input;
shader_t *shader;
input = &tess;
shader = input->shader;
//
// compute colors
//
RB_CalcDiffuseColor( ( unsigned char * ) tess.svars.colors );
//
// 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_StageIteratorVertexLitTexturedUnfogged( %s ) ---\n", tess.shader->name ) );
}
// set GL fog
SetIteratorFog();
//
// set face culling appropriately
//
GL_Cull( input->shader->cullType );
//
// set arrays and lock
//
qglEnableClientState( GL_COLOR_ARRAY );
qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
if ( qglPNTrianglesiATI && tess.ATI_tess ) {
#ifdef __MACOS__ //DAJ ATI
qglPNTrianglesiATI( GL_PN_TRIANGLES_ATI, 1 );
#else
qglEnable( GL_PN_TRIANGLES_ATI ); // ATI PN-Triangles extension
#endif
qglEnableClientState( GL_NORMAL_ARRAY ); // RF< so we can send the normals as an array
qglNormalPointer( GL_FLOAT, 16, input->normal );
}
qglColorPointer( 4, GL_UNSIGNED_BYTE, 0, tess.svars.colors );
qglTexCoordPointer( 2, GL_FLOAT, 16, tess.texCoords[0][0] );
qglVertexPointer( 3, GL_FLOAT, 16, input->xyz );
if ( qglLockArraysEXT ) {
qglLockArraysEXT( 0, input->numVertexes );
GLimp_LogComment( "glLockArraysEXT\n" );
}
//
// call special shade routine
//
R_BindAnimatedImage( &tess.xstages[0]->bundle[0] );
GL_State( tess.xstages[0]->stateBits );
R_DrawElements( input->numIndexes, input->indexes );
//
// now do any dynamic lighting needed
//
if ( tess.dlightBits && tess.shader->sort <= SS_OPAQUE ) {
ProjectDlightTexture();
}
//
// now do fog
//
if ( tess.fogNum && tess.shader->fogPass ) {
RB_FogPass();
}
//
// unlock arrays
//
if ( qglUnlockArraysEXT ) {
qglUnlockArraysEXT();
GLimp_LogComment( "glUnlockArraysEXT\n" );
}
if ( qglPNTrianglesiATI && tess.ATI_tess )
#ifdef __MACOS__ //DAJ ATI{
qglPNTrianglesiATI( GL_PN_TRIANGLES_ATI, 0 );
}
/*
=============
RB_ARB2_CreateDrawInteractions
=============
*/
void RB_GLSL_CreateDrawInteractions( const drawSurf_t *surf ) {
if ( !surf ) {
return;
}
// perform setup here that will be constant for all interactions
GL_State( GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE | GLS_DEPTHMASK | backEnd.depthFunc );
//GL_Cull(CT_TWO_SIDED);
qglEnableClientState(GL_VERTEX_ARRAY);
//qglDisableClientState(GL_VERTEX_ARRAY);
qglDisableClientState(GL_TEXTURE_COORD_ARRAY);
glUseProgram(program);
float modelMatrix[16];
myGlMultMatrix( surf->space->modelViewMatrix, backEnd.viewDef->projectionMatrix, modelMatrix);
glUniformMatrix4fv(wvp, 1, GL_FALSE, &modelMatrix[0] );
//glUniformMatrix4fv(wvp1, 1, GL_FALSE, &surf->space->modelViewMatrix[0] );
//const float* mat = backEnd.viewDef->projectionMatrix;
//glUniformMatrix4fv(wvp, 1, GL_FALSE, &mat[0] );
// enable the vertex arrays
glEnableVertexAttribArray( 1 );
glEnableVertexAttribArray( 2 );
glEnableVertexAttribArray( 3 );
glEnableVertexAttribArray( 4 );
glEnableVertexAttribArray( 5 );
glEnableVertexAttribArray( 6 );
// texture 0 is the normalization cube map for the vector towards the light
glActiveTexture(GL_TEXTURE0);
backEnd.glState.currenttmu = 0;
if ( backEnd.vLight->lightShader->IsAmbientLight() ) {
globalImages->ambientNormalMap->Bind();
} else {
globalImages->normalCubeMapImage->Bind();
}
// texture 6 is the specular lookup table
glActiveTexture(GL_TEXTURE6);
backEnd.glState.currenttmu = 6;
if ( r_testARBProgram.GetBool() ) {
globalImages->specular2DTableImage->Bind(); // variable specularity in alpha channel
} else {
globalImages->specularTableImage->Bind();
}
for ( ; surf ; surf=surf->nextOnLight ) {
// set the vertex pointers
idDrawVert *ac = (idDrawVert *)vertexCache.Position( surf->geo->ambientCache );
qglVertexPointer( 3, GL_FLOAT, sizeof( idDrawVert ), ac->xyz.ToFloatPtr() );
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(idDrawVert), ac->xyz.ToFloatPtr());
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(idDrawVert), ac->st.ToFloatPtr());
glVertexAttribPointer(3, 4, GL_UNSIGNED_BYTE, GL_FALSE, sizeof(idDrawVert), ac->color);
glVertexAttribPointer(4, 3, GL_FLOAT, GL_FALSE, sizeof(idDrawVert), ac->normal.ToFloatPtr());
glVertexAttribPointer(5, 3, GL_FLOAT, GL_FALSE, sizeof(idDrawVert), ac->tangents[0].ToFloatPtr());
glVertexAttribPointer(6, 3, GL_FLOAT, GL_FALSE, sizeof(idDrawVert), ac->tangents[1].ToFloatPtr());
idVec4 localLight;
R_GlobalPointToLocal( surf->space->modelMatrix, backEnd.vLight->globalLightOrigin, localLight.ToVec3() );
localLight.w = 0.0f;
glUniform3fv(lightOrgin, 1, localLight.ToFloatPtr());
//glDrawElements(GL_TRIANGLES, surf->geo->numIndexes, GL_UNSIGNED_SHORT, surf->geo->indexes);
// this may cause RB_ARB2_DrawInteraction to be exacuted multiple
// times with different colors and images if the surface or light have multiple layers
RB_CreateSingleDrawInteractions( surf, RB_GLSL_DrawInteraction );
}
glDisableVertexAttribArray( 1 );
glDisableVertexAttribArray( 2 );
glDisableVertexAttribArray( 3 );
glDisableVertexAttribArray( 4 );
glDisableVertexAttribArray( 5 );
glDisableVertexAttribArray( 6 );
// disable features
glActiveTexture( GL_TEXTURE6 );
backEnd.glState.currenttmu = 6;
globalImages->BindNull();
glActiveTexture( GL_TEXTURE5 );
backEnd.glState.currenttmu = 5;
globalImages->BindNull();
glActiveTexture( GL_TEXTURE4 );
backEnd.glState.currenttmu = 4;
globalImages->BindNull();
glActiveTexture( GL_TEXTURE3 );
backEnd.glState.currenttmu = 3;
globalImages->BindNull();
glActiveTexture( GL_TEXTURE2 );
backEnd.glState.currenttmu = 2;
globalImages->BindNull();
glActiveTexture( GL_TEXTURE1 );
backEnd.glState.currenttmu = 1;
globalImages->BindNull();
glUseProgram(0);
backEnd.glState.currenttmu = -1;
GL_SelectTexture(0 );
}
/*
===================
RB_StageIteratorVertexLitTexture
===================
*/
void RB_StageIteratorVertexLitTexture(void)
{
shaderCommands_t *input = &tess;
shader_t *shader = input->shader;
// compute colors
RB_CalcDiffuseColor(( unsigned char * ) tess.svars.colors);
// 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_StageIteratorVertexLitTexturedUnfogged( %s ) ---\n", tess.shader->name));
}
// set GL fog
SetIteratorFog();
// set face culling appropriately
GL_Cull(shader->cullType);
// set arrays and lock
qglEnableClientState(GL_COLOR_ARRAY);
qglEnableClientState(GL_TEXTURE_COORD_ARRAY);
qglColorPointer(4, GL_UNSIGNED_BYTE, 0, tess.svars.colors);
qglTexCoordPointer(2, GL_FLOAT, 8, tess.texCoords0);
qglVertexPointer(3, GL_FLOAT, 16, input->xyz);
if (qglLockArraysEXT)
{
qglLockArraysEXT(0, input->numVertexes);
GLimp_LogComment("glLockArraysEXT\n");
}
// call special shade routine
R_BindAnimatedImage(&tess.xstages[0]->bundle[0]);
GL_State(tess.xstages[0]->stateBits);
R_DrawElements(input->numIndexes, input->indexes);
// now do any dynamic lighting needed
//if ( tess.dlightBits && tess.shader->sort <= SS_OPAQUE )
if (tess.dlightBits && tess.shader->fogPass &&
!(tess.shader->surfaceFlags & (SURF_NODLIGHT | SURF_SKY)))
{
if (r_dynamiclight->integer == 2)
{
DynamicLightPass();
}
else
{
DynamicLightSinglePass();
}
}
// now do fog
if (tess.fogNum && tess.shader->fogPass)
{
RB_FogPass();
}
// unlock arrays
if (qglUnlockArraysEXT)
{
qglUnlockArraysEXT();
GLimp_LogComment("glUnlockArraysEXT\n");
}
}
/*
=============
RB_NV20_CreateDrawInteractions
=============
*/
static void RB_NV20_CreateDrawInteractions(const drawSurf_t *surf)
{
if (!surf) {
return;
}
qglEnable(GL_VERTEX_PROGRAM_ARB);
qglEnable(GL_REGISTER_COMBINERS_NV);
#ifdef MACOS_X
GL_SelectTexture(0);
qglDisableClientState(GL_TEXTURE_COORD_ARRAY);
#else
qglDisableClientState(GL_TEXTURE_COORD_ARRAY);
qglEnableVertexAttribArrayARB(8);
qglEnableVertexAttribArrayARB(9);
qglEnableVertexAttribArrayARB(10);
qglEnableVertexAttribArrayARB(11);
#endif
for (; surf ; surf=surf->nextOnLight) {
// set the vertex pointers
idDrawVert *ac = (idDrawVert *)vertexCache.Position(surf->geo->ambientCache);
qglColorPointer(4, GL_UNSIGNED_BYTE, sizeof(idDrawVert), ac->color);
#ifdef MACOS_X
GL_SelectTexture(0);
qglTexCoordPointer(2, GL_FLOAT, sizeof(idDrawVert), ac->st.ToFloatPtr());
GL_SelectTexture(1);
qglTexCoordPointer(3, GL_FLOAT, sizeof(idDrawVert), ac->tangents[0].ToFloatPtr());
GL_SelectTexture(2);
qglTexCoordPointer(3, GL_FLOAT, sizeof(idDrawVert), ac->tangents[1].ToFloatPtr());
GL_SelectTexture(3);
qglTexCoordPointer(3, GL_FLOAT, sizeof(idDrawVert), ac->normal.ToFloatPtr());
GL_SelectTexture(0);
#else
qglVertexAttribPointerARB(11, 3, GL_FLOAT, false, sizeof(idDrawVert), ac->normal.ToFloatPtr());
qglVertexAttribPointerARB(10, 3, GL_FLOAT, false, sizeof(idDrawVert), ac->tangents[1].ToFloatPtr());
qglVertexAttribPointerARB(9, 3, GL_FLOAT, false, sizeof(idDrawVert), ac->tangents[0].ToFloatPtr());
qglVertexAttribPointerARB(8, 2, GL_FLOAT, false, sizeof(idDrawVert), ac->st.ToFloatPtr());
#endif
qglVertexPointer(3, GL_FLOAT, sizeof(idDrawVert), ac->xyz.ToFloatPtr());
RB_CreateSingleDrawInteractions(surf, RB_NV20_DrawInteraction);
}
#ifndef MACOS_X
qglDisableVertexAttribArrayARB(8);
qglDisableVertexAttribArrayARB(9);
qglDisableVertexAttribArrayARB(10);
qglDisableVertexAttribArrayARB(11);
#endif
// disable features
#ifdef MACOS_X
GL_SelectTexture(3);
globalImages->BindNull();
qglDisableClientState(GL_TEXTURE_COORD_ARRAY);
GL_SelectTexture(2);
globalImages->BindNull();
qglDisableClientState(GL_TEXTURE_COORD_ARRAY);
GL_SelectTexture(1);
globalImages->BindNull();
qglDisableClientState(GL_TEXTURE_COORD_ARRAY);
#else
GL_SelectTextureNoClient(3);
globalImages->BindNull();
GL_SelectTextureNoClient(2);
globalImages->BindNull();
GL_SelectTextureNoClient(1);
globalImages->BindNull();
#endif
backEnd.glState.currenttmu = -1;
GL_SelectTexture(0);
qglEnableClientState(GL_TEXTURE_COORD_ARRAY);
qglDisable(GL_VERTEX_PROGRAM_ARB);
qglDisable(GL_REGISTER_COMBINERS_NV);
}
/*
===============
RB_ShowImages
Draw all the images to the screen, on top of whatever
was there. This is used to test for texture thrashing.
Also called by RE_EndRegistration
===============
*/
void RB_ShowImages( void ) {
int i;
image_t *image;
float x, y, w, h;
int start, end;
if ( !backEnd.projection2D ) {
RB_SetGL2D();
}
qglClear( GL_COLOR_BUFFER_BIT );
qglFinish();
start = ri.Milliseconds();
for ( i = 0 ; i < tr.numImages ; i++ ) {
image = tr.images[i];
w = glConfig.vidWidth / 40;
h = glConfig.vidHeight / 30;
x = i % 40 * w;
y = i / 30 * h;
// show in proportional size in mode 2
if ( r_showImages->integer == 2 ) {
w *= image->uploadWidth / 512.0f;
h *= image->uploadHeight / 512.0f;
}
#ifdef USE_OPENGLES
GLfloat tex[] = {
0, 0,
1, 0,
1, 1,
0, 1 };
GLfloat vtx[] = {
x, y,
x + w, y,
x + w, y + h,
x, y + h };
GLboolean text = qglIsEnabled(GL_TEXTURE_COORD_ARRAY);
GLboolean glcol = qglIsEnabled(GL_COLOR_ARRAY);
if (glcol)
qglDisableClientState(GL_COLOR_ARRAY);
if (!text)
qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
qglTexCoordPointer( 2, GL_FLOAT, 0, tex );
qglVertexPointer ( 2, GL_FLOAT, 0, vtx );
qglDrawArrays( GL_TRIANGLE_FAN, 0, 4 );
if (glcol)
qglEnableClientState(GL_COLOR_ARRAY);
if (!text)
qglDisableClientState( GL_TEXTURE_COORD_ARRAY );
#else
GL_Bind( image );
qglBegin( GL_QUADS );
qglTexCoord2f( 0, 0 );
qglVertex2f( x, y );
qglTexCoord2f( 1, 0 );
qglVertex2f( x + w, y );
qglTexCoord2f( 1, 1 );
qglVertex2f( x + w, y + h );
qglTexCoord2f( 0, 1 );
qglVertex2f( x, y + h );
qglEnd();
#endif
}
qglFinish();
end = ri.Milliseconds();
ri.Printf( PRINT_ALL, "%i msec to draw all images\n", end - start );
}
/*
=============
RB_ARB2_CreateDrawInteractions
=============
*/
void RB_ARB2_CreateDrawInteractions(const drawSurf_t *surf)
{
if (!surf) {
return;
}
// perform setup here that will be constant for all interactions
GL_State(GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE | GLS_DEPTHMASK | backEnd.depthFunc);
// bind the vertex program
if (r_testARBProgram.GetBool()) {
qglBindProgramARB(GL_VERTEX_PROGRAM_ARB, VPROG_TEST);
qglBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, FPROG_TEST);
} else {
qglBindProgramARB(GL_VERTEX_PROGRAM_ARB, VPROG_INTERACTION);
qglBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, FPROG_INTERACTION);
}
qglEnable(GL_VERTEX_PROGRAM_ARB);
qglEnable(GL_FRAGMENT_PROGRAM_ARB);
// enable the vertex arrays
qglEnableVertexAttribArrayARB(8);
qglEnableVertexAttribArrayARB(9);
qglEnableVertexAttribArrayARB(10);
qglEnableVertexAttribArrayARB(11);
qglEnableClientState(GL_COLOR_ARRAY);
// texture 0 is the normalization cube map for the vector towards the light
GL_SelectTextureNoClient(0);
if (backEnd.vLight->lightShader->IsAmbientLight()) {
globalImages->ambientNormalMap->Bind();
} else {
globalImages->normalCubeMapImage->Bind();
}
// texture 6 is the specular lookup table
GL_SelectTextureNoClient(6);
if (r_testARBProgram.GetBool()) {
globalImages->specular2DTableImage->Bind(); // variable specularity in alpha channel
} else {
globalImages->specularTableImage->Bind();
}
for (; surf ; surf=surf->nextOnLight) {
// perform setup here that will not change over multiple interaction passes
// set the vertex pointers
idDrawVert *ac = (idDrawVert *)vertexCache.Position(surf->geo->ambientCache);
qglColorPointer(4, GL_UNSIGNED_BYTE, sizeof(idDrawVert), ac->color);
qglVertexAttribPointerARB(11, 3, GL_FLOAT, false, sizeof(idDrawVert), ac->normal.ToFloatPtr());
qglVertexAttribPointerARB(10, 3, GL_FLOAT, false, sizeof(idDrawVert), ac->tangents[1].ToFloatPtr());
qglVertexAttribPointerARB(9, 3, GL_FLOAT, false, sizeof(idDrawVert), ac->tangents[0].ToFloatPtr());
qglVertexAttribPointerARB(8, 2, GL_FLOAT, false, sizeof(idDrawVert), ac->st.ToFloatPtr());
qglVertexPointer(3, GL_FLOAT, sizeof(idDrawVert), ac->xyz.ToFloatPtr());
// this may cause RB_ARB2_DrawInteraction to be exacuted multiple
// times with different colors and images if the surface or light have multiple layers
RB_CreateSingleDrawInteractions(surf, RB_ARB2_DrawInteraction);
}
qglDisableVertexAttribArrayARB(8);
qglDisableVertexAttribArrayARB(9);
qglDisableVertexAttribArrayARB(10);
qglDisableVertexAttribArrayARB(11);
qglDisableClientState(GL_COLOR_ARRAY);
// disable features
GL_SelectTextureNoClient(6);
globalImages->BindNull();
GL_SelectTextureNoClient(5);
globalImages->BindNull();
GL_SelectTextureNoClient(4);
globalImages->BindNull();
GL_SelectTextureNoClient(3);
globalImages->BindNull();
GL_SelectTextureNoClient(2);
globalImages->BindNull();
GL_SelectTextureNoClient(1);
globalImages->BindNull();
backEnd.glState.currenttmu = -1;
GL_SelectTexture(0);
qglDisable(GL_VERTEX_PROGRAM_ARB);
qglDisable(GL_FRAGMENT_PROGRAM_ARB);
}
/*
=============
RE_StretchRaw
FIXME: not exactly backend
Stretches a raw 32 bit power of 2 bitmap image over the given screen rectangle.
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 ) {
int i, j;
int start, end;
if ( !tr.registered ) {
return;
}
R_IssuePendingRenderCommands();
if ( tess.numIndexes ) {
RB_EndSurface();
}
// we definately want to sync every frame for the cinematics
qglFinish();
start = 0;
if ( r_speeds->integer ) {
start = ri.Milliseconds();
}
// make sure rows and cols are powers of 2
for ( i = 0 ; ( 1 << i ) < cols ; i++ ) {
}
for ( j = 0 ; ( 1 << j ) < rows ; j++ ) {
}
if ( ( 1 << i ) != cols || ( 1 << j ) != rows ) {
ri.Error( ERR_DROP, "Draw_StretchRaw: size not a power of 2: %i by %i", cols, rows );
}
GL_Bind( tr.scratchImage[client] );
// if the scratchImage isn't in the format we want, specify it as a new texture
if ( cols != tr.scratchImage[client]->width || rows != tr.scratchImage[client]->height ) {
tr.scratchImage[client]->width = tr.scratchImage[client]->uploadWidth = cols;
tr.scratchImage[client]->height = tr.scratchImage[client]->uploadHeight = rows;
#ifdef USE_OPENGLES
qglTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, cols, rows, 0, GL_RGBA, GL_UNSIGNED_BYTE, data );
#else
qglTexImage2D( GL_TEXTURE_2D, 0, 3, cols, rows, 0, GL_RGBA, GL_UNSIGNED_BYTE, data );
#endif
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
} else {
if ( dirty ) {
// otherwise, just subimage upload it so that drivers can tell we are going to be changing
// it and don't try and do a texture compression
qglTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, cols, rows, GL_RGBA, GL_UNSIGNED_BYTE, data );
}
}
if ( r_speeds->integer ) {
end = ri.Milliseconds();
ri.Printf( PRINT_ALL, "qglTexSubImage2D %i, %i: %i msec\n", cols, rows, end - start );
}
RB_SetGL2D();
qglColor3f( tr.identityLight, tr.identityLight, tr.identityLight );
#ifdef USE_OPENGLES
GLfloat tex[] = {
0.5f / cols, 0.5f / rows,
( cols - 0.5f ) / cols , 0.5f / rows,
( cols - 0.5f ) / cols, ( rows - 0.5f ) / rows,
0.5f / cols, ( rows - 0.5f ) / rows };
GLfloat vtx[] = {
x, y,
x+w, y,
x+w, y+h,
x, y+h };
GLboolean text = qglIsEnabled(GL_TEXTURE_COORD_ARRAY);
GLboolean glcol = qglIsEnabled(GL_COLOR_ARRAY);
if (glcol)
qglDisableClientState(GL_COLOR_ARRAY);
if (!text)
qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
qglTexCoordPointer( 2, GL_FLOAT, 0, tex );
qglVertexPointer ( 2, GL_FLOAT, 0, vtx );
qglDrawArrays( GL_TRIANGLE_FAN, 0, 4 );
if (!text)
qglDisableClientState( GL_TEXTURE_COORD_ARRAY );
if (glcol)
qglEnableClientState(GL_COLOR_ARRAY);
#else
qglBegin( GL_QUADS );
qglTexCoord2f( 0.5f / cols, 0.5f / rows );
qglVertex2f( x, y );
qglTexCoord2f( ( cols - 0.5f ) / cols, 0.5f / rows );
qglVertex2f( x + w, y );
qglTexCoord2f( ( cols - 0.5f ) / cols, ( rows - 0.5f ) / rows );
qglVertex2f( x + w, y + h );
qglTexCoord2f( 0.5f / cols, ( rows - 0.5f ) / rows );
qglVertex2f( x, y + h );
qglEnd();
#endif
}
/*
* RB_GLSL_StageIteratorGeneric
* Stage iterator for GLSL programs
*/
void RB_GLSL_StageIteratorGeneric(void) {
shaderCommands_t *input;
input = &tess;
/* 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("--- R_GLSL_StageIteratorGeneric( %s ) ---\n", input->shader->name));
}
/* set face culling appropiately */
GL_Cull(input->shader->cullType);
/* set polygon offset if necessary */
if (input->shader->polygonOffset) {
qglEnable(GL_POLYGON_OFFSET_FILL);
qglPolygonOffset(r_offsetFactor->value, r_offsetUnits->value);
}
/* set vertex color array */
qglEnableClientState(GL_COLOR_ARRAY);
qglColorPointer(4, GL_UNSIGNED_BYTE, 0, input->vertexColors);
/* set texture coordinate array 0 */
GL_SelectTexture(0);
qglEnableClientState(GL_TEXTURE_COORD_ARRAY);
qglTexCoordPointer(2, GL_FLOAT, 16, input->texCoords[0][0]);
/* set texture coordinate array 1 */
GL_SelectTexture(1);
qglEnableClientState(GL_TEXTURE_COORD_ARRAY);
qglTexCoordPointer(2, GL_FLOAT, 16, input->texCoords[0][1]);
/* set vertex normal array */
qglEnableClientState(GL_NORMAL_ARRAY);
qglNormalPointer(GL_FLOAT, 16, input->normal);
/* lock XYZ */
qglVertexPointer(3, GL_FLOAT, 16, input->xyz); /* padded SIMD */
if (qglLockArraysEXT) {
qglLockArraysEXT(0, input->numVertexes);
GLimp_LogComment("glLockArraysEXT\n");
}
RB_GLSL_IterateStagesGeneric(input);
/* now do any dynamic lighting needed */
if (input->dlightBits && input->shader->sort <= SS_OPAQUE && !(input->shader->surfaceFlags & (SURF_NODLIGHT | SURF_SKY)))
ProjectDlightTexture();
// <-- RiO_Outlines: now do outlines
RB_OutlinesPass();
// -->
/* now do fog */
if (input->fogNum && input->shader->fogPass)
RB_FogPass(); // TODO: uses svars which aren't set, so move to program
/* unlock arrays */
if (qglUnlockArraysEXT) {
qglUnlockArraysEXT();
GLimp_LogComment("glUnlockArraysExt\n");
}
/* reset polygon offset */
if (input->shader->polygonOffset)
qglDisable(GL_POLYGON_OFFSET_FILL);
}
/*
** RB_StageIteratorVertexLitTexture
*/
void RB_StageIteratorVertexLitTexture( void )
{
shaderCommands_t *input;
shader_t *shader;
input = &tess;
shader = input->shader;
//
// compute colors
//
RB_CalcDiffuseColor( ( unsigned char * ) tess.svars.colors );
//
// 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_StageIteratorVertexLitTexturedUnfogged( %s ) ---\n", tess.shader->name) );
}
//
// set face culling appropriately
//
GL_Cull( input->shader->cullType );
//
// set arrays and lock
//
qglEnableClientState( GL_COLOR_ARRAY);
qglEnableClientState( GL_TEXTURE_COORD_ARRAY);
qglColorPointer( 4, GL_UNSIGNED_BYTE, 0, tess.svars.colors );
qglTexCoordPointer( 2, GL_FLOAT, 16, tess.texCoords[0][0] );
qglVertexPointer (3, GL_FLOAT, 16, input->xyz);
if ( qglLockArraysEXT )
{
qglLockArraysEXT(0, input->numVertexes);
GLimp_LogComment( "glLockArraysEXT\n" );
}
//
// call special shade routine
//
R_BindAnimatedImage( &tess.xstages[0]->bundle[0] );
GL_State( tess.xstages[0]->stateBits );
R_DrawElements( input->numIndexes, input->indexes );
//
// now do any dynamic lighting needed
//
if ( tess.dlightBits && tess.shader->sort <= SS_OPAQUE ) {
ProjectDlightTexture();
}
// <-- RiO_Outlines: now do outlines
RB_OutlinesPass();
// -->
//
// now do fog
//
if ( tess.fogNum && tess.shader->fogPass ) {
RB_FogPass();
}
//
// unlock arrays
//
if (qglUnlockArraysEXT)
{
qglUnlockArraysEXT();
GLimp_LogComment( "glUnlockArraysEXT\n" );
}
}
/**
* Draws simple colored rectangle with given parameters.
*/
void Gui_DrawRect(const GLfloat &x, const GLfloat &y,
const GLfloat &width, const GLfloat &height,
const float colorUpperLeft[], const float colorUpperRight[],
const float colorLowerLeft[], const float colorLowerRight[],
const int &blendMode,
const GLuint texture)
{
switch(blendMode)
{
case BM_HIDE:
return;
case BM_MULTIPLY:
qglBlendFunc(GL_SRC_ALPHA, GL_ONE);
break;
case BM_SIMPLE_SHADE:
qglBlendFunc(GL_ONE_MINUS_SRC_COLOR, GL_ONE_MINUS_SRC_ALPHA);
break;
case BM_SCREEN:
qglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
break;
default:
case BM_OPAQUE:
qglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
break;
};
GLfloat x0 = x;
GLfloat y0 = y + height;
GLfloat x1 = x + width;
GLfloat y1 = y;
GLfloat *v, rectArray[32];
v = rectArray;
*v++ = x0; *v++ = y0;
*v++ = 0.0f; *v++ = 0.0f;
vec4_copy(v, colorUpperLeft);
v += 4;
*v++ = x1; *v++ = y0;
*v++ = 1.0f; *v++ = 0.0f;
vec4_copy(v, colorUpperRight);
v += 4;
*v++ = x1; *v++ = y1;
*v++ = 1.0f; *v++ = 1.0f;
vec4_copy(v, colorLowerRight);
v += 4;
*v++ = x0; *v++ = y1;
*v++ = 0.0f; *v++ = 1.0f;
vec4_copy(v, colorLowerLeft);
if(qglIsTexture(texture))
{
qglBindTexture(GL_TEXTURE_2D, texture);
}
else
{
BindWhiteTexture();
}
qglBindBufferARB(GL_ARRAY_BUFFER, rectBuffer);
qglBufferDataARB(GL_ARRAY_BUFFER, sizeof(GLfloat[32]), rectArray, GL_DYNAMIC_DRAW);
qglVertexPointer(2, GL_FLOAT, 8 * sizeof(GLfloat), (void *)0);
qglTexCoordPointer(2, GL_FLOAT, 8 * sizeof(GLfloat), (void *)sizeof(GLfloat[2]));
qglColorPointer(4, GL_FLOAT, 8 * sizeof(GLfloat), (void *)sizeof(GLfloat[4]));
qglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}
/*
===================
RB_StageIteratorLightmappedMultitexture
===================
*/
void RB_StageIteratorLightmappedMultitexture(void)
{
shaderCommands_t *input = &tess;
shader_t *shader = input->shader;
// 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_StageIteratorLightmappedMultitexture( %s ) ---\n", tess.shader->name));
}
// set GL fog
SetIteratorFog();
// set face culling appropriately
GL_Cull(shader->cullType);
// set color, pointers, and lock
GL_State(GLS_DEFAULT);
qglVertexPointer(3, GL_FLOAT, 16, input->xyz);
#ifdef REPLACE_MODE
qglDisableClientState(GL_COLOR_ARRAY);
qglColor3f(1, 1, 1);
qglShadeModel(GL_FLAT);
#else
qglEnableClientState(GL_COLOR_ARRAY);
qglColorPointer(4, GL_UNSIGNED_BYTE, 0, tess.constantColor255);
#endif
// select base stage
GL_SelectTexture(0);
qglEnableClientState(GL_TEXTURE_COORD_ARRAY);
R_BindAnimatedImage(&tess.xstages[0]->bundle[0]);
qglTexCoordPointer(2, GL_FLOAT, 8, tess.texCoords0);
// configure second stage
GL_SelectTexture(1);
qglEnable(GL_TEXTURE_2D);
if (r_lightmap->integer)
{
GL_TexEnv(GL_REPLACE);
}
else
{
GL_TexEnv(GL_MODULATE);
}
// modified for snooper
if (tess.xstages[0]->bundle[1].isLightmap && (backEnd.refdef.rdflags & RDF_SNOOPERVIEW))
{
GL_Bind(tr.whiteImage);
}
else
{
R_BindAnimatedImage(&tess.xstages[0]->bundle[1]);
}
qglEnableClientState(GL_TEXTURE_COORD_ARRAY);
qglTexCoordPointer(2, GL_FLOAT, 8, tess.texCoords1);
// lock arrays
if (qglLockArraysEXT)
{
qglLockArraysEXT(0, input->numVertexes);
GLimp_LogComment("glLockArraysEXT\n");
}
R_DrawElements(input->numIndexes, input->indexes);
// disable texturing on TEXTURE1, then select TEXTURE0
qglDisable(GL_TEXTURE_2D);
qglDisableClientState(GL_TEXTURE_COORD_ARRAY);
GL_SelectTexture(0);
#ifdef REPLACE_MODE
GL_TexEnv(GL_MODULATE);
qglShadeModel(GL_SMOOTH);
#endif
// now do any dynamic lighting needed
//if ( tess.dlightBits && tess.shader->sort <= SS_OPAQUE )
if (tess.dlightBits && tess.shader->fogPass &&
!(tess.shader->surfaceFlags & (SURF_NODLIGHT | SURF_SKY)))
{
if (r_dynamiclight->integer == 2)
{
DynamicLightPass();
}
else
{
DynamicLightSinglePass();
}
}
// now do fog
if (tess.fogNum && tess.shader->fogPass)
{
RB_FogPass();
}
// unlock arrays
if (qglUnlockArraysEXT)
{
qglUnlockArraysEXT();
GLimp_LogComment("glUnlockArraysEXT\n");
}
}
static void DrawSkySide( struct image_s *image, const int mins[2], const int maxs[2] )
{
int s, t;
GL_Bind( image );
#ifdef HAVE_GLES
GLfloat vtx[3*1024]; // arbitrary sized
GLfloat tex[2*1024];
int idx;
GLboolean text = qglIsEnabled(GL_TEXTURE_COORD_ARRAY);
GLboolean glcol = qglIsEnabled(GL_COLOR_ARRAY);
if (glcol)
qglDisableClientState(GL_COLOR_ARRAY);
if (!text)
qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
#endif
#ifdef _XBOX
int verts = ((maxs[0]+HALF_SKY_SUBDIVISIONS) - (mins[0]+HALF_SKY_SUBDIVISIONS)) * 2 + 2;
#endif
for ( t = mins[1]+HALF_SKY_SUBDIVISIONS; t < maxs[1]+HALF_SKY_SUBDIVISIONS; t++ )
{
#ifdef _XBOX
qglBeginEXT( GL_TRIANGLE_STRIP, verts, 0, 0, verts, 0);
#else
#ifdef HAVE_GLES
idx=0;
#else
qglBegin( GL_TRIANGLE_STRIP );
#endif
#endif
for ( s = mins[0]+HALF_SKY_SUBDIVISIONS; s <= maxs[0]+HALF_SKY_SUBDIVISIONS; s++ )
{
#ifdef HAVE_GLES
memcpy(tex+idx*2, s_skyTexCoords[t][s], sizeof(GLfloat)*2);
memcpy(vtx+idx*3, s_skyPoints[t][s], sizeof(GLfloat)*3);
idx++;
memcpy(tex+idx*2, s_skyTexCoords[t+1][s], sizeof(GLfloat)*2);
memcpy(vtx+idx*3, s_skyPoints[t+1][s], sizeof(GLfloat)*3);
idx++;
#else
qglTexCoord2fv( s_skyTexCoords[t][s] );
qglVertex3fv( s_skyPoints[t][s] );
qglTexCoord2fv( s_skyTexCoords[t+1][s] );
qglVertex3fv( s_skyPoints[t+1][s] );
#endif
}
#ifdef HAVE_GLES
qglVertexPointer (3, GL_FLOAT, 0, vtx);
qglTexCoordPointer(2, GL_FLOAT, 0, tex);
qglDrawArrays(GL_TRIANGLE_STRIP, 0, idx);
#else
qglEnd();
#endif
}
#ifdef HAVE_GLES
if (glcol)
qglEnableClientState(GL_COLOR_ARRAY);
if (!text)
qglDisableClientState( GL_TEXTURE_COORD_ARRAY );
#endif
}
/*
================
DrawTris
Draws triangle outlines for debugging
================
*/
static void DrawTris(shaderCommands_t *input)
{
char *s = r_trisColor->string;
vec4_t trisColor = { 1, 1, 1, 1 };
unsigned int stateBits = 0;
GL_Bind(tr.whiteImage);
if (*s == '0' && (*(s + 1) == 'x' || *(s + 1) == 'X'))
{
s += 2;
if (Q_IsHexColorString(s))
{
trisColor[0] = ((float)(gethex(*(s)) * 16 + gethex(*(s + 1)))) / 255.00;
trisColor[1] = ((float)(gethex(*(s + 2)) * 16 + gethex(*(s + 3)))) / 255.00;
trisColor[2] = ((float)(gethex(*(s + 4)) * 16 + gethex(*(s + 5)))) / 255.00;
if (Q_HexColorStringHasAlpha(s))
{
trisColor[3] = ((float)(gethex(*(s + 6)) * 16 + gethex(*(s + 7)))) / 255.00;
}
}
}
else
{
int i;
char *token;
for (i = 0 ; i < 4 ; i++)
{
token = COM_Parse(&s);
if (token)
{
trisColor[i] = atof(token);
}
else
{
trisColor[i] = 1.f;
}
}
if (!trisColor[3])
{
trisColor[3] = 1.f;
}
}
if (trisColor[3] < 1.f)
{
stateBits |= (GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA);
}
qglColor4fv(trisColor);
if (r_showtris->integer == 2)
{
stateBits |= (GLS_POLYMODE_LINE | GLS_DEPTHMASK_TRUE);
GL_State(stateBits);
qglDepthRange(0, 0);
}
#ifdef CELSHADING_HACK
else if (r_showtris->integer == 3)
{
stateBits |= (GLS_POLYMODE_LINE | GLS_DEPTHMASK_TRUE);
GL_State(stateBits);
qglEnable(GL_POLYGON_OFFSET_LINE);
qglPolygonOffset(4.0, 0.5);
qglLineWidth(5.0);
}
#endif
else
{
stateBits |= (GLS_POLYMODE_LINE);
GL_State(stateBits);
qglEnable(GL_POLYGON_OFFSET_LINE);
qglPolygonOffset(r_offsetFactor->value, r_offsetUnits->value);
}
qglDisableClientState(GL_COLOR_ARRAY);
qglDisableClientState(GL_TEXTURE_COORD_ARRAY);
qglVertexPointer(3, GL_FLOAT, 16, input->xyz); // padded for SIMD
if (qglLockArraysEXT)
{
qglLockArraysEXT(0, input->numVertexes);
GLimp_LogComment("glLockArraysEXT\n");
}
R_DrawElements(input->numIndexes, input->indexes);
if (qglUnlockArraysEXT)
{
qglUnlockArraysEXT();
GLimp_LogComment("glUnlockArraysEXT\n");
}
qglDepthRange(0, 1);
qglDisable(GL_POLYGON_OFFSET_LINE);
}
/*
** RB_StageIteratorGeneric
*/
void RB_StageIteratorGeneric( void ) {
shaderCommands_t *input;
input = &tess;
RB_DeformTessGeometry();
//
// 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_StageIteratorGeneric( %s ) ---\n", tess.shader->name ) );
}
// set GL fog
SetIteratorFog();
if ( qglPNTrianglesiATI && tess.ATI_tess ) {
// RF< so we can send the normals as an array
qglEnableClientState( GL_NORMAL_ARRAY );
#ifdef __MACOS__ //DAJ ATI
qglPNTrianglesiATI( GL_PN_TRIANGLES_ATI, 1 );
#else
qglEnable( GL_PN_TRIANGLES_ATI ); // ATI PN-Triangles extension
#endif
}
//
// set face culling appropriately
//
GL_Cull( input->shader->cullType );
// set polygon offset if necessary
if ( input->shader->polygonOffset ) {
qglEnable( GL_POLYGON_OFFSET_FILL );
qglPolygonOffset( r_offsetFactor->value, r_offsetUnits->value );
}
//
// if there is only a single pass then we can enable color
// and texture arrays before we compile, otherwise we need
// to avoid compiling those arrays since they will change
// during multipass rendering
//
if ( tess.numPasses > 1 || input->shader->multitextureEnv ) {
setArraysOnce = qfalse;
qglDisableClientState( GL_COLOR_ARRAY );
qglDisableClientState( GL_TEXTURE_COORD_ARRAY );
} else
{
setArraysOnce = qtrue;
qglEnableClientState( GL_COLOR_ARRAY );
qglColorPointer( 4, GL_UNSIGNED_BYTE, 0, tess.svars.colors );
qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
qglTexCoordPointer( 2, GL_FLOAT, 0, tess.svars.texcoords[0] );
}
// RF, send normals only if required
// This must be done first, since we can't change the arrays once they have been
// locked
if ( qglPNTrianglesiATI && tess.ATI_tess ) {
qglNormalPointer( GL_FLOAT, 16, input->normal );
}
//
// lock XYZ
//
qglVertexPointer( 3, GL_FLOAT, 16, input->xyz ); // padded for SIMD
if ( qglLockArraysEXT ) {
qglLockArraysEXT( 0, input->numVertexes );
GLimp_LogComment( "glLockArraysEXT\n" );
}
//
// enable color and texcoord arrays after the lock if necessary
//
if ( !setArraysOnce ) {
qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
qglEnableClientState( GL_COLOR_ARRAY );
}
//
// call shader function
//
RB_IterateStagesGeneric( input );
//
// now do any dynamic lighting needed
//
if ( tess.dlightBits && tess.shader->sort <= SS_OPAQUE
&& !( tess.shader->surfaceFlags & ( SURF_NODLIGHT | SURF_SKY ) ) ) {
ProjectDlightTexture();
}
//
// now do fog
//
if ( tess.fogNum && tess.shader->fogPass ) {
RB_FogPass();
}
//
// unlock arrays
//
if ( qglUnlockArraysEXT ) {
qglUnlockArraysEXT();
GLimp_LogComment( "glUnlockArraysEXT\n" );
}
//
// reset polygon offset
//
if ( input->shader->polygonOffset ) {
qglDisable( GL_POLYGON_OFFSET_FILL );
}
// turn truform back off
if ( qglPNTrianglesiATI && tess.ATI_tess ) {
#ifdef __MACOS__ //DAJ ATI
qglPNTrianglesiATI( GL_PN_TRIANGLES_ATI, 0 );
#else
qglDisable( GL_PN_TRIANGLES_ATI ); // ATI PN-Triangles extension
#endif
qglDisableClientState( GL_NORMAL_ARRAY );
}
}
/*
** RB_StageIteratorGeneric
*/
void RB_StageIteratorGeneric( void )
{
shaderCommands_t *input;
shader_t *shader;
input = &tess;
shader = input->shader;
RB_DeformTessGeometry();
//
// 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_StageIteratorGeneric( %s ) ---\n", tess.shader->name) );
}
//
// set face culling appropriately
//
GL_Cull( shader->cullType );
// set polygon offset if necessary
if ( shader->polygonOffset )
{
qglEnable( GL_POLYGON_OFFSET_FILL );
qglPolygonOffset( r_offsetFactor->value, r_offsetUnits->value );
}
//
// if there is only a single pass then we can enable color
// and texture arrays before we compile, otherwise we need
// to avoid compiling those arrays since they will change
// during multipass rendering
//
if ( tess.numPasses > 1 || shader->multitextureEnv )
{
setArraysOnce = qfalse;
qglDisableClientState (GL_COLOR_ARRAY);
qglDisableClientState (GL_TEXTURE_COORD_ARRAY);
}
else
{
setArraysOnce = qtrue;
qglEnableClientState( GL_COLOR_ARRAY);
qglColorPointer( 4, GL_UNSIGNED_BYTE, 0, tess.svars.colors );
qglEnableClientState( GL_TEXTURE_COORD_ARRAY);
qglTexCoordPointer( 2, GL_FLOAT, 0, tess.svars.texcoords[0] );
}
//
// lock XYZ
//
qglVertexPointer (3, GL_FLOAT, 16, input->xyz); // padded for SIMD
if (qglLockArraysEXT)
{
qglLockArraysEXT(0, input->numVertexes);
GLimp_LogComment( "glLockArraysEXT\n" );
}
//
// enable color and texcoord arrays after the lock if necessary
//
if ( !setArraysOnce )
{
qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
qglEnableClientState( GL_COLOR_ARRAY );
}
//
// call shader function
//
RB_IterateStagesGeneric( input );
//
// now do any dynamic lighting needed
//
if ( tess.dlightBits && tess.shader->sort <= SS_OPAQUE
&& !(tess.shader->surfaceFlags & (SURF_NODLIGHT | SURF_SKY) ) ) {
ProjectDlightTexture();
}
//
// now do fog
//
if ( tess.fogNum && tess.shader->fogPass ) {
RB_FogPass();
}
//
// unlock arrays
//
if (qglUnlockArraysEXT)
{
qglUnlockArraysEXT();
GLimp_LogComment( "glUnlockArraysEXT\n" );
}
//
// reset polygon offset
//
if ( shader->polygonOffset )
{
qglDisable( GL_POLYGON_OFFSET_FILL );
}
}
/*
===============
RB_ShowImages
Draw all the images to the screen, on top of whatever
was there. This is used to test for texture thrashing.
Also called by RE_EndRegistration
===============
*/
void RB_ShowImages( void ) {
int i;
image_t *image;
float x, y, w, h;
int start, end;
#ifdef PANDORA
vec2_t texcoords[4] = { {0.0f, 0.0f}, {1.0f, 0.0f}, {1.0f, 1.0f}, {0.0f, 1.0f} };
vec2_t verts[4];
glIndex_t indicies[6] = { 0, 1, 2, 0, 3, 2 };
#endif
if ( !backEnd.projection2D ) {
RB_SetGL2D();
}
qglClear( GL_COLOR_BUFFER_BIT );
qglFinish();
start = ri.Milliseconds();
#ifdef PANDORA
qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
#endif
for ( i=0 ; i<tr.numImages ; i++ ) {
image = tr.images[i];
w = glConfig.vidWidth / 20;
h = glConfig.vidHeight / 15;
x = i % 20 * w;
y = i / 20 * h;
// show in proportional size in mode 2
if ( r_showImages->integer == 2 ) {
w *= image->uploadWidth / 512.0f;
h *= image->uploadHeight / 512.0f;
}
#ifdef PANDORA
verts[0][0] = x; verts[0][1] = y;
verts[1][0] = x+w; verts[1][1] = y;
verts[2][0] = x+w; verts[2][1] = y+h;
verts[3][0] = x; verts[3][1] = y+h;
qglTexCoordPointer( 2, GL_FLOAT, 0, texcoords );
qglVertexPointer ( 2, GL_FLOAT, 0, verts );
qglDrawElements( GL_TRIANGLE_STRIP, 6, GL_INDEX_TYPE, indicies );
#else
GL_Bind( image );
qglBegin (GL_QUADS);
qglTexCoord2f( 0, 0 );
qglVertex2f( x, y );
qglTexCoord2f( 1, 0 );
qglVertex2f( x + w, y );
qglTexCoord2f( 1, 1 );
qglVertex2f( x + w, y + h );
qglTexCoord2f( 0, 1 );
qglVertex2f( x, y + h );
qglEnd();
#endif
}
#ifdef PANDORA
qglDisableClientState( GL_TEXTURE_COORD_ARRAY );
#endif
qglFinish();
end = ri.Milliseconds();
ri.Printf( PRINT_ALL, "%i msec to draw all images\n", end - start );
}
/*
===================
ProjectDlightTexture
Perform dynamic lighting with another rendering pass
===================
*/
static void ProjectDlightTexture2( void ) {
int i, l;
vec3_t origin;
byte clipBits[SHADER_MAX_VERTEXES];
float texCoordsArray[SHADER_MAX_VERTEXES][2];
float oldTexCoordsArray[SHADER_MAX_VERTEXES][2];
float vertCoordsArray[SHADER_MAX_VERTEXES][4];
unsigned int colorArray[SHADER_MAX_VERTEXES];
glIndex_t hitIndexes[SHADER_MAX_INDEXES];
int numIndexes;
float radius;
int fogging;
shaderStage_t *dStage;
vec3_t posa;
vec3_t posb;
vec3_t posc;
vec3_t dist;
vec3_t e1;
vec3_t e2;
vec3_t normal;
float fac,modulate;
vec3_t floatColor;
byte colorTemp[4];
int needResetVerts=0;
if ( !backEnd.refdef.num_dlights )
{
return;
}
for ( l = 0 ; l < backEnd.refdef.num_dlights ; l++ )
{
dlight_t *dl;
if ( !( tess.dlightBits & ( 1 << l ) ) ) {
continue; // this surface definately doesn't have any of this light
}
dl = &backEnd.refdef.dlights[l];
VectorCopy( dl->transformed, origin );
radius = dl->radius;
int clipall = 63;
for ( i = 0 ; i < tess.numVertexes ; i++)
{
int clip;
VectorSubtract( origin, tess.xyz[i], dist );
clip = 0;
if ( dist[0] < -radius )
{
clip |= 1;
}
else if ( dist[0] > radius )
{
clip |= 2;
}
if ( dist[1] < -radius )
{
clip |= 4;
}
else if ( dist[1] > radius )
{
clip |= 8;
}
if ( dist[2] < -radius )
{
clip |= 16;
}
else if ( dist[2] > radius )
{
clip |= 32;
}
clipBits[i] = clip;
clipall &= clip;
}
if ( clipall )
{
continue; // this surface doesn't have any of this light
}
floatColor[0] = dl->color[0] * 255.0f;
floatColor[1] = dl->color[1] * 255.0f;
floatColor[2] = dl->color[2] * 255.0f;
// build a list of triangles that need light
numIndexes = 0;
for ( i = 0 ; i < tess.numIndexes ; i += 3 )
{
int a, b, c;
a = tess.indexes[i];
b = tess.indexes[i+1];
c = tess.indexes[i+2];
if ( clipBits[a] & clipBits[b] & clipBits[c] )
{
continue; // not lighted
}
// copy the vertex positions
VectorCopy(tess.xyz[a],posa);
VectorCopy(tess.xyz[b],posb);
VectorCopy(tess.xyz[c],posc);
VectorSubtract( posa, posb,e1);
VectorSubtract( posc, posb,e2);
CrossProduct(e1,e2,normal);
// rjr - removed for hacking if ( (!r_dlightBacks->integer && DotProduct(normal,origin)-DotProduct(normal,posa) <= 0.0f) || // backface
if ( DotProduct(normal,origin)-DotProduct(normal,posa) <= 0.0f || // backface
DotProduct(normal,normal) < 1E-8f) // junk triangle
{
continue;
}
VectorNormalize(normal);
fac=DotProduct(normal,origin)-DotProduct(normal,posa);
if (fac >= radius) // out of range
{
continue;
}
modulate = 1.0f-((fac*fac) / (radius*radius));
fac = 0.5f/sqrtf(radius*radius - fac*fac);
// save the verts
VectorCopy(posa,vertCoordsArray[numIndexes]);
VectorCopy(posb,vertCoordsArray[numIndexes+1]);
VectorCopy(posc,vertCoordsArray[numIndexes+2]);
// now we need e1 and e2 to be an orthonormal basis
if (DotProduct(e1,e1) > DotProduct(e2,e2))
{
VectorNormalize(e1);
CrossProduct(e1,normal,e2);
}
else
{
VectorNormalize(e2);
CrossProduct(normal,e2,e1);
}
VectorScale(e1,fac,e1);
VectorScale(e2,fac,e2);
VectorSubtract( posa, origin,dist);
texCoordsArray[numIndexes][0]=DotProduct(dist,e1)+0.5f;
texCoordsArray[numIndexes][1]=DotProduct(dist,e2)+0.5f;
VectorSubtract( posb, origin,dist);
texCoordsArray[numIndexes+1][0]=DotProduct(dist,e1)+0.5f;
texCoordsArray[numIndexes+1][1]=DotProduct(dist,e2)+0.5f;
VectorSubtract( posc, origin,dist);
texCoordsArray[numIndexes+2][0]=DotProduct(dist,e1)+0.5f;
texCoordsArray[numIndexes+2][1]=DotProduct(dist,e2)+0.5f;
if ((texCoordsArray[numIndexes][0] < 0.0f && texCoordsArray[numIndexes+1][0] < 0.0f && texCoordsArray[numIndexes+2][0] < 0.0f) ||
(texCoordsArray[numIndexes][0] > 1.0f && texCoordsArray[numIndexes+1][0] > 1.0f && texCoordsArray[numIndexes+2][0] > 1.0f) ||
(texCoordsArray[numIndexes][1] < 0.0f && texCoordsArray[numIndexes+1][1] < 0.0f && texCoordsArray[numIndexes+2][1] < 0.0f) ||
(texCoordsArray[numIndexes][1] > 1.0f && texCoordsArray[numIndexes+1][1] > 1.0f && texCoordsArray[numIndexes+2][1] > 1.0f) )
{
continue; // didn't end up hitting this tri
}
/* old code, get from the svars = wrong
oldTexCoordsArray[numIndexes][0]=tess.svars.texcoords[0][a][0];
oldTexCoordsArray[numIndexes][1]=tess.svars.texcoords[0][a][1];
oldTexCoordsArray[numIndexes+1][0]=tess.svars.texcoords[0][b][0];
oldTexCoordsArray[numIndexes+1][1]=tess.svars.texcoords[0][b][1];
oldTexCoordsArray[numIndexes+2][0]=tess.svars.texcoords[0][c][0];
oldTexCoordsArray[numIndexes+2][1]=tess.svars.texcoords[0][c][1];
*/
oldTexCoordsArray[numIndexes][0]=tess.texCoords[a][0][0];
oldTexCoordsArray[numIndexes][1]=tess.texCoords[a][0][1];
oldTexCoordsArray[numIndexes+1][0]=tess.texCoords[b][0][0];
oldTexCoordsArray[numIndexes+1][1]=tess.texCoords[b][0][1];
oldTexCoordsArray[numIndexes+2][0]=tess.texCoords[c][0][0];
oldTexCoordsArray[numIndexes+2][1]=tess.texCoords[c][0][1];
colorTemp[0] = Q_ftol(floatColor[0] * modulate);
colorTemp[1] = Q_ftol(floatColor[1] * modulate);
colorTemp[2] = Q_ftol(floatColor[2] * modulate);
colorTemp[3] = 255;
byteAlias_t *ba = (byteAlias_t *)&colorTemp;
colorArray[numIndexes + 0] = ba->ui;
colorArray[numIndexes + 1] = ba->ui;
colorArray[numIndexes + 2] = ba->ui;
hitIndexes[numIndexes] = numIndexes;
hitIndexes[numIndexes+1] = numIndexes+1;
hitIndexes[numIndexes+2] = numIndexes+2;
numIndexes += 3;
if (numIndexes>=SHADER_MAX_VERTEXES-3)
{
break; // we are out of space, so we are done :)
}
}
if ( !numIndexes ) {
continue;
}
//don't have fog enabled when we redraw with alpha test, or it will double over
//and screw the tri up -rww
if (r_drawfog->value == 2 &&
tr.world &&
(tess.fogNum == tr.world->globalFog || tess.fogNum == tr.world->numfogs))
{
fogging = qglIsEnabled(GL_FOG);
if (fogging)
{
qglDisable(GL_FOG);
}
}
else
{
fogging = 0;
}
dStage = NULL;
if (tess.shader && qglActiveTextureARB)
{
int i = 0;
while (i < tess.shader->numUnfoggedPasses)
{
const int blendBits = (GLS_SRCBLEND_BITS+GLS_DSTBLEND_BITS);
if (((tess.shader->stages[i].bundle[0].image && !tess.shader->stages[i].bundle[0].isLightmap && !tess.shader->stages[i].bundle[0].numTexMods && tess.shader->stages[i].bundle[0].tcGen != TCGEN_ENVIRONMENT_MAPPED && tess.shader->stages[i].bundle[0].tcGen != TCGEN_FOG) ||
(tess.shader->stages[i].bundle[1].image && !tess.shader->stages[i].bundle[1].isLightmap && !tess.shader->stages[i].bundle[1].numTexMods && tess.shader->stages[i].bundle[1].tcGen != TCGEN_ENVIRONMENT_MAPPED && tess.shader->stages[i].bundle[1].tcGen != TCGEN_FOG)) &&
(tess.shader->stages[i].stateBits & blendBits) == 0 )
{ //only use non-lightmap opaque stages
dStage = &tess.shader->stages[i];
break;
}
i++;
}
}
if (!needResetVerts)
{
needResetVerts=1;
if (qglUnlockArraysEXT)
{
qglUnlockArraysEXT();
GLimp_LogComment( "glUnlockArraysEXT\n" );
}
}
qglVertexPointer (3, GL_FLOAT, 16, vertCoordsArray); // padded for SIMD
if (dStage)
{
GL_SelectTexture( 0 );
GL_State(0);
qglTexCoordPointer( 2, GL_FLOAT, 0, oldTexCoordsArray[0] );
if (dStage->bundle[0].image && !dStage->bundle[0].isLightmap && !dStage->bundle[0].numTexMods && dStage->bundle[0].tcGen != TCGEN_ENVIRONMENT_MAPPED && dStage->bundle[0].tcGen != TCGEN_FOG)
{
R_BindAnimatedImage( &dStage->bundle[0] );
}
else
{
R_BindAnimatedImage( &dStage->bundle[1] );
}
GL_SelectTexture( 1 );
qglEnable( GL_TEXTURE_2D );
qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
qglTexCoordPointer( 2, GL_FLOAT, 0, texCoordsArray[0] );
qglEnableClientState( GL_COLOR_ARRAY );
qglColorPointer( 4, GL_UNSIGNED_BYTE, 0, colorArray );
GL_Bind( tr.dlightImage );
GL_TexEnv( GL_MODULATE );
GL_State(GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE | GLS_DEPTHFUNC_EQUAL);// | GLS_ATEST_GT_0);
R_DrawElements( numIndexes, hitIndexes );
qglDisable( GL_TEXTURE_2D );
GL_SelectTexture(0);
}
else
{
qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
qglTexCoordPointer( 2, GL_FLOAT, 0, texCoordsArray[0] );
qglEnableClientState( GL_COLOR_ARRAY );
qglColorPointer( 4, GL_UNSIGNED_BYTE, 0, colorArray );
GL_Bind( tr.dlightImage );
// include GLS_DEPTHFUNC_EQUAL so alpha tested surfaces don't add light
// where they aren't rendered
if ( dl->additive ) {
GL_State( GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE | GLS_DEPTHFUNC_EQUAL );
}
else {
GL_State( GLS_SRCBLEND_DST_COLOR | GLS_DSTBLEND_ONE | GLS_DEPTHFUNC_EQUAL );
}
R_DrawElements( numIndexes, hitIndexes );
}
if (fogging)
{
qglEnable(GL_FOG);
}
backEnd.pc.c_totalIndexes += numIndexes;
backEnd.pc.c_dlightIndexes += numIndexes;
}
if (needResetVerts)
{
qglVertexPointer (3, GL_FLOAT, 16, tess.xyz); // padded for SIMD
if (qglLockArraysEXT)
{
qglLockArraysEXT(0, tess.numVertexes);
GLimp_LogComment( "glLockArraysEXT\n" );
}
}
}
