//Draw all visible windows.
void WindowManager::draw()
{
GFXHudMode( true ); //Load identity matrices.
GFXColorf( GUI_OPAQUE_WHITE() );
GFXDisable( DEPTHTEST );
GFXEnable( DEPTHWRITE );
GFXDisable( LIGHTING );
GFXDisable( CULLFACE );
GFXClear( GFXTRUE );
GFXDisable( DEPTHWRITE );
GFXBlendMode( SRCALPHA, INVSRCALPHA );
GFXDisable( TEXTURE1 );
GFXEnable( TEXTURE0 );
//Just loop through all the windows, and remember if anything gets drawn.
//Since the first window in the list is drawn first, z-order is
//maintained. First entry is the bottom window, last is the top window.
//FIXME mbyron -- I think the event manager needs to get involved with window z-order.
//(Mouse events should go to windows in zorder, shouldn't they?)
for (size_t i = 0; i < m_windows.size(); i++)
{
if ( m_windows[i]->controller() )//it's a controller
m_windows[i]->controller()->draw();//that can draw
if ( i < m_windows.size() )
m_windows[i]->draw();
}
//Emulate EndGUIFrame.
static VSSprite MouseVSSprite( "mouse.spr", BILINEAR, GFXTRUE );
static Texture dummy( "white.bmp", 0, NEAREST, TEXTURE2D, TEXTURE_2D, GFXTRUE );
GFXDisable( CULLFACE );
ConditionalCursorDraw( true );
//Figure position of cursor sprite.
float sizex = 0.0, sizey = 0.0;
const Point loc = globalEventManager().mouseLoc();
MouseVSSprite.GetSize( sizex, sizey );
float tempx = 0.0, tempy = 0.0;
MouseVSSprite.GetPosition( tempx, tempy );
MouseVSSprite.SetPosition( tempx+loc.x+sizex/2, tempy+loc.y+sizey/2 );
dummy.MakeActive();
GFXBlendMode( SRCALPHA, INVSRCALPHA );
GFXColorf( GUI_OPAQUE_WHITE() );
//Draw the cursor sprite.
GFXEnable( TEXTURE0 );
GFXDisable( DEPTHTEST );
GFXDisable( TEXTURE1 );
MouseVSSprite.Draw();
GFXHudMode( false );
GFXEnable( CULLFACE );
MouseVSSprite.SetPosition( tempx, tempy );
}
void CoordinateSelect::Draw () {
if (CoordinateSelectChange) {
UpdateMouse();
}
GFXLoadIdentity (MODEL);
GFXPushBlendMode();
// VSFileSystem::Fprintf (stderr,"Location: %f %f %f", LocalPosition.i, LocalPosition.j, LocalPosition.k);
GFXBlendMode(ONE,ONE);
LocSelAni.SetPosition(LocalPosition);
LocSelAni.Draw();
GFXPopBlendMode();
}
static void TerrainMakeActive( const TerrainTexture &text )
{
if (text.tex.t) {
GFXEnable( TEXTURE0 );
text.tex.t->MakeActive();
} else {
GFXDisable( TEXTURE0 );
}
GFXBlendMode( text.blendSrc, text.blendDst );
if (text.reflect)
GFXEnable( TEXTURE1 );
else
GFXDisable( TEXTURE1 );
GFXSelectMaterial( text.material );
}
int TextPlane::Draw(const string & newText, int offset,bool startlower, bool force_highquality, bool automatte)
{
int retval=1;
bool drawbg = (bgcol.a!=0);
static unsigned int * display_lists=CreateLists ();
// some stuff to draw the text stuff
string::const_iterator text_it = newText.begin();
static bool use_bit = force_highquality||XMLSupport::parse_bool(vs_config->getVariable ("graphics","high_quality_font","false"));
static float font_point = XMLSupport::parse_float (vs_config->getVariable ("graphics","font_point","16"));
static bool font_antialias = XMLSupport::parse_bool (vs_config->getVariable ("graphics","font_antialias","true"));
void * fnt = getFont();
static float std_wid=glutStrokeWidth (GLUT_STROKE_ROMAN,'W');
myFontMetrics.i=font_point*std_wid/(119.05+33.33);
if (use_bit)
myFontMetrics.i=glutBitmapWidth(fnt,'W');
myFontMetrics.j=font_point;
myFontMetrics.i/=.5*g_game.x_resolution;
myFontMetrics.j/=.5*g_game.y_resolution;
float tmp,row, col;
float origcol,origrow;
GetPos (row,col);
GetPos(row,origcol);
float rowheight=use_bit?getFontHeight():myFontMetrics.j;
myFontMetrics.j=rowheight;
if (startlower) {
row -= rowheight;
}
GFXPushBlendMode();
glLineWidth (1);
if (!use_bit&&font_antialias) {
GFXBlendMode (SRCALPHA,INVSRCALPHA);
if(gl_options.smooth_lines)
{
glEnable(GL_LINE_SMOOTH);
}
}else {
GFXBlendMode (SRCALPHA,INVSRCALPHA);
if(gl_options.smooth_lines)
{
glDisable(GL_LINE_SMOOTH);
}
}
GFXColorf(this->col);
GFXDisable (DEPTHTEST);
GFXDisable (CULLFACE);
GFXDisable (LIGHTING);
GFXDisable (TEXTURE0);
GFXDisable (TEXTURE1);
glPushMatrix();
glLoadIdentity();
if (!automatte&&drawbg) {
GFXColorf(this->bgcol);
DrawSquare(col,this->myDims.i,row-rowheight*.25,row+rowheight);
}
GFXColorf(this->col);
int entercount=0;
for (;entercount<offset&&text_it!=newText.end();text_it++) {
if (*text_it=='\n')
entercount++;
}
glTranslatef(col,row,0);
// glRasterPos2f (g_game.x_resolution*(1-(col+1)/2),g_game.y_resolution*(row+1)/2);
glRasterPos2f (0,0);
float scalex=1;
float scaley=1;
int potentialincrease=0;
if (!use_bit) {
int numplayers=1;
if (_Universe) // _Universe can be NULL during bootstrap.
numplayers = (_Universe->numPlayers()>3?_Universe->numPlayers()/2:
_Universe->numPlayers());
scalex=numplayers*myFontMetrics.i/std_wid;
scaley=myFontMetrics.j/(119.05+33.33);
}
glScalef (scalex,scaley,1);
bool firstThroughLoop=true;
GFXColor currentCol (this->col);
while(text_it != newText.end() && (firstThroughLoop||row>myDims.j-rowheight*.25)) {
unsigned char myc = *text_it;
if (myc=='_') {
myc = ' ';
}
float shadowlen = 0;
if(myc=='\t') {
shadowlen=glutBitmapWidth(fnt,' ')*5./(.5*g_game.x_resolution);
} else {
if (use_bit) {
shadowlen = glutBitmapWidth (fnt,myc)/(float)(.5*g_game.x_resolution); // need to use myc -- could have transformed '_' to ' '
} else {
shadowlen = myFontMetrics.i*glutStrokeWidth(GLUT_STROKE_ROMAN,myc)/std_wid;
}
}
if (*text_it=='#') {
if (newText.end()-text_it>6) {
float r,g,b;
r = TwoCharToFloat (*(text_it+1),*(text_it+2));
g = TwoCharToFloat (*(text_it+3),*(text_it+4));
b = TwoCharToFloat (*(text_it+5),*(text_it+6));
if (r==0&&g==0&&b==0) {
currentCol = this->col;
}else {
currentCol = GFXColor(r, g, b, this->col.a);
}
GFXColorf(currentCol);
static bool setRasterPos= XMLSupport::parse_bool(vs_config->getVariable("graphics","set_raster_text_color","true"));
if (use_bit&&setRasterPos)
glRasterPos2f(col-origcol,0);
text_it = text_it+6;
} else {
break;
}
text_it++;
continue;
}else if(*text_it>=32) {//always true
if(automatte){
GFXColorf(this->bgcol);
DrawSquare(col-origcol,col-origcol+shadowlen/scalex,-rowheight*.25/scaley,rowheight*.75/scaley);
GFXColorf(currentCol);
}
//glutStrokeCharacter (GLUT_STROKE_ROMAN,*text_it);
retval+=potentialincrease;
potentialincrease=0;
int lists = display_lists[myc+(isInside()?128:0)];
if (lists) {
GFXCallList(lists);
}else{
if (use_bit){
glutBitmapCharacter (fnt,myc);
}
else{
glutStrokeCharacter (GLUT_STROKE_ROMAN,myc);
}
}
}
if(*text_it=='\t') {
if(automatte){
GFXColorf(this->bgcol);
DrawSquare(col-origcol,col-origcol+shadowlen*5/(.5*g_game.x_resolution),-rowheight*.25/scaley,rowheight*.75/scaley);
GFXColorf(currentCol);
}
col+=shadowlen;
glutBitmapCharacter (fnt,' ');
glutBitmapCharacter (fnt,' ');
glutBitmapCharacter (fnt,' ');
glutBitmapCharacter (fnt,' ');
glutBitmapCharacter (fnt,' ');
} else {
col+=shadowlen;
}
if(doNewLine(text_it,newText.end(),col,myDims.i, myFontMetrics.i,row-rowheight<=myDims.j)){
GetPos (tmp,col);
firstThroughLoop=false;
row -= rowheight;
glPopMatrix();
glPushMatrix ();
glLoadIdentity();
if (!automatte&&drawbg) {
GFXColorf(this->bgcol);
DrawSquare(col,this->myDims.i,row-rowheight*.25,row+rowheight*.75);
}
if (*text_it=='\n') {
currentCol = this->col;
}
GFXColorf(currentCol);
glTranslatef (col,row,0);
glScalef(scalex,scaley,1);
glRasterPos2f(0,0);
potentialincrease++;
}
text_it++;
}
if(gl_options.smooth_lines)
{
glDisable(GL_LINE_SMOOTH);
}
glPopMatrix();
GFXPopBlendMode();
GFXColorf(this->col);
return retval;
}
static void TerrainMakeClearActive( const TerrainTexture &text )
{
TerrainMakeActive( text );
GFXBlendMode( text.blendDst != ZERO ? text.blendSrc : SRCALPHA, INVSRCALPHA );
}
void GFXVertexList::Draw( enum POLYTYPE *mode, const INDEX index, const int numlists, const int *offsets )
{
//Hardware support for this seems... sketchy
if (vbo_data == 0 && display_list != 0) {
//Big issue: display lists cannot discriminate between lines/points/triangles,
//so, for now, we'll limit smoothing to single-mode GFXVertexLists, which, by the way,
//are the only ones being used, AFAIK.
bool blendchange = false;
if ( unique_mode && (numlists > 0) ) {
switch (*mode)
{
case GFXLINE:
case GFXLINESTRIP:
case GFXPOLY:
case GFXPOINT:
if ( ( (*mode == GFXPOINT)
&& gl_options.smooth_points ) || ( (*mode != GFXPOINT) && gl_options.smooth_lines ) ) {
BLENDFUNC src, dst;
GFXGetBlendMode( src, dst );
if ( (dst != ZERO) && ( (src == ONE) || (src == SRCALPHA) ) ) {
GFXPushBlendMode();
GFXBlendMode( SRCALPHA, dst );
GFXEnable( SMOOTH );
blendchange = true;
}
}
break;
default:
break;
}
}
GFXCallList( display_list );
if (blendchange) {
GFXPopBlendMode();
GFXDisable( SMOOTH );
}
++gl_batches_this_frame;
} else {
int totoffset = 0;
if (changed&HAS_INDEX) {
long stride = changed&HAS_INDEX;
GLenum indextype = (changed&INDEX_BYTE)
? GL_UNSIGNED_BYTE
: ( (changed&INDEX_SHORT)
? GL_UNSIGNED_SHORT
: GL_UNSIGNED_INT );
bool use_vbo = vbo_data != 0;
use_vbo = use_vbo && memcmp( &index, &this->index, sizeof (INDEX) ) == 0;
if (use_vbo) {
#ifndef NO_VBO_SUPPORT
GFXBindElementBuffer( display_list );
#else
use_vbo = false;
#endif
} else {
#ifndef NO_VBO_SUPPORT
if (vbo_data)
GFXBindElementBuffer( 0 );
#endif
}
if (glMultiDrawElements_p != NULL && numlists > 1) {
static std::vector< bool > drawn;
static std::vector< const GLvoid* >glindices;
static std::vector< GLsizei >glcounts;
drawn.clear();
drawn.resize( numlists, false );
for (int i = 0; i < numlists; totoffset += offsets[i++])
if (!drawn[i]) {
glindices.clear();
glcounts.clear();
int totcount = 0;
for (long j = i, offs = totoffset; j < numlists; offs += offsets[j++]) {
totcount += offsets[j];
if ( !drawn[j] && (mode[j] == mode[i]) ) {
glindices.push_back( use_vbo ? (GLvoid*) (stride*offs)
: (GLvoid*) &index.b[stride*offs] );
glcounts.push_back( offsets[j] );
drawn[j] = true;
}
}
if (glindices.size() == 1)
glDrawElements( PolyLookup( mode[i] ), glcounts[0], indextype, glindices[0] );
else
glMultiDrawElements_p( PolyLookup(
mode[i] ), &glcounts[0], indextype, &glindices[0], glindices.size() );
++gl_batches_this_frame;
gl_vertices_this_frame += totcount;
}
} else {
for (int i = 0; i < numlists; i++) {
glDrawElements( PolyLookup( mode[i] ), offsets[i], indextype,
use_vbo ? (GLvoid*) (stride*totoffset)
: (GLvoid*)&index.b[stride*totoffset] ); //changed&INDEX_BYTE == stride!
totoffset += offsets[i];
++gl_batches_this_frame;
gl_vertices_this_frame += offsets[i];
}
}
} else {
if (glMultiDrawArrays_p) {
static std::vector< bool > drawn;
static std::vector< GLint > gloffsets;
static std::vector< GLsizei >glcounts;
drawn.clear();
drawn.resize( numlists, false );
for (int i = 0; i < numlists; totoffset += offsets[i++])
if (!drawn[i]) {
gloffsets.clear();
glcounts.clear();
int totcount = 0;
for (int j = i, offs = totoffset; j < numlists; offs += offsets[j++]) {
totcount += offsets[j];
if ( !drawn[j] && (mode[j] == mode[i]) ) {
gloffsets.push_back( offs );
glcounts.push_back( offsets[j] );
drawn[j] = true;
}
}
bool blendchange = false;
switch (mode[i])
{
case GFXLINE:
case GFXLINESTRIP:
case GFXPOLY:
case GFXPOINT:
if ( ( (mode[i] == GFXPOINT)
&& gl_options.smooth_points ) || ( (mode[i] != GFXPOINT) && gl_options.smooth_lines ) ) {
BLENDFUNC src, dst;
GFXGetBlendMode( src, dst );
if ( (dst != ZERO) && ( (src == ONE) || (src == SRCALPHA) ) ) {
GFXPushBlendMode();
GFXBlendMode( SRCALPHA, dst );
GFXEnable( SMOOTH );
blendchange = true;
}
}
break;
default:
break;
}
if (gloffsets.size() == 1)
glDrawArrays( PolyLookup( mode[i] ), gloffsets[0], glcounts[0] );
else
glMultiDrawArrays_p( PolyLookup( mode[i] ), &gloffsets[0], &glcounts[0], gloffsets.size() );
if (blendchange) {
GFXPopBlendMode();
GFXDisable( SMOOTH );
}
++gl_batches_this_frame;
gl_vertices_this_frame += totcount;
}
} else {
for (int i = 0; i < numlists; i++) {
bool blendchange = false;
switch (mode[i])
{
case GFXLINE:
case GFXLINESTRIP:
case GFXPOLY:
case GFXPOINT:
if ( ( (mode[i] == GFXPOINT)
&& gl_options.smooth_points ) || ( (mode[i] != GFXPOINT) && gl_options.smooth_lines ) ) {
BLENDFUNC src, dst;
GFXGetBlendMode( src, dst );
if ( (dst != ZERO) && ( (src == ONE) || (src == SRCALPHA) ) ) {
GFXPushBlendMode();
GFXBlendMode( SRCALPHA, dst );
GFXEnable( SMOOTH );
blendchange = true;
}
}
break;
default:
break;
}
glDrawArrays( PolyLookup( mode[i] ), totoffset, offsets[i] );
totoffset += offsets[i];
if (blendchange) {
GFXPopBlendMode();
GFXDisable( SMOOTH );
}
++gl_batches_this_frame;
gl_vertices_this_frame += offsets[i];
}
}
}
}
}
void Stars::Draw() {
static bool stars_dont_move = XMLSupport::parse_bool (vs_config->getVariable("graphics","stars_dont_move","false"));
if (stars_dont_move)return;
const QVector cp (_Universe->AccessCamera()->GetPosition());
UpdatePosition(cp);
// GFXLightContextAmbient(GFXColor(0,0,0,1));
GFXColor (1,1,1,1);
GFXLoadIdentity(MODEL);
GFXDisable(DEPTHWRITE);
GFXDisable (TEXTURE0);
GFXDisable (TEXTURE1);
GFXEnable (DEPTHTEST);
static bool near_stars_alpha=XMLSupport::parse_bool(vs_config->getVariable("graphics","near_stars_alpha","false"));
static bool near_stars_alpha_blend=XMLSupport::parse_bool(vs_config->getVariable("graphics","near_stars_alpha_blend","false"));
static float AlphaTestingCutoff =XMLSupport::parse_float(vs_config->getVariable("graphics","stars_alpha_test_cutoff",".2"));
if (near_stars_alpha) {
GFXAlphaTest (GREATER,AlphaTestingCutoff);
if (!near_stars_alpha_blend) {
GFXBlendMode(ONE,ZERO);
} else {
GFXBlendMode(SRCALPHA,INVSRCALPHA);
}
GFXEnable(DEPTHWRITE);
} else {
if (blend) {
GFXBlendMode (ONE,ONE);
} else {
GFXBlendMode (ONE,ZERO);
}
}
int ligh;
GFXSelectMaterial (0);
if (fade) {
static float star_spread_attenuation = XMLSupport::parse_float(vs_config->getVariable("graphics","star_spread_attenuation",".2"));
GFXPushGlobalEffects();
GFXLight FadeLight (true, GFXColor (cp.i,cp.j,cp.k), GFXColor (0,0,0,1), GFXColor (0,0,0,1), GFXColor (1,1,1,1), GFXColor (.01,0,1/(star_spread_attenuation*star_spread_attenuation*spread*spread)));
GFXCreateLight (ligh,FadeLight,true);
GFXEnable (LIGHTING);
} else {
GFXDisable (LIGHTING);
}
_Universe->AccessCamera()->UpdateGFX(GFXFALSE,GFXFALSE,GFXFALSE);
int LC=0,LN=vlist->NumTextures();
for (LC=0; LC<LN; ++LC) {
bool stretch=vlist->BeginDrawState(_Universe->AccessCamera()->GetR().Scale(-spread).Cast(),_Universe->AccessCamera()->GetVelocity(),_Universe->AccessCamera()->GetAngularVelocity(),false,false,LC);
int i;
for (i=0; i<STARnumvlist; i++) {
if (i>=1)
GFXTranslateModel (pos[i]-pos[i-1]);
else
GFXTranslateModel (pos[i]);
vlist->Draw(stretch,LC);
}
GFXTranslateModel(-pos[i-1]);
vlist->EndDrawState(stretch,LC);
}
if (near_stars_alpha) {
GFXAlphaTest(ALWAYS,0);
} else {
GFXEnable(DEPTHWRITE);
}
GFXBlendMode(ONE,ZERO);
_Universe->AccessCamera()->UpdateGFX(GFXTRUE,GFXFALSE,GFXFALSE) ;
GFXEnable (TEXTURE0);
GFXEnable (TEXTURE1);
if (fade) {
GFXDeleteLight (ligh);
GFXPopGlobalEffects();
}
GFXLoadIdentity(MODEL);
}
void Box::ProcessDrawQueue( int )
{
if ( !draw_queue[0].size() ) return;
GFXBlendMode( SRCALPHA, INVSRCALPHA );
GFXColor( 0.0, .90, .3, .4 );
GFXDisable( LIGHTING );
GFXDisable( TEXTURE0 );
GFXDisable( TEXTURE1 );
GFXDisable( DEPTHWRITE );
GFXDisable( CULLFACE );
//GFXBlendMode(ONE, ONE);
while ( draw_queue[0].size() ) {
GFXLoadMatrixModel( draw_queue[0].back().mat );
draw_queue[0].pop_back();
GFXBegin( GFXQUAD );
GFXColor4f( 0.0, 1.0, 0.0, 0.2 );
GFXVertex3f( corner_max.i, corner_min.j, corner_max.k );
GFXVertex3f( corner_max.i, corner_max.j, corner_max.k );
GFXVertex3f( corner_min.i, corner_max.j, corner_max.k );
GFXVertex3f( corner_min.i, corner_min.j, corner_max.k );
GFXColor4f( 0.0, 1.0, 0.0, 0.2 );
GFXVertex3f( corner_min.i, corner_min.j, corner_min.k );
GFXVertex3f( corner_min.i, corner_max.j, corner_min.k );
GFXVertex3f( corner_max.i, corner_max.j, corner_min.k );
GFXVertex3f( corner_max.i, corner_min.j, corner_min.k );
GFXColor4f( 0.0, .70, 0.0, 0.2 );
GFXVertex3f( corner_max.i, corner_min.j, corner_max.k );
GFXVertex3f( corner_min.i, corner_min.j, corner_max.k );
GFXVertex3f( corner_min.i, corner_min.j, corner_min.k );
GFXVertex3f( corner_max.i, corner_min.j, corner_min.k );
GFXColor4f( 0.0, .70, 0.0, 0.2 );
GFXVertex3f( corner_max.i, corner_max.j, corner_min.k );
GFXVertex3f( corner_min.i, corner_max.j, corner_min.k );
GFXVertex3f( corner_min.i, corner_max.j, corner_max.k );
GFXVertex3f( corner_max.i, corner_max.j, corner_max.k );
GFXColor4f( 0.0, .90, .3, 0.2 );
GFXVertex3f( corner_max.i, corner_max.j, corner_max.k );
GFXVertex3f( corner_max.i, corner_min.j, corner_max.k );
GFXVertex3f( corner_max.i, corner_min.j, corner_min.k );
GFXVertex3f( corner_max.i, corner_max.j, corner_min.k );
GFXColor4f( 0.0, .90, .3, 0.2 );
GFXVertex3f( corner_min.i, corner_max.j, corner_min.k );
GFXVertex3f( corner_min.i, corner_min.j, corner_min.k );
GFXVertex3f( corner_min.i, corner_min.j, corner_max.k );
GFXVertex3f( corner_min.i, corner_max.j, corner_max.k );
GFXEnd();
/*
* vlist->Draw();
* if(quadstrips!=NULL) {
* for(int a=0; a<numQuadstrips; a++)
* quadstrips[a]->Draw()
* ;
* }
*/
}
GFXEnable( DEPTHWRITE );
}
// Draw specified lines of text.
void PaintText::drawLines(int start, int count) const {
// Make sure we hav a display list.
calcLayoutIfNeeded();
// Make sure we have something to do.
if(m_lines.empty()) {
return;
}
// Initialize the graphics state.
GFXToggleTexture(false,0);
if(gl_options.smooth_lines)
{
glEnable(GL_LINE_SMOOTH);
}
GFXPushBlendMode();
GFXBlendMode(SRCALPHA,INVSRCALPHA);
glPushMatrix();
// Keep track of line position.
float lineTop = m_rect.top();
// Figure ending line index.
const int end = guiMin(start + count, m_lines.size());
// Loop through the display list lines.
for(int i=start; i<end; i++) {
const TextLine& line = m_lines[i];
// Make sure we can paint this line in the vertical space we have left.
if(lineTop - line.height*LINE_HEIGHT_EPSILON < m_rect.origin.y) {
// Not enough space to draw this line.
break;
}
// Position at the start of the line.
glLoadIdentity();
glTranslatef(m_rect.origin.x+line.x, lineTop-line.baseLine, 0.0);
if (line.fragments.size()) {
GFXColorf(line.fragments[0].color);
}
if (!useStroke()){
glRasterPos2f(0,0);
}else
glScaled(m_horizontalScaling, m_verticalScaling, 1.0);
float rasterpos=0;
// Draw each fragment.
for(vector<TextFragment>::const_iterator frag=line.fragments.begin(); frag!=line.fragments.end(); frag++) {
if(frag->start == ELLIPSIS_FRAGMENT) {
// We have a special-case for the ellipsis at the end of a line.
drawChars(ELLIPSIS_STRING, 0, 2, frag->font, frag->color,rasterpos);
} else {
rasterpos=drawChars(m_text, frag->start, frag->end, frag->font, frag->color,rasterpos);
}
}
// Top of next line.
lineTop -= line.height;
}
glRasterPos2f(0,0);
// Undo graphics state
GFXPopBlendMode();
if(gl_options.smooth_lines)
{
glDisable(GL_LINE_SMOOTH);
}
glPopMatrix();
GFXToggleTexture(true,0);
}
