/*
=============
Draw_TileClear
This repeats a 64*64 tile graphic to fill the screen around a sized down
refresh window.
=============
*/
void Draw_TileClear (int x, int y, int w, int h, char *pic)
{
image_t *image;
image = Draw_FindPic (pic);
if (!image)
{
ri.Con_Printf (PRINT_ALL, "Can't find pic: %s\n", pic);
return;
}
if ( ( ( gl_config.renderer == GL_RENDERER_MCD ) || ( gl_config.renderer & GL_RENDERER_RENDITION ) ) && !image->has_alpha)
qglDisable (GL_ALPHA_TEST);
GL_Bind (image->texnum);
qglBegin (GL_QUADS);
qglTexCoord2f (x/64.0, y/64.0);
qglVertex2f (x, y);
qglTexCoord2f ( (x+w)/64.0, y/64.0);
qglVertex2f (x+w, y);
qglTexCoord2f ( (x+w)/64.0, (y+h)/64.0);
qglVertex2f (x+w, y+h);
qglTexCoord2f ( x/64.0, (y+h)/64.0 );
qglVertex2f (x, y+h);
qglEnd ();
if ( ( ( gl_config.renderer == GL_RENDERER_MCD ) || ( gl_config.renderer & GL_RENDERER_RENDITION ) ) && !image->has_alpha)
qglEnable (GL_ALPHA_TEST);
}
/*
=============
Draw_Pic
=============
*/
void Draw_Pic (int x, int y, char *pic)
{
image_t *gl;
gl = Draw_FindPic (pic);
if (!gl)
{
ri.Con_Printf (PRINT_ALL, "Can't find pic: %s\n", pic);
return;
}
if (scrap_dirty)
Scrap_Upload ();
if ( ( ( gl_config.renderer == GL_RENDERER_MCD ) || ( gl_config.renderer & GL_RENDERER_RENDITION ) ) && !gl->has_alpha)
qglDisable (GL_ALPHA_TEST);
GL_Bind (gl->texnum);
qglBegin (GL_QUADS);
qglTexCoord2f (gl->sl, gl->tl);
qglVertex2f (x, y);
qglTexCoord2f (gl->sh, gl->tl);
qglVertex2f (x+gl->width, y);
qglTexCoord2f (gl->sh, gl->th);
qglVertex2f (x+gl->width, y+gl->height);
qglTexCoord2f (gl->sl, gl->th);
qglVertex2f (x, y+gl->height);
qglEnd ();
if ( ( ( gl_config.renderer == GL_RENDERER_MCD ) || ( gl_config.renderer & GL_RENDERER_RENDITION ) ) && !gl->has_alpha)
qglEnable (GL_ALPHA_TEST);
}
static void ID_INLINE R_Bloom_Quad_Lens(float offsert, int width, int height, float texX, float texY, float texWidth, float texHeight) {
int x = 0;
int y = 0;
x = 0;
y += glConfig.vidHeight - height;
width += x;
height += y;
offsert = offsert * 9; // bah
texWidth -= texX;
texHeight -= texY;
qglBegin( GL_QUADS );
qglTexCoord2f( texX, texHeight );
qglVertex2f( width + offsert, height + offsert );
qglTexCoord2f( texX, texY );
qglVertex2f( width + offsert, y - offsert);
qglTexCoord2f( texWidth, texY );
qglVertex2f( x - offsert, y - offsert);
qglTexCoord2f( texWidth, texHeight );
qglVertex2f( x - offsert, height + offsert);
qglEnd ();
}
/*
=============
Draw_Fill
Fills a box of pixels with a single color
=============
*/
void Draw_Fill (int x, int y, int w, int h, int c)
{
union
{
unsigned c;
byte v[4];
} color;
if ( (unsigned)c > 255)
ri.Sys_Error (ERR_FATAL, "Draw_Fill: bad color");
qglDisable (GL_TEXTURE_2D);
color.c = d_8to24table[c];
qglColor3f (color.v[0]/255.0,
color.v[1]/255.0,
color.v[2]/255.0);
qglBegin (GL_QUADS);
qglVertex2f (x,y);
qglVertex2f (x+w, y);
qglVertex2f (x+w, y+h);
qglVertex2f (x, y+h);
qglEnd ();
qglColor3f (1,1,1);
qglEnable (GL_TEXTURE_2D);
}
static void ID_INLINE R_Bloom_Quad( int width, int height, float texX, float texY, float texWidth, float texHeight ) {
int x = 0;
int y = 0;
x = 0;
y += glConfig.vidHeight - height;
width += x;
height += y;
texWidth += texX;
texHeight += texY;
qglBegin( GL_QUADS );
qglTexCoord2f( texX, texHeight );
qglVertex2f( x, y );
qglTexCoord2f( texX, texY );
qglVertex2f( x, height );
qglTexCoord2f( texWidth, texY );
qglVertex2f( width, height );
qglTexCoord2f( texWidth, texHeight );
qglVertex2f( width, y );
qglEnd ();
}
/*
================
Draw_Char
Draws one 8*8 graphics character with 0 being transparent.
It can be clipped to the top of the screen to allow the console to be
smoothly scrolled off.
================
*/
void Draw_Char (int x, int y, int num)
{
int row, col;
float frow, fcol, size;
num &= 255;
if ( (num&127) == 32 )
return; // space
if (y <= -8)
return; // totally off screen
row = num>>4;
col = num&15;
frow = row*0.0625;
fcol = col*0.0625;
size = 0.0625;
GL_Bind (draw_chars->texnum);
qglBegin (GL_QUADS);
qglTexCoord2f (fcol, frow);
qglVertex2f (x, y);
qglTexCoord2f (fcol + size, frow);
qglVertex2f (x+8, y);
qglTexCoord2f (fcol + size, frow + size);
qglVertex2f (x+8, y+8);
qglTexCoord2f (fcol, frow + size);
qglVertex2f (x, y+8);
qglEnd ();
}
/*
* ================ Draw_Char
*
* Draws one 8*8 graphics character with 0 being transparent. It can be clipped
* to the top of the screen to allow the console to be smoothly scrolled off.
* ================
*/
void
Draw_Char(int x, int y, int num, int alpha)
{
int row, col;
float frow, fcol, size;
num &= 255;
if (alpha >= 254)
alpha = 254;
else if (alpha <= 1)
alpha = 1;
if ((num & 127) == 32)
return; /* space */
if (y <= -8)
return; /* totally off screen */
row = num >> 4;
col = num & 15;
frow = row * 0.0625;
fcol = col * 0.0625;
size = 0.0625;
{
/* GLSTATE_DISABLE_ALPHATEST */
qglDisable(GL_ALPHA_TEST);
GL_TexEnv(GL_MODULATE);
qglColor4ub(255, 255, 255, alpha);
/* GLSTATE_ENABLE_BLEND */
qglEnable(GL_BLEND);
qglDepthMask(false);
}
GL_Bind(draw_chars->texnum);
qglBegin(GL_QUADS);
qglTexCoord2f(fcol, frow);
qglVertex2f(x, y);
qglTexCoord2f(fcol + size, frow);
qglVertex2f(x + 8, y);
qglTexCoord2f(fcol + size, frow + size);
qglVertex2f(x + 8, y + 8);
qglTexCoord2f(fcol, frow + size);
qglVertex2f(x, y + 8);
qglEnd();
{
qglDepthMask(true);
GL_TexEnv(GL_REPLACE);
/* GLSTATE_DISABLE_BLEND */
qglDisable(GL_BLEND);
qglColor4f(1,1,1,1);
/* GLSTATE_ENABLE_ALPHATEST */
qglEnable(GL_ALPHA_TEST);
}
}
/*
==================
RB_STD_LightScale
Perform extra blending passes to multiply the entire buffer by
a floating point value
==================
*/
void RB_STD_LightScale( void ) {
float v, f;
if ( backEnd.overBright == 1.0f ) {
return;
}
if ( r_skipLightScale.GetBool() ) {
return;
}
// the scissor may be smaller than the viewport for subviews
if ( r_useScissor.GetBool() ) {
qglScissor( backEnd.viewDef->viewport.x1 + backEnd.viewDef->scissor.x1,
backEnd.viewDef->viewport.y1 + backEnd.viewDef->scissor.y1,
backEnd.viewDef->scissor.x2 - backEnd.viewDef->scissor.x1 + 1,
backEnd.viewDef->scissor.y2 - backEnd.viewDef->scissor.y1 + 1 );
backEnd.currentScissor = backEnd.viewDef->scissor;
}
// full screen blends
qglLoadIdentity();
qglMatrixMode( GL_PROJECTION );
qglPushMatrix();
qglLoadIdentity();
qglOrtho( 0, 1, 0, 1, -1, 1 );
GL_State( GLS_SRCBLEND_DST_COLOR | GLS_DSTBLEND_SRC_COLOR );
GL_Cull( CT_TWO_SIDED ); // so mirror views also get it
globalImages->BindNull();
qglDisable( GL_DEPTH_TEST );
qglDisable( GL_STENCIL_TEST );
v = 1;
while ( idMath::Fabs( v - backEnd.overBright ) > 0.01 ) { // a little extra slop
f = backEnd.overBright / v;
f /= 2;
if ( f > 1 ) {
f = 1;
}
qglColor3f( f, f, f );
v = v * f * 2;
qglBegin( GL_QUADS );
qglVertex2f( 0,0 );
qglVertex2f( 0,1 );
qglVertex2f( 1,1 );
qglVertex2f( 1,0 );
qglEnd();
}
qglPopMatrix();
qglEnable( GL_DEPTH_TEST );
qglMatrixMode( GL_MODELVIEW );
GL_Cull( CT_FRONT_SIDED );
}
/*
=============
RB_DrawRotatePic2
=============
*/
const void *RB_RotatePic2 ( const void *data )
{
const rotatePicCommand_t *cmd;
image_t *image;
shader_t *shader;
cmd = (const rotatePicCommand_t *)data;
shader = cmd->shader;
if ( shader->stages[0] )
{
image = shader->stages[0]->bundle[0].image[0];
if ( image )
{
if ( !backEnd.projection2D )
{
RB_SetGL2D();
}
// Get our current blend mode, etc.
GL_State( shader->stages[0]->stateBits );
qglColor4ubv( backEnd.color2D );
qglPushMatrix();
// rotation point is going to be around the center of the passed in coordinates
qglTranslatef( cmd->x, cmd->y, 0 );
qglRotatef( cmd->a, 0.0, 0.0, 1.0 );
GL_Bind( image );
qglBegin( GL_QUADS );
qglTexCoord2f( cmd->s1, cmd->t1);
qglVertex2f( -cmd->w * 0.5f, -cmd->h * 0.5f );
qglTexCoord2f( cmd->s2, cmd->t1 );
qglVertex2f( cmd->w * 0.5f, -cmd->h * 0.5f );
qglTexCoord2f( cmd->s2, cmd->t2 );
qglVertex2f( cmd->w * 0.5f, cmd->h * 0.5f );
qglTexCoord2f( cmd->s1, cmd->t2 );
qglVertex2f( -cmd->w * 0.5f, cmd->h * 0.5f );
qglEnd();
qglPopMatrix();
// Hmmm, this is not too cool
GL_State( GLS_DEPTHTEST_DISABLE |
GLS_SRCBLEND_SRC_ALPHA |
GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
}
}
return (const void *)(cmd + 1);
}
/*
===============
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;
}
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();
}
qglFinish();
end = ri.Milliseconds();
ri.Printf(PRINT_ALL, "%i msec to draw all images\n", end - start);
}
/*
* ============= Draw_StretchPic -- only used for drawing console...
* =============
*/
void
Draw_StretchPic(int x, int y, int w, int h, char *pic, float alpha)
{
image_t *gl;
gl = Draw_FindPic(pic);
if (!gl) {
ri.Con_Printf(PRINT_ALL, "Can't find pic: %s\n", pic);
return;
}
if (scrap_dirty)
Scrap_Upload();
if (((gl_config.renderer == GL_RENDERER_MCD) || (gl_config.renderer & GL_RENDERER_RENDITION))
&& !gl->has_alpha)
qglDisable(GL_ALPHA_TEST);
/* add alpha support */
if (gl->has_alpha || alpha < 1) {
qglDisable(GL_ALPHA_TEST);
GL_Bind(gl->texnum);
GL_TexEnv(GL_MODULATE);
qglColor4f(1, 1, 1, alpha);
qglEnable(GL_BLEND);
qglDepthMask(false);
} else
GL_Bind(gl->texnum);
qglBegin(GL_QUADS);
qglTexCoord2f(gl->sl, gl->tl);
qglVertex2f(x, y);
qglTexCoord2f(gl->sh, gl->tl);
qglVertex2f(x + w, y);
qglTexCoord2f(gl->sh, gl->th);
qglVertex2f(x + w, y + h);
qglTexCoord2f(gl->sl, gl->th);
qglVertex2f(x, y + h);
qglEnd();
/* add alpha support */
if (gl->has_alpha || alpha < 1) {
qglDepthMask(true);
GL_TexEnv(GL_REPLACE);
qglDisable(GL_BLEND);
qglColor4f(1, 1, 1, 1);
qglEnable(GL_ALPHA_TEST);
}
if (((gl_config.renderer == GL_RENDERER_MCD) || (gl_config.renderer & GL_RENDERER_RENDITION))
&& !gl->has_alpha)
qglEnable(GL_ALPHA_TEST);
}
/*
* ============= Draw_Pic =============
*/
void
Draw_Pic(int x, int y, char *pic, float alpha)
{
image_t *gl;
gl = Draw_FindPic(pic);
if (!gl) {
ri.Con_Printf(PRINT_ALL, "Can't find pic: %s\n", pic);
return;
}
if (scrap_dirty)
Scrap_Upload();
if (((gl_config.renderer == GL_RENDERER_MCD) || (gl_config.renderer & GL_RENDERER_RENDITION)) && !gl->has_alpha)
qglDisable(GL_ALPHA_TEST);
/* add alpha support */
{
qglDisable(GL_ALPHA_TEST);
qglBindTexture(GL_TEXTURE_2D, gl->texnum);
GL_TexEnv(GL_MODULATE);
qglColor4f(1, 1, 1, 0.999); /* need <1 for trans to work */
qglEnable(GL_BLEND);
qglDepthMask(false);
}
GL_Bind(gl->texnum);
qglBegin(GL_QUADS);
qglTexCoord2f(gl->sl, gl->tl);
qglVertex2f(x, y);
qglTexCoord2f(gl->sh, gl->tl);
qglVertex2f(x + gl->width, y);
qglTexCoord2f(gl->sh, gl->th);
qglVertex2f(x + gl->width, y + gl->height);
qglTexCoord2f(gl->sl, gl->th);
qglVertex2f(x, y + gl->height);
qglEnd();
/* add alpha support */
{
qglDepthMask(true);
GL_TexEnv(GL_REPLACE);
qglDisable(GL_BLEND);
qglColor4f(1, 1, 1, 1);
qglEnable(GL_ALPHA_TEST);
}
if (((gl_config.renderer == GL_RENDERER_MCD) || (gl_config.renderer & GL_RENDERER_RENDITION)) && !gl->has_alpha)
qglEnable(GL_ALPHA_TEST);
}
/*
===============
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 ) {
image_t *image;
float x, y, w, h;
int start, end;
if ( !backEnd.projection2D ) {
RB_SetGL2D();
}
qglFinish();
start = Sys_Milliseconds();
int i=0;
// int iNumImages =
R_Images_StartIteration();
while ( (image = R_Images_GetNextIteration()) != NULL)
{
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->width / 512.0;
h *= image->height / 512.0;
}
GL_Bind( image );
#ifdef _XBOX
qglBeginEXT (GL_QUADS, 4, 0, 0, 4, 0);
#else
qglBegin (GL_QUADS);
#endif
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();
i++;
}
qglFinish();
end = Sys_Milliseconds();
//VID_Printf( PRINT_ALL, "%i msec to draw all images\n", end - start );
}
/*
* R_Bloom_Quad
*/
static inline void R_Bloom_Quad( int x, int y, int w, int h, float texwidth, float texheight )
{
qglBegin( GL_QUADS );
qglTexCoord2f( 0, texheight );
qglVertex2f( x, glState.height-h-y );
qglTexCoord2f( 0, 0 );
qglVertex2f( x, glState.height-y );
qglTexCoord2f( texwidth, 0 );
qglVertex2f( x+w, glState.height-y );
qglTexCoord2f( texwidth, texheight );
qglVertex2f( x+w, glState.height-h );
qglEnd();
}
/*
* R_Bloom_SamplePass
*/
static inline void R_Bloom_SamplePass( int xpos, int ypos )
{
qglBegin( GL_QUADS );
qglTexCoord2f( 0, sampleText_tch );
qglVertex2f( xpos, ypos );
qglTexCoord2f( 0, 0 );
qglVertex2f( xpos, ypos+sample_height );
qglTexCoord2f( sampleText_tcw, 0 );
qglVertex2f( xpos+sample_width, ypos+sample_height );
qglTexCoord2f( sampleText_tcw, sampleText_tch );
qglVertex2f( xpos+sample_width, ypos );
qglEnd();
}
/*
===============
RB_ShowImages
Draw all the images to the screen, on top of whatever
was there. This is used to test for texture thrashing.
===============
*/
void RB_ShowImages( void ) {
int i;
idImage *image;
float x, y, w, h;
int start, end;
RB_SetGL2D();
//qglClearColor( 0.2, 0.2, 0.2, 1 );
//qglClear( GL_COLOR_BUFFER_BIT );
qglFinish();
start = Sys_Milliseconds();
for ( i = 0 ; i < globalImages->images.Num() ; i++ ) {
image = globalImages->images[i];
if ( image->texnum == idImage::TEXTURE_NOT_LOADED && image->partialImage == NULL ) {
continue;
}
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.GetInteger() == 2 ) {
w *= image->uploadWidth / 512.0f;
h *= image->uploadHeight / 512.0f;
}
image->Bind();
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();
}
qglFinish();
end = Sys_Milliseconds();
common->Printf( "%i msec to draw all images\n", end - start );
}
/*
===============
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 ) {
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();
int i=0;
R_Images_StartIteration();
while ( (image = R_Images_GetNextIteration()) != NULL)
{
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.0;
h *= image->uploadHeight / 512.0;
}
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();
i++;
}
qglFinish();
end = ri.Milliseconds();
ri.Printf( PRINT_ALL, "%i msec to draw all images\n", end - start );
}
void CPointMsg::Draw2D( VIEWTYPE vt ){
int nDim1 = ( vt == YZ ) ? 1 : 0;
int nDim2 = ( vt == XY ) ? 1 : 2;
qglPointSize( 4 );
qglColor3f( 1.0f,0.0f,0.0f );
qglBegin( GL_POINTS );
qglVertex2f( pt[nDim1], pt[nDim2] );
qglEnd();
qglBegin( GL_LINE_LOOP );
qglVertex2f( pt[nDim1] - 8, pt[nDim2] - 8 );
qglVertex2f( pt[nDim1] + 8, pt[nDim2] - 8 );
qglVertex2f( pt[nDim1] + 8, pt[nDim2] + 8 );
qglVertex2f( pt[nDim1] - 8, pt[nDim2] + 8 );
qglEnd();
}
void R_Splash()
{
#ifndef _XBOX
image_t *pImage;
/*
const char* s = Cvar_VariableString("se_language");
if (stricmp(s,"english"))
{
pImage = R_FindImageFile( "menu/splash_eur", qfalse, qfalse, qfalse, GL_CLAMP);
}
else
{
pImage = R_FindImageFile( "menu/splash", qfalse, qfalse, qfalse, GL_CLAMP);
}
*/
pImage = R_FindImageFile( "menu/splash", qfalse, qfalse, qfalse, GL_CLAMP);
extern void RB_SetGL2D (void);
RB_SetGL2D();
if (pImage )
{//invalid paths?
GL_Bind( pImage );
}
GL_State(GLS_SRCBLEND_ONE | GLS_DSTBLEND_ZERO);
const int width = 640;
const int height = 480;
const float x1 = 320 - width / 2;
const float x2 = 320 + width / 2;
const float y1 = 240 - height / 2;
const float y2 = 240 + height / 2;
qglBegin (GL_TRIANGLE_STRIP);
qglTexCoord2f( 0, 0 );
qglVertex2f(x1, y1);
qglTexCoord2f( 1 , 0 );
qglVertex2f(x2, y1);
qglTexCoord2f( 0, 1 );
qglVertex2f(x1, y2);
qglTexCoord2f( 1, 1 );
qglVertex2f(x2, y2);
qglEnd();
GLimp_EndFrame();
#endif
}
/*
================
Draw_FadeScreen
================
*/
void Draw_FadeScreen (void)
{
qglEnable (GL_BLEND);
qglDisable (GL_TEXTURE_2D);
qglColor4f (0, 0, 0, 0.8);
qglBegin (GL_QUADS);
qglVertex2f (0,0);
qglVertex2f (vid.width, 0);
qglVertex2f (vid.width, vid.height);
qglVertex2f (0, vid.height);
qglEnd ();
qglColor4f (1,1,1,1);
qglEnable (GL_TEXTURE_2D);
qglDisable (GL_BLEND);
}
/*
* R_Bloom_DrawEffect
*/
static void R_Bloom_DrawEffect( void )
{
GL_Bind( 0, r_bloomeffecttexture );
GL_TexEnv( GL_MODULATE );
GL_SetState( GLSTATE_NO_DEPTH_TEST|GLSTATE_SRCBLEND_ONE|GLSTATE_DSTBLEND_ONE );
qglColor4f( r_bloom_alpha->value, r_bloom_alpha->value, r_bloom_alpha->value, 1.0f );
qglBegin( GL_QUADS );
qglTexCoord2f( 0, sampleText_tch );
qglVertex2f( curView_x, curView_y );
qglTexCoord2f( 0, 0 );
qglVertex2f( curView_x, curView_y+curView_height );
qglTexCoord2f( sampleText_tcw, 0 );
qglVertex2f( curView_x+curView_width, curView_y+curView_height );
qglTexCoord2f( sampleText_tcw, sampleText_tch );
qglVertex2f( curView_x+curView_width, curView_y );
qglEnd();
}
/*
=============
RB_DrawRotatePic
=============
*/
const void *RB_RotatePic ( const void *data )
{
const rotatePicCommand_t *cmd;
image_t *image;
shader_t *shader;
cmd = (const rotatePicCommand_t *)data;
shader = cmd->shader;
image = &shader->stages[0].bundle[0].image[0];
if ( image ) {
if ( !backEnd.projection2D ) {
RB_SetGL2D();
}
qglColor4ubv( backEnd.color2D );
qglPushMatrix();
qglTranslatef(cmd->x+cmd->w,cmd->y,0);
qglRotatef(cmd->a, 0.0, 0.0, 1.0);
GL_Bind( image );
#ifdef _XBOX
qglBeginEXT (GL_QUADS, 4, 0, 0, 4, 0);
#else
qglBegin (GL_QUADS);
#endif
qglTexCoord2f( cmd->s1, cmd->t1);
qglVertex2f( -cmd->w, 0 );
qglTexCoord2f( cmd->s2, cmd->t1 );
qglVertex2f( 0, 0 );
qglTexCoord2f( cmd->s2, cmd->t2 );
qglVertex2f( 0, cmd->h );
qglTexCoord2f( cmd->s1, cmd->t2 );
qglVertex2f( -cmd->w, cmd->h );
qglEnd();
qglPopMatrix();
}
return (const void *)(cmd + 1);
}
/*
=================
R_Bloom_DrawEffect
=================
*/
void R_Bloom_DrawEffect( refdef_t *fd )
{
GL_Bind(r_bloomeffecttexture->texnum);
GL_Enable(GL_BLEND);
GL_BlendFunc(GL_ONE, GL_ONE);
qglColor4f(r_bloom_alpha->value + fd->bloomalpha /*bc mod*/, r_bloom_alpha->value + fd->bloomalpha /*bc mod*/, r_bloom_alpha->value + fd->bloomalpha /*bc mod*/, 1.0f);
GL_TexEnv(GL_MODULATE);
qglBegin(GL_QUADS);
qglTexCoord2f( 0, sampleText_tch );
qglVertex2f( curView_x, curView_y );
qglTexCoord2f( 0, 0 );
qglVertex2f( curView_x, curView_y + curView_height );
qglTexCoord2f( sampleText_tcw, 0 );
qglVertex2f( curView_x + curView_width, curView_y + curView_height );
qglTexCoord2f( sampleText_tcw, sampleText_tch );
qglVertex2f( curView_x + curView_width, curView_y );
qglEnd();
GL_Disable(GL_BLEND);
}
void GLRB_DrawImage( const image_t* image, const float* coords, const float* texcoords, const float* color )
{
GL_Bind( image );
if ( color )
qglColor3f( tr.identityLight, tr.identityLight, tr.identityLight );
else
qglColor3f( 1, 1, 1 );
qglBegin (GL_QUADS);
qglTexCoord2f ( texcoords[0], texcoords[1] );
qglVertex2f (coords[0], coords[1]);
qglTexCoord2f ( texcoords[2], texcoords[1] );
qglVertex2f (coords[2], coords[1]);
qglTexCoord2f ( texcoords[2], texcoords[3] );
qglVertex2f (coords[2], coords[3]);
qglTexCoord2f ( texcoords[0], texcoords[3] );
qglVertex2f (coords[0], coords[3]);
qglEnd ();
}
/*
================
rvGEWorkspace::RenderGrid
Renders the grid on top of the user interface
================
*/
void rvGEWorkspace::RenderGrid ( void )
{
float x;
float y;
float step;
idVec4& color = mApplication->GetOptions().GetGridColor ( );
// See if the grid is off before rendering it
if ( !mApplication->GetOptions().GetGridVisible ( ))
{
return;
}
qglEnable(GL_BLEND);
qglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
qglColor4f ( color[0], color[1], color[2], 0.5f );
qglBegin ( GL_LINES );
step = mApplication->GetOptions().GetGridWidth ( ) * g_ZoomScales[mZoom];
for ( x = mRect.x + mRect.w; x >= mRect.x ; x -= step )
{
qglVertex2f ( x, mRect.y );
qglVertex2f ( x, mRect.y + mRect.h );
}
step = mApplication->GetOptions().GetGridHeight ( ) * g_ZoomScales[mZoom];
for ( y = mRect.y + mRect.h; y >= mRect.y ; y -= step )
{
qglVertex2f ( mRect.x, y );
qglVertex2f ( mRect.x + mRect.w, y );
}
qglEnd ( );
qglDisable(GL_BLEND);
qglColor3f ( color[0], color[1], color[2] );
qglBegin ( GL_LINES );
step = mApplication->GetOptions().GetGridWidth ( ) * g_ZoomScales[mZoom];
for ( x = mRect.x + mRect.w; x >= mRect.x ; x -= step * 4 )
{
qglVertex2f ( x, mRect.y );
qglVertex2f ( x, mRect.y + mRect.h );
}
step = mApplication->GetOptions().GetGridHeight ( ) * g_ZoomScales[mZoom];
for ( y = mRect.y + mRect.h; y >= mRect.y ; y -= step * 4 )
{
qglVertex2f ( mRect.x, y );
qglVertex2f ( mRect.x + mRect.w, y );
}
qglEnd ( );
}
/*
=============
Draw_StretchPic
=============
*/
void Draw_StretchPic (int x, int y, int w, int h, char *pic)
{
image_t *gl;
GLint previousMagFilter;
gl = Draw_FindPic (pic);
if (!gl)
{
ri.Con_Printf (PRINT_ALL, "Can't find pic: %s\n", pic);
return;
}
if (scrap_dirty)
Scrap_Upload ();
if ( ( ( gl_config.renderer == GL_RENDERER_MCD ) || ( gl_config.renderer & GL_RENDERER_RENDITION ) ) && !gl->has_alpha)
qglDisable (GL_ALPHA_TEST);
GL_Bind (gl->texnum);
qglGetTexParameteriv( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, &previousMagFilter );
qglTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
qglBegin (GL_QUADS);
{
qglTexCoord2f (gl->sl, gl->tl);
qglVertex2f (x, y);
qglTexCoord2f (gl->sh, gl->tl);
qglVertex2f (x+w, y);
qglTexCoord2f (gl->sh, gl->th);
qglVertex2f (x+w, y+h);
qglTexCoord2f (gl->sl, gl->th);
qglVertex2f (x, y+h);
}
qglEnd ();
qglTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, previousMagFilter );
if ( ( ( gl_config.renderer == GL_RENDERER_MCD ) || ( gl_config.renderer & GL_RENDERER_RENDITION ) ) && !gl->has_alpha)
qglEnable (GL_ALPHA_TEST);
}
void idGLDrawable::draw(int x, int y, int w, int h) {
GL_State( GLS_DEFAULT );
qglViewport(x, y, w, h);
qglScissor(x, y, w, h);
qglMatrixMode(GL_PROJECTION);
qglClearColor( 0.1f, 0.1f, 0.1f, 0.0f );
qglClear(GL_COLOR_BUFFER_BIT);
qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
qglLineWidth(0.5);
qglColor3f(1, 1, 1);
globalImages->BindNull();
qglBegin(GL_LINE_LOOP);
qglColor3f(1, 0, 0);
qglVertex2f(x + 3, y + 3);
qglColor3f(0, 1, 0);
qglVertex2f(x + 3, h - 3);
qglColor3f(0, 0, 1);
qglVertex2f(w - 3, h - 3);
qglColor3f(1, 1, 1);
qglVertex2f(w - 3, y + 3);
qglEnd();
}
void CWindingMsg::Draw2D( VIEWTYPE vt ){
int i;
int nDim1 = ( vt == YZ ) ? 1 : 0;
int nDim2 = ( vt == XY ) ? 1 : 2;
qglColor3f( 1.0f,0.f,0.0f );
qglPointSize( 4 );
qglBegin( GL_POINTS );
for ( i = 0; i < numpoints; i++ )
qglVertex2f( wt[i][nDim1], wt[i][nDim2] );
qglEnd();
qglPointSize( 1 );
qglEnable( GL_BLEND );
qglPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
qglBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
qglColor4f( 0.133f,0.4f,1.0f,0.5f );
qglBegin( GL_POLYGON );
for ( i = 0; i < numpoints; i++ )
qglVertex2f( wt[i][nDim1], wt[i][nDim2] );
qglEnd();
qglDisable( GL_BLEND );
}
int gld_wipe_doMelt(int ticks, int *y_lookup)
{
int i;
int total_w, total_h;
float fU1, fU2, fV1, fV2;
total_w = gld_GetTexDimension(SCREENWIDTH);
total_h = gld_GetTexDimension(SCREENHEIGHT);
fU1 = 0.0f;
fV1 = (float)SCREENHEIGHT / (float)total_h;
fU2 = (float)SCREENWIDTH / (float)total_w;
fV2 = 0.0f;
gld_EnableTexture2D(GL_TEXTURE0_ARB, true);
qglBindTexture(GL_TEXTURE_2D, wipe_scr_end_tex);
qglColor3f(1.0f, 1.0f, 1.0f);
qglBegin(GL_TRIANGLE_STRIP);
{
qglTexCoord2f(fU1, fV1); qglVertex2f(0.0f, 0.0f);
qglTexCoord2f(fU1, fV2); qglVertex2f(0.0f, (float)SCREENHEIGHT);
qglTexCoord2f(fU2, fV1); qglVertex2f((float)SCREENWIDTH, 0.0f);
qglTexCoord2f(fU2, fV2); qglVertex2f((float)SCREENWIDTH, (float)SCREENHEIGHT);
}
qglEnd();
qglBindTexture(GL_TEXTURE_2D, wipe_scr_start_tex);
qglColor3f(1.0f, 1.0f, 1.0f);
qglBegin(GL_QUAD_STRIP);
for (i=0; i <= SCREENWIDTH; i++)
{
int yoffs = MAX(0, y_lookup[i]);
float tx = (float) i / total_w;
float sx = (float) i;
float sy = (float) yoffs;
qglTexCoord2f(tx, fV1); qglVertex2f(sx, sy);
qglTexCoord2f(tx, fV2); qglVertex2f(sx, sy + (float)SCREENHEIGHT);
}
qglEnd();
return 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_SyncRenderThread();
// we definately want to sync every frame for the cinematics
qglFinish();
start = end = 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;
qglTexImage2D( GL_TEXTURE_2D, 0, GL_RGB8, cols, rows, 0, GL_RGBA, GL_UNSIGNED_BYTE, data );
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 );
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );
} 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 );
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 ();
}
