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
for ( t = mins[1]+HALF_SKY_SUBDIVISIONS; t < maxs[1]+HALF_SKY_SUBDIVISIONS; t++ )
{
#ifdef HAVE_GLES
idx=0;
#else
qglBegin( GL_TRIANGLE_STRIP );
#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
//*TODO* Try to switch from many DrawArrays of GL_TRIANGLE_STRIP to a single DrawArrays of TRIANGLES to see if it perform better
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
}
/*
===============
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 / 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;
}
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();
*/
GLfloat texcoords[] = { 0.0f, 0.0f, 1.0f, 0.0f, 1.1f, 1.1f, 0.0f, 1.0f };
GLfloat vertices [] = { x, y, x + w, y, x + w, y + h, x, y + h };
qglEnableClientState (GL_VERTEX_ARRAY);
qglEnableClientState (GL_TEXTURE_COORD_ARRAY);
qglVertexPointer ( 2, GL_FLOAT, 0, vertices );
qglTexCoordPointer ( 2, GL_FLOAT, 0, vertices );
qglDrawArrays( GL_TRIANGLE_FAN, 0, 4 );
}
qglFinish();
end = ri.Milliseconds();
ri.Printf( PRINT_ALL, "%i msec to draw all images\n", end - start );
}
void Gui_DrawCrosshair()
{
// TBI: actual ingame crosshair
BindWhiteTexture();
qglBindBufferARB(GL_ARRAY_BUFFER_ARB, crosshairBuffer);
qglVertexPointer(2, GL_FLOAT, 8 * sizeof(GLfloat), (void *)0);
qglColorPointer(4, GL_FLOAT, 8 * sizeof(GLfloat), (void *)sizeof(GLfloat[2]));
qglTexCoordPointer(2, GL_FLOAT, 8 * sizeof(GLfloat), (void *)sizeof(GLfloat[6]));
qglDrawArrays(GL_LINES, 0, 4);
}
/*
=================
RB_ShadowFinish
Darken everything that is is a shadow volume.
We have to delay this until everything has been shadowed,
because otherwise shadows from different body parts would
overlap and double darken.
=================
*/
void RB_ShadowFinish(void)
{
if (r_shadows->integer != 2)
{
return;
}
if (glConfig.stencilBits < 4)
{
return;
}
qglEnable(GL_STENCIL_TEST);
qglStencilFunc(GL_NOTEQUAL, 0, 255);
qglDisable(GL_CLIP_PLANE0);
qglDisable(GL_CULL_FACE);
GL_Bind(tr.whiteImage);
qglLoadIdentity();
qglColor3f(0.6f, 0.6f, 0.6f);
GL_State(GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_DST_COLOR | GLS_DSTBLEND_ZERO);
GLboolean text = qglIsEnabled(GL_TEXTURE_COORD_ARRAY);
GLboolean glcol = qglIsEnabled(GL_COLOR_ARRAY);
if (text)
{
qglDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
if (glcol)
{
qglDisableClientState(GL_COLOR_ARRAY);
}
GLfloat vtx[] =
{
-100, 100, -10,
100, 100, -10,
100, -100, -10,
-100, -100, -10
};
qglVertexPointer(3, GL_FLOAT, 0, vtx);
qglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
if (text)
{
qglEnableClientState(GL_TEXTURE_COORD_ARRAY);
}
if (glcol)
{
qglEnableClientState(GL_COLOR_ARRAY);
}
qglColor4f(1, 1, 1, 1);
qglDisable(GL_STENCIL_TEST);
}
/*
==============
R_DrawSkyBox
==============
*/
void R_DrawSkyBox( void ) {
static const int skytexorder[6] = {0,2,1,3,4,5};
vec5_t verts[4];
int i;
if( skyrotate ) {
// hack, forces full sky to draw when rotating
for( i = 0; i < 6; i++ ) {
skymins[0][i] = -1;
skymins[1][i] = -1;
skymaxs[0][i] = 1;
skymaxs[1][i] = 1;
}
} else {
// check for no sky at all
for( i = 0; i < 6; i++ ) {
if( SKY_VISIBLE( i ) ) {
break;
}
}
if( i == 6 ) {
return; // nothing visible
}
}
qglPushMatrix ();
qglTranslatef (glr.fd.vieworg[0], glr.fd.vieworg[1], glr.fd.vieworg[2]);
if( skyrotate ) {
qglRotatef (glr.fd.time * skyrotate, skyaxis[0], skyaxis[1], skyaxis[2]);
}
GL_TexEnv( GL_REPLACE );
GL_Bits( GLS_DEFAULT );
qglVertexPointer( 3, GL_FLOAT, 5*4, &verts[0][0] );
qglTexCoordPointer( 2, GL_FLOAT, 5*4, &verts[0][3] );
for( i = 0; i < 6; i++ ) {
if( !SKY_VISIBLE( i ) ) {
continue;
}
GL_BindTexture (sky_images[skytexorder[i]]);
MakeSkyVec (skymaxs[0][i], skymins[1][i], i, verts[0]);
MakeSkyVec (skymins[0][i], skymins[1][i], i, verts[1]);
MakeSkyVec (skymaxs[0][i], skymaxs[1][i], i, verts[2]);
MakeSkyVec (skymins[0][i], skymaxs[1][i], i, verts[3]);
qglDrawArrays( GL_TRIANGLE_STRIP, 0, 4 );
}
qglPopMatrix ();
}
static void DrawSkySideInner(struct image_s *image, const int mins[2], const int maxs[2])
{
int s, t;
GL_Bind(image);
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);
}
//qglDisable (GL_BLEND);
qglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
qglEnable(GL_BLEND);
GL_TexEnv(GL_MODULATE);
for (t = mins[1] + HALF_SKY_SUBDIVISIONS; t < maxs[1] + HALF_SKY_SUBDIVISIONS; t++)
{
idx = 0;
for (s = mins[0] + HALF_SKY_SUBDIVISIONS; s <= maxs[0] + HALF_SKY_SUBDIVISIONS; s++)
{
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++;
}
qglVertexPointer(3, GL_FLOAT, 0, vtx);
qglTexCoordPointer(2, GL_FLOAT, 0, tex);
qglDrawArrays(GL_TRIANGLE_STRIP, 0, idx);
}
qglDisable(GL_BLEND);
}
static void DrawSkySide( struct image_s *image, const int mins[2], const int maxs[2] )
{
int s, t;
unsigned i;
vec3_t points[(SKY_SUBDIVISIONS+1) * (SKY_SUBDIVISIONS+1)];
float texcoords[(SKY_SUBDIVISIONS+1) * (SKY_SUBDIVISIONS+1) * 2];
GL_Bind( image );
for ( t = mins[1]+HALF_SKY_SUBDIVISIONS; t < maxs[1]+HALF_SKY_SUBDIVISIONS; t++ )
{
#ifndef GL_VERSION_ES_CM_1_0
qglBegin( GL_TRIANGLE_STRIP );
for ( s = mins[0]+HALF_SKY_SUBDIVISIONS; s <= maxs[0]+HALF_SKY_SUBDIVISIONS; s++ )
{
qglTexCoord2fv( s_skyTexCoords[t][s] );
qglVertex3fv( s_skyPoints[t][s] );
qglTexCoord2fv( s_skyTexCoords[t+1][s] );
qglVertex3fv( s_skyPoints[t+1][s] );
}
qglEnd();
#else
for ( s = mins[0]+HALF_SKY_SUBDIVISIONS, i = 0; s <= maxs[0]+HALF_SKY_SUBDIVISIONS; s++, i += 2 )
{
VectorCopy( s_skyPoints[t][s], points[i] );
VectorCopy( s_skyPoints[t+1][s], points[i+1] );
texcoords[i*2] = s_skyTexCoords[t][s][0];
texcoords[i*2+1] = s_skyTexCoords[t][s][1];
texcoords[i*2+2] = s_skyTexCoords[t+1][s][0];
texcoords[i*2+3] = s_skyTexCoords[t+1][s][1];
}
qglEnableClientState ( GL_VERTEX_ARRAY );
qglEnableClientState ( GL_TEXTURE_COORD_ARRAY );
qglTexCoordPointer ( 2, GL_FLOAT, 0, texcoords );
qglVertexPointer ( 3, GL_FLOAT, 0, points );
qglDrawArrays( GL_TRIANGLE_STRIP, 0, i );
#endif
}
}
/*
================
DrawNormals
Draws vertex normals for debugging
================
*/
static void DrawNormals( shaderCommands_t *input ) {
int i;
vec3_t temp;
GL_Bind( tr.whiteImage );
qglColor3f( 1,1,1 );
qglDepthRange( 0, 0 ); // never occluded
GL_State( GLS_POLYMODE_LINE | GLS_DEPTHMASK_TRUE );
#ifdef USE_OPENGLES
vec3_t vtx[2];
//*TODO* save states for texture & color array
#else
qglBegin( GL_LINES );
#endif
for ( i = 0 ; i < input->numVertexes ; i++ ) {
#ifndef USE_OPENGLES
qglVertex3fv( input->xyz[i] );
#endif
VectorMA( input->xyz[i], 2, input->normal[i], temp );
#ifdef USE_OPENGLES
memcpy(vtx, input->xyz[i], sizeof(GLfloat)*3);
memcpy(vtx+1, temp, sizeof(GLfloat)*3);
qglVertexPointer (3, GL_FLOAT, 16, vtx);
qglDrawArrays(GL_LINES, 0, 2);
#else
qglVertex3fv( temp );
#endif
}
#ifdef USE_OPENGLES
//*TODO* restaure state for texture & color
#else
qglEnd();
#endif
qglDepthRange( 0, 1 );
}
/*
=================
RB_ShadowFinish
Darken everything that is is a shadow volume.
We have to delay this until everything has been shadowed,
because otherwise shadows from different body parts would
overlap and double darken.
=================
*/
void RB_ShadowFinish( void ) {
vec3_t quad[4] = {
{-100.0f, 100.0f, -10.0f},
{ 100.0f, 100.0f, -10.0f},
{ 100.0f, -100.0f, -10.0f},
{-100.0f, -100.0f, -10.0f}
};
if ( r_shadows->integer != 2 ) {
return;
}
if ( glConfig.stencilBits < 4 ) {
return;
}
qglEnable( GL_STENCIL_TEST );
qglStencilFunc( GL_NOTEQUAL, 0, 255 );
qglDisable (GL_CLIP_PLANE0);
qglDisable (GL_CULL_FACE);
GL_Bind( tr.whiteImage );
qglLoadIdentity ();
glColor4f( 0.6f, 0.6f, 0.6f, 1.0f );
GL_State( GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_DST_COLOR | GLS_DSTBLEND_ZERO );
// glColor4f( 1, 0, 0, 1 );
// GL_State( GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_ONE | GLS_DSTBLEND_ZERO );
qglVertexPointer(3, GL_FLOAT, 0, quad);
qglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glColor4f(1,1,1,1);
qglDisable( GL_STENCIL_TEST );
}
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;
qglFogf(GL_FOG_MODE, GL_EXP2);
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
//
qglTexCoordPointer( 2, GL_FLOAT, 0, mTextureCoords );
qglEnableClientState( GL_TEXTURE_COORD_ARRAY);
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;
}
/*
* Interpolates between two frames and origins
*/
void
R_DrawAliasFrameLerp ( dmdl_t *paliashdr, float backlerp )
{
#if defined(VERTEX_ARRAYS)
uint16_t total;
GLenum type;
#endif
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 );
if ( currententity->flags & RF_TRANSLUCENT )
{
alpha = currententity->alpha;
}
else
{
alpha = 1.0;
}
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 ];
R_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 );
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 !defined(VERTEX_ARRAYS)
if ( qglLockArraysEXT != 0 )
{
qglLockArraysEXT( 0, paliashdr->num_xyz );
}
#endif
while ( 1 )
{
/* get the vertex count and primitive type */
count = *order++;
if ( !count )
{
break; /* done */
}
if ( count < 0 )
{
count = -count;
#if defined(VERTEX_ARRAYS)
type = GL_TRIANGLE_FAN;
#else
qglBegin( GL_TRIANGLE_FAN );
#endif
}
else
{
#if defined(VERTEX_ARRAYS)
type = GL_TRIANGLE_STRIP;
#else
qglBegin( GL_TRIANGLE_STRIP );
#endif
}
#if defined(VERTEX_ARRAYS)
total = count;
GLfloat vtx[3*total];
GLfloat tex[2*total];
uint32_t index_vtx = 0;
uint32_t index_tex = 0;
#endif
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;
#if defined(VERTEX_ARRAYS)
vtx[index_vtx++] = s_lerped [ index_xyz ][0];
vtx[index_vtx++] = s_lerped [ index_xyz ][1];
vtx[index_vtx++] = s_lerped [ index_xyz ][2];
#else
qglVertex3fv( s_lerped [ index_xyz ] );
#endif
}
while ( --count );
}
else
{
do
{
#if defined(VERTEX_ARRAYS)
tex[index_tex++] = ( (float *) order ) [ 0 ];
tex[index_tex++] = ( (float *) order ) [ 1 ];
index_xyz = order [ 2 ];
order += 3;
#else
/* texture coordinates come from the draw list */
qglTexCoord2f( ( (float *) order ) [ 0 ], ( (float *) order ) [ 1 ] );
index_xyz = order [ 2 ];
order += 3;
qglArrayElement( index_xyz );
#endif
}
while ( --count );
}
#if defined(VERTEX_ARRAYS)
qglEnableClientState( GL_VERTEX_ARRAY );
qglVertexPointer( 3, GL_FLOAT, 0, vtx );
qglDrawArrays( type, 0, total );
qglDisableClientState( GL_VERTEX_ARRAY );
#else
qglEnd();
#endif
}
#if !defined(VERTEX_ARRAYS)
if ( qglUnlockArraysEXT != 0 )
{
qglUnlockArraysEXT();
}
#endif
}
else
{
while ( 1 )
{
/* get the vertex count and primitive type */
count = *order++;
if ( !count )
{
break; /* done */
}
if ( count < 0 )
{
count = -count;
#if defined(VERTEX_ARRAYS)
type = GL_TRIANGLE_FAN;
#else
qglBegin( GL_TRIANGLE_FAN );
#endif
}
else
{
#if defined(VERTEX_ARRAYS)
type = GL_TRIANGLE_STRIP;
#else
qglBegin( GL_TRIANGLE_STRIP );
#endif
}
#if defined(VERTEX_ARRAYS)
total = count;
GLfloat vtx[3*total];
GLfloat tex[2*total];
GLfloat clr[4*total];
uint32_t index_vtx = 0;
uint32_t index_tex = 0;
uint32_t index_clr = 0;
#endif
if ( currententity->flags & ( RF_SHELL_RED | RF_SHELL_GREEN | RF_SHELL_BLUE ) )
{
do
{
index_xyz = order [ 2 ];
order += 3;
#if defined(VERTEX_ARRAYS)
clr[index_clr++] = shadelight [ 0 ];
clr[index_clr++] = shadelight [ 1 ];
clr[index_clr++] = shadelight [ 2 ];
clr[index_clr++] = alpha;
vtx[index_vtx++] = s_lerped [ index_xyz ][ 0 ];
vtx[index_vtx++] = s_lerped [ index_xyz ][ 1 ];
vtx[index_vtx++] = s_lerped [ index_xyz ][ 2 ];
#else
qglColor4f( shadelight [ 0 ], shadelight [ 1 ], shadelight [ 2 ], alpha );
qglVertex3fv( s_lerped [ index_xyz ] );
#endif
}
while ( --count );
}
else
{
do
{
/* texture coordinates come from the draw list */
#if defined(VERTEX_ARRAYS)
tex[index_tex++] = ( (float *) order ) [ 0 ];
tex[index_tex++] = ( (float *) order ) [ 1 ];
#else
qglTexCoord2f( ( (float *) order ) [ 0 ], ( (float *) order ) [ 1 ] );
#endif
index_xyz = order [ 2 ];
order += 3;
/* normals and vertexes come from the frame list */
l = shadedots [ verts [ index_xyz ].lightnormalindex ];
#if defined(VERTEX_ARRAYS)
clr[index_clr++] = l * shadelight [ 0 ];
clr[index_clr++] = l * shadelight [ 1 ];
clr[index_clr++] = l * shadelight [ 2 ];
clr[index_clr++] = alpha;
vtx[index_vtx++] = s_lerped [ index_xyz ][ 0 ];
vtx[index_vtx++] = s_lerped [ index_xyz ][ 1 ];
vtx[index_vtx++] = s_lerped [ index_xyz ][ 2 ];
#else
qglColor4f( l * shadelight [ 0 ], l * shadelight [ 1 ], l * shadelight [ 2 ], alpha );
qglVertex3fv( s_lerped [ index_xyz ] );
#endif
}
while ( --count );
}
#if defined(VERTEX_ARRAYS)
qglEnableClientState( GL_VERTEX_ARRAY );
qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
qglEnableClientState( GL_COLOR_ARRAY );
qglVertexPointer( 3, GL_FLOAT, 0, vtx );
qglTexCoordPointer( 2, GL_FLOAT, 0, tex );
qglColorPointer( 4, GL_FLOAT, 0, clr );
qglDrawArrays( type, 0, total );
qglDisableClientState( GL_VERTEX_ARRAY );
qglDisableClientState( GL_TEXTURE_COORD_ARRAY );
qglDisableClientState( GL_COLOR_ARRAY );
#else
qglEnd();
#endif
}
}
if ( currententity->flags & ( RF_SHELL_RED | RF_SHELL_GREEN | RF_SHELL_BLUE | RF_SHELL_DOUBLE | RF_SHELL_HALF_DAM ) )
{
qglEnable( GL_TEXTURE_2D );
}
}
void
R_DrawAliasShadow ( dmdl_t *paliashdr, int posenum )
{
#if defined(VERTEX_ARRAYS)
uint16_t total;
GLenum type;
#endif
int *order;
vec3_t point;
float height, lheight;
int count;
lheight = currententity->origin [ 2 ] - lightspot [ 2 ];
height = 0;
order = (int *) ( (byte *) paliashdr + paliashdr->ofs_glcmds );
height = -lheight + 0.1f;
/* stencilbuffer shadows */
if ( have_stencil && gl_stencilshadow->value )
{
qglEnable( GL_STENCIL_TEST );
qglStencilFunc( GL_EQUAL, 1, 2 );
qglStencilOp( GL_KEEP, GL_KEEP, GL_INCR );
}
while ( 1 )
{
/* get the vertex count and primitive type */
count = *order++;
if ( !count )
{
break; /* done */
}
if ( count < 0 )
{
count = -count;
#if defined(VERTEX_ARRAYS)
type = GL_TRIANGLE_FAN;
#else
qglBegin( GL_TRIANGLE_FAN );
#endif
}
else
{
#if defined(VERTEX_ARRAYS)
type = GL_TRIANGLE_STRIP;
#else
qglBegin( GL_TRIANGLE_STRIP );
#endif
}
#if defined(VERTEX_ARRAYS)
total = count;
GLfloat vtx[3*total];
uint32_t index_vtx = 0;
#endif
do
{
/* normals and vertexes come from the frame list */
memcpy( point, s_lerped [ order [ 2 ] ], sizeof ( point ) );
point [ 0 ] -= shadevector [ 0 ] * ( point [ 2 ] + lheight );
point [ 1 ] -= shadevector [ 1 ] * ( point [ 2 ] + lheight );
point [ 2 ] = height;
#if defined(VERTEX_ARRAYS)
vtx[index_vtx++] = point [ 0 ];
vtx[index_vtx++] = point [ 1 ];
vtx[index_vtx++] = point [ 2 ];
#else
qglVertex3fv( point );
#endif
order += 3;
}
while ( --count );
#if defined(VERTEX_ARRAYS)
qglEnableClientState( GL_VERTEX_ARRAY );
qglVertexPointer( 3, GL_FLOAT, 0, vtx );
qglDrawArrays( type, 0, total );
qglDisableClientState( GL_VERTEX_ARRAY );
#else
qglEnd();
#endif
}
/* stencilbuffer shadows */
if ( have_stencil && gl_stencilshadow->value )
{
qglDisable( GL_STENCIL_TEST );
}
}
void glf_render_str(gl_tex_font_p glf, GLfloat x, GLfloat y, const char *text, int32_t n_sym)
{
if(glf && glf->ft_face && text && (text[0] != 0))
{
uint8_t *nch, *ch = (uint8_t*)text;
FT_Vector kern;
int32_t x_pt = 0;
int32_t y_pt = 0;
if(glf->gl_real_tex_indexes_count == 1)
{
GLuint elements_count = 0;
uint32_t curr_utf32, next_utf32;
GLfloat *p, *buffer;
buffer = (GLfloat*)malloc(48 * utf8_strlen(text) * sizeof(GLfloat));
nch = utf8_to_utf32(ch, &curr_utf32);
curr_utf32 = FT_Get_Char_Index(glf->ft_face, curr_utf32);
qglBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
for(p = buffer; *ch && n_sym--;)
{
char_info_p g;
uint8_t *nch2 = utf8_to_utf32(nch, &next_utf32);
next_utf32 = FT_Get_Char_Index(glf->ft_face, next_utf32);
ch = nch;
nch = nch2;
g = glf->glyphs + curr_utf32;
FT_Get_Kerning(glf->ft_face, curr_utf32, next_utf32, FT_KERNING_UNSCALED, &kern); // kern in 1/64 pixel
curr_utf32 = next_utf32;
if(g->tex_index != 0)
{
GLfloat x0 = x + g->left + x_pt / 64.0f;
GLfloat x1 = x0 + g->width;
GLfloat y0 = y + g->top + y_pt / 64.0f;
GLfloat y1 = y0 - g->height;
*p = x0; p++;
*p = y0; p++;
*p = g->tex_x0; p++;
*p = g->tex_y0; p++;
vec4_copy(p, glf->gl_font_color); p += 4;
*p = x1; p++;
*p = y0; p++;
*p = g->tex_x1; p++;
*p = g->tex_y0; p++;
vec4_copy(p, glf->gl_font_color); p += 4;
*p = x1; p++;
*p = y1; p++;
*p = g->tex_x1; p++;
*p = g->tex_y1; p++;
vec4_copy(p, glf->gl_font_color); p += 4;
elements_count++;
*p = x0; p++;
*p = y0; p++;
*p = g->tex_x0; p++;
*p = g->tex_y0; p++;
vec4_copy(p, glf->gl_font_color); p += 4;
*p = x1; p++;
*p = y1; p++;
*p = g->tex_x1; p++;
*p = g->tex_y1; p++;
vec4_copy(p, glf->gl_font_color); p += 4;
*p = x0; p++;
*p = y1; p++;
*p = g->tex_x0; p++;
*p = g->tex_y1; p++;
vec4_copy(p, glf->gl_font_color); p += 4;
elements_count++;
}
x_pt += kern.x + g->advance_x_pt;
y_pt += kern.y + g->advance_y_pt;
}
///RENDER
if(elements_count != 0)
{
qglBindTexture(GL_TEXTURE_2D, glf->gl_tex_indexes[0]);
qglVertexPointer(2, GL_FLOAT, 8 * sizeof(GLfloat), buffer+0);
qglTexCoordPointer(2, GL_FLOAT, 8 * sizeof(GLfloat), buffer+2);
qglColorPointer(4, GL_FLOAT, 8 * sizeof(GLfloat), buffer+4);
qglDrawArrays(GL_TRIANGLES, 0, elements_count * 3);
}
qglBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
free(buffer);
}
else
{
GLfloat *p, buffer[32];
GLuint active_texture = 0;
uint32_t curr_utf32, next_utf32;
nch = utf8_to_utf32(ch, &curr_utf32);
curr_utf32 = FT_Get_Char_Index(glf->ft_face, curr_utf32);
qglBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
for(; *ch && n_sym--;)
{
char_info_p g;
uint8_t *nch2 = utf8_to_utf32(nch, &next_utf32);
next_utf32 = FT_Get_Char_Index(glf->ft_face, next_utf32);
ch = nch;
nch = nch2;
g = glf->glyphs + curr_utf32;
FT_Get_Kerning(glf->ft_face, curr_utf32, next_utf32, FT_KERNING_UNSCALED, &kern); // kern in 1/64 pixel
curr_utf32 = next_utf32;
if(g->tex_index != 0)
{
///RENDER
GLfloat x0 = x + g->left + x_pt / 64.0f;
GLfloat x1 = x0 + g->width;
GLfloat y0 = y + g->top + y_pt / 64.0f;
GLfloat y1 = y0 - g->height;
p = buffer;
*p = x0; p++;
*p = y0; p++;
*p = g->tex_x0; p++;
*p = g->tex_y0; p++;
vec4_copy(p, glf->gl_font_color); p += 4;
*p = x1; p++;
*p = y0; p++;
*p = g->tex_x1; p++;
*p = g->tex_y0; p++;
vec4_copy(p, glf->gl_font_color); p += 4;
*p = x1; p++;
*p = y1; p++;
*p = g->tex_x1; p++;
*p = g->tex_y1; p++;
vec4_copy(p, glf->gl_font_color); p += 4;
*p = x0; p++;
*p = y1; p++;
*p = g->tex_x0; p++;
*p = g->tex_y1; p++;
vec4_copy(p, glf->gl_font_color);
if(active_texture != g->tex_index)
{
qglBindTexture(GL_TEXTURE_2D, g->tex_index);
active_texture = g->tex_index;
}
qglVertexPointer(2, GL_FLOAT, 8 * sizeof(GLfloat), buffer+0);
qglTexCoordPointer(2, GL_FLOAT, 8 * sizeof(GLfloat), buffer+2);
qglColorPointer(4, GL_FLOAT, 8 * sizeof(GLfloat), buffer+4);
qglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}
x_pt += kern.x + g->advance_x_pt;
y_pt += kern.y + g->advance_y_pt;
}
}
}
}
void RB_DistortionFill(void)
{
float alpha = tr_distortionAlpha;
float spost = 0.0f;
float spost2 = 0.0f;
if ( glConfig.stencilBits < 4 )
{
return;
}
//ok, cap the stupid thing now I guess
if (!tr_distortionPrePost)
{
RB_CaptureScreenImage();
}
qglEnable(GL_STENCIL_TEST);
qglStencilFunc(GL_NOTEQUAL, 0, 0xFFFFFFFF);
qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
qglDisable (GL_CLIP_PLANE0);
GL_Cull( CT_TWO_SIDED );
//reset the view matrices and go into ortho mode
qglMatrixMode(GL_PROJECTION);
qglPushMatrix();
qglLoadIdentity();
qglOrtho(0, glConfig.vidWidth, glConfig.vidHeight, 32, -1, 1);
qglMatrixMode(GL_MODELVIEW);
qglPushMatrix();
qglLoadIdentity();
if (tr_distortionStretch)
{ //override
spost = tr_distortionStretch;
spost2 = tr_distortionStretch;
}
else
{ //do slow stretchy effect
spost = sin(tr.refdef.time*0.0005f);
if (spost < 0.0f)
{
spost = -spost;
}
spost *= 0.2f;
spost2 = sin(tr.refdef.time*0.0005f);
if (spost2 < 0.0f)
{
spost2 = -spost2;
}
spost2 *= 0.08f;
}
if (alpha != 1.0f)
{ //blend
GL_State(GLS_SRCBLEND_SRC_ALPHA|GLS_DSTBLEND_SRC_ALPHA);
}
else
{ //be sure to reset the draw state
GL_State(0);
}
#ifdef HAVE_GLES
qglColor4f(1.0f, 1.0f, 1.0f, alpha);
GLboolean text = qglIsEnabled(GL_TEXTURE_COORD_ARRAY);
GLboolean glcol = qglIsEnabled(GL_COLOR_ARRAY);
if (!text)
qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
if (glcol)
qglDisableClientState( GL_COLOR_ARRAY );
GLfloat tex[] = {
0+spost2, 1-spost,
0+spost2, 0+spost,
1-spost2, 0+spost,
1-spost2, 1-spost
};
GLfloat vtx[] = {
0, 0,
0, glConfig.vidHeight,
glConfig.vidWidth, glConfig.vidHeight,
glConfig.vidWidth, 0
};
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
qglBegin(GL_QUADS);
qglColor4f(1.0f, 1.0f, 1.0f, alpha);
qglTexCoord2f(0+spost2, 1-spost);
qglVertex2f(0, 0);
qglTexCoord2f(0+spost2, 0+spost);
qglVertex2f(0, glConfig.vidHeight);
qglTexCoord2f(1-spost2, 0+spost);
qglVertex2f(glConfig.vidWidth, glConfig.vidHeight);
qglTexCoord2f(1-spost2, 1-spost);
qglVertex2f(glConfig.vidWidth, 0);
qglEnd();
#endif
if (tr_distortionAlpha == 1.0f && tr_distortionStretch == 0.0f)
{ //no overrides
if (tr_distortionNegate)
{ //probably the crazy alternate saber trail
alpha = 0.8f;
GL_State(GLS_SRCBLEND_ZERO|GLS_DSTBLEND_ONE_MINUS_SRC_COLOR);
}
else
{
alpha = 0.5f;
GL_State(GLS_SRCBLEND_SRC_ALPHA|GLS_DSTBLEND_SRC_ALPHA);
}
spost = sin(tr.refdef.time*0.0008f);
if (spost < 0.0f)
{
spost = -spost;
}
spost *= 0.08f;
spost2 = sin(tr.refdef.time*0.0008f);
if (spost2 < 0.0f)
{
spost2 = -spost2;
}
spost2 *= 0.2f;
#ifdef HAVE_GLES
qglColor4f(1.0f, 1.0f, 1.0f, alpha);
/* GLboolean text = qglIsEnabled(GL_TEXTURE_COORD_ARRAY);
GLboolean glcol = qglIsEnabled(GL_COLOR_ARRAY);
if (!text)
qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
if (glcol)
qglDisableClientState( GL_COLOR_ARRAY );*/
GLfloat tex[] = {
0+spost2, 1-spost,
0+spost2, 0+spost,
1-spost2, 0+spost,
1-spost2, 1-spost
};
GLfloat vtx[] = {
0, 0,
0, glConfig.vidHeight,
glConfig.vidWidth, glConfig.vidHeight,
glConfig.vidWidth, 0
};
qglTexCoordPointer( 2, GL_FLOAT, 0, tex );
qglVertexPointer ( 2, GL_FLOAT, 0, vtx );
qglDrawArrays( GL_TRIANGLE_FAN, 0, 4 );
#else
qglBegin(GL_QUADS);
qglColor4f(1.0f, 1.0f, 1.0f, alpha);
qglTexCoord2f(0+spost2, 1-spost);
qglVertex2f(0, 0);
qglTexCoord2f(0+spost2, 0+spost);
qglVertex2f(0, glConfig.vidHeight);
qglTexCoord2f(1-spost2, 0+spost);
qglVertex2f(glConfig.vidWidth, glConfig.vidHeight);
qglTexCoord2f(1-spost2, 1-spost);
qglVertex2f(glConfig.vidWidth, 0);
qglEnd();
#endif
}
#ifdef HAVE_GLES
if (glcol)
qglEnableClientState( GL_COLOR_ARRAY );
if (!text)
qglDisableClientState( GL_TEXTURE_COORD_ARRAY );
#endif
//pop the view matrices back
qglMatrixMode(GL_PROJECTION);
qglPopMatrix();
qglMatrixMode(GL_MODELVIEW);
qglPopMatrix();
qglDisable( GL_STENCIL_TEST );
}
/**
* @note Unused.
*/
void RB_DrawBounds(vec3_t mins, vec3_t maxs)
{
vec3_t center;
GL_Bind(tr.whiteImage);
GL_State(GLS_POLYMODE_LINE);
// box corners
GLboolean text = qglIsEnabled(GL_TEXTURE_COORD_ARRAY);
GLboolean glcol = qglIsEnabled(GL_COLOR_ARRAY);
if (glcol)
{
qglDisableClientState(GL_COLOR_ARRAY);
}
if (text)
{
qglDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
GLfloat vtx1[] =
{
mins[0], mins[1], mins[2],
maxs[0], mins[1], mins[2],
mins[0], mins[1], mins[2],
mins[0], maxs[1], mins[2],
mins[0], mins[1], mins[2],
mins[0], mins[1], maxs[2],
maxs[0], maxs[1], maxs[2],
mins[0], maxs[1], maxs[2],
maxs[0], maxs[1], maxs[2],
maxs[0], mins[1], maxs[2],
maxs[0], maxs[1], maxs[2],
maxs[0], maxs[1], mins[2]
};
qglColor3f(1, 1, 1);
qglVertexPointer(3, GL_FLOAT, 0, vtx1);
qglDrawArrays(GL_LINES, 0, 12);
center[0] = (mins[0] + maxs[0]) * 0.5;
center[1] = (mins[1] + maxs[1]) * 0.5;
center[2] = (mins[2] + maxs[2]) * 0.5;
// center axis
GLfloat vtx2[] =
{
mins[0], center[1], center[2],
maxs[0], center[1], center[2],
center[0], mins[1], center[2],
center[0], maxs[1], center[2],
center[0], center[1], mins[2],
center[0], center[1], maxs[2]
};
qglColor3f(1, 0.85, 0);
qglVertexPointer(3, GL_FLOAT, 0, vtx2);
qglDrawArrays(GL_LINES, 0, 6);
if (glcol)
{
qglEnableClientState(GL_COLOR_ARRAY);
}
if (text)
{
qglEnableClientState(GL_TEXTURE_COORD_ARRAY);
}
}
/**
* 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_ShadowFinish
Darken everything that is is a shadow volume.
We have to delay this until everything has been shadowed,
because otherwise shadows from different body parts would
overlap and double darken.
=================
*/
void RB_ShadowFinish( void ) {
if ( r_shadows->integer != 2 ) {
return;
}
if ( glConfig.stencilBits < 4 ) {
return;
}
#ifdef _DEBUG_STENCIL_SHADOWS
return;
#endif
qglEnable( GL_STENCIL_TEST );
qglStencilFunc( GL_NOTEQUAL, 0, 255 );
qglStencilOp( GL_KEEP, GL_KEEP, GL_KEEP );
bool planeZeroBack = false;
if (qglIsEnabled(GL_CLIP_PLANE0))
{
planeZeroBack = true;
qglDisable (GL_CLIP_PLANE0);
}
GL_Cull(CT_TWO_SIDED);
//qglDisable (GL_CULL_FACE);
GL_Bind( tr.whiteImage );
qglPushMatrix();
qglLoadIdentity ();
// qglColor3f( 0.6f, 0.6f, 0.6f );
// GL_State( GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_DST_COLOR | GLS_DSTBLEND_ZERO );
// qglColor3f( 1, 0, 0 );
// GL_State( GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_ONE | GLS_DSTBLEND_ZERO );
qglColor4f( 0.0f, 0.0f, 0.0f, 0.5f );
//GL_State( GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
GL_State( GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
#ifdef HAVE_GLES
GLfloat vtx[] = {
-100, 100, -10,
100, 100, -10,
100, -100, -10,
-100, -100, -10
};
GLboolean text = qglIsEnabled(GL_TEXTURE_COORD_ARRAY);
GLboolean glcol = qglIsEnabled(GL_COLOR_ARRAY);
if (text)
qglDisableClientState( GL_TEXTURE_COORD_ARRAY );
if (glcol)
qglDisableClientState( GL_COLOR_ARRAY );
qglVertexPointer ( 3, GL_FLOAT, 0, vtx );
qglDrawArrays( GL_TRIANGLE_FAN, 0, 4 );
if (text)
qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
if (glcol)
qglEnableClientState( GL_COLOR_ARRAY );
#else
qglBegin( GL_QUADS );
qglVertex3f( -100, 100, -10 );
qglVertex3f( 100, 100, -10 );
qglVertex3f( 100, -100, -10 );
qglVertex3f( -100, -100, -10 );
qglEnd ();
#endif
qglColor4f(1,1,1,1);
qglDisable( GL_STENCIL_TEST );
if (planeZeroBack)
{
qglEnable (GL_CLIP_PLANE0);
}
qglPopMatrix();
}
/*
===============
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 );
}
void CQuickSpriteSystem::Flush(void)
{
if (mNextVert==0)
{
return;
}
//
// render the main pass
//
R_BindAnimatedImage( mTexBundle );
GL_State(mGLStateBits);
//
// set arrays and lock
//
qglTexCoordPointer( 2, GL_FLOAT, 0, mTextureCoords );
qglEnableClientState( GL_TEXTURE_COORD_ARRAY);
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;
if (mUseFog)
{
//
// 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 *)&mFogColor);
// 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;
}
/*
=============
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
}
